1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#ifdef CONFIG_CISS_SCSI_TAPE
24
25
26
27
28
29
30
31#include <linux/timer.h>
32#include <linux/completion.h>
33#include <linux/slab.h>
34#include <linux/string.h>
35
36#include <asm/atomic.h>
37
38#include <scsi/scsi_cmnd.h>
39#include <scsi/scsi_device.h>
40#include <scsi/scsi_host.h>
41
42#include "cciss_scsi.h"
43
44#define CCISS_ABORT_MSG 0x00
45#define CCISS_RESET_MSG 0x01
46
47static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
48 size_t size,
49 __u8 page_code, unsigned char *scsi3addr,
50 int cmd_type);
51
52static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
53static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
54
55static int cciss_scsi_proc_info(
56 struct Scsi_Host *sh,
57 char *buffer,
58 char **start,
59 off_t offset,
60 int length,
61 int func);
62
63static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
64 void (* done)(struct scsi_cmnd *));
65static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
66static int cciss_eh_abort_handler(struct scsi_cmnd *);
67
68static 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 },
77};
78
79static struct scsi_host_template cciss_driver_template = {
80 .module = THIS_MODULE,
81 .name = "cciss",
82 .proc_name = "cciss",
83 .proc_info = cciss_scsi_proc_info,
84 .queuecommand = cciss_scsi_queue_command,
85 .can_queue = SCSI_CCISS_CAN_QUEUE,
86 .this_id = 7,
87 .sg_tablesize = MAXSGENTRIES,
88 .cmd_per_lun = 1,
89 .use_clustering = DISABLE_CLUSTERING,
90
91 .eh_device_reset_handler= cciss_eh_device_reset_handler,
92 .eh_abort_handler = cciss_eh_abort_handler,
93};
94
95#pragma pack(1)
96struct cciss_scsi_cmd_stack_elem_t {
97 CommandList_struct cmd;
98 ErrorInfo_struct Err;
99 __u32 busaddr;
100 __u32 pad;
101};
102
103#pragma pack()
104
105#define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
106 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
107
108
109#pragma pack(1)
110struct cciss_scsi_cmd_stack_t {
111 struct cciss_scsi_cmd_stack_elem_t *pool;
112 struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
113 dma_addr_t cmd_pool_handle;
114 int top;
115};
116#pragma pack()
117
118struct cciss_scsi_adapter_data_t {
119 struct Scsi_Host *scsi_host;
120 struct cciss_scsi_cmd_stack_t cmd_stack;
121 int registered;
122 spinlock_t lock;
123};
124
125#define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
126 &(((struct cciss_scsi_adapter_data_t *) \
127 hba[ctlr]->scsi_ctlr)->lock), flags);
128#define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
129 &(((struct cciss_scsi_adapter_data_t *) \
130 hba[ctlr]->scsi_ctlr)->lock), flags);
131
132static CommandList_struct *
133scsi_cmd_alloc(ctlr_info_t *h)
134{
135
136
137
138
139
140
141 struct cciss_scsi_cmd_stack_elem_t *c;
142 struct cciss_scsi_adapter_data_t *sa;
143 struct cciss_scsi_cmd_stack_t *stk;
144 u64bit temp64;
145
146 sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
147 stk = &sa->cmd_stack;
148
149 if (stk->top < 0)
150 return NULL;
151 c = stk->elem[stk->top];
152
153 memset(&c->cmd, 0, sizeof(c->cmd));
154 memset(&c->Err, 0, sizeof(c->Err));
155
156 c->cmd.busaddr = c->busaddr;
157
158
159
160 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
161
162
163
164 stk->top--;
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);
168
169 c->cmd.ctlr = h->ctlr;
170 c->cmd.err_info = &c->Err;
171
172 return (CommandList_struct *) c;
173}
174
175static void
176scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
177{
178
179
180
181
182 struct cciss_scsi_adapter_data_t *sa;
183 struct cciss_scsi_cmd_stack_t *stk;
184
185 sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
186 stk = &sa->cmd_stack;
187 if (stk->top >= CMD_STACK_SIZE) {
188 printk("cciss: scsi_cmd_free called too many times.\n");
189 BUG();
190 }
191 stk->top++;
192 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
193}
194
195static int
196scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
197{
198 int i;
199 struct cciss_scsi_cmd_stack_t *stk;
200 size_t size;
201
202 stk = &sa->cmd_stack;
203 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
204
205
206
207
208 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
209 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
210
211 if (stk->pool == NULL) {
212 printk("stk->pool is null\n");
213 return -1;
214 }
215
216 for (i=0; i<CMD_STACK_SIZE; i++) {
217 stk->elem[i] = &stk->pool[i];
218 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
219 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
220 }
221 stk->top = CMD_STACK_SIZE-1;
222 return 0;
223}
224
225static void
226scsi_cmd_stack_free(int ctlr)
227{
228 struct cciss_scsi_adapter_data_t *sa;
229 struct cciss_scsi_cmd_stack_t *stk;
230 size_t size;
231
232 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
233 stk = &sa->cmd_stack;
234 if (stk->top != CMD_STACK_SIZE-1) {
235 printk( "cciss: %d scsi commands are still outstanding.\n",
236 CMD_STACK_SIZE - stk->top);
237
238 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
239 }
240 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
241
242 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
243 stk->pool = NULL;
244}
245
246#if 0
247static int xmargin=8;
248static int amargin=60;
249
250static void
251print_bytes (unsigned char *c, int len, int hex, int ascii)
252{
253
254 int i;
255 unsigned char *x;
256
257 if (hex)
258 {
259 x = c;
260 for (i=0;i<len;i++)
261 {
262 if ((i % xmargin) == 0 && i>0) printk("\n");
263 if ((i % xmargin) == 0) printk("0x%04x:", i);
264 printk(" %02x", *x);
265 x++;
266 }
267 printk("\n");
268 }
269 if (ascii)
270 {
271 x = c;
272 for (i=0;i<len;i++)
273 {
274 if ((i % amargin) == 0 && i>0) printk("\n");
275 if ((i % amargin) == 0) printk("0x%04x:", i);
276 if (*x > 26 && *x < 128) printk("%c", *x);
277 else printk(".");
278 x++;
279 }
280 printk("\n");
281 }
282}
283
284static void
285print_cmd(CommandList_struct *cp)
286{
287 printk("queue:%d\n", cp->Header.ReplyQueue);
288 printk("sglist:%d\n", cp->Header.SGList);
289 printk("sgtot:%d\n", cp->Header.SGTotal);
290 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
291 cp->Header.Tag.lower);
292 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
293 cp->Header.LUN.LunAddrBytes[0],
294 cp->Header.LUN.LunAddrBytes[1],
295 cp->Header.LUN.LunAddrBytes[2],
296 cp->Header.LUN.LunAddrBytes[3],
297 cp->Header.LUN.LunAddrBytes[4],
298 cp->Header.LUN.LunAddrBytes[5],
299 cp->Header.LUN.LunAddrBytes[6],
300 cp->Header.LUN.LunAddrBytes[7]);
301 printk("CDBLen:%d\n", cp->Request.CDBLen);
302 printk("Type:%d\n",cp->Request.Type.Type);
303 printk("Attr:%d\n",cp->Request.Type.Attribute);
304 printk(" Dir:%d\n",cp->Request.Type.Direction);
305 printk("Timeout:%d\n",cp->Request.Timeout);
306 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
307 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
308 cp->Request.CDB[0], cp->Request.CDB[1],
309 cp->Request.CDB[2], cp->Request.CDB[3],
310 cp->Request.CDB[4], cp->Request.CDB[5],
311 cp->Request.CDB[6], cp->Request.CDB[7],
312 cp->Request.CDB[8], cp->Request.CDB[9],
313 cp->Request.CDB[10], cp->Request.CDB[11],
314 cp->Request.CDB[12], cp->Request.CDB[13],
315 cp->Request.CDB[14], cp->Request.CDB[15]),
316 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
317 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
318 cp->ErrDesc.Len);
319 printk("sgs..........Errorinfo:\n");
320 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
321 printk("senselen:%d\n", cp->err_info->SenseLen);
322 printk("cmd status:%d\n", cp->err_info->CommandStatus);
323 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
324 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
325 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
326 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
327
328}
329
330#endif
331
332static int
333find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
334{
335
336
337 int i, found=0;
338 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
339
340 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
341
342 target_taken[SELF_SCSI_ID] = 1;
343 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
344 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
345
346 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
347 if (!target_taken[i]) {
348 *bus = 0; *target=i; *lun = 0; found=1;
349 break;
350 }
351 }
352 return (!found);
353}
354struct scsi2map {
355 char scsi3addr[8];
356 int bus, target, lun;
357};
358
359static int
360cciss_scsi_add_entry(int ctlr, int hostno,
361 struct cciss_scsi_dev_t *device,
362 struct scsi2map *added, int *nadded)
363{
364
365 int n = ccissscsi[ctlr].ndevices;
366 struct cciss_scsi_dev_t *sd;
367 int i, bus, target, lun;
368 unsigned char addr1[8], addr2[8];
369
370 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
371 printk("cciss%d: Too many devices, "
372 "some will be inaccessible.\n", ctlr);
373 return -1;
374 }
375
376 bus = target = -1;
377 lun = 0;
378
379
380 if (device->scsi3addr[4] != 0) {
381
382
383
384
385 memcpy(addr1, device->scsi3addr, 8);
386 addr1[4] = 0;
387 for (i = 0; i < n; i++) {
388 sd = &ccissscsi[ctlr].dev[i];
389 memcpy(addr2, sd->scsi3addr, 8);
390 addr2[4] = 0;
391
392 if (memcmp(addr1, addr2, 8) == 0) {
393 bus = sd->bus;
394 target = sd->target;
395 lun = device->scsi3addr[4];
396 break;
397 }
398 }
399 }
400
401 sd = &ccissscsi[ctlr].dev[n];
402 if (lun == 0) {
403 if (find_bus_target_lun(ctlr,
404 &sd->bus, &sd->target, &sd->lun) != 0)
405 return -1;
406 } else {
407 sd->bus = bus;
408 sd->target = target;
409 sd->lun = lun;
410 }
411 added[*nadded].bus = sd->bus;
412 added[*nadded].target = sd->target;
413 added[*nadded].lun = sd->lun;
414 (*nadded)++;
415
416 memcpy(sd->scsi3addr, device->scsi3addr, 8);
417 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
418 memcpy(sd->revision, device->revision, sizeof(sd->revision));
419 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
420 sd->devtype = device->devtype;
421
422 ccissscsi[ctlr].ndevices++;
423
424
425
426
427 if (hostno != -1)
428 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
429 ctlr, scsi_device_type(sd->devtype), hostno,
430 sd->bus, sd->target, sd->lun);
431 return 0;
432}
433
434static void
435cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
436 struct scsi2map *removed, int *nremoved)
437{
438
439 int i;
440 struct cciss_scsi_dev_t sd;
441
442 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
443 sd = ccissscsi[ctlr].dev[entry];
444 removed[*nremoved].bus = sd.bus;
445 removed[*nremoved].target = sd.target;
446 removed[*nremoved].lun = sd.lun;
447 (*nremoved)++;
448 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
449 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
450 ccissscsi[ctlr].ndevices--;
451 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
452 ctlr, scsi_device_type(sd.devtype), hostno,
453 sd.bus, sd.target, sd.lun);
454}
455
456
457#define SCSI3ADDR_EQ(a,b) ( \
458 (a)[7] == (b)[7] && \
459 (a)[6] == (b)[6] && \
460 (a)[5] == (b)[5] && \
461 (a)[4] == (b)[4] && \
462 (a)[3] == (b)[3] && \
463 (a)[2] == (b)[2] && \
464 (a)[1] == (b)[1] && \
465 (a)[0] == (b)[0])
466
467static void fixup_botched_add(int ctlr, char *scsi3addr)
468{
469
470
471 unsigned long flags;
472 int i, j;
473 CPQ_TAPE_LOCK(ctlr, flags);
474 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
475 if (memcmp(scsi3addr,
476 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
477 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
478 ccissscsi[ctlr].dev[j] =
479 ccissscsi[ctlr].dev[j+1];
480 ccissscsi[ctlr].ndevices--;
481 break;
482 }
483 }
484 CPQ_TAPE_UNLOCK(ctlr, flags);
485}
486
487static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
488 struct cciss_scsi_dev_t *dev2)
489{
490 return dev1->devtype == dev2->devtype &&
491 memcmp(dev1->scsi3addr, dev2->scsi3addr,
492 sizeof(dev1->scsi3addr)) == 0 &&
493 memcmp(dev1->device_id, dev2->device_id,
494 sizeof(dev1->device_id)) == 0 &&
495 memcmp(dev1->vendor, dev2->vendor,
496 sizeof(dev1->vendor)) == 0 &&
497 memcmp(dev1->model, dev2->model,
498 sizeof(dev1->model)) == 0 &&
499 memcmp(dev1->revision, dev2->revision,
500 sizeof(dev1->revision)) == 0;
501}
502
503static int
504adjust_cciss_scsi_table(int ctlr, int hostno,
505 struct cciss_scsi_dev_t sd[], int nsds)
506{
507
508
509
510
511
512 int i,j, found, changes=0;
513 struct cciss_scsi_dev_t *csd;
514 unsigned long flags;
515 struct scsi2map *added, *removed;
516 int nadded, nremoved;
517 struct Scsi_Host *sh = NULL;
518
519 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
520 GFP_KERNEL);
521 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
522 GFP_KERNEL);
523
524 if (!added || !removed) {
525 printk(KERN_WARNING "cciss%d: Out of memory in "
526 "adjust_cciss_scsi_table\n", ctlr);
527 goto free_and_out;
528 }
529
530 CPQ_TAPE_LOCK(ctlr, flags);
531
532 if (hostno != -1)
533 sh = ((struct cciss_scsi_adapter_data_t *)
534 hba[ctlr]->scsi_ctlr)->scsi_host;
535
536
537
538
539 i = 0;
540 nremoved = 0;
541 nadded = 0;
542 while(i<ccissscsi[ctlr].ndevices) {
543 csd = &ccissscsi[ctlr].dev[i];
544 found=0;
545 for (j=0;j<nsds;j++) {
546 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
547 csd->scsi3addr)) {
548 if (device_is_the_same(&sd[j], csd))
549 found=2;
550 else
551 found=1;
552 break;
553 }
554 }
555
556 if (found == 0) {
557 changes++;
558
559
560
561 cciss_scsi_remove_entry(ctlr, hostno, i,
562 removed, &nremoved);
563
564 } else if (found == 1) {
565 changes++;
566 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
567 ctlr, hostno, csd->bus, csd->target, csd->lun);
568 cciss_scsi_remove_entry(ctlr, hostno, i,
569 removed, &nremoved);
570
571 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
572 added, &nadded) != 0)
573
574 BUG();
575 csd->devtype = sd[j].devtype;
576 memcpy(csd->device_id, sd[j].device_id,
577 sizeof(csd->device_id));
578 memcpy(csd->vendor, sd[j].vendor,
579 sizeof(csd->vendor));
580 memcpy(csd->model, sd[j].model,
581 sizeof(csd->model));
582 memcpy(csd->revision, sd[j].revision,
583 sizeof(csd->revision));
584 } else
585 i++;
586 }
587
588
589
590
591 for (i=0;i<nsds;i++) {
592 found=0;
593 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
594 csd = &ccissscsi[ctlr].dev[j];
595 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
596 csd->scsi3addr)) {
597 if (device_is_the_same(&sd[i], csd))
598 found=2;
599 else
600 found=1;
601 break;
602 }
603 }
604 if (!found) {
605 changes++;
606 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
607 added, &nadded) != 0)
608 break;
609 } else if (found == 1) {
610
611 changes++;
612 printk(KERN_WARNING "cciss%d: device "
613 "unexpectedly changed\n", ctlr);
614
615 }
616 }
617 CPQ_TAPE_UNLOCK(ctlr, flags);
618
619
620
621
622 if (hostno == -1 || !changes)
623 goto free_and_out;
624
625
626 for (i = 0; i < nremoved; i++) {
627 struct scsi_device *sdev =
628 scsi_device_lookup(sh, removed[i].bus,
629 removed[i].target, removed[i].lun);
630 if (sdev != NULL) {
631 scsi_remove_device(sdev);
632 scsi_device_put(sdev);
633 } else {
634
635
636
637 printk(KERN_WARNING "cciss%d: didn't find "
638 "c%db%dt%dl%d\n for removal.",
639 ctlr, hostno, removed[i].bus,
640 removed[i].target, removed[i].lun);
641 }
642 }
643
644
645 for (i = 0; i < nadded; i++) {
646 int rc;
647 rc = scsi_add_device(sh, added[i].bus,
648 added[i].target, added[i].lun);
649 if (rc == 0)
650 continue;
651 printk(KERN_WARNING "cciss%d: scsi_add_device "
652 "c%db%dt%dl%d failed, device not added.\n",
653 ctlr, hostno,
654 added[i].bus, added[i].target, added[i].lun);
655
656
657 fixup_botched_add(ctlr, added[i].scsi3addr);
658 }
659
660free_and_out:
661 kfree(added);
662 kfree(removed);
663 return 0;
664}
665
666static int
667lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
668{
669 int i;
670 struct cciss_scsi_dev_t *sd;
671 unsigned long flags;
672
673 CPQ_TAPE_LOCK(ctlr, flags);
674 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
675 sd = &ccissscsi[ctlr].dev[i];
676 if (sd->bus == bus &&
677 sd->target == target &&
678 sd->lun == lun) {
679 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
680 CPQ_TAPE_UNLOCK(ctlr, flags);
681 return 0;
682 }
683 }
684 CPQ_TAPE_UNLOCK(ctlr, flags);
685 return -1;
686}
687
688static void
689cciss_scsi_setup(int cntl_num)
690{
691 struct cciss_scsi_adapter_data_t * shba;
692
693 ccissscsi[cntl_num].ndevices = 0;
694 shba = (struct cciss_scsi_adapter_data_t *)
695 kmalloc(sizeof(*shba), GFP_KERNEL);
696 if (shba == NULL)
697 return;
698 shba->scsi_host = NULL;
699 spin_lock_init(&shba->lock);
700 shba->registered = 0;
701 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
702 kfree(shba);
703 shba = NULL;
704 }
705 hba[cntl_num]->scsi_ctlr = (void *) shba;
706 return;
707}
708
709static void
710complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
711{
712 struct scsi_cmnd *cmd;
713 ctlr_info_t *ctlr;
714 ErrorInfo_struct *ei;
715
716 ei = cp->err_info;
717
718
719 if (cp->Request.Type.Type == TYPE_MSG) {
720 cp->cmd_type = CMD_MSG_DONE;
721 return;
722 }
723
724 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
725 ctlr = hba[cp->ctlr];
726
727 scsi_dma_unmap(cmd);
728
729 cmd->result = (DID_OK << 16);
730 cmd->result |= (COMMAND_COMPLETE << 8);
731
732
733 cmd->result |= (ei->ScsiStatus);
734
735
736
737
738 memcpy(cmd->sense_buffer, ei->SenseInfo,
739 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
740 SCSI_SENSE_BUFFERSIZE :
741 ei->SenseLen);
742 scsi_set_resid(cmd, ei->ResidualCnt);
743
744 if(ei->CommandStatus != 0)
745 {
746 switch(ei->CommandStatus)
747 {
748 case CMD_TARGET_STATUS:
749
750 if( ei->ScsiStatus)
751 {
752#if 0
753 printk(KERN_WARNING "cciss: cmd %p "
754 "has SCSI Status = %x\n",
755 cp,
756 ei->ScsiStatus);
757#endif
758 cmd->result |= (ei->ScsiStatus < 1);
759 }
760 else {
761
762
763
764
765
766
767
768
769
770 cmd->result = DID_NO_CONNECT << 16;
771 }
772 break;
773 case CMD_DATA_UNDERRUN:
774 break;
775 case CMD_DATA_OVERRUN:
776 printk(KERN_WARNING "cciss: cp %p has"
777 " completed with data overrun "
778 "reported\n", cp);
779 break;
780 case CMD_INVALID: {
781
782
783
784
785
786
787
788 cmd->result = DID_NO_CONNECT << 16;
789 }
790 break;
791 case CMD_PROTOCOL_ERR:
792 printk(KERN_WARNING "cciss: cp %p has "
793 "protocol error \n", cp);
794 break;
795 case CMD_HARDWARE_ERR:
796 cmd->result = DID_ERROR << 16;
797 printk(KERN_WARNING "cciss: cp %p had "
798 " hardware error\n", cp);
799 break;
800 case CMD_CONNECTION_LOST:
801 cmd->result = DID_ERROR << 16;
802 printk(KERN_WARNING "cciss: cp %p had "
803 "connection lost\n", cp);
804 break;
805 case CMD_ABORTED:
806 cmd->result = DID_ABORT << 16;
807 printk(KERN_WARNING "cciss: cp %p was "
808 "aborted\n", cp);
809 break;
810 case CMD_ABORT_FAILED:
811 cmd->result = DID_ERROR << 16;
812 printk(KERN_WARNING "cciss: cp %p reports "
813 "abort failed\n", cp);
814 break;
815 case CMD_UNSOLICITED_ABORT:
816 cmd->result = DID_ABORT << 16;
817 printk(KERN_WARNING "cciss: cp %p aborted "
818 "do to an unsolicited abort\n", cp);
819 break;
820 case CMD_TIMEOUT:
821 cmd->result = DID_TIME_OUT << 16;
822 printk(KERN_WARNING "cciss: cp %p timedout\n",
823 cp);
824 break;
825 default:
826 cmd->result = DID_ERROR << 16;
827 printk(KERN_WARNING "cciss: cp %p returned "
828 "unknown status %x\n", cp,
829 ei->CommandStatus);
830 }
831 }
832
833
834 cmd->scsi_done(cmd);
835 scsi_cmd_free(ctlr, cp);
836}
837
838static int
839cciss_scsi_detect(int ctlr)
840{
841 struct Scsi_Host *sh;
842 int error;
843
844 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
845 if (sh == NULL)
846 goto fail;
847 sh->io_port = 0;
848 sh->n_io_port = 0;
849 sh->this_id = SELF_SCSI_ID;
850
851 ((struct cciss_scsi_adapter_data_t *)
852 hba[ctlr]->scsi_ctlr)->scsi_host = (void *) sh;
853 sh->hostdata[0] = (unsigned long) hba[ctlr];
854 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
855 sh->unique_id = sh->irq;
856 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
857 if (error)
858 goto fail_host_put;
859 scsi_scan_host(sh);
860 return 1;
861
862 fail_host_put:
863 scsi_host_put(sh);
864 fail:
865 return 0;
866}
867
868static void
869cciss_unmap_one(struct pci_dev *pdev,
870 CommandList_struct *cp,
871 size_t buflen,
872 int data_direction)
873{
874 u64bit addr64;
875
876 addr64.val32.lower = cp->SG[0].Addr.lower;
877 addr64.val32.upper = cp->SG[0].Addr.upper;
878 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
879}
880
881static void
882cciss_map_one(struct pci_dev *pdev,
883 CommandList_struct *cp,
884 unsigned char *buf,
885 size_t buflen,
886 int data_direction)
887{
888 __u64 addr64;
889
890 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
891 cp->SG[0].Addr.lower =
892 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
893 cp->SG[0].Addr.upper =
894 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
895 cp->SG[0].Len = buflen;
896 cp->Header.SGList = (__u8) 1;
897 cp->Header.SGTotal = (__u16) 1;
898}
899
900static int
901cciss_scsi_do_simple_cmd(ctlr_info_t *c,
902 CommandList_struct *cp,
903 unsigned char *scsi3addr,
904 unsigned char *cdb,
905 unsigned char cdblen,
906 unsigned char *buf, int bufsize,
907 int direction)
908{
909 unsigned long flags;
910 DECLARE_COMPLETION_ONSTACK(wait);
911
912 cp->cmd_type = CMD_IOCTL_PEND;
913 cp->scsi_cmd = NULL;
914 cp->Header.ReplyQueue = 0;
915 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
916 cp->Header.Tag.lower = cp->busaddr;
917
918
919
920
921
922
923 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
924 memcpy(cp->Request.CDB, cdb, cdblen);
925 cp->Request.Timeout = 0;
926 cp->Request.CDBLen = cdblen;
927 cp->Request.Type.Type = TYPE_CMD;
928 cp->Request.Type.Attribute = ATTR_SIMPLE;
929 cp->Request.Type.Direction = direction;
930
931
932 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
933 bufsize, DMA_FROM_DEVICE);
934
935 cp->waiting = &wait;
936
937
938 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
939 addQ(&c->reqQ, cp);
940 c->Qdepth++;
941 start_io(c);
942 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
943
944 wait_for_completion(&wait);
945
946
947 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
948 return(0);
949}
950
951static void
952cciss_scsi_interpret_error(CommandList_struct *cp)
953{
954 ErrorInfo_struct *ei;
955
956 ei = cp->err_info;
957 switch(ei->CommandStatus)
958 {
959 case CMD_TARGET_STATUS:
960 printk(KERN_WARNING "cciss: cmd %p has "
961 "completed with errors\n", cp);
962 printk(KERN_WARNING "cciss: cmd %p "
963 "has SCSI Status = %x\n",
964 cp,
965 ei->ScsiStatus);
966 if (ei->ScsiStatus == 0)
967 printk(KERN_WARNING
968 "cciss:SCSI status is abnormally zero. "
969 "(probably indicates selection timeout "
970 "reported incorrectly due to a known "
971 "firmware bug, circa July, 2001.)\n");
972 break;
973 case CMD_DATA_UNDERRUN:
974 printk("UNDERRUN\n");
975 break;
976 case CMD_DATA_OVERRUN:
977 printk(KERN_WARNING "cciss: cp %p has"
978 " completed with data overrun "
979 "reported\n", cp);
980 break;
981 case CMD_INVALID: {
982
983
984 printk(KERN_WARNING "cciss: cp %p is "
985 "reported invalid (probably means "
986 "target device no longer present)\n",
987 cp);
988
989
990 }
991 break;
992 case CMD_PROTOCOL_ERR:
993 printk(KERN_WARNING "cciss: cp %p has "
994 "protocol error \n", cp);
995 break;
996 case CMD_HARDWARE_ERR:
997
998 printk(KERN_WARNING "cciss: cp %p had "
999 " hardware error\n", cp);
1000 break;
1001 case CMD_CONNECTION_LOST:
1002 printk(KERN_WARNING "cciss: cp %p had "
1003 "connection lost\n", cp);
1004 break;
1005 case CMD_ABORTED:
1006 printk(KERN_WARNING "cciss: cp %p was "
1007 "aborted\n", cp);
1008 break;
1009 case CMD_ABORT_FAILED:
1010 printk(KERN_WARNING "cciss: cp %p reports "
1011 "abort failed\n", cp);
1012 break;
1013 case CMD_UNSOLICITED_ABORT:
1014 printk(KERN_WARNING "cciss: cp %p aborted "
1015 "do to an unsolicited abort\n", cp);
1016 break;
1017 case CMD_TIMEOUT:
1018 printk(KERN_WARNING "cciss: cp %p timedout\n",
1019 cp);
1020 break;
1021 default:
1022 printk(KERN_WARNING "cciss: cp %p returned "
1023 "unknown status %x\n", cp,
1024 ei->CommandStatus);
1025 }
1026}
1027
1028static int
1029cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1030 unsigned char page, unsigned char *buf,
1031 unsigned char bufsize)
1032{
1033 int rc;
1034 CommandList_struct *cp;
1035 char cdb[6];
1036 ErrorInfo_struct *ei;
1037 unsigned long flags;
1038
1039 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1040 cp = scsi_cmd_alloc(c);
1041 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1042
1043 if (cp == NULL) {
1044 printk("cmd_alloc returned NULL!\n");
1045 return -1;
1046 }
1047
1048 ei = cp->err_info;
1049
1050 cdb[0] = CISS_INQUIRY;
1051 cdb[1] = (page != 0);
1052 cdb[2] = page;
1053 cdb[3] = 0;
1054 cdb[4] = bufsize;
1055 cdb[5] = 0;
1056 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
1057 6, buf, bufsize, XFER_READ);
1058
1059 if (rc != 0) return rc;
1060
1061 if (ei->CommandStatus != 0 &&
1062 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1063 cciss_scsi_interpret_error(cp);
1064 rc = -1;
1065 }
1066 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1067 scsi_cmd_free(c, cp);
1068 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1069 return rc;
1070}
1071
1072
1073static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1074 unsigned char *device_id, int buflen)
1075{
1076 int rc;
1077 unsigned char *buf;
1078
1079 if (buflen > 16)
1080 buflen = 16;
1081 buf = kzalloc(64, GFP_KERNEL);
1082 if (!buf)
1083 return -1;
1084 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1085 if (rc == 0)
1086 memcpy(device_id, &buf[8], buflen);
1087 kfree(buf);
1088 return rc != 0;
1089}
1090
1091static int
1092cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1093 ReportLunData_struct *buf, int bufsize)
1094{
1095 int rc;
1096 CommandList_struct *cp;
1097 unsigned char cdb[12];
1098 unsigned char scsi3addr[8];
1099 ErrorInfo_struct *ei;
1100 unsigned long flags;
1101
1102 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1103 cp = scsi_cmd_alloc(c);
1104 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1105 if (cp == NULL) {
1106 printk("cmd_alloc returned NULL!\n");
1107 return -1;
1108 }
1109
1110 memset(&scsi3addr[0], 0, 8);
1111 cdb[0] = CISS_REPORT_PHYS;
1112 cdb[1] = 0;
1113 cdb[2] = 0;
1114 cdb[3] = 0;
1115 cdb[4] = 0;
1116 cdb[5] = 0;
1117 cdb[6] = (bufsize >> 24) & 0xFF;
1118 cdb[7] = (bufsize >> 16) & 0xFF;
1119 cdb[8] = (bufsize >> 8) & 0xFF;
1120 cdb[9] = bufsize & 0xFF;
1121 cdb[10] = 0;
1122 cdb[11] = 0;
1123
1124 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1125 cdb, 12,
1126 (unsigned char *) buf,
1127 bufsize, XFER_READ);
1128
1129 if (rc != 0) return rc;
1130
1131 ei = cp->err_info;
1132 if (ei->CommandStatus != 0 &&
1133 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1134 cciss_scsi_interpret_error(cp);
1135 rc = -1;
1136 }
1137 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1138 scsi_cmd_free(c, cp);
1139 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1140 return rc;
1141}
1142
1143static void
1144cciss_update_non_disk_devices(int cntl_num, int hostno)
1145{
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172#define OBDR_TAPE_INQ_SIZE 49
1173#define OBDR_TAPE_SIG "$DR-10"
1174 ReportLunData_struct *ld_buff;
1175 unsigned char *inq_buff;
1176 unsigned char scsi3addr[8];
1177 ctlr_info_t *c;
1178 __u32 num_luns=0;
1179 unsigned char *ch;
1180 struct cciss_scsi_dev_t *currentsd, *this_device;
1181 int ncurrent=0;
1182 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1183 int i;
1184
1185 c = (ctlr_info_t *) hba[cntl_num];
1186 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1187 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1188 currentsd = kzalloc(sizeof(*currentsd) *
1189 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1190 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1191 printk(KERN_ERR "cciss: out of memory\n");
1192 goto out;
1193 }
1194 this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1195 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1196 ch = &ld_buff->LUNListLength[0];
1197 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1198 if (num_luns > CISS_MAX_PHYS_LUN) {
1199 printk(KERN_WARNING
1200 "cciss: Maximum physical LUNs (%d) exceeded. "
1201 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1202 num_luns - CISS_MAX_PHYS_LUN);
1203 num_luns = CISS_MAX_PHYS_LUN;
1204 }
1205 }
1206 else {
1207 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1208 goto out;
1209 }
1210
1211
1212
1213 for (i = 0; i < num_luns; i++) {
1214
1215 if (ld_buff->LUN[i][3] & 0xC0) continue;
1216 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1217 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1218
1219 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1220 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1221
1222 continue;
1223
1224 this_device->devtype = (inq_buff[0] & 0x1f);
1225 this_device->bus = -1;
1226 this_device->target = -1;
1227 this_device->lun = -1;
1228 memcpy(this_device->scsi3addr, scsi3addr, 8);
1229 memcpy(this_device->vendor, &inq_buff[8],
1230 sizeof(this_device->vendor));
1231 memcpy(this_device->model, &inq_buff[16],
1232 sizeof(this_device->model));
1233 memcpy(this_device->revision, &inq_buff[32],
1234 sizeof(this_device->revision));
1235 memset(this_device->device_id, 0,
1236 sizeof(this_device->device_id));
1237 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1238 this_device->device_id, sizeof(this_device->device_id));
1239
1240 switch (this_device->devtype)
1241 {
1242 case 0x05: {
1243
1244
1245
1246
1247
1248
1249
1250
1251 char obdr_sig[7];
1252
1253 strncpy(obdr_sig, &inq_buff[43], 6);
1254 obdr_sig[6] = '\0';
1255 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1256
1257 break;
1258 }
1259
1260 case 0x01:
1261 case 0x08:
1262 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1263 printk(KERN_INFO "cciss%d: %s ignored, "
1264 "too many devices.\n", cntl_num,
1265 scsi_device_type(this_device->devtype));
1266 break;
1267 }
1268 currentsd[ncurrent] = *this_device;
1269 ncurrent++;
1270 break;
1271 default:
1272 break;
1273 }
1274 }
1275
1276 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1277out:
1278 kfree(inq_buff);
1279 kfree(ld_buff);
1280 kfree(currentsd);
1281 return;
1282}
1283
1284static int
1285is_keyword(char *ptr, int len, char *verb)
1286{
1287 int verb_len = strlen(verb);
1288 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1289 return verb_len;
1290 else
1291 return 0;
1292}
1293
1294static int
1295cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1296{
1297 int arg_len;
1298
1299 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1300 cciss_update_non_disk_devices(ctlr, hostno);
1301 else
1302 return -EINVAL;
1303 return length;
1304}
1305
1306
1307static int
1308cciss_scsi_proc_info(struct Scsi_Host *sh,
1309 char *buffer,
1310 char **start,
1311 off_t offset,
1312 int length,
1313 int func)
1314{
1315
1316 int buflen, datalen;
1317 ctlr_info_t *ci;
1318 int i;
1319 int cntl_num;
1320
1321
1322 ci = (ctlr_info_t *) sh->hostdata[0];
1323 if (ci == NULL)
1324 return -EINVAL;
1325
1326 cntl_num = ci->ctlr;
1327
1328 if (func == 0) {
1329 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1330 cntl_num, sh->host_no);
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1341 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1342 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1343 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1344 sh->host_no, sd->bus, sd->target, sd->lun,
1345 sd->devtype,
1346 sd->scsi3addr[0], sd->scsi3addr[1],
1347 sd->scsi3addr[2], sd->scsi3addr[3],
1348 sd->scsi3addr[4], sd->scsi3addr[5],
1349 sd->scsi3addr[6], sd->scsi3addr[7]);
1350 }
1351 datalen = buflen - offset;
1352 if (datalen < 0) {
1353 datalen = 0;
1354 *start = buffer+buflen;
1355 } else
1356 *start = buffer + offset;
1357 return(datalen);
1358 } else
1359 return cciss_scsi_user_command(cntl_num, sh->host_no,
1360 buffer, length);
1361}
1362
1363
1364
1365
1366
1367static void
1368cciss_scatter_gather(struct pci_dev *pdev,
1369 CommandList_struct *cp,
1370 struct scsi_cmnd *cmd)
1371{
1372 unsigned int len;
1373 struct scatterlist *sg;
1374 __u64 addr64;
1375 int use_sg, i;
1376
1377 BUG_ON(scsi_sg_count(cmd) > MAXSGENTRIES);
1378
1379 use_sg = scsi_dma_map(cmd);
1380 if (use_sg) {
1381 scsi_for_each_sg(cmd, sg, use_sg, i) {
1382 addr64 = (__u64) sg_dma_address(sg);
1383 len = sg_dma_len(sg);
1384 cp->SG[i].Addr.lower =
1385 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1386 cp->SG[i].Addr.upper =
1387 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1388 cp->SG[i].Len = len;
1389 cp->SG[i].Ext = 0;
1390 }
1391 }
1392
1393 cp->Header.SGList = (__u8) use_sg;
1394 cp->Header.SGTotal = (__u16) use_sg;
1395 return;
1396}
1397
1398
1399static int
1400cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1401{
1402 ctlr_info_t **c;
1403 int ctlr, rc;
1404 unsigned char scsi3addr[8];
1405 CommandList_struct *cp;
1406 unsigned long flags;
1407
1408
1409
1410 c = (ctlr_info_t **) &cmd->device->host->hostdata[0];
1411 ctlr = (*c)->ctlr;
1412
1413 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1414 cmd->device->lun, scsi3addr);
1415 if (rc != 0) {
1416
1417
1418 cmd->result = DID_NO_CONNECT << 16;
1419 done(cmd);
1420
1421
1422 return 0;
1423 }
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1434 cp = scsi_cmd_alloc(*c);
1435 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1436 if (cp == NULL) {
1437 printk("scsi_cmd_alloc returned NULL!\n");
1438
1439 cmd->result = DID_NO_CONNECT << 16;
1440 done(cmd);
1441 return 0;
1442 }
1443
1444
1445
1446 cmd->scsi_done = done;
1447
1448
1449 cmd->host_scribble = (unsigned char *) cp;
1450
1451 cp->cmd_type = CMD_SCSI;
1452 cp->scsi_cmd = cmd;
1453 cp->Header.ReplyQueue = 0;
1454 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1455 cp->Header.Tag.lower = cp->busaddr;
1456
1457
1458
1459 cp->Request.Timeout = 0;
1460 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1461 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1462 cp->Request.CDBLen = cmd->cmd_len;
1463 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1464 cp->Request.Type.Type = TYPE_CMD;
1465 cp->Request.Type.Attribute = ATTR_SIMPLE;
1466 switch(cmd->sc_data_direction)
1467 {
1468 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1469 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1470 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1471 case DMA_BIDIRECTIONAL:
1472
1473
1474
1475
1476 cp->Request.Type.Direction = XFER_RSVD;
1477
1478
1479
1480
1481
1482
1483
1484 break;
1485
1486 default:
1487 printk("cciss: unknown data direction: %d\n",
1488 cmd->sc_data_direction);
1489 BUG();
1490 break;
1491 }
1492
1493 cciss_scatter_gather((*c)->pdev, cp, cmd);
1494
1495
1496
1497 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1498 addQ(&(*c)->reqQ, cp);
1499 (*c)->Qdepth++;
1500 start_io(*c);
1501 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1502
1503
1504 return 0;
1505}
1506
1507static void
1508cciss_unregister_scsi(int ctlr)
1509{
1510 struct cciss_scsi_adapter_data_t *sa;
1511 struct cciss_scsi_cmd_stack_t *stk;
1512 unsigned long flags;
1513
1514
1515
1516 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1517 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1518 stk = &sa->cmd_stack;
1519
1520
1521 if (sa->registered) {
1522 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1523 scsi_remove_host(sa->scsi_host);
1524 scsi_host_put(sa->scsi_host);
1525 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1526 }
1527
1528
1529
1530 sa->scsi_host = NULL;
1531 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1532 scsi_cmd_stack_free(ctlr);
1533 kfree(sa);
1534}
1535
1536static int
1537cciss_engage_scsi(int ctlr)
1538{
1539 struct cciss_scsi_adapter_data_t *sa;
1540 struct cciss_scsi_cmd_stack_t *stk;
1541 unsigned long flags;
1542
1543 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1544 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1545 stk = &sa->cmd_stack;
1546
1547 if (sa->registered) {
1548 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1549 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1550 return ENXIO;
1551 }
1552 sa->registered = 1;
1553 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1554 cciss_update_non_disk_devices(ctlr, -1);
1555 cciss_scsi_detect(ctlr);
1556 return 0;
1557}
1558
1559static void
1560cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1561{
1562 unsigned long flags;
1563
1564 CPQ_TAPE_LOCK(ctlr, flags);
1565 seq_printf(seq,
1566 "Sequential access devices: %d\n\n",
1567 ccissscsi[ctlr].ndevices);
1568 CPQ_TAPE_UNLOCK(ctlr, flags);
1569}
1570
1571static int wait_for_device_to_become_ready(ctlr_info_t *h,
1572 unsigned char lunaddr[])
1573{
1574 int rc;
1575 int count = 0;
1576 int waittime = HZ;
1577 CommandList_struct *c;
1578
1579 c = cmd_alloc(h, 1);
1580 if (!c) {
1581 printk(KERN_WARNING "cciss%d: out of memory in "
1582 "wait_for_device_to_become_ready.\n", h->ctlr);
1583 return IO_ERROR;
1584 }
1585
1586
1587 while (count < 20) {
1588
1589
1590
1591
1592 schedule_timeout_uninterruptible(waittime);
1593 count++;
1594
1595
1596 if (waittime < (HZ * 30))
1597 waittime = waittime * 2;
1598
1599
1600 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1601 lunaddr, TYPE_CMD);
1602 if (rc == 0)
1603 rc = sendcmd_withirq_core(h, c, 0);
1604
1605 (void) process_sendcmd_error(h, c);
1606
1607 if (rc != 0)
1608 goto retry_tur;
1609
1610 if (c->err_info->CommandStatus == CMD_SUCCESS)
1611 break;
1612
1613 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1614 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1615 if (c->err_info->SenseInfo[2] == NO_SENSE)
1616 break;
1617 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1618 unsigned char asc;
1619 asc = c->err_info->SenseInfo[12];
1620 check_for_unit_attention(h, c);
1621 if (asc == POWER_OR_RESET)
1622 break;
1623 }
1624 }
1625retry_tur:
1626 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1627 "for device to become ready.\n",
1628 h->ctlr, waittime / HZ);
1629 rc = 1;
1630 }
1631
1632 if (rc)
1633 printk("cciss%d: giving up on device.\n", h->ctlr);
1634 else
1635 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1636
1637 cmd_free(h, c, 1);
1638 return rc;
1639}
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1653{
1654 int rc;
1655 CommandList_struct *cmd_in_trouble;
1656 unsigned char lunaddr[8];
1657 ctlr_info_t **c;
1658 int ctlr;
1659
1660
1661 c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];
1662 if (c == NULL)
1663 return FAILED;
1664 ctlr = (*c)->ctlr;
1665 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1666
1667 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1668 if (cmd_in_trouble == NULL)
1669 return FAILED;
1670 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1671
1672 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1673 TYPE_MSG);
1674 if (rc == 0 && wait_for_device_to_become_ready(*c, lunaddr) == 0)
1675 return SUCCESS;
1676 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1677 return FAILED;
1678}
1679
1680static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1681{
1682 int rc;
1683 CommandList_struct *cmd_to_abort;
1684 unsigned char lunaddr[8];
1685 ctlr_info_t **c;
1686 int ctlr;
1687
1688
1689 c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];
1690 if (c == NULL)
1691 return FAILED;
1692 ctlr = (*c)->ctlr;
1693 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1694
1695
1696 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1697 if (cmd_to_abort == NULL)
1698 return FAILED;
1699 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1700 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1701 0, 0, lunaddr, TYPE_MSG);
1702 if (rc == 0)
1703 return SUCCESS;
1704 return FAILED;
1705
1706}
1707
1708#else
1709
1710
1711
1712#define cciss_scsi_setup(cntl_num)
1713
1714#endif
1715