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