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