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