Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/scsi/ibmvscsi/ibmvstgt.c

  1 /*
  2  * IBM eServer i/pSeries Virtual SCSI Target Driver
  3  * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp.
  4  *                         Santiago Leon (santil@us.ibm.com) IBM Corp.
  5  *                         Linda Xie (lxie@us.ibm.com) IBM Corp.
  6  *
  7  * Copyright (C) 2005-2006 FUJITA Tomonori <tomof@acm.org>
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2 of the License, or
 12  * (at your option) any later version.
 13  *
 14  * This program is distributed in the hope that it will be useful,
 15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17  * GNU General Public License for more details.
 18  *
 19  * You should have received a copy of the GNU General Public License
 20  * along with this program; if not, write to the Free Software
 21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 22  * USA
 23  */
 24 #include <linux/interrupt.h>
 25 #include <linux/module.h>
 26 #include <linux/slab.h>
 27 #include <scsi/scsi.h>
 28 #include <scsi/scsi_host.h>
 29 #include <scsi/scsi_transport_srp.h>
 30 #include <scsi/scsi_tgt.h>
 31 #include <scsi/libsrp.h>
 32 #include <asm/hvcall.h>
 33 #include <asm/iommu.h>
 34 #include <asm/prom.h>
 35 #include <asm/vio.h>
 36 
 37 #include "ibmvscsi.h"
 38 
 39 #define INITIAL_SRP_LIMIT       16
 40 #define DEFAULT_MAX_SECTORS     256
 41 
 42 #define TGT_NAME        "ibmvstgt"
 43 
 44 /*
 45  * Hypervisor calls.
 46  */
 47 #define h_copy_rdma(l, sa, sb, da, db) \
 48                         plpar_hcall_norets(H_COPY_RDMA, l, sa, sb, da, db)
 49 #define h_send_crq(ua, l, h) \
 50                         plpar_hcall_norets(H_SEND_CRQ, ua, l, h)
 51 #define h_reg_crq(ua, tok, sz)\
 52                         plpar_hcall_norets(H_REG_CRQ, ua, tok, sz);
 53 #define h_free_crq(ua) \
 54                         plpar_hcall_norets(H_FREE_CRQ, ua);
 55 
 56 /* tmp - will replace with SCSI logging stuff */
 57 #define eprintk(fmt, args...)                                   \
 58 do {                                                            \
 59         printk("%s(%d) " fmt, __func__, __LINE__, ##args);      \
 60 } while (0)
 61 /* #define dprintk eprintk */
 62 #define dprintk(fmt, args...)
 63 
 64 struct vio_port {
 65         struct vio_dev *dma_dev;
 66 
 67         struct crq_queue crq_queue;
 68         struct work_struct crq_work;
 69 
 70         unsigned long liobn;
 71         unsigned long riobn;
 72         struct srp_target *target;
 73 
 74         struct srp_rport *rport;
 75 };
 76 
 77 static struct workqueue_struct *vtgtd;
 78 static struct scsi_transport_template *ibmvstgt_transport_template;
 79 
 80 /*
 81  * These are fixed for the system and come from the Open Firmware device tree.
 82  * We just store them here to save getting them every time.
 83  */
 84 static char system_id[64] = "";
 85 static char partition_name[97] = "UNKNOWN";
 86 static unsigned int partition_number = -1;
 87 
 88 static struct vio_port *target_to_port(struct srp_target *target)
 89 {
 90         return (struct vio_port *) target->ldata;
 91 }
 92 
 93 static inline union viosrp_iu *vio_iu(struct iu_entry *iue)
 94 {
 95         return (union viosrp_iu *) (iue->sbuf->buf);
 96 }
 97 
 98 static int send_iu(struct iu_entry *iue, uint64_t length, uint8_t format)
 99 {
100         struct srp_target *target = iue->target;
101         struct vio_port *vport = target_to_port(target);
102         long rc, rc1;
103         union {
104                 struct viosrp_crq cooked;
105                 uint64_t raw[2];
106         } crq;
107 
108         /* First copy the SRP */
109         rc = h_copy_rdma(length, vport->liobn, iue->sbuf->dma,
110                          vport->riobn, iue->remote_token);
111 
112         if (rc)
113                 eprintk("Error %ld transferring data\n", rc);
114 
115         crq.cooked.valid = 0x80;
116         crq.cooked.format = format;
117         crq.cooked.reserved = 0x00;
118         crq.cooked.timeout = 0x00;
119         crq.cooked.IU_length = length;
120         crq.cooked.IU_data_ptr = vio_iu(iue)->srp.rsp.tag;
121 
122         if (rc == 0)
123                 crq.cooked.status = 0x99;       /* Just needs to be non-zero */
124         else
125                 crq.cooked.status = 0x00;
126 
127         rc1 = h_send_crq(vport->dma_dev->unit_address, crq.raw[0], crq.raw[1]);
128 
129         if (rc1) {
130                 eprintk("%ld sending response\n", rc1);
131                 return rc1;
132         }
133 
134         return rc;
135 }
136 
137 #define SRP_RSP_SENSE_DATA_LEN  18
138 
139 static int send_rsp(struct iu_entry *iue, struct scsi_cmnd *sc,
140                     unsigned char status, unsigned char asc)
141 {
142         union viosrp_iu *iu = vio_iu(iue);
143         uint64_t tag = iu->srp.rsp.tag;
144 
145         /* If the linked bit is on and status is good */
146         if (test_bit(V_LINKED, &iue->flags) && (status == NO_SENSE))
147                 status = 0x10;
148 
149         memset(iu, 0, sizeof(struct srp_rsp));
150         iu->srp.rsp.opcode = SRP_RSP;
151         iu->srp.rsp.req_lim_delta = 1;
152         iu->srp.rsp.tag = tag;
153 
154         if (test_bit(V_DIOVER, &iue->flags))
155                 iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER;
156 
157         iu->srp.rsp.data_in_res_cnt = 0;
158         iu->srp.rsp.data_out_res_cnt = 0;
159 
160         iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID;
161 
162         iu->srp.rsp.resp_data_len = 0;
163         iu->srp.rsp.status = status;
164         if (status) {
165                 uint8_t *sense = iu->srp.rsp.data;
166 
167                 if (sc) {
168                         iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
169                         iu->srp.rsp.sense_data_len = SCSI_SENSE_BUFFERSIZE;
170                         memcpy(sense, sc->sense_buffer, SCSI_SENSE_BUFFERSIZE);
171                 } else {
172                         iu->srp.rsp.status = SAM_STAT_CHECK_CONDITION;
173                         iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
174                         iu->srp.rsp.sense_data_len = SRP_RSP_SENSE_DATA_LEN;
175 
176                         /* Valid bit and 'current errors' */
177                         sense[0] = (0x1 << 7 | 0x70);
178                         /* Sense key */
179                         sense[2] = status;
180                         /* Additional sense length */
181                         sense[7] = 0xa; /* 10 bytes */
182                         /* Additional sense code */
183                         sense[12] = asc;
184                 }
185         }
186 
187         send_iu(iue, sizeof(iu->srp.rsp) + SRP_RSP_SENSE_DATA_LEN,
188                 VIOSRP_SRP_FORMAT);
189 
190         return 0;
191 }
192 
193 static void handle_cmd_queue(struct srp_target *target)
194 {
195         struct Scsi_Host *shost = target->shost;
196         struct srp_rport *rport = target_to_port(target)->rport;
197         struct iu_entry *iue;
198         struct srp_cmd *cmd;
199         unsigned long flags;
200         int err;
201 
202 retry:
203         spin_lock_irqsave(&target->lock, flags);
204 
205         list_for_each_entry(iue, &target->cmd_queue, ilist) {
206                 if (!test_and_set_bit(V_FLYING, &iue->flags)) {
207                         spin_unlock_irqrestore(&target->lock, flags);
208                         cmd = iue->sbuf->buf;
209                         err = srp_cmd_queue(shost, cmd, iue,
210                                             (unsigned long)rport, 0);
211                         if (err) {
212                                 eprintk("cannot queue cmd %p %d\n", cmd, err);
213                                 srp_iu_put(iue);
214                         }
215                         goto retry;
216                 }
217         }
218 
219         spin_unlock_irqrestore(&target->lock, flags);
220 }
221 
222 static int ibmvstgt_rdma(struct scsi_cmnd *sc, struct scatterlist *sg, int nsg,
223                          struct srp_direct_buf *md, int nmd,
224                          enum dma_data_direction dir, unsigned int rest)
225 {
226         struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
227         struct srp_target *target = iue->target;
228         struct vio_port *vport = target_to_port(target);
229         dma_addr_t token;
230         long err;
231         unsigned int done = 0;
232         int i, sidx, soff;
233 
234         sidx = soff = 0;
235         token = sg_dma_address(sg + sidx);
236 
237         for (i = 0; i < nmd && rest; i++) {
238                 unsigned int mdone, mlen;
239 
240                 mlen = min(rest, md[i].len);
241                 for (mdone = 0; mlen;) {
242                         int slen = min(sg_dma_len(sg + sidx) - soff, mlen);
243 
244                         if (dir == DMA_TO_DEVICE)
245                                 err = h_copy_rdma(slen,
246                                                   vport->riobn,
247                                                   md[i].va + mdone,
248                                                   vport->liobn,
249                                                   token + soff);
250                         else
251                                 err = h_copy_rdma(slen,
252                                                   vport->liobn,
253                                                   token + soff,
254                                                   vport->riobn,
255                                                   md[i].va + mdone);
256 
257                         if (err != H_SUCCESS) {
258                                 eprintk("rdma error %d %d %ld\n", dir, slen, err);
259                                 return -EIO;
260                         }
261 
262                         mlen -= slen;
263                         mdone += slen;
264                         soff += slen;
265                         done += slen;
266 
267                         if (soff == sg_dma_len(sg + sidx)) {
268                                 sidx++;
269                                 soff = 0;
270                                 token = sg_dma_address(sg + sidx);
271 
272                                 if (sidx > nsg) {
273                                         eprintk("out of sg %p %d %d\n",
274                                                 iue, sidx, nsg);
275                                         return -EIO;
276                                 }
277                         }
278                 };
279 
280                 rest -= mlen;
281         }
282         return 0;
283 }
284 
285 static int ibmvstgt_cmd_done(struct scsi_cmnd *sc,
286                              void (*done)(struct scsi_cmnd *))
287 {
288         unsigned long flags;
289         struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
290         struct srp_target *target = iue->target;
291         int err = 0;
292 
293         dprintk("%p %p %x %u\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0],
294                 scsi_sg_count(sc));
295 
296         if (scsi_sg_count(sc))
297                 err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1);
298 
299         spin_lock_irqsave(&target->lock, flags);
300         list_del(&iue->ilist);
301         spin_unlock_irqrestore(&target->lock, flags);
302 
303         if (err|| sc->result != SAM_STAT_GOOD) {
304                 eprintk("operation failed %p %d %x\n",
305                         iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]);
306                 send_rsp(iue, sc, HARDWARE_ERROR, 0x00);
307         } else
308                 send_rsp(iue, sc, NO_SENSE, 0x00);
309 
310         done(sc);
311         srp_iu_put(iue);
312         return 0;
313 }
314 
315 int send_adapter_info(struct iu_entry *iue,
316                       dma_addr_t remote_buffer, uint16_t length)
317 {
318         struct srp_target *target = iue->target;
319         struct vio_port *vport = target_to_port(target);
320         struct Scsi_Host *shost = target->shost;
321         dma_addr_t data_token;
322         struct mad_adapter_info_data *info;
323         int err;
324 
325         info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token,
326                                   GFP_KERNEL);
327         if (!info) {
328                 eprintk("bad dma_alloc_coherent %p\n", target);
329                 return 1;
330         }
331 
332         /* Get remote info */
333         err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer,
334                           vport->liobn, data_token);
335         if (err == H_SUCCESS) {
336                 dprintk("Client connect: %s (%d)\n",
337                         info->partition_name, info->partition_number);
338         }
339 
340         memset(info, 0, sizeof(*info));
341 
342         strcpy(info->srp_version, "16.a");
343         strncpy(info->partition_name, partition_name,
344                 sizeof(info->partition_name));
345         info->partition_number = partition_number;
346         info->mad_version = 1;
347         info->os_type = 2;
348         info->port_max_txu[0] = shost->hostt->max_sectors << 9;
349 
350         /* Send our info to remote */
351         err = h_copy_rdma(sizeof(*info), vport->liobn, data_token,
352                           vport->riobn, remote_buffer);
353 
354         dma_free_coherent(target->dev, sizeof(*info), info, data_token);
355 
356         if (err != H_SUCCESS) {
357                 eprintk("Error sending adapter info %d\n", err);
358                 return 1;
359         }
360 
361         return 0;
362 }
363 
364 static void process_login(struct iu_entry *iue)
365 {
366         union viosrp_iu *iu = vio_iu(iue);
367         struct srp_login_rsp *rsp = &iu->srp.login_rsp;
368         uint64_t tag = iu->srp.rsp.tag;
369         struct Scsi_Host *shost = iue->target->shost;
370         struct srp_target *target = host_to_srp_target(shost);
371         struct vio_port *vport = target_to_port(target);
372         struct srp_rport_identifiers ids;
373 
374         memset(&ids, 0, sizeof(ids));
375         sprintf(ids.port_id, "%x", vport->dma_dev->unit_address);
376         ids.roles = SRP_RPORT_ROLE_INITIATOR;
377         if (!vport->rport)
378                 vport->rport = srp_rport_add(shost, &ids);
379 
380         /* TODO handle case that requested size is wrong and
381          * buffer format is wrong
382          */
383         memset(iu, 0, sizeof(struct srp_login_rsp));
384         rsp->opcode = SRP_LOGIN_RSP;
385         rsp->req_lim_delta = INITIAL_SRP_LIMIT;
386         rsp->tag = tag;
387         rsp->max_it_iu_len = sizeof(union srp_iu);
388         rsp->max_ti_iu_len = sizeof(union srp_iu);
389         /* direct and indirect */
390         rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT;
391 
392         send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT);
393 }
394 
395 static inline void queue_cmd(struct iu_entry *iue)
396 {
397         struct srp_target *target = iue->target;
398         unsigned long flags;
399 
400         spin_lock_irqsave(&target->lock, flags);
401         list_add_tail(&iue->ilist, &target->cmd_queue);
402         spin_unlock_irqrestore(&target->lock, flags);
403 }
404 
405 static int process_tsk_mgmt(struct iu_entry *iue)
406 {
407         union viosrp_iu *iu = vio_iu(iue);
408         int fn;
409 
410         dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func);
411 
412         switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
413         case SRP_TSK_ABORT_TASK:
414                 fn = ABORT_TASK;
415                 break;
416         case SRP_TSK_ABORT_TASK_SET:
417                 fn = ABORT_TASK_SET;
418                 break;
419         case SRP_TSK_CLEAR_TASK_SET:
420                 fn = CLEAR_TASK_SET;
421                 break;
422         case SRP_TSK_LUN_RESET:
423                 fn = LOGICAL_UNIT_RESET;
424                 break;
425         case SRP_TSK_CLEAR_ACA:
426                 fn = CLEAR_ACA;
427                 break;
428         default:
429                 fn = 0;
430         }
431         if (fn)
432                 scsi_tgt_tsk_mgmt_request(iue->target->shost,
433                                           (unsigned long)iue->target->shost,
434                                           fn,
435                                           iu->srp.tsk_mgmt.task_tag,
436                                           (struct scsi_lun *) &iu->srp.tsk_mgmt.lun,
437                                           iue);
438         else
439                 send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20);
440 
441         return !fn;
442 }
443 
444 static int process_mad_iu(struct iu_entry *iue)
445 {
446         union viosrp_iu *iu = vio_iu(iue);
447         struct viosrp_adapter_info *info;
448         struct viosrp_host_config *conf;
449 
450         switch (iu->mad.empty_iu.common.type) {
451         case VIOSRP_EMPTY_IU_TYPE:
452                 eprintk("%s\n", "Unsupported EMPTY MAD IU");
453                 break;
454         case VIOSRP_ERROR_LOG_TYPE:
455                 eprintk("%s\n", "Unsupported ERROR LOG MAD IU");
456                 iu->mad.error_log.common.status = 1;
457                 send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT);
458                 break;
459         case VIOSRP_ADAPTER_INFO_TYPE:
460                 info = &iu->mad.adapter_info;
461                 info->common.status = send_adapter_info(iue, info->buffer,
462                                                         info->common.length);
463                 send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT);
464                 break;
465         case VIOSRP_HOST_CONFIG_TYPE:
466                 conf = &iu->mad.host_config;
467                 conf->common.status = 1;
468                 send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT);
469                 break;
470         default:
471                 eprintk("Unknown type %u\n", iu->srp.rsp.opcode);
472         }
473 
474         return 1;
475 }
476 
477 static int process_srp_iu(struct iu_entry *iue)
478 {
479         union viosrp_iu *iu = vio_iu(iue);
480         int done = 1;
481         u8 opcode = iu->srp.rsp.opcode;
482 
483         switch (opcode) {
484         case SRP_LOGIN_REQ:
485                 process_login(iue);
486                 break;
487         case SRP_TSK_MGMT:
488                 done = process_tsk_mgmt(iue);
489                 break;
490         case SRP_CMD:
491                 queue_cmd(iue);
492                 done = 0;
493                 break;
494         case SRP_LOGIN_RSP:
495         case SRP_I_LOGOUT:
496         case SRP_T_LOGOUT:
497         case SRP_RSP:
498         case SRP_CRED_REQ:
499         case SRP_CRED_RSP:
500         case SRP_AER_REQ:
501         case SRP_AER_RSP:
502                 eprintk("Unsupported type %u\n", opcode);
503                 break;
504         default:
505                 eprintk("Unknown type %u\n", opcode);
506         }
507 
508         return done;
509 }
510 
511 static void process_iu(struct viosrp_crq *crq, struct srp_target *target)
512 {
513         struct vio_port *vport = target_to_port(target);
514         struct iu_entry *iue;
515         long err;
516         int done = 1;
517 
518         iue = srp_iu_get(target);
519         if (!iue) {
520                 eprintk("Error getting IU from pool, %p\n", target);
521                 return;
522         }
523 
524         iue->remote_token = crq->IU_data_ptr;
525 
526         err = h_copy_rdma(crq->IU_length, vport->riobn,
527                           iue->remote_token, vport->liobn, iue->sbuf->dma);
528 
529         if (err != H_SUCCESS) {
530                 eprintk("%ld transferring data error %p\n", err, iue);
531                 goto out;
532         }
533 
534         if (crq->format == VIOSRP_MAD_FORMAT)
535                 done = process_mad_iu(iue);
536         else
537                 done = process_srp_iu(iue);
538 out:
539         if (done)
540                 srp_iu_put(iue);
541 }
542 
543 static irqreturn_t ibmvstgt_interrupt(int dummy, void *data)
544 {
545         struct srp_target *target = data;
546         struct vio_port *vport = target_to_port(target);
547 
548         vio_disable_interrupts(vport->dma_dev);
549         queue_work(vtgtd, &vport->crq_work);
550 
551         return IRQ_HANDLED;
552 }
553 
554 static int crq_queue_create(struct crq_queue *queue, struct srp_target *target)
555 {
556         int err;
557         struct vio_port *vport = target_to_port(target);
558 
559         queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL);
560         if (!queue->msgs)
561                 goto malloc_failed;
562         queue->size = PAGE_SIZE / sizeof(*queue->msgs);
563 
564         queue->msg_token = dma_map_single(target->dev, queue->msgs,
565                                           queue->size * sizeof(*queue->msgs),
566                                           DMA_BIDIRECTIONAL);
567 
568         if (dma_mapping_error(target->dev, queue->msg_token))
569                 goto map_failed;
570 
571         err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
572                         PAGE_SIZE);
573 
574         /* If the adapter was left active for some reason (like kexec)
575          * try freeing and re-registering
576          */
577         if (err == H_RESOURCE) {
578             do {
579                 err = h_free_crq(vport->dma_dev->unit_address);
580             } while (err == H_BUSY || H_IS_LONG_BUSY(err));
581 
582             err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
583                             PAGE_SIZE);
584         }
585 
586         if (err != H_SUCCESS && err != 2) {
587                 eprintk("Error 0x%x opening virtual adapter\n", err);
588                 goto reg_crq_failed;
589         }
590 
591         err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt,
592                           0, "ibmvstgt", target);
593         if (err)
594                 goto req_irq_failed;
595 
596         vio_enable_interrupts(vport->dma_dev);
597 
598         h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0);
599 
600         queue->cur = 0;
601         spin_lock_init(&queue->lock);
602 
603         return 0;
604 
605 req_irq_failed:
606         do {
607                 err = h_free_crq(vport->dma_dev->unit_address);
608         } while (err == H_BUSY || H_IS_LONG_BUSY(err));
609 
610 reg_crq_failed:
611         dma_unmap_single(target->dev, queue->msg_token,
612                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
613 map_failed:
614         free_page((unsigned long) queue->msgs);
615 
616 malloc_failed:
617         return -ENOMEM;
618 }
619 
620 static void crq_queue_destroy(struct srp_target *target)
621 {
622         struct vio_port *vport = target_to_port(target);
623         struct crq_queue *queue = &vport->crq_queue;
624         int err;
625 
626         free_irq(vport->dma_dev->irq, target);
627         do {
628                 err = h_free_crq(vport->dma_dev->unit_address);
629         } while (err == H_BUSY || H_IS_LONG_BUSY(err));
630 
631         dma_unmap_single(target->dev, queue->msg_token,
632                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
633 
634         free_page((unsigned long) queue->msgs);
635 }
636 
637 static void process_crq(struct viosrp_crq *crq, struct srp_target *target)
638 {
639         struct vio_port *vport = target_to_port(target);
640         dprintk("%x %x\n", crq->valid, crq->format);
641 
642         switch (crq->valid) {
643         case 0xC0:
644                 /* initialization */
645                 switch (crq->format) {
646                 case 0x01:
647                         h_send_crq(vport->dma_dev->unit_address,
648                                    0xC002000000000000, 0);
649                         break;
650                 case 0x02:
651                         break;
652                 default:
653                         eprintk("Unknown format %u\n", crq->format);
654                 }
655                 break;
656         case 0xFF:
657                 /* transport event */
658                 break;
659         case 0x80:
660                 /* real payload */
661                 switch (crq->format) {
662                 case VIOSRP_SRP_FORMAT:
663                 case VIOSRP_MAD_FORMAT:
664                         process_iu(crq, target);
665                         break;
666                 case VIOSRP_OS400_FORMAT:
667                 case VIOSRP_AIX_FORMAT:
668                 case VIOSRP_LINUX_FORMAT:
669                 case VIOSRP_INLINE_FORMAT:
670                         eprintk("Unsupported format %u\n", crq->format);
671                         break;
672                 default:
673                         eprintk("Unknown format %u\n", crq->format);
674                 }
675                 break;
676         default:
677                 eprintk("unknown message type 0x%02x!?\n", crq->valid);
678         }
679 }
680 
681 static inline struct viosrp_crq *next_crq(struct crq_queue *queue)
682 {
683         struct viosrp_crq *crq;
684         unsigned long flags;
685 
686         spin_lock_irqsave(&queue->lock, flags);
687         crq = &queue->msgs[queue->cur];
688         if (crq->valid & 0x80) {
689                 if (++queue->cur == queue->size)
690                         queue->cur = 0;
691         } else
692                 crq = NULL;
693         spin_unlock_irqrestore(&queue->lock, flags);
694 
695         return crq;
696 }
697 
698 static void handle_crq(struct work_struct *work)
699 {
700         struct vio_port *vport = container_of(work, struct vio_port, crq_work);
701         struct srp_target *target = vport->target;
702         struct viosrp_crq *crq;
703         int done = 0;
704 
705         while (!done) {
706                 while ((crq = next_crq(&vport->crq_queue)) != NULL) {
707                         process_crq(crq, target);
708                         crq->valid = 0x00;
709                 }
710 
711                 vio_enable_interrupts(vport->dma_dev);
712 
713                 crq = next_crq(&vport->crq_queue);
714                 if (crq) {
715                         vio_disable_interrupts(vport->dma_dev);
716                         process_crq(crq, target);
717                         crq->valid = 0x00;
718                 } else
719                         done = 1;
720         }
721 
722         handle_cmd_queue(target);
723 }
724 
725 
726 static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc)
727 {
728         unsigned long flags;
729         struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
730         struct srp_target *target = iue->target;
731 
732         dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
733 
734         spin_lock_irqsave(&target->lock, flags);
735         list_del(&iue->ilist);
736         spin_unlock_irqrestore(&target->lock, flags);
737 
738         srp_iu_put(iue);
739 
740         return 0;
741 }
742 
743 static int ibmvstgt_tsk_mgmt_response(struct Scsi_Host *shost,
744                                       u64 itn_id, u64 mid, int result)
745 {
746         struct iu_entry *iue = (struct iu_entry *) ((void *) mid);
747         union viosrp_iu *iu = vio_iu(iue);
748         unsigned char status, asc;
749 
750         eprintk("%p %d\n", iue, result);
751         status = NO_SENSE;
752         asc = 0;
753 
754         switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
755         case SRP_TSK_ABORT_TASK:
756                 asc = 0x14;
757                 if (result)
758                         status = ABORTED_COMMAND;
759                 break;
760         default:
761                 break;
762         }
763 
764         send_rsp(iue, NULL, status, asc);
765         srp_iu_put(iue);
766 
767         return 0;
768 }
769 
770 static int ibmvstgt_it_nexus_response(struct Scsi_Host *shost, u64 itn_id,
771                                       int result)
772 {
773         struct srp_target *target = host_to_srp_target(shost);
774         struct vio_port *vport = target_to_port(target);
775 
776         if (result) {
777                 eprintk("%p %d\n", shost, result);
778                 srp_rport_del(vport->rport);
779                 vport->rport = NULL;
780         }
781         return 0;
782 }
783 
784 static ssize_t system_id_show(struct device *dev,
785                               struct device_attribute *attr, char *buf)
786 {
787         return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
788 }
789 
790 static ssize_t partition_number_show(struct device *dev,
791                                      struct device_attribute *attr, char *buf)
792 {
793         return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
794 }
795 
796 static ssize_t unit_address_show(struct device *dev,
797                                   struct device_attribute *attr, char *buf)
798 {
799         struct Scsi_Host *shost = class_to_shost(dev);
800         struct srp_target *target = host_to_srp_target(shost);
801         struct vio_port *vport = target_to_port(target);
802         return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address);
803 }
804 
805 static DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
806 static DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
807 static DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
808 
809 static struct device_attribute *ibmvstgt_attrs[] = {
810         &dev_attr_system_id,
811         &dev_attr_partition_number,
812         &dev_attr_unit_address,
813         NULL,
814 };
815 
816 static struct scsi_host_template ibmvstgt_sht = {
817         .name                   = TGT_NAME,
818         .module                 = THIS_MODULE,
819         .can_queue              = INITIAL_SRP_LIMIT,
820         .sg_tablesize           = SG_ALL,
821         .use_clustering         = DISABLE_CLUSTERING,
822         .max_sectors            = DEFAULT_MAX_SECTORS,
823         .transfer_response      = ibmvstgt_cmd_done,
824         .eh_abort_handler       = ibmvstgt_eh_abort_handler,
825         .shost_attrs            = ibmvstgt_attrs,
826         .proc_name              = TGT_NAME,
827         .supported_mode         = MODE_TARGET,
828 };
829 
830 static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id)
831 {
832         struct Scsi_Host *shost;
833         struct srp_target *target;
834         struct vio_port *vport;
835         unsigned int *dma, dma_size;
836         int err = -ENOMEM;
837 
838         vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL);
839         if (!vport)
840                 return err;
841         shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target));
842         if (!shost)
843                 goto free_vport;
844         shost->transportt = ibmvstgt_transport_template;
845 
846         target = host_to_srp_target(shost);
847         target->shost = shost;
848         vport->dma_dev = dev;
849         target->ldata = vport;
850         vport->target = target;
851         err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT,
852                                SRP_MAX_IU_LEN);
853         if (err)
854                 goto put_host;
855 
856         dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window",
857                                                  &dma_size);
858         if (!dma || dma_size != 40) {
859                 eprintk("Couldn't get window property %d\n", dma_size);
860                 err = -EIO;
861                 goto free_srp_target;
862         }
863         vport->liobn = dma[0];
864         vport->riobn = dma[5];
865 
866         INIT_WORK(&vport->crq_work, handle_crq);
867 
868         err = scsi_add_host(shost, target->dev);
869         if (err)
870                 goto free_srp_target;
871 
872         err = scsi_tgt_alloc_queue(shost);
873         if (err)
874                 goto remove_host;
875 
876         err = crq_queue_create(&vport->crq_queue, target);
877         if (err)
878                 goto free_queue;
879 
880         return 0;
881 free_queue:
882         scsi_tgt_free_queue(shost);
883 remove_host:
884         scsi_remove_host(shost);
885 free_srp_target:
886         srp_target_free(target);
887 put_host:
888         scsi_host_put(shost);
889 free_vport:
890         kfree(vport);
891         return err;
892 }
893 
894 static int ibmvstgt_remove(struct vio_dev *dev)
895 {
896         struct srp_target *target = dev_get_drvdata(&dev->dev);
897         struct Scsi_Host *shost = target->shost;
898         struct vio_port *vport = target->ldata;
899 
900         crq_queue_destroy(target);
901         srp_remove_host(shost);
902         scsi_remove_host(shost);
903         scsi_tgt_free_queue(shost);
904         srp_target_free(target);
905         kfree(vport);
906         scsi_host_put(shost);
907         return 0;
908 }
909 
910 static struct vio_device_id ibmvstgt_device_table[] = {
911         {"v-scsi-host", "IBM,v-scsi-host"},
912         {"",""}
913 };
914 
915 MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table);
916 
917 static struct vio_driver ibmvstgt_driver = {
918         .id_table = ibmvstgt_device_table,
919         .probe = ibmvstgt_probe,
920         .remove = ibmvstgt_remove,
921         .name = "ibmvscsis",
922 };
923 
924 static int get_system_info(void)
925 {
926         struct device_node *rootdn;
927         const char *id, *model, *name;
928         const unsigned int *num;
929 
930         rootdn = of_find_node_by_path("/");
931         if (!rootdn)
932                 return -ENOENT;
933 
934         model = of_get_property(rootdn, "model", NULL);
935         id = of_get_property(rootdn, "system-id", NULL);
936         if (model && id)
937                 snprintf(system_id, sizeof(system_id), "%s-%s", model, id);
938 
939         name = of_get_property(rootdn, "ibm,partition-name", NULL);
940         if (name)
941                 strncpy(partition_name, name, sizeof(partition_name));
942 
943         num = of_get_property(rootdn, "ibm,partition-no", NULL);
944         if (num)
945                 partition_number = *num;
946 
947         of_node_put(rootdn);
948         return 0;
949 }
950 
951 static struct srp_function_template ibmvstgt_transport_functions = {
952         .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response,
953         .it_nexus_response = ibmvstgt_it_nexus_response,
954 };
955 
956 static int __init ibmvstgt_init(void)
957 {
958         int err = -ENOMEM;
959 
960         printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n");
961 
962         ibmvstgt_transport_template =
963                 srp_attach_transport(&ibmvstgt_transport_functions);
964         if (!ibmvstgt_transport_template)
965                 return err;
966 
967         vtgtd = create_workqueue("ibmvtgtd");
968         if (!vtgtd)
969                 goto release_transport;
970 
971         err = get_system_info();
972         if (err)
973                 goto destroy_wq;
974 
975         err = vio_register_driver(&ibmvstgt_driver);
976         if (err)
977                 goto destroy_wq;
978 
979         return 0;
980 destroy_wq:
981         destroy_workqueue(vtgtd);
982 release_transport:
983         srp_release_transport(ibmvstgt_transport_template);
984         return err;
985 }
986 
987 static void __exit ibmvstgt_exit(void)
988 {
989         printk("Unregister IBM virtual SCSI driver\n");
990 
991         destroy_workqueue(vtgtd);
992         vio_unregister_driver(&ibmvstgt_driver);
993         srp_release_transport(ibmvstgt_transport_template);
994 }
995 
996 MODULE_DESCRIPTION("IBM Virtual SCSI Target");
997 MODULE_AUTHOR("Santiago Leon");
998 MODULE_LICENSE("GPL");
999 
1000 module_init(ibmvstgt_init);
1001 module_exit(ibmvstgt_exit);
1002 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us