aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/block/cciss_scsi.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/block/cciss_scsi.c')
-rw-r--r--drivers/block/cciss_scsi.c1417
1 files changed, 1417 insertions, 0 deletions
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
new file mode 100644
index 000000000000..f16e3caed58a
--- /dev/null
+++ b/drivers/block/cciss_scsi.c
@@ -0,0 +1,1417 @@
1/*
2 * Disk Array driver for Compaq SA53xx Controllers, SCSI Tape module
3 * Copyright 2001 Compaq Computer Corporation
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13 * NON INFRINGEMENT. See the GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
20 *
21 * Author: Stephen M. Cameron
22 */
23#ifdef CONFIG_CISS_SCSI_TAPE
24
25/* Here we have code to present the driver as a scsi driver
26 as it is simultaneously presented as a block driver. The
27 reason for doing this is to allow access to SCSI tape drives
28 through the array controller. Note in particular, neither
29 physical nor logical disks are presented through the scsi layer. */
30
31#include <scsi/scsi.h>
32#include <scsi/scsi_cmnd.h>
33#include <scsi/scsi_device.h>
34#include <scsi/scsi_host.h>
35#include <asm/atomic.h>
36#include <linux/timer.h>
37#include <linux/completion.h>
38
39#include "cciss_scsi.h"
40
41/* some prototypes... */
42static int sendcmd(
43 __u8 cmd,
44 int ctlr,
45 void *buff,
46 size_t size,
47 unsigned int use_unit_num, /* 0: address the controller,
48 1: address logical volume log_unit,
49 2: address is in scsi3addr */
50 unsigned int log_unit,
51 __u8 page_code,
52 unsigned char *scsi3addr,
53 int cmd_type);
54
55
56static int cciss_scsi_proc_info(
57 struct Scsi_Host *sh,
58 char *buffer, /* data buffer */
59 char **start, /* where data in buffer starts */
60 off_t offset, /* offset from start of imaginary file */
61 int length, /* length of data in buffer */
62 int func); /* 0 == read, 1 == write */
63
64static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
65 void (* done)(struct scsi_cmnd *));
66
67static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
68 { .name = "cciss0", .ndevices = 0 },
69 { .name = "cciss1", .ndevices = 0 },
70 { .name = "cciss2", .ndevices = 0 },
71 { .name = "cciss3", .ndevices = 0 },
72 { .name = "cciss4", .ndevices = 0 },
73 { .name = "cciss5", .ndevices = 0 },
74 { .name = "cciss6", .ndevices = 0 },
75 { .name = "cciss7", .ndevices = 0 },
76};
77
78static struct scsi_host_template cciss_driver_template = {
79 .module = THIS_MODULE,
80 .name = "cciss",
81 .proc_name = "cciss",
82 .proc_info = cciss_scsi_proc_info,
83 .queuecommand = cciss_scsi_queue_command,
84 .can_queue = SCSI_CCISS_CAN_QUEUE,
85 .this_id = 7,
86 .sg_tablesize = MAXSGENTRIES,
87 .cmd_per_lun = 1,
88 .use_clustering = DISABLE_CLUSTERING,
89};
90
91#pragma pack(1)
92struct cciss_scsi_cmd_stack_elem_t {
93 CommandList_struct cmd;
94 ErrorInfo_struct Err;
95 __u32 busaddr;
96};
97
98#pragma pack()
99
100#define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
101 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
102 // plus two for init time usage
103
104#pragma pack(1)
105struct cciss_scsi_cmd_stack_t {
106 struct cciss_scsi_cmd_stack_elem_t *pool;
107 struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
108 dma_addr_t cmd_pool_handle;
109 int top;
110};
111#pragma pack()
112
113struct cciss_scsi_adapter_data_t {
114 struct Scsi_Host *scsi_host;
115 struct cciss_scsi_cmd_stack_t cmd_stack;
116 int registered;
117 spinlock_t lock; // to protect ccissscsi[ctlr];
118};
119
120#define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
121 &(((struct cciss_scsi_adapter_data_t *) \
122 hba[ctlr]->scsi_ctlr)->lock), flags);
123#define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
124 &(((struct cciss_scsi_adapter_data_t *) \
125 hba[ctlr]->scsi_ctlr)->lock), flags);
126
127static CommandList_struct *
128scsi_cmd_alloc(ctlr_info_t *h)
129{
130 /* assume only one process in here at a time, locking done by caller. */
131 /* use CCISS_LOCK(ctlr) */
132 /* might be better to rewrite how we allocate scsi commands in a way that */
133 /* needs no locking at all. */
134
135 /* take the top memory chunk off the stack and return it, if any. */
136 struct cciss_scsi_cmd_stack_elem_t *c;
137 struct cciss_scsi_adapter_data_t *sa;
138 struct cciss_scsi_cmd_stack_t *stk;
139 u64bit temp64;
140
141 sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
142 stk = &sa->cmd_stack;
143
144 if (stk->top < 0)
145 return NULL;
146 c = stk->elem[stk->top];
147 /* memset(c, 0, sizeof(*c)); */
148 memset(&c->cmd, 0, sizeof(c->cmd));
149 memset(&c->Err, 0, sizeof(c->Err));
150 /* set physical addr of cmd and addr of scsi parameters */
151 c->cmd.busaddr = c->busaddr;
152 /* (__u32) (stk->cmd_pool_handle +
153 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
154
155 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
156 /* (__u64) (stk->cmd_pool_handle +
157 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
158 sizeof(CommandList_struct)); */
159 stk->top--;
160 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
161 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
162 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
163
164 c->cmd.ctlr = h->ctlr;
165 c->cmd.err_info = &c->Err;
166
167 return (CommandList_struct *) c;
168}
169
170static void
171scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
172{
173 /* assume only one process in here at a time, locking done by caller. */
174 /* use CCISS_LOCK(ctlr) */
175 /* drop the free memory chunk on top of the stack. */
176
177 struct cciss_scsi_adapter_data_t *sa;
178 struct cciss_scsi_cmd_stack_t *stk;
179
180 sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
181 stk = &sa->cmd_stack;
182 if (stk->top >= CMD_STACK_SIZE) {
183 printk("cciss: scsi_cmd_free called too many times.\n");
184 BUG();
185 }
186 stk->top++;
187 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
188}
189
190static int
191scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
192{
193 int i;
194 struct cciss_scsi_cmd_stack_t *stk;
195 size_t size;
196
197 stk = &sa->cmd_stack;
198 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
199
200 // pci_alloc_consistent guarantees 32-bit DMA address will
201 // be used
202
203 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
204 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
205
206 if (stk->pool == NULL) {
207 printk("stk->pool is null\n");
208 return -1;
209 }
210
211 for (i=0; i<CMD_STACK_SIZE; i++) {
212 stk->elem[i] = &stk->pool[i];
213 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
214 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
215 }
216 stk->top = CMD_STACK_SIZE-1;
217 return 0;
218}
219
220static void
221scsi_cmd_stack_free(int ctlr)
222{
223 struct cciss_scsi_adapter_data_t *sa;
224 struct cciss_scsi_cmd_stack_t *stk;
225 size_t size;
226
227 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
228 stk = &sa->cmd_stack;
229 if (stk->top != CMD_STACK_SIZE-1) {
230 printk( "cciss: %d scsi commands are still outstanding.\n",
231 CMD_STACK_SIZE - stk->top);
232 // BUG();
233 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
234 }
235 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
236
237 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
238 stk->pool = NULL;
239}
240
241/* scsi_device_types comes from scsi.h */
242#define DEVICETYPE(n) (n<0 || n>MAX_SCSI_DEVICE_CODE) ? \
243 "Unknown" : scsi_device_types[n]
244
245#if 0
246static int xmargin=8;
247static int amargin=60;
248
249static void
250print_bytes (unsigned char *c, int len, int hex, int ascii)
251{
252
253 int i;
254 unsigned char *x;
255
256 if (hex)
257 {
258 x = c;
259 for (i=0;i<len;i++)
260 {
261 if ((i % xmargin) == 0 && i>0) printk("\n");
262 if ((i % xmargin) == 0) printk("0x%04x:", i);
263 printk(" %02x", *x);
264 x++;
265 }
266 printk("\n");
267 }
268 if (ascii)
269 {
270 x = c;
271 for (i=0;i<len;i++)
272 {
273 if ((i % amargin) == 0 && i>0) printk("\n");
274 if ((i % amargin) == 0) printk("0x%04x:", i);
275 if (*x > 26 && *x < 128) printk("%c", *x);
276 else printk(".");
277 x++;
278 }
279 printk("\n");
280 }
281}
282
283static void
284print_cmd(CommandList_struct *cp)
285{
286 printk("queue:%d\n", cp->Header.ReplyQueue);
287 printk("sglist:%d\n", cp->Header.SGList);
288 printk("sgtot:%d\n", cp->Header.SGTotal);
289 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
290 cp->Header.Tag.lower);
291 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
292 cp->Header.LUN.LunAddrBytes[0],
293 cp->Header.LUN.LunAddrBytes[1],
294 cp->Header.LUN.LunAddrBytes[2],
295 cp->Header.LUN.LunAddrBytes[3],
296 cp->Header.LUN.LunAddrBytes[4],
297 cp->Header.LUN.LunAddrBytes[5],
298 cp->Header.LUN.LunAddrBytes[6],
299 cp->Header.LUN.LunAddrBytes[7]);
300 printk("CDBLen:%d\n", cp->Request.CDBLen);
301 printk("Type:%d\n",cp->Request.Type.Type);
302 printk("Attr:%d\n",cp->Request.Type.Attribute);
303 printk(" Dir:%d\n",cp->Request.Type.Direction);
304 printk("Timeout:%d\n",cp->Request.Timeout);
305 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
306 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
307 cp->Request.CDB[0], cp->Request.CDB[1],
308 cp->Request.CDB[2], cp->Request.CDB[3],
309 cp->Request.CDB[4], cp->Request.CDB[5],
310 cp->Request.CDB[6], cp->Request.CDB[7],
311 cp->Request.CDB[8], cp->Request.CDB[9],
312 cp->Request.CDB[10], cp->Request.CDB[11],
313 cp->Request.CDB[12], cp->Request.CDB[13],
314 cp->Request.CDB[14], cp->Request.CDB[15]),
315 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
316 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
317 cp->ErrDesc.Len);
318 printk("sgs..........Errorinfo:\n");
319 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
320 printk("senselen:%d\n", cp->err_info->SenseLen);
321 printk("cmd status:%d\n", cp->err_info->CommandStatus);
322 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
323 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
324 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
325 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
326
327}
328
329#endif
330
331static int
332find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
333{
334 /* finds an unused bus, target, lun for a new device */
335 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
336 int i, found=0;
337 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
338
339 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
340
341 target_taken[SELF_SCSI_ID] = 1;
342 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
343 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
344
345 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
346 if (!target_taken[i]) {
347 *bus = 0; *target=i; *lun = 0; found=1;
348 break;
349 }
350 }
351 return (!found);
352}
353
354static int
355cciss_scsi_add_entry(int ctlr, int hostno,
356 unsigned char *scsi3addr, int devtype)
357{
358 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
359 int n = ccissscsi[ctlr].ndevices;
360 struct cciss_scsi_dev_t *sd;
361
362 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
363 printk("cciss%d: Too many devices, "
364 "some will be inaccessible.\n", ctlr);
365 return -1;
366 }
367 sd = &ccissscsi[ctlr].dev[n];
368 if (find_bus_target_lun(ctlr, &sd->bus, &sd->target, &sd->lun) != 0)
369 return -1;
370 memcpy(&sd->scsi3addr[0], scsi3addr, 8);
371 sd->devtype = devtype;
372 ccissscsi[ctlr].ndevices++;
373
374 /* initially, (before registering with scsi layer) we don't
375 know our hostno and we don't want to print anything first
376 time anyway (the scsi layer's inquiries will show that info) */
377 if (hostno != -1)
378 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
379 ctlr, DEVICETYPE(sd->devtype), hostno,
380 sd->bus, sd->target, sd->lun);
381 return 0;
382}
383
384static void
385cciss_scsi_remove_entry(int ctlr, int hostno, int entry)
386{
387 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
388 int i;
389 struct cciss_scsi_dev_t sd;
390
391 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
392 sd = ccissscsi[ctlr].dev[entry];
393 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
394 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
395 ccissscsi[ctlr].ndevices--;
396 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
397 ctlr, DEVICETYPE(sd.devtype), hostno,
398 sd.bus, sd.target, sd.lun);
399}
400
401
402#define SCSI3ADDR_EQ(a,b) ( \
403 (a)[7] == (b)[7] && \
404 (a)[6] == (b)[6] && \
405 (a)[5] == (b)[5] && \
406 (a)[4] == (b)[4] && \
407 (a)[3] == (b)[3] && \
408 (a)[2] == (b)[2] && \
409 (a)[1] == (b)[1] && \
410 (a)[0] == (b)[0])
411
412static int
413adjust_cciss_scsi_table(int ctlr, int hostno,
414 struct cciss_scsi_dev_t sd[], int nsds)
415{
416 /* sd contains scsi3 addresses and devtypes, but
417 bus target and lun are not filled in. This funciton
418 takes what's in sd to be the current and adjusts
419 ccissscsi[] to be in line with what's in sd. */
420
421 int i,j, found, changes=0;
422 struct cciss_scsi_dev_t *csd;
423 unsigned long flags;
424
425 CPQ_TAPE_LOCK(ctlr, flags);
426
427 /* find any devices in ccissscsi[] that are not in
428 sd[] and remove them from ccissscsi[] */
429
430 i = 0;
431 while(i<ccissscsi[ctlr].ndevices) {
432 csd = &ccissscsi[ctlr].dev[i];
433 found=0;
434 for (j=0;j<nsds;j++) {
435 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
436 csd->scsi3addr)) {
437 if (sd[j].devtype == csd->devtype)
438 found=2;
439 else
440 found=1;
441 break;
442 }
443 }
444
445 if (found == 0) { /* device no longer present. */
446 changes++;
447 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
448 ctlr, DEVICETYPE(csd->devtype), hostno,
449 csd->bus, csd->target, csd->lun); */
450 cciss_scsi_remove_entry(ctlr, hostno, i);
451 /* note, i not incremented */
452 }
453 else if (found == 1) { /* device is different kind */
454 changes++;
455 printk("cciss%d: device c%db%dt%dl%d type changed "
456 "(device type now %s).\n",
457 ctlr, hostno, csd->bus, csd->target, csd->lun,
458 DEVICETYPE(csd->devtype));
459 csd->devtype = sd[j].devtype;
460 i++; /* so just move along. */
461 } else /* device is same as it ever was, */
462 i++; /* so just move along. */
463 }
464
465 /* Now, make sure every device listed in sd[] is also
466 listed in ccissscsi[], adding them if they aren't found */
467
468 for (i=0;i<nsds;i++) {
469 found=0;
470 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
471 csd = &ccissscsi[ctlr].dev[j];
472 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
473 csd->scsi3addr)) {
474 if (sd[i].devtype == csd->devtype)
475 found=2; /* found device */
476 else
477 found=1; /* found a bug. */
478 break;
479 }
480 }
481 if (!found) {
482 changes++;
483 if (cciss_scsi_add_entry(ctlr, hostno,
484 &sd[i].scsi3addr[0], sd[i].devtype) != 0)
485 break;
486 } else if (found == 1) {
487 /* should never happen... */
488 changes++;
489 printk("cciss%d: device unexpectedly changed type\n",
490 ctlr);
491 /* but if it does happen, we just ignore that device */
492 }
493 }
494 CPQ_TAPE_UNLOCK(ctlr, flags);
495
496 if (!changes)
497 printk("cciss%d: No device changes detected.\n", ctlr);
498
499 return 0;
500}
501
502static int
503lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
504{
505 int i;
506 struct cciss_scsi_dev_t *sd;
507 unsigned long flags;
508
509 CPQ_TAPE_LOCK(ctlr, flags);
510 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
511 sd = &ccissscsi[ctlr].dev[i];
512 if (sd->bus == bus &&
513 sd->target == target &&
514 sd->lun == lun) {
515 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
516 CPQ_TAPE_UNLOCK(ctlr, flags);
517 return 0;
518 }
519 }
520 CPQ_TAPE_UNLOCK(ctlr, flags);
521 return -1;
522}
523
524static void
525cciss_scsi_setup(int cntl_num)
526{
527 struct cciss_scsi_adapter_data_t * shba;
528
529 ccissscsi[cntl_num].ndevices = 0;
530 shba = (struct cciss_scsi_adapter_data_t *)
531 kmalloc(sizeof(*shba), GFP_KERNEL);
532 if (shba == NULL)
533 return;
534 shba->scsi_host = NULL;
535 spin_lock_init(&shba->lock);
536 shba->registered = 0;
537 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
538 kfree(shba);
539 shba = NULL;
540 }
541 hba[cntl_num]->scsi_ctlr = (void *) shba;
542 return;
543}
544
545static void
546complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
547{
548 struct scsi_cmnd *cmd;
549 ctlr_info_t *ctlr;
550 u64bit addr64;
551 ErrorInfo_struct *ei;
552
553 ei = cp->err_info;
554
555 /* First, see if it was a message rather than a command */
556 if (cp->Request.Type.Type == TYPE_MSG) {
557 cp->cmd_type = CMD_MSG_DONE;
558 return;
559 }
560
561 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
562 ctlr = hba[cp->ctlr];
563
564 /* undo the DMA mappings */
565
566 if (cmd->use_sg) {
567 pci_unmap_sg(ctlr->pdev,
568 cmd->buffer, cmd->use_sg,
569 cmd->sc_data_direction);
570 }
571 else if (cmd->request_bufflen) {
572 addr64.val32.lower = cp->SG[0].Addr.lower;
573 addr64.val32.upper = cp->SG[0].Addr.upper;
574 pci_unmap_single(ctlr->pdev, (dma_addr_t) addr64.val,
575 cmd->request_bufflen,
576 cmd->sc_data_direction);
577 }
578
579 cmd->result = (DID_OK << 16); /* host byte */
580 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
581 /* cmd->result |= (GOOD < 1); */ /* status byte */
582
583 cmd->result |= (ei->ScsiStatus);
584 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
585
586 /* copy the sense data whether we need to or not. */
587
588 memcpy(cmd->sense_buffer, ei->SenseInfo,
589 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
590 SCSI_SENSE_BUFFERSIZE :
591 ei->SenseLen);
592 cmd->resid = ei->ResidualCnt;
593
594 if(ei->CommandStatus != 0)
595 { /* an error has occurred */
596 switch(ei->CommandStatus)
597 {
598 case CMD_TARGET_STATUS:
599 /* Pass it up to the upper layers... */
600 if( ei->ScsiStatus)
601 {
602#if 0
603 printk(KERN_WARNING "cciss: cmd %p "
604 "has SCSI Status = %x\n",
605 cp,
606 ei->ScsiStatus);
607#endif
608 cmd->result |= (ei->ScsiStatus < 1);
609 }
610 else { /* scsi status is zero??? How??? */
611
612 /* Ordinarily, this case should never happen, but there is a bug
613 in some released firmware revisions that allows it to happen
614 if, for example, a 4100 backplane loses power and the tape
615 drive is in it. We assume that it's a fatal error of some
616 kind because we can't show that it wasn't. We will make it
617 look like selection timeout since that is the most common
618 reason for this to occur, and it's severe enough. */
619
620 cmd->result = DID_NO_CONNECT << 16;
621 }
622 break;
623 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
624 break;
625 case CMD_DATA_OVERRUN:
626 printk(KERN_WARNING "cciss: cp %p has"
627 " completed with data overrun "
628 "reported\n", cp);
629 break;
630 case CMD_INVALID: {
631 /* print_bytes(cp, sizeof(*cp), 1, 0);
632 print_cmd(cp); */
633 /* We get CMD_INVALID if you address a non-existent tape drive instead
634 of a selection timeout (no response). You will see this if you yank
635 out a tape drive, then try to access it. This is kind of a shame
636 because it means that any other CMD_INVALID (e.g. driver bug) will
637 get interpreted as a missing target. */
638 cmd->result = DID_NO_CONNECT << 16;
639 }
640 break;
641 case CMD_PROTOCOL_ERR:
642 printk(KERN_WARNING "cciss: cp %p has "
643 "protocol error \n", cp);
644 break;
645 case CMD_HARDWARE_ERR:
646 cmd->result = DID_ERROR << 16;
647 printk(KERN_WARNING "cciss: cp %p had "
648 " hardware error\n", cp);
649 break;
650 case CMD_CONNECTION_LOST:
651 cmd->result = DID_ERROR << 16;
652 printk(KERN_WARNING "cciss: cp %p had "
653 "connection lost\n", cp);
654 break;
655 case CMD_ABORTED:
656 cmd->result = DID_ABORT << 16;
657 printk(KERN_WARNING "cciss: cp %p was "
658 "aborted\n", cp);
659 break;
660 case CMD_ABORT_FAILED:
661 cmd->result = DID_ERROR << 16;
662 printk(KERN_WARNING "cciss: cp %p reports "
663 "abort failed\n", cp);
664 break;
665 case CMD_UNSOLICITED_ABORT:
666 cmd->result = DID_ABORT << 16;
667 printk(KERN_WARNING "cciss: cp %p aborted "
668 "do to an unsolicited abort\n", cp);
669 break;
670 case CMD_TIMEOUT:
671 cmd->result = DID_TIME_OUT << 16;
672 printk(KERN_WARNING "cciss: cp %p timedout\n",
673 cp);
674 break;
675 default:
676 cmd->result = DID_ERROR << 16;
677 printk(KERN_WARNING "cciss: cp %p returned "
678 "unknown status %x\n", cp,
679 ei->CommandStatus);
680 }
681 }
682 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
683 // cmd->target, cmd->lun);
684 cmd->scsi_done(cmd);
685 scsi_cmd_free(ctlr, cp);
686}
687
688static int
689cciss_scsi_detect(int ctlr)
690{
691 struct Scsi_Host *sh;
692 int error;
693
694 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
695 if (sh == NULL)
696 goto fail;
697 sh->io_port = 0; // good enough? FIXME,
698 sh->n_io_port = 0; // I don't think we use these two...
699 sh->this_id = SELF_SCSI_ID;
700
701 ((struct cciss_scsi_adapter_data_t *)
702 hba[ctlr]->scsi_ctlr)->scsi_host = (void *) sh;
703 sh->hostdata[0] = (unsigned long) hba[ctlr];
704 sh->irq = hba[ctlr]->intr;
705 sh->unique_id = sh->irq;
706 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
707 if (error)
708 goto fail_host_put;
709 scsi_scan_host(sh);
710 return 1;
711
712 fail_host_put:
713 scsi_host_put(sh);
714 fail:
715 return 0;
716}
717
718static void
719cciss_unmap_one(struct pci_dev *pdev,
720 CommandList_struct *cp,
721 size_t buflen,
722 int data_direction)
723{
724 u64bit addr64;
725
726 addr64.val32.lower = cp->SG[0].Addr.lower;
727 addr64.val32.upper = cp->SG[0].Addr.upper;
728 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
729}
730
731static void
732cciss_map_one(struct pci_dev *pdev,
733 CommandList_struct *cp,
734 unsigned char *buf,
735 size_t buflen,
736 int data_direction)
737{
738 __u64 addr64;
739
740 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
741 cp->SG[0].Addr.lower =
742 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
743 cp->SG[0].Addr.upper =
744 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
745 cp->SG[0].Len = buflen;
746 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
747 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
748}
749
750static int
751cciss_scsi_do_simple_cmd(ctlr_info_t *c,
752 CommandList_struct *cp,
753 unsigned char *scsi3addr,
754 unsigned char *cdb,
755 unsigned char cdblen,
756 unsigned char *buf, int bufsize,
757 int direction)
758{
759 unsigned long flags;
760 DECLARE_COMPLETION(wait);
761
762 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl
763 cp->scsi_cmd = NULL;
764 cp->Header.ReplyQueue = 0; // unused in simple mode
765 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
766 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
767 // Fill in the request block...
768
769 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
770 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
771 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
772
773 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
774 memcpy(cp->Request.CDB, cdb, cdblen);
775 cp->Request.Timeout = 0;
776 cp->Request.CDBLen = cdblen;
777 cp->Request.Type.Type = TYPE_CMD;
778 cp->Request.Type.Attribute = ATTR_SIMPLE;
779 cp->Request.Type.Direction = direction;
780
781 /* Fill in the SG list and do dma mapping */
782 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
783 bufsize, DMA_FROM_DEVICE);
784
785 cp->waiting = &wait;
786
787 /* Put the request on the tail of the request queue */
788 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
789 addQ(&c->reqQ, cp);
790 c->Qdepth++;
791 start_io(c);
792 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
793
794 wait_for_completion(&wait);
795
796 /* undo the dma mapping */
797 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
798 return(0);
799}
800
801static void
802cciss_scsi_interpret_error(CommandList_struct *cp)
803{
804 ErrorInfo_struct *ei;
805
806 ei = cp->err_info;
807 switch(ei->CommandStatus)
808 {
809 case CMD_TARGET_STATUS:
810 printk(KERN_WARNING "cciss: cmd %p has "
811 "completed with errors\n", cp);
812 printk(KERN_WARNING "cciss: cmd %p "
813 "has SCSI Status = %x\n",
814 cp,
815 ei->ScsiStatus);
816 if (ei->ScsiStatus == 0)
817 printk(KERN_WARNING
818 "cciss:SCSI status is abnormally zero. "
819 "(probably indicates selection timeout "
820 "reported incorrectly due to a known "
821 "firmware bug, circa July, 2001.)\n");
822 break;
823 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
824 printk("UNDERRUN\n");
825 break;
826 case CMD_DATA_OVERRUN:
827 printk(KERN_WARNING "cciss: cp %p has"
828 " completed with data overrun "
829 "reported\n", cp);
830 break;
831 case CMD_INVALID: {
832 /* controller unfortunately reports SCSI passthru's */
833 /* to non-existent targets as invalid commands. */
834 printk(KERN_WARNING "cciss: cp %p is "
835 "reported invalid (probably means "
836 "target device no longer present)\n",
837 cp);
838 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
839 print_cmd(cp); */
840 }
841 break;
842 case CMD_PROTOCOL_ERR:
843 printk(KERN_WARNING "cciss: cp %p has "
844 "protocol error \n", cp);
845 break;
846 case CMD_HARDWARE_ERR:
847 /* cmd->result = DID_ERROR << 16; */
848 printk(KERN_WARNING "cciss: cp %p had "
849 " hardware error\n", cp);
850 break;
851 case CMD_CONNECTION_LOST:
852 printk(KERN_WARNING "cciss: cp %p had "
853 "connection lost\n", cp);
854 break;
855 case CMD_ABORTED:
856 printk(KERN_WARNING "cciss: cp %p was "
857 "aborted\n", cp);
858 break;
859 case CMD_ABORT_FAILED:
860 printk(KERN_WARNING "cciss: cp %p reports "
861 "abort failed\n", cp);
862 break;
863 case CMD_UNSOLICITED_ABORT:
864 printk(KERN_WARNING "cciss: cp %p aborted "
865 "do to an unsolicited abort\n", cp);
866 break;
867 case CMD_TIMEOUT:
868 printk(KERN_WARNING "cciss: cp %p timedout\n",
869 cp);
870 break;
871 default:
872 printk(KERN_WARNING "cciss: cp %p returned "
873 "unknown status %x\n", cp,
874 ei->CommandStatus);
875 }
876}
877
878static int
879cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
880 InquiryData_struct *buf)
881{
882 int rc;
883 CommandList_struct *cp;
884 char cdb[6];
885 ErrorInfo_struct *ei;
886 unsigned long flags;
887
888 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
889 cp = scsi_cmd_alloc(c);
890 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
891
892 if (cp == NULL) { /* trouble... */
893 printk("cmd_alloc returned NULL!\n");
894 return -1;
895 }
896
897 ei = cp->err_info;
898
899 cdb[0] = CISS_INQUIRY;
900 cdb[1] = 0;
901 cdb[2] = 0;
902 cdb[3] = 0;
903 cdb[4] = sizeof(*buf) & 0xff;
904 cdb[5] = 0;
905 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
906 6, (unsigned char *) buf,
907 sizeof(*buf), XFER_READ);
908
909 if (rc != 0) return rc; /* something went wrong */
910
911 if (ei->CommandStatus != 0 &&
912 ei->CommandStatus != CMD_DATA_UNDERRUN) {
913 cciss_scsi_interpret_error(cp);
914 rc = -1;
915 }
916 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
917 scsi_cmd_free(c, cp);
918 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
919 return rc;
920}
921
922static int
923cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
924 ReportLunData_struct *buf, int bufsize)
925{
926 int rc;
927 CommandList_struct *cp;
928 unsigned char cdb[12];
929 unsigned char scsi3addr[8];
930 ErrorInfo_struct *ei;
931 unsigned long flags;
932
933 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
934 cp = scsi_cmd_alloc(c);
935 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
936 if (cp == NULL) { /* trouble... */
937 printk("cmd_alloc returned NULL!\n");
938 return -1;
939 }
940
941 memset(&scsi3addr[0], 0, 8); /* address the controller */
942 cdb[0] = CISS_REPORT_PHYS;
943 cdb[1] = 0;
944 cdb[2] = 0;
945 cdb[3] = 0;
946 cdb[4] = 0;
947 cdb[5] = 0;
948 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
949 cdb[7] = (bufsize >> 16) & 0xFF;
950 cdb[8] = (bufsize >> 8) & 0xFF;
951 cdb[9] = bufsize & 0xFF;
952 cdb[10] = 0;
953 cdb[11] = 0;
954
955 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
956 cdb, 12,
957 (unsigned char *) buf,
958 bufsize, XFER_READ);
959
960 if (rc != 0) return rc; /* something went wrong */
961
962 ei = cp->err_info;
963 if (ei->CommandStatus != 0 &&
964 ei->CommandStatus != CMD_DATA_UNDERRUN) {
965 cciss_scsi_interpret_error(cp);
966 rc = -1;
967 }
968 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
969 scsi_cmd_free(c, cp);
970 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
971 return rc;
972}
973
974static void
975cciss_update_non_disk_devices(int cntl_num, int hostno)
976{
977 /* the idea here is we could get notified from /proc
978 that some devices have changed, so we do a report
979 physical luns cmd, and adjust our list of devices
980 accordingly. (We can't rely on the scsi-mid layer just
981 doing inquiries, because the "busses" that the scsi
982 mid-layer probes are totally fabricated by this driver,
983 so new devices wouldn't show up.
984
985 the scsi3addr's of devices won't change so long as the
986 adapter is not reset. That means we can rescan and
987 tell which devices we already know about, vs. new
988 devices, vs. disappearing devices.
989
990 Also, if you yank out a tape drive, then put in a disk
991 in it's place, (say, a configured volume from another
992 array controller for instance) _don't_ poke this driver
993 (so it thinks it's still a tape, but _do_ poke the scsi
994 mid layer, so it does an inquiry... the scsi mid layer
995 will see the physical disk. This would be bad. Need to
996 think about how to prevent that. One idea would be to
997 snoop all scsi responses and if an inquiry repsonse comes
998 back that reports a disk, chuck it an return selection
999 timeout instead and adjust our table... Not sure i like
1000 that though.
1001
1002 */
1003
1004 ReportLunData_struct *ld_buff;
1005 InquiryData_struct *inq_buff;
1006 unsigned char scsi3addr[8];
1007 ctlr_info_t *c;
1008 __u32 num_luns=0;
1009 unsigned char *ch;
1010 /* unsigned char found[CCISS_MAX_SCSI_DEVS_PER_HBA]; */
1011 struct cciss_scsi_dev_t currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1012 int ncurrent=0;
1013 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1014 int i;
1015
1016 c = (ctlr_info_t *) hba[cntl_num];
1017 ld_buff = kmalloc(reportlunsize, GFP_KERNEL);
1018 if (ld_buff == NULL) {
1019 printk(KERN_ERR "cciss: out of memory\n");
1020 return;
1021 }
1022 memset(ld_buff, 0, reportlunsize);
1023 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1024 if (inq_buff == NULL) {
1025 printk(KERN_ERR "cciss: out of memory\n");
1026 kfree(ld_buff);
1027 return;
1028 }
1029
1030 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1031 ch = &ld_buff->LUNListLength[0];
1032 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1033 if (num_luns > CISS_MAX_PHYS_LUN) {
1034 printk(KERN_WARNING
1035 "cciss: Maximum physical LUNs (%d) exceeded. "
1036 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1037 num_luns - CISS_MAX_PHYS_LUN);
1038 num_luns = CISS_MAX_PHYS_LUN;
1039 }
1040 }
1041 else {
1042 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1043 goto out;
1044 }
1045
1046
1047 /* adjust our table of devices */
1048 for(i=0; i<num_luns; i++)
1049 {
1050 int devtype;
1051
1052 /* for each physical lun, do an inquiry */
1053 if (ld_buff->LUN[i][3] & 0xC0) continue;
1054 memset(inq_buff, 0, sizeof(InquiryData_struct));
1055 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1056
1057 if (cciss_scsi_do_inquiry(hba[cntl_num],
1058 scsi3addr, inq_buff) != 0)
1059 {
1060 /* Inquiry failed (msg printed already) */
1061 devtype = 0; /* so we will skip this device. */
1062 } else /* what kind of device is this? */
1063 devtype = (inq_buff->data_byte[0] & 0x1f);
1064
1065 switch (devtype)
1066 {
1067 case 0x01: /* sequential access, (tape) */
1068 case 0x08: /* medium changer */
1069 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1070 printk(KERN_INFO "cciss%d: %s ignored, "
1071 "too many devices.\n", cntl_num,
1072 DEVICETYPE(devtype));
1073 break;
1074 }
1075 memcpy(&currentsd[ncurrent].scsi3addr[0],
1076 &scsi3addr[0], 8);
1077 currentsd[ncurrent].devtype = devtype;
1078 currentsd[ncurrent].bus = -1;
1079 currentsd[ncurrent].target = -1;
1080 currentsd[ncurrent].lun = -1;
1081 ncurrent++;
1082 break;
1083 default:
1084 break;
1085 }
1086 }
1087
1088 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1089out:
1090 kfree(inq_buff);
1091 kfree(ld_buff);
1092 return;
1093}
1094
1095static int
1096is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1097{
1098 int verb_len = strlen(verb);
1099 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1100 return verb_len;
1101 else
1102 return 0;
1103}
1104
1105static int
1106cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1107{
1108 int arg_len;
1109
1110 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1111 cciss_update_non_disk_devices(ctlr, hostno);
1112 else
1113 return -EINVAL;
1114 return length;
1115}
1116
1117
1118static int
1119cciss_scsi_proc_info(struct Scsi_Host *sh,
1120 char *buffer, /* data buffer */
1121 char **start, /* where data in buffer starts */
1122 off_t offset, /* offset from start of imaginary file */
1123 int length, /* length of data in buffer */
1124 int func) /* 0 == read, 1 == write */
1125{
1126
1127 int buflen, datalen;
1128 ctlr_info_t *ci;
1129 int cntl_num;
1130
1131
1132 ci = (ctlr_info_t *) sh->hostdata[0];
1133 if (ci == NULL) /* This really shouldn't ever happen. */
1134 return -EINVAL;
1135
1136 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1137
1138 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1139 buflen = sprintf(buffer, "hostnum=%d\n", sh->host_no);
1140
1141 datalen = buflen - offset;
1142 if (datalen < 0) { /* they're reading past EOF. */
1143 datalen = 0;
1144 *start = buffer+buflen;
1145 } else
1146 *start = buffer + offset;
1147 return(datalen);
1148 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1149 return cciss_scsi_user_command(cntl_num, sh->host_no,
1150 buffer, length);
1151}
1152
1153/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1154 dma mapping and fills in the scatter gather entries of the
1155 cciss command, cp. */
1156
1157static void
1158cciss_scatter_gather(struct pci_dev *pdev,
1159 CommandList_struct *cp,
1160 struct scsi_cmnd *cmd)
1161{
1162 unsigned int use_sg, nsegs=0, len;
1163 struct scatterlist *scatter = (struct scatterlist *) cmd->buffer;
1164 __u64 addr64;
1165
1166 /* is it just one virtual address? */
1167 if (!cmd->use_sg) {
1168 if (cmd->request_bufflen) { /* anything to xfer? */
1169
1170 addr64 = (__u64) pci_map_single(pdev,
1171 cmd->request_buffer,
1172 cmd->request_bufflen,
1173 cmd->sc_data_direction);
1174
1175 cp->SG[0].Addr.lower =
1176 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1177 cp->SG[0].Addr.upper =
1178 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1179 cp->SG[0].Len = cmd->request_bufflen;
1180 nsegs=1;
1181 }
1182 } /* else, must be a list of virtual addresses.... */
1183 else if (cmd->use_sg <= MAXSGENTRIES) { /* not too many addrs? */
1184
1185 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg,
1186 cmd->sc_data_direction);
1187
1188 for (nsegs=0; nsegs < use_sg; nsegs++) {
1189 addr64 = (__u64) sg_dma_address(&scatter[nsegs]);
1190 len = sg_dma_len(&scatter[nsegs]);
1191 cp->SG[nsegs].Addr.lower =
1192 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1193 cp->SG[nsegs].Addr.upper =
1194 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1195 cp->SG[nsegs].Len = len;
1196 cp->SG[nsegs].Ext = 0; // we are not chaining
1197 }
1198 } else BUG();
1199
1200 cp->Header.SGList = (__u8) nsegs; /* no. SGs contig in this cmd */
1201 cp->Header.SGTotal = (__u16) nsegs; /* total sgs in this cmd list */
1202 return;
1203}
1204
1205
1206static int
1207cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1208{
1209 ctlr_info_t **c;
1210 int ctlr, rc;
1211 unsigned char scsi3addr[8];
1212 CommandList_struct *cp;
1213 unsigned long flags;
1214
1215 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1216 // We violate cmd->host privacy here. (Is there another way?)
1217 c = (ctlr_info_t **) &cmd->device->host->hostdata[0];
1218 ctlr = (*c)->ctlr;
1219
1220 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1221 cmd->device->lun, scsi3addr);
1222 if (rc != 0) {
1223 /* the scsi nexus does not match any that we presented... */
1224 /* pretend to mid layer that we got selection timeout */
1225 cmd->result = DID_NO_CONNECT << 16;
1226 done(cmd);
1227 /* we might want to think about registering controller itself
1228 as a processor device on the bus so sg binds to it. */
1229 return 0;
1230 }
1231
1232 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1233 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1234 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1235 // cmd->target, cmd->lun);
1236
1237 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1238 see what the device thinks of it. */
1239
1240 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1241 cp = scsi_cmd_alloc(*c);
1242 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1243 if (cp == NULL) { /* trouble... */
1244 printk("scsi_cmd_alloc returned NULL!\n");
1245 /* FIXME: next 3 lines are -> BAD! <- */
1246 cmd->result = DID_NO_CONNECT << 16;
1247 done(cmd);
1248 return 0;
1249 }
1250
1251 // Fill in the command list header
1252
1253 cmd->scsi_done = done; // save this for use by completion code
1254
1255 // save cp in case we have to abort it
1256 cmd->host_scribble = (unsigned char *) cp;
1257
1258 cp->cmd_type = CMD_SCSI;
1259 cp->scsi_cmd = cmd;
1260 cp->Header.ReplyQueue = 0; // unused in simple mode
1261 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1262 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
1263
1264 // Fill in the request block...
1265
1266 cp->Request.Timeout = 0;
1267 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1268 if (cmd->cmd_len > sizeof(cp->Request.CDB)) BUG();
1269 cp->Request.CDBLen = cmd->cmd_len;
1270 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1271 cp->Request.Type.Type = TYPE_CMD;
1272 cp->Request.Type.Attribute = ATTR_SIMPLE;
1273 switch(cmd->sc_data_direction)
1274 {
1275 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1276 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1277 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1278 case DMA_BIDIRECTIONAL:
1279 // This can happen if a buggy application does a scsi passthru
1280 // and sets both inlen and outlen to non-zero. ( see
1281 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1282
1283 cp->Request.Type.Direction = XFER_RSVD;
1284 // This is technically wrong, and cciss controllers should
1285 // reject it with CMD_INVALID, which is the most correct
1286 // response, but non-fibre backends appear to let it
1287 // slide by, and give the same results as if this field
1288 // were set correctly. Either way is acceptable for
1289 // our purposes here.
1290
1291 break;
1292
1293 default:
1294 printk("cciss: unknown data direction: %d\n",
1295 cmd->sc_data_direction);
1296 BUG();
1297 break;
1298 }
1299
1300 cciss_scatter_gather((*c)->pdev, cp, cmd); // Fill the SG list
1301
1302 /* Put the request on the tail of the request queue */
1303
1304 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1305 addQ(&(*c)->reqQ, cp);
1306 (*c)->Qdepth++;
1307 start_io(*c);
1308 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1309
1310 /* the cmd'll come back via intr handler in complete_scsi_command() */
1311 return 0;
1312}
1313
1314static void
1315cciss_unregister_scsi(int ctlr)
1316{
1317 struct cciss_scsi_adapter_data_t *sa;
1318 struct cciss_scsi_cmd_stack_t *stk;
1319 unsigned long flags;
1320
1321 /* we are being forcibly unloaded, and may not refuse. */
1322
1323 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1324 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1325 stk = &sa->cmd_stack;
1326
1327 /* if we weren't ever actually registered, don't unregister */
1328 if (sa->registered) {
1329 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1330 scsi_remove_host(sa->scsi_host);
1331 scsi_host_put(sa->scsi_host);
1332 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1333 }
1334
1335 /* set scsi_host to NULL so our detect routine will
1336 find us on register */
1337 sa->scsi_host = NULL;
1338 scsi_cmd_stack_free(ctlr);
1339 kfree(sa);
1340 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1341}
1342
1343static int
1344cciss_register_scsi(int ctlr)
1345{
1346 unsigned long flags;
1347
1348 CPQ_TAPE_LOCK(ctlr, flags);
1349
1350 /* Since this is really a block driver, the SCSI core may not be
1351 initialized at init time, in which case, calling scsi_register_host
1352 would hang. Instead, we do it later, via /proc filesystem
1353 and rc scripts, when we know SCSI core is good to go. */
1354
1355 /* Only register if SCSI devices are detected. */
1356 if (ccissscsi[ctlr].ndevices != 0) {
1357 ((struct cciss_scsi_adapter_data_t *)
1358 hba[ctlr]->scsi_ctlr)->registered = 1;
1359 CPQ_TAPE_UNLOCK(ctlr, flags);
1360 return cciss_scsi_detect(ctlr);
1361 }
1362 CPQ_TAPE_UNLOCK(ctlr, flags);
1363 printk(KERN_INFO
1364 "cciss%d: No appropriate SCSI device detected, "
1365 "SCSI subsystem not engaged.\n", ctlr);
1366 return 0;
1367}
1368
1369static int
1370cciss_engage_scsi(int ctlr)
1371{
1372 struct cciss_scsi_adapter_data_t *sa;
1373 struct cciss_scsi_cmd_stack_t *stk;
1374 unsigned long flags;
1375
1376 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1377 sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1378 stk = &sa->cmd_stack;
1379
1380 if (((struct cciss_scsi_adapter_data_t *)
1381 hba[ctlr]->scsi_ctlr)->registered) {
1382 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1383 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1384 return ENXIO;
1385 }
1386 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1387 cciss_update_non_disk_devices(ctlr, -1);
1388 cciss_register_scsi(ctlr);
1389 return 0;
1390}
1391
1392static void
1393cciss_proc_tape_report(int ctlr, unsigned char *buffer, off_t *pos, off_t *len)
1394{
1395 unsigned long flags;
1396 int size;
1397
1398 *pos = *pos -1; *len = *len - 1; // cut off the last trailing newline
1399
1400 CPQ_TAPE_LOCK(ctlr, flags);
1401 size = sprintf(buffer + *len,
1402 " Sequential access devices: %d\n\n",
1403 ccissscsi[ctlr].ndevices);
1404 CPQ_TAPE_UNLOCK(ctlr, flags);
1405 *pos += size; *len += size;
1406}
1407
1408#else /* no CONFIG_CISS_SCSI_TAPE */
1409
1410/* If no tape support, then these become defined out of existence */
1411
1412#define cciss_scsi_setup(cntl_num)
1413#define cciss_unregister_scsi(ctlr)
1414#define cciss_register_scsi(ctlr)
1415#define cciss_proc_tape_report(ctlr, buffer, pos, len)
1416
1417#endif /* CONFIG_CISS_SCSI_TAPE */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-24 07:11:52 -0500