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