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