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