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