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,
88 .use_clustering = DISABLE_CLUSTERING,
89 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
90 .eh_device_reset_handler= cciss_eh_device_reset_handler,
91 .eh_abort_handler = cciss_eh_abort_handler,
99 struct cciss_scsi_cmd_stack_elem_t {
100 CommandList_struct cmd;
101 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;
125 SGDescriptor_struct **cmd_sg_list;
127 spinlock_t lock; // to protect ccissscsi[ctlr];
130 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
131 &hba[ctlr]->scsi_ctlr->lock, flags);
132 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
133 &hba[ctlr]->scsi_ctlr->lock, flags);
135 static CommandList_struct *
136 scsi_cmd_alloc(ctlr_info_t *h)
138 /* assume only one process in here at a time, locking done by caller. */
139 /* use CCISS_LOCK(ctlr) */
140 /* might be better to rewrite how we allocate scsi commands in a way that */
141 /* needs no locking at all. */
143 /* take the top memory chunk off the stack and return it, if any. */
144 struct cciss_scsi_cmd_stack_elem_t *c;
145 struct cciss_scsi_adapter_data_t *sa;
146 struct cciss_scsi_cmd_stack_t *stk;
150 stk = &sa->cmd_stack;
154 c = stk->elem[stk->top];
155 /* memset(c, 0, sizeof(*c)); */
156 memset(&c->cmd, 0, sizeof(c->cmd));
157 memset(&c->Err, 0, sizeof(c->Err));
158 /* set physical addr of cmd and addr of scsi parameters */
159 c->cmd.busaddr = c->busaddr;
160 c->cmd.cmdindex = c->cmdindex;
161 /* (__u32) (stk->cmd_pool_handle +
162 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
164 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
165 /* (__u64) (stk->cmd_pool_handle +
166 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
167 sizeof(CommandList_struct)); */
169 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
170 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
171 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
173 c->cmd.ctlr = h->ctlr;
174 c->cmd.err_info = &c->Err;
176 return (CommandList_struct *) c;
180 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
182 /* assume only one process in here at a time, locking done by caller. */
183 /* use CCISS_LOCK(ctlr) */
184 /* drop the free memory chunk on top of the stack. */
186 struct cciss_scsi_adapter_data_t *sa;
187 struct cciss_scsi_cmd_stack_t *stk;
190 stk = &sa->cmd_stack;
192 if (stk->top >= CMD_STACK_SIZE) {
193 printk("cciss: scsi_cmd_free called too many times.\n");
196 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
200 scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
203 struct cciss_scsi_cmd_stack_t *stk;
206 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr],
207 hba[ctlr]->chainsize, CMD_STACK_SIZE);
208 if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0)
211 stk = &sa->cmd_stack;
212 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
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(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
220 if (stk->pool == NULL) {
221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
222 sa->cmd_sg_list = NULL;
226 for (i=0; i<CMD_STACK_SIZE; i++) {
227 stk->elem[i] = &stk->pool[i];
228 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
229 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
230 stk->elem[i]->cmdindex = i;
232 stk->top = CMD_STACK_SIZE-1;
237 scsi_cmd_stack_free(int ctlr)
239 struct cciss_scsi_adapter_data_t *sa;
240 struct cciss_scsi_cmd_stack_t *stk;
243 sa = hba[ctlr]->scsi_ctlr;
244 stk = &sa->cmd_stack;
245 if (stk->top != CMD_STACK_SIZE-1) {
246 printk( "cciss: %d scsi commands are still outstanding.\n",
247 CMD_STACK_SIZE - stk->top);
249 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
251 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
253 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
255 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
259 static int xmargin=8;
260 static int amargin=60;
263 print_bytes (unsigned char *c, int len, int hex, int ascii)
274 if ((i % xmargin) == 0 && i>0) printk("\n");
275 if ((i % xmargin) == 0) printk("0x%04x:", i);
286 if ((i % amargin) == 0 && i>0) printk("\n");
287 if ((i % amargin) == 0) printk("0x%04x:", i);
288 if (*x > 26 && *x < 128) printk("%c", *x);
297 print_cmd(CommandList_struct *cp)
299 printk("queue:%d\n", cp->Header.ReplyQueue);
300 printk("sglist:%d\n", cp->Header.SGList);
301 printk("sgtot:%d\n", cp->Header.SGTotal);
302 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
303 cp->Header.Tag.lower);
304 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
305 cp->Header.LUN.LunAddrBytes[0],
306 cp->Header.LUN.LunAddrBytes[1],
307 cp->Header.LUN.LunAddrBytes[2],
308 cp->Header.LUN.LunAddrBytes[3],
309 cp->Header.LUN.LunAddrBytes[4],
310 cp->Header.LUN.LunAddrBytes[5],
311 cp->Header.LUN.LunAddrBytes[6],
312 cp->Header.LUN.LunAddrBytes[7]);
313 printk("CDBLen:%d\n", cp->Request.CDBLen);
314 printk("Type:%d\n",cp->Request.Type.Type);
315 printk("Attr:%d\n",cp->Request.Type.Attribute);
316 printk(" Dir:%d\n",cp->Request.Type.Direction);
317 printk("Timeout:%d\n",cp->Request.Timeout);
318 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
319 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
320 cp->Request.CDB[0], cp->Request.CDB[1],
321 cp->Request.CDB[2], cp->Request.CDB[3],
322 cp->Request.CDB[4], cp->Request.CDB[5],
323 cp->Request.CDB[6], cp->Request.CDB[7],
324 cp->Request.CDB[8], cp->Request.CDB[9],
325 cp->Request.CDB[10], cp->Request.CDB[11],
326 cp->Request.CDB[12], cp->Request.CDB[13],
327 cp->Request.CDB[14], cp->Request.CDB[15]),
328 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
329 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
331 printk("sgs..........Errorinfo:\n");
332 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
333 printk("senselen:%d\n", cp->err_info->SenseLen);
334 printk("cmd status:%d\n", cp->err_info->CommandStatus);
335 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
336 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
337 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
338 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
345 find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
347 /* finds an unused bus, target, lun for a new device */
348 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
350 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
352 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
354 target_taken[SELF_SCSI_ID] = 1;
355 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
356 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
358 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
359 if (!target_taken[i]) {
360 *bus = 0; *target=i; *lun = 0; found=1;
368 int bus, target, lun;
372 cciss_scsi_add_entry(int ctlr, int hostno,
373 struct cciss_scsi_dev_t *device,
374 struct scsi2map *added, int *nadded)
376 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
377 int n = ccissscsi[ctlr].ndevices;
378 struct cciss_scsi_dev_t *sd;
379 int i, bus, target, lun;
380 unsigned char addr1[8], addr2[8];
382 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
383 printk("cciss%d: Too many devices, "
384 "some will be inaccessible.\n", ctlr);
390 /* Is this device a non-zero lun of a multi-lun device */
391 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
392 if (device->scsi3addr[4] != 0) {
393 /* Search through our list and find the device which */
394 /* has the same 8 byte LUN address, excepting byte 4. */
395 /* Assign the same bus and target for this new LUN. */
396 /* Use the logical unit number from the firmware. */
397 memcpy(addr1, device->scsi3addr, 8);
399 for (i = 0; i < n; i++) {
400 sd = &ccissscsi[ctlr].dev[i];
401 memcpy(addr2, sd->scsi3addr, 8);
403 /* differ only in byte 4? */
404 if (memcmp(addr1, addr2, 8) == 0) {
407 lun = device->scsi3addr[4];
413 sd = &ccissscsi[ctlr].dev[n];
415 if (find_bus_target_lun(ctlr,
416 &sd->bus, &sd->target, &sd->lun) != 0)
423 added[*nadded].bus = sd->bus;
424 added[*nadded].target = sd->target;
425 added[*nadded].lun = sd->lun;
428 memcpy(sd->scsi3addr, device->scsi3addr, 8);
429 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
430 memcpy(sd->revision, device->revision, sizeof(sd->revision));
431 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
432 sd->devtype = device->devtype;
434 ccissscsi[ctlr].ndevices++;
436 /* initially, (before registering with scsi layer) we don't
437 know our hostno and we don't want to print anything first
438 time anyway (the scsi layer's inquiries will show that info) */
440 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
441 ctlr, scsi_device_type(sd->devtype), hostno,
442 sd->bus, sd->target, sd->lun);
447 cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
448 struct scsi2map *removed, int *nremoved)
450 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
452 struct cciss_scsi_dev_t sd;
454 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
455 sd = ccissscsi[ctlr].dev[entry];
456 removed[*nremoved].bus = sd.bus;
457 removed[*nremoved].target = sd.target;
458 removed[*nremoved].lun = sd.lun;
460 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
461 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
462 ccissscsi[ctlr].ndevices--;
463 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
464 ctlr, scsi_device_type(sd.devtype), hostno,
465 sd.bus, sd.target, sd.lun);
469 #define SCSI3ADDR_EQ(a,b) ( \
470 (a)[7] == (b)[7] && \
471 (a)[6] == (b)[6] && \
472 (a)[5] == (b)[5] && \
473 (a)[4] == (b)[4] && \
474 (a)[3] == (b)[3] && \
475 (a)[2] == (b)[2] && \
476 (a)[1] == (b)[1] && \
479 static void fixup_botched_add(int ctlr, char *scsi3addr)
481 /* called when scsi_add_device fails in order to re-adjust */
482 /* ccissscsi[] to match the mid layer's view. */
485 CPQ_TAPE_LOCK(ctlr, flags);
486 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
487 if (memcmp(scsi3addr,
488 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
489 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
490 ccissscsi[ctlr].dev[j] =
491 ccissscsi[ctlr].dev[j+1];
492 ccissscsi[ctlr].ndevices--;
496 CPQ_TAPE_UNLOCK(ctlr, flags);
499 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
500 struct cciss_scsi_dev_t *dev2)
502 return dev1->devtype == dev2->devtype &&
503 memcmp(dev1->scsi3addr, dev2->scsi3addr,
504 sizeof(dev1->scsi3addr)) == 0 &&
505 memcmp(dev1->device_id, dev2->device_id,
506 sizeof(dev1->device_id)) == 0 &&
507 memcmp(dev1->vendor, dev2->vendor,
508 sizeof(dev1->vendor)) == 0 &&
509 memcmp(dev1->model, dev2->model,
510 sizeof(dev1->model)) == 0 &&
511 memcmp(dev1->revision, dev2->revision,
512 sizeof(dev1->revision)) == 0;
516 adjust_cciss_scsi_table(int ctlr, int hostno,
517 struct cciss_scsi_dev_t sd[], int nsds)
519 /* sd contains scsi3 addresses and devtypes, but
520 bus target and lun are not filled in. This funciton
521 takes what's in sd to be the current and adjusts
522 ccissscsi[] to be in line with what's in sd. */
524 int i,j, found, changes=0;
525 struct cciss_scsi_dev_t *csd;
527 struct scsi2map *added, *removed;
528 int nadded, nremoved;
529 struct Scsi_Host *sh = NULL;
531 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
533 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
536 if (!added || !removed) {
537 printk(KERN_WARNING "cciss%d: Out of memory in "
538 "adjust_cciss_scsi_table\n", ctlr);
542 CPQ_TAPE_LOCK(ctlr, flags);
544 if (hostno != -1) /* if it's not the first time... */
545 sh = hba[ctlr]->scsi_ctlr->scsi_host;
547 /* find any devices in ccissscsi[] that are not in
548 sd[] and remove them from ccissscsi[] */
553 while(i<ccissscsi[ctlr].ndevices) {
554 csd = &ccissscsi[ctlr].dev[i];
556 for (j=0;j<nsds;j++) {
557 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
559 if (device_is_the_same(&sd[j], csd))
567 if (found == 0) { /* device no longer present. */
569 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
570 ctlr, scsi_device_type(csd->devtype), hostno,
571 csd->bus, csd->target, csd->lun); */
572 cciss_scsi_remove_entry(ctlr, hostno, i,
574 /* remove ^^^, hence i not incremented */
575 } else if (found == 1) { /* device is different in some way */
577 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
578 ctlr, hostno, csd->bus, csd->target, csd->lun);
579 cciss_scsi_remove_entry(ctlr, hostno, i,
581 /* remove ^^^, hence i not incremented */
582 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
583 added, &nadded) != 0)
584 /* we just removed one, so add can't fail. */
586 csd->devtype = sd[j].devtype;
587 memcpy(csd->device_id, sd[j].device_id,
588 sizeof(csd->device_id));
589 memcpy(csd->vendor, sd[j].vendor,
590 sizeof(csd->vendor));
591 memcpy(csd->model, sd[j].model,
593 memcpy(csd->revision, sd[j].revision,
594 sizeof(csd->revision));
595 } else /* device is same as it ever was, */
596 i++; /* so just move along. */
599 /* Now, make sure every device listed in sd[] is also
600 listed in ccissscsi[], adding them if they aren't found */
602 for (i=0;i<nsds;i++) {
604 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
605 csd = &ccissscsi[ctlr].dev[j];
606 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
608 if (device_is_the_same(&sd[i], csd))
609 found=2; /* found device */
611 found=1; /* found a bug. */
617 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
618 added, &nadded) != 0)
620 } else if (found == 1) {
621 /* should never happen... */
623 printk(KERN_WARNING "cciss%d: device "
624 "unexpectedly changed\n", ctlr);
625 /* but if it does happen, we just ignore that device */
628 CPQ_TAPE_UNLOCK(ctlr, flags);
630 /* Don't notify scsi mid layer of any changes the first time through */
631 /* (or if there are no changes) scsi_scan_host will do it later the */
632 /* first time through. */
633 if (hostno == -1 || !changes)
636 /* Notify scsi mid layer of any removed devices */
637 for (i = 0; i < nremoved; i++) {
638 struct scsi_device *sdev =
639 scsi_device_lookup(sh, removed[i].bus,
640 removed[i].target, removed[i].lun);
642 scsi_remove_device(sdev);
643 scsi_device_put(sdev);
645 /* We don't expect to get here. */
646 /* future cmds to this device will get selection */
647 /* timeout as if the device was gone. */
648 printk(KERN_WARNING "cciss%d: didn't find "
649 "c%db%dt%dl%d\n for removal.",
650 ctlr, hostno, removed[i].bus,
651 removed[i].target, removed[i].lun);
655 /* Notify scsi mid layer of any added devices */
656 for (i = 0; i < nadded; i++) {
658 rc = scsi_add_device(sh, added[i].bus,
659 added[i].target, added[i].lun);
662 printk(KERN_WARNING "cciss%d: scsi_add_device "
663 "c%db%dt%dl%d failed, device not added.\n",
665 added[i].bus, added[i].target, added[i].lun);
666 /* now we have to remove it from ccissscsi, */
667 /* since it didn't get added to scsi mid layer */
668 fixup_botched_add(ctlr, added[i].scsi3addr);
678 lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
681 struct cciss_scsi_dev_t *sd;
684 CPQ_TAPE_LOCK(ctlr, flags);
685 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
686 sd = &ccissscsi[ctlr].dev[i];
687 if (sd->bus == bus &&
688 sd->target == target &&
690 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
691 CPQ_TAPE_UNLOCK(ctlr, flags);
695 CPQ_TAPE_UNLOCK(ctlr, flags);
700 cciss_scsi_setup(int cntl_num)
702 struct cciss_scsi_adapter_data_t * shba;
704 ccissscsi[cntl_num].ndevices = 0;
705 shba = (struct cciss_scsi_adapter_data_t *)
706 kmalloc(sizeof(*shba), GFP_KERNEL);
709 shba->scsi_host = NULL;
710 spin_lock_init(&shba->lock);
711 shba->registered = 0;
712 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
716 hba[cntl_num]->scsi_ctlr = shba;
721 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
723 struct scsi_cmnd *cmd;
725 ErrorInfo_struct *ei;
729 /* First, see if it was a message rather than a command */
730 if (cp->Request.Type.Type == TYPE_MSG) {
731 cp->cmd_type = CMD_MSG_DONE;
735 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
736 ctlr = hba[cp->ctlr];
739 if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
740 cciss_unmap_sg_chain_block(ctlr, cp);
742 cmd->result = (DID_OK << 16); /* host byte */
743 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
744 /* cmd->result |= (GOOD < 1); */ /* status byte */
746 cmd->result |= (ei->ScsiStatus);
747 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
749 /* copy the sense data whether we need to or not. */
751 memcpy(cmd->sense_buffer, ei->SenseInfo,
752 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
753 SCSI_SENSE_BUFFERSIZE :
755 scsi_set_resid(cmd, ei->ResidualCnt);
757 if(ei->CommandStatus != 0)
758 { /* an error has occurred */
759 switch(ei->CommandStatus)
761 case CMD_TARGET_STATUS:
762 /* Pass it up to the upper layers... */
766 printk(KERN_WARNING "cciss: cmd %p "
767 "has SCSI Status = %x\n",
771 cmd->result |= (ei->ScsiStatus << 1);
773 else { /* scsi status is zero??? How??? */
775 /* Ordinarily, this case should never happen, but there is a bug
776 in some released firmware revisions that allows it to happen
777 if, for example, a 4100 backplane loses power and the tape
778 drive is in it. We assume that it's a fatal error of some
779 kind because we can't show that it wasn't. We will make it
780 look like selection timeout since that is the most common
781 reason for this to occur, and it's severe enough. */
783 cmd->result = DID_NO_CONNECT << 16;
786 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
788 case CMD_DATA_OVERRUN:
789 printk(KERN_WARNING "cciss: cp %p has"
790 " completed with data overrun "
794 /* print_bytes(cp, sizeof(*cp), 1, 0);
796 /* We get CMD_INVALID if you address a non-existent tape drive instead
797 of a selection timeout (no response). You will see this if you yank
798 out a tape drive, then try to access it. This is kind of a shame
799 because it means that any other CMD_INVALID (e.g. driver bug) will
800 get interpreted as a missing target. */
801 cmd->result = DID_NO_CONNECT << 16;
804 case CMD_PROTOCOL_ERR:
805 printk(KERN_WARNING "cciss: cp %p has "
806 "protocol error \n", cp);
808 case CMD_HARDWARE_ERR:
809 cmd->result = DID_ERROR << 16;
810 printk(KERN_WARNING "cciss: cp %p had "
811 " hardware error\n", cp);
813 case CMD_CONNECTION_LOST:
814 cmd->result = DID_ERROR << 16;
815 printk(KERN_WARNING "cciss: cp %p had "
816 "connection lost\n", cp);
819 cmd->result = DID_ABORT << 16;
820 printk(KERN_WARNING "cciss: cp %p was "
823 case CMD_ABORT_FAILED:
824 cmd->result = DID_ERROR << 16;
825 printk(KERN_WARNING "cciss: cp %p reports "
826 "abort failed\n", cp);
828 case CMD_UNSOLICITED_ABORT:
829 cmd->result = DID_ABORT << 16;
830 printk(KERN_WARNING "cciss: cp %p aborted "
831 "do to an unsolicited abort\n", cp);
834 cmd->result = DID_TIME_OUT << 16;
835 printk(KERN_WARNING "cciss: cp %p timedout\n",
839 cmd->result = DID_ERROR << 16;
840 printk(KERN_WARNING "cciss: cp %p returned "
841 "unknown status %x\n", cp,
845 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
846 // cmd->target, cmd->lun);
848 scsi_cmd_free(ctlr, cp);
852 cciss_scsi_detect(int ctlr)
854 struct Scsi_Host *sh;
857 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
860 sh->io_port = 0; // good enough? FIXME,
861 sh->n_io_port = 0; // I don't think we use these two...
862 sh->this_id = SELF_SCSI_ID;
863 sh->sg_tablesize = hba[ctlr]->maxsgentries;
864 sh->max_cmd_len = MAX_COMMAND_SIZE;
866 ((struct cciss_scsi_adapter_data_t *)
867 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
868 sh->hostdata[0] = (unsigned long) hba[ctlr];
869 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
870 sh->unique_id = sh->irq;
871 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
884 cciss_unmap_one(struct pci_dev *pdev,
885 CommandList_struct *cp,
891 addr64.val32.lower = cp->SG[0].Addr.lower;
892 addr64.val32.upper = cp->SG[0].Addr.upper;
893 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
897 cciss_map_one(struct pci_dev *pdev,
898 CommandList_struct *cp,
905 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
906 cp->SG[0].Addr.lower =
907 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
908 cp->SG[0].Addr.upper =
909 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
910 cp->SG[0].Len = buflen;
911 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
912 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
916 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
917 CommandList_struct *cp,
918 unsigned char *scsi3addr,
920 unsigned char cdblen,
921 unsigned char *buf, int bufsize,
924 DECLARE_COMPLETION_ONSTACK(wait);
926 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl
928 cp->Header.ReplyQueue = 0; // unused in simple mode
929 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
930 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
931 // Fill in the request block...
933 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
934 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
935 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
937 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
938 memcpy(cp->Request.CDB, cdb, cdblen);
939 cp->Request.Timeout = 0;
940 cp->Request.CDBLen = cdblen;
941 cp->Request.Type.Type = TYPE_CMD;
942 cp->Request.Type.Attribute = ATTR_SIMPLE;
943 cp->Request.Type.Direction = direction;
945 /* Fill in the SG list and do dma mapping */
946 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
947 bufsize, DMA_FROM_DEVICE);
950 enqueue_cmd_and_start_io(c, cp);
951 wait_for_completion(&wait);
953 /* undo the dma mapping */
954 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
959 cciss_scsi_interpret_error(CommandList_struct *cp)
961 ErrorInfo_struct *ei;
964 switch(ei->CommandStatus)
966 case CMD_TARGET_STATUS:
967 printk(KERN_WARNING "cciss: cmd %p has "
968 "completed with errors\n", cp);
969 printk(KERN_WARNING "cciss: cmd %p "
970 "has SCSI Status = %x\n",
973 if (ei->ScsiStatus == 0)
975 "cciss:SCSI status is abnormally zero. "
976 "(probably indicates selection timeout "
977 "reported incorrectly due to a known "
978 "firmware bug, circa July, 2001.)\n");
980 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
981 printk("UNDERRUN\n");
983 case CMD_DATA_OVERRUN:
984 printk(KERN_WARNING "cciss: cp %p has"
985 " completed with data overrun "
989 /* controller unfortunately reports SCSI passthru's */
990 /* to non-existent targets as invalid commands. */
991 printk(KERN_WARNING "cciss: cp %p is "
992 "reported invalid (probably means "
993 "target device no longer present)\n",
995 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
999 case CMD_PROTOCOL_ERR:
1000 printk(KERN_WARNING "cciss: cp %p has "
1001 "protocol error \n", cp);
1003 case CMD_HARDWARE_ERR:
1004 /* cmd->result = DID_ERROR << 16; */
1005 printk(KERN_WARNING "cciss: cp %p had "
1006 " hardware error\n", cp);
1008 case CMD_CONNECTION_LOST:
1009 printk(KERN_WARNING "cciss: cp %p had "
1010 "connection lost\n", cp);
1013 printk(KERN_WARNING "cciss: cp %p was "
1016 case CMD_ABORT_FAILED:
1017 printk(KERN_WARNING "cciss: cp %p reports "
1018 "abort failed\n", cp);
1020 case CMD_UNSOLICITED_ABORT:
1021 printk(KERN_WARNING "cciss: cp %p aborted "
1022 "do to an unsolicited abort\n", cp);
1025 printk(KERN_WARNING "cciss: cp %p timedout\n",
1029 printk(KERN_WARNING "cciss: cp %p returned "
1030 "unknown status %x\n", cp,
1036 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1037 unsigned char page, unsigned char *buf,
1038 unsigned char bufsize)
1041 CommandList_struct *cp;
1043 ErrorInfo_struct *ei;
1044 unsigned long flags;
1046 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1047 cp = scsi_cmd_alloc(c);
1048 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1050 if (cp == NULL) { /* trouble... */
1051 printk("cmd_alloc returned NULL!\n");
1057 cdb[0] = CISS_INQUIRY;
1058 cdb[1] = (page != 0);
1063 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
1064 6, buf, bufsize, XFER_READ);
1066 if (rc != 0) return rc; /* something went wrong */
1068 if (ei->CommandStatus != 0 &&
1069 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1070 cciss_scsi_interpret_error(cp);
1073 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1074 scsi_cmd_free(c, cp);
1075 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1079 /* Get the device id from inquiry page 0x83 */
1080 static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1081 unsigned char *device_id, int buflen)
1088 buf = kzalloc(64, GFP_KERNEL);
1091 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1093 memcpy(device_id, &buf[8], buflen);
1099 cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1100 ReportLunData_struct *buf, int bufsize)
1103 CommandList_struct *cp;
1104 unsigned char cdb[12];
1105 unsigned char scsi3addr[8];
1106 ErrorInfo_struct *ei;
1107 unsigned long flags;
1109 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1110 cp = scsi_cmd_alloc(c);
1111 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1112 if (cp == NULL) { /* trouble... */
1113 printk("cmd_alloc returned NULL!\n");
1117 memset(&scsi3addr[0], 0, 8); /* address the controller */
1118 cdb[0] = CISS_REPORT_PHYS;
1124 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1125 cdb[7] = (bufsize >> 16) & 0xFF;
1126 cdb[8] = (bufsize >> 8) & 0xFF;
1127 cdb[9] = bufsize & 0xFF;
1131 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1133 (unsigned char *) buf,
1134 bufsize, XFER_READ);
1136 if (rc != 0) return rc; /* something went wrong */
1139 if (ei->CommandStatus != 0 &&
1140 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1141 cciss_scsi_interpret_error(cp);
1144 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1145 scsi_cmd_free(c, cp);
1146 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1151 cciss_update_non_disk_devices(int cntl_num, int hostno)
1153 /* the idea here is we could get notified from /proc
1154 that some devices have changed, so we do a report
1155 physical luns cmd, and adjust our list of devices
1156 accordingly. (We can't rely on the scsi-mid layer just
1157 doing inquiries, because the "busses" that the scsi
1158 mid-layer probes are totally fabricated by this driver,
1159 so new devices wouldn't show up.
1161 the scsi3addr's of devices won't change so long as the
1162 adapter is not reset. That means we can rescan and
1163 tell which devices we already know about, vs. new
1164 devices, vs. disappearing devices.
1166 Also, if you yank out a tape drive, then put in a disk
1167 in it's place, (say, a configured volume from another
1168 array controller for instance) _don't_ poke this driver
1169 (so it thinks it's still a tape, but _do_ poke the scsi
1170 mid layer, so it does an inquiry... the scsi mid layer
1171 will see the physical disk. This would be bad. Need to
1172 think about how to prevent that. One idea would be to
1173 snoop all scsi responses and if an inquiry repsonse comes
1174 back that reports a disk, chuck it an return selection
1175 timeout instead and adjust our table... Not sure i like
1179 #define OBDR_TAPE_INQ_SIZE 49
1180 #define OBDR_TAPE_SIG "$DR-10"
1181 ReportLunData_struct *ld_buff;
1182 unsigned char *inq_buff;
1183 unsigned char scsi3addr[8];
1187 struct cciss_scsi_dev_t *currentsd, *this_device;
1189 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1192 c = (ctlr_info_t *) hba[cntl_num];
1193 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1194 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1195 currentsd = kzalloc(sizeof(*currentsd) *
1196 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1197 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1198 printk(KERN_ERR "cciss: out of memory\n");
1201 this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1202 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1203 ch = &ld_buff->LUNListLength[0];
1204 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1205 if (num_luns > CISS_MAX_PHYS_LUN) {
1207 "cciss: Maximum physical LUNs (%d) exceeded. "
1208 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1209 num_luns - CISS_MAX_PHYS_LUN);
1210 num_luns = CISS_MAX_PHYS_LUN;
1214 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1219 /* adjust our table of devices */
1220 for (i = 0; i < num_luns; i++) {
1221 /* for each physical lun, do an inquiry */
1222 if (ld_buff->LUN[i][3] & 0xC0) continue;
1223 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1224 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1226 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1227 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1228 /* Inquiry failed (msg printed already) */
1229 continue; /* so we will skip this device. */
1231 this_device->devtype = (inq_buff[0] & 0x1f);
1232 this_device->bus = -1;
1233 this_device->target = -1;
1234 this_device->lun = -1;
1235 memcpy(this_device->scsi3addr, scsi3addr, 8);
1236 memcpy(this_device->vendor, &inq_buff[8],
1237 sizeof(this_device->vendor));
1238 memcpy(this_device->model, &inq_buff[16],
1239 sizeof(this_device->model));
1240 memcpy(this_device->revision, &inq_buff[32],
1241 sizeof(this_device->revision));
1242 memset(this_device->device_id, 0,
1243 sizeof(this_device->device_id));
1244 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1245 this_device->device_id, sizeof(this_device->device_id));
1247 switch (this_device->devtype)
1249 case 0x05: /* CD-ROM */ {
1251 /* We don't *really* support actual CD-ROM devices,
1252 * just this "One Button Disaster Recovery" tape drive
1253 * which temporarily pretends to be a CD-ROM drive.
1254 * So we check that the device is really an OBDR tape
1255 * device by checking for "$DR-10" in bytes 43-48 of
1260 strncpy(obdr_sig, &inq_buff[43], 6);
1262 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1263 /* Not OBDR device, ignore it. */
1266 /* fall through . . . */
1267 case 0x01: /* sequential access, (tape) */
1268 case 0x08: /* medium changer */
1269 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1270 printk(KERN_INFO "cciss%d: %s ignored, "
1271 "too many devices.\n", cntl_num,
1272 scsi_device_type(this_device->devtype));
1275 currentsd[ncurrent] = *this_device;
1283 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1292 is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1294 int verb_len = strlen(verb);
1295 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1302 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1306 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1307 cciss_update_non_disk_devices(ctlr, hostno);
1315 cciss_scsi_proc_info(struct Scsi_Host *sh,
1316 char *buffer, /* data buffer */
1317 char **start, /* where data in buffer starts */
1318 off_t offset, /* offset from start of imaginary file */
1319 int length, /* length of data in buffer */
1320 int func) /* 0 == read, 1 == write */
1323 int buflen, datalen;
1329 ci = (ctlr_info_t *) sh->hostdata[0];
1330 if (ci == NULL) /* This really shouldn't ever happen. */
1333 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1335 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1336 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1337 cntl_num, sh->host_no);
1339 /* this information is needed by apps to know which cciss
1340 device corresponds to which scsi host number without
1341 having to open a scsi target device node. The device
1342 information is not a duplicate of /proc/scsi/scsi because
1343 the two may be out of sync due to scsi hotplug, rather
1344 this info is for an app to be able to use to know how to
1345 get them back in sync. */
1347 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1348 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1349 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1350 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1351 sh->host_no, sd->bus, sd->target, sd->lun,
1353 sd->scsi3addr[0], sd->scsi3addr[1],
1354 sd->scsi3addr[2], sd->scsi3addr[3],
1355 sd->scsi3addr[4], sd->scsi3addr[5],
1356 sd->scsi3addr[6], sd->scsi3addr[7]);
1358 datalen = buflen - offset;
1359 if (datalen < 0) { /* they're reading past EOF. */
1361 *start = buffer+buflen;
1363 *start = buffer + offset;
1365 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1366 return cciss_scsi_user_command(cntl_num, sh->host_no,
1370 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1371 dma mapping and fills in the scatter gather entries of the
1372 cciss command, cp. */
1374 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1375 struct scsi_cmnd *cmd)
1378 struct scatterlist *sg;
1380 int request_nsgs, i, chained, sg_index;
1381 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1382 SGDescriptor_struct *curr_sg;
1384 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1389 request_nsgs = scsi_dma_map(cmd);
1391 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1392 if (sg_index + 1 == h->max_cmd_sgentries &&
1393 !chained && request_nsgs - i > 1) {
1396 curr_sg = sa->cmd_sg_list[cp->cmdindex];
1398 addr64 = (__u64) sg_dma_address(sg);
1399 len = sg_dma_len(sg);
1400 curr_sg[sg_index].Addr.lower =
1401 (__u32) (addr64 & 0x0FFFFFFFFULL);
1402 curr_sg[sg_index].Addr.upper =
1403 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1404 curr_sg[sg_index].Len = len;
1405 curr_sg[sg_index].Ext = 0;
1409 cciss_map_sg_chain_block(h, cp,
1410 sa->cmd_sg_list[cp->cmdindex],
1411 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1412 sizeof(SGDescriptor_struct));
1414 /* track how many SG entries we are using */
1415 if (request_nsgs > h->maxSG)
1416 h->maxSG = request_nsgs;
1417 cp->Header.SGTotal = (__u8) request_nsgs + chained;
1418 if (request_nsgs > h->max_cmd_sgentries)
1419 cp->Header.SGList = h->max_cmd_sgentries;
1421 cp->Header.SGList = cp->Header.SGTotal;
1427 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1431 unsigned char scsi3addr[8];
1432 CommandList_struct *cp;
1433 unsigned long flags;
1435 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1436 // We violate cmd->host privacy here. (Is there another way?)
1437 c = (ctlr_info_t *) cmd->device->host->hostdata[0];
1440 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1441 cmd->device->lun, scsi3addr);
1443 /* the scsi nexus does not match any that we presented... */
1444 /* pretend to mid layer that we got selection timeout */
1445 cmd->result = DID_NO_CONNECT << 16;
1447 /* we might want to think about registering controller itself
1448 as a processor device on the bus so sg binds to it. */
1452 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1453 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1454 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1455 // cmd->target, cmd->lun);
1457 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1458 see what the device thinks of it. */
1460 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1461 cp = scsi_cmd_alloc(c);
1462 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1463 if (cp == NULL) { /* trouble... */
1464 printk("scsi_cmd_alloc returned NULL!\n");
1465 /* FIXME: next 3 lines are -> BAD! <- */
1466 cmd->result = DID_NO_CONNECT << 16;
1471 // Fill in the command list header
1473 cmd->scsi_done = done; // save this for use by completion code
1475 // save cp in case we have to abort it
1476 cmd->host_scribble = (unsigned char *) cp;
1478 cp->cmd_type = CMD_SCSI;
1480 cp->Header.ReplyQueue = 0; // unused in simple mode
1481 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1482 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
1484 // Fill in the request block...
1486 cp->Request.Timeout = 0;
1487 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1488 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1489 cp->Request.CDBLen = cmd->cmd_len;
1490 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1491 cp->Request.Type.Type = TYPE_CMD;
1492 cp->Request.Type.Attribute = ATTR_SIMPLE;
1493 switch(cmd->sc_data_direction)
1495 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1496 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1497 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1498 case DMA_BIDIRECTIONAL:
1499 // This can happen if a buggy application does a scsi passthru
1500 // and sets both inlen and outlen to non-zero. ( see
1501 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1503 cp->Request.Type.Direction = XFER_RSVD;
1504 // This is technically wrong, and cciss controllers should
1505 // reject it with CMD_INVALID, which is the most correct
1506 // response, but non-fibre backends appear to let it
1507 // slide by, and give the same results as if this field
1508 // were set correctly. Either way is acceptable for
1509 // our purposes here.
1514 printk("cciss: unknown data direction: %d\n",
1515 cmd->sc_data_direction);
1519 cciss_scatter_gather(c, cp, cmd);
1520 enqueue_cmd_and_start_io(c, cp);
1521 /* the cmd'll come back via intr handler in complete_scsi_command() */
1526 cciss_unregister_scsi(int ctlr)
1528 struct cciss_scsi_adapter_data_t *sa;
1529 struct cciss_scsi_cmd_stack_t *stk;
1530 unsigned long flags;
1532 /* we are being forcibly unloaded, and may not refuse. */
1534 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1535 sa = hba[ctlr]->scsi_ctlr;
1536 stk = &sa->cmd_stack;
1538 /* if we weren't ever actually registered, don't unregister */
1539 if (sa->registered) {
1540 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1541 scsi_remove_host(sa->scsi_host);
1542 scsi_host_put(sa->scsi_host);
1543 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1546 /* set scsi_host to NULL so our detect routine will
1547 find us on register */
1548 sa->scsi_host = NULL;
1549 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1550 scsi_cmd_stack_free(ctlr);
1555 cciss_engage_scsi(int ctlr)
1557 struct cciss_scsi_adapter_data_t *sa;
1558 struct cciss_scsi_cmd_stack_t *stk;
1559 unsigned long flags;
1561 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1562 sa = hba[ctlr]->scsi_ctlr;
1563 stk = &sa->cmd_stack;
1565 if (sa->registered) {
1566 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1567 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1571 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1572 cciss_update_non_disk_devices(ctlr, -1);
1573 cciss_scsi_detect(ctlr);
1578 cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1580 unsigned long flags;
1582 CPQ_TAPE_LOCK(ctlr, flags);
1584 "Sequential access devices: %d\n\n",
1585 ccissscsi[ctlr].ndevices);
1586 CPQ_TAPE_UNLOCK(ctlr, flags);
1589 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1590 unsigned char lunaddr[])
1595 CommandList_struct *c;
1597 c = cmd_alloc(h, 1);
1599 printk(KERN_WARNING "cciss%d: out of memory in "
1600 "wait_for_device_to_become_ready.\n", h->ctlr);
1604 /* Send test unit ready until device ready, or give up. */
1605 while (count < 20) {
1607 /* Wait for a bit. do this first, because if we send
1608 * the TUR right away, the reset will just abort it.
1610 schedule_timeout_uninterruptible(waittime);
1613 /* Increase wait time with each try, up to a point. */
1614 if (waittime < (HZ * 30))
1615 waittime = waittime * 2;
1617 /* Send the Test Unit Ready */
1618 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1621 rc = sendcmd_withirq_core(h, c, 0);
1623 (void) process_sendcmd_error(h, c);
1628 if (c->err_info->CommandStatus == CMD_SUCCESS)
1631 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1632 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1633 if (c->err_info->SenseInfo[2] == NO_SENSE)
1635 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1637 asc = c->err_info->SenseInfo[12];
1638 check_for_unit_attention(h, c);
1639 if (asc == POWER_OR_RESET)
1644 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1645 "for device to become ready.\n",
1646 h->ctlr, waittime / HZ);
1647 rc = 1; /* device not ready. */
1651 printk("cciss%d: giving up on device.\n", h->ctlr);
1653 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1659 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1660 * complaining. Doing a host- or bus-reset can't do anything good here.
1661 * Despite what it might say in scsi_error.c, there may well be commands
1662 * on the controller, as the cciss driver registers twice, once as a block
1663 * device for the logical drives, and once as a scsi device, for any tape
1664 * drives. So we know there are no commands out on the tape drives, but we
1665 * don't know there are no commands on the controller, and it is likely
1666 * that there probably are, as the cciss block device is most commonly used
1667 * as a boot device (embedded controller on HP/Compaq systems.)
1670 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1673 CommandList_struct *cmd_in_trouble;
1674 unsigned char lunaddr[8];
1678 /* find the controller to which the command to be aborted was sent */
1679 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1680 if (c == NULL) /* paranoia */
1683 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1684 /* find the command that's giving us trouble */
1685 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1686 if (cmd_in_trouble == NULL) /* paranoia */
1688 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1689 /* send a reset to the SCSI LUN which the command was sent to */
1690 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1692 if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
1694 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1698 static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1701 CommandList_struct *cmd_to_abort;
1702 unsigned char lunaddr[8];
1706 /* find the controller to which the command to be aborted was sent */
1707 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1708 if (c == NULL) /* paranoia */
1711 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1713 /* find the command to be aborted */
1714 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1715 if (cmd_to_abort == NULL) /* paranoia */
1717 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1718 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1719 0, 0, lunaddr, TYPE_MSG);
1726 #else /* no CONFIG_CISS_SCSI_TAPE */
1728 /* If no tape support, then these become defined out of existence */
1730 #define cciss_scsi_setup(cntl_num)
1732 #endif /* CONFIG_CISS_SCSI_TAPE */