?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[MIPS] RTLX: Protect rtlx_{read,write} with mutex.
[linux-2.6/linux-mips/linux-dm7025.git] / drivers / scsi / ibmvscsi / ibmvstgt.c
blob4368ca0e8270b7a4b9b8d75596dcbb79d906c0c6
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 512
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\n", dir, slen);
252 goto out;
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 goto out;
269 }
270 }
271 };
272
273 rest -= mlen;
274 }
275 out:
276
277 return 0;
278 }
279
280 static int ibmvstgt_transfer_data(struct scsi_cmnd *sc,
281 void (*done)(struct scsi_cmnd *))
282 {
283 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
284 int err;
285
286 err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1);
287
288 done(sc);
289
290 return err;
291 }
292
293 static int ibmvstgt_cmd_done(struct scsi_cmnd *sc,
294 void (*done)(struct scsi_cmnd *))
295 {
296 unsigned long flags;
297 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
298 struct srp_target *target = iue->target;
299
300 dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
301
302 spin_lock_irqsave(&target->lock, flags);
303 list_del(&iue->ilist);
304 spin_unlock_irqrestore(&target->lock, flags);
305
306 if (sc->result != SAM_STAT_GOOD) {
307 eprintk("operation failed %p %d %x\n",
308 iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]);
309 send_rsp(iue, sc, HARDWARE_ERROR, 0x00);
310 } else
311 send_rsp(iue, sc, NO_SENSE, 0x00);
312
313 done(sc);
314 srp_iu_put(iue);
315 return 0;
316 }
317
318 int send_adapter_info(struct iu_entry *iue,
319 dma_addr_t remote_buffer, uint16_t length)
320 {
321 struct srp_target *target = iue->target;
322 struct vio_port *vport = target_to_port(target);
323 struct Scsi_Host *shost = target->shost;
324 dma_addr_t data_token;
325 struct mad_adapter_info_data *info;
326 int err;
327
328 info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token,
329 GFP_KERNEL);
330 if (!info) {
331 eprintk("bad dma_alloc_coherent %p\n", target);
332 return 1;
333 }
334
335 /* Get remote info */
336 err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer,
337 vport->liobn, data_token);
338 if (err == H_SUCCESS) {
339 dprintk("Client connect: %s (%d)\n",
340 info->partition_name, info->partition_number);
341 }
342
343 memset(info, 0, sizeof(*info));
344
345 strcpy(info->srp_version, "16.a");
346 strncpy(info->partition_name, partition_name,
347 sizeof(info->partition_name));
348 info->partition_number = partition_number;
349 info->mad_version = 1;
350 info->os_type = 2;
351 info->port_max_txu[0] = shost->hostt->max_sectors << 9;
352
353 /* Send our info to remote */
354 err = h_copy_rdma(sizeof(*info), vport->liobn, data_token,
355 vport->riobn, remote_buffer);
356
357 dma_free_coherent(target->dev, sizeof(*info), info, data_token);
358
359 if (err != H_SUCCESS) {
360 eprintk("Error sending adapter info %d\n", err);
361 return 1;
362 }
363
364 return 0;
365 }
366
367 static void process_login(struct iu_entry *iue)
368 {
369 union viosrp_iu *iu = vio_iu(iue);
370 struct srp_login_rsp *rsp = &iu->srp.login_rsp;
371 uint64_t tag = iu->srp.rsp.tag;
372
373 /* TODO handle case that requested size is wrong and
374 * buffer format is wrong
375 */
376 memset(iu, 0, sizeof(struct srp_login_rsp));
377 rsp->opcode = SRP_LOGIN_RSP;
378 rsp->req_lim_delta = INITIAL_SRP_LIMIT;
379 rsp->tag = tag;
380 rsp->max_it_iu_len = sizeof(union srp_iu);
381 rsp->max_ti_iu_len = sizeof(union srp_iu);
382 /* direct and indirect */
383 rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT;
384
385 send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT);
386 }
387
388 static inline void queue_cmd(struct iu_entry *iue)
389 {
390 struct srp_target *target = iue->target;
391 unsigned long flags;
392
393 spin_lock_irqsave(&target->lock, flags);
394 list_add_tail(&iue->ilist, &target->cmd_queue);
395 spin_unlock_irqrestore(&target->lock, flags);
396 }
397
398 static int process_tsk_mgmt(struct iu_entry *iue)
399 {
400 union viosrp_iu *iu = vio_iu(iue);
401 int fn;
402
403 dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func);
404
405 switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
406 case SRP_TSK_ABORT_TASK:
407 fn = ABORT_TASK;
408 break;
409 case SRP_TSK_ABORT_TASK_SET:
410 fn = ABORT_TASK_SET;
411 break;
412 case SRP_TSK_CLEAR_TASK_SET:
413 fn = CLEAR_TASK_SET;
414 break;
415 case SRP_TSK_LUN_RESET:
416 fn = LOGICAL_UNIT_RESET;
417 break;
418 case SRP_TSK_CLEAR_ACA:
419 fn = CLEAR_ACA;
420 break;
421 default:
422 fn = 0;
423 }
424 if (fn)
425 scsi_tgt_tsk_mgmt_request(iue->target->shost, fn,
426 iu->srp.tsk_mgmt.task_tag,
427 (struct scsi_lun *) &iu->srp.tsk_mgmt.lun,
428 iue);
429 else
430 send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20);
431
432 return !fn;
433 }
434
435 static int process_mad_iu(struct iu_entry *iue)
436 {
437 union viosrp_iu *iu = vio_iu(iue);
438 struct viosrp_adapter_info *info;
439 struct viosrp_host_config *conf;
440
441 switch (iu->mad.empty_iu.common.type) {
442 case VIOSRP_EMPTY_IU_TYPE:
443 eprintk("%s\n", "Unsupported EMPTY MAD IU");
444 break;
445 case VIOSRP_ERROR_LOG_TYPE:
446 eprintk("%s\n", "Unsupported ERROR LOG MAD IU");
447 iu->mad.error_log.common.status = 1;
448 send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT);
449 break;
450 case VIOSRP_ADAPTER_INFO_TYPE:
451 info = &iu->mad.adapter_info;
452 info->common.status = send_adapter_info(iue, info->buffer,
453 info->common.length);
454 send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT);
455 break;
456 case VIOSRP_HOST_CONFIG_TYPE:
457 conf = &iu->mad.host_config;
458 conf->common.status = 1;
459 send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT);
460 break;
461 default:
462 eprintk("Unknown type %u\n", iu->srp.rsp.opcode);
463 }
464
465 return 1;
466 }
467
468 static int process_srp_iu(struct iu_entry *iue)
469 {
470 union viosrp_iu *iu = vio_iu(iue);
471 int done = 1;
472 u8 opcode = iu->srp.rsp.opcode;
473
474 switch (opcode) {
475 case SRP_LOGIN_REQ:
476 process_login(iue);
477 break;
478 case SRP_TSK_MGMT:
479 done = process_tsk_mgmt(iue);
480 break;
481 case SRP_CMD:
482 queue_cmd(iue);
483 done = 0;
484 break;
485 case SRP_LOGIN_RSP:
486 case SRP_I_LOGOUT:
487 case SRP_T_LOGOUT:
488 case SRP_RSP:
489 case SRP_CRED_REQ:
490 case SRP_CRED_RSP:
491 case SRP_AER_REQ:
492 case SRP_AER_RSP:
493 eprintk("Unsupported type %u\n", opcode);
494 break;
495 default:
496 eprintk("Unknown type %u\n", opcode);
497 }
498
499 return done;
500 }
501
502 static void process_iu(struct viosrp_crq *crq, struct srp_target *target)
503 {
504 struct vio_port *vport = target_to_port(target);
505 struct iu_entry *iue;
506 long err, done;
507
508 iue = srp_iu_get(target);
509 if (!iue) {
510 eprintk("Error getting IU from pool, %p\n", target);
511 return;
512 }
513
514 iue->remote_token = crq->IU_data_ptr;
515
516 err = h_copy_rdma(crq->IU_length, vport->riobn,
517 iue->remote_token, vport->liobn, iue->sbuf->dma);
518
519 if (err != H_SUCCESS) {
520 eprintk("%ld transferring data error %p\n", err, iue);
521 done = 1;
522 goto out;
523 }
524
525 if (crq->format == VIOSRP_MAD_FORMAT)
526 done = process_mad_iu(iue);
527 else
528 done = process_srp_iu(iue);
529 out:
530 if (done)
531 srp_iu_put(iue);
532 }
533
534 static irqreturn_t ibmvstgt_interrupt(int irq, void *data)
535 {
536 struct srp_target *target = (struct srp_target *) data;
537 struct vio_port *vport = target_to_port(target);
538
539 vio_disable_interrupts(vport->dma_dev);
540 queue_work(vtgtd, &vport->crq_work);
541
542 return IRQ_HANDLED;
543 }
544
545 static int crq_queue_create(struct crq_queue *queue, struct srp_target *target)
546 {
547 int err;
548 struct vio_port *vport = target_to_port(target);
549
550 queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL);
551 if (!queue->msgs)
552 goto malloc_failed;
553 queue->size = PAGE_SIZE / sizeof(*queue->msgs);
554
555 queue->msg_token = dma_map_single(target->dev, queue->msgs,
556 queue->size * sizeof(*queue->msgs),
557 DMA_BIDIRECTIONAL);
558
559 if (dma_mapping_error(queue->msg_token))
560 goto map_failed;
561
562 err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
563 PAGE_SIZE);
564
565 /* If the adapter was left active for some reason (like kexec)
566 * try freeing and re-registering
567 */
568 if (err == H_RESOURCE) {
569 do {
570 err = h_free_crq(vport->dma_dev->unit_address);
571 } while (err == H_BUSY || H_IS_LONG_BUSY(err));
572
573 err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
574 PAGE_SIZE);
575 }
576
577 if (err != H_SUCCESS && err != 2) {
578 eprintk("Error 0x%x opening virtual adapter\n", err);
579 goto reg_crq_failed;
580 }
581
582 err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt,
583 IRQF_DISABLED, "ibmvstgt", target);
584 if (err)
585 goto req_irq_failed;
586
587 vio_enable_interrupts(vport->dma_dev);
588
589 h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0);
590
591 queue->cur = 0;
592 spin_lock_init(&queue->lock);
593
594 return 0;
595
596 req_irq_failed:
597 do {
598 err = h_free_crq(vport->dma_dev->unit_address);
599 } while (err == H_BUSY || H_IS_LONG_BUSY(err));
600
601 reg_crq_failed:
602 dma_unmap_single(target->dev, queue->msg_token,
603 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
604 map_failed:
605 free_page((unsigned long) queue->msgs);
606
607 malloc_failed:
608 return -ENOMEM;
609 }
610
611 static void crq_queue_destroy(struct srp_target *target)
612 {
613 struct vio_port *vport = target_to_port(target);
614 struct crq_queue *queue = &vport->crq_queue;
615 int err;
616
617 free_irq(vport->dma_dev->irq, target);
618 do {
619 err = h_free_crq(vport->dma_dev->unit_address);
620 } while (err == H_BUSY || H_IS_LONG_BUSY(err));
621
622 dma_unmap_single(target->dev, queue->msg_token,
623 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
624
625 free_page((unsigned long) queue->msgs);
626 }
627
628 static void process_crq(struct viosrp_crq *crq, struct srp_target *target)
629 {
630 struct vio_port *vport = target_to_port(target);
631 dprintk("%x %x\n", crq->valid, crq->format);
632
633 switch (crq->valid) {
634 case 0xC0:
635 /* initialization */
636 switch (crq->format) {
637 case 0x01:
638 h_send_crq(vport->dma_dev->unit_address,
639 0xC002000000000000, 0);
640 break;
641 case 0x02:
642 break;
643 default:
644 eprintk("Unknown format %u\n", crq->format);
645 }
646 break;
647 case 0xFF:
648 /* transport event */
649 break;
650 case 0x80:
651 /* real payload */
652 switch (crq->format) {
653 case VIOSRP_SRP_FORMAT:
654 case VIOSRP_MAD_FORMAT:
655 process_iu(crq, target);
656 break;
657 case VIOSRP_OS400_FORMAT:
658 case VIOSRP_AIX_FORMAT:
659 case VIOSRP_LINUX_FORMAT:
660 case VIOSRP_INLINE_FORMAT:
661 eprintk("Unsupported format %u\n", crq->format);
662 break;
663 default:
664 eprintk("Unknown format %u\n", crq->format);
665 }
666 break;
667 default:
668 eprintk("unknown message type 0x%02x!?\n", crq->valid);
669 }
670 }
671
672 static inline struct viosrp_crq *next_crq(struct crq_queue *queue)
673 {
674 struct viosrp_crq *crq;
675 unsigned long flags;
676
677 spin_lock_irqsave(&queue->lock, flags);
678 crq = &queue->msgs[queue->cur];
679 if (crq->valid & 0x80) {
680 if (++queue->cur == queue->size)
681 queue->cur = 0;
682 } else
683 crq = NULL;
684 spin_unlock_irqrestore(&queue->lock, flags);
685
686 return crq;
687 }
688
689 static void handle_crq(struct work_struct *work)
690 {
691 struct vio_port *vport = container_of(work, struct vio_port, crq_work);
692 struct srp_target *target = vport->target;
693 struct viosrp_crq *crq;
694 int done = 0;
695
696 while (!done) {
697 while ((crq = next_crq(&vport->crq_queue)) != NULL) {
698 process_crq(crq, target);
699 crq->valid = 0x00;
700 }
701
702 vio_enable_interrupts(vport->dma_dev);
703
704 crq = next_crq(&vport->crq_queue);
705 if (crq) {
706 vio_disable_interrupts(vport->dma_dev);
707 process_crq(crq, target);
708 crq->valid = 0x00;
709 } else
710 done = 1;
711 }
712
713 handle_cmd_queue(target);
714 }
715
716
717 static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc)
718 {
719 unsigned long flags;
720 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
721 struct srp_target *target = iue->target;
722
723 dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
724
725 spin_lock_irqsave(&target->lock, flags);
726 list_del(&iue->ilist);
727 spin_unlock_irqrestore(&target->lock, flags);
728
729 srp_iu_put(iue);
730
731 return 0;
732 }
733
734 static int ibmvstgt_tsk_mgmt_response(u64 mid, int result)
735 {
736 struct iu_entry *iue = (struct iu_entry *) ((void *) mid);
737 union viosrp_iu *iu = vio_iu(iue);
738 unsigned char status, asc;
739
740 eprintk("%p %d\n", iue, result);
741 status = NO_SENSE;
742 asc = 0;
743
744 switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
745 case SRP_TSK_ABORT_TASK:
746 asc = 0x14;
747 if (result)
748 status = ABORTED_COMMAND;
749 break;
750 default:
751 break;
752 }
753
754 send_rsp(iue, NULL, status, asc);
755 srp_iu_put(iue);
756
757 return 0;
758 }
759
760 static ssize_t system_id_show(struct class_device *cdev, char *buf)
761 {
762 return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
763 }
764
765 static ssize_t partition_number_show(struct class_device *cdev, char *buf)
766 {
767 return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
768 }
769
770 static ssize_t unit_address_show(struct class_device *cdev, char *buf)
771 {
772 struct Scsi_Host *shost = class_to_shost(cdev);
773 struct srp_target *target = host_to_srp_target(shost);
774 struct vio_port *vport = target_to_port(target);
775 return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address);
776 }
777
778 static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
779 static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
780 static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
781
782 static struct class_device_attribute *ibmvstgt_attrs[] = {
783 &class_device_attr_system_id,
784 &class_device_attr_partition_number,
785 &class_device_attr_unit_address,
786 NULL,
787 };
788
789 static struct scsi_host_template ibmvstgt_sht = {
790 .name = TGT_NAME,
791 .module = THIS_MODULE,
792 .can_queue = INITIAL_SRP_LIMIT,
793 .sg_tablesize = SG_ALL,
794 .use_clustering = DISABLE_CLUSTERING,
795 .max_sectors = DEFAULT_MAX_SECTORS,
796 .transfer_response = ibmvstgt_cmd_done,
797 .transfer_data = ibmvstgt_transfer_data,
798 .eh_abort_handler = ibmvstgt_eh_abort_handler,
799 .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response,
800 .shost_attrs = ibmvstgt_attrs,
801 .proc_name = TGT_NAME,
802 };
803
804 static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id)
805 {
806 struct Scsi_Host *shost;
807 struct srp_target *target;
808 struct vio_port *vport;
809 unsigned int *dma, dma_size;
810 int err = -ENOMEM;
811
812 vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL);
813 if (!vport)
814 return err;
815 shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target));
816 if (!shost)
817 goto free_vport;
818 err = scsi_tgt_alloc_queue(shost);
819 if (err)
820 goto put_host;
821
822 target = host_to_srp_target(shost);
823 target->shost = shost;
824 vport->dma_dev = dev;
825 target->ldata = vport;
826 vport->target = target;
827 err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT,
828 SRP_MAX_IU_LEN);
829 if (err)
830 goto put_host;
831
832 dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window",
833 &dma_size);
834 if (!dma || dma_size != 40) {
835 eprintk("Couldn't get window property %d\n", dma_size);
836 err = -EIO;
837 goto free_srp_target;
838 }
839 vport->liobn = dma[0];
840 vport->riobn = dma[5];
841
842 INIT_WORK(&vport->crq_work, handle_crq);
843
844 err = crq_queue_create(&vport->crq_queue, target);
845 if (err)
846 goto free_srp_target;
847
848 err = scsi_add_host(shost, target->dev);
849 if (err)
850 goto destroy_queue;
851 return 0;
852
853 destroy_queue:
854 crq_queue_destroy(target);
855 free_srp_target:
856 srp_target_free(target);
857 put_host:
858 scsi_host_put(shost);
859 free_vport:
860 kfree(vport);
861 return err;
862 }
863
864 static int ibmvstgt_remove(struct vio_dev *dev)
865 {
866 struct srp_target *target = (struct srp_target *) dev->dev.driver_data;
867 struct Scsi_Host *shost = target->shost;
868 struct vio_port *vport = target->ldata;
869
870 crq_queue_destroy(target);
871 scsi_remove_host(shost);
872 scsi_tgt_free_queue(shost);
873 srp_target_free(target);
874 kfree(vport);
875 scsi_host_put(shost);
876 return 0;
877 }
878
879 static struct vio_device_id ibmvstgt_device_table[] __devinitdata = {
880 {"v-scsi-host", "IBM,v-scsi-host"},
881 {"",""}
882 };
883
884 MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table);
885
886 static struct vio_driver ibmvstgt_driver = {
887 .id_table = ibmvstgt_device_table,
888 .probe = ibmvstgt_probe,
889 .remove = ibmvstgt_remove,
890 .driver = {
891 .name = "ibmvscsis",
892 .owner = THIS_MODULE,
893 }
894 };
895
896 static int get_system_info(void)
897 {
898 struct device_node *rootdn;
899 const char *id, *model, *name;
900 unsigned int *num;
901
902 rootdn = find_path_device("/");
903 if (!rootdn)
904 return -ENOENT;
905
906 model = get_property(rootdn, "model", NULL);
907 id = get_property(rootdn, "system-id", NULL);
908 if (model && id)
909 snprintf(system_id, sizeof(system_id), "%s-%s", model, id);
910
911 name = get_property(rootdn, "ibm,partition-name", NULL);
912 if (name)
913 strncpy(partition_name, name, sizeof(partition_name));
914
915 num = (unsigned int *) get_property(rootdn, "ibm,partition-no", NULL);
916 if (num)
917 partition_number = *num;
918
919 return 0;
920 }
921
922 static int ibmvstgt_init(void)
923 {
924 int err = -ENOMEM;
925
926 printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n");
927
928 vtgtd = create_workqueue("ibmvtgtd");
929 if (!vtgtd)
930 return err;
931
932 err = get_system_info();
933 if (err)
934 goto destroy_wq;
935
936 err = vio_register_driver(&ibmvstgt_driver);
937 if (err)
938 goto destroy_wq;
939
940 return 0;
941
942 destroy_wq:
943 destroy_workqueue(vtgtd);
944 return err;
945 }
946
947 static void ibmvstgt_exit(void)
948 {
949 printk("Unregister IBM virtual SCSI driver\n");
950
951 destroy_workqueue(vtgtd);
952 vio_unregister_driver(&ibmvstgt_driver);
953 }
954
955 MODULE_DESCRIPTION("IBM Virtual SCSI Target");
956 MODULE_AUTHOR("Santiago Leon");
957 MODULE_LICENSE("GPL");
958
959 module_init(ibmvstgt_init);
960 module_exit(ibmvstgt_exit);
A Kernel for the Dreambox dm7025.