1 /* 2 * scsi_scan.c 3 * 4 * Copyright (C) 2000 Eric Youngdale, 5 * Copyright (C) 2002 Patrick Mansfield 6 * 7 * The general scanning/probing algorithm is as follows, exceptions are 8 * made to it depending on device specific flags, compilation options, and 9 * global variable (boot or module load time) settings. 10 * 11 * A specific LUN is scanned via an INQUIRY command; if the LUN has a 12 * device attached, a Scsi_Device is allocated and setup for it. 13 * 14 * For every id of every channel on the given host: 15 * 16 * Scan LUN 0; if the target responds to LUN 0 (even if there is no 17 * device or storage attached to LUN 0): 18 * 19 * If LUN 0 has a device attached, allocate and setup a 20 * Scsi_Device for it. 21 * 22 * If target is SCSI-3 or up, issue a REPORT LUN, and scan 23 * all of the LUNs returned by the REPORT LUN; else, 24 * sequentially scan LUNs up until some maximum is reached, 25 * or a LUN is seen that cannot have a device attached to it. 26 */ 27 28 #include <linux/config.h> 29 #include <linux/module.h> 30 #include <linux/moduleparam.h> 31 #include <linux/init.h> 32 #include <linux/blkdev.h> 33 #include <asm/semaphore.h> 34 35 #include <scsi/scsi.h> 36 #include <scsi/scsi_device.h> 37 #include <scsi/scsi_driver.h> 38 #include <scsi/scsi_devinfo.h> 39 #include <scsi/scsi_host.h> 40 #include <scsi/scsi_request.h> 41 #include <scsi/scsi_transport.h> 42 #include <scsi/scsi_eh.h> 43 44 #include "scsi_priv.h" 45 #include "scsi_logging.h" 46 47 #define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \ 48 " SCSI scanning, some SCSI devices might not be configured\n" 49 50 /* 51 * Default timeout 52 */ 53 #define SCSI_TIMEOUT (2*HZ) 54 55 /* 56 * Prefix values for the SCSI id's (stored in driverfs name field) 57 */ 58 #define SCSI_UID_SER_NUM 'S' 59 #define SCSI_UID_UNKNOWN 'Z' 60 61 /* 62 * Return values of some of the scanning functions. 63 * 64 * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this 65 * includes allocation or general failures preventing IO from being sent. 66 * 67 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available 68 * on the given LUN. 69 * 70 * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a 71 * given LUN. 72 */ 73 #define SCSI_SCAN_NO_RESPONSE 0 74 #define SCSI_SCAN_TARGET_PRESENT 1 75 #define SCSI_SCAN_LUN_PRESENT 2 76 77 static char *scsi_null_device_strs = "nullnullnullnull"; 78 79 #define MAX_SCSI_LUNS 512 80 81 #ifdef CONFIG_SCSI_MULTI_LUN 82 static unsigned int max_scsi_luns = MAX_SCSI_LUNS; 83 #else 84 static unsigned int max_scsi_luns = 1; 85 #endif 86 87 module_param_named(max_luns, max_scsi_luns, int, S_IRUGO|S_IWUSR); 88 MODULE_PARM_DESC(max_luns, 89 "last scsi LUN (should be between 1 and 2^32-1)"); 90 91 /* 92 * max_scsi_report_luns: the maximum number of LUNS that will be 93 * returned from the REPORT LUNS command. 8 times this value must 94 * be allocated. In theory this could be up to an 8 byte value, but 95 * in practice, the maximum number of LUNs suppored by any device 96 * is about 16k. 97 */ 98 static unsigned int max_scsi_report_luns = 511; 99 100 module_param_named(max_report_luns, max_scsi_report_luns, int, S_IRUGO|S_IWUSR); 101 MODULE_PARM_DESC(max_report_luns, 102 "REPORT LUNS maximum number of LUNS received (should be" 103 " between 1 and 16384)"); 104 105 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ+3; 106 107 module_param_named(inq_timeout, scsi_inq_timeout, int, S_IRUGO|S_IWUSR); 108 MODULE_PARM_DESC(inq_timeout, 109 "Timeout (in seconds) waiting for devices to answer INQUIRY." 110 " Default is 5. Some non-compliant devices need more."); 111 112 /** 113 * scsi_unlock_floptical - unlock device via a special MODE SENSE command 114 * @sdev: scsi device to send command to 115 * @result: area to store the result of the MODE SENSE 116 * 117 * Description: 118 * Send a vendor specific MODE SENSE (not a MODE SELECT) command. 119 * Called for BLIST_KEY devices. 120 **/ 121 static void scsi_unlock_floptical(struct scsi_device *sdev, 122 unsigned char *result) 123 { 124 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 125 126 printk(KERN_NOTICE "scsi: unlocking floptical drive\n"); 127 scsi_cmd[0] = MODE_SENSE; 128 scsi_cmd[1] = 0; 129 scsi_cmd[2] = 0x2e; 130 scsi_cmd[3] = 0; 131 scsi_cmd[4] = 0x2a; /* size */ 132 scsi_cmd[5] = 0; 133 scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL, 134 SCSI_TIMEOUT, 3); 135 } 136 137 /** 138 * print_inquiry - printk the inquiry information 139 * @inq_result: printk this SCSI INQUIRY 140 * 141 * Description: 142 * printk the vendor, model, and other information found in the 143 * INQUIRY data in @inq_result. 144 * 145 * Notes: 146 * Remove this, and replace with a hotplug event that logs any 147 * relevant information. 148 **/ 149 static void print_inquiry(unsigned char *inq_result) 150 { 151 int i; 152 153 printk(KERN_NOTICE " Vendor: "); 154 for (i = 8; i < 16; i++) 155 if (inq_result[i] >= 0x20 && i < inq_result[4] + 5) 156 printk("%c", inq_result[i]); 157 else 158 printk(" "); 159 160 printk(" Model: "); 161 for (i = 16; i < 32; i++) 162 if (inq_result[i] >= 0x20 && i < inq_result[4] + 5) 163 printk("%c", inq_result[i]); 164 else 165 printk(" "); 166 167 printk(" Rev: "); 168 for (i = 32; i < 36; i++) 169 if (inq_result[i] >= 0x20 && i < inq_result[4] + 5) 170 printk("%c", inq_result[i]); 171 else 172 printk(" "); 173 174 printk("\n"); 175 176 i = inq_result[0] & 0x1f; 177 178 printk(KERN_NOTICE " Type: %s ", 179 i < 180 MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] : 181 "Unknown "); 182 printk(" ANSI SCSI revision: %02x", 183 inq_result[2] & 0x07); 184 if ((inq_result[2] & 0x07) == 1 && (inq_result[3] & 0x0f) == 1) 185 printk(" CCS\n"); 186 else 187 printk("\n"); 188 } 189 190 /** 191 * scsi_alloc_sdev - allocate and setup a scsi_Device 192 * 193 * Description: 194 * Allocate, initialize for io, and return a pointer to a scsi_Device. 195 * Stores the @shost, @channel, @id, and @lun in the scsi_Device, and 196 * adds scsi_Device to the appropriate list. 197 * 198 * Return value: 199 * scsi_Device pointer, or NULL on failure. 200 **/ 201 static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget, 202 unsigned int lun, void *hostdata) 203 { 204 struct scsi_device *sdev; 205 int display_failure_msg = 1, ret; 206 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 207 208 sdev = kmalloc(sizeof(*sdev) + shost->transportt->device_size, 209 GFP_ATOMIC); 210 if (!sdev) 211 goto out; 212 213 memset(sdev, 0, sizeof(*sdev)); 214 sdev->vendor = scsi_null_device_strs; 215 sdev->model = scsi_null_device_strs; 216 sdev->rev = scsi_null_device_strs; 217 sdev->host = shost; 218 sdev->id = starget->id; 219 sdev->lun = lun; 220 sdev->channel = starget->channel; 221 sdev->sdev_state = SDEV_CREATED; 222 INIT_LIST_HEAD(&sdev->siblings); 223 INIT_LIST_HEAD(&sdev->same_target_siblings); 224 INIT_LIST_HEAD(&sdev->cmd_list); 225 INIT_LIST_HEAD(&sdev->starved_entry); 226 spin_lock_init(&sdev->list_lock); 227 228 sdev->sdev_gendev.parent = get_device(&starget->dev); 229 sdev->sdev_target = starget; 230 231 /* usually NULL and set by ->slave_alloc instead */ 232 sdev->hostdata = hostdata; 233 234 /* if the device needs this changing, it may do so in the 235 * slave_configure function */ 236 sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED; 237 238 /* 239 * Some low level driver could use device->type 240 */ 241 sdev->type = -1; 242 243 /* 244 * Assume that the device will have handshaking problems, 245 * and then fix this field later if it turns out it 246 * doesn't 247 */ 248 sdev->borken = 1; 249 250 sdev->request_queue = scsi_alloc_queue(sdev); 251 if (!sdev->request_queue) { 252 /* release fn is set up in scsi_sysfs_device_initialise, so 253 * have to free and put manually here */ 254 put_device(&starget->dev); 255 goto out; 256 } 257 258 sdev->request_queue->queuedata = sdev; 259 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 260 261 scsi_sysfs_device_initialize(sdev); 262 263 if (shost->hostt->slave_alloc) { 264 ret = shost->hostt->slave_alloc(sdev); 265 if (ret) { 266 /* 267 * if LLDD reports slave not present, don't clutter 268 * console with alloc failure messages 269 270 271 */ 272 if (ret == -ENXIO) 273 display_failure_msg = 0; 274 goto out_device_destroy; 275 } 276 } 277 278 return sdev; 279 280 out_device_destroy: 281 transport_destroy_device(&sdev->sdev_gendev); 282 scsi_free_queue(sdev->request_queue); 283 put_device(&sdev->sdev_gendev); 284 out: 285 if (display_failure_msg) 286 printk(ALLOC_FAILURE_MSG, __FUNCTION__); 287 return NULL; 288 } 289 290 static void scsi_target_dev_release(struct device *dev) 291 { 292 struct device *parent = dev->parent; 293 struct scsi_target *starget = to_scsi_target(dev); 294 struct Scsi_Host *shost = dev_to_shost(parent); 295 296 if (shost->hostt->target_destroy) 297 shost->hostt->target_destroy(starget); 298 kfree(starget); 299 put_device(parent); 300 } 301 302 int scsi_is_target_device(const struct device *dev) 303 { 304 return dev->release == scsi_target_dev_release; 305 } 306 EXPORT_SYMBOL(scsi_is_target_device); 307 308 static struct scsi_target *__scsi_find_target(struct device *parent, 309 int channel, uint id) 310 { 311 struct scsi_target *starget, *found_starget = NULL; 312 struct Scsi_Host *shost = dev_to_shost(parent); 313 /* 314 * Search for an existing target for this sdev. 315 */ 316 list_for_each_entry(starget, &shost->__targets, siblings) { 317 if (starget->id == id && 318 starget->channel == channel) { 319 found_starget = starget; 320 break; 321 } 322 } 323 if (found_starget) 324 get_device(&found_starget->dev); 325 326 return found_starget; 327 } 328 329 static struct scsi_target *scsi_alloc_target(struct device *parent, 330 int channel, uint id) 331 { 332 struct Scsi_Host *shost = dev_to_shost(parent); 333 struct device *dev = NULL; 334 unsigned long flags; 335 const int size = sizeof(struct scsi_target) 336 + shost->transportt->target_size; 337 struct scsi_target *starget; 338 struct scsi_target *found_target; 339 340 /* 341 * Obtain the real parent from the transport. The transport 342 * is allowed to fail (no error) if there is nothing at that 343 * target id. 344 */ 345 if (shost->transportt->target_parent) { 346 spin_lock_irqsave(shost->host_lock, flags); 347 parent = shost->transportt->target_parent(shost, channel, id); 348 spin_unlock_irqrestore(shost->host_lock, flags); 349 if (!parent) 350 return NULL; 351 } 352 353 starget = kmalloc(size, GFP_KERNEL); 354 if (!starget) { 355 printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__); 356 return NULL; 357 } 358 memset(starget, 0, size); 359 dev = &starget->dev; 360 device_initialize(dev); 361 starget->reap_ref = 1; 362 dev->parent = get_device(parent); 363 dev->release = scsi_target_dev_release; 364 sprintf(dev->bus_id, "target%d:%d:%d", 365 shost->host_no, channel, id); 366 starget->id = id; 367 starget->channel = channel; 368 INIT_LIST_HEAD(&starget->siblings); 369 INIT_LIST_HEAD(&starget->devices); 370 spin_lock_irqsave(shost->host_lock, flags); 371 372 found_target = __scsi_find_target(parent, channel, id); 373 if (found_target) 374 goto found; 375 376 list_add_tail(&starget->siblings, &shost->__targets); 377 spin_unlock_irqrestore(shost->host_lock, flags); 378 /* allocate and add */ 379 transport_setup_device(dev); 380 device_add(dev); 381 transport_add_device(dev); 382 if (shost->hostt->target_alloc) { 383 int error = shost->hostt->target_alloc(starget); 384 385 if(error) { 386 dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error); 387 /* don't want scsi_target_reap to do the final 388 * put because it will be under the host lock */ 389 get_device(dev); 390 scsi_target_reap(starget); 391 put_device(dev); 392 return NULL; 393 } 394 } 395 396 return starget; 397 398 found: 399 found_target->reap_ref++; 400 spin_unlock_irqrestore(shost->host_lock, flags); 401 put_device(parent); 402 kfree(starget); 403 return found_target; 404 } 405 406 /** 407 * scsi_target_reap - check to see if target is in use and destroy if not 408 * 409 * @starget: target to be checked 410 * 411 * This is used after removing a LUN or doing a last put of the target 412 * it checks atomically that nothing is using the target and removes 413 * it if so. 414 */ 415 void scsi_target_reap(struct scsi_target *starget) 416 { 417 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 418 unsigned long flags; 419 spin_lock_irqsave(shost->host_lock, flags); 420 421 if (--starget->reap_ref == 0 && list_empty(&starget->devices)) { 422 list_del_init(&starget->siblings); 423 spin_unlock_irqrestore(shost->host_lock, flags); 424 device_del(&starget->dev); 425 transport_unregister_device(&starget->dev); 426 put_device(&starget->dev); 427 return; 428 } 429 spin_unlock_irqrestore(shost->host_lock, flags); 430 } 431 432 /** 433 * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY 434 * @sdev: scsi_device to probe 435 * @inq_result: area to store the INQUIRY result 436 * @result_len: len of inq_result 437 * @bflags: store any bflags found here 438 * 439 * Description: 440 * Probe the lun associated with @req using a standard SCSI INQUIRY; 441 * 442 * If the INQUIRY is successful, zero is returned and the 443 * INQUIRY data is in @inq_result; the scsi_level and INQUIRY length 444 * are copied to the Scsi_Device any flags value is stored in *@bflags. 445 **/ 446 static int scsi_probe_lun(struct scsi_device *sdev, char *inq_result, 447 int result_len, int *bflags) 448 { 449 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 450 int first_inquiry_len, try_inquiry_len, next_inquiry_len; 451 int response_len = 0; 452 int pass, count, result; 453 struct scsi_sense_hdr sshdr; 454 455 *bflags = 0; 456 457 /* Perform up to 3 passes. The first pass uses a conservative 458 * transfer length of 36 unless sdev->inquiry_len specifies a 459 * different value. */ 460 first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36; 461 try_inquiry_len = first_inquiry_len; 462 pass = 1; 463 464 next_pass: 465 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY pass %d " 466 "to host %d channel %d id %d lun %d, length %d\n", 467 pass, sdev->host->host_no, sdev->channel, 468 sdev->id, sdev->lun, try_inquiry_len)); 469 470 /* Each pass gets up to three chances to ignore Unit Attention */ 471 for (count = 0; count < 3; ++count) { 472 memset(scsi_cmd, 0, 6); 473 scsi_cmd[0] = INQUIRY; 474 scsi_cmd[4] = (unsigned char) try_inquiry_len; 475 476 memset(inq_result, 0, try_inquiry_len); 477 478 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, 479 inq_result, try_inquiry_len, &sshdr, 480 HZ / 2 + HZ * scsi_inq_timeout, 3); 481 482 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s " 483 "with code 0x%x\n", 484 result ? "failed" : "successful", result)); 485 486 if (result) { 487 /* 488 * not-ready to ready transition [asc/ascq=0x28/0x0] 489 * or power-on, reset [asc/ascq=0x29/0x0], continue. 490 * INQUIRY should not yield UNIT_ATTENTION 491 * but many buggy devices do so anyway. 492 */ 493 if ((driver_byte(result) & DRIVER_SENSE) && 494 scsi_sense_valid(&sshdr)) { 495 if ((sshdr.sense_key == UNIT_ATTENTION) && 496 ((sshdr.asc == 0x28) || 497 (sshdr.asc == 0x29)) && 498 (sshdr.ascq == 0)) 499 continue; 500 } 501 } 502 break; 503 } 504 505 if (result == 0) { 506 response_len = (unsigned char) inq_result[4] + 5; 507 if (response_len > 255) 508 response_len = first_inquiry_len; /* sanity */ 509 510 /* 511 * Get any flags for this device. 512 * 513 * XXX add a bflags to Scsi_Device, and replace the 514 * corresponding bit fields in Scsi_Device, so bflags 515 * need not be passed as an argument. 516 */ 517 *bflags = scsi_get_device_flags(sdev, &inq_result[8], 518 &inq_result[16]); 519 520 /* When the first pass succeeds we gain information about 521 * what larger transfer lengths might work. */ 522 if (pass == 1) { 523 if (BLIST_INQUIRY_36 & *bflags) 524 next_inquiry_len = 36; 525 else if (BLIST_INQUIRY_58 & *bflags) 526 next_inquiry_len = 58; 527 else if (sdev->inquiry_len) 528 next_inquiry_len = sdev->inquiry_len; 529 else 530 next_inquiry_len = response_len; 531 532 /* If more data is available perform the second pass */ 533 if (next_inquiry_len > try_inquiry_len) { 534 try_inquiry_len = next_inquiry_len; 535 pass = 2; 536 goto next_pass; 537 } 538 } 539 540 } else if (pass == 2) { 541 printk(KERN_INFO "scsi scan: %d byte inquiry failed. " 542 "Consider BLIST_INQUIRY_36 for this device\n", 543 try_inquiry_len); 544 545 /* If this pass failed, the third pass goes back and transfers 546 * the same amount as we successfully got in the first pass. */ 547 try_inquiry_len = first_inquiry_len; 548 pass = 3; 549 goto next_pass; 550 } 551 552 /* If the last transfer attempt got an error, assume the 553 * peripheral doesn't exist or is dead. */ 554 if (result) 555 return -EIO; 556 557 /* Don't report any more data than the device says is valid */ 558 sdev->inquiry_len = min(try_inquiry_len, response_len); 559 560 /* 561 * XXX Abort if the response length is less than 36? If less than 562 * 32, the lookup of the device flags (above) could be invalid, 563 * and it would be possible to take an incorrect action - we do 564 * not want to hang because of a short INQUIRY. On the flip side, 565 * if the device is spun down or becoming ready (and so it gives a 566 * short INQUIRY), an abort here prevents any further use of the 567 * device, including spin up. 568 * 569 * Related to the above issue: 570 * 571 * XXX Devices (disk or all?) should be sent a TEST UNIT READY, 572 * and if not ready, sent a START_STOP to start (maybe spin up) and 573 * then send the INQUIRY again, since the INQUIRY can change after 574 * a device is initialized. 575 * 576 * Ideally, start a device if explicitly asked to do so. This 577 * assumes that a device is spun up on power on, spun down on 578 * request, and then spun up on request. 579 */ 580 581 /* 582 * The scanning code needs to know the scsi_level, even if no 583 * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so 584 * non-zero LUNs can be scanned. 585 */ 586 sdev->scsi_level = inq_result[2] & 0x07; 587 if (sdev->scsi_level >= 2 || 588 (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1)) 589 sdev->scsi_level++; 590 591 return 0; 592 } 593 594 /** 595 * scsi_add_lun - allocate and fully initialze a Scsi_Device 596 * @sdevscan: holds information to be stored in the new Scsi_Device 597 * @sdevnew: store the address of the newly allocated Scsi_Device 598 * @inq_result: holds the result of a previous INQUIRY to the LUN 599 * @bflags: black/white list flag 600 * 601 * Description: 602 * Allocate and initialize a Scsi_Device matching sdevscan. Optionally 603 * set fields based on values in *@bflags. If @sdevnew is not 604 * NULL, store the address of the new Scsi_Device in *@sdevnew (needed 605 * when scanning a particular LUN). 606 * 607 * Return: 608 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a Scsi_Device 609 * SCSI_SCAN_LUN_PRESENT: a new Scsi_Device was allocated and initialized 610 **/ 611 static int scsi_add_lun(struct scsi_device *sdev, char *inq_result, int *bflags) 612 { 613 /* 614 * XXX do not save the inquiry, since it can change underneath us, 615 * save just vendor/model/rev. 616 * 617 * Rather than save it and have an ioctl that retrieves the saved 618 * value, have an ioctl that executes the same INQUIRY code used 619 * in scsi_probe_lun, let user level programs doing INQUIRY 620 * scanning run at their own risk, or supply a user level program 621 * that can correctly scan. 622 */ 623 sdev->inquiry = kmalloc(sdev->inquiry_len, GFP_ATOMIC); 624 if (sdev->inquiry == NULL) { 625 return SCSI_SCAN_NO_RESPONSE; 626 } 627 628 memcpy(sdev->inquiry, inq_result, sdev->inquiry_len); 629 sdev->vendor = (char *) (sdev->inquiry + 8); 630 sdev->model = (char *) (sdev->inquiry + 16); 631 sdev->rev = (char *) (sdev->inquiry + 32); 632 633 if (*bflags & BLIST_ISROM) { 634 /* 635 * It would be better to modify sdev->type, and set 636 * sdev->removable, but then the print_inquiry() output 637 * would not show TYPE_ROM; if print_inquiry() is removed 638 * the issue goes away. 639 */ 640 inq_result[0] = TYPE_ROM; 641 inq_result[1] |= 0x80; /* removable */ 642 } else if (*bflags & BLIST_NO_ULD_ATTACH) 643 sdev->no_uld_attach = 1; 644 645 switch (sdev->type = (inq_result[0] & 0x1f)) { 646 case TYPE_TAPE: 647 case TYPE_DISK: 648 case TYPE_PRINTER: 649 case TYPE_MOD: 650 case TYPE_PROCESSOR: 651 case TYPE_SCANNER: 652 case TYPE_MEDIUM_CHANGER: 653 case TYPE_ENCLOSURE: 654 case TYPE_COMM: 655 case TYPE_RBC: 656 sdev->writeable = 1; 657 break; 658 case TYPE_WORM: 659 case TYPE_ROM: 660 sdev->writeable = 0; 661 break; 662 default: 663 printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type); 664 } 665 666 print_inquiry(inq_result); 667 668 /* 669 * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI 670 * spec says: The device server is capable of supporting the 671 * specified peripheral device type on this logical unit. However, 672 * the physical device is not currently connected to this logical 673 * unit. 674 * 675 * The above is vague, as it implies that we could treat 001 and 676 * 011 the same. Stay compatible with previous code, and create a 677 * Scsi_Device for a PQ of 1 678 * 679 * Don't set the device offline here; rather let the upper 680 * level drivers eval the PQ to decide whether they should 681 * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check. 682 */ 683 684 sdev->inq_periph_qual = (inq_result[0] >> 5) & 7; 685 sdev->removable = (0x80 & inq_result[1]) >> 7; 686 sdev->lockable = sdev->removable; 687 sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2); 688 689 if (sdev->scsi_level >= SCSI_3 || (sdev->inquiry_len > 56 && 690 inq_result[56] & 0x04)) 691 sdev->ppr = 1; 692 if (inq_result[7] & 0x60) 693 sdev->wdtr = 1; 694 if (inq_result[7] & 0x10) 695 sdev->sdtr = 1; 696 697 sprintf(sdev->devfs_name, "scsi/host%d/bus%d/target%d/lun%d", 698 sdev->host->host_no, sdev->channel, 699 sdev->id, sdev->lun); 700 701 /* 702 * End driverfs/devfs code. 703 */ 704 705 if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) && 706 !(*bflags & BLIST_NOTQ)) 707 sdev->tagged_supported = 1; 708 /* 709 * Some devices (Texel CD ROM drives) have handshaking problems 710 * when used with the Seagate controllers. borken is initialized 711 * to 1, and then set it to 0 here. 712 */ 713 if ((*bflags & BLIST_BORKEN) == 0) 714 sdev->borken = 0; 715 716 /* 717 * Apparently some really broken devices (contrary to the SCSI 718 * standards) need to be selected without asserting ATN 719 */ 720 if (*bflags & BLIST_SELECT_NO_ATN) 721 sdev->select_no_atn = 1; 722 723 /* 724 * Some devices may not want to have a start command automatically 725 * issued when a device is added. 726 */ 727 if (*bflags & BLIST_NOSTARTONADD) 728 sdev->no_start_on_add = 1; 729 730 if (*bflags & BLIST_SINGLELUN) 731 sdev->single_lun = 1; 732 733 734 sdev->use_10_for_rw = 1; 735 736 if (*bflags & BLIST_MS_SKIP_PAGE_08) 737 sdev->skip_ms_page_8 = 1; 738 739 if (*bflags & BLIST_MS_SKIP_PAGE_3F) 740 sdev->skip_ms_page_3f = 1; 741 742 if (*bflags & BLIST_USE_10_BYTE_MS) 743 sdev->use_10_for_ms = 1; 744 745 /* set the device running here so that slave configure 746 * may do I/O */ 747 scsi_device_set_state(sdev, SDEV_RUNNING); 748 749 if (*bflags & BLIST_MS_192_BYTES_FOR_3F) 750 sdev->use_192_bytes_for_3f = 1; 751 752 if (*bflags & BLIST_NOT_LOCKABLE) 753 sdev->lockable = 0; 754 755 if (*bflags & BLIST_RETRY_HWERROR) 756 sdev->retry_hwerror = 1; 757 758 transport_configure_device(&sdev->sdev_gendev); 759 760 if (sdev->host->hostt->slave_configure) 761 sdev->host->hostt->slave_configure(sdev); 762 763 /* 764 * Ok, the device is now all set up, we can 765 * register it and tell the rest of the kernel 766 * about it. 767 */ 768 if (scsi_sysfs_add_sdev(sdev) != 0) 769 return SCSI_SCAN_NO_RESPONSE; 770 771 return SCSI_SCAN_LUN_PRESENT; 772 } 773 774 /** 775 * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it 776 * @starget: pointer to target device structure 777 * @lun: LUN of target device 778 * @sdevscan: probe the LUN corresponding to this Scsi_Device 779 * @sdevnew: store the value of any new Scsi_Device allocated 780 * @bflagsp: store bflags here if not NULL 781 * 782 * Description: 783 * Call scsi_probe_lun, if a LUN with an attached device is found, 784 * allocate and set it up by calling scsi_add_lun. 785 * 786 * Return: 787 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a Scsi_Device 788 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is 789 * attached at the LUN 790 * SCSI_SCAN_LUN_PRESENT: a new Scsi_Device was allocated and initialized 791 **/ 792 static int scsi_probe_and_add_lun(struct scsi_target *starget, 793 uint lun, int *bflagsp, 794 struct scsi_device **sdevp, int rescan, 795 void *hostdata) 796 { 797 struct scsi_device *sdev; 798 unsigned char *result; 799 int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256; 800 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 801 802 /* 803 * The rescan flag is used as an optimization, the first scan of a 804 * host adapter calls into here with rescan == 0. 805 */ 806 if (rescan) { 807 sdev = scsi_device_lookup_by_target(starget, lun); 808 if (sdev) { 809 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO 810 "scsi scan: device exists on %s\n", 811 sdev->sdev_gendev.bus_id)); 812 if (sdevp) 813 *sdevp = sdev; 814 else 815 scsi_device_put(sdev); 816 817 if (bflagsp) 818 *bflagsp = scsi_get_device_flags(sdev, 819 sdev->vendor, 820 sdev->model); 821 return SCSI_SCAN_LUN_PRESENT; 822 } 823 } 824 825 sdev = scsi_alloc_sdev(starget, lun, hostdata); 826 if (!sdev) 827 goto out; 828 829 result = kmalloc(result_len, GFP_ATOMIC | 830 ((shost->unchecked_isa_dma) ? __GFP_DMA : 0)); 831 if (!result) 832 goto out_free_sdev; 833 834 if (scsi_probe_lun(sdev, result, result_len, &bflags)) 835 goto out_free_result; 836 837 /* 838 * result contains valid SCSI INQUIRY data. 839 */ 840 if ((result[0] >> 5) == 3) { 841 /* 842 * For a Peripheral qualifier 3 (011b), the SCSI 843 * spec says: The device server is not capable of 844 * supporting a physical device on this logical 845 * unit. 846 * 847 * For disks, this implies that there is no 848 * logical disk configured at sdev->lun, but there 849 * is a target id responding. 850 */ 851 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO 852 "scsi scan: peripheral qualifier of 3," 853 " no device added\n")); 854 res = SCSI_SCAN_TARGET_PRESENT; 855 goto out_free_result; 856 } 857 858 res = scsi_add_lun(sdev, result, &bflags); 859 if (res == SCSI_SCAN_LUN_PRESENT) { 860 if (bflags & BLIST_KEY) { 861 sdev->lockable = 0; 862 scsi_unlock_floptical(sdev, result); 863 } 864 if (bflagsp) 865 *bflagsp = bflags; 866 } 867 868 out_free_result: 869 kfree(result); 870 out_free_sdev: 871 if (res == SCSI_SCAN_LUN_PRESENT) { 872 if (sdevp) { 873 scsi_device_get(sdev); 874 *sdevp = sdev; 875 } 876 } else { 877 if (sdev->host->hostt->slave_destroy) 878 sdev->host->hostt->slave_destroy(sdev); 879 transport_destroy_device(&sdev->sdev_gendev); 880 put_device(&sdev->sdev_gendev); 881 } 882 out: 883 return res; 884 } 885 886 /** 887 * scsi_sequential_lun_scan - sequentially scan a SCSI target 888 * @starget: pointer to target structure to scan 889 * @bflags: black/white list flag for LUN 0 890 * @lun0_res: result of scanning LUN 0 891 * 892 * Description: 893 * Generally, scan from LUN 1 (LUN 0 is assumed to already have been 894 * scanned) to some maximum lun until a LUN is found with no device 895 * attached. Use the bflags to figure out any oddities. 896 * 897 * Modifies sdevscan->lun. 898 **/ 899 static void scsi_sequential_lun_scan(struct scsi_target *starget, 900 int bflags, int lun0_res, int scsi_level, 901 int rescan) 902 { 903 unsigned int sparse_lun, lun, max_dev_lun; 904 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 905 906 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of" 907 "%s\n", starget->dev.bus_id)); 908 909 max_dev_lun = min(max_scsi_luns, shost->max_lun); 910 /* 911 * If this device is known to support sparse multiple units, 912 * override the other settings, and scan all of them. Normally, 913 * SCSI-3 devices should be scanned via the REPORT LUNS. 914 */ 915 if (bflags & BLIST_SPARSELUN) { 916 max_dev_lun = shost->max_lun; 917 sparse_lun = 1; 918 } else 919 sparse_lun = 0; 920 921 /* 922 * If not sparse lun and no device attached at LUN 0 do not scan 923 * any further. 924 */ 925 if (!sparse_lun && (lun0_res != SCSI_SCAN_LUN_PRESENT)) 926 return; 927 928 /* 929 * If less than SCSI_1_CSS, and no special lun scaning, stop 930 * scanning; this matches 2.4 behaviour, but could just be a bug 931 * (to continue scanning a SCSI_1_CSS device). 932 * 933 * This test is broken. We might not have any device on lun0 for 934 * a sparselun device, and if that's the case then how would we 935 * know the real scsi_level, eh? It might make sense to just not 936 * scan any SCSI_1 device for non-0 luns, but that check would best 937 * go into scsi_alloc_sdev() and just have it return null when asked 938 * to alloc an sdev for lun > 0 on an already found SCSI_1 device. 939 * 940 if ((sdevscan->scsi_level < SCSI_1_CCS) && 941 ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN)) 942 == 0)) 943 return; 944 */ 945 /* 946 * If this device is known to support multiple units, override 947 * the other settings, and scan all of them. 948 */ 949 if (bflags & BLIST_FORCELUN) 950 max_dev_lun = shost->max_lun; 951 /* 952 * REGAL CDC-4X: avoid hang after LUN 4 953 */ 954 if (bflags & BLIST_MAX5LUN) 955 max_dev_lun = min(5U, max_dev_lun); 956 /* 957 * Do not scan SCSI-2 or lower device past LUN 7, unless 958 * BLIST_LARGELUN. 959 */ 960 if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN)) 961 max_dev_lun = min(8U, max_dev_lun); 962 963 /* 964 * We have already scanned LUN 0, so start at LUN 1. Keep scanning 965 * until we reach the max, or no LUN is found and we are not 966 * sparse_lun. 967 */ 968 for (lun = 1; lun < max_dev_lun; ++lun) 969 if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, 970 NULL) != SCSI_SCAN_LUN_PRESENT) && 971 !sparse_lun) 972 return; 973 } 974 975 /** 976 * scsilun_to_int: convert a scsi_lun to an int 977 * @scsilun: struct scsi_lun to be converted. 978 * 979 * Description: 980 * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered 981 * integer, and return the result. The caller must check for 982 * truncation before using this function. 983 * 984 * Notes: 985 * The struct scsi_lun is assumed to be four levels, with each level 986 * effectively containing a SCSI byte-ordered (big endian) short; the 987 * addressing bits of each level are ignored (the highest two bits). 988 * For a description of the LUN format, post SCSI-3 see the SCSI 989 * Architecture Model, for SCSI-3 see the SCSI Controller Commands. 990 * 991 * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns 992 * the integer: 0x0b030a04 993 **/ 994 static int scsilun_to_int(struct scsi_lun *scsilun) 995 { 996 int i; 997 unsigned int lun; 998 999 lun = 0; 1000 for (i = 0; i < sizeof(lun); i += 2) 1001 lun = lun | (((scsilun->scsi_lun[i] << 8) | 1002 scsilun->scsi_lun[i + 1]) << (i * 8)); 1003 return lun; 1004 } 1005 1006 /** 1007 * int_to_scsilun: reverts an int into a scsi_lun 1008 * @int: integer to be reverted 1009 * @scsilun: struct scsi_lun to be set. 1010 * 1011 * Description: 1012 * Reverts the functionality of the scsilun_to_int, which packed 1013 * an 8-byte lun value into an int. This routine unpacks the int 1014 * back into the lun value. 1015 * Note: the scsilun_to_int() routine does not truly handle all 1016 * 8bytes of the lun value. This functions restores only as much 1017 * as was set by the routine. 1018 * 1019 * Notes: 1020 * Given an integer : 0x0b030a04, this function returns a 1021 * scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00 1022 * 1023 **/ 1024 void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun) 1025 { 1026 int i; 1027 1028 memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun)); 1029 1030 for (i = 0; i < sizeof(lun); i += 2) { 1031 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF; 1032 scsilun->scsi_lun[i+1] = lun & 0xFF; 1033 lun = lun >> 16; 1034 } 1035 } 1036 EXPORT_SYMBOL(int_to_scsilun); 1037 1038 /** 1039 * scsi_report_lun_scan - Scan using SCSI REPORT LUN results 1040 * @sdevscan: scan the host, channel, and id of this Scsi_Device 1041 * 1042 * Description: 1043 * If @sdevscan is for a SCSI-3 or up device, send a REPORT LUN 1044 * command, and scan the resulting list of LUNs by calling 1045 * scsi_probe_and_add_lun. 1046 * 1047 * Modifies sdevscan->lun. 1048 * 1049 * Return: 1050 * 0: scan completed (or no memory, so further scanning is futile) 1051 * 1: no report lun scan, or not configured 1052 **/ 1053 static int scsi_report_lun_scan(struct scsi_device *sdev, int bflags, 1054 int rescan) 1055 { 1056 char devname[64]; 1057 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 1058 unsigned int length; 1059 unsigned int lun; 1060 unsigned int num_luns; 1061 unsigned int retries; 1062 int result; 1063 struct scsi_lun *lunp, *lun_data; 1064 u8 *data; 1065 struct scsi_sense_hdr sshdr; 1066 struct scsi_target *starget = scsi_target(sdev); 1067 1068 /* 1069 * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set. 1070 * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does 1071 * support more than 8 LUNs. 1072 */ 1073 if ((bflags & BLIST_NOREPORTLUN) || 1074 sdev->scsi_level < SCSI_2 || 1075 (sdev->scsi_level < SCSI_3 && 1076 (!(bflags & BLIST_REPORTLUN2) || sdev->host->max_lun <= 8)) ) 1077 return 1; 1078 if (bflags & BLIST_NOLUN) 1079 return 0; 1080 1081 sprintf(devname, "host %d channel %d id %d", 1082 sdev->host->host_no, sdev->channel, sdev->id); 1083 1084 /* 1085 * Allocate enough to hold the header (the same size as one scsi_lun) 1086 * plus the max number of luns we are requesting. 1087 * 1088 * Reallocating and trying again (with the exact amount we need) 1089 * would be nice, but then we need to somehow limit the size 1090 * allocated based on the available memory and the limits of 1091 * kmalloc - we don't want a kmalloc() failure of a huge value to 1092 * prevent us from finding any LUNs on this target. 1093 */ 1094 length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun); 1095 lun_data = kmalloc(length, GFP_ATOMIC | 1096 (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0)); 1097 if (!lun_data) 1098 goto out; 1099 1100 scsi_cmd[0] = REPORT_LUNS; 1101 1102 /* 1103 * bytes 1 - 5: reserved, set to zero. 1104 */ 1105 memset(&scsi_cmd[1], 0, 5); 1106 1107 /* 1108 * bytes 6 - 9: length of the command. 1109 */ 1110 scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff; 1111 scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff; 1112 scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff; 1113 scsi_cmd[9] = (unsigned char) length & 0xff; 1114 1115 scsi_cmd[10] = 0; /* reserved */ 1116 scsi_cmd[11] = 0; /* control */ 1117 1118 /* 1119 * We can get a UNIT ATTENTION, for example a power on/reset, so 1120 * retry a few times (like sd.c does for TEST UNIT READY). 1121 * Experience shows some combinations of adapter/devices get at 1122 * least two power on/resets. 1123 * 1124 * Illegal requests (for devices that do not support REPORT LUNS) 1125 * should come through as a check condition, and will not generate 1126 * a retry. 1127 */ 1128 for (retries = 0; retries < 3; retries++) { 1129 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending" 1130 " REPORT LUNS to %s (try %d)\n", devname, 1131 retries)); 1132 1133 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, 1134 lun_data, length, &sshdr, 1135 SCSI_TIMEOUT + 4 * HZ, 3); 1136 1137 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS" 1138 " %s (try %d) result 0x%x\n", result 1139 ? "failed" : "successful", retries, result)); 1140 if (result == 0) 1141 break; 1142 else if (scsi_sense_valid(&sshdr)) { 1143 if (sshdr.sense_key != UNIT_ATTENTION) 1144 break; 1145 } 1146 } 1147 1148 if (result) { 1149 /* 1150 * The device probably does not support a REPORT LUN command 1151 */ 1152 kfree(lun_data); 1153 return 1; 1154 } 1155 1156 /* 1157 * Get the length from the first four bytes of lun_data. 1158 */ 1159 data = (u8 *) lun_data->scsi_lun; 1160 length = ((data[0] << 24) | (data[1] << 16) | 1161 (data[2] << 8) | (data[3] << 0)); 1162 1163 num_luns = (length / sizeof(struct scsi_lun)); 1164 if (num_luns > max_scsi_report_luns) { 1165 printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)" 1166 " of %d luns reported, try increasing" 1167 " max_scsi_report_luns.\n", devname, 1168 max_scsi_report_luns, num_luns); 1169 num_luns = max_scsi_report_luns; 1170 } 1171 1172 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUN scan of" 1173 " host %d channel %d id %d\n", sdev->host->host_no, 1174 sdev->channel, sdev->id)); 1175 1176 /* 1177 * Scan the luns in lun_data. The entry at offset 0 is really 1178 * the header, so start at 1 and go up to and including num_luns. 1179 */ 1180 for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) { 1181 lun = scsilun_to_int(lunp); 1182 1183 /* 1184 * Check if the unused part of lunp is non-zero, and so 1185 * does not fit in lun. 1186 */ 1187 if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) { 1188 int i; 1189 1190 /* 1191 * Output an error displaying the LUN in byte order, 1192 * this differs from what linux would print for the 1193 * integer LUN value. 1194 */ 1195 printk(KERN_WARNING "scsi: %s lun 0x", devname); 1196 data = (char *)lunp->scsi_lun; 1197 for (i = 0; i < sizeof(struct scsi_lun); i++) 1198 printk("%02x", data[i]); 1199 printk(" has a LUN larger than currently supported.\n"); 1200 } else if (lun == 0) { 1201 /* 1202 * LUN 0 has already been scanned. 1203 */ 1204 } else if (lun > sdev->host->max_lun) { 1205 printk(KERN_WARNING "scsi: %s lun%d has a LUN larger" 1206 " than allowed by the host adapter\n", 1207 devname, lun); 1208 } else { 1209 int res; 1210 1211 res = scsi_probe_and_add_lun(starget, 1212 lun, NULL, NULL, rescan, NULL); 1213 if (res == SCSI_SCAN_NO_RESPONSE) { 1214 /* 1215 * Got some results, but now none, abort. 1216 */ 1217 printk(KERN_ERR "scsi: Unexpected response" 1218 " from %s lun %d while scanning, scan" 1219 " aborted\n", devname, lun); 1220 break; 1221 } 1222 } 1223 } 1224 1225 kfree(lun_data); 1226 return 0; 1227 1228 out: 1229 /* 1230 * We are out of memory, don't try scanning any further. 1231 */ 1232 printk(ALLOC_FAILURE_MSG, __FUNCTION__); 1233 return 0; 1234 } 1235 1236 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel, 1237 uint id, uint lun, void *hostdata) 1238 { 1239 struct scsi_device *sdev; 1240 struct device *parent = &shost->shost_gendev; 1241 int res; 1242 struct scsi_target *starget = scsi_alloc_target(parent, channel, id); 1243 1244 if (!starget) 1245 return ERR_PTR(-ENOMEM); 1246 1247 get_device(&starget->dev); 1248 down(&shost->scan_mutex); 1249 if (scsi_host_scan_allowed(shost)) { 1250 res = scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, 1251 hostdata); 1252 if (res != SCSI_SCAN_LUN_PRESENT) 1253 sdev = ERR_PTR(-ENODEV); 1254 } 1255 up(&shost->scan_mutex); 1256 scsi_target_reap(starget); 1257 put_device(&starget->dev); 1258 1259 return sdev; 1260 } 1261 EXPORT_SYMBOL(__scsi_add_device); 1262 1263 void scsi_rescan_device(struct device *dev) 1264 { 1265 struct scsi_driver *drv; 1266 1267 if (!dev->driver) 1268 return; 1269 1270 drv = to_scsi_driver(dev->driver); 1271 if (try_module_get(drv->owner)) { 1272 if (drv->rescan) 1273 drv->rescan(dev); 1274 module_put(drv->owner); 1275 } 1276 } 1277 EXPORT_SYMBOL(scsi_rescan_device); 1278 1279 /** 1280 * scsi_scan_target - scan a target id, possibly including all LUNs on the 1281 * target. 1282 * @sdevsca: Scsi_Device handle for scanning 1283 * @shost: host to scan 1284 * @channel: channel to scan 1285 * @id: target id to scan 1286 * 1287 * Description: 1288 * Scan the target id on @shost, @channel, and @id. Scan at least LUN 1289 * 0, and possibly all LUNs on the target id. 1290 * 1291 * Use the pre-allocated @sdevscan as a handle for the scanning. This 1292 * function sets sdevscan->host, sdevscan->id and sdevscan->lun; the 1293 * scanning functions modify sdevscan->lun. 1294 * 1295 * First try a REPORT LUN scan, if that does not scan the target, do a 1296 * sequential scan of LUNs on the target id. 1297 **/ 1298 void scsi_scan_target(struct device *parent, unsigned int channel, 1299 unsigned int id, unsigned int lun, int rescan) 1300 { 1301 struct Scsi_Host *shost = dev_to_shost(parent); 1302 int bflags = 0; 1303 int res; 1304 struct scsi_device *sdev = NULL; 1305 struct scsi_target *starget; 1306 1307 if (shost->this_id == id) 1308 /* 1309 * Don't scan the host adapter 1310 */ 1311 return; 1312 1313 1314 starget = scsi_alloc_target(parent, channel, id); 1315 1316 if (!starget) 1317 return; 1318 1319 get_device(&starget->dev); 1320 if (lun != SCAN_WILD_CARD) { 1321 /* 1322 * Scan for a specific host/chan/id/lun. 1323 */ 1324 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL); 1325 goto out_reap; 1326 } 1327 1328 /* 1329 * Scan LUN 0, if there is some response, scan further. Ideally, we 1330 * would not configure LUN 0 until all LUNs are scanned. 1331 */ 1332 res = scsi_probe_and_add_lun(starget, 0, &bflags, &sdev, rescan, NULL); 1333 if (res == SCSI_SCAN_LUN_PRESENT) { 1334 if (scsi_report_lun_scan(sdev, bflags, rescan) != 0) 1335 /* 1336 * The REPORT LUN did not scan the target, 1337 * do a sequential scan. 1338 */ 1339 scsi_sequential_lun_scan(starget, bflags, 1340 res, sdev->scsi_level, rescan); 1341 } else if (res == SCSI_SCAN_TARGET_PRESENT) { 1342 /* 1343 * There's a target here, but lun 0 is offline so we 1344 * can't use the report_lun scan. Fall back to a 1345 * sequential lun scan with a bflags of SPARSELUN and 1346 * a default scsi level of SCSI_2 1347 */ 1348 scsi_sequential_lun_scan(starget, BLIST_SPARSELUN, 1349 SCSI_SCAN_TARGET_PRESENT, SCSI_2, rescan); 1350 } 1351 if (sdev) 1352 scsi_device_put(sdev); 1353 1354 out_reap: 1355 /* now determine if the target has any children at all 1356 * and if not, nuke it */ 1357 scsi_target_reap(starget); 1358 1359 put_device(&starget->dev); 1360 } 1361 EXPORT_SYMBOL(scsi_scan_target); 1362 1363 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel, 1364 unsigned int id, unsigned int lun, int rescan) 1365 { 1366 uint order_id; 1367 1368 if (id == SCAN_WILD_CARD) 1369 for (id = 0; id < shost->max_id; ++id) { 1370 /* 1371 * XXX adapter drivers when possible (FCP, iSCSI) 1372 * could modify max_id to match the current max, 1373 * not the absolute max. 1374 * 1375 * XXX add a shost id iterator, so for example, 1376 * the FC ID can be the same as a target id 1377 * without a huge overhead of sparse id's. 1378 */ 1379 if (shost->reverse_ordering) 1380 /* 1381 * Scan from high to low id. 1382 */ 1383 order_id = shost->max_id - id - 1; 1384 else 1385 order_id = id; 1386 scsi_scan_target(&shost->shost_gendev, channel, order_id, lun, rescan); 1387 } 1388 else 1389 scsi_scan_target(&shost->shost_gendev, channel, id, lun, rescan); 1390 } 1391 1392 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel, 1393 unsigned int id, unsigned int lun, int rescan) 1394 { 1395 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "%s: <%u:%u:%u:%u>\n", 1396 __FUNCTION__, shost->host_no, channel, id, lun)); 1397 1398 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) || 1399 ((id != SCAN_WILD_CARD) && (id > shost->max_id)) || 1400 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun))) 1401 return -EINVAL; 1402 1403 down(&shost->scan_mutex); 1404 if (scsi_host_scan_allowed(shost)) { 1405 if (channel == SCAN_WILD_CARD) 1406 for (channel = 0; channel <= shost->max_channel; 1407 channel++) 1408 scsi_scan_channel(shost, channel, id, lun, 1409 rescan); 1410 else 1411 scsi_scan_channel(shost, channel, id, lun, rescan); 1412 } 1413 up(&shost->scan_mutex); 1414 1415 return 0; 1416 } 1417 1418 /** 1419 * scsi_scan_host - scan the given adapter 1420 * @shost: adapter to scan 1421 **/ 1422 void scsi_scan_host(struct Scsi_Host *shost) 1423 { 1424 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD, 1425 SCAN_WILD_CARD, 0); 1426 } 1427 EXPORT_SYMBOL(scsi_scan_host); 1428 1429 /** 1430 * scsi_scan_single_target - scan the given SCSI target 1431 * @shost: adapter to scan 1432 * @chan: channel to scan 1433 * @id: target id to scan 1434 **/ 1435 void scsi_scan_single_target(struct Scsi_Host *shost, 1436 unsigned int chan, unsigned int id) 1437 { 1438 scsi_scan_host_selected(shost, chan, id, SCAN_WILD_CARD, 1); 1439 } 1440 EXPORT_SYMBOL(scsi_scan_single_target); 1441 1442 void scsi_forget_host(struct Scsi_Host *shost) 1443 { 1444 struct scsi_target *starget, *tmp; 1445 unsigned long flags; 1446 1447 /* 1448 * Ok, this look a bit strange. We always look for the first device 1449 * on the list as scsi_remove_device removes them from it - thus we 1450 * also have to release the lock. 1451 * We don't need to get another reference to the device before 1452 * releasing the lock as we already own the reference from 1453 * scsi_register_device that's release in scsi_remove_device. And 1454 * after that we don't look at sdev anymore. 1455 */ 1456 spin_lock_irqsave(shost->host_lock, flags); 1457 list_for_each_entry_safe(starget, tmp, &shost->__targets, siblings) { 1458 spin_unlock_irqrestore(shost->host_lock, flags); 1459 scsi_remove_target(&starget->dev); 1460 spin_lock_irqsave(shost->host_lock, flags); 1461 } 1462 spin_unlock_irqrestore(shost->host_lock, flags); 1463 } 1464 1465 /* 1466 * Function: scsi_get_host_dev() 1467 * 1468 * Purpose: Create a Scsi_Device that points to the host adapter itself. 1469 * 1470 * Arguments: SHpnt - Host that needs a Scsi_Device 1471 * 1472 * Lock status: None assumed. 1473 * 1474 * Returns: The Scsi_Device or NULL 1475 * 1476 * Notes: 1477 * Attach a single Scsi_Device to the Scsi_Host - this should 1478 * be made to look like a "pseudo-device" that points to the 1479 * HA itself. 1480 * 1481 * Note - this device is not accessible from any high-level 1482 * drivers (including generics), which is probably not 1483 * optimal. We can add hooks later to attach 1484 */ 1485 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost) 1486 { 1487 struct scsi_device *sdev; 1488 struct scsi_target *starget; 1489 1490 starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id); 1491 if (!starget) 1492 return NULL; 1493 1494 sdev = scsi_alloc_sdev(starget, 0, NULL); 1495 if (sdev) { 1496 sdev->sdev_gendev.parent = get_device(&starget->dev); 1497 sdev->borken = 0; 1498 } 1499 put_device(&starget->dev); 1500 return sdev; 1501 } 1502 EXPORT_SYMBOL(scsi_get_host_dev); 1503 1504 /* 1505 * Function: scsi_free_host_dev() 1506 * 1507 * Purpose: Free a scsi_device that points to the host adapter itself. 1508 * 1509 * Arguments: SHpnt - Host that needs a Scsi_Device 1510 * 1511 * Lock status: None assumed. 1512 * 1513 * Returns: Nothing 1514 * 1515 * Notes: 1516 */ 1517 void scsi_free_host_dev(struct scsi_device *sdev) 1518 { 1519 BUG_ON(sdev->id != sdev->host->this_id); 1520 1521 if (sdev->host->hostt->slave_destroy) 1522 sdev->host->hostt->slave_destroy(sdev); 1523 transport_destroy_device(&sdev->sdev_gendev); 1524 put_device(&sdev->sdev_gendev); 1525 } 1526 EXPORT_SYMBOL(scsi_free_host_dev); 1527 1528