diff options
Diffstat (limited to 'drivers/block/cciss_scsi.c')
-rw-r--r-- | drivers/block/cciss_scsi.c | 670 |
1 files changed, 315 insertions, 355 deletions
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c index 72dae92f3cab..575495f3c4b8 100644 --- a/drivers/block/cciss_scsi.c +++ b/drivers/block/cciss_scsi.c | |||
@@ -44,13 +44,15 @@ | |||
44 | #define CCISS_ABORT_MSG 0x00 | 44 | #define CCISS_ABORT_MSG 0x00 |
45 | #define CCISS_RESET_MSG 0x01 | 45 | #define CCISS_RESET_MSG 0x01 |
46 | 46 | ||
47 | static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, | 47 | static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff, |
48 | size_t size, | 48 | size_t size, |
49 | __u8 page_code, unsigned char *scsi3addr, | 49 | __u8 page_code, unsigned char *scsi3addr, |
50 | int cmd_type); | 50 | int cmd_type); |
51 | 51 | ||
52 | static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool); | 52 | static CommandList_struct *cmd_alloc(ctlr_info_t *h); |
53 | static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool); | 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); | ||
54 | 56 | ||
55 | static int cciss_scsi_proc_info( | 57 | static int cciss_scsi_proc_info( |
56 | struct Scsi_Host *sh, | 58 | struct Scsi_Host *sh, |
@@ -93,8 +95,8 @@ static struct scsi_host_template cciss_driver_template = { | |||
93 | 95 | ||
94 | #pragma pack(1) | 96 | #pragma pack(1) |
95 | 97 | ||
96 | #define SCSI_PAD_32 0 | 98 | #define SCSI_PAD_32 8 |
97 | #define SCSI_PAD_64 0 | 99 | #define SCSI_PAD_64 8 |
98 | 100 | ||
99 | struct cciss_scsi_cmd_stack_elem_t { | 101 | struct cciss_scsi_cmd_stack_elem_t { |
100 | CommandList_struct cmd; | 102 | CommandList_struct cmd; |
@@ -127,16 +129,16 @@ struct cciss_scsi_adapter_data_t { | |||
127 | spinlock_t lock; // to protect ccissscsi[ctlr]; | 129 | spinlock_t lock; // to protect ccissscsi[ctlr]; |
128 | }; | 130 | }; |
129 | 131 | ||
130 | #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \ | 132 | #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \ |
131 | &hba[ctlr]->scsi_ctlr->lock, flags); | 133 | &h->scsi_ctlr->lock, flags); |
132 | #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \ | 134 | #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \ |
133 | &hba[ctlr]->scsi_ctlr->lock, flags); | 135 | &h->scsi_ctlr->lock, flags); |
134 | 136 | ||
135 | static CommandList_struct * | 137 | static CommandList_struct * |
136 | scsi_cmd_alloc(ctlr_info_t *h) | 138 | scsi_cmd_alloc(ctlr_info_t *h) |
137 | { | 139 | { |
138 | /* assume only one process in here at a time, locking done by caller. */ | 140 | /* assume only one process in here at a time, locking done by caller. */ |
139 | /* use CCISS_LOCK(ctlr) */ | 141 | /* use h->lock */ |
140 | /* might be better to rewrite how we allocate scsi commands in a way that */ | 142 | /* might be better to rewrite how we allocate scsi commands in a way that */ |
141 | /* needs no locking at all. */ | 143 | /* needs no locking at all. */ |
142 | 144 | ||
@@ -177,10 +179,10 @@ scsi_cmd_alloc(ctlr_info_t *h) | |||
177 | } | 179 | } |
178 | 180 | ||
179 | static void | 181 | static void |
180 | scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd) | 182 | scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c) |
181 | { | 183 | { |
182 | /* assume only one process in here at a time, locking done by caller. */ | 184 | /* assume only one process in here at a time, locking done by caller. */ |
183 | /* use CCISS_LOCK(ctlr) */ | 185 | /* use h->lock */ |
184 | /* drop the free memory chunk on top of the stack. */ | 186 | /* drop the free memory chunk on top of the stack. */ |
185 | 187 | ||
186 | struct cciss_scsi_adapter_data_t *sa; | 188 | struct cciss_scsi_adapter_data_t *sa; |
@@ -190,22 +192,23 @@ scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd) | |||
190 | stk = &sa->cmd_stack; | 192 | stk = &sa->cmd_stack; |
191 | stk->top++; | 193 | stk->top++; |
192 | if (stk->top >= CMD_STACK_SIZE) { | 194 | if (stk->top >= CMD_STACK_SIZE) { |
193 | printk("cciss: scsi_cmd_free called too many times.\n"); | 195 | dev_err(&h->pdev->dev, |
196 | "scsi_cmd_free called too many times.\n"); | ||
194 | BUG(); | 197 | BUG(); |
195 | } | 198 | } |
196 | stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd; | 199 | stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c; |
197 | } | 200 | } |
198 | 201 | ||
199 | static int | 202 | static int |
200 | scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa) | 203 | scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa) |
201 | { | 204 | { |
202 | int i; | 205 | int i; |
203 | struct cciss_scsi_cmd_stack_t *stk; | 206 | struct cciss_scsi_cmd_stack_t *stk; |
204 | size_t size; | 207 | size_t size; |
205 | 208 | ||
206 | sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr], | 209 | sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h, |
207 | hba[ctlr]->chainsize, CMD_STACK_SIZE); | 210 | h->chainsize, CMD_STACK_SIZE); |
208 | if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0) | 211 | if (!sa->cmd_sg_list && h->chainsize > 0) |
209 | return -ENOMEM; | 212 | return -ENOMEM; |
210 | 213 | ||
211 | stk = &sa->cmd_stack; | 214 | stk = &sa->cmd_stack; |
@@ -215,7 +218,7 @@ scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa) | |||
215 | BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0); | 218 | BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0); |
216 | /* pci_alloc_consistent guarantees 32-bit DMA address will be used */ | 219 | /* pci_alloc_consistent guarantees 32-bit DMA address will be used */ |
217 | stk->pool = (struct cciss_scsi_cmd_stack_elem_t *) | 220 | stk->pool = (struct cciss_scsi_cmd_stack_elem_t *) |
218 | pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle); | 221 | pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle); |
219 | 222 | ||
220 | if (stk->pool == NULL) { | 223 | if (stk->pool == NULL) { |
221 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); | 224 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); |
@@ -234,23 +237,22 @@ scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa) | |||
234 | } | 237 | } |
235 | 238 | ||
236 | static void | 239 | static void |
237 | scsi_cmd_stack_free(int ctlr) | 240 | scsi_cmd_stack_free(ctlr_info_t *h) |
238 | { | 241 | { |
239 | struct cciss_scsi_adapter_data_t *sa; | 242 | struct cciss_scsi_adapter_data_t *sa; |
240 | struct cciss_scsi_cmd_stack_t *stk; | 243 | struct cciss_scsi_cmd_stack_t *stk; |
241 | size_t size; | 244 | size_t size; |
242 | 245 | ||
243 | sa = hba[ctlr]->scsi_ctlr; | 246 | sa = h->scsi_ctlr; |
244 | stk = &sa->cmd_stack; | 247 | stk = &sa->cmd_stack; |
245 | if (stk->top != CMD_STACK_SIZE-1) { | 248 | if (stk->top != CMD_STACK_SIZE-1) { |
246 | printk( "cciss: %d scsi commands are still outstanding.\n", | 249 | dev_warn(&h->pdev->dev, |
250 | "bug: %d scsi commands are still outstanding.\n", | ||
247 | CMD_STACK_SIZE - stk->top); | 251 | CMD_STACK_SIZE - stk->top); |
248 | // BUG(); | ||
249 | printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk); | ||
250 | } | 252 | } |
251 | size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE; | 253 | size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE; |
252 | 254 | ||
253 | pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle); | 255 | pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle); |
254 | stk->pool = NULL; | 256 | stk->pool = NULL; |
255 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); | 257 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); |
256 | } | 258 | } |
@@ -342,20 +344,20 @@ print_cmd(CommandList_struct *cp) | |||
342 | #endif | 344 | #endif |
343 | 345 | ||
344 | static int | 346 | static int |
345 | find_bus_target_lun(int ctlr, int *bus, int *target, int *lun) | 347 | find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun) |
346 | { | 348 | { |
347 | /* finds an unused bus, target, lun for a new device */ | 349 | /* finds an unused bus, target, lun for a new device */ |
348 | /* assumes hba[ctlr]->scsi_ctlr->lock is held */ | 350 | /* assumes h->scsi_ctlr->lock is held */ |
349 | int i, found=0; | 351 | int i, found=0; |
350 | unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA]; | 352 | unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA]; |
351 | 353 | ||
352 | memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA); | 354 | memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA); |
353 | 355 | ||
354 | target_taken[SELF_SCSI_ID] = 1; | 356 | target_taken[SELF_SCSI_ID] = 1; |
355 | for (i=0;i<ccissscsi[ctlr].ndevices;i++) | 357 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) |
356 | target_taken[ccissscsi[ctlr].dev[i].target] = 1; | 358 | target_taken[ccissscsi[h->ctlr].dev[i].target] = 1; |
357 | 359 | ||
358 | for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) { | 360 | for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) { |
359 | if (!target_taken[i]) { | 361 | if (!target_taken[i]) { |
360 | *bus = 0; *target=i; *lun = 0; found=1; | 362 | *bus = 0; *target=i; *lun = 0; found=1; |
361 | break; | 363 | break; |
@@ -369,19 +371,19 @@ struct scsi2map { | |||
369 | }; | 371 | }; |
370 | 372 | ||
371 | static int | 373 | static int |
372 | cciss_scsi_add_entry(int ctlr, int hostno, | 374 | cciss_scsi_add_entry(ctlr_info_t *h, int hostno, |
373 | struct cciss_scsi_dev_t *device, | 375 | struct cciss_scsi_dev_t *device, |
374 | struct scsi2map *added, int *nadded) | 376 | struct scsi2map *added, int *nadded) |
375 | { | 377 | { |
376 | /* assumes hba[ctlr]->scsi_ctlr->lock is held */ | 378 | /* assumes h->scsi_ctlr->lock is held */ |
377 | int n = ccissscsi[ctlr].ndevices; | 379 | int n = ccissscsi[h->ctlr].ndevices; |
378 | struct cciss_scsi_dev_t *sd; | 380 | struct cciss_scsi_dev_t *sd; |
379 | int i, bus, target, lun; | 381 | int i, bus, target, lun; |
380 | unsigned char addr1[8], addr2[8]; | 382 | unsigned char addr1[8], addr2[8]; |
381 | 383 | ||
382 | if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) { | 384 | if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) { |
383 | printk("cciss%d: Too many devices, " | 385 | dev_warn(&h->pdev->dev, "Too many devices, " |
384 | "some will be inaccessible.\n", ctlr); | 386 | "some will be inaccessible.\n"); |
385 | return -1; | 387 | return -1; |
386 | } | 388 | } |
387 | 389 | ||
@@ -397,7 +399,7 @@ cciss_scsi_add_entry(int ctlr, int hostno, | |||
397 | memcpy(addr1, device->scsi3addr, 8); | 399 | memcpy(addr1, device->scsi3addr, 8); |
398 | addr1[4] = 0; | 400 | addr1[4] = 0; |
399 | for (i = 0; i < n; i++) { | 401 | for (i = 0; i < n; i++) { |
400 | sd = &ccissscsi[ctlr].dev[i]; | 402 | sd = &ccissscsi[h->ctlr].dev[i]; |
401 | memcpy(addr2, sd->scsi3addr, 8); | 403 | memcpy(addr2, sd->scsi3addr, 8); |
402 | addr2[4] = 0; | 404 | addr2[4] = 0; |
403 | /* differ only in byte 4? */ | 405 | /* differ only in byte 4? */ |
@@ -410,9 +412,9 @@ cciss_scsi_add_entry(int ctlr, int hostno, | |||
410 | } | 412 | } |
411 | } | 413 | } |
412 | 414 | ||
413 | sd = &ccissscsi[ctlr].dev[n]; | 415 | sd = &ccissscsi[h->ctlr].dev[n]; |
414 | if (lun == 0) { | 416 | if (lun == 0) { |
415 | if (find_bus_target_lun(ctlr, | 417 | if (find_bus_target_lun(h, |
416 | &sd->bus, &sd->target, &sd->lun) != 0) | 418 | &sd->bus, &sd->target, &sd->lun) != 0) |
417 | return -1; | 419 | return -1; |
418 | } else { | 420 | } else { |
@@ -431,37 +433,37 @@ cciss_scsi_add_entry(int ctlr, int hostno, | |||
431 | memcpy(sd->device_id, device->device_id, sizeof(sd->device_id)); | 433 | memcpy(sd->device_id, device->device_id, sizeof(sd->device_id)); |
432 | sd->devtype = device->devtype; | 434 | sd->devtype = device->devtype; |
433 | 435 | ||
434 | ccissscsi[ctlr].ndevices++; | 436 | ccissscsi[h->ctlr].ndevices++; |
435 | 437 | ||
436 | /* initially, (before registering with scsi layer) we don't | 438 | /* initially, (before registering with scsi layer) we don't |
437 | know our hostno and we don't want to print anything first | 439 | know our hostno and we don't want to print anything first |
438 | time anyway (the scsi layer's inquiries will show that info) */ | 440 | time anyway (the scsi layer's inquiries will show that info) */ |
439 | if (hostno != -1) | 441 | if (hostno != -1) |
440 | printk("cciss%d: %s device c%db%dt%dl%d added.\n", | 442 | dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n", |
441 | ctlr, scsi_device_type(sd->devtype), hostno, | 443 | scsi_device_type(sd->devtype), hostno, |
442 | sd->bus, sd->target, sd->lun); | 444 | sd->bus, sd->target, sd->lun); |
443 | return 0; | 445 | return 0; |
444 | } | 446 | } |
445 | 447 | ||
446 | static void | 448 | static void |
447 | cciss_scsi_remove_entry(int ctlr, int hostno, int entry, | 449 | cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry, |
448 | struct scsi2map *removed, int *nremoved) | 450 | struct scsi2map *removed, int *nremoved) |
449 | { | 451 | { |
450 | /* assumes hba[ctlr]->scsi_ctlr->lock is held */ | 452 | /* assumes h->ctlr]->scsi_ctlr->lock is held */ |
451 | int i; | 453 | int i; |
452 | struct cciss_scsi_dev_t sd; | 454 | struct cciss_scsi_dev_t sd; |
453 | 455 | ||
454 | if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return; | 456 | if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return; |
455 | sd = ccissscsi[ctlr].dev[entry]; | 457 | sd = ccissscsi[h->ctlr].dev[entry]; |
456 | removed[*nremoved].bus = sd.bus; | 458 | removed[*nremoved].bus = sd.bus; |
457 | removed[*nremoved].target = sd.target; | 459 | removed[*nremoved].target = sd.target; |
458 | removed[*nremoved].lun = sd.lun; | 460 | removed[*nremoved].lun = sd.lun; |
459 | (*nremoved)++; | 461 | (*nremoved)++; |
460 | for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++) | 462 | for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++) |
461 | ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1]; | 463 | ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1]; |
462 | ccissscsi[ctlr].ndevices--; | 464 | ccissscsi[h->ctlr].ndevices--; |
463 | printk("cciss%d: %s device c%db%dt%dl%d removed.\n", | 465 | dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n", |
464 | ctlr, scsi_device_type(sd.devtype), hostno, | 466 | scsi_device_type(sd.devtype), hostno, |
465 | sd.bus, sd.target, sd.lun); | 467 | sd.bus, sd.target, sd.lun); |
466 | } | 468 | } |
467 | 469 | ||
@@ -476,24 +478,24 @@ cciss_scsi_remove_entry(int ctlr, int hostno, int entry, | |||
476 | (a)[1] == (b)[1] && \ | 478 | (a)[1] == (b)[1] && \ |
477 | (a)[0] == (b)[0]) | 479 | (a)[0] == (b)[0]) |
478 | 480 | ||
479 | static void fixup_botched_add(int ctlr, char *scsi3addr) | 481 | static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr) |
480 | { | 482 | { |
481 | /* called when scsi_add_device fails in order to re-adjust */ | 483 | /* called when scsi_add_device fails in order to re-adjust */ |
482 | /* ccissscsi[] to match the mid layer's view. */ | 484 | /* ccissscsi[] to match the mid layer's view. */ |
483 | unsigned long flags; | 485 | unsigned long flags; |
484 | int i, j; | 486 | int i, j; |
485 | CPQ_TAPE_LOCK(ctlr, flags); | 487 | CPQ_TAPE_LOCK(h, flags); |
486 | for (i = 0; i < ccissscsi[ctlr].ndevices; i++) { | 488 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
487 | if (memcmp(scsi3addr, | 489 | if (memcmp(scsi3addr, |
488 | ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) { | 490 | ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) { |
489 | for (j = i; j < ccissscsi[ctlr].ndevices-1; j++) | 491 | for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++) |
490 | ccissscsi[ctlr].dev[j] = | 492 | ccissscsi[h->ctlr].dev[j] = |
491 | ccissscsi[ctlr].dev[j+1]; | 493 | ccissscsi[h->ctlr].dev[j+1]; |
492 | ccissscsi[ctlr].ndevices--; | 494 | ccissscsi[h->ctlr].ndevices--; |
493 | break; | 495 | break; |
494 | } | 496 | } |
495 | } | 497 | } |
496 | CPQ_TAPE_UNLOCK(ctlr, flags); | 498 | CPQ_TAPE_UNLOCK(h, flags); |
497 | } | 499 | } |
498 | 500 | ||
499 | static int device_is_the_same(struct cciss_scsi_dev_t *dev1, | 501 | static int device_is_the_same(struct cciss_scsi_dev_t *dev1, |
@@ -513,7 +515,7 @@ static int device_is_the_same(struct cciss_scsi_dev_t *dev1, | |||
513 | } | 515 | } |
514 | 516 | ||
515 | static int | 517 | static int |
516 | adjust_cciss_scsi_table(int ctlr, int hostno, | 518 | adjust_cciss_scsi_table(ctlr_info_t *h, int hostno, |
517 | struct cciss_scsi_dev_t sd[], int nsds) | 519 | struct cciss_scsi_dev_t sd[], int nsds) |
518 | { | 520 | { |
519 | /* sd contains scsi3 addresses and devtypes, but | 521 | /* sd contains scsi3 addresses and devtypes, but |
@@ -534,15 +536,15 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
534 | GFP_KERNEL); | 536 | GFP_KERNEL); |
535 | 537 | ||
536 | if (!added || !removed) { | 538 | if (!added || !removed) { |
537 | printk(KERN_WARNING "cciss%d: Out of memory in " | 539 | dev_warn(&h->pdev->dev, |
538 | "adjust_cciss_scsi_table\n", ctlr); | 540 | "Out of memory in adjust_cciss_scsi_table\n"); |
539 | goto free_and_out; | 541 | goto free_and_out; |
540 | } | 542 | } |
541 | 543 | ||
542 | CPQ_TAPE_LOCK(ctlr, flags); | 544 | CPQ_TAPE_LOCK(h, flags); |
543 | 545 | ||
544 | if (hostno != -1) /* if it's not the first time... */ | 546 | if (hostno != -1) /* if it's not the first time... */ |
545 | sh = hba[ctlr]->scsi_ctlr->scsi_host; | 547 | sh = h->scsi_ctlr->scsi_host; |
546 | 548 | ||
547 | /* find any devices in ccissscsi[] that are not in | 549 | /* find any devices in ccissscsi[] that are not in |
548 | sd[] and remove them from ccissscsi[] */ | 550 | sd[] and remove them from ccissscsi[] */ |
@@ -550,8 +552,8 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
550 | i = 0; | 552 | i = 0; |
551 | nremoved = 0; | 553 | nremoved = 0; |
552 | nadded = 0; | 554 | nadded = 0; |
553 | while(i<ccissscsi[ctlr].ndevices) { | 555 | while (i < ccissscsi[h->ctlr].ndevices) { |
554 | csd = &ccissscsi[ctlr].dev[i]; | 556 | csd = &ccissscsi[h->ctlr].dev[i]; |
555 | found=0; | 557 | found=0; |
556 | for (j=0;j<nsds;j++) { | 558 | for (j=0;j<nsds;j++) { |
557 | if (SCSI3ADDR_EQ(sd[j].scsi3addr, | 559 | if (SCSI3ADDR_EQ(sd[j].scsi3addr, |
@@ -566,20 +568,18 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
566 | 568 | ||
567 | if (found == 0) { /* device no longer present. */ | 569 | if (found == 0) { /* device no longer present. */ |
568 | changes++; | 570 | changes++; |
569 | /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n", | 571 | cciss_scsi_remove_entry(h, hostno, i, |
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); | 572 | removed, &nremoved); |
574 | /* remove ^^^, hence i not incremented */ | 573 | /* remove ^^^, hence i not incremented */ |
575 | } else if (found == 1) { /* device is different in some way */ | 574 | } else if (found == 1) { /* device is different in some way */ |
576 | changes++; | 575 | changes++; |
577 | printk("cciss%d: device c%db%dt%dl%d has changed.\n", | 576 | dev_info(&h->pdev->dev, |
578 | ctlr, hostno, csd->bus, csd->target, csd->lun); | 577 | "device c%db%dt%dl%d has changed.\n", |
579 | cciss_scsi_remove_entry(ctlr, hostno, i, | 578 | hostno, csd->bus, csd->target, csd->lun); |
579 | cciss_scsi_remove_entry(h, hostno, i, | ||
580 | removed, &nremoved); | 580 | removed, &nremoved); |
581 | /* remove ^^^, hence i not incremented */ | 581 | /* remove ^^^, hence i not incremented */ |
582 | if (cciss_scsi_add_entry(ctlr, hostno, &sd[j], | 582 | if (cciss_scsi_add_entry(h, hostno, &sd[j], |
583 | added, &nadded) != 0) | 583 | added, &nadded) != 0) |
584 | /* we just removed one, so add can't fail. */ | 584 | /* we just removed one, so add can't fail. */ |
585 | BUG(); | 585 | BUG(); |
@@ -601,8 +601,8 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
601 | 601 | ||
602 | for (i=0;i<nsds;i++) { | 602 | for (i=0;i<nsds;i++) { |
603 | found=0; | 603 | found=0; |
604 | for (j=0;j<ccissscsi[ctlr].ndevices;j++) { | 604 | for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) { |
605 | csd = &ccissscsi[ctlr].dev[j]; | 605 | csd = &ccissscsi[h->ctlr].dev[j]; |
606 | if (SCSI3ADDR_EQ(sd[i].scsi3addr, | 606 | if (SCSI3ADDR_EQ(sd[i].scsi3addr, |
607 | csd->scsi3addr)) { | 607 | csd->scsi3addr)) { |
608 | if (device_is_the_same(&sd[i], csd)) | 608 | if (device_is_the_same(&sd[i], csd)) |
@@ -614,18 +614,18 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
614 | } | 614 | } |
615 | if (!found) { | 615 | if (!found) { |
616 | changes++; | 616 | changes++; |
617 | if (cciss_scsi_add_entry(ctlr, hostno, &sd[i], | 617 | if (cciss_scsi_add_entry(h, hostno, &sd[i], |
618 | added, &nadded) != 0) | 618 | added, &nadded) != 0) |
619 | break; | 619 | break; |
620 | } else if (found == 1) { | 620 | } else if (found == 1) { |
621 | /* should never happen... */ | 621 | /* should never happen... */ |
622 | changes++; | 622 | changes++; |
623 | printk(KERN_WARNING "cciss%d: device " | 623 | dev_warn(&h->pdev->dev, |
624 | "unexpectedly changed\n", ctlr); | 624 | "device unexpectedly changed\n"); |
625 | /* but if it does happen, we just ignore that device */ | 625 | /* but if it does happen, we just ignore that device */ |
626 | } | 626 | } |
627 | } | 627 | } |
628 | CPQ_TAPE_UNLOCK(ctlr, flags); | 628 | CPQ_TAPE_UNLOCK(h, flags); |
629 | 629 | ||
630 | /* Don't notify scsi mid layer of any changes the first time through */ | 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 */ | 631 | /* (or if there are no changes) scsi_scan_host will do it later the */ |
@@ -645,9 +645,9 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
645 | /* We don't expect to get here. */ | 645 | /* We don't expect to get here. */ |
646 | /* future cmds to this device will get selection */ | 646 | /* future cmds to this device will get selection */ |
647 | /* timeout as if the device was gone. */ | 647 | /* timeout as if the device was gone. */ |
648 | printk(KERN_WARNING "cciss%d: didn't find " | 648 | dev_warn(&h->pdev->dev, "didn't find " |
649 | "c%db%dt%dl%d\n for removal.", | 649 | "c%db%dt%dl%d\n for removal.", |
650 | ctlr, hostno, removed[i].bus, | 650 | hostno, removed[i].bus, |
651 | removed[i].target, removed[i].lun); | 651 | removed[i].target, removed[i].lun); |
652 | } | 652 | } |
653 | } | 653 | } |
@@ -659,13 +659,12 @@ adjust_cciss_scsi_table(int ctlr, int hostno, | |||
659 | added[i].target, added[i].lun); | 659 | added[i].target, added[i].lun); |
660 | if (rc == 0) | 660 | if (rc == 0) |
661 | continue; | 661 | continue; |
662 | printk(KERN_WARNING "cciss%d: scsi_add_device " | 662 | dev_warn(&h->pdev->dev, "scsi_add_device " |
663 | "c%db%dt%dl%d failed, device not added.\n", | 663 | "c%db%dt%dl%d failed, device not added.\n", |
664 | ctlr, hostno, | 664 | hostno, added[i].bus, added[i].target, added[i].lun); |
665 | added[i].bus, added[i].target, added[i].lun); | ||
666 | /* now we have to remove it from ccissscsi, */ | 665 | /* now we have to remove it from ccissscsi, */ |
667 | /* since it didn't get added to scsi mid layer */ | 666 | /* since it didn't get added to scsi mid layer */ |
668 | fixup_botched_add(ctlr, added[i].scsi3addr); | 667 | fixup_botched_add(h, added[i].scsi3addr); |
669 | } | 668 | } |
670 | 669 | ||
671 | free_and_out: | 670 | free_and_out: |
@@ -675,33 +674,33 @@ free_and_out: | |||
675 | } | 674 | } |
676 | 675 | ||
677 | static int | 676 | static int |
678 | lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr) | 677 | lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr) |
679 | { | 678 | { |
680 | int i; | 679 | int i; |
681 | struct cciss_scsi_dev_t *sd; | 680 | struct cciss_scsi_dev_t *sd; |
682 | unsigned long flags; | 681 | unsigned long flags; |
683 | 682 | ||
684 | CPQ_TAPE_LOCK(ctlr, flags); | 683 | CPQ_TAPE_LOCK(h, flags); |
685 | for (i=0;i<ccissscsi[ctlr].ndevices;i++) { | 684 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
686 | sd = &ccissscsi[ctlr].dev[i]; | 685 | sd = &ccissscsi[h->ctlr].dev[i]; |
687 | if (sd->bus == bus && | 686 | if (sd->bus == bus && |
688 | sd->target == target && | 687 | sd->target == target && |
689 | sd->lun == lun) { | 688 | sd->lun == lun) { |
690 | memcpy(scsi3addr, &sd->scsi3addr[0], 8); | 689 | memcpy(scsi3addr, &sd->scsi3addr[0], 8); |
691 | CPQ_TAPE_UNLOCK(ctlr, flags); | 690 | CPQ_TAPE_UNLOCK(h, flags); |
692 | return 0; | 691 | return 0; |
693 | } | 692 | } |
694 | } | 693 | } |
695 | CPQ_TAPE_UNLOCK(ctlr, flags); | 694 | CPQ_TAPE_UNLOCK(h, flags); |
696 | return -1; | 695 | return -1; |
697 | } | 696 | } |
698 | 697 | ||
699 | static void | 698 | static void |
700 | cciss_scsi_setup(int cntl_num) | 699 | cciss_scsi_setup(ctlr_info_t *h) |
701 | { | 700 | { |
702 | struct cciss_scsi_adapter_data_t * shba; | 701 | struct cciss_scsi_adapter_data_t * shba; |
703 | 702 | ||
704 | ccissscsi[cntl_num].ndevices = 0; | 703 | ccissscsi[h->ctlr].ndevices = 0; |
705 | shba = (struct cciss_scsi_adapter_data_t *) | 704 | shba = (struct cciss_scsi_adapter_data_t *) |
706 | kmalloc(sizeof(*shba), GFP_KERNEL); | 705 | kmalloc(sizeof(*shba), GFP_KERNEL); |
707 | if (shba == NULL) | 706 | if (shba == NULL) |
@@ -709,35 +708,35 @@ cciss_scsi_setup(int cntl_num) | |||
709 | shba->scsi_host = NULL; | 708 | shba->scsi_host = NULL; |
710 | spin_lock_init(&shba->lock); | 709 | spin_lock_init(&shba->lock); |
711 | shba->registered = 0; | 710 | shba->registered = 0; |
712 | if (scsi_cmd_stack_setup(cntl_num, shba) != 0) { | 711 | if (scsi_cmd_stack_setup(h, shba) != 0) { |
713 | kfree(shba); | 712 | kfree(shba); |
714 | shba = NULL; | 713 | shba = NULL; |
715 | } | 714 | } |
716 | hba[cntl_num]->scsi_ctlr = shba; | 715 | h->scsi_ctlr = shba; |
717 | return; | 716 | return; |
718 | } | 717 | } |
719 | 718 | ||
720 | static void | 719 | static void complete_scsi_command(CommandList_struct *c, int timeout, |
721 | complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag) | 720 | __u32 tag) |
722 | { | 721 | { |
723 | struct scsi_cmnd *cmd; | 722 | struct scsi_cmnd *cmd; |
724 | ctlr_info_t *ctlr; | 723 | ctlr_info_t *h; |
725 | ErrorInfo_struct *ei; | 724 | ErrorInfo_struct *ei; |
726 | 725 | ||
727 | ei = cp->err_info; | 726 | ei = c->err_info; |
728 | 727 | ||
729 | /* First, see if it was a message rather than a command */ | 728 | /* First, see if it was a message rather than a command */ |
730 | if (cp->Request.Type.Type == TYPE_MSG) { | 729 | if (c->Request.Type.Type == TYPE_MSG) { |
731 | cp->cmd_type = CMD_MSG_DONE; | 730 | c->cmd_type = CMD_MSG_DONE; |
732 | return; | 731 | return; |
733 | } | 732 | } |
734 | 733 | ||
735 | cmd = (struct scsi_cmnd *) cp->scsi_cmd; | 734 | cmd = (struct scsi_cmnd *) c->scsi_cmd; |
736 | ctlr = hba[cp->ctlr]; | 735 | h = hba[c->ctlr]; |
737 | 736 | ||
738 | scsi_dma_unmap(cmd); | 737 | scsi_dma_unmap(cmd); |
739 | if (cp->Header.SGTotal > ctlr->max_cmd_sgentries) | 738 | if (c->Header.SGTotal > h->max_cmd_sgentries) |
740 | cciss_unmap_sg_chain_block(ctlr, cp); | 739 | cciss_unmap_sg_chain_block(h, c); |
741 | 740 | ||
742 | cmd->result = (DID_OK << 16); /* host byte */ | 741 | cmd->result = (DID_OK << 16); /* host byte */ |
743 | cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */ | 742 | cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */ |
@@ -764,9 +763,8 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag) | |||
764 | { | 763 | { |
765 | #if 0 | 764 | #if 0 |
766 | printk(KERN_WARNING "cciss: cmd %p " | 765 | printk(KERN_WARNING "cciss: cmd %p " |
767 | "has SCSI Status = %x\n", | 766 | "has SCSI Status = %x\n", |
768 | cp, | 767 | c, ei->ScsiStatus); |
769 | ei->ScsiStatus); | ||
770 | #endif | 768 | #endif |
771 | cmd->result |= (ei->ScsiStatus << 1); | 769 | cmd->result |= (ei->ScsiStatus << 1); |
772 | } | 770 | } |
@@ -786,13 +784,13 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag) | |||
786 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ | 784 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ |
787 | break; | 785 | break; |
788 | case CMD_DATA_OVERRUN: | 786 | case CMD_DATA_OVERRUN: |
789 | printk(KERN_WARNING "cciss: cp %p has" | 787 | dev_warn(&h->pdev->dev, "%p has" |
790 | " completed with data overrun " | 788 | " completed with data overrun " |
791 | "reported\n", cp); | 789 | "reported\n", c); |
792 | break; | 790 | break; |
793 | case CMD_INVALID: { | 791 | case CMD_INVALID: { |
794 | /* print_bytes(cp, sizeof(*cp), 1, 0); | 792 | /* print_bytes(c, sizeof(*c), 1, 0); |
795 | print_cmd(cp); */ | 793 | print_cmd(c); */ |
796 | /* We get CMD_INVALID if you address a non-existent tape drive instead | 794 | /* 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 | 795 | 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 | 796 | out a tape drive, then try to access it. This is kind of a shame |
@@ -802,54 +800,50 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag) | |||
802 | } | 800 | } |
803 | break; | 801 | break; |
804 | case CMD_PROTOCOL_ERR: | 802 | case CMD_PROTOCOL_ERR: |
805 | printk(KERN_WARNING "cciss: cp %p has " | 803 | dev_warn(&h->pdev->dev, |
806 | "protocol error \n", cp); | 804 | "%p has protocol error\n", c); |
807 | break; | 805 | break; |
808 | case CMD_HARDWARE_ERR: | 806 | case CMD_HARDWARE_ERR: |
809 | cmd->result = DID_ERROR << 16; | 807 | cmd->result = DID_ERROR << 16; |
810 | printk(KERN_WARNING "cciss: cp %p had " | 808 | dev_warn(&h->pdev->dev, |
811 | " hardware error\n", cp); | 809 | "%p had hardware error\n", c); |
812 | break; | 810 | break; |
813 | case CMD_CONNECTION_LOST: | 811 | case CMD_CONNECTION_LOST: |
814 | cmd->result = DID_ERROR << 16; | 812 | cmd->result = DID_ERROR << 16; |
815 | printk(KERN_WARNING "cciss: cp %p had " | 813 | dev_warn(&h->pdev->dev, |
816 | "connection lost\n", cp); | 814 | "%p had connection lost\n", c); |
817 | break; | 815 | break; |
818 | case CMD_ABORTED: | 816 | case CMD_ABORTED: |
819 | cmd->result = DID_ABORT << 16; | 817 | cmd->result = DID_ABORT << 16; |
820 | printk(KERN_WARNING "cciss: cp %p was " | 818 | dev_warn(&h->pdev->dev, "%p was aborted\n", c); |
821 | "aborted\n", cp); | ||
822 | break; | 819 | break; |
823 | case CMD_ABORT_FAILED: | 820 | case CMD_ABORT_FAILED: |
824 | cmd->result = DID_ERROR << 16; | 821 | cmd->result = DID_ERROR << 16; |
825 | printk(KERN_WARNING "cciss: cp %p reports " | 822 | dev_warn(&h->pdev->dev, |
826 | "abort failed\n", cp); | 823 | "%p reports abort failed\n", c); |
827 | break; | 824 | break; |
828 | case CMD_UNSOLICITED_ABORT: | 825 | case CMD_UNSOLICITED_ABORT: |
829 | cmd->result = DID_ABORT << 16; | 826 | cmd->result = DID_ABORT << 16; |
830 | printk(KERN_WARNING "cciss: cp %p aborted " | 827 | dev_warn(&h->pdev->dev, "%p aborted do to an " |
831 | "do to an unsolicited abort\n", cp); | 828 | "unsolicited abort\n", c); |
832 | break; | 829 | break; |
833 | case CMD_TIMEOUT: | 830 | case CMD_TIMEOUT: |
834 | cmd->result = DID_TIME_OUT << 16; | 831 | cmd->result = DID_TIME_OUT << 16; |
835 | printk(KERN_WARNING "cciss: cp %p timedout\n", | 832 | dev_warn(&h->pdev->dev, "%p timedout\n", c); |
836 | cp); | ||
837 | break; | 833 | break; |
838 | default: | 834 | default: |
839 | cmd->result = DID_ERROR << 16; | 835 | cmd->result = DID_ERROR << 16; |
840 | printk(KERN_WARNING "cciss: cp %p returned " | 836 | dev_warn(&h->pdev->dev, |
841 | "unknown status %x\n", cp, | 837 | "%p returned unknown status %x\n", c, |
842 | ei->CommandStatus); | 838 | ei->CommandStatus); |
843 | } | 839 | } |
844 | } | 840 | } |
845 | // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel, | ||
846 | // cmd->target, cmd->lun); | ||
847 | cmd->scsi_done(cmd); | 841 | cmd->scsi_done(cmd); |
848 | scsi_cmd_free(ctlr, cp); | 842 | scsi_cmd_free(h, c); |
849 | } | 843 | } |
850 | 844 | ||
851 | static int | 845 | static int |
852 | cciss_scsi_detect(int ctlr) | 846 | cciss_scsi_detect(ctlr_info_t *h) |
853 | { | 847 | { |
854 | struct Scsi_Host *sh; | 848 | struct Scsi_Host *sh; |
855 | int error; | 849 | int error; |
@@ -860,15 +854,15 @@ cciss_scsi_detect(int ctlr) | |||
860 | sh->io_port = 0; // good enough? FIXME, | 854 | sh->io_port = 0; // good enough? FIXME, |
861 | sh->n_io_port = 0; // I don't think we use these two... | 855 | sh->n_io_port = 0; // I don't think we use these two... |
862 | sh->this_id = SELF_SCSI_ID; | 856 | sh->this_id = SELF_SCSI_ID; |
863 | sh->sg_tablesize = hba[ctlr]->maxsgentries; | 857 | sh->sg_tablesize = h->maxsgentries; |
864 | sh->max_cmd_len = MAX_COMMAND_SIZE; | 858 | sh->max_cmd_len = MAX_COMMAND_SIZE; |
865 | 859 | ||
866 | ((struct cciss_scsi_adapter_data_t *) | 860 | ((struct cciss_scsi_adapter_data_t *) |
867 | hba[ctlr]->scsi_ctlr)->scsi_host = sh; | 861 | h->scsi_ctlr)->scsi_host = sh; |
868 | sh->hostdata[0] = (unsigned long) hba[ctlr]; | 862 | sh->hostdata[0] = (unsigned long) h; |
869 | sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT]; | 863 | sh->irq = h->intr[SIMPLE_MODE_INT]; |
870 | sh->unique_id = sh->irq; | 864 | sh->unique_id = sh->irq; |
871 | error = scsi_add_host(sh, &hba[ctlr]->pdev->dev); | 865 | error = scsi_add_host(sh, &h->pdev->dev); |
872 | if (error) | 866 | if (error) |
873 | goto fail_host_put; | 867 | goto fail_host_put; |
874 | scsi_scan_host(sh); | 868 | scsi_scan_host(sh); |
@@ -882,20 +876,20 @@ cciss_scsi_detect(int ctlr) | |||
882 | 876 | ||
883 | static void | 877 | static void |
884 | cciss_unmap_one(struct pci_dev *pdev, | 878 | cciss_unmap_one(struct pci_dev *pdev, |
885 | CommandList_struct *cp, | 879 | CommandList_struct *c, |
886 | size_t buflen, | 880 | size_t buflen, |
887 | int data_direction) | 881 | int data_direction) |
888 | { | 882 | { |
889 | u64bit addr64; | 883 | u64bit addr64; |
890 | 884 | ||
891 | addr64.val32.lower = cp->SG[0].Addr.lower; | 885 | addr64.val32.lower = c->SG[0].Addr.lower; |
892 | addr64.val32.upper = cp->SG[0].Addr.upper; | 886 | addr64.val32.upper = c->SG[0].Addr.upper; |
893 | pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction); | 887 | pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction); |
894 | } | 888 | } |
895 | 889 | ||
896 | static void | 890 | static void |
897 | cciss_map_one(struct pci_dev *pdev, | 891 | cciss_map_one(struct pci_dev *pdev, |
898 | CommandList_struct *cp, | 892 | CommandList_struct *c, |
899 | unsigned char *buf, | 893 | unsigned char *buf, |
900 | size_t buflen, | 894 | size_t buflen, |
901 | int data_direction) | 895 | int data_direction) |
@@ -903,164 +897,149 @@ cciss_map_one(struct pci_dev *pdev, | |||
903 | __u64 addr64; | 897 | __u64 addr64; |
904 | 898 | ||
905 | addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction); | 899 | addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction); |
906 | cp->SG[0].Addr.lower = | 900 | c->SG[0].Addr.lower = |
907 | (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF); | 901 | (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF); |
908 | cp->SG[0].Addr.upper = | 902 | c->SG[0].Addr.upper = |
909 | (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF); | 903 | (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF); |
910 | cp->SG[0].Len = buflen; | 904 | c->SG[0].Len = buflen; |
911 | cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */ | 905 | c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */ |
912 | cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */ | 906 | c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */ |
913 | } | 907 | } |
914 | 908 | ||
915 | static int | 909 | static int |
916 | cciss_scsi_do_simple_cmd(ctlr_info_t *c, | 910 | cciss_scsi_do_simple_cmd(ctlr_info_t *h, |
917 | CommandList_struct *cp, | 911 | CommandList_struct *c, |
918 | unsigned char *scsi3addr, | 912 | unsigned char *scsi3addr, |
919 | unsigned char *cdb, | 913 | unsigned char *cdb, |
920 | unsigned char cdblen, | 914 | unsigned char cdblen, |
921 | unsigned char *buf, int bufsize, | 915 | unsigned char *buf, int bufsize, |
922 | int direction) | 916 | int direction) |
923 | { | 917 | { |
924 | unsigned long flags; | ||
925 | DECLARE_COMPLETION_ONSTACK(wait); | 918 | DECLARE_COMPLETION_ONSTACK(wait); |
926 | 919 | ||
927 | cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl | 920 | c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */ |
928 | cp->scsi_cmd = NULL; | 921 | c->scsi_cmd = NULL; |
929 | cp->Header.ReplyQueue = 0; // unused in simple mode | 922 | c->Header.ReplyQueue = 0; /* unused in simple mode */ |
930 | memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN)); | 923 | memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN)); |
931 | cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag | 924 | c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */ |
932 | // Fill in the request block... | 925 | // Fill in the request block... |
933 | 926 | ||
934 | /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", | 927 | /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", |
935 | scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3], | 928 | scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3], |
936 | scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */ | 929 | scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */ |
937 | 930 | ||
938 | memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB)); | 931 | memset(c->Request.CDB, 0, sizeof(c->Request.CDB)); |
939 | memcpy(cp->Request.CDB, cdb, cdblen); | 932 | memcpy(c->Request.CDB, cdb, cdblen); |
940 | cp->Request.Timeout = 0; | 933 | c->Request.Timeout = 0; |
941 | cp->Request.CDBLen = cdblen; | 934 | c->Request.CDBLen = cdblen; |
942 | cp->Request.Type.Type = TYPE_CMD; | 935 | c->Request.Type.Type = TYPE_CMD; |
943 | cp->Request.Type.Attribute = ATTR_SIMPLE; | 936 | c->Request.Type.Attribute = ATTR_SIMPLE; |
944 | cp->Request.Type.Direction = direction; | 937 | c->Request.Type.Direction = direction; |
945 | 938 | ||
946 | /* Fill in the SG list and do dma mapping */ | 939 | /* Fill in the SG list and do dma mapping */ |
947 | cciss_map_one(c->pdev, cp, (unsigned char *) buf, | 940 | cciss_map_one(h->pdev, c, (unsigned char *) buf, |
948 | bufsize, DMA_FROM_DEVICE); | 941 | bufsize, DMA_FROM_DEVICE); |
949 | 942 | ||
950 | cp->waiting = &wait; | 943 | c->waiting = &wait; |
951 | 944 | enqueue_cmd_and_start_io(h, c); | |
952 | /* Put the request on the tail of the request queue */ | ||
953 | spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); | ||
954 | addQ(&c->reqQ, cp); | ||
955 | c->Qdepth++; | ||
956 | start_io(c); | ||
957 | spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); | ||
958 | |||
959 | wait_for_completion(&wait); | 945 | wait_for_completion(&wait); |
960 | 946 | ||
961 | /* undo the dma mapping */ | 947 | /* undo the dma mapping */ |
962 | cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE); | 948 | cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE); |
963 | return(0); | 949 | return(0); |
964 | } | 950 | } |
965 | 951 | ||
966 | static void | 952 | static void |
967 | cciss_scsi_interpret_error(CommandList_struct *cp) | 953 | cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c) |
968 | { | 954 | { |
969 | ErrorInfo_struct *ei; | 955 | ErrorInfo_struct *ei; |
970 | 956 | ||
971 | ei = cp->err_info; | 957 | ei = c->err_info; |
972 | switch(ei->CommandStatus) | 958 | switch(ei->CommandStatus) |
973 | { | 959 | { |
974 | case CMD_TARGET_STATUS: | 960 | case CMD_TARGET_STATUS: |
975 | printk(KERN_WARNING "cciss: cmd %p has " | 961 | dev_warn(&h->pdev->dev, |
976 | "completed with errors\n", cp); | 962 | "cmd %p has completed with errors\n", c); |
977 | printk(KERN_WARNING "cciss: cmd %p " | 963 | dev_warn(&h->pdev->dev, |
978 | "has SCSI Status = %x\n", | 964 | "cmd %p has SCSI Status = %x\n", |
979 | cp, | 965 | c, ei->ScsiStatus); |
980 | ei->ScsiStatus); | ||
981 | if (ei->ScsiStatus == 0) | 966 | if (ei->ScsiStatus == 0) |
982 | printk(KERN_WARNING | 967 | dev_warn(&h->pdev->dev, |
983 | "cciss:SCSI status is abnormally zero. " | 968 | "SCSI status is abnormally zero. " |
984 | "(probably indicates selection timeout " | 969 | "(probably indicates selection timeout " |
985 | "reported incorrectly due to a known " | 970 | "reported incorrectly due to a known " |
986 | "firmware bug, circa July, 2001.)\n"); | 971 | "firmware bug, circa July, 2001.)\n"); |
987 | break; | 972 | break; |
988 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ | 973 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ |
989 | printk("UNDERRUN\n"); | 974 | dev_info(&h->pdev->dev, "UNDERRUN\n"); |
990 | break; | 975 | break; |
991 | case CMD_DATA_OVERRUN: | 976 | case CMD_DATA_OVERRUN: |
992 | printk(KERN_WARNING "cciss: cp %p has" | 977 | dev_warn(&h->pdev->dev, "%p has" |
993 | " completed with data overrun " | 978 | " completed with data overrun " |
994 | "reported\n", cp); | 979 | "reported\n", c); |
995 | break; | 980 | break; |
996 | case CMD_INVALID: { | 981 | case CMD_INVALID: { |
997 | /* controller unfortunately reports SCSI passthru's */ | 982 | /* controller unfortunately reports SCSI passthru's */ |
998 | /* to non-existent targets as invalid commands. */ | 983 | /* to non-existent targets as invalid commands. */ |
999 | printk(KERN_WARNING "cciss: cp %p is " | 984 | dev_warn(&h->pdev->dev, |
1000 | "reported invalid (probably means " | 985 | "%p is reported invalid (probably means " |
1001 | "target device no longer present)\n", | 986 | "target device no longer present)\n", c); |
1002 | cp); | 987 | /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0); |
1003 | /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0); | 988 | print_cmd(c); */ |
1004 | print_cmd(cp); */ | ||
1005 | } | 989 | } |
1006 | break; | 990 | break; |
1007 | case CMD_PROTOCOL_ERR: | 991 | case CMD_PROTOCOL_ERR: |
1008 | printk(KERN_WARNING "cciss: cp %p has " | 992 | dev_warn(&h->pdev->dev, "%p has protocol error\n", c); |
1009 | "protocol error \n", cp); | ||
1010 | break; | 993 | break; |
1011 | case CMD_HARDWARE_ERR: | 994 | case CMD_HARDWARE_ERR: |
1012 | /* cmd->result = DID_ERROR << 16; */ | 995 | /* cmd->result = DID_ERROR << 16; */ |
1013 | printk(KERN_WARNING "cciss: cp %p had " | 996 | dev_warn(&h->pdev->dev, "%p had hardware error\n", c); |
1014 | " hardware error\n", cp); | ||
1015 | break; | 997 | break; |
1016 | case CMD_CONNECTION_LOST: | 998 | case CMD_CONNECTION_LOST: |
1017 | printk(KERN_WARNING "cciss: cp %p had " | 999 | dev_warn(&h->pdev->dev, "%p had connection lost\n", c); |
1018 | "connection lost\n", cp); | ||
1019 | break; | 1000 | break; |
1020 | case CMD_ABORTED: | 1001 | case CMD_ABORTED: |
1021 | printk(KERN_WARNING "cciss: cp %p was " | 1002 | dev_warn(&h->pdev->dev, "%p was aborted\n", c); |
1022 | "aborted\n", cp); | ||
1023 | break; | 1003 | break; |
1024 | case CMD_ABORT_FAILED: | 1004 | case CMD_ABORT_FAILED: |
1025 | printk(KERN_WARNING "cciss: cp %p reports " | 1005 | dev_warn(&h->pdev->dev, |
1026 | "abort failed\n", cp); | 1006 | "%p reports abort failed\n", c); |
1027 | break; | 1007 | break; |
1028 | case CMD_UNSOLICITED_ABORT: | 1008 | case CMD_UNSOLICITED_ABORT: |
1029 | printk(KERN_WARNING "cciss: cp %p aborted " | 1009 | dev_warn(&h->pdev->dev, |
1030 | "do to an unsolicited abort\n", cp); | 1010 | "%p aborted do to an unsolicited abort\n", c); |
1031 | break; | 1011 | break; |
1032 | case CMD_TIMEOUT: | 1012 | case CMD_TIMEOUT: |
1033 | printk(KERN_WARNING "cciss: cp %p timedout\n", | 1013 | dev_warn(&h->pdev->dev, "%p timedout\n", c); |
1034 | cp); | ||
1035 | break; | 1014 | break; |
1036 | default: | 1015 | default: |
1037 | printk(KERN_WARNING "cciss: cp %p returned " | 1016 | dev_warn(&h->pdev->dev, |
1038 | "unknown status %x\n", cp, | 1017 | "%p returned unknown status %x\n", |
1039 | ei->CommandStatus); | 1018 | c, ei->CommandStatus); |
1040 | } | 1019 | } |
1041 | } | 1020 | } |
1042 | 1021 | ||
1043 | static int | 1022 | static int |
1044 | cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr, | 1023 | cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr, |
1045 | unsigned char page, unsigned char *buf, | 1024 | unsigned char page, unsigned char *buf, |
1046 | unsigned char bufsize) | 1025 | unsigned char bufsize) |
1047 | { | 1026 | { |
1048 | int rc; | 1027 | int rc; |
1049 | CommandList_struct *cp; | 1028 | CommandList_struct *c; |
1050 | char cdb[6]; | 1029 | char cdb[6]; |
1051 | ErrorInfo_struct *ei; | 1030 | ErrorInfo_struct *ei; |
1052 | unsigned long flags; | 1031 | unsigned long flags; |
1053 | 1032 | ||
1054 | spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); | 1033 | spin_lock_irqsave(&h->lock, flags); |
1055 | cp = scsi_cmd_alloc(c); | 1034 | c = scsi_cmd_alloc(h); |
1056 | spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); | 1035 | spin_unlock_irqrestore(&h->lock, flags); |
1057 | 1036 | ||
1058 | if (cp == NULL) { /* trouble... */ | 1037 | if (c == NULL) { /* trouble... */ |
1059 | printk("cmd_alloc returned NULL!\n"); | 1038 | printk("cmd_alloc returned NULL!\n"); |
1060 | return -1; | 1039 | return -1; |
1061 | } | 1040 | } |
1062 | 1041 | ||
1063 | ei = cp->err_info; | 1042 | ei = c->err_info; |
1064 | 1043 | ||
1065 | cdb[0] = CISS_INQUIRY; | 1044 | cdb[0] = CISS_INQUIRY; |
1066 | cdb[1] = (page != 0); | 1045 | cdb[1] = (page != 0); |
@@ -1068,24 +1047,24 @@ cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr, | |||
1068 | cdb[3] = 0; | 1047 | cdb[3] = 0; |
1069 | cdb[4] = bufsize; | 1048 | cdb[4] = bufsize; |
1070 | cdb[5] = 0; | 1049 | cdb[5] = 0; |
1071 | rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb, | 1050 | rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb, |
1072 | 6, buf, bufsize, XFER_READ); | 1051 | 6, buf, bufsize, XFER_READ); |
1073 | 1052 | ||
1074 | if (rc != 0) return rc; /* something went wrong */ | 1053 | if (rc != 0) return rc; /* something went wrong */ |
1075 | 1054 | ||
1076 | if (ei->CommandStatus != 0 && | 1055 | if (ei->CommandStatus != 0 && |
1077 | ei->CommandStatus != CMD_DATA_UNDERRUN) { | 1056 | ei->CommandStatus != CMD_DATA_UNDERRUN) { |
1078 | cciss_scsi_interpret_error(cp); | 1057 | cciss_scsi_interpret_error(h, c); |
1079 | rc = -1; | 1058 | rc = -1; |
1080 | } | 1059 | } |
1081 | spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); | 1060 | spin_lock_irqsave(&h->lock, flags); |
1082 | scsi_cmd_free(c, cp); | 1061 | scsi_cmd_free(h, c); |
1083 | spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); | 1062 | spin_unlock_irqrestore(&h->lock, flags); |
1084 | return rc; | 1063 | return rc; |
1085 | } | 1064 | } |
1086 | 1065 | ||
1087 | /* Get the device id from inquiry page 0x83 */ | 1066 | /* Get the device id from inquiry page 0x83 */ |
1088 | static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr, | 1067 | static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr, |
1089 | unsigned char *device_id, int buflen) | 1068 | unsigned char *device_id, int buflen) |
1090 | { | 1069 | { |
1091 | int rc; | 1070 | int rc; |
@@ -1096,7 +1075,7 @@ static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr, | |||
1096 | buf = kzalloc(64, GFP_KERNEL); | 1075 | buf = kzalloc(64, GFP_KERNEL); |
1097 | if (!buf) | 1076 | if (!buf) |
1098 | return -1; | 1077 | return -1; |
1099 | rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64); | 1078 | rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64); |
1100 | if (rc == 0) | 1079 | if (rc == 0) |
1101 | memcpy(device_id, &buf[8], buflen); | 1080 | memcpy(device_id, &buf[8], buflen); |
1102 | kfree(buf); | 1081 | kfree(buf); |
@@ -1104,20 +1083,20 @@ static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr, | |||
1104 | } | 1083 | } |
1105 | 1084 | ||
1106 | static int | 1085 | static int |
1107 | cciss_scsi_do_report_phys_luns(ctlr_info_t *c, | 1086 | cciss_scsi_do_report_phys_luns(ctlr_info_t *h, |
1108 | ReportLunData_struct *buf, int bufsize) | 1087 | ReportLunData_struct *buf, int bufsize) |
1109 | { | 1088 | { |
1110 | int rc; | 1089 | int rc; |
1111 | CommandList_struct *cp; | 1090 | CommandList_struct *c; |
1112 | unsigned char cdb[12]; | 1091 | unsigned char cdb[12]; |
1113 | unsigned char scsi3addr[8]; | 1092 | unsigned char scsi3addr[8]; |
1114 | ErrorInfo_struct *ei; | 1093 | ErrorInfo_struct *ei; |
1115 | unsigned long flags; | 1094 | unsigned long flags; |
1116 | 1095 | ||
1117 | spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); | 1096 | spin_lock_irqsave(&h->lock, flags); |
1118 | cp = scsi_cmd_alloc(c); | 1097 | c = scsi_cmd_alloc(h); |
1119 | spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); | 1098 | spin_unlock_irqrestore(&h->lock, flags); |
1120 | if (cp == NULL) { /* trouble... */ | 1099 | if (c == NULL) { /* trouble... */ |
1121 | printk("cmd_alloc returned NULL!\n"); | 1100 | printk("cmd_alloc returned NULL!\n"); |
1122 | return -1; | 1101 | return -1; |
1123 | } | 1102 | } |
@@ -1136,27 +1115,27 @@ cciss_scsi_do_report_phys_luns(ctlr_info_t *c, | |||
1136 | cdb[10] = 0; | 1115 | cdb[10] = 0; |
1137 | cdb[11] = 0; | 1116 | cdb[11] = 0; |
1138 | 1117 | ||
1139 | rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, | 1118 | rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, |
1140 | cdb, 12, | 1119 | cdb, 12, |
1141 | (unsigned char *) buf, | 1120 | (unsigned char *) buf, |
1142 | bufsize, XFER_READ); | 1121 | bufsize, XFER_READ); |
1143 | 1122 | ||
1144 | if (rc != 0) return rc; /* something went wrong */ | 1123 | if (rc != 0) return rc; /* something went wrong */ |
1145 | 1124 | ||
1146 | ei = cp->err_info; | 1125 | ei = c->err_info; |
1147 | if (ei->CommandStatus != 0 && | 1126 | if (ei->CommandStatus != 0 && |
1148 | ei->CommandStatus != CMD_DATA_UNDERRUN) { | 1127 | ei->CommandStatus != CMD_DATA_UNDERRUN) { |
1149 | cciss_scsi_interpret_error(cp); | 1128 | cciss_scsi_interpret_error(h, c); |
1150 | rc = -1; | 1129 | rc = -1; |
1151 | } | 1130 | } |
1152 | spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); | 1131 | spin_lock_irqsave(&h->lock, flags); |
1153 | scsi_cmd_free(c, cp); | 1132 | scsi_cmd_free(h, c); |
1154 | spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); | 1133 | spin_unlock_irqrestore(&h->lock, flags); |
1155 | return rc; | 1134 | return rc; |
1156 | } | 1135 | } |
1157 | 1136 | ||
1158 | static void | 1137 | static void |
1159 | cciss_update_non_disk_devices(int cntl_num, int hostno) | 1138 | cciss_update_non_disk_devices(ctlr_info_t *h, int hostno) |
1160 | { | 1139 | { |
1161 | /* the idea here is we could get notified from /proc | 1140 | /* the idea here is we could get notified from /proc |
1162 | that some devices have changed, so we do a report | 1141 | that some devices have changed, so we do a report |
@@ -1189,7 +1168,6 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1189 | ReportLunData_struct *ld_buff; | 1168 | ReportLunData_struct *ld_buff; |
1190 | unsigned char *inq_buff; | 1169 | unsigned char *inq_buff; |
1191 | unsigned char scsi3addr[8]; | 1170 | unsigned char scsi3addr[8]; |
1192 | ctlr_info_t *c; | ||
1193 | __u32 num_luns=0; | 1171 | __u32 num_luns=0; |
1194 | unsigned char *ch; | 1172 | unsigned char *ch; |
1195 | struct cciss_scsi_dev_t *currentsd, *this_device; | 1173 | struct cciss_scsi_dev_t *currentsd, *this_device; |
@@ -1197,7 +1175,6 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1197 | int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8; | 1175 | int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8; |
1198 | int i; | 1176 | int i; |
1199 | 1177 | ||
1200 | c = (ctlr_info_t *) hba[cntl_num]; | ||
1201 | ld_buff = kzalloc(reportlunsize, GFP_KERNEL); | 1178 | ld_buff = kzalloc(reportlunsize, GFP_KERNEL); |
1202 | inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL); | 1179 | inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL); |
1203 | currentsd = kzalloc(sizeof(*currentsd) * | 1180 | currentsd = kzalloc(sizeof(*currentsd) * |
@@ -1207,7 +1184,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1207 | goto out; | 1184 | goto out; |
1208 | } | 1185 | } |
1209 | this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA]; | 1186 | this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA]; |
1210 | if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) { | 1187 | if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) { |
1211 | ch = &ld_buff->LUNListLength[0]; | 1188 | ch = &ld_buff->LUNListLength[0]; |
1212 | num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8; | 1189 | num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8; |
1213 | if (num_luns > CISS_MAX_PHYS_LUN) { | 1190 | if (num_luns > CISS_MAX_PHYS_LUN) { |
@@ -1231,7 +1208,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1231 | memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE); | 1208 | memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE); |
1232 | memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8); | 1209 | memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8); |
1233 | 1210 | ||
1234 | if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff, | 1211 | if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff, |
1235 | (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) | 1212 | (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) |
1236 | /* Inquiry failed (msg printed already) */ | 1213 | /* Inquiry failed (msg printed already) */ |
1237 | continue; /* so we will skip this device. */ | 1214 | continue; /* so we will skip this device. */ |
@@ -1249,7 +1226,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1249 | sizeof(this_device->revision)); | 1226 | sizeof(this_device->revision)); |
1250 | memset(this_device->device_id, 0, | 1227 | memset(this_device->device_id, 0, |
1251 | sizeof(this_device->device_id)); | 1228 | sizeof(this_device->device_id)); |
1252 | cciss_scsi_get_device_id(hba[cntl_num], scsi3addr, | 1229 | cciss_scsi_get_device_id(h, scsi3addr, |
1253 | this_device->device_id, sizeof(this_device->device_id)); | 1230 | this_device->device_id, sizeof(this_device->device_id)); |
1254 | 1231 | ||
1255 | switch (this_device->devtype) | 1232 | switch (this_device->devtype) |
@@ -1276,7 +1253,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1276 | case 0x08: /* medium changer */ | 1253 | case 0x08: /* medium changer */ |
1277 | if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) { | 1254 | if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) { |
1278 | printk(KERN_INFO "cciss%d: %s ignored, " | 1255 | printk(KERN_INFO "cciss%d: %s ignored, " |
1279 | "too many devices.\n", cntl_num, | 1256 | "too many devices.\n", h->ctlr, |
1280 | scsi_device_type(this_device->devtype)); | 1257 | scsi_device_type(this_device->devtype)); |
1281 | break; | 1258 | break; |
1282 | } | 1259 | } |
@@ -1288,7 +1265,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno) | |||
1288 | } | 1265 | } |
1289 | } | 1266 | } |
1290 | 1267 | ||
1291 | adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent); | 1268 | adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent); |
1292 | out: | 1269 | out: |
1293 | kfree(inq_buff); | 1270 | kfree(inq_buff); |
1294 | kfree(ld_buff); | 1271 | kfree(ld_buff); |
@@ -1307,12 +1284,12 @@ is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c | |||
1307 | } | 1284 | } |
1308 | 1285 | ||
1309 | static int | 1286 | static int |
1310 | cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length) | 1287 | cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length) |
1311 | { | 1288 | { |
1312 | int arg_len; | 1289 | int arg_len; |
1313 | 1290 | ||
1314 | if ((arg_len = is_keyword(buffer, length, "rescan")) != 0) | 1291 | if ((arg_len = is_keyword(buffer, length, "rescan")) != 0) |
1315 | cciss_update_non_disk_devices(ctlr, hostno); | 1292 | cciss_update_non_disk_devices(h, hostno); |
1316 | else | 1293 | else |
1317 | return -EINVAL; | 1294 | return -EINVAL; |
1318 | return length; | 1295 | return length; |
@@ -1329,20 +1306,16 @@ cciss_scsi_proc_info(struct Scsi_Host *sh, | |||
1329 | { | 1306 | { |
1330 | 1307 | ||
1331 | int buflen, datalen; | 1308 | int buflen, datalen; |
1332 | ctlr_info_t *ci; | 1309 | ctlr_info_t *h; |
1333 | int i; | 1310 | int i; |
1334 | int cntl_num; | ||
1335 | |||
1336 | 1311 | ||
1337 | ci = (ctlr_info_t *) sh->hostdata[0]; | 1312 | h = (ctlr_info_t *) sh->hostdata[0]; |
1338 | if (ci == NULL) /* This really shouldn't ever happen. */ | 1313 | if (h == NULL) /* This really shouldn't ever happen. */ |
1339 | return -EINVAL; | 1314 | return -EINVAL; |
1340 | 1315 | ||
1341 | cntl_num = ci->ctlr; /* Get our index into the hba[] array */ | ||
1342 | |||
1343 | if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */ | 1316 | if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */ |
1344 | buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n", | 1317 | buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n", |
1345 | cntl_num, sh->host_no); | 1318 | h->ctlr, sh->host_no); |
1346 | 1319 | ||
1347 | /* this information is needed by apps to know which cciss | 1320 | /* this information is needed by apps to know which cciss |
1348 | device corresponds to which scsi host number without | 1321 | device corresponds to which scsi host number without |
@@ -1352,8 +1325,9 @@ cciss_scsi_proc_info(struct Scsi_Host *sh, | |||
1352 | this info is for an app to be able to use to know how to | 1325 | this info is for an app to be able to use to know how to |
1353 | get them back in sync. */ | 1326 | get them back in sync. */ |
1354 | 1327 | ||
1355 | for (i=0;i<ccissscsi[cntl_num].ndevices;i++) { | 1328 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
1356 | struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i]; | 1329 | struct cciss_scsi_dev_t *sd = |
1330 | &ccissscsi[h->ctlr].dev[i]; | ||
1357 | buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d " | 1331 | buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d " |
1358 | "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", | 1332 | "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
1359 | sh->host_no, sd->bus, sd->target, sd->lun, | 1333 | sh->host_no, sd->bus, sd->target, sd->lun, |
@@ -1371,15 +1345,15 @@ cciss_scsi_proc_info(struct Scsi_Host *sh, | |||
1371 | *start = buffer + offset; | 1345 | *start = buffer + offset; |
1372 | return(datalen); | 1346 | return(datalen); |
1373 | } else /* User is writing to /proc/scsi/cciss*?/?* ... */ | 1347 | } else /* User is writing to /proc/scsi/cciss*?/?* ... */ |
1374 | return cciss_scsi_user_command(cntl_num, sh->host_no, | 1348 | return cciss_scsi_user_command(h, sh->host_no, |
1375 | buffer, length); | 1349 | buffer, length); |
1376 | } | 1350 | } |
1377 | 1351 | ||
1378 | /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci | 1352 | /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci |
1379 | dma mapping and fills in the scatter gather entries of the | 1353 | dma mapping and fills in the scatter gather entries of the |
1380 | cciss command, cp. */ | 1354 | cciss command, c. */ |
1381 | 1355 | ||
1382 | static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, | 1356 | static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c, |
1383 | struct scsi_cmnd *cmd) | 1357 | struct scsi_cmnd *cmd) |
1384 | { | 1358 | { |
1385 | unsigned int len; | 1359 | unsigned int len; |
@@ -1393,7 +1367,7 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, | |||
1393 | 1367 | ||
1394 | chained = 0; | 1368 | chained = 0; |
1395 | sg_index = 0; | 1369 | sg_index = 0; |
1396 | curr_sg = cp->SG; | 1370 | curr_sg = c->SG; |
1397 | request_nsgs = scsi_dma_map(cmd); | 1371 | request_nsgs = scsi_dma_map(cmd); |
1398 | if (request_nsgs) { | 1372 | if (request_nsgs) { |
1399 | scsi_for_each_sg(cmd, sg, request_nsgs, i) { | 1373 | scsi_for_each_sg(cmd, sg, request_nsgs, i) { |
@@ -1401,7 +1375,7 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, | |||
1401 | !chained && request_nsgs - i > 1) { | 1375 | !chained && request_nsgs - i > 1) { |
1402 | chained = 1; | 1376 | chained = 1; |
1403 | sg_index = 0; | 1377 | sg_index = 0; |
1404 | curr_sg = sa->cmd_sg_list[cp->cmdindex]; | 1378 | curr_sg = sa->cmd_sg_list[c->cmdindex]; |
1405 | } | 1379 | } |
1406 | addr64 = (__u64) sg_dma_address(sg); | 1380 | addr64 = (__u64) sg_dma_address(sg); |
1407 | len = sg_dma_len(sg); | 1381 | len = sg_dma_len(sg); |
@@ -1414,19 +1388,19 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, | |||
1414 | ++sg_index; | 1388 | ++sg_index; |
1415 | } | 1389 | } |
1416 | if (chained) | 1390 | if (chained) |
1417 | cciss_map_sg_chain_block(h, cp, | 1391 | cciss_map_sg_chain_block(h, c, |
1418 | sa->cmd_sg_list[cp->cmdindex], | 1392 | sa->cmd_sg_list[c->cmdindex], |
1419 | (request_nsgs - (h->max_cmd_sgentries - 1)) * | 1393 | (request_nsgs - (h->max_cmd_sgentries - 1)) * |
1420 | sizeof(SGDescriptor_struct)); | 1394 | sizeof(SGDescriptor_struct)); |
1421 | } | 1395 | } |
1422 | /* track how many SG entries we are using */ | 1396 | /* track how many SG entries we are using */ |
1423 | if (request_nsgs > h->maxSG) | 1397 | if (request_nsgs > h->maxSG) |
1424 | h->maxSG = request_nsgs; | 1398 | h->maxSG = request_nsgs; |
1425 | cp->Header.SGTotal = (__u8) request_nsgs + chained; | 1399 | c->Header.SGTotal = (__u8) request_nsgs + chained; |
1426 | if (request_nsgs > h->max_cmd_sgentries) | 1400 | if (request_nsgs > h->max_cmd_sgentries) |
1427 | cp->Header.SGList = h->max_cmd_sgentries; | 1401 | c->Header.SGList = h->max_cmd_sgentries; |
1428 | else | 1402 | else |
1429 | cp->Header.SGList = cp->Header.SGTotal; | 1403 | c->Header.SGList = c->Header.SGTotal; |
1430 | return; | 1404 | return; |
1431 | } | 1405 | } |
1432 | 1406 | ||
@@ -1434,18 +1408,17 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, | |||
1434 | static int | 1408 | static int |
1435 | cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *)) | 1409 | cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *)) |
1436 | { | 1410 | { |
1437 | ctlr_info_t *c; | 1411 | ctlr_info_t *h; |
1438 | int ctlr, rc; | 1412 | int rc; |
1439 | unsigned char scsi3addr[8]; | 1413 | unsigned char scsi3addr[8]; |
1440 | CommandList_struct *cp; | 1414 | CommandList_struct *c; |
1441 | unsigned long flags; | 1415 | unsigned long flags; |
1442 | 1416 | ||
1443 | // Get the ptr to our adapter structure (hba[i]) out of cmd->host. | 1417 | // Get the ptr to our adapter structure (hba[i]) out of cmd->host. |
1444 | // We violate cmd->host privacy here. (Is there another way?) | 1418 | // We violate cmd->host privacy here. (Is there another way?) |
1445 | c = (ctlr_info_t *) cmd->device->host->hostdata[0]; | 1419 | h = (ctlr_info_t *) cmd->device->host->hostdata[0]; |
1446 | ctlr = c->ctlr; | ||
1447 | 1420 | ||
1448 | rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, | 1421 | rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id, |
1449 | cmd->device->lun, scsi3addr); | 1422 | cmd->device->lun, scsi3addr); |
1450 | if (rc != 0) { | 1423 | if (rc != 0) { |
1451 | /* the scsi nexus does not match any that we presented... */ | 1424 | /* the scsi nexus does not match any that we presented... */ |
@@ -1457,19 +1430,14 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd | |||
1457 | return 0; | 1430 | return 0; |
1458 | } | 1431 | } |
1459 | 1432 | ||
1460 | /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n", | ||
1461 | cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/ | ||
1462 | // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel, | ||
1463 | // cmd->target, cmd->lun); | ||
1464 | |||
1465 | /* Ok, we have a reasonable scsi nexus, so send the cmd down, and | 1433 | /* Ok, we have a reasonable scsi nexus, so send the cmd down, and |
1466 | see what the device thinks of it. */ | 1434 | see what the device thinks of it. */ |
1467 | 1435 | ||
1468 | spin_lock_irqsave(CCISS_LOCK(ctlr), flags); | 1436 | spin_lock_irqsave(&h->lock, flags); |
1469 | cp = scsi_cmd_alloc(c); | 1437 | c = scsi_cmd_alloc(h); |
1470 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | 1438 | spin_unlock_irqrestore(&h->lock, flags); |
1471 | if (cp == NULL) { /* trouble... */ | 1439 | if (c == NULL) { /* trouble... */ |
1472 | printk("scsi_cmd_alloc returned NULL!\n"); | 1440 | dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n"); |
1473 | /* FIXME: next 3 lines are -> BAD! <- */ | 1441 | /* FIXME: next 3 lines are -> BAD! <- */ |
1474 | cmd->result = DID_NO_CONNECT << 16; | 1442 | cmd->result = DID_NO_CONNECT << 16; |
1475 | done(cmd); | 1443 | done(cmd); |
@@ -1480,35 +1448,41 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd | |||
1480 | 1448 | ||
1481 | cmd->scsi_done = done; // save this for use by completion code | 1449 | cmd->scsi_done = done; // save this for use by completion code |
1482 | 1450 | ||
1483 | // save cp in case we have to abort it | 1451 | /* save c in case we have to abort it */ |
1484 | cmd->host_scribble = (unsigned char *) cp; | 1452 | cmd->host_scribble = (unsigned char *) c; |
1485 | 1453 | ||
1486 | cp->cmd_type = CMD_SCSI; | 1454 | c->cmd_type = CMD_SCSI; |
1487 | cp->scsi_cmd = cmd; | 1455 | c->scsi_cmd = cmd; |
1488 | cp->Header.ReplyQueue = 0; // unused in simple mode | 1456 | c->Header.ReplyQueue = 0; /* unused in simple mode */ |
1489 | memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8); | 1457 | memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8); |
1490 | cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag | 1458 | c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */ |
1491 | 1459 | ||
1492 | // Fill in the request block... | 1460 | // Fill in the request block... |
1493 | 1461 | ||
1494 | cp->Request.Timeout = 0; | 1462 | c->Request.Timeout = 0; |
1495 | memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB)); | 1463 | memset(c->Request.CDB, 0, sizeof(c->Request.CDB)); |
1496 | BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB)); | 1464 | BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB)); |
1497 | cp->Request.CDBLen = cmd->cmd_len; | 1465 | c->Request.CDBLen = cmd->cmd_len; |
1498 | memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len); | 1466 | memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len); |
1499 | cp->Request.Type.Type = TYPE_CMD; | 1467 | c->Request.Type.Type = TYPE_CMD; |
1500 | cp->Request.Type.Attribute = ATTR_SIMPLE; | 1468 | c->Request.Type.Attribute = ATTR_SIMPLE; |
1501 | switch(cmd->sc_data_direction) | 1469 | switch(cmd->sc_data_direction) |
1502 | { | 1470 | { |
1503 | case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break; | 1471 | case DMA_TO_DEVICE: |
1504 | case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break; | 1472 | c->Request.Type.Direction = XFER_WRITE; |
1505 | case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break; | 1473 | break; |
1474 | case DMA_FROM_DEVICE: | ||
1475 | c->Request.Type.Direction = XFER_READ; | ||
1476 | break; | ||
1477 | case DMA_NONE: | ||
1478 | c->Request.Type.Direction = XFER_NONE; | ||
1479 | break; | ||
1506 | case DMA_BIDIRECTIONAL: | 1480 | case DMA_BIDIRECTIONAL: |
1507 | // This can happen if a buggy application does a scsi passthru | 1481 | // This can happen if a buggy application does a scsi passthru |
1508 | // and sets both inlen and outlen to non-zero. ( see | 1482 | // and sets both inlen and outlen to non-zero. ( see |
1509 | // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() ) | 1483 | // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() ) |
1510 | 1484 | ||
1511 | cp->Request.Type.Direction = XFER_RSVD; | 1485 | c->Request.Type.Direction = XFER_RSVD; |
1512 | // This is technically wrong, and cciss controllers should | 1486 | // This is technically wrong, and cciss controllers should |
1513 | // reject it with CMD_INVALID, which is the most correct | 1487 | // reject it with CMD_INVALID, which is the most correct |
1514 | // response, but non-fibre backends appear to let it | 1488 | // response, but non-fibre backends appear to let it |
@@ -1519,27 +1493,18 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd | |||
1519 | break; | 1493 | break; |
1520 | 1494 | ||
1521 | default: | 1495 | default: |
1522 | printk("cciss: unknown data direction: %d\n", | 1496 | dev_warn(&h->pdev->dev, "unknown data direction: %d\n", |
1523 | cmd->sc_data_direction); | 1497 | cmd->sc_data_direction); |
1524 | BUG(); | 1498 | BUG(); |
1525 | break; | 1499 | break; |
1526 | } | 1500 | } |
1527 | cciss_scatter_gather(c, cp, cmd); | 1501 | cciss_scatter_gather(h, c, cmd); |
1528 | 1502 | enqueue_cmd_and_start_io(h, c); | |
1529 | /* Put the request on the tail of the request queue */ | ||
1530 | |||
1531 | spin_lock_irqsave(CCISS_LOCK(ctlr), flags); | ||
1532 | addQ(&c->reqQ, cp); | ||
1533 | c->Qdepth++; | ||
1534 | start_io(c); | ||
1535 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | ||
1536 | |||
1537 | /* the cmd'll come back via intr handler in complete_scsi_command() */ | 1503 | /* the cmd'll come back via intr handler in complete_scsi_command() */ |
1538 | return 0; | 1504 | return 0; |
1539 | } | 1505 | } |
1540 | 1506 | ||
1541 | static void | 1507 | static void cciss_unregister_scsi(ctlr_info_t *h) |
1542 | cciss_unregister_scsi(int ctlr) | ||
1543 | { | 1508 | { |
1544 | struct cciss_scsi_adapter_data_t *sa; | 1509 | struct cciss_scsi_adapter_data_t *sa; |
1545 | struct cciss_scsi_cmd_stack_t *stk; | 1510 | struct cciss_scsi_cmd_stack_t *stk; |
@@ -1547,59 +1512,58 @@ cciss_unregister_scsi(int ctlr) | |||
1547 | 1512 | ||
1548 | /* we are being forcibly unloaded, and may not refuse. */ | 1513 | /* we are being forcibly unloaded, and may not refuse. */ |
1549 | 1514 | ||
1550 | spin_lock_irqsave(CCISS_LOCK(ctlr), flags); | 1515 | spin_lock_irqsave(&h->lock, flags); |
1551 | sa = hba[ctlr]->scsi_ctlr; | 1516 | sa = h->scsi_ctlr; |
1552 | stk = &sa->cmd_stack; | 1517 | stk = &sa->cmd_stack; |
1553 | 1518 | ||
1554 | /* if we weren't ever actually registered, don't unregister */ | 1519 | /* if we weren't ever actually registered, don't unregister */ |
1555 | if (sa->registered) { | 1520 | if (sa->registered) { |
1556 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | 1521 | spin_unlock_irqrestore(&h->lock, flags); |
1557 | scsi_remove_host(sa->scsi_host); | 1522 | scsi_remove_host(sa->scsi_host); |
1558 | scsi_host_put(sa->scsi_host); | 1523 | scsi_host_put(sa->scsi_host); |
1559 | spin_lock_irqsave(CCISS_LOCK(ctlr), flags); | 1524 | spin_lock_irqsave(&h->lock, flags); |
1560 | } | 1525 | } |
1561 | 1526 | ||
1562 | /* set scsi_host to NULL so our detect routine will | 1527 | /* set scsi_host to NULL so our detect routine will |
1563 | find us on register */ | 1528 | find us on register */ |
1564 | sa->scsi_host = NULL; | 1529 | sa->scsi_host = NULL; |
1565 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | 1530 | spin_unlock_irqrestore(&h->lock, flags); |
1566 | scsi_cmd_stack_free(ctlr); | 1531 | scsi_cmd_stack_free(h); |
1567 | kfree(sa); | 1532 | kfree(sa); |
1568 | } | 1533 | } |
1569 | 1534 | ||
1570 | static int | 1535 | static int cciss_engage_scsi(ctlr_info_t *h) |
1571 | cciss_engage_scsi(int ctlr) | ||
1572 | { | 1536 | { |
1573 | struct cciss_scsi_adapter_data_t *sa; | 1537 | struct cciss_scsi_adapter_data_t *sa; |
1574 | struct cciss_scsi_cmd_stack_t *stk; | 1538 | struct cciss_scsi_cmd_stack_t *stk; |
1575 | unsigned long flags; | 1539 | unsigned long flags; |
1576 | 1540 | ||
1577 | spin_lock_irqsave(CCISS_LOCK(ctlr), flags); | 1541 | spin_lock_irqsave(&h->lock, flags); |
1578 | sa = hba[ctlr]->scsi_ctlr; | 1542 | sa = h->scsi_ctlr; |
1579 | stk = &sa->cmd_stack; | 1543 | stk = &sa->cmd_stack; |
1580 | 1544 | ||
1581 | if (sa->registered) { | 1545 | if (sa->registered) { |
1582 | printk("cciss%d: SCSI subsystem already engaged.\n", ctlr); | 1546 | dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n"); |
1583 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | 1547 | spin_unlock_irqrestore(&h->lock, flags); |
1584 | return -ENXIO; | 1548 | return -ENXIO; |
1585 | } | 1549 | } |
1586 | sa->registered = 1; | 1550 | sa->registered = 1; |
1587 | spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); | 1551 | spin_unlock_irqrestore(&h->lock, flags); |
1588 | cciss_update_non_disk_devices(ctlr, -1); | 1552 | cciss_update_non_disk_devices(h, -1); |
1589 | cciss_scsi_detect(ctlr); | 1553 | cciss_scsi_detect(h); |
1590 | return 0; | 1554 | return 0; |
1591 | } | 1555 | } |
1592 | 1556 | ||
1593 | static void | 1557 | static void |
1594 | cciss_seq_tape_report(struct seq_file *seq, int ctlr) | 1558 | cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h) |
1595 | { | 1559 | { |
1596 | unsigned long flags; | 1560 | unsigned long flags; |
1597 | 1561 | ||
1598 | CPQ_TAPE_LOCK(ctlr, flags); | 1562 | CPQ_TAPE_LOCK(h, flags); |
1599 | seq_printf(seq, | 1563 | seq_printf(seq, |
1600 | "Sequential access devices: %d\n\n", | 1564 | "Sequential access devices: %d\n\n", |
1601 | ccissscsi[ctlr].ndevices); | 1565 | ccissscsi[h->ctlr].ndevices); |
1602 | CPQ_TAPE_UNLOCK(ctlr, flags); | 1566 | CPQ_TAPE_UNLOCK(h, flags); |
1603 | } | 1567 | } |
1604 | 1568 | ||
1605 | static int wait_for_device_to_become_ready(ctlr_info_t *h, | 1569 | static int wait_for_device_to_become_ready(ctlr_info_t *h, |
@@ -1610,10 +1574,10 @@ static int wait_for_device_to_become_ready(ctlr_info_t *h, | |||
1610 | int waittime = HZ; | 1574 | int waittime = HZ; |
1611 | CommandList_struct *c; | 1575 | CommandList_struct *c; |
1612 | 1576 | ||
1613 | c = cmd_alloc(h, 1); | 1577 | c = cmd_alloc(h); |
1614 | if (!c) { | 1578 | if (!c) { |
1615 | printk(KERN_WARNING "cciss%d: out of memory in " | 1579 | dev_warn(&h->pdev->dev, "out of memory in " |
1616 | "wait_for_device_to_become_ready.\n", h->ctlr); | 1580 | "wait_for_device_to_become_ready.\n"); |
1617 | return IO_ERROR; | 1581 | return IO_ERROR; |
1618 | } | 1582 | } |
1619 | 1583 | ||
@@ -1631,7 +1595,7 @@ static int wait_for_device_to_become_ready(ctlr_info_t *h, | |||
1631 | waittime = waittime * 2; | 1595 | waittime = waittime * 2; |
1632 | 1596 | ||
1633 | /* Send the Test Unit Ready */ | 1597 | /* Send the Test Unit Ready */ |
1634 | rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0, | 1598 | rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0, |
1635 | lunaddr, TYPE_CMD); | 1599 | lunaddr, TYPE_CMD); |
1636 | if (rc == 0) | 1600 | if (rc == 0) |
1637 | rc = sendcmd_withirq_core(h, c, 0); | 1601 | rc = sendcmd_withirq_core(h, c, 0); |
@@ -1657,18 +1621,18 @@ static int wait_for_device_to_become_ready(ctlr_info_t *h, | |||
1657 | } | 1621 | } |
1658 | } | 1622 | } |
1659 | retry_tur: | 1623 | retry_tur: |
1660 | printk(KERN_WARNING "cciss%d: Waiting %d secs " | 1624 | dev_warn(&h->pdev->dev, "Waiting %d secs " |
1661 | "for device to become ready.\n", | 1625 | "for device to become ready.\n", |
1662 | h->ctlr, waittime / HZ); | 1626 | waittime / HZ); |
1663 | rc = 1; /* device not ready. */ | 1627 | rc = 1; /* device not ready. */ |
1664 | } | 1628 | } |
1665 | 1629 | ||
1666 | if (rc) | 1630 | if (rc) |
1667 | printk("cciss%d: giving up on device.\n", h->ctlr); | 1631 | dev_warn(&h->pdev->dev, "giving up on device.\n"); |
1668 | else | 1632 | else |
1669 | printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr); | 1633 | dev_warn(&h->pdev->dev, "device is ready.\n"); |
1670 | 1634 | ||
1671 | cmd_free(h, c, 1); | 1635 | cmd_free(h, c); |
1672 | return rc; | 1636 | return rc; |
1673 | } | 1637 | } |
1674 | 1638 | ||
@@ -1688,26 +1652,24 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd) | |||
1688 | int rc; | 1652 | int rc; |
1689 | CommandList_struct *cmd_in_trouble; | 1653 | CommandList_struct *cmd_in_trouble; |
1690 | unsigned char lunaddr[8]; | 1654 | unsigned char lunaddr[8]; |
1691 | ctlr_info_t *c; | 1655 | ctlr_info_t *h; |
1692 | int ctlr; | ||
1693 | 1656 | ||
1694 | /* find the controller to which the command to be aborted was sent */ | 1657 | /* find the controller to which the command to be aborted was sent */ |
1695 | c = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; | 1658 | h = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; |
1696 | if (c == NULL) /* paranoia */ | 1659 | if (h == NULL) /* paranoia */ |
1697 | return FAILED; | 1660 | return FAILED; |
1698 | ctlr = c->ctlr; | 1661 | dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n"); |
1699 | printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr); | ||
1700 | /* find the command that's giving us trouble */ | 1662 | /* find the command that's giving us trouble */ |
1701 | cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble; | 1663 | cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble; |
1702 | if (cmd_in_trouble == NULL) /* paranoia */ | 1664 | if (cmd_in_trouble == NULL) /* paranoia */ |
1703 | return FAILED; | 1665 | return FAILED; |
1704 | memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8); | 1666 | memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8); |
1705 | /* send a reset to the SCSI LUN which the command was sent to */ | 1667 | /* send a reset to the SCSI LUN which the command was sent to */ |
1706 | rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr, | 1668 | rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr, |
1707 | TYPE_MSG); | 1669 | TYPE_MSG); |
1708 | if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0) | 1670 | if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0) |
1709 | return SUCCESS; | 1671 | return SUCCESS; |
1710 | printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr); | 1672 | dev_warn(&h->pdev->dev, "resetting device failed.\n"); |
1711 | return FAILED; | 1673 | return FAILED; |
1712 | } | 1674 | } |
1713 | 1675 | ||
@@ -1716,22 +1678,20 @@ static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd) | |||
1716 | int rc; | 1678 | int rc; |
1717 | CommandList_struct *cmd_to_abort; | 1679 | CommandList_struct *cmd_to_abort; |
1718 | unsigned char lunaddr[8]; | 1680 | unsigned char lunaddr[8]; |
1719 | ctlr_info_t *c; | 1681 | ctlr_info_t *h; |
1720 | int ctlr; | ||
1721 | 1682 | ||
1722 | /* find the controller to which the command to be aborted was sent */ | 1683 | /* find the controller to which the command to be aborted was sent */ |
1723 | c = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; | 1684 | h = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; |
1724 | if (c == NULL) /* paranoia */ | 1685 | if (h == NULL) /* paranoia */ |
1725 | return FAILED; | 1686 | return FAILED; |
1726 | ctlr = c->ctlr; | 1687 | dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n"); |
1727 | printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr); | ||
1728 | 1688 | ||
1729 | /* find the command to be aborted */ | 1689 | /* find the command to be aborted */ |
1730 | cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble; | 1690 | cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble; |
1731 | if (cmd_to_abort == NULL) /* paranoia */ | 1691 | if (cmd_to_abort == NULL) /* paranoia */ |
1732 | return FAILED; | 1692 | return FAILED; |
1733 | memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8); | 1693 | memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8); |
1734 | rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag, | 1694 | rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag, |
1735 | 0, 0, lunaddr, TYPE_MSG); | 1695 | 0, 0, lunaddr, TYPE_MSG); |
1736 | if (rc == 0) | 1696 | if (rc == 0) |
1737 | return SUCCESS; | 1697 | return SUCCESS; |