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