?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / block / cciss_scsi.c
blobe1d0e2cfec72aaae4d332e693005d5d30833e8ab
1 /*
2 * Disk Array driver for HP Smart Array controllers, SCSI Tape module.
3 * (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P.
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; version 2 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
17 * 02111-1307, 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 <linux/timer.h>
32 #include <linux/completion.h>
33 #include <linux/slab.h>
34 #include <linux/string.h>
35
36 #include <asm/atomic.h>
37
38 #include <scsi/scsi_cmnd.h>
39 #include <scsi/scsi_device.h>
40 #include <scsi/scsi_host.h>
41
42 #include "cciss_scsi.h"
43
44 #define CCISS_ABORT_MSG 0x00
45 #define CCISS_RESET_MSG 0x01
46
47 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
48 size_t size,
49 __u8 page_code, unsigned char *scsi3addr,
50 int cmd_type);
51
52 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
53 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
54
55 static int cciss_scsi_proc_info(
56 struct Scsi_Host *sh,
57 char *buffer, /* data buffer */
58 char **start, /* where data in buffer starts */
59 off_t offset, /* offset from start of imaginary file */
60 int length, /* length of data in buffer */
61 int func); /* 0 == read, 1 == write */
62
63 static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
64 void (* done)(struct scsi_cmnd *));
65 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
66 static int cciss_eh_abort_handler(struct scsi_cmnd *);
67
68 static 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
79 static struct scsi_host_template cciss_driver_template = {
80 .module = THIS_MODULE,
81 .name = "cciss",
82 .proc_name = "cciss",
83 .proc_info = cciss_scsi_proc_info,
84 .queuecommand = cciss_scsi_queue_command,
85 .can_queue = SCSI_CCISS_CAN_QUEUE,
86 .this_id = 7,
87 .cmd_per_lun = 1,
88 .use_clustering = DISABLE_CLUSTERING,
89 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
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 0
97 #define SCSI_PAD_64 0
98
99 struct 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 #define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
110 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
111 // plus two for init time usage
112
113 #pragma pack(1)
114 struct cciss_scsi_cmd_stack_t {
115 struct cciss_scsi_cmd_stack_elem_t *pool;
116 struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
117 dma_addr_t cmd_pool_handle;
118 int top;
119 };
120 #pragma pack()
121
122 struct cciss_scsi_adapter_data_t {
123 struct Scsi_Host *scsi_host;
124 struct cciss_scsi_cmd_stack_t cmd_stack;
125 SGDescriptor_struct **cmd_sg_list;
126 int registered;
127 spinlock_t lock; // to protect ccissscsi[ctlr];
128 };
129
130 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
131 &hba[ctlr]->scsi_ctlr->lock, flags);
132 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
133 &hba[ctlr]->scsi_ctlr->lock, flags);
134
135 static CommandList_struct *
136 scsi_cmd_alloc(ctlr_info_t *h)
137 {
138 /* assume only one process in here at a time, locking done by caller. */
139 /* use CCISS_LOCK(ctlr) */
140 /* might be better to rewrite how we allocate scsi commands in a way that */
141 /* needs no locking at all. */
142
143 /* take the top memory chunk off the stack and return it, if any. */
144 struct cciss_scsi_cmd_stack_elem_t *c;
145 struct cciss_scsi_adapter_data_t *sa;
146 struct cciss_scsi_cmd_stack_t *stk;
147 u64bit temp64;
148
149 sa = h->scsi_ctlr;
150 stk = &sa->cmd_stack;
151
152 if (stk->top < 0)
153 return NULL;
154 c = stk->elem[stk->top];
155 /* memset(c, 0, sizeof(*c)); */
156 memset(&c->cmd, 0, sizeof(c->cmd));
157 memset(&c->Err, 0, sizeof(c->Err));
158 /* set physical addr of cmd and addr of scsi parameters */
159 c->cmd.busaddr = c->busaddr;
160 c->cmd.cmdindex = c->cmdindex;
161 /* (__u32) (stk->cmd_pool_handle +
162 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
163
164 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
165 /* (__u64) (stk->cmd_pool_handle +
166 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
167 sizeof(CommandList_struct)); */
168 stk->top--;
169 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
170 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
171 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
172
173 c->cmd.ctlr = h->ctlr;
174 c->cmd.err_info = &c->Err;
175
176 return (CommandList_struct *) c;
177 }
178
179 static void
180 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
181 {
182 /* assume only one process in here at a time, locking done by caller. */
183 /* use CCISS_LOCK(ctlr) */
184 /* drop the free memory chunk on top of the stack. */
185
186 struct cciss_scsi_adapter_data_t *sa;
187 struct cciss_scsi_cmd_stack_t *stk;
188
189 sa = h->scsi_ctlr;
190 stk = &sa->cmd_stack;
191 if (stk->top >= CMD_STACK_SIZE) {
192 printk("cciss: scsi_cmd_free called too many times.\n");
193 BUG();
194 }
195 stk->top++;
196 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
197 }
198
199 static int
200 scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
201 {
202 int i;
203 struct cciss_scsi_cmd_stack_t *stk;
204 size_t size;
205
206 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr],
207 hba[ctlr]->chainsize, CMD_STACK_SIZE);
208 if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0)
209 return -ENOMEM;
210
211 stk = &sa->cmd_stack;
212 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
213
214 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
215 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
216 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
217 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
218 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
219
220 if (stk->pool == NULL) {
221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
222 sa->cmd_sg_list = NULL;
223 return -ENOMEM;
224 }
225
226 for (i=0; i<CMD_STACK_SIZE; i++) {
227 stk->elem[i] = &stk->pool[i];
228 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
229 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
230 stk->elem[i]->cmdindex = i;
231 }
232 stk->top = CMD_STACK_SIZE-1;
233 return 0;
234 }
235
236 static void
237 scsi_cmd_stack_free(int ctlr)
238 {
239 struct cciss_scsi_adapter_data_t *sa;
240 struct cciss_scsi_cmd_stack_t *stk;
241 size_t size;
242
243 sa = hba[ctlr]->scsi_ctlr;
244 stk = &sa->cmd_stack;
245 if (stk->top != CMD_STACK_SIZE-1) {
246 printk( "cciss: %d scsi commands are still outstanding.\n",
247 CMD_STACK_SIZE - stk->top);
248 // BUG();
249 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
250 }
251 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
252
253 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
254 stk->pool = NULL;
255 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
256 }
257
258 #if 0
259 static int xmargin=8;
260 static int amargin=60;
261
262 static void
263 print_bytes (unsigned char *c, int len, int hex, int ascii)
264 {
265
266 int i;
267 unsigned char *x;
268
269 if (hex)
270 {
271 x = c;
272 for (i=0;i<len;i++)
273 {
274 if ((i % xmargin) == 0 && i>0) printk("\n");
275 if ((i % xmargin) == 0) printk("0x%04x:", i);
276 printk(" %02x", *x);
277 x++;
278 }
279 printk("\n");
280 }
281 if (ascii)
282 {
283 x = c;
284 for (i=0;i<len;i++)
285 {
286 if ((i % amargin) == 0 && i>0) printk("\n");
287 if ((i % amargin) == 0) printk("0x%04x:", i);
288 if (*x > 26 && *x < 128) printk("%c", *x);
289 else printk(".");
290 x++;
291 }
292 printk("\n");
293 }
294 }
295
296 static void
297 print_cmd(CommandList_struct *cp)
298 {
299 printk("queue:%d\n", cp->Header.ReplyQueue);
300 printk("sglist:%d\n", cp->Header.SGList);
301 printk("sgtot:%d\n", cp->Header.SGTotal);
302 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
303 cp->Header.Tag.lower);
304 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
305 cp->Header.LUN.LunAddrBytes[0],
306 cp->Header.LUN.LunAddrBytes[1],
307 cp->Header.LUN.LunAddrBytes[2],
308 cp->Header.LUN.LunAddrBytes[3],
309 cp->Header.LUN.LunAddrBytes[4],
310 cp->Header.LUN.LunAddrBytes[5],
311 cp->Header.LUN.LunAddrBytes[6],
312 cp->Header.LUN.LunAddrBytes[7]);
313 printk("CDBLen:%d\n", cp->Request.CDBLen);
314 printk("Type:%d\n",cp->Request.Type.Type);
315 printk("Attr:%d\n",cp->Request.Type.Attribute);
316 printk(" Dir:%d\n",cp->Request.Type.Direction);
317 printk("Timeout:%d\n",cp->Request.Timeout);
318 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
319 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
320 cp->Request.CDB[0], cp->Request.CDB[1],
321 cp->Request.CDB[2], cp->Request.CDB[3],
322 cp->Request.CDB[4], cp->Request.CDB[5],
323 cp->Request.CDB[6], cp->Request.CDB[7],
324 cp->Request.CDB[8], cp->Request.CDB[9],
325 cp->Request.CDB[10], cp->Request.CDB[11],
326 cp->Request.CDB[12], cp->Request.CDB[13],
327 cp->Request.CDB[14], cp->Request.CDB[15]),
328 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
329 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
330 cp->ErrDesc.Len);
331 printk("sgs..........Errorinfo:\n");
332 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
333 printk("senselen:%d\n", cp->err_info->SenseLen);
334 printk("cmd status:%d\n", cp->err_info->CommandStatus);
335 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
336 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
337 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
338 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
339
340 }
341
342 #endif
343
344 static int
345 find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
346 {
347 /* finds an unused bus, target, lun for a new device */
348 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
349 int i, found=0;
350 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
351
352 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
353
354 target_taken[SELF_SCSI_ID] = 1;
355 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
356 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
357
358 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
359 if (!target_taken[i]) {
360 *bus = 0; *target=i; *lun = 0; found=1;
361 break;
362 }
363 }
364 return (!found);
365 }
366 struct scsi2map {
367 char scsi3addr[8];
368 int bus, target, lun;
369 };
370
371 static int
372 cciss_scsi_add_entry(int ctlr, int hostno,
373 struct cciss_scsi_dev_t *device,
374 struct scsi2map *added, int *nadded)
375 {
376 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
377 int n = ccissscsi[ctlr].ndevices;
378 struct cciss_scsi_dev_t *sd;
379 int i, bus, target, lun;
380 unsigned char addr1[8], addr2[8];
381
382 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
383 printk("cciss%d: Too many devices, "
384 "some will be inaccessible.\n", ctlr);
385 return -1;
386 }
387
388 bus = target = -1;
389 lun = 0;
390 /* Is this device a non-zero lun of a multi-lun device */
391 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
392 if (device->scsi3addr[4] != 0) {
393 /* Search through our list and find the device which */
394 /* has the same 8 byte LUN address, excepting byte 4. */
395 /* Assign the same bus and target for this new LUN. */
396 /* Use the logical unit number from the firmware. */
397 memcpy(addr1, device->scsi3addr, 8);
398 addr1[4] = 0;
399 for (i = 0; i < n; i++) {
400 sd = &ccissscsi[ctlr].dev[i];
401 memcpy(addr2, sd->scsi3addr, 8);
402 addr2[4] = 0;
403 /* differ only in byte 4? */
404 if (memcmp(addr1, addr2, 8) == 0) {
405 bus = sd->bus;
406 target = sd->target;
407 lun = device->scsi3addr[4];
408 break;
409 }
410 }
411 }
412
413 sd = &ccissscsi[ctlr].dev[n];
414 if (lun == 0) {
415 if (find_bus_target_lun(ctlr,
416 &sd->bus, &sd->target, &sd->lun) != 0)
417 return -1;
418 } else {
419 sd->bus = bus;
420 sd->target = target;
421 sd->lun = lun;
422 }
423 added[*nadded].bus = sd->bus;
424 added[*nadded].target = sd->target;
425 added[*nadded].lun = sd->lun;
426 (*nadded)++;
427
428 memcpy(sd->scsi3addr, device->scsi3addr, 8);
429 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
430 memcpy(sd->revision, device->revision, sizeof(sd->revision));
431 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
432 sd->devtype = device->devtype;
433
434 ccissscsi[ctlr].ndevices++;
435
436 /* initially, (before registering with scsi layer) we don't
437 know our hostno and we don't want to print anything first
438 time anyway (the scsi layer's inquiries will show that info) */
439 if (hostno != -1)
440 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
441 ctlr, scsi_device_type(sd->devtype), hostno,
442 sd->bus, sd->target, sd->lun);
443 return 0;
444 }
445
446 static void
447 cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
448 struct scsi2map *removed, int *nremoved)
449 {
450 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
451 int i;
452 struct cciss_scsi_dev_t sd;
453
454 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
455 sd = ccissscsi[ctlr].dev[entry];
456 removed[*nremoved].bus = sd.bus;
457 removed[*nremoved].target = sd.target;
458 removed[*nremoved].lun = sd.lun;
459 (*nremoved)++;
460 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
461 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
462 ccissscsi[ctlr].ndevices--;
463 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
464 ctlr, scsi_device_type(sd.devtype), hostno,
465 sd.bus, sd.target, sd.lun);
466 }
467
468
469 #define SCSI3ADDR_EQ(a,b) ( \
470 (a)[7] == (b)[7] && \
471 (a)[6] == (b)[6] && \
472 (a)[5] == (b)[5] && \
473 (a)[4] == (b)[4] && \
474 (a)[3] == (b)[3] && \
475 (a)[2] == (b)[2] && \
476 (a)[1] == (b)[1] && \
477 (a)[0] == (b)[0])
478
479 static void fixup_botched_add(int ctlr, char *scsi3addr)
480 {
481 /* called when scsi_add_device fails in order to re-adjust */
482 /* ccissscsi[] to match the mid layer's view. */
483 unsigned long flags;
484 int i, j;
485 CPQ_TAPE_LOCK(ctlr, flags);
486 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
487 if (memcmp(scsi3addr,
488 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
489 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
490 ccissscsi[ctlr].dev[j] =
491 ccissscsi[ctlr].dev[j+1];
492 ccissscsi[ctlr].ndevices--;
493 break;
494 }
495 }
496 CPQ_TAPE_UNLOCK(ctlr, flags);
497 }
498
499 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
500 struct cciss_scsi_dev_t *dev2)
501 {
502 return dev1->devtype == dev2->devtype &&
503 memcmp(dev1->scsi3addr, dev2->scsi3addr,
504 sizeof(dev1->scsi3addr)) == 0 &&
505 memcmp(dev1->device_id, dev2->device_id,
506 sizeof(dev1->device_id)) == 0 &&
507 memcmp(dev1->vendor, dev2->vendor,
508 sizeof(dev1->vendor)) == 0 &&
509 memcmp(dev1->model, dev2->model,
510 sizeof(dev1->model)) == 0 &&
511 memcmp(dev1->revision, dev2->revision,
512 sizeof(dev1->revision)) == 0;
513 }
514
515 static int
516 adjust_cciss_scsi_table(int ctlr, int hostno,
517 struct cciss_scsi_dev_t sd[], int nsds)
518 {
519 /* sd contains scsi3 addresses and devtypes, but
520 bus target and lun are not filled in. This funciton
521 takes what's in sd to be the current and adjusts
522 ccissscsi[] to be in line with what's in sd. */
523
524 int i,j, found, changes=0;
525 struct cciss_scsi_dev_t *csd;
526 unsigned long flags;
527 struct scsi2map *added, *removed;
528 int nadded, nremoved;
529 struct Scsi_Host *sh = NULL;
530
531 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
532 GFP_KERNEL);
533 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
534 GFP_KERNEL);
535
536 if (!added || !removed) {
537 printk(KERN_WARNING "cciss%d: Out of memory in "
538 "adjust_cciss_scsi_table\n", ctlr);
539 goto free_and_out;
540 }
541
542 CPQ_TAPE_LOCK(ctlr, flags);
543
544 if (hostno != -1) /* if it's not the first time... */
545 sh = hba[ctlr]->scsi_ctlr->scsi_host;
546
547 /* find any devices in ccissscsi[] that are not in
548 sd[] and remove them from ccissscsi[] */
549
550 i = 0;
551 nremoved = 0;
552 nadded = 0;
553 while(i<ccissscsi[ctlr].ndevices) {
554 csd = &ccissscsi[ctlr].dev[i];
555 found=0;
556 for (j=0;j<nsds;j++) {
557 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
558 csd->scsi3addr)) {
559 if (device_is_the_same(&sd[j], csd))
560 found=2;
561 else
562 found=1;
563 break;
564 }
565 }
566
567 if (found == 0) { /* device no longer present. */
568 changes++;
569 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
570 ctlr, scsi_device_type(csd->devtype), hostno,
571 csd->bus, csd->target, csd->lun); */
572 cciss_scsi_remove_entry(ctlr, hostno, i,
573 removed, &nremoved);
574 /* remove ^^^, hence i not incremented */
575 } else if (found == 1) { /* device is different in some way */
576 changes++;
577 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
578 ctlr, hostno, csd->bus, csd->target, csd->lun);
579 cciss_scsi_remove_entry(ctlr, hostno, i,
580 removed, &nremoved);
581 /* remove ^^^, hence i not incremented */
582 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
583 added, &nadded) != 0)
584 /* we just removed one, so add can't fail. */
585 BUG();
586 csd->devtype = sd[j].devtype;
587 memcpy(csd->device_id, sd[j].device_id,
588 sizeof(csd->device_id));
589 memcpy(csd->vendor, sd[j].vendor,
590 sizeof(csd->vendor));
591 memcpy(csd->model, sd[j].model,
592 sizeof(csd->model));
593 memcpy(csd->revision, sd[j].revision,
594 sizeof(csd->revision));
595 } else /* device is same as it ever was, */
596 i++; /* so just move along. */
597 }
598
599 /* Now, make sure every device listed in sd[] is also
600 listed in ccissscsi[], adding them if they aren't found */
601
602 for (i=0;i<nsds;i++) {
603 found=0;
604 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
605 csd = &ccissscsi[ctlr].dev[j];
606 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
607 csd->scsi3addr)) {
608 if (device_is_the_same(&sd[i], csd))
609 found=2; /* found device */
610 else
611 found=1; /* found a bug. */
612 break;
613 }
614 }
615 if (!found) {
616 changes++;
617 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
618 added, &nadded) != 0)
619 break;
620 } else if (found == 1) {
621 /* should never happen... */
622 changes++;
623 printk(KERN_WARNING "cciss%d: device "
624 "unexpectedly changed\n", ctlr);
625 /* but if it does happen, we just ignore that device */
626 }
627 }
628 CPQ_TAPE_UNLOCK(ctlr, flags);
629
630 /* Don't notify scsi mid layer of any changes the first time through */
631 /* (or if there are no changes) scsi_scan_host will do it later the */
632 /* first time through. */
633 if (hostno == -1 || !changes)
634 goto free_and_out;
635
636 /* Notify scsi mid layer of any removed devices */
637 for (i = 0; i < nremoved; i++) {
638 struct scsi_device *sdev =
639 scsi_device_lookup(sh, removed[i].bus,
640 removed[i].target, removed[i].lun);
641 if (sdev != NULL) {
642 scsi_remove_device(sdev);
643 scsi_device_put(sdev);
644 } else {
645 /* We don't expect to get here. */
646 /* future cmds to this device will get selection */
647 /* timeout as if the device was gone. */
648 printk(KERN_WARNING "cciss%d: didn't find "
649 "c%db%dt%dl%d\n for removal.",
650 ctlr, hostno, removed[i].bus,
651 removed[i].target, removed[i].lun);
652 }
653 }
654
655 /* Notify scsi mid layer of any added devices */
656 for (i = 0; i < nadded; i++) {
657 int rc;
658 rc = scsi_add_device(sh, added[i].bus,
659 added[i].target, added[i].lun);
660 if (rc == 0)
661 continue;
662 printk(KERN_WARNING "cciss%d: scsi_add_device "
663 "c%db%dt%dl%d failed, device not added.\n",
664 ctlr, hostno,
665 added[i].bus, added[i].target, added[i].lun);
666 /* now we have to remove it from ccissscsi, */
667 /* since it didn't get added to scsi mid layer */
668 fixup_botched_add(ctlr, added[i].scsi3addr);
669 }
670
671 free_and_out:
672 kfree(added);
673 kfree(removed);
674 return 0;
675 }
676
677 static int
678 lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
679 {
680 int i;
681 struct cciss_scsi_dev_t *sd;
682 unsigned long flags;
683
684 CPQ_TAPE_LOCK(ctlr, flags);
685 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
686 sd = &ccissscsi[ctlr].dev[i];
687 if (sd->bus == bus &&
688 sd->target == target &&
689 sd->lun == lun) {
690 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
691 CPQ_TAPE_UNLOCK(ctlr, flags);
692 return 0;
693 }
694 }
695 CPQ_TAPE_UNLOCK(ctlr, flags);
696 return -1;
697 }
698
699 static void
700 cciss_scsi_setup(int cntl_num)
701 {
702 struct cciss_scsi_adapter_data_t * shba;
703
704 ccissscsi[cntl_num].ndevices = 0;
705 shba = (struct cciss_scsi_adapter_data_t *)
706 kmalloc(sizeof(*shba), GFP_KERNEL);
707 if (shba == NULL)
708 return;
709 shba->scsi_host = NULL;
710 spin_lock_init(&shba->lock);
711 shba->registered = 0;
712 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
713 kfree(shba);
714 shba = NULL;
715 }
716 hba[cntl_num]->scsi_ctlr = shba;
717 return;
718 }
719
720 static void
721 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
722 {
723 struct scsi_cmnd *cmd;
724 ctlr_info_t *ctlr;
725 ErrorInfo_struct *ei;
726
727 ei = cp->err_info;
728
729 /* First, see if it was a message rather than a command */
730 if (cp->Request.Type.Type == TYPE_MSG) {
731 cp->cmd_type = CMD_MSG_DONE;
732 return;
733 }
734
735 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
736 ctlr = hba[cp->ctlr];
737
738 scsi_dma_unmap(cmd);
739 if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
740 cciss_unmap_sg_chain_block(ctlr, cp);
741
742 cmd->result = (DID_OK << 16); /* host byte */
743 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
744 /* cmd->result |= (GOOD < 1); */ /* status byte */
745
746 cmd->result |= (ei->ScsiStatus);
747 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
748
749 /* copy the sense data whether we need to or not. */
750
751 memcpy(cmd->sense_buffer, ei->SenseInfo,
752 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
753 SCSI_SENSE_BUFFERSIZE :
754 ei->SenseLen);
755 scsi_set_resid(cmd, ei->ResidualCnt);
756
757 if(ei->CommandStatus != 0)
758 { /* an error has occurred */
759 switch(ei->CommandStatus)
760 {
761 case CMD_TARGET_STATUS:
762 /* Pass it up to the upper layers... */
763 if( ei->ScsiStatus)
764 {
765 #if 0
766 printk(KERN_WARNING "cciss: cmd %p "
767 "has SCSI Status = %x\n",
768 cp,
769 ei->ScsiStatus);
770 #endif
771 cmd->result |= (ei->ScsiStatus << 1);
772 }
773 else { /* scsi status is zero??? How??? */
774
775 /* Ordinarily, this case should never happen, but there is a bug
776 in some released firmware revisions that allows it to happen
777 if, for example, a 4100 backplane loses power and the tape
778 drive is in it. We assume that it's a fatal error of some
779 kind because we can't show that it wasn't. We will make it
780 look like selection timeout since that is the most common
781 reason for this to occur, and it's severe enough. */
782
783 cmd->result = DID_NO_CONNECT << 16;
784 }
785 break;
786 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
787 break;
788 case CMD_DATA_OVERRUN:
789 printk(KERN_WARNING "cciss: cp %p has"
790 " completed with data overrun "
791 "reported\n", cp);
792 break;
793 case CMD_INVALID: {
794 /* print_bytes(cp, sizeof(*cp), 1, 0);
795 print_cmd(cp); */
796 /* We get CMD_INVALID if you address a non-existent tape drive instead
797 of a selection timeout (no response). You will see this if you yank
798 out a tape drive, then try to access it. This is kind of a shame
799 because it means that any other CMD_INVALID (e.g. driver bug) will
800 get interpreted as a missing target. */
801 cmd->result = DID_NO_CONNECT << 16;
802 }
803 break;
804 case CMD_PROTOCOL_ERR:
805 printk(KERN_WARNING "cciss: cp %p has "
806 "protocol error \n", cp);
807 break;
808 case CMD_HARDWARE_ERR:
809 cmd->result = DID_ERROR << 16;
810 printk(KERN_WARNING "cciss: cp %p had "
811 " hardware error\n", cp);
812 break;
813 case CMD_CONNECTION_LOST:
814 cmd->result = DID_ERROR << 16;
815 printk(KERN_WARNING "cciss: cp %p had "
816 "connection lost\n", cp);
817 break;
818 case CMD_ABORTED:
819 cmd->result = DID_ABORT << 16;
820 printk(KERN_WARNING "cciss: cp %p was "
821 "aborted\n", cp);
822 break;
823 case CMD_ABORT_FAILED:
824 cmd->result = DID_ERROR << 16;
825 printk(KERN_WARNING "cciss: cp %p reports "
826 "abort failed\n", cp);
827 break;
828 case CMD_UNSOLICITED_ABORT:
829 cmd->result = DID_ABORT << 16;
830 printk(KERN_WARNING "cciss: cp %p aborted "
831 "do to an unsolicited abort\n", cp);
832 break;
833 case CMD_TIMEOUT:
834 cmd->result = DID_TIME_OUT << 16;
835 printk(KERN_WARNING "cciss: cp %p timedout\n",
836 cp);
837 break;
838 default:
839 cmd->result = DID_ERROR << 16;
840 printk(KERN_WARNING "cciss: cp %p returned "
841 "unknown status %x\n", cp,
842 ei->CommandStatus);
843 }
844 }
845 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
846 // cmd->target, cmd->lun);
847 cmd->scsi_done(cmd);
848 scsi_cmd_free(ctlr, cp);
849 }
850
851 static int
852 cciss_scsi_detect(int ctlr)
853 {
854 struct Scsi_Host *sh;
855 int error;
856
857 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
858 if (sh == NULL)
859 goto fail;
860 sh->io_port = 0; // good enough? FIXME,
861 sh->n_io_port = 0; // I don't think we use these two...
862 sh->this_id = SELF_SCSI_ID;
863 sh->sg_tablesize = hba[ctlr]->maxsgentries;
864
865 ((struct cciss_scsi_adapter_data_t *)
866 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
867 sh->hostdata[0] = (unsigned long) hba[ctlr];
868 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
869 sh->unique_id = sh->irq;
870 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
871 if (error)
872 goto fail_host_put;
873 scsi_scan_host(sh);
874 return 1;
875
876 fail_host_put:
877 scsi_host_put(sh);
878 fail:
879 return 0;
880 }
881
882 static void
883 cciss_unmap_one(struct pci_dev *pdev,
884 CommandList_struct *cp,
885 size_t buflen,
886 int data_direction)
887 {
888 u64bit addr64;
889
890 addr64.val32.lower = cp->SG[0].Addr.lower;
891 addr64.val32.upper = cp->SG[0].Addr.upper;
892 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
893 }
894
895 static void
896 cciss_map_one(struct pci_dev *pdev,
897 CommandList_struct *cp,
898 unsigned char *buf,
899 size_t buflen,
900 int data_direction)
901 {
902 __u64 addr64;
903
904 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
905 cp->SG[0].Addr.lower =
906 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
907 cp->SG[0].Addr.upper =
908 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
909 cp->SG[0].Len = buflen;
910 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
911 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
912 }
913
914 static int
915 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
916 CommandList_struct *cp,
917 unsigned char *scsi3addr,
918 unsigned char *cdb,
919 unsigned char cdblen,
920 unsigned char *buf, int bufsize,
921 int direction)
922 {
923 unsigned long flags;
924 DECLARE_COMPLETION_ONSTACK(wait);
925
926 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl
927 cp->scsi_cmd = NULL;
928 cp->Header.ReplyQueue = 0; // unused in simple mode
929 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
930 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
931 // Fill in the request block...
932
933 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
934 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
935 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
936
937 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
938 memcpy(cp->Request.CDB, cdb, cdblen);
939 cp->Request.Timeout = 0;
940 cp->Request.CDBLen = cdblen;
941 cp->Request.Type.Type = TYPE_CMD;
942 cp->Request.Type.Attribute = ATTR_SIMPLE;
943 cp->Request.Type.Direction = direction;
944
945 /* Fill in the SG list and do dma mapping */
946 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
947 bufsize, DMA_FROM_DEVICE);
948
949 cp->waiting = &wait;
950
951 /* Put the request on the tail of the request queue */
952 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
953 addQ(&c->reqQ, cp);
954 c->Qdepth++;
955 start_io(c);
956 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
957
958 wait_for_completion(&wait);
959
960 /* undo the dma mapping */
961 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
962 return(0);
963 }
964
965 static void
966 cciss_scsi_interpret_error(CommandList_struct *cp)
967 {
968 ErrorInfo_struct *ei;
969
970 ei = cp->err_info;
971 switch(ei->CommandStatus)
972 {
973 case CMD_TARGET_STATUS:
974 printk(KERN_WARNING "cciss: cmd %p has "
975 "completed with errors\n", cp);
976 printk(KERN_WARNING "cciss: cmd %p "
977 "has SCSI Status = %x\n",
978 cp,
979 ei->ScsiStatus);
980 if (ei->ScsiStatus == 0)
981 printk(KERN_WARNING
982 "cciss:SCSI status is abnormally zero. "
983 "(probably indicates selection timeout "
984 "reported incorrectly due to a known "
985 "firmware bug, circa July, 2001.)\n");
986 break;
987 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
988 printk("UNDERRUN\n");
989 break;
990 case CMD_DATA_OVERRUN:
991 printk(KERN_WARNING "cciss: cp %p has"
992 " completed with data overrun "
993 "reported\n", cp);
994 break;
995 case CMD_INVALID: {
996 /* controller unfortunately reports SCSI passthru's */
997 /* to non-existent targets as invalid commands. */
998 printk(KERN_WARNING "cciss: cp %p is "
999 "reported invalid (probably means "
1000 "target device no longer present)\n",
1001 cp);
1002 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
1003 print_cmd(cp); */
1004 }
1005 break;
1006 case CMD_PROTOCOL_ERR:
1007 printk(KERN_WARNING "cciss: cp %p has "
1008 "protocol error \n", cp);
1009 break;
1010 case CMD_HARDWARE_ERR:
1011 /* cmd->result = DID_ERROR << 16; */
1012 printk(KERN_WARNING "cciss: cp %p had "
1013 " hardware error\n", cp);
1014 break;
1015 case CMD_CONNECTION_LOST:
1016 printk(KERN_WARNING "cciss: cp %p had "
1017 "connection lost\n", cp);
1018 break;
1019 case CMD_ABORTED:
1020 printk(KERN_WARNING "cciss: cp %p was "
1021 "aborted\n", cp);
1022 break;
1023 case CMD_ABORT_FAILED:
1024 printk(KERN_WARNING "cciss: cp %p reports "
1025 "abort failed\n", cp);
1026 break;
1027 case CMD_UNSOLICITED_ABORT:
1028 printk(KERN_WARNING "cciss: cp %p aborted "
1029 "do to an unsolicited abort\n", cp);
1030 break;
1031 case CMD_TIMEOUT:
1032 printk(KERN_WARNING "cciss: cp %p timedout\n",
1033 cp);
1034 break;
1035 default:
1036 printk(KERN_WARNING "cciss: cp %p returned "
1037 "unknown status %x\n", cp,
1038 ei->CommandStatus);
1039 }
1040 }
1041
1042 static int
1043 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1044 unsigned char page, unsigned char *buf,
1045 unsigned char bufsize)
1046 {
1047 int rc;
1048 CommandList_struct *cp;
1049 char cdb[6];
1050 ErrorInfo_struct *ei;
1051 unsigned long flags;
1052
1053 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1054 cp = scsi_cmd_alloc(c);
1055 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1056
1057 if (cp == NULL) { /* trouble... */
1058 printk("cmd_alloc returned NULL!\n");
1059 return -1;
1060 }
1061
1062 ei = cp->err_info;
1063
1064 cdb[0] = CISS_INQUIRY;
1065 cdb[1] = (page != 0);
1066 cdb[2] = page;
1067 cdb[3] = 0;
1068 cdb[4] = bufsize;
1069 cdb[5] = 0;
1070 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
1071 6, buf, bufsize, XFER_READ);
1072
1073 if (rc != 0) return rc; /* something went wrong */
1074
1075 if (ei->CommandStatus != 0 &&
1076 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1077 cciss_scsi_interpret_error(cp);
1078 rc = -1;
1079 }
1080 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1081 scsi_cmd_free(c, cp);
1082 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1083 return rc;
1084 }
1085
1086 /* Get the device id from inquiry page 0x83 */
1087 static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1088 unsigned char *device_id, int buflen)
1089 {
1090 int rc;
1091 unsigned char *buf;
1092
1093 if (buflen > 16)
1094 buflen = 16;
1095 buf = kzalloc(64, GFP_KERNEL);
1096 if (!buf)
1097 return -1;
1098 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1099 if (rc == 0)
1100 memcpy(device_id, &buf[8], buflen);
1101 kfree(buf);
1102 return rc != 0;
1103 }
1104
1105 static int
1106 cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1107 ReportLunData_struct *buf, int bufsize)
1108 {
1109 int rc;
1110 CommandList_struct *cp;
1111 unsigned char cdb[12];
1112 unsigned char scsi3addr[8];
1113 ErrorInfo_struct *ei;
1114 unsigned long flags;
1115
1116 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1117 cp = scsi_cmd_alloc(c);
1118 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1119 if (cp == NULL) { /* trouble... */
1120 printk("cmd_alloc returned NULL!\n");
1121 return -1;
1122 }
1123
1124 memset(&scsi3addr[0], 0, 8); /* address the controller */
1125 cdb[0] = CISS_REPORT_PHYS;
1126 cdb[1] = 0;
1127 cdb[2] = 0;
1128 cdb[3] = 0;
1129 cdb[4] = 0;
1130 cdb[5] = 0;
1131 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1132 cdb[7] = (bufsize >> 16) & 0xFF;
1133 cdb[8] = (bufsize >> 8) & 0xFF;
1134 cdb[9] = bufsize & 0xFF;
1135 cdb[10] = 0;
1136 cdb[11] = 0;
1137
1138 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1139 cdb, 12,
1140 (unsigned char *) buf,
1141 bufsize, XFER_READ);
1142
1143 if (rc != 0) return rc; /* something went wrong */
1144
1145 ei = cp->err_info;
1146 if (ei->CommandStatus != 0 &&
1147 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1148 cciss_scsi_interpret_error(cp);
1149 rc = -1;
1150 }
1151 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1152 scsi_cmd_free(c, cp);
1153 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1154 return rc;
1155 }
1156
1157 static void
1158 cciss_update_non_disk_devices(int cntl_num, int hostno)
1159 {
1160 /* the idea here is we could get notified from /proc
1161 that some devices have changed, so we do a report
1162 physical luns cmd, and adjust our list of devices
1163 accordingly. (We can't rely on the scsi-mid layer just
1164 doing inquiries, because the "busses" that the scsi
1165 mid-layer probes are totally fabricated by this driver,
1166 so new devices wouldn't show up.
1167
1168 the scsi3addr's of devices won't change so long as the
1169 adapter is not reset. That means we can rescan and
1170 tell which devices we already know about, vs. new
1171 devices, vs. disappearing devices.
1172
1173 Also, if you yank out a tape drive, then put in a disk
1174 in it's place, (say, a configured volume from another
1175 array controller for instance) _don't_ poke this driver
1176 (so it thinks it's still a tape, but _do_ poke the scsi
1177 mid layer, so it does an inquiry... the scsi mid layer
1178 will see the physical disk. This would be bad. Need to
1179 think about how to prevent that. One idea would be to
1180 snoop all scsi responses and if an inquiry repsonse comes
1181 back that reports a disk, chuck it an return selection
1182 timeout instead and adjust our table... Not sure i like
1183 that though.
1184
1185 */
1186 #define OBDR_TAPE_INQ_SIZE 49
1187 #define OBDR_TAPE_SIG "$DR-10"
1188 ReportLunData_struct *ld_buff;
1189 unsigned char *inq_buff;
1190 unsigned char scsi3addr[8];
1191 ctlr_info_t *c;
1192 __u32 num_luns=0;
1193 unsigned char *ch;
1194 struct cciss_scsi_dev_t *currentsd, *this_device;
1195 int ncurrent=0;
1196 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1197 int i;
1198
1199 c = (ctlr_info_t *) hba[cntl_num];
1200 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1201 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1202 currentsd = kzalloc(sizeof(*currentsd) *
1203 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1204 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1205 printk(KERN_ERR "cciss: out of memory\n");
1206 goto out;
1207 }
1208 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1209 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1210 ch = &ld_buff->LUNListLength[0];
1211 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1212 if (num_luns > CISS_MAX_PHYS_LUN) {
1213 printk(KERN_WARNING
1214 "cciss: Maximum physical LUNs (%d) exceeded. "
1215 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1216 num_luns - CISS_MAX_PHYS_LUN);
1217 num_luns = CISS_MAX_PHYS_LUN;
1218 }
1219 }
1220 else {
1221 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1222 goto out;
1223 }
1224
1225
1226 /* adjust our table of devices */
1227 for (i = 0; i < num_luns; i++) {
1228 /* for each physical lun, do an inquiry */
1229 if (ld_buff->LUN[i][3] & 0xC0) continue;
1230 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1231 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1232
1233 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1234 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1235 /* Inquiry failed (msg printed already) */
1236 continue; /* so we will skip this device. */
1237
1238 this_device->devtype = (inq_buff[0] & 0x1f);
1239 this_device->bus = -1;
1240 this_device->target = -1;
1241 this_device->lun = -1;
1242 memcpy(this_device->scsi3addr, scsi3addr, 8);
1243 memcpy(this_device->vendor, &inq_buff[8],
1244 sizeof(this_device->vendor));
1245 memcpy(this_device->model, &inq_buff[16],
1246 sizeof(this_device->model));
1247 memcpy(this_device->revision, &inq_buff[32],
1248 sizeof(this_device->revision));
1249 memset(this_device->device_id, 0,
1250 sizeof(this_device->device_id));
1251 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1252 this_device->device_id, sizeof(this_device->device_id));
1253
1254 switch (this_device->devtype)
1255 {
1256 case 0x05: /* CD-ROM */ {
1257
1258 /* We don't *really* support actual CD-ROM devices,
1259 * just this "One Button Disaster Recovery" tape drive
1260 * which temporarily pretends to be a CD-ROM drive.
1261 * So we check that the device is really an OBDR tape
1262 * device by checking for "$DR-10" in bytes 43-48 of
1263 * the inquiry data.
1264 */
1265 char obdr_sig[7];
1266
1267 strncpy(obdr_sig, &inq_buff[43], 6);
1268 obdr_sig[6] = '\0';
1269 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1270 /* Not OBDR device, ignore it. */
1271 break;
1272 }
1273 /* fall through . . . */
1274 case 0x01: /* sequential access, (tape) */
1275 case 0x08: /* medium changer */
1276 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1277 printk(KERN_INFO "cciss%d: %s ignored, "
1278 "too many devices.\n", cntl_num,
1279 scsi_device_type(this_device->devtype));
1280 break;
1281 }
1282 currentsd[ncurrent] = *this_device;
1283 ncurrent++;
1284 break;
1285 default:
1286 break;
1287 }
1288 }
1289
1290 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1291 out:
1292 kfree(inq_buff);
1293 kfree(ld_buff);
1294 kfree(currentsd);
1295 return;
1296 }
1297
1298 static int
1299 is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1300 {
1301 int verb_len = strlen(verb);
1302 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1303 return verb_len;
1304 else
1305 return 0;
1306 }
1307
1308 static int
1309 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1310 {
1311 int arg_len;
1312
1313 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1314 cciss_update_non_disk_devices(ctlr, hostno);
1315 else
1316 return -EINVAL;
1317 return length;
1318 }
1319
1320
1321 static int
1322 cciss_scsi_proc_info(struct Scsi_Host *sh,
1323 char *buffer, /* data buffer */
1324 char **start, /* where data in buffer starts */
1325 off_t offset, /* offset from start of imaginary file */
1326 int length, /* length of data in buffer */
1327 int func) /* 0 == read, 1 == write */
1328 {
1329
1330 int buflen, datalen;
1331 ctlr_info_t *ci;
1332 int i;
1333 int cntl_num;
1334
1335
1336 ci = (ctlr_info_t *) sh->hostdata[0];
1337 if (ci == NULL) /* This really shouldn't ever happen. */
1338 return -EINVAL;
1339
1340 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1341
1342 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1343 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1344 cntl_num, sh->host_no);
1345
1346 /* this information is needed by apps to know which cciss
1347 device corresponds to which scsi host number without
1348 having to open a scsi target device node. The device
1349 information is not a duplicate of /proc/scsi/scsi because
1350 the two may be out of sync due to scsi hotplug, rather
1351 this info is for an app to be able to use to know how to
1352 get them back in sync. */
1353
1354 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1355 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1356 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1357 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1358 sh->host_no, sd->bus, sd->target, sd->lun,
1359 sd->devtype,
1360 sd->scsi3addr[0], sd->scsi3addr[1],
1361 sd->scsi3addr[2], sd->scsi3addr[3],
1362 sd->scsi3addr[4], sd->scsi3addr[5],
1363 sd->scsi3addr[6], sd->scsi3addr[7]);
1364 }
1365 datalen = buflen - offset;
1366 if (datalen < 0) { /* they're reading past EOF. */
1367 datalen = 0;
1368 *start = buffer+buflen;
1369 } else
1370 *start = buffer + offset;
1371 return(datalen);
1372 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1373 return cciss_scsi_user_command(cntl_num, sh->host_no,
1374 buffer, length);
1375 }
1376
1377 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1378 dma mapping and fills in the scatter gather entries of the
1379 cciss command, cp. */
1380
1381 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1382 struct scsi_cmnd *cmd)
1383 {
1384 unsigned int len;
1385 struct scatterlist *sg;
1386 __u64 addr64;
1387 int request_nsgs, i, chained, sg_index;
1388 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1389 SGDescriptor_struct *curr_sg;
1390
1391 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1392
1393 chained = 0;
1394 sg_index = 0;
1395 curr_sg = cp->SG;
1396 request_nsgs = scsi_dma_map(cmd);
1397 if (request_nsgs) {
1398 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1399 if (sg_index + 1 == h->max_cmd_sgentries &&
1400 !chained && request_nsgs - i > 1) {
1401 chained = 1;
1402 sg_index = 0;
1403 curr_sg = sa->cmd_sg_list[cp->cmdindex];
1404 }
1405 addr64 = (__u64) sg_dma_address(sg);
1406 len = sg_dma_len(sg);
1407 curr_sg[sg_index].Addr.lower =
1408 (__u32) (addr64 & 0x0FFFFFFFFULL);
1409 curr_sg[sg_index].Addr.upper =
1410 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1411 curr_sg[sg_index].Len = len;
1412 curr_sg[sg_index].Ext = 0;
1413 ++sg_index;
1414 }
1415 if (chained)
1416 cciss_map_sg_chain_block(h, cp,
1417 sa->cmd_sg_list[cp->cmdindex],
1418 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1419 sizeof(SGDescriptor_struct));
1420 }
1421 /* track how many SG entries we are using */
1422 if (request_nsgs > h->maxSG)
1423 h->maxSG = request_nsgs;
1424 cp->Header.SGTotal = (__u8) request_nsgs + chained;
1425 if (request_nsgs > h->max_cmd_sgentries)
1426 cp->Header.SGList = h->max_cmd_sgentries;
1427 else
1428 cp->Header.SGList = cp->Header.SGTotal;
1429 return;
1430 }
1431
1432
1433 static int
1434 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1435 {
1436 ctlr_info_t *c;
1437 int ctlr, rc;
1438 unsigned char scsi3addr[8];
1439 CommandList_struct *cp;
1440 unsigned long flags;
1441
1442 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1443 // We violate cmd->host privacy here. (Is there another way?)
1444 c = (ctlr_info_t *) cmd->device->host->hostdata[0];
1445 ctlr = c->ctlr;
1446
1447 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1448 cmd->device->lun, scsi3addr);
1449 if (rc != 0) {
1450 /* the scsi nexus does not match any that we presented... */
1451 /* pretend to mid layer that we got selection timeout */
1452 cmd->result = DID_NO_CONNECT << 16;
1453 done(cmd);
1454 /* we might want to think about registering controller itself
1455 as a processor device on the bus so sg binds to it. */
1456 return 0;
1457 }
1458
1459 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1460 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1461 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1462 // cmd->target, cmd->lun);
1463
1464 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1465 see what the device thinks of it. */
1466
1467 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1468 cp = scsi_cmd_alloc(c);
1469 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1470 if (cp == NULL) { /* trouble... */
1471 printk("scsi_cmd_alloc returned NULL!\n");
1472 /* FIXME: next 3 lines are -> BAD! <- */
1473 cmd->result = DID_NO_CONNECT << 16;
1474 done(cmd);
1475 return 0;
1476 }
1477
1478 // Fill in the command list header
1479
1480 cmd->scsi_done = done; // save this for use by completion code
1481
1482 // save cp in case we have to abort it
1483 cmd->host_scribble = (unsigned char *) cp;
1484
1485 cp->cmd_type = CMD_SCSI;
1486 cp->scsi_cmd = cmd;
1487 cp->Header.ReplyQueue = 0; // unused in simple mode
1488 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1489 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
1490
1491 // Fill in the request block...
1492
1493 cp->Request.Timeout = 0;
1494 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1495 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1496 cp->Request.CDBLen = cmd->cmd_len;
1497 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1498 cp->Request.Type.Type = TYPE_CMD;
1499 cp->Request.Type.Attribute = ATTR_SIMPLE;
1500 switch(cmd->sc_data_direction)
1501 {
1502 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1503 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1504 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1505 case DMA_BIDIRECTIONAL:
1506 // This can happen if a buggy application does a scsi passthru
1507 // and sets both inlen and outlen to non-zero. ( see
1508 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1509
1510 cp->Request.Type.Direction = XFER_RSVD;
1511 // This is technically wrong, and cciss controllers should
1512 // reject it with CMD_INVALID, which is the most correct
1513 // response, but non-fibre backends appear to let it
1514 // slide by, and give the same results as if this field
1515 // were set correctly. Either way is acceptable for
1516 // our purposes here.
1517
1518 break;
1519
1520 default:
1521 printk("cciss: unknown data direction: %d\n",
1522 cmd->sc_data_direction);
1523 BUG();
1524 break;
1525 }
1526 cciss_scatter_gather(c, cp, cmd);
1527
1528 /* Put the request on the tail of the request queue */
1529
1530 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1531 addQ(&c->reqQ, cp);
1532 c->Qdepth++;
1533 start_io(c);
1534 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1535
1536 /* the cmd'll come back via intr handler in complete_scsi_command() */
1537 return 0;
1538 }
1539
1540 static void
1541 cciss_unregister_scsi(int ctlr)
1542 {
1543 struct cciss_scsi_adapter_data_t *sa;
1544 struct cciss_scsi_cmd_stack_t *stk;
1545 unsigned long flags;
1546
1547 /* we are being forcibly unloaded, and may not refuse. */
1548
1549 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1550 sa = hba[ctlr]->scsi_ctlr;
1551 stk = &sa->cmd_stack;
1552
1553 /* if we weren't ever actually registered, don't unregister */
1554 if (sa->registered) {
1555 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1556 scsi_remove_host(sa->scsi_host);
1557 scsi_host_put(sa->scsi_host);
1558 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1559 }
1560
1561 /* set scsi_host to NULL so our detect routine will
1562 find us on register */
1563 sa->scsi_host = NULL;
1564 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1565 scsi_cmd_stack_free(ctlr);
1566 kfree(sa);
1567 }
1568
1569 static int
1570 cciss_engage_scsi(int ctlr)
1571 {
1572 struct cciss_scsi_adapter_data_t *sa;
1573 struct cciss_scsi_cmd_stack_t *stk;
1574 unsigned long flags;
1575
1576 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1577 sa = hba[ctlr]->scsi_ctlr;
1578 stk = &sa->cmd_stack;
1579
1580 if (sa->registered) {
1581 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1582 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1583 return -ENXIO;
1584 }
1585 sa->registered = 1;
1586 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1587 cciss_update_non_disk_devices(ctlr, -1);
1588 cciss_scsi_detect(ctlr);
1589 return 0;
1590 }
1591
1592 static void
1593 cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1594 {
1595 unsigned long flags;
1596
1597 CPQ_TAPE_LOCK(ctlr, flags);
1598 seq_printf(seq,
1599 "Sequential access devices: %d\n\n",
1600 ccissscsi[ctlr].ndevices);
1601 CPQ_TAPE_UNLOCK(ctlr, flags);
1602 }
1603
1604 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1605 unsigned char lunaddr[])
1606 {
1607 int rc;
1608 int count = 0;
1609 int waittime = HZ;
1610 CommandList_struct *c;
1611
1612 c = cmd_alloc(h, 1);
1613 if (!c) {
1614 printk(KERN_WARNING "cciss%d: out of memory in "
1615 "wait_for_device_to_become_ready.\n", h->ctlr);
1616 return IO_ERROR;
1617 }
1618
1619 /* Send test unit ready until device ready, or give up. */
1620 while (count < 20) {
1621
1622 /* Wait for a bit. do this first, because if we send
1623 * the TUR right away, the reset will just abort it.
1624 */
1625 schedule_timeout_uninterruptible(waittime);
1626 count++;
1627
1628 /* Increase wait time with each try, up to a point. */
1629 if (waittime < (HZ * 30))
1630 waittime = waittime * 2;
1631
1632 /* Send the Test Unit Ready */
1633 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1634 lunaddr, TYPE_CMD);
1635 if (rc == 0)
1636 rc = sendcmd_withirq_core(h, c, 0);
1637
1638 (void) process_sendcmd_error(h, c);
1639
1640 if (rc != 0)
1641 goto retry_tur;
1642
1643 if (c->err_info->CommandStatus == CMD_SUCCESS)
1644 break;
1645
1646 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1647 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1648 if (c->err_info->SenseInfo[2] == NO_SENSE)
1649 break;
1650 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1651 unsigned char asc;
1652 asc = c->err_info->SenseInfo[12];
1653 check_for_unit_attention(h, c);
1654 if (asc == POWER_OR_RESET)
1655 break;
1656 }
1657 }
1658 retry_tur:
1659 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1660 "for device to become ready.\n",
1661 h->ctlr, waittime / HZ);
1662 rc = 1; /* device not ready. */
1663 }
1664
1665 if (rc)
1666 printk("cciss%d: giving up on device.\n", h->ctlr);
1667 else
1668 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1669
1670 cmd_free(h, c, 1);
1671 return rc;
1672 }
1673
1674 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1675 * complaining. Doing a host- or bus-reset can't do anything good here.
1676 * Despite what it might say in scsi_error.c, there may well be commands
1677 * on the controller, as the cciss driver registers twice, once as a block
1678 * device for the logical drives, and once as a scsi device, for any tape
1679 * drives. So we know there are no commands out on the tape drives, but we
1680 * don't know there are no commands on the controller, and it is likely
1681 * that there probably are, as the cciss block device is most commonly used
1682 * as a boot device (embedded controller on HP/Compaq systems.)
1683 */
1684
1685 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1686 {
1687 int rc;
1688 CommandList_struct *cmd_in_trouble;
1689 unsigned char lunaddr[8];
1690 ctlr_info_t *c;
1691 int ctlr;
1692
1693 /* find the controller to which the command to be aborted was sent */
1694 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1695 if (c == NULL) /* paranoia */
1696 return FAILED;
1697 ctlr = c->ctlr;
1698 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1699 /* find the command that's giving us trouble */
1700 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1701 if (cmd_in_trouble == NULL) /* paranoia */
1702 return FAILED;
1703 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1704 /* send a reset to the SCSI LUN which the command was sent to */
1705 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1706 TYPE_MSG);
1707 if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
1708 return SUCCESS;
1709 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1710 return FAILED;
1711 }
1712
1713 static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1714 {
1715 int rc;
1716 CommandList_struct *cmd_to_abort;
1717 unsigned char lunaddr[8];
1718 ctlr_info_t *c;
1719 int ctlr;
1720
1721 /* find the controller to which the command to be aborted was sent */
1722 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1723 if (c == NULL) /* paranoia */
1724 return FAILED;
1725 ctlr = c->ctlr;
1726 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1727
1728 /* find the command to be aborted */
1729 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1730 if (cmd_to_abort == NULL) /* paranoia */
1731 return FAILED;
1732 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1733 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1734 0, 0, lunaddr, TYPE_MSG);
1735 if (rc == 0)
1736 return SUCCESS;
1737 return FAILED;
1738
1739 }
1740
1741 #else /* no CONFIG_CISS_SCSI_TAPE */
1742
1743 /* If no tape support, then these become defined out of existence */
1744
1745 #define cciss_scsi_setup(cntl_num)
1746
1747 #endif /* CONFIG_CISS_SCSI_TAPE */