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