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