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(ctlr_info_t
*h
, CommandList_struct
*c
, __u8 cmd
, void *buff
,
49 __u8 page_code
, unsigned char *scsi3addr
,
52 static CommandList_struct
*cmd_alloc(ctlr_info_t
*h
);
53 static CommandList_struct
*cmd_special_alloc(ctlr_info_t
*h
);
54 static void cmd_free(ctlr_info_t
*h
, CommandList_struct
*c
);
55 static void cmd_special_free(ctlr_info_t
*h
, CommandList_struct
*c
);
57 static int cciss_scsi_proc_info(
59 char *buffer
, /* data buffer */
60 char **start
, /* where data in buffer starts */
61 off_t offset
, /* offset from start of imaginary file */
62 int length
, /* length of data in buffer */
63 int func
); /* 0 == read, 1 == write */
65 static int cciss_scsi_queue_command (struct scsi_cmnd
*cmd
,
66 void (* done
)(struct scsi_cmnd
*));
67 static int cciss_eh_device_reset_handler(struct scsi_cmnd
*);
68 static int cciss_eh_abort_handler(struct scsi_cmnd
*);
70 static struct cciss_scsi_hba_t ccissscsi
[MAX_CTLR
] = {
71 { .name
= "cciss0", .ndevices
= 0 },
72 { .name
= "cciss1", .ndevices
= 0 },
73 { .name
= "cciss2", .ndevices
= 0 },
74 { .name
= "cciss3", .ndevices
= 0 },
75 { .name
= "cciss4", .ndevices
= 0 },
76 { .name
= "cciss5", .ndevices
= 0 },
77 { .name
= "cciss6", .ndevices
= 0 },
78 { .name
= "cciss7", .ndevices
= 0 },
81 static struct scsi_host_template cciss_driver_template
= {
82 .module
= THIS_MODULE
,
85 .proc_info
= cciss_scsi_proc_info
,
86 .queuecommand
= cciss_scsi_queue_command
,
87 .can_queue
= SCSI_CCISS_CAN_QUEUE
,
90 .use_clustering
= DISABLE_CLUSTERING
,
91 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
92 .eh_device_reset_handler
= cciss_eh_device_reset_handler
,
93 .eh_abort_handler
= cciss_eh_abort_handler
,
101 struct cciss_scsi_cmd_stack_elem_t
{
102 CommandList_struct cmd
;
103 ErrorInfo_struct Err
;
106 u8 pad
[IS_32_BIT
* SCSI_PAD_32
+ IS_64_BIT
* SCSI_PAD_64
];
111 #define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
112 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
113 // plus two for init time usage
116 struct cciss_scsi_cmd_stack_t
{
117 struct cciss_scsi_cmd_stack_elem_t
*pool
;
118 struct cciss_scsi_cmd_stack_elem_t
*elem
[CMD_STACK_SIZE
];
119 dma_addr_t cmd_pool_handle
;
124 struct cciss_scsi_adapter_data_t
{
125 struct Scsi_Host
*scsi_host
;
126 struct cciss_scsi_cmd_stack_t cmd_stack
;
127 SGDescriptor_struct
**cmd_sg_list
;
129 spinlock_t lock
; // to protect ccissscsi[ctlr];
132 #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
133 &h->scsi_ctlr->lock, flags);
134 #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
135 &h->scsi_ctlr->lock, flags);
137 static CommandList_struct
*
138 scsi_cmd_alloc(ctlr_info_t
*h
)
140 /* assume only one process in here at a time, locking done by caller. */
142 /* might be better to rewrite how we allocate scsi commands in a way that */
143 /* needs no locking at all. */
145 /* take the top memory chunk off the stack and return it, if any. */
146 struct cciss_scsi_cmd_stack_elem_t
*c
;
147 struct cciss_scsi_adapter_data_t
*sa
;
148 struct cciss_scsi_cmd_stack_t
*stk
;
152 stk
= &sa
->cmd_stack
;
156 c
= stk
->elem
[stk
->top
];
157 /* memset(c, 0, sizeof(*c)); */
158 memset(&c
->cmd
, 0, sizeof(c
->cmd
));
159 memset(&c
->Err
, 0, sizeof(c
->Err
));
160 /* set physical addr of cmd and addr of scsi parameters */
161 c
->cmd
.busaddr
= c
->busaddr
;
162 c
->cmd
.cmdindex
= c
->cmdindex
;
163 /* (__u32) (stk->cmd_pool_handle +
164 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
166 temp64
.val
= (__u64
) (c
->busaddr
+ sizeof(CommandList_struct
));
167 /* (__u64) (stk->cmd_pool_handle +
168 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
169 sizeof(CommandList_struct)); */
171 c
->cmd
.ErrDesc
.Addr
.lower
= temp64
.val32
.lower
;
172 c
->cmd
.ErrDesc
.Addr
.upper
= temp64
.val32
.upper
;
173 c
->cmd
.ErrDesc
.Len
= sizeof(ErrorInfo_struct
);
175 c
->cmd
.ctlr
= h
->ctlr
;
176 c
->cmd
.err_info
= &c
->Err
;
178 return (CommandList_struct
*) c
;
182 scsi_cmd_free(ctlr_info_t
*h
, CommandList_struct
*c
)
184 /* assume only one process in here at a time, locking done by caller. */
186 /* drop the free memory chunk on top of the stack. */
188 struct cciss_scsi_adapter_data_t
*sa
;
189 struct cciss_scsi_cmd_stack_t
*stk
;
192 stk
= &sa
->cmd_stack
;
194 if (stk
->top
>= CMD_STACK_SIZE
) {
195 dev_err(&h
->pdev
->dev
,
196 "scsi_cmd_free called too many times.\n");
199 stk
->elem
[stk
->top
] = (struct cciss_scsi_cmd_stack_elem_t
*) c
;
203 scsi_cmd_stack_setup(ctlr_info_t
*h
, struct cciss_scsi_adapter_data_t
*sa
)
206 struct cciss_scsi_cmd_stack_t
*stk
;
209 sa
->cmd_sg_list
= cciss_allocate_sg_chain_blocks(h
,
210 h
->chainsize
, CMD_STACK_SIZE
);
211 if (!sa
->cmd_sg_list
&& h
->chainsize
> 0)
214 stk
= &sa
->cmd_stack
;
215 size
= sizeof(struct cciss_scsi_cmd_stack_elem_t
) * CMD_STACK_SIZE
;
217 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
218 BUILD_BUG_ON((sizeof(*stk
->pool
) % COMMANDLIST_ALIGNMENT
) != 0);
219 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
220 stk
->pool
= (struct cciss_scsi_cmd_stack_elem_t
*)
221 pci_alloc_consistent(h
->pdev
, size
, &stk
->cmd_pool_handle
);
223 if (stk
->pool
== NULL
) {
224 cciss_free_sg_chain_blocks(sa
->cmd_sg_list
, CMD_STACK_SIZE
);
225 sa
->cmd_sg_list
= NULL
;
229 for (i
=0; i
<CMD_STACK_SIZE
; 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
= CMD_STACK_SIZE
-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
!= CMD_STACK_SIZE
-1) {
249 dev_warn(&h
->pdev
->dev
,
250 "bug: %d scsi commands are still outstanding.\n",
251 CMD_STACK_SIZE
- stk
->top
);
253 size
= sizeof(struct cciss_scsi_cmd_stack_elem_t
) * CMD_STACK_SIZE
;
255 pci_free_consistent(h
->pdev
, size
, stk
->pool
, stk
->cmd_pool_handle
);
257 cciss_free_sg_chain_blocks(sa
->cmd_sg_list
, CMD_STACK_SIZE
);
262 find_bus_target_lun(ctlr_info_t
*h
, int *bus
, int *target
, int *lun
)
264 /* finds an unused bus, target, lun for a new device */
265 /* assumes h->scsi_ctlr->lock is held */
267 unsigned char target_taken
[CCISS_MAX_SCSI_DEVS_PER_HBA
];
269 memset(&target_taken
[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA
);
271 target_taken
[SELF_SCSI_ID
] = 1;
272 for (i
= 0; i
< ccissscsi
[h
->ctlr
].ndevices
; i
++)
273 target_taken
[ccissscsi
[h
->ctlr
].dev
[i
].target
] = 1;
275 for (i
= 0; i
< CCISS_MAX_SCSI_DEVS_PER_HBA
; i
++) {
276 if (!target_taken
[i
]) {
277 *bus
= 0; *target
=i
; *lun
= 0; found
=1;
285 int bus
, target
, lun
;
289 cciss_scsi_add_entry(ctlr_info_t
*h
, int hostno
,
290 struct cciss_scsi_dev_t
*device
,
291 struct scsi2map
*added
, int *nadded
)
293 /* assumes h->scsi_ctlr->lock is held */
294 int n
= ccissscsi
[h
->ctlr
].ndevices
;
295 struct cciss_scsi_dev_t
*sd
;
296 int i
, bus
, target
, lun
;
297 unsigned char addr1
[8], addr2
[8];
299 if (n
>= CCISS_MAX_SCSI_DEVS_PER_HBA
) {
300 dev_warn(&h
->pdev
->dev
, "Too many devices, "
301 "some will be inaccessible.\n");
307 /* Is this device a non-zero lun of a multi-lun device */
308 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
309 if (device
->scsi3addr
[4] != 0) {
310 /* Search through our list and find the device which */
311 /* has the same 8 byte LUN address, excepting byte 4. */
312 /* Assign the same bus and target for this new LUN. */
313 /* Use the logical unit number from the firmware. */
314 memcpy(addr1
, device
->scsi3addr
, 8);
316 for (i
= 0; i
< n
; i
++) {
317 sd
= &ccissscsi
[h
->ctlr
].dev
[i
];
318 memcpy(addr2
, sd
->scsi3addr
, 8);
320 /* differ only in byte 4? */
321 if (memcmp(addr1
, addr2
, 8) == 0) {
324 lun
= device
->scsi3addr
[4];
330 sd
= &ccissscsi
[h
->ctlr
].dev
[n
];
332 if (find_bus_target_lun(h
,
333 &sd
->bus
, &sd
->target
, &sd
->lun
) != 0)
340 added
[*nadded
].bus
= sd
->bus
;
341 added
[*nadded
].target
= sd
->target
;
342 added
[*nadded
].lun
= sd
->lun
;
345 memcpy(sd
->scsi3addr
, device
->scsi3addr
, 8);
346 memcpy(sd
->vendor
, device
->vendor
, sizeof(sd
->vendor
));
347 memcpy(sd
->revision
, device
->revision
, sizeof(sd
->revision
));
348 memcpy(sd
->device_id
, device
->device_id
, sizeof(sd
->device_id
));
349 sd
->devtype
= device
->devtype
;
351 ccissscsi
[h
->ctlr
].ndevices
++;
353 /* initially, (before registering with scsi layer) we don't
354 know our hostno and we don't want to print anything first
355 time anyway (the scsi layer's inquiries will show that info) */
357 dev_info(&h
->pdev
->dev
, "%s device c%db%dt%dl%d added.\n",
358 scsi_device_type(sd
->devtype
), hostno
,
359 sd
->bus
, sd
->target
, sd
->lun
);
364 cciss_scsi_remove_entry(ctlr_info_t
*h
, int hostno
, int entry
,
365 struct scsi2map
*removed
, int *nremoved
)
367 /* assumes h->ctlr]->scsi_ctlr->lock is held */
369 struct cciss_scsi_dev_t sd
;
371 if (entry
< 0 || entry
>= CCISS_MAX_SCSI_DEVS_PER_HBA
) return;
372 sd
= ccissscsi
[h
->ctlr
].dev
[entry
];
373 removed
[*nremoved
].bus
= sd
.bus
;
374 removed
[*nremoved
].target
= sd
.target
;
375 removed
[*nremoved
].lun
= sd
.lun
;
377 for (i
= entry
; i
< ccissscsi
[h
->ctlr
].ndevices
-1; i
++)
378 ccissscsi
[h
->ctlr
].dev
[i
] = ccissscsi
[h
->ctlr
].dev
[i
+1];
379 ccissscsi
[h
->ctlr
].ndevices
--;
380 dev_info(&h
->pdev
->dev
, "%s device c%db%dt%dl%d removed.\n",
381 scsi_device_type(sd
.devtype
), hostno
,
382 sd
.bus
, sd
.target
, sd
.lun
);
386 #define SCSI3ADDR_EQ(a,b) ( \
387 (a)[7] == (b)[7] && \
388 (a)[6] == (b)[6] && \
389 (a)[5] == (b)[5] && \
390 (a)[4] == (b)[4] && \
391 (a)[3] == (b)[3] && \
392 (a)[2] == (b)[2] && \
393 (a)[1] == (b)[1] && \
396 static void fixup_botched_add(ctlr_info_t
*h
, char *scsi3addr
)
398 /* called when scsi_add_device fails in order to re-adjust */
399 /* ccissscsi[] to match the mid layer's view. */
402 CPQ_TAPE_LOCK(h
, flags
);
403 for (i
= 0; i
< ccissscsi
[h
->ctlr
].ndevices
; i
++) {
404 if (memcmp(scsi3addr
,
405 ccissscsi
[h
->ctlr
].dev
[i
].scsi3addr
, 8) == 0) {
406 for (j
= i
; j
< ccissscsi
[h
->ctlr
].ndevices
-1; j
++)
407 ccissscsi
[h
->ctlr
].dev
[j
] =
408 ccissscsi
[h
->ctlr
].dev
[j
+1];
409 ccissscsi
[h
->ctlr
].ndevices
--;
413 CPQ_TAPE_UNLOCK(h
, flags
);
416 static int device_is_the_same(struct cciss_scsi_dev_t
*dev1
,
417 struct cciss_scsi_dev_t
*dev2
)
419 return dev1
->devtype
== dev2
->devtype
&&
420 memcmp(dev1
->scsi3addr
, dev2
->scsi3addr
,
421 sizeof(dev1
->scsi3addr
)) == 0 &&
422 memcmp(dev1
->device_id
, dev2
->device_id
,
423 sizeof(dev1
->device_id
)) == 0 &&
424 memcmp(dev1
->vendor
, dev2
->vendor
,
425 sizeof(dev1
->vendor
)) == 0 &&
426 memcmp(dev1
->model
, dev2
->model
,
427 sizeof(dev1
->model
)) == 0 &&
428 memcmp(dev1
->revision
, dev2
->revision
,
429 sizeof(dev1
->revision
)) == 0;
433 adjust_cciss_scsi_table(ctlr_info_t
*h
, int hostno
,
434 struct cciss_scsi_dev_t sd
[], int nsds
)
436 /* sd contains scsi3 addresses and devtypes, but
437 bus target and lun are not filled in. This funciton
438 takes what's in sd to be the current and adjusts
439 ccissscsi[] to be in line with what's in sd. */
441 int i
,j
, found
, changes
=0;
442 struct cciss_scsi_dev_t
*csd
;
444 struct scsi2map
*added
, *removed
;
445 int nadded
, nremoved
;
446 struct Scsi_Host
*sh
= NULL
;
448 added
= kzalloc(sizeof(*added
) * CCISS_MAX_SCSI_DEVS_PER_HBA
,
450 removed
= kzalloc(sizeof(*removed
) * CCISS_MAX_SCSI_DEVS_PER_HBA
,
453 if (!added
|| !removed
) {
454 dev_warn(&h
->pdev
->dev
,
455 "Out of memory in adjust_cciss_scsi_table\n");
459 CPQ_TAPE_LOCK(h
, flags
);
461 if (hostno
!= -1) /* if it's not the first time... */
462 sh
= h
->scsi_ctlr
->scsi_host
;
464 /* find any devices in ccissscsi[] that are not in
465 sd[] and remove them from ccissscsi[] */
470 while (i
< ccissscsi
[h
->ctlr
].ndevices
) {
471 csd
= &ccissscsi
[h
->ctlr
].dev
[i
];
473 for (j
=0;j
<nsds
;j
++) {
474 if (SCSI3ADDR_EQ(sd
[j
].scsi3addr
,
476 if (device_is_the_same(&sd
[j
], csd
))
484 if (found
== 0) { /* device no longer present. */
486 cciss_scsi_remove_entry(h
, hostno
, i
,
488 /* remove ^^^, hence i not incremented */
489 } else if (found
== 1) { /* device is different in some way */
491 dev_info(&h
->pdev
->dev
,
492 "device c%db%dt%dl%d has changed.\n",
493 hostno
, csd
->bus
, csd
->target
, csd
->lun
);
494 cciss_scsi_remove_entry(h
, hostno
, i
,
496 /* remove ^^^, hence i not incremented */
497 if (cciss_scsi_add_entry(h
, hostno
, &sd
[j
],
498 added
, &nadded
) != 0)
499 /* we just removed one, so add can't fail. */
501 csd
->devtype
= sd
[j
].devtype
;
502 memcpy(csd
->device_id
, sd
[j
].device_id
,
503 sizeof(csd
->device_id
));
504 memcpy(csd
->vendor
, sd
[j
].vendor
,
505 sizeof(csd
->vendor
));
506 memcpy(csd
->model
, sd
[j
].model
,
508 memcpy(csd
->revision
, sd
[j
].revision
,
509 sizeof(csd
->revision
));
510 } else /* device is same as it ever was, */
511 i
++; /* so just move along. */
514 /* Now, make sure every device listed in sd[] is also
515 listed in ccissscsi[], adding them if they aren't found */
517 for (i
=0;i
<nsds
;i
++) {
519 for (j
= 0; j
< ccissscsi
[h
->ctlr
].ndevices
; j
++) {
520 csd
= &ccissscsi
[h
->ctlr
].dev
[j
];
521 if (SCSI3ADDR_EQ(sd
[i
].scsi3addr
,
523 if (device_is_the_same(&sd
[i
], csd
))
524 found
=2; /* found device */
526 found
=1; /* found a bug. */
532 if (cciss_scsi_add_entry(h
, hostno
, &sd
[i
],
533 added
, &nadded
) != 0)
535 } else if (found
== 1) {
536 /* should never happen... */
538 dev_warn(&h
->pdev
->dev
,
539 "device unexpectedly changed\n");
540 /* but if it does happen, we just ignore that device */
543 CPQ_TAPE_UNLOCK(h
, flags
);
545 /* Don't notify scsi mid layer of any changes the first time through */
546 /* (or if there are no changes) scsi_scan_host will do it later the */
547 /* first time through. */
548 if (hostno
== -1 || !changes
)
551 /* Notify scsi mid layer of any removed devices */
552 for (i
= 0; i
< nremoved
; i
++) {
553 struct scsi_device
*sdev
=
554 scsi_device_lookup(sh
, removed
[i
].bus
,
555 removed
[i
].target
, removed
[i
].lun
);
557 scsi_remove_device(sdev
);
558 scsi_device_put(sdev
);
560 /* We don't expect to get here. */
561 /* future cmds to this device will get selection */
562 /* timeout as if the device was gone. */
563 dev_warn(&h
->pdev
->dev
, "didn't find "
564 "c%db%dt%dl%d\n for removal.",
565 hostno
, removed
[i
].bus
,
566 removed
[i
].target
, removed
[i
].lun
);
570 /* Notify scsi mid layer of any added devices */
571 for (i
= 0; i
< nadded
; i
++) {
573 rc
= scsi_add_device(sh
, added
[i
].bus
,
574 added
[i
].target
, added
[i
].lun
);
577 dev_warn(&h
->pdev
->dev
, "scsi_add_device "
578 "c%db%dt%dl%d failed, device not added.\n",
579 hostno
, added
[i
].bus
, added
[i
].target
, added
[i
].lun
);
580 /* now we have to remove it from ccissscsi, */
581 /* since it didn't get added to scsi mid layer */
582 fixup_botched_add(h
, added
[i
].scsi3addr
);
592 lookup_scsi3addr(ctlr_info_t
*h
, int bus
, int target
, int lun
, char *scsi3addr
)
595 struct cciss_scsi_dev_t
*sd
;
598 CPQ_TAPE_LOCK(h
, flags
);
599 for (i
= 0; i
< ccissscsi
[h
->ctlr
].ndevices
; i
++) {
600 sd
= &ccissscsi
[h
->ctlr
].dev
[i
];
601 if (sd
->bus
== bus
&&
602 sd
->target
== target
&&
604 memcpy(scsi3addr
, &sd
->scsi3addr
[0], 8);
605 CPQ_TAPE_UNLOCK(h
, flags
);
609 CPQ_TAPE_UNLOCK(h
, flags
);
614 cciss_scsi_setup(ctlr_info_t
*h
)
616 struct cciss_scsi_adapter_data_t
* shba
;
618 ccissscsi
[h
->ctlr
].ndevices
= 0;
619 shba
= (struct cciss_scsi_adapter_data_t
*)
620 kmalloc(sizeof(*shba
), GFP_KERNEL
);
623 shba
->scsi_host
= NULL
;
624 spin_lock_init(&shba
->lock
);
625 shba
->registered
= 0;
626 if (scsi_cmd_stack_setup(h
, shba
) != 0) {
634 static void complete_scsi_command(CommandList_struct
*c
, int timeout
,
637 struct scsi_cmnd
*cmd
;
639 ErrorInfo_struct
*ei
;
643 /* First, see if it was a message rather than a command */
644 if (c
->Request
.Type
.Type
== TYPE_MSG
) {
645 c
->cmd_type
= CMD_MSG_DONE
;
649 cmd
= (struct scsi_cmnd
*) c
->scsi_cmd
;
653 if (c
->Header
.SGTotal
> h
->max_cmd_sgentries
)
654 cciss_unmap_sg_chain_block(h
, c
);
656 cmd
->result
= (DID_OK
<< 16); /* host byte */
657 cmd
->result
|= (COMMAND_COMPLETE
<< 8); /* msg byte */
658 /* cmd->result |= (GOOD < 1); */ /* status byte */
660 cmd
->result
|= (ei
->ScsiStatus
);
661 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
663 /* copy the sense data whether we need to or not. */
665 memcpy(cmd
->sense_buffer
, ei
->SenseInfo
,
666 ei
->SenseLen
> SCSI_SENSE_BUFFERSIZE
?
667 SCSI_SENSE_BUFFERSIZE
:
669 scsi_set_resid(cmd
, ei
->ResidualCnt
);
671 if(ei
->CommandStatus
!= 0)
672 { /* an error has occurred */
673 switch(ei
->CommandStatus
)
675 case CMD_TARGET_STATUS
:
676 /* Pass it up to the upper layers... */
679 cmd
->result
|= (ei
->ScsiStatus
<< 1);
681 else { /* scsi status is zero??? How??? */
683 /* Ordinarily, this case should never happen, but there is a bug
684 in some released firmware revisions that allows it to happen
685 if, for example, a 4100 backplane loses power and the tape
686 drive is in it. We assume that it's a fatal error of some
687 kind because we can't show that it wasn't. We will make it
688 look like selection timeout since that is the most common
689 reason for this to occur, and it's severe enough. */
691 cmd
->result
= DID_NO_CONNECT
<< 16;
694 case CMD_DATA_UNDERRUN
: /* let mid layer handle it. */
696 case CMD_DATA_OVERRUN
:
697 dev_warn(&h
->pdev
->dev
, "%p has"
698 " completed with data overrun "
702 /* print_bytes(c, sizeof(*c), 1, 0);
704 /* We get CMD_INVALID if you address a non-existent tape drive instead
705 of a selection timeout (no response). You will see this if you yank
706 out a tape drive, then try to access it. This is kind of a shame
707 because it means that any other CMD_INVALID (e.g. driver bug) will
708 get interpreted as a missing target. */
709 cmd
->result
= DID_NO_CONNECT
<< 16;
712 case CMD_PROTOCOL_ERR
:
713 dev_warn(&h
->pdev
->dev
,
714 "%p has protocol error\n", c
);
716 case CMD_HARDWARE_ERR
:
717 cmd
->result
= DID_ERROR
<< 16;
718 dev_warn(&h
->pdev
->dev
,
719 "%p had hardware error\n", c
);
721 case CMD_CONNECTION_LOST
:
722 cmd
->result
= DID_ERROR
<< 16;
723 dev_warn(&h
->pdev
->dev
,
724 "%p had connection lost\n", c
);
727 cmd
->result
= DID_ABORT
<< 16;
728 dev_warn(&h
->pdev
->dev
, "%p was aborted\n", c
);
730 case CMD_ABORT_FAILED
:
731 cmd
->result
= DID_ERROR
<< 16;
732 dev_warn(&h
->pdev
->dev
,
733 "%p reports abort failed\n", c
);
735 case CMD_UNSOLICITED_ABORT
:
736 cmd
->result
= DID_ABORT
<< 16;
737 dev_warn(&h
->pdev
->dev
, "%p aborted do to an "
738 "unsolicited abort\n", c
);
741 cmd
->result
= DID_TIME_OUT
<< 16;
742 dev_warn(&h
->pdev
->dev
, "%p timedout\n", c
);
745 cmd
->result
= DID_ERROR
<< 16;
746 dev_warn(&h
->pdev
->dev
,
747 "%p returned unknown status %x\n", c
,
756 cciss_scsi_detect(ctlr_info_t
*h
)
758 struct Scsi_Host
*sh
;
761 sh
= scsi_host_alloc(&cciss_driver_template
, sizeof(struct ctlr_info
*));
765 sh
->n_io_port
= 0; // I don't think we use these two...
766 sh
->this_id
= SELF_SCSI_ID
;
767 sh
->sg_tablesize
= h
->maxsgentries
;
768 sh
->max_cmd_len
= MAX_COMMAND_SIZE
;
770 ((struct cciss_scsi_adapter_data_t
*)
771 h
->scsi_ctlr
)->scsi_host
= sh
;
772 sh
->hostdata
[0] = (unsigned long) h
;
773 sh
->irq
= h
->intr
[SIMPLE_MODE_INT
];
774 sh
->unique_id
= sh
->irq
;
775 error
= scsi_add_host(sh
, &h
->pdev
->dev
);
788 cciss_unmap_one(struct pci_dev
*pdev
,
789 CommandList_struct
*c
,
795 addr64
.val32
.lower
= c
->SG
[0].Addr
.lower
;
796 addr64
.val32
.upper
= c
->SG
[0].Addr
.upper
;
797 pci_unmap_single(pdev
, (dma_addr_t
) addr64
.val
, buflen
, data_direction
);
801 cciss_map_one(struct pci_dev
*pdev
,
802 CommandList_struct
*c
,
809 addr64
= (__u64
) pci_map_single(pdev
, buf
, buflen
, data_direction
);
810 c
->SG
[0].Addr
.lower
=
811 (__u32
) (addr64
& (__u64
) 0x00000000FFFFFFFF);
812 c
->SG
[0].Addr
.upper
=
813 (__u32
) ((addr64
>> 32) & (__u64
) 0x00000000FFFFFFFF);
814 c
->SG
[0].Len
= buflen
;
815 c
->Header
.SGList
= (__u8
) 1; /* no. SGs contig in this cmd */
816 c
->Header
.SGTotal
= (__u16
) 1; /* total sgs in this cmd list */
820 cciss_scsi_do_simple_cmd(ctlr_info_t
*h
,
821 CommandList_struct
*c
,
822 unsigned char *scsi3addr
,
824 unsigned char cdblen
,
825 unsigned char *buf
, int bufsize
,
828 DECLARE_COMPLETION_ONSTACK(wait
);
830 c
->cmd_type
= CMD_IOCTL_PEND
; /* treat this like an ioctl */
832 c
->Header
.ReplyQueue
= 0; /* unused in simple mode */
833 memcpy(&c
->Header
.LUN
, scsi3addr
, sizeof(c
->Header
.LUN
));
834 c
->Header
.Tag
.lower
= c
->busaddr
; /* Use k. address of cmd as tag */
835 // Fill in the request block...
837 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
838 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
839 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
841 memset(c
->Request
.CDB
, 0, sizeof(c
->Request
.CDB
));
842 memcpy(c
->Request
.CDB
, cdb
, cdblen
);
843 c
->Request
.Timeout
= 0;
844 c
->Request
.CDBLen
= cdblen
;
845 c
->Request
.Type
.Type
= TYPE_CMD
;
846 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
847 c
->Request
.Type
.Direction
= direction
;
849 /* Fill in the SG list and do dma mapping */
850 cciss_map_one(h
->pdev
, c
, (unsigned char *) buf
,
851 bufsize
, DMA_FROM_DEVICE
);
854 enqueue_cmd_and_start_io(h
, c
);
855 wait_for_completion(&wait
);
857 /* undo the dma mapping */
858 cciss_unmap_one(h
->pdev
, c
, bufsize
, DMA_FROM_DEVICE
);
863 cciss_scsi_interpret_error(ctlr_info_t
*h
, CommandList_struct
*c
)
865 ErrorInfo_struct
*ei
;
868 switch(ei
->CommandStatus
)
870 case CMD_TARGET_STATUS
:
871 dev_warn(&h
->pdev
->dev
,
872 "cmd %p has completed with errors\n", c
);
873 dev_warn(&h
->pdev
->dev
,
874 "cmd %p has SCSI Status = %x\n",
876 if (ei
->ScsiStatus
== 0)
877 dev_warn(&h
->pdev
->dev
,
878 "SCSI status is abnormally zero. "
879 "(probably indicates selection timeout "
880 "reported incorrectly due to a known "
881 "firmware bug, circa July, 2001.)\n");
883 case CMD_DATA_UNDERRUN
: /* let mid layer handle it. */
884 dev_info(&h
->pdev
->dev
, "UNDERRUN\n");
886 case CMD_DATA_OVERRUN
:
887 dev_warn(&h
->pdev
->dev
, "%p has"
888 " completed with data overrun "
892 /* controller unfortunately reports SCSI passthru's */
893 /* to non-existent targets as invalid commands. */
894 dev_warn(&h
->pdev
->dev
,
895 "%p is reported invalid (probably means "
896 "target device no longer present)\n", c
);
897 /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
901 case CMD_PROTOCOL_ERR
:
902 dev_warn(&h
->pdev
->dev
, "%p has protocol error\n", c
);
904 case CMD_HARDWARE_ERR
:
905 /* cmd->result = DID_ERROR << 16; */
906 dev_warn(&h
->pdev
->dev
, "%p had hardware error\n", c
);
908 case CMD_CONNECTION_LOST
:
909 dev_warn(&h
->pdev
->dev
, "%p had connection lost\n", c
);
912 dev_warn(&h
->pdev
->dev
, "%p was aborted\n", c
);
914 case CMD_ABORT_FAILED
:
915 dev_warn(&h
->pdev
->dev
,
916 "%p reports abort failed\n", c
);
918 case CMD_UNSOLICITED_ABORT
:
919 dev_warn(&h
->pdev
->dev
,
920 "%p aborted do to an unsolicited abort\n", c
);
923 dev_warn(&h
->pdev
->dev
, "%p timedout\n", c
);
926 dev_warn(&h
->pdev
->dev
,
927 "%p returned unknown status %x\n",
928 c
, ei
->CommandStatus
);
933 cciss_scsi_do_inquiry(ctlr_info_t
*h
, unsigned char *scsi3addr
,
934 unsigned char page
, unsigned char *buf
,
935 unsigned char bufsize
)
938 CommandList_struct
*c
;
940 ErrorInfo_struct
*ei
;
943 spin_lock_irqsave(&h
->lock
, flags
);
944 c
= scsi_cmd_alloc(h
);
945 spin_unlock_irqrestore(&h
->lock
, flags
);
947 if (c
== NULL
) { /* trouble... */
948 printk("cmd_alloc returned NULL!\n");
954 cdb
[0] = CISS_INQUIRY
;
955 cdb
[1] = (page
!= 0);
960 rc
= cciss_scsi_do_simple_cmd(h
, c
, scsi3addr
, cdb
,
961 6, buf
, bufsize
, XFER_READ
);
963 if (rc
!= 0) return rc
; /* something went wrong */
965 if (ei
->CommandStatus
!= 0 &&
966 ei
->CommandStatus
!= CMD_DATA_UNDERRUN
) {
967 cciss_scsi_interpret_error(h
, c
);
970 spin_lock_irqsave(&h
->lock
, flags
);
972 spin_unlock_irqrestore(&h
->lock
, flags
);
976 /* Get the device id from inquiry page 0x83 */
977 static int cciss_scsi_get_device_id(ctlr_info_t
*h
, unsigned char *scsi3addr
,
978 unsigned char *device_id
, int buflen
)
985 buf
= kzalloc(64, GFP_KERNEL
);
988 rc
= cciss_scsi_do_inquiry(h
, scsi3addr
, 0x83, buf
, 64);
990 memcpy(device_id
, &buf
[8], buflen
);
996 cciss_scsi_do_report_phys_luns(ctlr_info_t
*h
,
997 ReportLunData_struct
*buf
, int bufsize
)
1000 CommandList_struct
*c
;
1001 unsigned char cdb
[12];
1002 unsigned char scsi3addr
[8];
1003 ErrorInfo_struct
*ei
;
1004 unsigned long flags
;
1006 spin_lock_irqsave(&h
->lock
, flags
);
1007 c
= scsi_cmd_alloc(h
);
1008 spin_unlock_irqrestore(&h
->lock
, flags
);
1009 if (c
== NULL
) { /* trouble... */
1010 printk("cmd_alloc returned NULL!\n");
1014 memset(&scsi3addr
[0], 0, 8); /* address the controller */
1015 cdb
[0] = CISS_REPORT_PHYS
;
1021 cdb
[6] = (bufsize
>> 24) & 0xFF; //MSB
1022 cdb
[7] = (bufsize
>> 16) & 0xFF;
1023 cdb
[8] = (bufsize
>> 8) & 0xFF;
1024 cdb
[9] = bufsize
& 0xFF;
1028 rc
= cciss_scsi_do_simple_cmd(h
, c
, scsi3addr
,
1030 (unsigned char *) buf
,
1031 bufsize
, XFER_READ
);
1033 if (rc
!= 0) return rc
; /* something went wrong */
1036 if (ei
->CommandStatus
!= 0 &&
1037 ei
->CommandStatus
!= CMD_DATA_UNDERRUN
) {
1038 cciss_scsi_interpret_error(h
, c
);
1041 spin_lock_irqsave(&h
->lock
, flags
);
1042 scsi_cmd_free(h
, c
);
1043 spin_unlock_irqrestore(&h
->lock
, flags
);
1048 cciss_update_non_disk_devices(ctlr_info_t
*h
, int hostno
)
1050 /* the idea here is we could get notified from /proc
1051 that some devices have changed, so we do a report
1052 physical luns cmd, and adjust our list of devices
1053 accordingly. (We can't rely on the scsi-mid layer just
1054 doing inquiries, because the "busses" that the scsi
1055 mid-layer probes are totally fabricated by this driver,
1056 so new devices wouldn't show up.
1058 the scsi3addr's of devices won't change so long as the
1059 adapter is not reset. That means we can rescan and
1060 tell which devices we already know about, vs. new
1061 devices, vs. disappearing devices.
1063 Also, if you yank out a tape drive, then put in a disk
1064 in it's place, (say, a configured volume from another
1065 array controller for instance) _don't_ poke this driver
1066 (so it thinks it's still a tape, but _do_ poke the scsi
1067 mid layer, so it does an inquiry... the scsi mid layer
1068 will see the physical disk. This would be bad. Need to
1069 think about how to prevent that. One idea would be to
1070 snoop all scsi responses and if an inquiry repsonse comes
1071 back that reports a disk, chuck it an return selection
1072 timeout instead and adjust our table... Not sure i like
1076 #define OBDR_TAPE_INQ_SIZE 49
1077 #define OBDR_TAPE_SIG "$DR-10"
1078 ReportLunData_struct
*ld_buff
;
1079 unsigned char *inq_buff
;
1080 unsigned char scsi3addr
[8];
1083 struct cciss_scsi_dev_t
*currentsd
, *this_device
;
1085 int reportlunsize
= sizeof(*ld_buff
) + CISS_MAX_PHYS_LUN
* 8;
1088 ld_buff
= kzalloc(reportlunsize
, GFP_KERNEL
);
1089 inq_buff
= kmalloc(OBDR_TAPE_INQ_SIZE
, GFP_KERNEL
);
1090 currentsd
= kzalloc(sizeof(*currentsd
) *
1091 (CCISS_MAX_SCSI_DEVS_PER_HBA
+1), GFP_KERNEL
);
1092 if (ld_buff
== NULL
|| inq_buff
== NULL
|| currentsd
== NULL
) {
1093 printk(KERN_ERR
"cciss: out of memory\n");
1096 this_device
= ¤tsd
[CCISS_MAX_SCSI_DEVS_PER_HBA
];
1097 if (cciss_scsi_do_report_phys_luns(h
, ld_buff
, reportlunsize
) == 0) {
1098 ch
= &ld_buff
->LUNListLength
[0];
1099 num_luns
= ((ch
[0]<<24) | (ch
[1]<<16) | (ch
[2]<<8) | ch
[3]) / 8;
1100 if (num_luns
> CISS_MAX_PHYS_LUN
) {
1102 "cciss: Maximum physical LUNs (%d) exceeded. "
1103 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN
,
1104 num_luns
- CISS_MAX_PHYS_LUN
);
1105 num_luns
= CISS_MAX_PHYS_LUN
;
1109 printk(KERN_ERR
"cciss: Report physical LUNs failed.\n");
1114 /* adjust our table of devices */
1115 for (i
= 0; i
< num_luns
; i
++) {
1116 /* for each physical lun, do an inquiry */
1117 if (ld_buff
->LUN
[i
][3] & 0xC0) continue;
1118 memset(inq_buff
, 0, OBDR_TAPE_INQ_SIZE
);
1119 memcpy(&scsi3addr
[0], &ld_buff
->LUN
[i
][0], 8);
1121 if (cciss_scsi_do_inquiry(h
, scsi3addr
, 0, inq_buff
,
1122 (unsigned char) OBDR_TAPE_INQ_SIZE
) != 0)
1123 /* Inquiry failed (msg printed already) */
1124 continue; /* so we will skip this device. */
1126 this_device
->devtype
= (inq_buff
[0] & 0x1f);
1127 this_device
->bus
= -1;
1128 this_device
->target
= -1;
1129 this_device
->lun
= -1;
1130 memcpy(this_device
->scsi3addr
, scsi3addr
, 8);
1131 memcpy(this_device
->vendor
, &inq_buff
[8],
1132 sizeof(this_device
->vendor
));
1133 memcpy(this_device
->model
, &inq_buff
[16],
1134 sizeof(this_device
->model
));
1135 memcpy(this_device
->revision
, &inq_buff
[32],
1136 sizeof(this_device
->revision
));
1137 memset(this_device
->device_id
, 0,
1138 sizeof(this_device
->device_id
));
1139 cciss_scsi_get_device_id(h
, scsi3addr
,
1140 this_device
->device_id
, sizeof(this_device
->device_id
));
1142 switch (this_device
->devtype
)
1144 case 0x05: /* CD-ROM */ {
1146 /* We don't *really* support actual CD-ROM devices,
1147 * just this "One Button Disaster Recovery" tape drive
1148 * which temporarily pretends to be a CD-ROM drive.
1149 * So we check that the device is really an OBDR tape
1150 * device by checking for "$DR-10" in bytes 43-48 of
1155 strncpy(obdr_sig
, &inq_buff
[43], 6);
1157 if (strncmp(obdr_sig
, OBDR_TAPE_SIG
, 6) != 0)
1158 /* Not OBDR device, ignore it. */
1161 /* fall through . . . */
1162 case 0x01: /* sequential access, (tape) */
1163 case 0x08: /* medium changer */
1164 if (ncurrent
>= CCISS_MAX_SCSI_DEVS_PER_HBA
) {
1165 printk(KERN_INFO
"cciss%d: %s ignored, "
1166 "too many devices.\n", h
->ctlr
,
1167 scsi_device_type(this_device
->devtype
));
1170 currentsd
[ncurrent
] = *this_device
;
1178 adjust_cciss_scsi_table(h
, hostno
, currentsd
, ncurrent
);
1187 is_keyword(char *ptr
, int len
, char *verb
) // Thanks to ncr53c8xx.c
1189 int verb_len
= strlen(verb
);
1190 if (len
>= verb_len
&& !memcmp(verb
,ptr
,verb_len
))
1197 cciss_scsi_user_command(ctlr_info_t
*h
, int hostno
, char *buffer
, int length
)
1201 if ((arg_len
= is_keyword(buffer
, length
, "rescan")) != 0)
1202 cciss_update_non_disk_devices(h
, hostno
);
1210 cciss_scsi_proc_info(struct Scsi_Host
*sh
,
1211 char *buffer
, /* data buffer */
1212 char **start
, /* where data in buffer starts */
1213 off_t offset
, /* offset from start of imaginary file */
1214 int length
, /* length of data in buffer */
1215 int func
) /* 0 == read, 1 == write */
1218 int buflen
, datalen
;
1222 h
= (ctlr_info_t
*) sh
->hostdata
[0];
1223 if (h
== NULL
) /* This really shouldn't ever happen. */
1226 if (func
== 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1227 buflen
= sprintf(buffer
, "cciss%d: SCSI host: %d\n",
1228 h
->ctlr
, sh
->host_no
);
1230 /* this information is needed by apps to know which cciss
1231 device corresponds to which scsi host number without
1232 having to open a scsi target device node. The device
1233 information is not a duplicate of /proc/scsi/scsi because
1234 the two may be out of sync due to scsi hotplug, rather
1235 this info is for an app to be able to use to know how to
1236 get them back in sync. */
1238 for (i
= 0; i
< ccissscsi
[h
->ctlr
].ndevices
; i
++) {
1239 struct cciss_scsi_dev_t
*sd
=
1240 &ccissscsi
[h
->ctlr
].dev
[i
];
1241 buflen
+= sprintf(&buffer
[buflen
], "c%db%dt%dl%d %02d "
1242 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1243 sh
->host_no
, sd
->bus
, sd
->target
, sd
->lun
,
1245 sd
->scsi3addr
[0], sd
->scsi3addr
[1],
1246 sd
->scsi3addr
[2], sd
->scsi3addr
[3],
1247 sd
->scsi3addr
[4], sd
->scsi3addr
[5],
1248 sd
->scsi3addr
[6], sd
->scsi3addr
[7]);
1250 datalen
= buflen
- offset
;
1251 if (datalen
< 0) { /* they're reading past EOF. */
1253 *start
= buffer
+buflen
;
1255 *start
= buffer
+ offset
;
1257 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1258 return cciss_scsi_user_command(h
, sh
->host_no
,
1262 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1263 dma mapping and fills in the scatter gather entries of the
1264 cciss command, c. */
1266 static void cciss_scatter_gather(ctlr_info_t
*h
, CommandList_struct
*c
,
1267 struct scsi_cmnd
*cmd
)
1270 struct scatterlist
*sg
;
1272 int request_nsgs
, i
, chained
, sg_index
;
1273 struct cciss_scsi_adapter_data_t
*sa
= h
->scsi_ctlr
;
1274 SGDescriptor_struct
*curr_sg
;
1276 BUG_ON(scsi_sg_count(cmd
) > h
->maxsgentries
);
1281 request_nsgs
= scsi_dma_map(cmd
);
1283 scsi_for_each_sg(cmd
, sg
, request_nsgs
, i
) {
1284 if (sg_index
+ 1 == h
->max_cmd_sgentries
&&
1285 !chained
&& request_nsgs
- i
> 1) {
1288 curr_sg
= sa
->cmd_sg_list
[c
->cmdindex
];
1290 addr64
= (__u64
) sg_dma_address(sg
);
1291 len
= sg_dma_len(sg
);
1292 curr_sg
[sg_index
].Addr
.lower
=
1293 (__u32
) (addr64
& 0x0FFFFFFFFULL
);
1294 curr_sg
[sg_index
].Addr
.upper
=
1295 (__u32
) ((addr64
>> 32) & 0x0FFFFFFFFULL
);
1296 curr_sg
[sg_index
].Len
= len
;
1297 curr_sg
[sg_index
].Ext
= 0;
1301 cciss_map_sg_chain_block(h
, c
,
1302 sa
->cmd_sg_list
[c
->cmdindex
],
1303 (request_nsgs
- (h
->max_cmd_sgentries
- 1)) *
1304 sizeof(SGDescriptor_struct
));
1306 /* track how many SG entries we are using */
1307 if (request_nsgs
> h
->maxSG
)
1308 h
->maxSG
= request_nsgs
;
1309 c
->Header
.SGTotal
= (__u8
) request_nsgs
+ chained
;
1310 if (request_nsgs
> h
->max_cmd_sgentries
)
1311 c
->Header
.SGList
= h
->max_cmd_sgentries
;
1313 c
->Header
.SGList
= c
->Header
.SGTotal
;
1319 cciss_scsi_queue_command (struct scsi_cmnd
*cmd
, void (* done
)(struct scsi_cmnd
*))
1323 unsigned char scsi3addr
[8];
1324 CommandList_struct
*c
;
1325 unsigned long flags
;
1327 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1328 // We violate cmd->host privacy here. (Is there another way?)
1329 h
= (ctlr_info_t
*) cmd
->device
->host
->hostdata
[0];
1331 rc
= lookup_scsi3addr(h
, cmd
->device
->channel
, cmd
->device
->id
,
1332 cmd
->device
->lun
, scsi3addr
);
1334 /* the scsi nexus does not match any that we presented... */
1335 /* pretend to mid layer that we got selection timeout */
1336 cmd
->result
= DID_NO_CONNECT
<< 16;
1338 /* we might want to think about registering controller itself
1339 as a processor device on the bus so sg binds to it. */
1343 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1344 see what the device thinks of it. */
1346 spin_lock_irqsave(&h
->lock
, flags
);
1347 c
= scsi_cmd_alloc(h
);
1348 spin_unlock_irqrestore(&h
->lock
, flags
);
1349 if (c
== NULL
) { /* trouble... */
1350 dev_warn(&h
->pdev
->dev
, "scsi_cmd_alloc returned NULL!\n");
1351 cmd
->result
= DID_NO_CONNECT
<< 16;
1356 // Fill in the command list header
1358 cmd
->scsi_done
= done
; // save this for use by completion code
1360 /* save c in case we have to abort it */
1361 cmd
->host_scribble
= (unsigned char *) c
;
1363 c
->cmd_type
= CMD_SCSI
;
1365 c
->Header
.ReplyQueue
= 0; /* unused in simple mode */
1366 memcpy(&c
->Header
.LUN
.LunAddrBytes
[0], &scsi3addr
[0], 8);
1367 c
->Header
.Tag
.lower
= c
->busaddr
; /* Use k. address of cmd as tag */
1369 // Fill in the request block...
1371 c
->Request
.Timeout
= 0;
1372 memset(c
->Request
.CDB
, 0, sizeof(c
->Request
.CDB
));
1373 BUG_ON(cmd
->cmd_len
> sizeof(c
->Request
.CDB
));
1374 c
->Request
.CDBLen
= cmd
->cmd_len
;
1375 memcpy(c
->Request
.CDB
, cmd
->cmnd
, cmd
->cmd_len
);
1376 c
->Request
.Type
.Type
= TYPE_CMD
;
1377 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1378 switch(cmd
->sc_data_direction
)
1381 c
->Request
.Type
.Direction
= XFER_WRITE
;
1383 case DMA_FROM_DEVICE
:
1384 c
->Request
.Type
.Direction
= XFER_READ
;
1387 c
->Request
.Type
.Direction
= XFER_NONE
;
1389 case DMA_BIDIRECTIONAL
:
1390 // This can happen if a buggy application does a scsi passthru
1391 // and sets both inlen and outlen to non-zero. ( see
1392 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1394 c
->Request
.Type
.Direction
= XFER_RSVD
;
1395 // This is technically wrong, and cciss controllers should
1396 // reject it with CMD_INVALID, which is the most correct
1397 // response, but non-fibre backends appear to let it
1398 // slide by, and give the same results as if this field
1399 // were set correctly. Either way is acceptable for
1400 // our purposes here.
1405 dev_warn(&h
->pdev
->dev
, "unknown data direction: %d\n",
1406 cmd
->sc_data_direction
);
1410 cciss_scatter_gather(h
, c
, cmd
);
1411 enqueue_cmd_and_start_io(h
, c
);
1412 /* the cmd'll come back via intr handler in complete_scsi_command() */
1416 static void cciss_unregister_scsi(ctlr_info_t
*h
)
1418 struct cciss_scsi_adapter_data_t
*sa
;
1419 struct cciss_scsi_cmd_stack_t
*stk
;
1420 unsigned long flags
;
1422 /* we are being forcibly unloaded, and may not refuse. */
1424 spin_lock_irqsave(&h
->lock
, flags
);
1426 stk
= &sa
->cmd_stack
;
1428 /* if we weren't ever actually registered, don't unregister */
1429 if (sa
->registered
) {
1430 spin_unlock_irqrestore(&h
->lock
, flags
);
1431 scsi_remove_host(sa
->scsi_host
);
1432 scsi_host_put(sa
->scsi_host
);
1433 spin_lock_irqsave(&h
->lock
, flags
);
1436 /* set scsi_host to NULL so our detect routine will
1437 find us on register */
1438 sa
->scsi_host
= NULL
;
1439 spin_unlock_irqrestore(&h
->lock
, flags
);
1440 scsi_cmd_stack_free(h
);
1444 static int cciss_engage_scsi(ctlr_info_t
*h
)
1446 struct cciss_scsi_adapter_data_t
*sa
;
1447 struct cciss_scsi_cmd_stack_t
*stk
;
1448 unsigned long flags
;
1450 spin_lock_irqsave(&h
->lock
, flags
);
1452 stk
= &sa
->cmd_stack
;
1454 if (sa
->registered
) {
1455 dev_info(&h
->pdev
->dev
, "SCSI subsystem already engaged.\n");
1456 spin_unlock_irqrestore(&h
->lock
, flags
);
1460 spin_unlock_irqrestore(&h
->lock
, flags
);
1461 cciss_update_non_disk_devices(h
, -1);
1462 cciss_scsi_detect(h
);
1467 cciss_seq_tape_report(struct seq_file
*seq
, ctlr_info_t
*h
)
1469 unsigned long flags
;
1471 CPQ_TAPE_LOCK(h
, flags
);
1473 "Sequential access devices: %d\n\n",
1474 ccissscsi
[h
->ctlr
].ndevices
);
1475 CPQ_TAPE_UNLOCK(h
, flags
);
1478 static int wait_for_device_to_become_ready(ctlr_info_t
*h
,
1479 unsigned char lunaddr
[])
1484 CommandList_struct
*c
;
1488 dev_warn(&h
->pdev
->dev
, "out of memory in "
1489 "wait_for_device_to_become_ready.\n");
1493 /* Send test unit ready until device ready, or give up. */
1494 while (count
< 20) {
1496 /* Wait for a bit. do this first, because if we send
1497 * the TUR right away, the reset will just abort it.
1499 schedule_timeout_uninterruptible(waittime
);
1502 /* Increase wait time with each try, up to a point. */
1503 if (waittime
< (HZ
* 30))
1504 waittime
= waittime
* 2;
1506 /* Send the Test Unit Ready */
1507 rc
= fill_cmd(h
, c
, TEST_UNIT_READY
, NULL
, 0, 0,
1510 rc
= sendcmd_withirq_core(h
, c
, 0);
1512 (void) process_sendcmd_error(h
, c
);
1517 if (c
->err_info
->CommandStatus
== CMD_SUCCESS
)
1520 if (c
->err_info
->CommandStatus
== CMD_TARGET_STATUS
&&
1521 c
->err_info
->ScsiStatus
== SAM_STAT_CHECK_CONDITION
) {
1522 if (c
->err_info
->SenseInfo
[2] == NO_SENSE
)
1524 if (c
->err_info
->SenseInfo
[2] == UNIT_ATTENTION
) {
1526 asc
= c
->err_info
->SenseInfo
[12];
1527 check_for_unit_attention(h
, c
);
1528 if (asc
== POWER_OR_RESET
)
1533 dev_warn(&h
->pdev
->dev
, "Waiting %d secs "
1534 "for device to become ready.\n",
1536 rc
= 1; /* device not ready. */
1540 dev_warn(&h
->pdev
->dev
, "giving up on device.\n");
1542 dev_warn(&h
->pdev
->dev
, "device is ready.\n");
1548 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1549 * complaining. Doing a host- or bus-reset can't do anything good here.
1550 * Despite what it might say in scsi_error.c, there may well be commands
1551 * on the controller, as the cciss driver registers twice, once as a block
1552 * device for the logical drives, and once as a scsi device, for any tape
1553 * drives. So we know there are no commands out on the tape drives, but we
1554 * don't know there are no commands on the controller, and it is likely
1555 * that there probably are, as the cciss block device is most commonly used
1556 * as a boot device (embedded controller on HP/Compaq systems.)
1559 static int cciss_eh_device_reset_handler(struct scsi_cmnd
*scsicmd
)
1562 CommandList_struct
*cmd_in_trouble
;
1563 unsigned char lunaddr
[8];
1566 /* find the controller to which the command to be aborted was sent */
1567 h
= (ctlr_info_t
*) scsicmd
->device
->host
->hostdata
[0];
1568 if (h
== NULL
) /* paranoia */
1570 dev_warn(&h
->pdev
->dev
, "resetting tape drive or medium changer.\n");
1571 /* find the command that's giving us trouble */
1572 cmd_in_trouble
= (CommandList_struct
*) scsicmd
->host_scribble
;
1573 if (cmd_in_trouble
== NULL
) /* paranoia */
1575 memcpy(lunaddr
, &cmd_in_trouble
->Header
.LUN
.LunAddrBytes
[0], 8);
1576 /* send a reset to the SCSI LUN which the command was sent to */
1577 rc
= sendcmd_withirq(h
, CCISS_RESET_MSG
, NULL
, 0, 0, lunaddr
,
1579 if (rc
== 0 && wait_for_device_to_become_ready(h
, lunaddr
) == 0)
1581 dev_warn(&h
->pdev
->dev
, "resetting device failed.\n");
1585 static int cciss_eh_abort_handler(struct scsi_cmnd
*scsicmd
)
1588 CommandList_struct
*cmd_to_abort
;
1589 unsigned char lunaddr
[8];
1592 /* find the controller to which the command to be aborted was sent */
1593 h
= (ctlr_info_t
*) scsicmd
->device
->host
->hostdata
[0];
1594 if (h
== NULL
) /* paranoia */
1596 dev_warn(&h
->pdev
->dev
, "aborting tardy SCSI cmd\n");
1598 /* find the command to be aborted */
1599 cmd_to_abort
= (CommandList_struct
*) scsicmd
->host_scribble
;
1600 if (cmd_to_abort
== NULL
) /* paranoia */
1602 memcpy(lunaddr
, &cmd_to_abort
->Header
.LUN
.LunAddrBytes
[0], 8);
1603 rc
= sendcmd_withirq(h
, CCISS_ABORT_MSG
, &cmd_to_abort
->Header
.Tag
,
1604 0, 0, lunaddr
, TYPE_MSG
);
1611 #else /* no CONFIG_CISS_SCSI_TAPE */
1613 /* If no tape support, then these become defined out of existence */
1615 #define cciss_scsi_setup(cntl_num)
1617 #endif /* CONFIG_CISS_SCSI_TAPE */