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_write_info(struct Scsi_Host *sh,
58 char *buffer, /* data buffer */
59 int length); /* length of data in buffer */
60 static int cciss_scsi_show_info(struct seq_file *m,
61 struct Scsi_Host *sh);
63 static int cciss_scsi_queue_command (struct Scsi_Host *h,
64 struct scsi_cmnd *cmd);
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 .write_info = cciss_scsi_write_info,
84 .show_info = cciss_scsi_show_info,
85 .queuecommand = cciss_scsi_queue_command,
87 .use_clustering = DISABLE_CLUSTERING,
88 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
89 .eh_device_reset_handler= cciss_eh_device_reset_handler,
90 .eh_abort_handler = cciss_eh_abort_handler,
98 struct cciss_scsi_cmd_stack_elem_t {
99 CommandList_struct cmd;
100 ErrorInfo_struct Err;
103 u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
109 struct cciss_scsi_cmd_stack_t {
110 struct cciss_scsi_cmd_stack_elem_t *pool;
111 struct cciss_scsi_cmd_stack_elem_t **elem;
112 dma_addr_t cmd_pool_handle;
118 struct cciss_scsi_adapter_data_t {
119 struct Scsi_Host *scsi_host;
120 struct cciss_scsi_cmd_stack_t cmd_stack;
121 SGDescriptor_struct **cmd_sg_list;
123 spinlock_t lock; // to protect ccissscsi[ctlr];
126 #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
127 &h->scsi_ctlr->lock, flags);
128 #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
129 &h->scsi_ctlr->lock, flags);
131 static CommandList_struct *
132 scsi_cmd_alloc(ctlr_info_t *h)
134 /* assume only one process in here at a time, locking done by caller. */
136 /* might be better to rewrite how we allocate scsi commands in a way that */
137 /* needs no locking at all. */
139 /* take the top memory chunk off the stack and return it, if any. */
140 struct cciss_scsi_cmd_stack_elem_t *c;
141 struct cciss_scsi_adapter_data_t *sa;
142 struct cciss_scsi_cmd_stack_t *stk;
146 stk = &sa->cmd_stack;
150 c = stk->elem[stk->top];
151 /* memset(c, 0, sizeof(*c)); */
152 memset(&c->cmd, 0, sizeof(c->cmd));
153 memset(&c->Err, 0, sizeof(c->Err));
154 /* set physical addr of cmd and addr of scsi parameters */
155 c->cmd.busaddr = c->busaddr;
156 c->cmd.cmdindex = c->cmdindex;
157 /* (__u32) (stk->cmd_pool_handle +
158 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
160 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
161 /* (__u64) (stk->cmd_pool_handle +
162 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
163 sizeof(CommandList_struct)); */
165 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
166 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
167 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
169 c->cmd.ctlr = h->ctlr;
170 c->cmd.err_info = &c->Err;
172 return (CommandList_struct *) c;
176 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
178 /* assume only one process in here at a time, locking done by caller. */
180 /* drop the free memory chunk on top of the stack. */
182 struct cciss_scsi_adapter_data_t *sa;
183 struct cciss_scsi_cmd_stack_t *stk;
186 stk = &sa->cmd_stack;
188 if (stk->top >= stk->nelems) {
189 dev_err(&h->pdev->dev,
190 "scsi_cmd_free called too many times.\n");
193 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
197 scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
200 struct cciss_scsi_cmd_stack_t *stk;
203 stk = &sa->cmd_stack;
204 stk->nelems = cciss_tape_cmds + 2;
205 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
206 h->chainsize, stk->nelems);
207 if (!sa->cmd_sg_list && h->chainsize > 0)
210 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
212 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
213 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
214 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
215 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
216 pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
218 if (stk->pool == NULL) {
219 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
220 sa->cmd_sg_list = NULL;
223 stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL);
225 pci_free_consistent(h->pdev, size, stk->pool,
226 stk->cmd_pool_handle);
229 for (i = 0; i < stk->nelems; i++) {
230 stk->elem[i] = &stk->pool[i];
231 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
232 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
233 stk->elem[i]->cmdindex = i;
235 stk->top = stk->nelems-1;
240 scsi_cmd_stack_free(ctlr_info_t *h)
242 struct cciss_scsi_adapter_data_t *sa;
243 struct cciss_scsi_cmd_stack_t *stk;
247 stk = &sa->cmd_stack;
248 if (stk->top != stk->nelems-1) {
249 dev_warn(&h->pdev->dev,
250 "bug: %d scsi commands are still outstanding.\n",
251 stk->nelems - stk->top);
253 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
255 pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
257 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
264 print_cmd(CommandList_struct *cp)
266 printk("queue:%d\n", cp->Header.ReplyQueue);
267 printk("sglist:%d\n", cp->Header.SGList);
268 printk("sgtot:%d\n", cp->Header.SGTotal);
269 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
270 cp->Header.Tag.lower);
271 printk("LUN:0x%8phN\n", cp->Header.LUN.LunAddrBytes);
272 printk("CDBLen:%d\n", cp->Request.CDBLen);
273 printk("Type:%d\n",cp->Request.Type.Type);
274 printk("Attr:%d\n",cp->Request.Type.Attribute);
275 printk(" Dir:%d\n",cp->Request.Type.Direction);
276 printk("Timeout:%d\n",cp->Request.Timeout);
277 printk("CDB: %16ph\n", cp->Request.CDB);
278 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
279 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
281 printk("sgs..........Errorinfo:\n");
282 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
283 printk("senselen:%d\n", cp->err_info->SenseLen);
284 printk("cmd status:%d\n", cp->err_info->CommandStatus);
285 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
286 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
287 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
288 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
293 find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
295 /* finds an unused bus, target, lun for a new device */
296 /* assumes h->scsi_ctlr->lock is held */
298 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
300 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
302 target_taken[SELF_SCSI_ID] = 1;
303 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
304 target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
306 for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
307 if (!target_taken[i]) {
308 *bus = 0; *target=i; *lun = 0; found=1;
316 int bus, target, lun;
320 cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
321 struct cciss_scsi_dev_t *device,
322 struct scsi2map *added, int *nadded)
324 /* assumes h->scsi_ctlr->lock is held */
325 int n = ccissscsi[h->ctlr].ndevices;
326 struct cciss_scsi_dev_t *sd;
327 int i, bus, target, lun;
328 unsigned char addr1[8], addr2[8];
330 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
331 dev_warn(&h->pdev->dev, "Too many devices, "
332 "some will be inaccessible.\n");
338 /* Is this device a non-zero lun of a multi-lun device */
339 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
340 if (device->scsi3addr[4] != 0) {
341 /* Search through our list and find the device which */
342 /* has the same 8 byte LUN address, excepting byte 4. */
343 /* Assign the same bus and target for this new LUN. */
344 /* Use the logical unit number from the firmware. */
345 memcpy(addr1, device->scsi3addr, 8);
347 for (i = 0; i < n; i++) {
348 sd = &ccissscsi[h->ctlr].dev[i];
349 memcpy(addr2, sd->scsi3addr, 8);
351 /* differ only in byte 4? */
352 if (memcmp(addr1, addr2, 8) == 0) {
355 lun = device->scsi3addr[4];
361 sd = &ccissscsi[h->ctlr].dev[n];
363 if (find_bus_target_lun(h,
364 &sd->bus, &sd->target, &sd->lun) != 0)
371 added[*nadded].bus = sd->bus;
372 added[*nadded].target = sd->target;
373 added[*nadded].lun = sd->lun;
376 memcpy(sd->scsi3addr, device->scsi3addr, 8);
377 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
378 memcpy(sd->revision, device->revision, sizeof(sd->revision));
379 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
380 sd->devtype = device->devtype;
382 ccissscsi[h->ctlr].ndevices++;
384 /* initially, (before registering with scsi layer) we don't
385 know our hostno and we don't want to print anything first
386 time anyway (the scsi layer's inquiries will show that info) */
388 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
389 scsi_device_type(sd->devtype), hostno,
390 sd->bus, sd->target, sd->lun);
395 cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
396 struct scsi2map *removed, int *nremoved)
398 /* assumes h->ctlr]->scsi_ctlr->lock is held */
400 struct cciss_scsi_dev_t sd;
402 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
403 sd = ccissscsi[h->ctlr].dev[entry];
404 removed[*nremoved].bus = sd.bus;
405 removed[*nremoved].target = sd.target;
406 removed[*nremoved].lun = sd.lun;
408 for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
409 ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
410 ccissscsi[h->ctlr].ndevices--;
411 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
412 scsi_device_type(sd.devtype), hostno,
413 sd.bus, sd.target, sd.lun);
417 #define SCSI3ADDR_EQ(a,b) ( \
418 (a)[7] == (b)[7] && \
419 (a)[6] == (b)[6] && \
420 (a)[5] == (b)[5] && \
421 (a)[4] == (b)[4] && \
422 (a)[3] == (b)[3] && \
423 (a)[2] == (b)[2] && \
424 (a)[1] == (b)[1] && \
427 static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
429 /* called when scsi_add_device fails in order to re-adjust */
430 /* ccissscsi[] to match the mid layer's view. */
433 CPQ_TAPE_LOCK(h, flags);
434 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
435 if (memcmp(scsi3addr,
436 ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
437 for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
438 ccissscsi[h->ctlr].dev[j] =
439 ccissscsi[h->ctlr].dev[j+1];
440 ccissscsi[h->ctlr].ndevices--;
444 CPQ_TAPE_UNLOCK(h, flags);
447 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
448 struct cciss_scsi_dev_t *dev2)
450 return dev1->devtype == dev2->devtype &&
451 memcmp(dev1->scsi3addr, dev2->scsi3addr,
452 sizeof(dev1->scsi3addr)) == 0 &&
453 memcmp(dev1->device_id, dev2->device_id,
454 sizeof(dev1->device_id)) == 0 &&
455 memcmp(dev1->vendor, dev2->vendor,
456 sizeof(dev1->vendor)) == 0 &&
457 memcmp(dev1->model, dev2->model,
458 sizeof(dev1->model)) == 0 &&
459 memcmp(dev1->revision, dev2->revision,
460 sizeof(dev1->revision)) == 0;
464 adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
465 struct cciss_scsi_dev_t sd[], int nsds)
467 /* sd contains scsi3 addresses and devtypes, but
468 bus target and lun are not filled in. This funciton
469 takes what's in sd to be the current and adjusts
470 ccissscsi[] to be in line with what's in sd. */
472 int i,j, found, changes=0;
473 struct cciss_scsi_dev_t *csd;
475 struct scsi2map *added, *removed;
476 int nadded, nremoved;
477 struct Scsi_Host *sh = NULL;
479 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
481 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
484 if (!added || !removed) {
485 dev_warn(&h->pdev->dev,
486 "Out of memory in adjust_cciss_scsi_table\n");
490 CPQ_TAPE_LOCK(h, flags);
492 if (hostno != -1) /* if it's not the first time... */
493 sh = h->scsi_ctlr->scsi_host;
495 /* find any devices in ccissscsi[] that are not in
496 sd[] and remove them from ccissscsi[] */
501 while (i < ccissscsi[h->ctlr].ndevices) {
502 csd = &ccissscsi[h->ctlr].dev[i];
504 for (j=0;j<nsds;j++) {
505 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
507 if (device_is_the_same(&sd[j], csd))
515 if (found == 0) { /* device no longer present. */
517 cciss_scsi_remove_entry(h, hostno, i,
519 /* remove ^^^, hence i not incremented */
520 } else if (found == 1) { /* device is different in some way */
522 dev_info(&h->pdev->dev,
523 "device c%db%dt%dl%d has changed.\n",
524 hostno, csd->bus, csd->target, csd->lun);
525 cciss_scsi_remove_entry(h, hostno, i,
527 /* remove ^^^, hence i not incremented */
528 if (cciss_scsi_add_entry(h, hostno, &sd[j],
529 added, &nadded) != 0)
530 /* we just removed one, so add can't fail. */
532 csd->devtype = sd[j].devtype;
533 memcpy(csd->device_id, sd[j].device_id,
534 sizeof(csd->device_id));
535 memcpy(csd->vendor, sd[j].vendor,
536 sizeof(csd->vendor));
537 memcpy(csd->model, sd[j].model,
539 memcpy(csd->revision, sd[j].revision,
540 sizeof(csd->revision));
541 } else /* device is same as it ever was, */
542 i++; /* so just move along. */
545 /* Now, make sure every device listed in sd[] is also
546 listed in ccissscsi[], adding them if they aren't found */
548 for (i=0;i<nsds;i++) {
550 for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
551 csd = &ccissscsi[h->ctlr].dev[j];
552 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
554 if (device_is_the_same(&sd[i], csd))
555 found=2; /* found device */
557 found=1; /* found a bug. */
563 if (cciss_scsi_add_entry(h, hostno, &sd[i],
564 added, &nadded) != 0)
566 } else if (found == 1) {
567 /* should never happen... */
569 dev_warn(&h->pdev->dev,
570 "device unexpectedly changed\n");
571 /* but if it does happen, we just ignore that device */
574 CPQ_TAPE_UNLOCK(h, flags);
576 /* Don't notify scsi mid layer of any changes the first time through */
577 /* (or if there are no changes) scsi_scan_host will do it later the */
578 /* first time through. */
579 if (hostno == -1 || !changes)
582 /* Notify scsi mid layer of any removed devices */
583 for (i = 0; i < nremoved; i++) {
584 struct scsi_device *sdev =
585 scsi_device_lookup(sh, removed[i].bus,
586 removed[i].target, removed[i].lun);
588 scsi_remove_device(sdev);
589 scsi_device_put(sdev);
591 /* We don't expect to get here. */
592 /* future cmds to this device will get selection */
593 /* timeout as if the device was gone. */
594 dev_warn(&h->pdev->dev, "didn't find "
595 "c%db%dt%dl%d\n for removal.",
596 hostno, removed[i].bus,
597 removed[i].target, removed[i].lun);
601 /* Notify scsi mid layer of any added devices */
602 for (i = 0; i < nadded; i++) {
604 rc = scsi_add_device(sh, added[i].bus,
605 added[i].target, added[i].lun);
608 dev_warn(&h->pdev->dev, "scsi_add_device "
609 "c%db%dt%dl%d failed, device not added.\n",
610 hostno, added[i].bus, added[i].target, added[i].lun);
611 /* now we have to remove it from ccissscsi, */
612 /* since it didn't get added to scsi mid layer */
613 fixup_botched_add(h, added[i].scsi3addr);
623 lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
626 struct cciss_scsi_dev_t *sd;
629 CPQ_TAPE_LOCK(h, flags);
630 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
631 sd = &ccissscsi[h->ctlr].dev[i];
632 if (sd->bus == bus &&
633 sd->target == target &&
635 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
636 CPQ_TAPE_UNLOCK(h, flags);
640 CPQ_TAPE_UNLOCK(h, flags);
645 cciss_scsi_setup(ctlr_info_t *h)
647 struct cciss_scsi_adapter_data_t * shba;
649 ccissscsi[h->ctlr].ndevices = 0;
650 shba = (struct cciss_scsi_adapter_data_t *)
651 kmalloc(sizeof(*shba), GFP_KERNEL);
654 shba->scsi_host = NULL;
655 spin_lock_init(&shba->lock);
656 shba->registered = 0;
657 if (scsi_cmd_stack_setup(h, shba) != 0) {
665 static void complete_scsi_command(CommandList_struct *c, int timeout,
668 struct scsi_cmnd *cmd;
670 ErrorInfo_struct *ei;
674 /* First, see if it was a message rather than a command */
675 if (c->Request.Type.Type == TYPE_MSG) {
676 c->cmd_type = CMD_MSG_DONE;
680 cmd = (struct scsi_cmnd *) c->scsi_cmd;
684 if (c->Header.SGTotal > h->max_cmd_sgentries)
685 cciss_unmap_sg_chain_block(h, c);
687 cmd->result = (DID_OK << 16); /* host byte */
688 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
689 /* cmd->result |= (GOOD < 1); */ /* status byte */
691 cmd->result |= (ei->ScsiStatus);
692 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
694 /* copy the sense data whether we need to or not. */
696 memcpy(cmd->sense_buffer, ei->SenseInfo,
697 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
698 SCSI_SENSE_BUFFERSIZE :
700 scsi_set_resid(cmd, ei->ResidualCnt);
702 if(ei->CommandStatus != 0)
703 { /* an error has occurred */
704 switch(ei->CommandStatus)
706 case CMD_TARGET_STATUS:
707 /* Pass it up to the upper layers... */
708 if (!ei->ScsiStatus) {
710 /* Ordinarily, this case should never happen, but there is a bug
711 in some released firmware revisions that allows it to happen
712 if, for example, a 4100 backplane loses power and the tape
713 drive is in it. We assume that it's a fatal error of some
714 kind because we can't show that it wasn't. We will make it
715 look like selection timeout since that is the most common
716 reason for this to occur, and it's severe enough. */
718 cmd->result = DID_NO_CONNECT << 16;
721 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
723 case CMD_DATA_OVERRUN:
724 dev_warn(&h->pdev->dev, "%p has"
725 " completed with data overrun "
730 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, c, sizeof(*c), false);
733 /* We get CMD_INVALID if you address a non-existent tape drive instead
734 of a selection timeout (no response). You will see this if you yank
735 out a tape drive, then try to access it. This is kind of a shame
736 because it means that any other CMD_INVALID (e.g. driver bug) will
737 get interpreted as a missing target. */
738 cmd->result = DID_NO_CONNECT << 16;
741 case CMD_PROTOCOL_ERR:
742 cmd->result = DID_ERROR << 16;
743 dev_warn(&h->pdev->dev,
744 "%p has protocol error\n", c);
746 case CMD_HARDWARE_ERR:
747 cmd->result = DID_ERROR << 16;
748 dev_warn(&h->pdev->dev,
749 "%p had hardware error\n", c);
751 case CMD_CONNECTION_LOST:
752 cmd->result = DID_ERROR << 16;
753 dev_warn(&h->pdev->dev,
754 "%p had connection lost\n", c);
757 cmd->result = DID_ABORT << 16;
758 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
760 case CMD_ABORT_FAILED:
761 cmd->result = DID_ERROR << 16;
762 dev_warn(&h->pdev->dev,
763 "%p reports abort failed\n", c);
765 case CMD_UNSOLICITED_ABORT:
766 cmd->result = DID_ABORT << 16;
767 dev_warn(&h->pdev->dev, "%p aborted due to an "
768 "unsolicited abort\n", c);
771 cmd->result = DID_TIME_OUT << 16;
772 dev_warn(&h->pdev->dev, "%p timedout\n", c);
774 case CMD_UNABORTABLE:
775 cmd->result = DID_ERROR << 16;
776 dev_warn(&h->pdev->dev, "c %p command "
780 cmd->result = DID_ERROR << 16;
781 dev_warn(&h->pdev->dev,
782 "%p returned unknown status %x\n", c,
791 cciss_scsi_detect(ctlr_info_t *h)
793 struct Scsi_Host *sh;
796 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
799 sh->io_port = 0; // good enough? FIXME,
800 sh->n_io_port = 0; // I don't think we use these two...
801 sh->this_id = SELF_SCSI_ID;
802 sh->can_queue = cciss_tape_cmds;
803 sh->sg_tablesize = h->maxsgentries;
804 sh->max_cmd_len = MAX_COMMAND_SIZE;
805 sh->max_sectors = h->cciss_max_sectors;
807 ((struct cciss_scsi_adapter_data_t *)
808 h->scsi_ctlr)->scsi_host = sh;
809 sh->hostdata[0] = (unsigned long) h;
810 sh->irq = h->intr[SIMPLE_MODE_INT];
811 sh->unique_id = sh->irq;
812 error = scsi_add_host(sh, &h->pdev->dev);
825 cciss_unmap_one(struct pci_dev *pdev,
826 CommandList_struct *c,
832 addr64.val32.lower = c->SG[0].Addr.lower;
833 addr64.val32.upper = c->SG[0].Addr.upper;
834 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
838 cciss_map_one(struct pci_dev *pdev,
839 CommandList_struct *c,
846 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
847 c->SG[0].Addr.lower =
848 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
849 c->SG[0].Addr.upper =
850 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
851 c->SG[0].Len = buflen;
852 c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
853 c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
857 cciss_scsi_do_simple_cmd(ctlr_info_t *h,
858 CommandList_struct *c,
859 unsigned char *scsi3addr,
861 unsigned char cdblen,
862 unsigned char *buf, int bufsize,
865 DECLARE_COMPLETION_ONSTACK(wait);
867 c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
869 c->Header.ReplyQueue = 0; /* unused in simple mode */
870 memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
871 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
872 // Fill in the request block...
874 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
875 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
876 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
878 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
879 memcpy(c->Request.CDB, cdb, cdblen);
880 c->Request.Timeout = 0;
881 c->Request.CDBLen = cdblen;
882 c->Request.Type.Type = TYPE_CMD;
883 c->Request.Type.Attribute = ATTR_SIMPLE;
884 c->Request.Type.Direction = direction;
886 /* Fill in the SG list and do dma mapping */
887 cciss_map_one(h->pdev, c, (unsigned char *) buf,
888 bufsize, DMA_FROM_DEVICE);
891 enqueue_cmd_and_start_io(h, c);
892 wait_for_completion(&wait);
894 /* undo the dma mapping */
895 cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
900 cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
902 ErrorInfo_struct *ei;
905 switch(ei->CommandStatus)
907 case CMD_TARGET_STATUS:
908 dev_warn(&h->pdev->dev,
909 "cmd %p has completed with errors\n", c);
910 dev_warn(&h->pdev->dev,
911 "cmd %p has SCSI Status = %x\n",
913 if (ei->ScsiStatus == 0)
914 dev_warn(&h->pdev->dev,
915 "SCSI status is abnormally zero. "
916 "(probably indicates selection timeout "
917 "reported incorrectly due to a known "
918 "firmware bug, circa July, 2001.)\n");
920 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
921 dev_info(&h->pdev->dev, "UNDERRUN\n");
923 case CMD_DATA_OVERRUN:
924 dev_warn(&h->pdev->dev, "%p has"
925 " completed with data overrun "
929 /* controller unfortunately reports SCSI passthru's */
930 /* to non-existent targets as invalid commands. */
931 dev_warn(&h->pdev->dev,
932 "%p is reported invalid (probably means "
933 "target device no longer present)\n", c);
935 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, c, sizeof(*c), false);
940 case CMD_PROTOCOL_ERR:
941 dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
943 case CMD_HARDWARE_ERR:
944 /* cmd->result = DID_ERROR << 16; */
945 dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
947 case CMD_CONNECTION_LOST:
948 dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
951 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
953 case CMD_ABORT_FAILED:
954 dev_warn(&h->pdev->dev,
955 "%p reports abort failed\n", c);
957 case CMD_UNSOLICITED_ABORT:
958 dev_warn(&h->pdev->dev,
959 "%p aborted due to an unsolicited abort\n", c);
962 dev_warn(&h->pdev->dev, "%p timedout\n", c);
964 case CMD_UNABORTABLE:
965 dev_warn(&h->pdev->dev,
966 "%p unabortable\n", c);
969 dev_warn(&h->pdev->dev,
970 "%p returned unknown status %x\n",
971 c, ei->CommandStatus);
976 cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
977 unsigned char page, unsigned char *buf,
978 unsigned char bufsize)
981 CommandList_struct *c;
983 ErrorInfo_struct *ei;
986 spin_lock_irqsave(&h->lock, flags);
987 c = scsi_cmd_alloc(h);
988 spin_unlock_irqrestore(&h->lock, flags);
990 if (c == NULL) { /* trouble... */
991 printk("cmd_alloc returned NULL!\n");
997 cdb[0] = CISS_INQUIRY;
998 cdb[1] = (page != 0);
1003 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1004 6, buf, bufsize, XFER_READ);
1006 if (rc != 0) return rc; /* something went wrong */
1008 if (ei->CommandStatus != 0 &&
1009 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1010 cciss_scsi_interpret_error(h, c);
1013 spin_lock_irqsave(&h->lock, flags);
1014 scsi_cmd_free(h, c);
1015 spin_unlock_irqrestore(&h->lock, flags);
1019 /* Get the device id from inquiry page 0x83 */
1020 static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1021 unsigned char *device_id, int buflen)
1028 buf = kzalloc(64, GFP_KERNEL);
1031 rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1033 memcpy(device_id, &buf[8], buflen);
1039 cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1040 ReportLunData_struct *buf, int bufsize)
1043 CommandList_struct *c;
1044 unsigned char cdb[12];
1045 unsigned char scsi3addr[8];
1046 ErrorInfo_struct *ei;
1047 unsigned long flags;
1049 spin_lock_irqsave(&h->lock, flags);
1050 c = scsi_cmd_alloc(h);
1051 spin_unlock_irqrestore(&h->lock, flags);
1052 if (c == NULL) { /* trouble... */
1053 printk("cmd_alloc returned NULL!\n");
1057 memset(&scsi3addr[0], 0, 8); /* address the controller */
1058 cdb[0] = CISS_REPORT_PHYS;
1064 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1065 cdb[7] = (bufsize >> 16) & 0xFF;
1066 cdb[8] = (bufsize >> 8) & 0xFF;
1067 cdb[9] = bufsize & 0xFF;
1071 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1073 (unsigned char *) buf,
1074 bufsize, XFER_READ);
1076 if (rc != 0) return rc; /* something went wrong */
1079 if (ei->CommandStatus != 0 &&
1080 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1081 cciss_scsi_interpret_error(h, c);
1084 spin_lock_irqsave(&h->lock, flags);
1085 scsi_cmd_free(h, c);
1086 spin_unlock_irqrestore(&h->lock, flags);
1091 cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1093 /* the idea here is we could get notified from /proc
1094 that some devices have changed, so we do a report
1095 physical luns cmd, and adjust our list of devices
1096 accordingly. (We can't rely on the scsi-mid layer just
1097 doing inquiries, because the "busses" that the scsi
1098 mid-layer probes are totally fabricated by this driver,
1099 so new devices wouldn't show up.
1101 the scsi3addr's of devices won't change so long as the
1102 adapter is not reset. That means we can rescan and
1103 tell which devices we already know about, vs. new
1104 devices, vs. disappearing devices.
1106 Also, if you yank out a tape drive, then put in a disk
1107 in it's place, (say, a configured volume from another
1108 array controller for instance) _don't_ poke this driver
1109 (so it thinks it's still a tape, but _do_ poke the scsi
1110 mid layer, so it does an inquiry... the scsi mid layer
1111 will see the physical disk. This would be bad. Need to
1112 think about how to prevent that. One idea would be to
1113 snoop all scsi responses and if an inquiry repsonse comes
1114 back that reports a disk, chuck it an return selection
1115 timeout instead and adjust our table... Not sure i like
1119 #define OBDR_TAPE_INQ_SIZE 49
1120 #define OBDR_TAPE_SIG "$DR-10"
1121 ReportLunData_struct *ld_buff;
1122 unsigned char *inq_buff;
1123 unsigned char scsi3addr[8];
1126 struct cciss_scsi_dev_t *currentsd, *this_device;
1128 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1131 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1132 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1133 currentsd = kzalloc(sizeof(*currentsd) *
1134 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1135 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1136 printk(KERN_ERR "cciss: out of memory\n");
1139 this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1140 if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1141 ch = &ld_buff->LUNListLength[0];
1142 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1143 if (num_luns > CISS_MAX_PHYS_LUN) {
1145 "cciss: Maximum physical LUNs (%d) exceeded. "
1146 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1147 num_luns - CISS_MAX_PHYS_LUN);
1148 num_luns = CISS_MAX_PHYS_LUN;
1152 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1157 /* adjust our table of devices */
1158 for (i = 0; i < num_luns; i++) {
1159 /* for each physical lun, do an inquiry */
1160 if (ld_buff->LUN[i][3] & 0xC0) continue;
1161 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1162 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1164 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1165 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1166 /* Inquiry failed (msg printed already) */
1167 continue; /* so we will skip this device. */
1169 this_device->devtype = (inq_buff[0] & 0x1f);
1170 this_device->bus = -1;
1171 this_device->target = -1;
1172 this_device->lun = -1;
1173 memcpy(this_device->scsi3addr, scsi3addr, 8);
1174 memcpy(this_device->vendor, &inq_buff[8],
1175 sizeof(this_device->vendor));
1176 memcpy(this_device->model, &inq_buff[16],
1177 sizeof(this_device->model));
1178 memcpy(this_device->revision, &inq_buff[32],
1179 sizeof(this_device->revision));
1180 memset(this_device->device_id, 0,
1181 sizeof(this_device->device_id));
1182 cciss_scsi_get_device_id(h, scsi3addr,
1183 this_device->device_id, sizeof(this_device->device_id));
1185 switch (this_device->devtype)
1187 case 0x05: /* CD-ROM */ {
1189 /* We don't *really* support actual CD-ROM devices,
1190 * just this "One Button Disaster Recovery" tape drive
1191 * which temporarily pretends to be a CD-ROM drive.
1192 * So we check that the device is really an OBDR tape
1193 * device by checking for "$DR-10" in bytes 43-48 of
1198 strncpy(obdr_sig, &inq_buff[43], 6);
1200 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1201 /* Not OBDR device, ignore it. */
1204 /* fall through . . . */
1205 case 0x01: /* sequential access, (tape) */
1206 case 0x08: /* medium changer */
1207 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1208 printk(KERN_INFO "cciss%d: %s ignored, "
1209 "too many devices.\n", h->ctlr,
1210 scsi_device_type(this_device->devtype));
1213 currentsd[ncurrent] = *this_device;
1221 adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1230 is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1232 int verb_len = strlen(verb);
1233 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1240 cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1244 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1245 cciss_update_non_disk_devices(h, hostno);
1252 cciss_scsi_write_info(struct Scsi_Host *sh,
1253 char *buffer, /* data buffer */
1254 int length) /* length of data in buffer */
1256 ctlr_info_t *h = (ctlr_info_t *) sh->hostdata[0];
1257 if (h == NULL) /* This really shouldn't ever happen. */
1260 return cciss_scsi_user_command(h, sh->host_no,
1265 cciss_scsi_show_info(struct seq_file *m, struct Scsi_Host *sh)
1268 ctlr_info_t *h = (ctlr_info_t *) sh->hostdata[0];
1271 if (h == NULL) /* This really shouldn't ever happen. */
1274 seq_printf(m, "cciss%d: SCSI host: %d\n",
1275 h->ctlr, sh->host_no);
1277 /* this information is needed by apps to know which cciss
1278 device corresponds to which scsi host number without
1279 having to open a scsi target device node. The device
1280 information is not a duplicate of /proc/scsi/scsi because
1281 the two may be out of sync due to scsi hotplug, rather
1282 this info is for an app to be able to use to know how to
1283 get them back in sync. */
1285 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1286 struct cciss_scsi_dev_t *sd =
1287 &ccissscsi[h->ctlr].dev[i];
1288 seq_printf(m, "c%db%dt%dl%d %02d "
1289 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1290 sh->host_no, sd->bus, sd->target, sd->lun,
1292 sd->scsi3addr[0], sd->scsi3addr[1],
1293 sd->scsi3addr[2], sd->scsi3addr[3],
1294 sd->scsi3addr[4], sd->scsi3addr[5],
1295 sd->scsi3addr[6], sd->scsi3addr[7]);
1300 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1301 dma mapping and fills in the scatter gather entries of the
1302 cciss command, c. */
1304 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1305 struct scsi_cmnd *cmd)
1308 struct scatterlist *sg;
1310 int request_nsgs, i, chained, sg_index;
1311 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1312 SGDescriptor_struct *curr_sg;
1314 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1319 request_nsgs = scsi_dma_map(cmd);
1321 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1322 if (sg_index + 1 == h->max_cmd_sgentries &&
1323 !chained && request_nsgs - i > 1) {
1326 curr_sg = sa->cmd_sg_list[c->cmdindex];
1328 addr64 = (__u64) sg_dma_address(sg);
1329 len = sg_dma_len(sg);
1330 curr_sg[sg_index].Addr.lower =
1331 (__u32) (addr64 & 0x0FFFFFFFFULL);
1332 curr_sg[sg_index].Addr.upper =
1333 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1334 curr_sg[sg_index].Len = len;
1335 curr_sg[sg_index].Ext = 0;
1339 cciss_map_sg_chain_block(h, c,
1340 sa->cmd_sg_list[c->cmdindex],
1341 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1342 sizeof(SGDescriptor_struct));
1344 /* track how many SG entries we are using */
1345 if (request_nsgs > h->maxSG)
1346 h->maxSG = request_nsgs;
1347 c->Header.SGTotal = (u16) request_nsgs + chained;
1348 if (request_nsgs > h->max_cmd_sgentries)
1349 c->Header.SGList = h->max_cmd_sgentries;
1351 c->Header.SGList = c->Header.SGTotal;
1357 cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1361 unsigned char scsi3addr[8];
1362 CommandList_struct *c;
1363 unsigned long flags;
1365 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1366 // We violate cmd->host privacy here. (Is there another way?)
1367 h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1369 rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1370 cmd->device->lun, scsi3addr);
1372 /* the scsi nexus does not match any that we presented... */
1373 /* pretend to mid layer that we got selection timeout */
1374 cmd->result = DID_NO_CONNECT << 16;
1376 /* we might want to think about registering controller itself
1377 as a processor device on the bus so sg binds to it. */
1381 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1382 see what the device thinks of it. */
1384 spin_lock_irqsave(&h->lock, flags);
1385 c = scsi_cmd_alloc(h);
1386 spin_unlock_irqrestore(&h->lock, flags);
1387 if (c == NULL) { /* trouble... */
1388 dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
1389 /* FIXME: next 3 lines are -> BAD! <- */
1390 cmd->result = DID_NO_CONNECT << 16;
1395 // Fill in the command list header
1397 cmd->scsi_done = done; // save this for use by completion code
1399 /* save c in case we have to abort it */
1400 cmd->host_scribble = (unsigned char *) c;
1402 c->cmd_type = CMD_SCSI;
1404 c->Header.ReplyQueue = 0; /* unused in simple mode */
1405 memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1406 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
1408 // Fill in the request block...
1410 c->Request.Timeout = 0;
1411 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1412 BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1413 c->Request.CDBLen = cmd->cmd_len;
1414 memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1415 c->Request.Type.Type = TYPE_CMD;
1416 c->Request.Type.Attribute = ATTR_SIMPLE;
1417 switch(cmd->sc_data_direction)
1420 c->Request.Type.Direction = XFER_WRITE;
1422 case DMA_FROM_DEVICE:
1423 c->Request.Type.Direction = XFER_READ;
1426 c->Request.Type.Direction = XFER_NONE;
1428 case DMA_BIDIRECTIONAL:
1429 // This can happen if a buggy application does a scsi passthru
1430 // and sets both inlen and outlen to non-zero. ( see
1431 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1433 c->Request.Type.Direction = XFER_RSVD;
1434 // This is technically wrong, and cciss controllers should
1435 // reject it with CMD_INVALID, which is the most correct
1436 // response, but non-fibre backends appear to let it
1437 // slide by, and give the same results as if this field
1438 // were set correctly. Either way is acceptable for
1439 // our purposes here.
1444 dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
1445 cmd->sc_data_direction);
1449 cciss_scatter_gather(h, c, cmd);
1450 enqueue_cmd_and_start_io(h, c);
1451 /* the cmd'll come back via intr handler in complete_scsi_command() */
1455 static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1457 static void cciss_unregister_scsi(ctlr_info_t *h)
1459 struct cciss_scsi_adapter_data_t *sa;
1460 struct cciss_scsi_cmd_stack_t *stk;
1461 unsigned long flags;
1463 /* we are being forcibly unloaded, and may not refuse. */
1465 spin_lock_irqsave(&h->lock, flags);
1467 stk = &sa->cmd_stack;
1469 /* if we weren't ever actually registered, don't unregister */
1470 if (sa->registered) {
1471 spin_unlock_irqrestore(&h->lock, flags);
1472 scsi_remove_host(sa->scsi_host);
1473 scsi_host_put(sa->scsi_host);
1474 spin_lock_irqsave(&h->lock, flags);
1477 /* set scsi_host to NULL so our detect routine will
1478 find us on register */
1479 sa->scsi_host = NULL;
1480 spin_unlock_irqrestore(&h->lock, flags);
1481 scsi_cmd_stack_free(h);
1485 static int cciss_engage_scsi(ctlr_info_t *h)
1487 struct cciss_scsi_adapter_data_t *sa;
1488 struct cciss_scsi_cmd_stack_t *stk;
1489 unsigned long flags;
1491 spin_lock_irqsave(&h->lock, flags);
1493 stk = &sa->cmd_stack;
1495 if (sa->registered) {
1496 dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
1497 spin_unlock_irqrestore(&h->lock, flags);
1501 spin_unlock_irqrestore(&h->lock, flags);
1502 cciss_update_non_disk_devices(h, -1);
1503 cciss_scsi_detect(h);
1508 cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1510 unsigned long flags;
1512 CPQ_TAPE_LOCK(h, flags);
1514 "Sequential access devices: %d\n\n",
1515 ccissscsi[h->ctlr].ndevices);
1516 CPQ_TAPE_UNLOCK(h, flags);
1519 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1520 unsigned char lunaddr[])
1525 CommandList_struct *c;
1529 dev_warn(&h->pdev->dev, "out of memory in "
1530 "wait_for_device_to_become_ready.\n");
1534 /* Send test unit ready until device ready, or give up. */
1535 while (count < 20) {
1537 /* Wait for a bit. do this first, because if we send
1538 * the TUR right away, the reset will just abort it.
1540 schedule_timeout_uninterruptible(waittime);
1543 /* Increase wait time with each try, up to a point. */
1544 if (waittime < (HZ * 30))
1545 waittime = waittime * 2;
1547 /* Send the Test Unit Ready */
1548 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1551 rc = sendcmd_withirq_core(h, c, 0);
1553 (void) process_sendcmd_error(h, c);
1558 if (c->err_info->CommandStatus == CMD_SUCCESS)
1561 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1562 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1563 if (c->err_info->SenseInfo[2] == NO_SENSE)
1565 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1567 asc = c->err_info->SenseInfo[12];
1568 check_for_unit_attention(h, c);
1569 if (asc == POWER_OR_RESET)
1574 dev_warn(&h->pdev->dev, "Waiting %d secs "
1575 "for device to become ready.\n",
1577 rc = 1; /* device not ready. */
1581 dev_warn(&h->pdev->dev, "giving up on device.\n");
1583 dev_warn(&h->pdev->dev, "device is ready.\n");
1589 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1590 * complaining. Doing a host- or bus-reset can't do anything good here.
1591 * Despite what it might say in scsi_error.c, there may well be commands
1592 * on the controller, as the cciss driver registers twice, once as a block
1593 * device for the logical drives, and once as a scsi device, for any tape
1594 * drives. So we know there are no commands out on the tape drives, but we
1595 * don't know there are no commands on the controller, and it is likely
1596 * that there probably are, as the cciss block device is most commonly used
1597 * as a boot device (embedded controller on HP/Compaq systems.)
1600 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1603 CommandList_struct *cmd_in_trouble;
1604 unsigned char lunaddr[8];
1607 /* find the controller to which the command to be aborted was sent */
1608 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1609 if (h == NULL) /* paranoia */
1611 dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
1612 /* find the command that's giving us trouble */
1613 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1614 if (cmd_in_trouble == NULL) /* paranoia */
1616 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1617 /* send a reset to the SCSI LUN which the command was sent to */
1618 rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1620 if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1622 dev_warn(&h->pdev->dev, "resetting device failed.\n");
1626 static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1629 CommandList_struct *cmd_to_abort;
1630 unsigned char lunaddr[8];
1633 /* find the controller to which the command to be aborted was sent */
1634 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1635 if (h == NULL) /* paranoia */
1637 dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
1639 /* find the command to be aborted */
1640 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1641 if (cmd_to_abort == NULL) /* paranoia */
1643 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1644 rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1645 0, 0, lunaddr, TYPE_MSG);
1652 #else /* no CONFIG_CISS_SCSI_TAPE */
1654 /* If no tape support, then these become defined out of existence */
1656 #define cciss_scsi_setup(cntl_num)
1657 #define cciss_engage_scsi(h)
1659 #endif /* CONFIG_CISS_SCSI_TAPE */