2 * Disk Array driver for HP Smart Array controllers, SCSI Tape module.
3 * (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
21 * Author: Stephen M. Cameron
23 #ifdef CONFIG_CISS_SCSI_TAPE
25 /* Here we have code to present the driver as a scsi driver
26 as it is simultaneously presented as a block driver. The
27 reason for doing this is to allow access to SCSI tape drives
28 through the array controller. Note in particular, neither
29 physical nor logical disks are presented through the scsi layer. */
31 #include <linux/timer.h>
32 #include <linux/completion.h>
33 #include <linux/slab.h>
34 #include <linux/string.h>
36 #include <linux/atomic.h>
38 #include <scsi/scsi_cmnd.h>
39 #include <scsi/scsi_device.h>
40 #include <scsi/scsi_host.h>
42 #include "cciss_scsi.h"
44 #define CCISS_ABORT_MSG 0x00
45 #define CCISS_RESET_MSG 0x01
47 static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
49 __u8 page_code, unsigned char *scsi3addr,
52 static CommandList_struct *cmd_alloc(ctlr_info_t *h);
53 static CommandList_struct *cmd_special_alloc(ctlr_info_t *h);
54 static void cmd_free(ctlr_info_t *h, CommandList_struct *c);
55 static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c);
57 static int cciss_scsi_proc_info(
59 char *buffer, /* data buffer */
60 char **start, /* where data in buffer starts */
61 off_t offset, /* offset from start of imaginary file */
62 int length, /* length of data in buffer */
63 int func); /* 0 == read, 1 == write */
65 static int cciss_scsi_queue_command (struct Scsi_Host *h,
66 struct scsi_cmnd *cmd);
67 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
68 static int cciss_eh_abort_handler(struct scsi_cmnd *);
70 static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
71 { .name = "cciss0", .ndevices = 0 },
72 { .name = "cciss1", .ndevices = 0 },
73 { .name = "cciss2", .ndevices = 0 },
74 { .name = "cciss3", .ndevices = 0 },
75 { .name = "cciss4", .ndevices = 0 },
76 { .name = "cciss5", .ndevices = 0 },
77 { .name = "cciss6", .ndevices = 0 },
78 { .name = "cciss7", .ndevices = 0 },
81 static struct scsi_host_template cciss_driver_template = {
82 .module = THIS_MODULE,
85 .proc_info = cciss_scsi_proc_info,
86 .queuecommand = cciss_scsi_queue_command,
89 .use_clustering = DISABLE_CLUSTERING,
90 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
91 .eh_device_reset_handler= cciss_eh_device_reset_handler,
92 .eh_abort_handler = cciss_eh_abort_handler,
100 struct cciss_scsi_cmd_stack_elem_t {
101 CommandList_struct cmd;
102 ErrorInfo_struct Err;
105 u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
111 struct cciss_scsi_cmd_stack_t {
112 struct cciss_scsi_cmd_stack_elem_t *pool;
113 struct cciss_scsi_cmd_stack_elem_t **elem;
114 dma_addr_t cmd_pool_handle;
120 struct cciss_scsi_adapter_data_t {
121 struct Scsi_Host *scsi_host;
122 struct cciss_scsi_cmd_stack_t cmd_stack;
123 SGDescriptor_struct **cmd_sg_list;
125 spinlock_t lock; // to protect ccissscsi[ctlr];
128 #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
129 &h->scsi_ctlr->lock, flags);
130 #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
131 &h->scsi_ctlr->lock, flags);
133 static CommandList_struct *
134 scsi_cmd_alloc(ctlr_info_t *h)
136 /* assume only one process in here at a time, locking done by caller. */
138 /* might be better to rewrite how we allocate scsi commands in a way that */
139 /* needs no locking at all. */
141 /* take the top memory chunk off the stack and return it, if any. */
142 struct cciss_scsi_cmd_stack_elem_t *c;
143 struct cciss_scsi_adapter_data_t *sa;
144 struct cciss_scsi_cmd_stack_t *stk;
148 stk = &sa->cmd_stack;
152 c = stk->elem[stk->top];
153 /* memset(c, 0, sizeof(*c)); */
154 memset(&c->cmd, 0, sizeof(c->cmd));
155 memset(&c->Err, 0, sizeof(c->Err));
156 /* set physical addr of cmd and addr of scsi parameters */
157 c->cmd.busaddr = c->busaddr;
158 c->cmd.cmdindex = c->cmdindex;
159 /* (__u32) (stk->cmd_pool_handle +
160 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
162 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
163 /* (__u64) (stk->cmd_pool_handle +
164 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
165 sizeof(CommandList_struct)); */
167 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
168 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
169 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
171 c->cmd.ctlr = h->ctlr;
172 c->cmd.err_info = &c->Err;
174 return (CommandList_struct *) c;
178 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
180 /* assume only one process in here at a time, locking done by caller. */
182 /* drop the free memory chunk on top of the stack. */
184 struct cciss_scsi_adapter_data_t *sa;
185 struct cciss_scsi_cmd_stack_t *stk;
188 stk = &sa->cmd_stack;
190 if (stk->top >= stk->nelems) {
191 dev_err(&h->pdev->dev,
192 "scsi_cmd_free called too many times.\n");
195 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
199 scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
202 struct cciss_scsi_cmd_stack_t *stk;
205 stk = &sa->cmd_stack;
206 stk->nelems = cciss_tape_cmds + 2;
207 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
208 h->chainsize, stk->nelems);
209 if (!sa->cmd_sg_list && h->chainsize > 0)
212 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
214 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
215 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
216 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
217 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
218 pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
220 if (stk->pool == NULL) {
221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
222 sa->cmd_sg_list = NULL;
225 stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL);
227 pci_free_consistent(h->pdev, size, stk->pool,
228 stk->cmd_pool_handle);
231 for (i = 0; i < stk->nelems; i++) {
232 stk->elem[i] = &stk->pool[i];
233 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
234 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
235 stk->elem[i]->cmdindex = i;
237 stk->top = stk->nelems-1;
242 scsi_cmd_stack_free(ctlr_info_t *h)
244 struct cciss_scsi_adapter_data_t *sa;
245 struct cciss_scsi_cmd_stack_t *stk;
249 stk = &sa->cmd_stack;
250 if (stk->top != stk->nelems-1) {
251 dev_warn(&h->pdev->dev,
252 "bug: %d scsi commands are still outstanding.\n",
253 stk->nelems - stk->top);
255 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
257 pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
259 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
265 static int xmargin=8;
266 static int amargin=60;
269 print_bytes (unsigned char *c, int len, int hex, int ascii)
280 if ((i % xmargin) == 0 && i>0) printk("\n");
281 if ((i % xmargin) == 0) printk("0x%04x:", i);
292 if ((i % amargin) == 0 && i>0) printk("\n");
293 if ((i % amargin) == 0) printk("0x%04x:", i);
294 if (*x > 26 && *x < 128) printk("%c", *x);
303 print_cmd(CommandList_struct *cp)
305 printk("queue:%d\n", cp->Header.ReplyQueue);
306 printk("sglist:%d\n", cp->Header.SGList);
307 printk("sgtot:%d\n", cp->Header.SGTotal);
308 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
309 cp->Header.Tag.lower);
310 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
311 cp->Header.LUN.LunAddrBytes[0],
312 cp->Header.LUN.LunAddrBytes[1],
313 cp->Header.LUN.LunAddrBytes[2],
314 cp->Header.LUN.LunAddrBytes[3],
315 cp->Header.LUN.LunAddrBytes[4],
316 cp->Header.LUN.LunAddrBytes[5],
317 cp->Header.LUN.LunAddrBytes[6],
318 cp->Header.LUN.LunAddrBytes[7]);
319 printk("CDBLen:%d\n", cp->Request.CDBLen);
320 printk("Type:%d\n",cp->Request.Type.Type);
321 printk("Attr:%d\n",cp->Request.Type.Attribute);
322 printk(" Dir:%d\n",cp->Request.Type.Direction);
323 printk("Timeout:%d\n",cp->Request.Timeout);
324 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
325 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
326 cp->Request.CDB[0], cp->Request.CDB[1],
327 cp->Request.CDB[2], cp->Request.CDB[3],
328 cp->Request.CDB[4], cp->Request.CDB[5],
329 cp->Request.CDB[6], cp->Request.CDB[7],
330 cp->Request.CDB[8], cp->Request.CDB[9],
331 cp->Request.CDB[10], cp->Request.CDB[11],
332 cp->Request.CDB[12], cp->Request.CDB[13],
333 cp->Request.CDB[14], cp->Request.CDB[15]),
334 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
335 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
337 printk("sgs..........Errorinfo:\n");
338 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
339 printk("senselen:%d\n", cp->err_info->SenseLen);
340 printk("cmd status:%d\n", cp->err_info->CommandStatus);
341 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
342 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
343 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
344 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
351 find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
353 /* finds an unused bus, target, lun for a new device */
354 /* assumes h->scsi_ctlr->lock is held */
356 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
358 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
360 target_taken[SELF_SCSI_ID] = 1;
361 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
362 target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
364 for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
365 if (!target_taken[i]) {
366 *bus = 0; *target=i; *lun = 0; found=1;
374 int bus, target, lun;
378 cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
379 struct cciss_scsi_dev_t *device,
380 struct scsi2map *added, int *nadded)
382 /* assumes h->scsi_ctlr->lock is held */
383 int n = ccissscsi[h->ctlr].ndevices;
384 struct cciss_scsi_dev_t *sd;
385 int i, bus, target, lun;
386 unsigned char addr1[8], addr2[8];
388 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
389 dev_warn(&h->pdev->dev, "Too many devices, "
390 "some will be inaccessible.\n");
396 /* Is this device a non-zero lun of a multi-lun device */
397 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
398 if (device->scsi3addr[4] != 0) {
399 /* Search through our list and find the device which */
400 /* has the same 8 byte LUN address, excepting byte 4. */
401 /* Assign the same bus and target for this new LUN. */
402 /* Use the logical unit number from the firmware. */
403 memcpy(addr1, device->scsi3addr, 8);
405 for (i = 0; i < n; i++) {
406 sd = &ccissscsi[h->ctlr].dev[i];
407 memcpy(addr2, sd->scsi3addr, 8);
409 /* differ only in byte 4? */
410 if (memcmp(addr1, addr2, 8) == 0) {
413 lun = device->scsi3addr[4];
419 sd = &ccissscsi[h->ctlr].dev[n];
421 if (find_bus_target_lun(h,
422 &sd->bus, &sd->target, &sd->lun) != 0)
429 added[*nadded].bus = sd->bus;
430 added[*nadded].target = sd->target;
431 added[*nadded].lun = sd->lun;
434 memcpy(sd->scsi3addr, device->scsi3addr, 8);
435 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
436 memcpy(sd->revision, device->revision, sizeof(sd->revision));
437 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
438 sd->devtype = device->devtype;
440 ccissscsi[h->ctlr].ndevices++;
442 /* initially, (before registering with scsi layer) we don't
443 know our hostno and we don't want to print anything first
444 time anyway (the scsi layer's inquiries will show that info) */
446 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
447 scsi_device_type(sd->devtype), hostno,
448 sd->bus, sd->target, sd->lun);
453 cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
454 struct scsi2map *removed, int *nremoved)
456 /* assumes h->ctlr]->scsi_ctlr->lock is held */
458 struct cciss_scsi_dev_t sd;
460 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
461 sd = ccissscsi[h->ctlr].dev[entry];
462 removed[*nremoved].bus = sd.bus;
463 removed[*nremoved].target = sd.target;
464 removed[*nremoved].lun = sd.lun;
466 for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
467 ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
468 ccissscsi[h->ctlr].ndevices--;
469 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
470 scsi_device_type(sd.devtype), hostno,
471 sd.bus, sd.target, sd.lun);
475 #define SCSI3ADDR_EQ(a,b) ( \
476 (a)[7] == (b)[7] && \
477 (a)[6] == (b)[6] && \
478 (a)[5] == (b)[5] && \
479 (a)[4] == (b)[4] && \
480 (a)[3] == (b)[3] && \
481 (a)[2] == (b)[2] && \
482 (a)[1] == (b)[1] && \
485 static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
487 /* called when scsi_add_device fails in order to re-adjust */
488 /* ccissscsi[] to match the mid layer's view. */
491 CPQ_TAPE_LOCK(h, flags);
492 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
493 if (memcmp(scsi3addr,
494 ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
495 for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
496 ccissscsi[h->ctlr].dev[j] =
497 ccissscsi[h->ctlr].dev[j+1];
498 ccissscsi[h->ctlr].ndevices--;
502 CPQ_TAPE_UNLOCK(h, flags);
505 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
506 struct cciss_scsi_dev_t *dev2)
508 return dev1->devtype == dev2->devtype &&
509 memcmp(dev1->scsi3addr, dev2->scsi3addr,
510 sizeof(dev1->scsi3addr)) == 0 &&
511 memcmp(dev1->device_id, dev2->device_id,
512 sizeof(dev1->device_id)) == 0 &&
513 memcmp(dev1->vendor, dev2->vendor,
514 sizeof(dev1->vendor)) == 0 &&
515 memcmp(dev1->model, dev2->model,
516 sizeof(dev1->model)) == 0 &&
517 memcmp(dev1->revision, dev2->revision,
518 sizeof(dev1->revision)) == 0;
522 adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
523 struct cciss_scsi_dev_t sd[], int nsds)
525 /* sd contains scsi3 addresses and devtypes, but
526 bus target and lun are not filled in. This funciton
527 takes what's in sd to be the current and adjusts
528 ccissscsi[] to be in line with what's in sd. */
530 int i,j, found, changes=0;
531 struct cciss_scsi_dev_t *csd;
533 struct scsi2map *added, *removed;
534 int nadded, nremoved;
535 struct Scsi_Host *sh = NULL;
537 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
539 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
542 if (!added || !removed) {
543 dev_warn(&h->pdev->dev,
544 "Out of memory in adjust_cciss_scsi_table\n");
548 CPQ_TAPE_LOCK(h, flags);
550 if (hostno != -1) /* if it's not the first time... */
551 sh = h->scsi_ctlr->scsi_host;
553 /* find any devices in ccissscsi[] that are not in
554 sd[] and remove them from ccissscsi[] */
559 while (i < ccissscsi[h->ctlr].ndevices) {
560 csd = &ccissscsi[h->ctlr].dev[i];
562 for (j=0;j<nsds;j++) {
563 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
565 if (device_is_the_same(&sd[j], csd))
573 if (found == 0) { /* device no longer present. */
575 cciss_scsi_remove_entry(h, hostno, i,
577 /* remove ^^^, hence i not incremented */
578 } else if (found == 1) { /* device is different in some way */
580 dev_info(&h->pdev->dev,
581 "device c%db%dt%dl%d has changed.\n",
582 hostno, csd->bus, csd->target, csd->lun);
583 cciss_scsi_remove_entry(h, hostno, i,
585 /* remove ^^^, hence i not incremented */
586 if (cciss_scsi_add_entry(h, hostno, &sd[j],
587 added, &nadded) != 0)
588 /* we just removed one, so add can't fail. */
590 csd->devtype = sd[j].devtype;
591 memcpy(csd->device_id, sd[j].device_id,
592 sizeof(csd->device_id));
593 memcpy(csd->vendor, sd[j].vendor,
594 sizeof(csd->vendor));
595 memcpy(csd->model, sd[j].model,
597 memcpy(csd->revision, sd[j].revision,
598 sizeof(csd->revision));
599 } else /* device is same as it ever was, */
600 i++; /* so just move along. */
603 /* Now, make sure every device listed in sd[] is also
604 listed in ccissscsi[], adding them if they aren't found */
606 for (i=0;i<nsds;i++) {
608 for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
609 csd = &ccissscsi[h->ctlr].dev[j];
610 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
612 if (device_is_the_same(&sd[i], csd))
613 found=2; /* found device */
615 found=1; /* found a bug. */
621 if (cciss_scsi_add_entry(h, hostno, &sd[i],
622 added, &nadded) != 0)
624 } else if (found == 1) {
625 /* should never happen... */
627 dev_warn(&h->pdev->dev,
628 "device unexpectedly changed\n");
629 /* but if it does happen, we just ignore that device */
632 CPQ_TAPE_UNLOCK(h, flags);
634 /* Don't notify scsi mid layer of any changes the first time through */
635 /* (or if there are no changes) scsi_scan_host will do it later the */
636 /* first time through. */
637 if (hostno == -1 || !changes)
640 /* Notify scsi mid layer of any removed devices */
641 for (i = 0; i < nremoved; i++) {
642 struct scsi_device *sdev =
643 scsi_device_lookup(sh, removed[i].bus,
644 removed[i].target, removed[i].lun);
646 scsi_remove_device(sdev);
647 scsi_device_put(sdev);
649 /* We don't expect to get here. */
650 /* future cmds to this device will get selection */
651 /* timeout as if the device was gone. */
652 dev_warn(&h->pdev->dev, "didn't find "
653 "c%db%dt%dl%d\n for removal.",
654 hostno, removed[i].bus,
655 removed[i].target, removed[i].lun);
659 /* Notify scsi mid layer of any added devices */
660 for (i = 0; i < nadded; i++) {
662 rc = scsi_add_device(sh, added[i].bus,
663 added[i].target, added[i].lun);
666 dev_warn(&h->pdev->dev, "scsi_add_device "
667 "c%db%dt%dl%d failed, device not added.\n",
668 hostno, added[i].bus, added[i].target, added[i].lun);
669 /* now we have to remove it from ccissscsi, */
670 /* since it didn't get added to scsi mid layer */
671 fixup_botched_add(h, added[i].scsi3addr);
681 lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
684 struct cciss_scsi_dev_t *sd;
687 CPQ_TAPE_LOCK(h, flags);
688 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
689 sd = &ccissscsi[h->ctlr].dev[i];
690 if (sd->bus == bus &&
691 sd->target == target &&
693 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
694 CPQ_TAPE_UNLOCK(h, flags);
698 CPQ_TAPE_UNLOCK(h, flags);
703 cciss_scsi_setup(ctlr_info_t *h)
705 struct cciss_scsi_adapter_data_t * shba;
707 ccissscsi[h->ctlr].ndevices = 0;
708 shba = (struct cciss_scsi_adapter_data_t *)
709 kmalloc(sizeof(*shba), GFP_KERNEL);
712 shba->scsi_host = NULL;
713 spin_lock_init(&shba->lock);
714 shba->registered = 0;
715 if (scsi_cmd_stack_setup(h, shba) != 0) {
723 static void complete_scsi_command(CommandList_struct *c, int timeout,
726 struct scsi_cmnd *cmd;
728 ErrorInfo_struct *ei;
732 /* First, see if it was a message rather than a command */
733 if (c->Request.Type.Type == TYPE_MSG) {
734 c->cmd_type = CMD_MSG_DONE;
738 cmd = (struct scsi_cmnd *) c->scsi_cmd;
742 if (c->Header.SGTotal > h->max_cmd_sgentries)
743 cciss_unmap_sg_chain_block(h, c);
745 cmd->result = (DID_OK << 16); /* host byte */
746 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
747 /* cmd->result |= (GOOD < 1); */ /* status byte */
749 cmd->result |= (ei->ScsiStatus);
750 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
752 /* copy the sense data whether we need to or not. */
754 memcpy(cmd->sense_buffer, ei->SenseInfo,
755 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
756 SCSI_SENSE_BUFFERSIZE :
758 scsi_set_resid(cmd, ei->ResidualCnt);
760 if(ei->CommandStatus != 0)
761 { /* an error has occurred */
762 switch(ei->CommandStatus)
764 case CMD_TARGET_STATUS:
765 /* Pass it up to the upper layers... */
766 if (!ei->ScsiStatus) {
768 /* Ordinarily, this case should never happen, but there is a bug
769 in some released firmware revisions that allows it to happen
770 if, for example, a 4100 backplane loses power and the tape
771 drive is in it. We assume that it's a fatal error of some
772 kind because we can't show that it wasn't. We will make it
773 look like selection timeout since that is the most common
774 reason for this to occur, and it's severe enough. */
776 cmd->result = DID_NO_CONNECT << 16;
779 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
781 case CMD_DATA_OVERRUN:
782 dev_warn(&h->pdev->dev, "%p has"
783 " completed with data overrun "
787 /* print_bytes(c, sizeof(*c), 1, 0);
789 /* We get CMD_INVALID if you address a non-existent tape drive instead
790 of a selection timeout (no response). You will see this if you yank
791 out a tape drive, then try to access it. This is kind of a shame
792 because it means that any other CMD_INVALID (e.g. driver bug) will
793 get interpreted as a missing target. */
794 cmd->result = DID_NO_CONNECT << 16;
797 case CMD_PROTOCOL_ERR:
798 dev_warn(&h->pdev->dev,
799 "%p has protocol error\n", c);
801 case CMD_HARDWARE_ERR:
802 cmd->result = DID_ERROR << 16;
803 dev_warn(&h->pdev->dev,
804 "%p had hardware error\n", c);
806 case CMD_CONNECTION_LOST:
807 cmd->result = DID_ERROR << 16;
808 dev_warn(&h->pdev->dev,
809 "%p had connection lost\n", c);
812 cmd->result = DID_ABORT << 16;
813 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
815 case CMD_ABORT_FAILED:
816 cmd->result = DID_ERROR << 16;
817 dev_warn(&h->pdev->dev,
818 "%p reports abort failed\n", c);
820 case CMD_UNSOLICITED_ABORT:
821 cmd->result = DID_ABORT << 16;
822 dev_warn(&h->pdev->dev, "%p aborted due to an "
823 "unsolicited abort\n", c);
826 cmd->result = DID_TIME_OUT << 16;
827 dev_warn(&h->pdev->dev, "%p timedout\n", c);
829 case CMD_UNABORTABLE:
830 cmd->result = DID_ERROR << 16;
831 dev_warn(&h->pdev->dev, "c %p command "
835 cmd->result = DID_ERROR << 16;
836 dev_warn(&h->pdev->dev,
837 "%p returned unknown status %x\n", c,
846 cciss_scsi_detect(ctlr_info_t *h)
848 struct Scsi_Host *sh;
851 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
854 sh->io_port = 0; // good enough? FIXME,
855 sh->n_io_port = 0; // I don't think we use these two...
856 sh->this_id = SELF_SCSI_ID;
857 sh->can_queue = cciss_tape_cmds;
858 sh->sg_tablesize = h->maxsgentries;
859 sh->max_cmd_len = MAX_COMMAND_SIZE;
860 sh->max_sectors = h->cciss_max_sectors;
862 ((struct cciss_scsi_adapter_data_t *)
863 h->scsi_ctlr)->scsi_host = sh;
864 sh->hostdata[0] = (unsigned long) h;
865 sh->irq = h->intr[SIMPLE_MODE_INT];
866 sh->unique_id = sh->irq;
867 error = scsi_add_host(sh, &h->pdev->dev);
880 cciss_unmap_one(struct pci_dev *pdev,
881 CommandList_struct *c,
887 addr64.val32.lower = c->SG[0].Addr.lower;
888 addr64.val32.upper = c->SG[0].Addr.upper;
889 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
893 cciss_map_one(struct pci_dev *pdev,
894 CommandList_struct *c,
901 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
902 c->SG[0].Addr.lower =
903 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
904 c->SG[0].Addr.upper =
905 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
906 c->SG[0].Len = buflen;
907 c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
908 c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
912 cciss_scsi_do_simple_cmd(ctlr_info_t *h,
913 CommandList_struct *c,
914 unsigned char *scsi3addr,
916 unsigned char cdblen,
917 unsigned char *buf, int bufsize,
920 DECLARE_COMPLETION_ONSTACK(wait);
922 c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
924 c->Header.ReplyQueue = 0; /* unused in simple mode */
925 memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
926 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
927 // Fill in the request block...
929 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
930 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
931 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
933 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
934 memcpy(c->Request.CDB, cdb, cdblen);
935 c->Request.Timeout = 0;
936 c->Request.CDBLen = cdblen;
937 c->Request.Type.Type = TYPE_CMD;
938 c->Request.Type.Attribute = ATTR_SIMPLE;
939 c->Request.Type.Direction = direction;
941 /* Fill in the SG list and do dma mapping */
942 cciss_map_one(h->pdev, c, (unsigned char *) buf,
943 bufsize, DMA_FROM_DEVICE);
946 enqueue_cmd_and_start_io(h, c);
947 wait_for_completion(&wait);
949 /* undo the dma mapping */
950 cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
955 cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
957 ErrorInfo_struct *ei;
960 switch(ei->CommandStatus)
962 case CMD_TARGET_STATUS:
963 dev_warn(&h->pdev->dev,
964 "cmd %p has completed with errors\n", c);
965 dev_warn(&h->pdev->dev,
966 "cmd %p has SCSI Status = %x\n",
968 if (ei->ScsiStatus == 0)
969 dev_warn(&h->pdev->dev,
970 "SCSI status is abnormally zero. "
971 "(probably indicates selection timeout "
972 "reported incorrectly due to a known "
973 "firmware bug, circa July, 2001.)\n");
975 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
976 dev_info(&h->pdev->dev, "UNDERRUN\n");
978 case CMD_DATA_OVERRUN:
979 dev_warn(&h->pdev->dev, "%p has"
980 " completed with data overrun "
984 /* controller unfortunately reports SCSI passthru's */
985 /* to non-existent targets as invalid commands. */
986 dev_warn(&h->pdev->dev,
987 "%p is reported invalid (probably means "
988 "target device no longer present)\n", c);
989 /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
993 case CMD_PROTOCOL_ERR:
994 dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
996 case CMD_HARDWARE_ERR:
997 /* cmd->result = DID_ERROR << 16; */
998 dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
1000 case CMD_CONNECTION_LOST:
1001 dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
1004 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
1006 case CMD_ABORT_FAILED:
1007 dev_warn(&h->pdev->dev,
1008 "%p reports abort failed\n", c);
1010 case CMD_UNSOLICITED_ABORT:
1011 dev_warn(&h->pdev->dev,
1012 "%p aborted due to an unsolicited abort\n", c);
1015 dev_warn(&h->pdev->dev, "%p timedout\n", c);
1017 case CMD_UNABORTABLE:
1018 dev_warn(&h->pdev->dev,
1019 "%p unabortable\n", c);
1022 dev_warn(&h->pdev->dev,
1023 "%p returned unknown status %x\n",
1024 c, ei->CommandStatus);
1029 cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
1030 unsigned char page, unsigned char *buf,
1031 unsigned char bufsize)
1034 CommandList_struct *c;
1036 ErrorInfo_struct *ei;
1037 unsigned long flags;
1039 spin_lock_irqsave(&h->lock, flags);
1040 c = scsi_cmd_alloc(h);
1041 spin_unlock_irqrestore(&h->lock, flags);
1043 if (c == NULL) { /* trouble... */
1044 printk("cmd_alloc returned NULL!\n");
1050 cdb[0] = CISS_INQUIRY;
1051 cdb[1] = (page != 0);
1056 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1057 6, buf, bufsize, XFER_READ);
1059 if (rc != 0) return rc; /* something went wrong */
1061 if (ei->CommandStatus != 0 &&
1062 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1063 cciss_scsi_interpret_error(h, c);
1066 spin_lock_irqsave(&h->lock, flags);
1067 scsi_cmd_free(h, c);
1068 spin_unlock_irqrestore(&h->lock, flags);
1072 /* Get the device id from inquiry page 0x83 */
1073 static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1074 unsigned char *device_id, int buflen)
1081 buf = kzalloc(64, GFP_KERNEL);
1084 rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1086 memcpy(device_id, &buf[8], buflen);
1092 cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1093 ReportLunData_struct *buf, int bufsize)
1096 CommandList_struct *c;
1097 unsigned char cdb[12];
1098 unsigned char scsi3addr[8];
1099 ErrorInfo_struct *ei;
1100 unsigned long flags;
1102 spin_lock_irqsave(&h->lock, flags);
1103 c = scsi_cmd_alloc(h);
1104 spin_unlock_irqrestore(&h->lock, flags);
1105 if (c == NULL) { /* trouble... */
1106 printk("cmd_alloc returned NULL!\n");
1110 memset(&scsi3addr[0], 0, 8); /* address the controller */
1111 cdb[0] = CISS_REPORT_PHYS;
1117 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1118 cdb[7] = (bufsize >> 16) & 0xFF;
1119 cdb[8] = (bufsize >> 8) & 0xFF;
1120 cdb[9] = bufsize & 0xFF;
1124 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1126 (unsigned char *) buf,
1127 bufsize, XFER_READ);
1129 if (rc != 0) return rc; /* something went wrong */
1132 if (ei->CommandStatus != 0 &&
1133 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1134 cciss_scsi_interpret_error(h, c);
1137 spin_lock_irqsave(&h->lock, flags);
1138 scsi_cmd_free(h, c);
1139 spin_unlock_irqrestore(&h->lock, flags);
1144 cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1146 /* the idea here is we could get notified from /proc
1147 that some devices have changed, so we do a report
1148 physical luns cmd, and adjust our list of devices
1149 accordingly. (We can't rely on the scsi-mid layer just
1150 doing inquiries, because the "busses" that the scsi
1151 mid-layer probes are totally fabricated by this driver,
1152 so new devices wouldn't show up.
1154 the scsi3addr's of devices won't change so long as the
1155 adapter is not reset. That means we can rescan and
1156 tell which devices we already know about, vs. new
1157 devices, vs. disappearing devices.
1159 Also, if you yank out a tape drive, then put in a disk
1160 in it's place, (say, a configured volume from another
1161 array controller for instance) _don't_ poke this driver
1162 (so it thinks it's still a tape, but _do_ poke the scsi
1163 mid layer, so it does an inquiry... the scsi mid layer
1164 will see the physical disk. This would be bad. Need to
1165 think about how to prevent that. One idea would be to
1166 snoop all scsi responses and if an inquiry repsonse comes
1167 back that reports a disk, chuck it an return selection
1168 timeout instead and adjust our table... Not sure i like
1172 #define OBDR_TAPE_INQ_SIZE 49
1173 #define OBDR_TAPE_SIG "$DR-10"
1174 ReportLunData_struct *ld_buff;
1175 unsigned char *inq_buff;
1176 unsigned char scsi3addr[8];
1179 struct cciss_scsi_dev_t *currentsd, *this_device;
1181 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1184 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1185 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1186 currentsd = kzalloc(sizeof(*currentsd) *
1187 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1188 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1189 printk(KERN_ERR "cciss: out of memory\n");
1192 this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1193 if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1194 ch = &ld_buff->LUNListLength[0];
1195 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1196 if (num_luns > CISS_MAX_PHYS_LUN) {
1198 "cciss: Maximum physical LUNs (%d) exceeded. "
1199 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1200 num_luns - CISS_MAX_PHYS_LUN);
1201 num_luns = CISS_MAX_PHYS_LUN;
1205 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1210 /* adjust our table of devices */
1211 for (i = 0; i < num_luns; i++) {
1212 /* for each physical lun, do an inquiry */
1213 if (ld_buff->LUN[i][3] & 0xC0) continue;
1214 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1215 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1217 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1218 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1219 /* Inquiry failed (msg printed already) */
1220 continue; /* so we will skip this device. */
1222 this_device->devtype = (inq_buff[0] & 0x1f);
1223 this_device->bus = -1;
1224 this_device->target = -1;
1225 this_device->lun = -1;
1226 memcpy(this_device->scsi3addr, scsi3addr, 8);
1227 memcpy(this_device->vendor, &inq_buff[8],
1228 sizeof(this_device->vendor));
1229 memcpy(this_device->model, &inq_buff[16],
1230 sizeof(this_device->model));
1231 memcpy(this_device->revision, &inq_buff[32],
1232 sizeof(this_device->revision));
1233 memset(this_device->device_id, 0,
1234 sizeof(this_device->device_id));
1235 cciss_scsi_get_device_id(h, scsi3addr,
1236 this_device->device_id, sizeof(this_device->device_id));
1238 switch (this_device->devtype)
1240 case 0x05: /* CD-ROM */ {
1242 /* We don't *really* support actual CD-ROM devices,
1243 * just this "One Button Disaster Recovery" tape drive
1244 * which temporarily pretends to be a CD-ROM drive.
1245 * So we check that the device is really an OBDR tape
1246 * device by checking for "$DR-10" in bytes 43-48 of
1251 strncpy(obdr_sig, &inq_buff[43], 6);
1253 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1254 /* Not OBDR device, ignore it. */
1257 /* fall through . . . */
1258 case 0x01: /* sequential access, (tape) */
1259 case 0x08: /* medium changer */
1260 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1261 printk(KERN_INFO "cciss%d: %s ignored, "
1262 "too many devices.\n", h->ctlr,
1263 scsi_device_type(this_device->devtype));
1266 currentsd[ncurrent] = *this_device;
1274 adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1283 is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1285 int verb_len = strlen(verb);
1286 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1293 cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1297 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1298 cciss_update_non_disk_devices(h, hostno);
1306 cciss_scsi_proc_info(struct Scsi_Host *sh,
1307 char *buffer, /* data buffer */
1308 char **start, /* where data in buffer starts */
1309 off_t offset, /* offset from start of imaginary file */
1310 int length, /* length of data in buffer */
1311 int func) /* 0 == read, 1 == write */
1314 int buflen, datalen;
1318 h = (ctlr_info_t *) sh->hostdata[0];
1319 if (h == NULL) /* This really shouldn't ever happen. */
1322 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1323 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1324 h->ctlr, sh->host_no);
1326 /* this information is needed by apps to know which cciss
1327 device corresponds to which scsi host number without
1328 having to open a scsi target device node. The device
1329 information is not a duplicate of /proc/scsi/scsi because
1330 the two may be out of sync due to scsi hotplug, rather
1331 this info is for an app to be able to use to know how to
1332 get them back in sync. */
1334 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1335 struct cciss_scsi_dev_t *sd =
1336 &ccissscsi[h->ctlr].dev[i];
1337 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1338 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1339 sh->host_no, sd->bus, sd->target, sd->lun,
1341 sd->scsi3addr[0], sd->scsi3addr[1],
1342 sd->scsi3addr[2], sd->scsi3addr[3],
1343 sd->scsi3addr[4], sd->scsi3addr[5],
1344 sd->scsi3addr[6], sd->scsi3addr[7]);
1346 datalen = buflen - offset;
1347 if (datalen < 0) { /* they're reading past EOF. */
1349 *start = buffer+buflen;
1351 *start = buffer + offset;
1353 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1354 return cciss_scsi_user_command(h, sh->host_no,
1358 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1359 dma mapping and fills in the scatter gather entries of the
1360 cciss command, c. */
1362 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1363 struct scsi_cmnd *cmd)
1366 struct scatterlist *sg;
1368 int request_nsgs, i, chained, sg_index;
1369 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1370 SGDescriptor_struct *curr_sg;
1372 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1377 request_nsgs = scsi_dma_map(cmd);
1379 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1380 if (sg_index + 1 == h->max_cmd_sgentries &&
1381 !chained && request_nsgs - i > 1) {
1384 curr_sg = sa->cmd_sg_list[c->cmdindex];
1386 addr64 = (__u64) sg_dma_address(sg);
1387 len = sg_dma_len(sg);
1388 curr_sg[sg_index].Addr.lower =
1389 (__u32) (addr64 & 0x0FFFFFFFFULL);
1390 curr_sg[sg_index].Addr.upper =
1391 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1392 curr_sg[sg_index].Len = len;
1393 curr_sg[sg_index].Ext = 0;
1397 cciss_map_sg_chain_block(h, c,
1398 sa->cmd_sg_list[c->cmdindex],
1399 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1400 sizeof(SGDescriptor_struct));
1402 /* track how many SG entries we are using */
1403 if (request_nsgs > h->maxSG)
1404 h->maxSG = request_nsgs;
1405 c->Header.SGTotal = (u16) request_nsgs + chained;
1406 if (request_nsgs > h->max_cmd_sgentries)
1407 c->Header.SGList = h->max_cmd_sgentries;
1409 c->Header.SGList = c->Header.SGTotal;
1415 cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1419 unsigned char scsi3addr[8];
1420 CommandList_struct *c;
1421 unsigned long flags;
1423 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1424 // We violate cmd->host privacy here. (Is there another way?)
1425 h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1427 rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1428 cmd->device->lun, scsi3addr);
1430 /* the scsi nexus does not match any that we presented... */
1431 /* pretend to mid layer that we got selection timeout */
1432 cmd->result = DID_NO_CONNECT << 16;
1434 /* we might want to think about registering controller itself
1435 as a processor device on the bus so sg binds to it. */
1439 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1440 see what the device thinks of it. */
1442 spin_lock_irqsave(&h->lock, flags);
1443 c = scsi_cmd_alloc(h);
1444 spin_unlock_irqrestore(&h->lock, flags);
1445 if (c == NULL) { /* trouble... */
1446 dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
1447 /* FIXME: next 3 lines are -> BAD! <- */
1448 cmd->result = DID_NO_CONNECT << 16;
1453 // Fill in the command list header
1455 cmd->scsi_done = done; // save this for use by completion code
1457 /* save c in case we have to abort it */
1458 cmd->host_scribble = (unsigned char *) c;
1460 c->cmd_type = CMD_SCSI;
1462 c->Header.ReplyQueue = 0; /* unused in simple mode */
1463 memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1464 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
1466 // Fill in the request block...
1468 c->Request.Timeout = 0;
1469 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1470 BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1471 c->Request.CDBLen = cmd->cmd_len;
1472 memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1473 c->Request.Type.Type = TYPE_CMD;
1474 c->Request.Type.Attribute = ATTR_SIMPLE;
1475 switch(cmd->sc_data_direction)
1478 c->Request.Type.Direction = XFER_WRITE;
1480 case DMA_FROM_DEVICE:
1481 c->Request.Type.Direction = XFER_READ;
1484 c->Request.Type.Direction = XFER_NONE;
1486 case DMA_BIDIRECTIONAL:
1487 // This can happen if a buggy application does a scsi passthru
1488 // and sets both inlen and outlen to non-zero. ( see
1489 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1491 c->Request.Type.Direction = XFER_RSVD;
1492 // This is technically wrong, and cciss controllers should
1493 // reject it with CMD_INVALID, which is the most correct
1494 // response, but non-fibre backends appear to let it
1495 // slide by, and give the same results as if this field
1496 // were set correctly. Either way is acceptable for
1497 // our purposes here.
1502 dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
1503 cmd->sc_data_direction);
1507 cciss_scatter_gather(h, c, cmd);
1508 enqueue_cmd_and_start_io(h, c);
1509 /* the cmd'll come back via intr handler in complete_scsi_command() */
1513 static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1515 static void cciss_unregister_scsi(ctlr_info_t *h)
1517 struct cciss_scsi_adapter_data_t *sa;
1518 struct cciss_scsi_cmd_stack_t *stk;
1519 unsigned long flags;
1521 /* we are being forcibly unloaded, and may not refuse. */
1523 spin_lock_irqsave(&h->lock, flags);
1525 stk = &sa->cmd_stack;
1527 /* if we weren't ever actually registered, don't unregister */
1528 if (sa->registered) {
1529 spin_unlock_irqrestore(&h->lock, flags);
1530 scsi_remove_host(sa->scsi_host);
1531 scsi_host_put(sa->scsi_host);
1532 spin_lock_irqsave(&h->lock, flags);
1535 /* set scsi_host to NULL so our detect routine will
1536 find us on register */
1537 sa->scsi_host = NULL;
1538 spin_unlock_irqrestore(&h->lock, flags);
1539 scsi_cmd_stack_free(h);
1543 static int cciss_engage_scsi(ctlr_info_t *h)
1545 struct cciss_scsi_adapter_data_t *sa;
1546 struct cciss_scsi_cmd_stack_t *stk;
1547 unsigned long flags;
1549 spin_lock_irqsave(&h->lock, flags);
1551 stk = &sa->cmd_stack;
1553 if (sa->registered) {
1554 dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
1555 spin_unlock_irqrestore(&h->lock, flags);
1559 spin_unlock_irqrestore(&h->lock, flags);
1560 cciss_update_non_disk_devices(h, -1);
1561 cciss_scsi_detect(h);
1566 cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1568 unsigned long flags;
1570 CPQ_TAPE_LOCK(h, flags);
1572 "Sequential access devices: %d\n\n",
1573 ccissscsi[h->ctlr].ndevices);
1574 CPQ_TAPE_UNLOCK(h, flags);
1577 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1578 unsigned char lunaddr[])
1583 CommandList_struct *c;
1587 dev_warn(&h->pdev->dev, "out of memory in "
1588 "wait_for_device_to_become_ready.\n");
1592 /* Send test unit ready until device ready, or give up. */
1593 while (count < 20) {
1595 /* Wait for a bit. do this first, because if we send
1596 * the TUR right away, the reset will just abort it.
1598 schedule_timeout_uninterruptible(waittime);
1601 /* Increase wait time with each try, up to a point. */
1602 if (waittime < (HZ * 30))
1603 waittime = waittime * 2;
1605 /* Send the Test Unit Ready */
1606 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1609 rc = sendcmd_withirq_core(h, c, 0);
1611 (void) process_sendcmd_error(h, c);
1616 if (c->err_info->CommandStatus == CMD_SUCCESS)
1619 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1620 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1621 if (c->err_info->SenseInfo[2] == NO_SENSE)
1623 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1625 asc = c->err_info->SenseInfo[12];
1626 check_for_unit_attention(h, c);
1627 if (asc == POWER_OR_RESET)
1632 dev_warn(&h->pdev->dev, "Waiting %d secs "
1633 "for device to become ready.\n",
1635 rc = 1; /* device not ready. */
1639 dev_warn(&h->pdev->dev, "giving up on device.\n");
1641 dev_warn(&h->pdev->dev, "device is ready.\n");
1647 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1648 * complaining. Doing a host- or bus-reset can't do anything good here.
1649 * Despite what it might say in scsi_error.c, there may well be commands
1650 * on the controller, as the cciss driver registers twice, once as a block
1651 * device for the logical drives, and once as a scsi device, for any tape
1652 * drives. So we know there are no commands out on the tape drives, but we
1653 * don't know there are no commands on the controller, and it is likely
1654 * that there probably are, as the cciss block device is most commonly used
1655 * as a boot device (embedded controller on HP/Compaq systems.)
1658 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1661 CommandList_struct *cmd_in_trouble;
1662 unsigned char lunaddr[8];
1665 /* find the controller to which the command to be aborted was sent */
1666 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1667 if (h == NULL) /* paranoia */
1669 dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
1670 /* find the command that's giving us trouble */
1671 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1672 if (cmd_in_trouble == NULL) /* paranoia */
1674 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1675 /* send a reset to the SCSI LUN which the command was sent to */
1676 rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1678 if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1680 dev_warn(&h->pdev->dev, "resetting device failed.\n");
1684 static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1687 CommandList_struct *cmd_to_abort;
1688 unsigned char lunaddr[8];
1691 /* find the controller to which the command to be aborted was sent */
1692 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1693 if (h == NULL) /* paranoia */
1695 dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
1697 /* find the command to be aborted */
1698 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1699 if (cmd_to_abort == NULL) /* paranoia */
1701 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1702 rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1703 0, 0, lunaddr, TYPE_MSG);
1710 #else /* no CONFIG_CISS_SCSI_TAPE */
1712 /* If no tape support, then these become defined out of existence */
1714 #define cciss_scsi_setup(cntl_num)
1715 #define cciss_engage_scsi(h)
1717 #endif /* CONFIG_CISS_SCSI_TAPE */