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