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 <asm/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(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
49 __u8 page_code, unsigned char *scsi3addr,
52 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
53 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
55 static int cciss_scsi_proc_info(
57 char *buffer, /* data buffer */
58 char **start, /* where data in buffer starts */
59 off_t offset, /* offset from start of imaginary file */
60 int length, /* length of data in buffer */
61 int func); /* 0 == read, 1 == write */
63 static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
64 void (* done)(struct scsi_cmnd *));
65 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
66 static int cciss_eh_abort_handler(struct scsi_cmnd *);
68 static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
69 { .name = "cciss0", .ndevices = 0 },
70 { .name = "cciss1", .ndevices = 0 },
71 { .name = "cciss2", .ndevices = 0 },
72 { .name = "cciss3", .ndevices = 0 },
73 { .name = "cciss4", .ndevices = 0 },
74 { .name = "cciss5", .ndevices = 0 },
75 { .name = "cciss6", .ndevices = 0 },
76 { .name = "cciss7", .ndevices = 0 },
79 static struct scsi_host_template cciss_driver_template = {
80 .module = THIS_MODULE,
83 .proc_info = cciss_scsi_proc_info,
84 .queuecommand = cciss_scsi_queue_command,
85 .can_queue = SCSI_CCISS_CAN_QUEUE,
87 .sg_tablesize = MAXSGENTRIES,
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;
104 u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
109 #define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
110 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
111 // plus two for init time usage
114 struct cciss_scsi_cmd_stack_t {
115 struct cciss_scsi_cmd_stack_elem_t *pool;
116 struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
117 dma_addr_t cmd_pool_handle;
122 struct cciss_scsi_adapter_data_t {
123 struct Scsi_Host *scsi_host;
124 struct cciss_scsi_cmd_stack_t cmd_stack;
126 spinlock_t lock; // to protect ccissscsi[ctlr];
129 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
130 &hba[ctlr]->scsi_ctlr->lock, flags);
131 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
132 &hba[ctlr]->scsi_ctlr->lock, flags);
134 static CommandList_struct *
135 scsi_cmd_alloc(ctlr_info_t *h)
137 /* assume only one process in here at a time, locking done by caller. */
138 /* use CCISS_LOCK(ctlr) */
139 /* might be better to rewrite how we allocate scsi commands in a way that */
140 /* needs no locking at all. */
142 /* take the top memory chunk off the stack and return it, if any. */
143 struct cciss_scsi_cmd_stack_elem_t *c;
144 struct cciss_scsi_adapter_data_t *sa;
145 struct cciss_scsi_cmd_stack_t *stk;
149 stk = &sa->cmd_stack;
153 c = stk->elem[stk->top];
154 /* memset(c, 0, sizeof(*c)); */
155 memset(&c->cmd, 0, sizeof(c->cmd));
156 memset(&c->Err, 0, sizeof(c->Err));
157 /* set physical addr of cmd and addr of scsi parameters */
158 c->cmd.busaddr = c->busaddr;
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 *cmd)
180 /* assume only one process in here at a time, locking done by caller. */
181 /* use CCISS_LOCK(ctlr) */
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;
189 if (stk->top >= CMD_STACK_SIZE) {
190 printk("cciss: scsi_cmd_free called too many times.\n");
194 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
198 scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
201 struct cciss_scsi_cmd_stack_t *stk;
204 stk = &sa->cmd_stack;
205 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
207 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
208 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
209 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
210 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
211 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
213 if (stk->pool == NULL) {
214 printk("stk->pool is null\n");
218 for (i=0; i<CMD_STACK_SIZE; i++) {
219 stk->elem[i] = &stk->pool[i];
220 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
221 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
223 stk->top = CMD_STACK_SIZE-1;
228 scsi_cmd_stack_free(int ctlr)
230 struct cciss_scsi_adapter_data_t *sa;
231 struct cciss_scsi_cmd_stack_t *stk;
234 sa = hba[ctlr]->scsi_ctlr;
235 stk = &sa->cmd_stack;
236 if (stk->top != CMD_STACK_SIZE-1) {
237 printk( "cciss: %d scsi commands are still outstanding.\n",
238 CMD_STACK_SIZE - stk->top);
240 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
242 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
244 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
249 static int xmargin=8;
250 static int amargin=60;
253 print_bytes (unsigned char *c, int len, int hex, int ascii)
264 if ((i % xmargin) == 0 && i>0) printk("\n");
265 if ((i % xmargin) == 0) printk("0x%04x:", i);
276 if ((i % amargin) == 0 && i>0) printk("\n");
277 if ((i % amargin) == 0) printk("0x%04x:", i);
278 if (*x > 26 && *x < 128) printk("%c", *x);
287 print_cmd(CommandList_struct *cp)
289 printk("queue:%d\n", cp->Header.ReplyQueue);
290 printk("sglist:%d\n", cp->Header.SGList);
291 printk("sgtot:%d\n", cp->Header.SGTotal);
292 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
293 cp->Header.Tag.lower);
294 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
295 cp->Header.LUN.LunAddrBytes[0],
296 cp->Header.LUN.LunAddrBytes[1],
297 cp->Header.LUN.LunAddrBytes[2],
298 cp->Header.LUN.LunAddrBytes[3],
299 cp->Header.LUN.LunAddrBytes[4],
300 cp->Header.LUN.LunAddrBytes[5],
301 cp->Header.LUN.LunAddrBytes[6],
302 cp->Header.LUN.LunAddrBytes[7]);
303 printk("CDBLen:%d\n", cp->Request.CDBLen);
304 printk("Type:%d\n",cp->Request.Type.Type);
305 printk("Attr:%d\n",cp->Request.Type.Attribute);
306 printk(" Dir:%d\n",cp->Request.Type.Direction);
307 printk("Timeout:%d\n",cp->Request.Timeout);
308 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
309 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
310 cp->Request.CDB[0], cp->Request.CDB[1],
311 cp->Request.CDB[2], cp->Request.CDB[3],
312 cp->Request.CDB[4], cp->Request.CDB[5],
313 cp->Request.CDB[6], cp->Request.CDB[7],
314 cp->Request.CDB[8], cp->Request.CDB[9],
315 cp->Request.CDB[10], cp->Request.CDB[11],
316 cp->Request.CDB[12], cp->Request.CDB[13],
317 cp->Request.CDB[14], cp->Request.CDB[15]),
318 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
319 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
321 printk("sgs..........Errorinfo:\n");
322 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
323 printk("senselen:%d\n", cp->err_info->SenseLen);
324 printk("cmd status:%d\n", cp->err_info->CommandStatus);
325 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
326 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
327 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
328 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
335 find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
337 /* finds an unused bus, target, lun for a new device */
338 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
340 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
342 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
344 target_taken[SELF_SCSI_ID] = 1;
345 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
346 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
348 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
349 if (!target_taken[i]) {
350 *bus = 0; *target=i; *lun = 0; found=1;
358 int bus, target, lun;
362 cciss_scsi_add_entry(int ctlr, int hostno,
363 struct cciss_scsi_dev_t *device,
364 struct scsi2map *added, int *nadded)
366 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
367 int n = ccissscsi[ctlr].ndevices;
368 struct cciss_scsi_dev_t *sd;
369 int i, bus, target, lun;
370 unsigned char addr1[8], addr2[8];
372 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
373 printk("cciss%d: Too many devices, "
374 "some will be inaccessible.\n", ctlr);
380 /* Is this device a non-zero lun of a multi-lun device */
381 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
382 if (device->scsi3addr[4] != 0) {
383 /* Search through our list and find the device which */
384 /* has the same 8 byte LUN address, excepting byte 4. */
385 /* Assign the same bus and target for this new LUN. */
386 /* Use the logical unit number from the firmware. */
387 memcpy(addr1, device->scsi3addr, 8);
389 for (i = 0; i < n; i++) {
390 sd = &ccissscsi[ctlr].dev[i];
391 memcpy(addr2, sd->scsi3addr, 8);
393 /* differ only in byte 4? */
394 if (memcmp(addr1, addr2, 8) == 0) {
397 lun = device->scsi3addr[4];
403 sd = &ccissscsi[ctlr].dev[n];
405 if (find_bus_target_lun(ctlr,
406 &sd->bus, &sd->target, &sd->lun) != 0)
413 added[*nadded].bus = sd->bus;
414 added[*nadded].target = sd->target;
415 added[*nadded].lun = sd->lun;
418 memcpy(sd->scsi3addr, device->scsi3addr, 8);
419 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
420 memcpy(sd->revision, device->revision, sizeof(sd->revision));
421 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
422 sd->devtype = device->devtype;
424 ccissscsi[ctlr].ndevices++;
426 /* initially, (before registering with scsi layer) we don't
427 know our hostno and we don't want to print anything first
428 time anyway (the scsi layer's inquiries will show that info) */
430 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
431 ctlr, scsi_device_type(sd->devtype), hostno,
432 sd->bus, sd->target, sd->lun);
437 cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
438 struct scsi2map *removed, int *nremoved)
440 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
442 struct cciss_scsi_dev_t sd;
444 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
445 sd = ccissscsi[ctlr].dev[entry];
446 removed[*nremoved].bus = sd.bus;
447 removed[*nremoved].target = sd.target;
448 removed[*nremoved].lun = sd.lun;
450 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
451 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
452 ccissscsi[ctlr].ndevices--;
453 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
454 ctlr, scsi_device_type(sd.devtype), hostno,
455 sd.bus, sd.target, sd.lun);
459 #define SCSI3ADDR_EQ(a,b) ( \
460 (a)[7] == (b)[7] && \
461 (a)[6] == (b)[6] && \
462 (a)[5] == (b)[5] && \
463 (a)[4] == (b)[4] && \
464 (a)[3] == (b)[3] && \
465 (a)[2] == (b)[2] && \
466 (a)[1] == (b)[1] && \
469 static void fixup_botched_add(int ctlr, char *scsi3addr)
471 /* called when scsi_add_device fails in order to re-adjust */
472 /* ccissscsi[] to match the mid layer's view. */
475 CPQ_TAPE_LOCK(ctlr, flags);
476 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
477 if (memcmp(scsi3addr,
478 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
479 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
480 ccissscsi[ctlr].dev[j] =
481 ccissscsi[ctlr].dev[j+1];
482 ccissscsi[ctlr].ndevices--;
486 CPQ_TAPE_UNLOCK(ctlr, flags);
489 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
490 struct cciss_scsi_dev_t *dev2)
492 return dev1->devtype == dev2->devtype &&
493 memcmp(dev1->scsi3addr, dev2->scsi3addr,
494 sizeof(dev1->scsi3addr)) == 0 &&
495 memcmp(dev1->device_id, dev2->device_id,
496 sizeof(dev1->device_id)) == 0 &&
497 memcmp(dev1->vendor, dev2->vendor,
498 sizeof(dev1->vendor)) == 0 &&
499 memcmp(dev1->model, dev2->model,
500 sizeof(dev1->model)) == 0 &&
501 memcmp(dev1->revision, dev2->revision,
502 sizeof(dev1->revision)) == 0;
506 adjust_cciss_scsi_table(int ctlr, int hostno,
507 struct cciss_scsi_dev_t sd[], int nsds)
509 /* sd contains scsi3 addresses and devtypes, but
510 bus target and lun are not filled in. This funciton
511 takes what's in sd to be the current and adjusts
512 ccissscsi[] to be in line with what's in sd. */
514 int i,j, found, changes=0;
515 struct cciss_scsi_dev_t *csd;
517 struct scsi2map *added, *removed;
518 int nadded, nremoved;
519 struct Scsi_Host *sh = NULL;
521 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
523 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
526 if (!added || !removed) {
527 printk(KERN_WARNING "cciss%d: Out of memory in "
528 "adjust_cciss_scsi_table\n", ctlr);
532 CPQ_TAPE_LOCK(ctlr, flags);
534 if (hostno != -1) /* if it's not the first time... */
535 sh = hba[ctlr]->scsi_ctlr->scsi_host;
537 /* find any devices in ccissscsi[] that are not in
538 sd[] and remove them from ccissscsi[] */
543 while(i<ccissscsi[ctlr].ndevices) {
544 csd = &ccissscsi[ctlr].dev[i];
546 for (j=0;j<nsds;j++) {
547 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
549 if (device_is_the_same(&sd[j], csd))
557 if (found == 0) { /* device no longer present. */
559 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
560 ctlr, scsi_device_type(csd->devtype), hostno,
561 csd->bus, csd->target, csd->lun); */
562 cciss_scsi_remove_entry(ctlr, hostno, i,
564 /* remove ^^^, hence i not incremented */
565 } else if (found == 1) { /* device is different in some way */
567 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
568 ctlr, hostno, csd->bus, csd->target, csd->lun);
569 cciss_scsi_remove_entry(ctlr, hostno, i,
571 /* remove ^^^, hence i not incremented */
572 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
573 added, &nadded) != 0)
574 /* we just removed one, so add can't fail. */
576 csd->devtype = sd[j].devtype;
577 memcpy(csd->device_id, sd[j].device_id,
578 sizeof(csd->device_id));
579 memcpy(csd->vendor, sd[j].vendor,
580 sizeof(csd->vendor));
581 memcpy(csd->model, sd[j].model,
583 memcpy(csd->revision, sd[j].revision,
584 sizeof(csd->revision));
585 } else /* device is same as it ever was, */
586 i++; /* so just move along. */
589 /* Now, make sure every device listed in sd[] is also
590 listed in ccissscsi[], adding them if they aren't found */
592 for (i=0;i<nsds;i++) {
594 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
595 csd = &ccissscsi[ctlr].dev[j];
596 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
598 if (device_is_the_same(&sd[i], csd))
599 found=2; /* found device */
601 found=1; /* found a bug. */
607 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
608 added, &nadded) != 0)
610 } else if (found == 1) {
611 /* should never happen... */
613 printk(KERN_WARNING "cciss%d: device "
614 "unexpectedly changed\n", ctlr);
615 /* but if it does happen, we just ignore that device */
618 CPQ_TAPE_UNLOCK(ctlr, flags);
620 /* Don't notify scsi mid layer of any changes the first time through */
621 /* (or if there are no changes) scsi_scan_host will do it later the */
622 /* first time through. */
623 if (hostno == -1 || !changes)
626 /* Notify scsi mid layer of any removed devices */
627 for (i = 0; i < nremoved; i++) {
628 struct scsi_device *sdev =
629 scsi_device_lookup(sh, removed[i].bus,
630 removed[i].target, removed[i].lun);
632 scsi_remove_device(sdev);
633 scsi_device_put(sdev);
635 /* We don't expect to get here. */
636 /* future cmds to this device will get selection */
637 /* timeout as if the device was gone. */
638 printk(KERN_WARNING "cciss%d: didn't find "
639 "c%db%dt%dl%d\n for removal.",
640 ctlr, hostno, removed[i].bus,
641 removed[i].target, removed[i].lun);
645 /* Notify scsi mid layer of any added devices */
646 for (i = 0; i < nadded; i++) {
648 rc = scsi_add_device(sh, added[i].bus,
649 added[i].target, added[i].lun);
652 printk(KERN_WARNING "cciss%d: scsi_add_device "
653 "c%db%dt%dl%d failed, device not added.\n",
655 added[i].bus, added[i].target, added[i].lun);
656 /* now we have to remove it from ccissscsi, */
657 /* since it didn't get added to scsi mid layer */
658 fixup_botched_add(ctlr, added[i].scsi3addr);
668 lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
671 struct cciss_scsi_dev_t *sd;
674 CPQ_TAPE_LOCK(ctlr, flags);
675 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
676 sd = &ccissscsi[ctlr].dev[i];
677 if (sd->bus == bus &&
678 sd->target == target &&
680 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
681 CPQ_TAPE_UNLOCK(ctlr, flags);
685 CPQ_TAPE_UNLOCK(ctlr, flags);
690 cciss_scsi_setup(int cntl_num)
692 struct cciss_scsi_adapter_data_t * shba;
694 ccissscsi[cntl_num].ndevices = 0;
695 shba = (struct cciss_scsi_adapter_data_t *)
696 kmalloc(sizeof(*shba), GFP_KERNEL);
699 shba->scsi_host = NULL;
700 spin_lock_init(&shba->lock);
701 shba->registered = 0;
702 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
706 hba[cntl_num]->scsi_ctlr = shba;
711 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
713 struct scsi_cmnd *cmd;
715 ErrorInfo_struct *ei;
719 /* First, see if it was a message rather than a command */
720 if (cp->Request.Type.Type == TYPE_MSG) {
721 cp->cmd_type = CMD_MSG_DONE;
725 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
726 ctlr = hba[cp->ctlr];
730 cmd->result = (DID_OK << 16); /* host byte */
731 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
732 /* cmd->result |= (GOOD < 1); */ /* status byte */
734 cmd->result |= (ei->ScsiStatus);
735 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
737 /* copy the sense data whether we need to or not. */
739 memcpy(cmd->sense_buffer, ei->SenseInfo,
740 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
741 SCSI_SENSE_BUFFERSIZE :
743 scsi_set_resid(cmd, ei->ResidualCnt);
745 if(ei->CommandStatus != 0)
746 { /* an error has occurred */
747 switch(ei->CommandStatus)
749 case CMD_TARGET_STATUS:
750 /* Pass it up to the upper layers... */
754 printk(KERN_WARNING "cciss: cmd %p "
755 "has SCSI Status = %x\n",
759 cmd->result |= (ei->ScsiStatus << 1);
761 else { /* scsi status is zero??? How??? */
763 /* Ordinarily, this case should never happen, but there is a bug
764 in some released firmware revisions that allows it to happen
765 if, for example, a 4100 backplane loses power and the tape
766 drive is in it. We assume that it's a fatal error of some
767 kind because we can't show that it wasn't. We will make it
768 look like selection timeout since that is the most common
769 reason for this to occur, and it's severe enough. */
771 cmd->result = DID_NO_CONNECT << 16;
774 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
776 case CMD_DATA_OVERRUN:
777 printk(KERN_WARNING "cciss: cp %p has"
778 " completed with data overrun "
782 /* print_bytes(cp, sizeof(*cp), 1, 0);
784 /* We get CMD_INVALID if you address a non-existent tape drive instead
785 of a selection timeout (no response). You will see this if you yank
786 out a tape drive, then try to access it. This is kind of a shame
787 because it means that any other CMD_INVALID (e.g. driver bug) will
788 get interpreted as a missing target. */
789 cmd->result = DID_NO_CONNECT << 16;
792 case CMD_PROTOCOL_ERR:
793 printk(KERN_WARNING "cciss: cp %p has "
794 "protocol error \n", cp);
796 case CMD_HARDWARE_ERR:
797 cmd->result = DID_ERROR << 16;
798 printk(KERN_WARNING "cciss: cp %p had "
799 " hardware error\n", cp);
801 case CMD_CONNECTION_LOST:
802 cmd->result = DID_ERROR << 16;
803 printk(KERN_WARNING "cciss: cp %p had "
804 "connection lost\n", cp);
807 cmd->result = DID_ABORT << 16;
808 printk(KERN_WARNING "cciss: cp %p was "
811 case CMD_ABORT_FAILED:
812 cmd->result = DID_ERROR << 16;
813 printk(KERN_WARNING "cciss: cp %p reports "
814 "abort failed\n", cp);
816 case CMD_UNSOLICITED_ABORT:
817 cmd->result = DID_ABORT << 16;
818 printk(KERN_WARNING "cciss: cp %p aborted "
819 "do to an unsolicited abort\n", cp);
822 cmd->result = DID_TIME_OUT << 16;
823 printk(KERN_WARNING "cciss: cp %p timedout\n",
827 cmd->result = DID_ERROR << 16;
828 printk(KERN_WARNING "cciss: cp %p returned "
829 "unknown status %x\n", cp,
833 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
834 // cmd->target, cmd->lun);
836 scsi_cmd_free(ctlr, cp);
840 cciss_scsi_detect(int ctlr)
842 struct Scsi_Host *sh;
845 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
848 sh->io_port = 0; // good enough? FIXME,
849 sh->n_io_port = 0; // I don't think we use these two...
850 sh->this_id = SELF_SCSI_ID;
852 ((struct cciss_scsi_adapter_data_t *)
853 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
854 sh->hostdata[0] = (unsigned long) hba[ctlr];
855 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
856 sh->unique_id = sh->irq;
857 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
870 cciss_unmap_one(struct pci_dev *pdev,
871 CommandList_struct *cp,
877 addr64.val32.lower = cp->SG[0].Addr.lower;
878 addr64.val32.upper = cp->SG[0].Addr.upper;
879 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
883 cciss_map_one(struct pci_dev *pdev,
884 CommandList_struct *cp,
891 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
892 cp->SG[0].Addr.lower =
893 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
894 cp->SG[0].Addr.upper =
895 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
896 cp->SG[0].Len = buflen;
897 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
898 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
902 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
903 CommandList_struct *cp,
904 unsigned char *scsi3addr,
906 unsigned char cdblen,
907 unsigned char *buf, int bufsize,
911 DECLARE_COMPLETION_ONSTACK(wait);
913 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl
915 cp->Header.ReplyQueue = 0; // unused in simple mode
916 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
917 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
918 // Fill in the request block...
920 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
921 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
922 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
924 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
925 memcpy(cp->Request.CDB, cdb, cdblen);
926 cp->Request.Timeout = 0;
927 cp->Request.CDBLen = cdblen;
928 cp->Request.Type.Type = TYPE_CMD;
929 cp->Request.Type.Attribute = ATTR_SIMPLE;
930 cp->Request.Type.Direction = direction;
932 /* Fill in the SG list and do dma mapping */
933 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
934 bufsize, DMA_FROM_DEVICE);
938 /* Put the request on the tail of the request queue */
939 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
943 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
945 wait_for_completion(&wait);
947 /* undo the dma mapping */
948 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
953 cciss_scsi_interpret_error(CommandList_struct *cp)
955 ErrorInfo_struct *ei;
958 switch(ei->CommandStatus)
960 case CMD_TARGET_STATUS:
961 printk(KERN_WARNING "cciss: cmd %p has "
962 "completed with errors\n", cp);
963 printk(KERN_WARNING "cciss: cmd %p "
964 "has SCSI Status = %x\n",
967 if (ei->ScsiStatus == 0)
969 "cciss:SCSI status is abnormally zero. "
970 "(probably indicates selection timeout "
971 "reported incorrectly due to a known "
972 "firmware bug, circa July, 2001.)\n");
974 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
975 printk("UNDERRUN\n");
977 case CMD_DATA_OVERRUN:
978 printk(KERN_WARNING "cciss: cp %p has"
979 " completed with data overrun "
983 /* controller unfortunately reports SCSI passthru's */
984 /* to non-existent targets as invalid commands. */
985 printk(KERN_WARNING "cciss: cp %p is "
986 "reported invalid (probably means "
987 "target device no longer present)\n",
989 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
993 case CMD_PROTOCOL_ERR:
994 printk(KERN_WARNING "cciss: cp %p has "
995 "protocol error \n", cp);
997 case CMD_HARDWARE_ERR:
998 /* cmd->result = DID_ERROR << 16; */
999 printk(KERN_WARNING "cciss: cp %p had "
1000 " hardware error\n", cp);
1002 case CMD_CONNECTION_LOST:
1003 printk(KERN_WARNING "cciss: cp %p had "
1004 "connection lost\n", cp);
1007 printk(KERN_WARNING "cciss: cp %p was "
1010 case CMD_ABORT_FAILED:
1011 printk(KERN_WARNING "cciss: cp %p reports "
1012 "abort failed\n", cp);
1014 case CMD_UNSOLICITED_ABORT:
1015 printk(KERN_WARNING "cciss: cp %p aborted "
1016 "do to an unsolicited abort\n", cp);
1019 printk(KERN_WARNING "cciss: cp %p timedout\n",
1023 printk(KERN_WARNING "cciss: cp %p returned "
1024 "unknown status %x\n", cp,
1030 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1031 unsigned char page, unsigned char *buf,
1032 unsigned char bufsize)
1035 CommandList_struct *cp;
1037 ErrorInfo_struct *ei;
1038 unsigned long flags;
1040 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1041 cp = scsi_cmd_alloc(c);
1042 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1044 if (cp == NULL) { /* trouble... */
1045 printk("cmd_alloc returned NULL!\n");
1051 cdb[0] = CISS_INQUIRY;
1052 cdb[1] = (page != 0);
1057 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
1058 6, buf, bufsize, XFER_READ);
1060 if (rc != 0) return rc; /* something went wrong */
1062 if (ei->CommandStatus != 0 &&
1063 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1064 cciss_scsi_interpret_error(cp);
1067 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1068 scsi_cmd_free(c, cp);
1069 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1073 /* Get the device id from inquiry page 0x83 */
1074 static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1075 unsigned char *device_id, int buflen)
1082 buf = kzalloc(64, GFP_KERNEL);
1085 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1087 memcpy(device_id, &buf[8], buflen);
1093 cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1094 ReportLunData_struct *buf, int bufsize)
1097 CommandList_struct *cp;
1098 unsigned char cdb[12];
1099 unsigned char scsi3addr[8];
1100 ErrorInfo_struct *ei;
1101 unsigned long flags;
1103 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1104 cp = scsi_cmd_alloc(c);
1105 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1106 if (cp == NULL) { /* trouble... */
1107 printk("cmd_alloc returned NULL!\n");
1111 memset(&scsi3addr[0], 0, 8); /* address the controller */
1112 cdb[0] = CISS_REPORT_PHYS;
1118 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1119 cdb[7] = (bufsize >> 16) & 0xFF;
1120 cdb[8] = (bufsize >> 8) & 0xFF;
1121 cdb[9] = bufsize & 0xFF;
1125 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1127 (unsigned char *) buf,
1128 bufsize, XFER_READ);
1130 if (rc != 0) return rc; /* something went wrong */
1133 if (ei->CommandStatus != 0 &&
1134 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1135 cciss_scsi_interpret_error(cp);
1138 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1139 scsi_cmd_free(c, cp);
1140 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1145 cciss_update_non_disk_devices(int cntl_num, int hostno)
1147 /* the idea here is we could get notified from /proc
1148 that some devices have changed, so we do a report
1149 physical luns cmd, and adjust our list of devices
1150 accordingly. (We can't rely on the scsi-mid layer just
1151 doing inquiries, because the "busses" that the scsi
1152 mid-layer probes are totally fabricated by this driver,
1153 so new devices wouldn't show up.
1155 the scsi3addr's of devices won't change so long as the
1156 adapter is not reset. That means we can rescan and
1157 tell which devices we already know about, vs. new
1158 devices, vs. disappearing devices.
1160 Also, if you yank out a tape drive, then put in a disk
1161 in it's place, (say, a configured volume from another
1162 array controller for instance) _don't_ poke this driver
1163 (so it thinks it's still a tape, but _do_ poke the scsi
1164 mid layer, so it does an inquiry... the scsi mid layer
1165 will see the physical disk. This would be bad. Need to
1166 think about how to prevent that. One idea would be to
1167 snoop all scsi responses and if an inquiry repsonse comes
1168 back that reports a disk, chuck it an return selection
1169 timeout instead and adjust our table... Not sure i like
1173 #define OBDR_TAPE_INQ_SIZE 49
1174 #define OBDR_TAPE_SIG "$DR-10"
1175 ReportLunData_struct *ld_buff;
1176 unsigned char *inq_buff;
1177 unsigned char scsi3addr[8];
1181 struct cciss_scsi_dev_t *currentsd, *this_device;
1183 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1186 c = (ctlr_info_t *) hba[cntl_num];
1187 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1188 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1189 currentsd = kzalloc(sizeof(*currentsd) *
1190 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1191 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1192 printk(KERN_ERR "cciss: out of memory\n");
1195 this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1196 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1197 ch = &ld_buff->LUNListLength[0];
1198 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1199 if (num_luns > CISS_MAX_PHYS_LUN) {
1201 "cciss: Maximum physical LUNs (%d) exceeded. "
1202 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1203 num_luns - CISS_MAX_PHYS_LUN);
1204 num_luns = CISS_MAX_PHYS_LUN;
1208 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1213 /* adjust our table of devices */
1214 for (i = 0; i < num_luns; i++) {
1215 /* for each physical lun, do an inquiry */
1216 if (ld_buff->LUN[i][3] & 0xC0) continue;
1217 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1218 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1220 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1221 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1222 /* Inquiry failed (msg printed already) */
1223 continue; /* so we will skip this device. */
1225 this_device->devtype = (inq_buff[0] & 0x1f);
1226 this_device->bus = -1;
1227 this_device->target = -1;
1228 this_device->lun = -1;
1229 memcpy(this_device->scsi3addr, scsi3addr, 8);
1230 memcpy(this_device->vendor, &inq_buff[8],
1231 sizeof(this_device->vendor));
1232 memcpy(this_device->model, &inq_buff[16],
1233 sizeof(this_device->model));
1234 memcpy(this_device->revision, &inq_buff[32],
1235 sizeof(this_device->revision));
1236 memset(this_device->device_id, 0,
1237 sizeof(this_device->device_id));
1238 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1239 this_device->device_id, sizeof(this_device->device_id));
1241 switch (this_device->devtype)
1243 case 0x05: /* CD-ROM */ {
1245 /* We don't *really* support actual CD-ROM devices,
1246 * just this "One Button Disaster Recovery" tape drive
1247 * which temporarily pretends to be a CD-ROM drive.
1248 * So we check that the device is really an OBDR tape
1249 * device by checking for "$DR-10" in bytes 43-48 of
1254 strncpy(obdr_sig, &inq_buff[43], 6);
1256 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1257 /* Not OBDR device, ignore it. */
1260 /* fall through . . . */
1261 case 0x01: /* sequential access, (tape) */
1262 case 0x08: /* medium changer */
1263 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1264 printk(KERN_INFO "cciss%d: %s ignored, "
1265 "too many devices.\n", cntl_num,
1266 scsi_device_type(this_device->devtype));
1269 currentsd[ncurrent] = *this_device;
1277 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1286 is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1288 int verb_len = strlen(verb);
1289 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1296 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1300 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1301 cciss_update_non_disk_devices(ctlr, hostno);
1309 cciss_scsi_proc_info(struct Scsi_Host *sh,
1310 char *buffer, /* data buffer */
1311 char **start, /* where data in buffer starts */
1312 off_t offset, /* offset from start of imaginary file */
1313 int length, /* length of data in buffer */
1314 int func) /* 0 == read, 1 == write */
1317 int buflen, datalen;
1323 ci = (ctlr_info_t *) sh->hostdata[0];
1324 if (ci == NULL) /* This really shouldn't ever happen. */
1327 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1329 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1330 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1331 cntl_num, sh->host_no);
1333 /* this information is needed by apps to know which cciss
1334 device corresponds to which scsi host number without
1335 having to open a scsi target device node. The device
1336 information is not a duplicate of /proc/scsi/scsi because
1337 the two may be out of sync due to scsi hotplug, rather
1338 this info is for an app to be able to use to know how to
1339 get them back in sync. */
1341 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1342 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1343 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1344 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1345 sh->host_no, sd->bus, sd->target, sd->lun,
1347 sd->scsi3addr[0], sd->scsi3addr[1],
1348 sd->scsi3addr[2], sd->scsi3addr[3],
1349 sd->scsi3addr[4], sd->scsi3addr[5],
1350 sd->scsi3addr[6], sd->scsi3addr[7]);
1352 datalen = buflen - offset;
1353 if (datalen < 0) { /* they're reading past EOF. */
1355 *start = buffer+buflen;
1357 *start = buffer + offset;
1359 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1360 return cciss_scsi_user_command(cntl_num, sh->host_no,
1364 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1365 dma mapping and fills in the scatter gather entries of the
1366 cciss command, cp. */
1369 cciss_scatter_gather(struct pci_dev *pdev,
1370 CommandList_struct *cp,
1371 struct scsi_cmnd *cmd)
1374 struct scatterlist *sg;
1378 BUG_ON(scsi_sg_count(cmd) > MAXSGENTRIES);
1380 use_sg = scsi_dma_map(cmd);
1381 if (use_sg) { /* not too many addrs? */
1382 scsi_for_each_sg(cmd, sg, use_sg, i) {
1383 addr64 = (__u64) sg_dma_address(sg);
1384 len = sg_dma_len(sg);
1385 cp->SG[i].Addr.lower =
1386 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1387 cp->SG[i].Addr.upper =
1388 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1389 cp->SG[i].Len = len;
1390 cp->SG[i].Ext = 0; // we are not chaining
1394 cp->Header.SGList = (__u8) use_sg; /* no. SGs contig in this cmd */
1395 cp->Header.SGTotal = (__u16) use_sg; /* total sgs in this cmd list */
1401 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1405 unsigned char scsi3addr[8];
1406 CommandList_struct *cp;
1407 unsigned long flags;
1409 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1410 // We violate cmd->host privacy here. (Is there another way?)
1411 c = (ctlr_info_t **) &cmd->device->host->hostdata[0];
1414 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1415 cmd->device->lun, scsi3addr);
1417 /* the scsi nexus does not match any that we presented... */
1418 /* pretend to mid layer that we got selection timeout */
1419 cmd->result = DID_NO_CONNECT << 16;
1421 /* we might want to think about registering controller itself
1422 as a processor device on the bus so sg binds to it. */
1426 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1427 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1428 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1429 // cmd->target, cmd->lun);
1431 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1432 see what the device thinks of it. */
1434 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1435 cp = scsi_cmd_alloc(*c);
1436 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1437 if (cp == NULL) { /* trouble... */
1438 printk("scsi_cmd_alloc returned NULL!\n");
1439 /* FIXME: next 3 lines are -> BAD! <- */
1440 cmd->result = DID_NO_CONNECT << 16;
1445 // Fill in the command list header
1447 cmd->scsi_done = done; // save this for use by completion code
1449 // save cp in case we have to abort it
1450 cmd->host_scribble = (unsigned char *) cp;
1452 cp->cmd_type = CMD_SCSI;
1454 cp->Header.ReplyQueue = 0; // unused in simple mode
1455 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1456 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
1458 // Fill in the request block...
1460 cp->Request.Timeout = 0;
1461 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1462 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1463 cp->Request.CDBLen = cmd->cmd_len;
1464 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1465 cp->Request.Type.Type = TYPE_CMD;
1466 cp->Request.Type.Attribute = ATTR_SIMPLE;
1467 switch(cmd->sc_data_direction)
1469 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1470 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1471 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1472 case DMA_BIDIRECTIONAL:
1473 // This can happen if a buggy application does a scsi passthru
1474 // and sets both inlen and outlen to non-zero. ( see
1475 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1477 cp->Request.Type.Direction = XFER_RSVD;
1478 // This is technically wrong, and cciss controllers should
1479 // reject it with CMD_INVALID, which is the most correct
1480 // response, but non-fibre backends appear to let it
1481 // slide by, and give the same results as if this field
1482 // were set correctly. Either way is acceptable for
1483 // our purposes here.
1488 printk("cciss: unknown data direction: %d\n",
1489 cmd->sc_data_direction);
1494 cciss_scatter_gather((*c)->pdev, cp, cmd); // Fill the SG list
1496 /* Put the request on the tail of the request queue */
1498 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1499 addQ(&(*c)->reqQ, cp);
1502 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1504 /* the cmd'll come back via intr handler in complete_scsi_command() */
1509 cciss_unregister_scsi(int ctlr)
1511 struct cciss_scsi_adapter_data_t *sa;
1512 struct cciss_scsi_cmd_stack_t *stk;
1513 unsigned long flags;
1515 /* we are being forcibly unloaded, and may not refuse. */
1517 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1518 sa = hba[ctlr]->scsi_ctlr;
1519 stk = &sa->cmd_stack;
1521 /* if we weren't ever actually registered, don't unregister */
1522 if (sa->registered) {
1523 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1524 scsi_remove_host(sa->scsi_host);
1525 scsi_host_put(sa->scsi_host);
1526 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1529 /* set scsi_host to NULL so our detect routine will
1530 find us on register */
1531 sa->scsi_host = NULL;
1532 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1533 scsi_cmd_stack_free(ctlr);
1538 cciss_engage_scsi(int ctlr)
1540 struct cciss_scsi_adapter_data_t *sa;
1541 struct cciss_scsi_cmd_stack_t *stk;
1542 unsigned long flags;
1544 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1545 sa = hba[ctlr]->scsi_ctlr;
1546 stk = &sa->cmd_stack;
1548 if (sa->registered) {
1549 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1550 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1554 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1555 cciss_update_non_disk_devices(ctlr, -1);
1556 cciss_scsi_detect(ctlr);
1561 cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1563 unsigned long flags;
1565 CPQ_TAPE_LOCK(ctlr, flags);
1567 "Sequential access devices: %d\n\n",
1568 ccissscsi[ctlr].ndevices);
1569 CPQ_TAPE_UNLOCK(ctlr, flags);
1572 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1573 unsigned char lunaddr[])
1578 CommandList_struct *c;
1580 c = cmd_alloc(h, 1);
1582 printk(KERN_WARNING "cciss%d: out of memory in "
1583 "wait_for_device_to_become_ready.\n", h->ctlr);
1587 /* Send test unit ready until device ready, or give up. */
1588 while (count < 20) {
1590 /* Wait for a bit. do this first, because if we send
1591 * the TUR right away, the reset will just abort it.
1593 schedule_timeout_uninterruptible(waittime);
1596 /* Increase wait time with each try, up to a point. */
1597 if (waittime < (HZ * 30))
1598 waittime = waittime * 2;
1600 /* Send the Test Unit Ready */
1601 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1604 rc = sendcmd_withirq_core(h, c, 0);
1606 (void) process_sendcmd_error(h, c);
1611 if (c->err_info->CommandStatus == CMD_SUCCESS)
1614 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1615 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1616 if (c->err_info->SenseInfo[2] == NO_SENSE)
1618 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1620 asc = c->err_info->SenseInfo[12];
1621 check_for_unit_attention(h, c);
1622 if (asc == POWER_OR_RESET)
1627 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1628 "for device to become ready.\n",
1629 h->ctlr, waittime / HZ);
1630 rc = 1; /* device not ready. */
1634 printk("cciss%d: giving up on device.\n", h->ctlr);
1636 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1642 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1643 * complaining. Doing a host- or bus-reset can't do anything good here.
1644 * Despite what it might say in scsi_error.c, there may well be commands
1645 * on the controller, as the cciss driver registers twice, once as a block
1646 * device for the logical drives, and once as a scsi device, for any tape
1647 * drives. So we know there are no commands out on the tape drives, but we
1648 * don't know there are no commands on the controller, and it is likely
1649 * that there probably are, as the cciss block device is most commonly used
1650 * as a boot device (embedded controller on HP/Compaq systems.)
1653 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1656 CommandList_struct *cmd_in_trouble;
1657 unsigned char lunaddr[8];
1661 /* find the controller to which the command to be aborted was sent */
1662 c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];
1663 if (c == NULL) /* paranoia */
1666 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1667 /* find the command that's giving us trouble */
1668 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1669 if (cmd_in_trouble == NULL) /* paranoia */
1671 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1672 /* send a reset to the SCSI LUN which the command was sent to */
1673 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1675 if (rc == 0 && wait_for_device_to_become_ready(*c, lunaddr) == 0)
1677 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1681 static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1684 CommandList_struct *cmd_to_abort;
1685 unsigned char lunaddr[8];
1689 /* find the controller to which the command to be aborted was sent */
1690 c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];
1691 if (c == NULL) /* paranoia */
1694 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1696 /* find the command to be aborted */
1697 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1698 if (cmd_to_abort == NULL) /* paranoia */
1700 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1701 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1702 0, 0, lunaddr, TYPE_MSG);
1709 #else /* no CONFIG_CISS_SCSI_TAPE */
1711 /* If no tape support, then these become defined out of existence */
1713 #define cciss_scsi_setup(cntl_num)
1715 #endif /* CONFIG_CISS_SCSI_TAPE */