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