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