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 sdev->sdev_target->scsi_level = sdev->scsi_level; 591 592 return 0; 593 } 594 595 /** 596 * scsi_add_lun - allocate and fully initialze a Scsi_Device 597 * @sdevscan: holds information to be stored in the new Scsi_Device 598 * @sdevnew: store the address of the newly allocated Scsi_Device 599 * @inq_result: holds the result of a previous INQUIRY to the LUN 600 * @bflags: black/white list flag 601 * 602 * Description: 603 * Allocate and initialize a Scsi_Device matching sdevscan. Optionally 604 * set fields based on values in *@bflags. If @sdevnew is not 605 * NULL, store the address of the new Scsi_Device in *@sdevnew (needed 606 * when scanning a particular LUN). 607 * 608 * Return: 609 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a Scsi_Device 610 * SCSI_SCAN_LUN_PRESENT: a new Scsi_Device was allocated and initialized 611 **/ 612 static int scsi_add_lun(struct scsi_device *sdev, char *inq_result, int *bflags) 613 { 614 /* 615 * XXX do not save the inquiry, since it can change underneath us, 616 * save just vendor/model/rev. 617 * 618 * Rather than save it and have an ioctl that retrieves the saved 619 * value, have an ioctl that executes the same INQUIRY code used 620 * in scsi_probe_lun, let user level programs doing INQUIRY 621 * scanning run at their own risk, or supply a user level program 622 * that can correctly scan. 623 */ 624 sdev->inquiry = kmalloc(sdev->inquiry_len, GFP_ATOMIC); 625 if (sdev->inquiry == NULL) { 626 return SCSI_SCAN_NO_RESPONSE; 627 } 628 629 memcpy(sdev->inquiry, inq_result, sdev->inquiry_len); 630 sdev->vendor = (char *) (sdev->inquiry + 8); 631 sdev->model = (char *) (sdev->inquiry + 16); 632 sdev->rev = (char *) (sdev->inquiry + 32); 633 634 if (*bflags & BLIST_ISROM) { 635 /* 636 * It would be better to modify sdev->type, and set 637 * sdev->removable, but then the print_inquiry() output 638 * would not show TYPE_ROM; if print_inquiry() is removed 639 * the issue goes away. 640 */ 641 inq_result[0] = TYPE_ROM; 642 inq_result[1] |= 0x80; /* removable */ 643 } else if (*bflags & BLIST_NO_ULD_ATTACH) 644 sdev->no_uld_attach = 1; 645 646 switch (sdev->type = (inq_result[0] & 0x1f)) { 647 case TYPE_TAPE: 648 case TYPE_DISK: 649 case TYPE_PRINTER: 650 case TYPE_MOD: 651 case TYPE_PROCESSOR: 652 case TYPE_SCANNER: 653 case TYPE_MEDIUM_CHANGER: 654 case TYPE_ENCLOSURE: 655 case TYPE_COMM: 656 case TYPE_RBC: 657 sdev->writeable = 1; 658 break; 659 case TYPE_WORM: 660 case TYPE_ROM: 661 sdev->writeable = 0; 662 break; 663 default: 664 printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type); 665 } 666 667 print_inquiry(inq_result); 668 669 /* 670 * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI 671 * spec says: The device server is capable of supporting the 672 * specified peripheral device type on this logical unit. However, 673 * the physical device is not currently connected to this logical 674 * unit. 675 * 676 * The above is vague, as it implies that we could treat 001 and 677 * 011 the same. Stay compatible with previous code, and create a 678 * Scsi_Device for a PQ of 1 679 * 680 * Don't set the device offline here; rather let the upper 681 * level drivers eval the PQ to decide whether they should 682 * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check. 683 */ 684 685 sdev->inq_periph_qual = (inq_result[0] >> 5) & 7; 686 sdev->removable = (0x80 & inq_result[1]) >> 7; 687 sdev->lockable = sdev->removable; 688 sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2); 689 690 if (sdev->scsi_level >= SCSI_3 || (sdev->inquiry_len > 56 && 691 inq_result[56] & 0x04)) 692 sdev->ppr = 1; 693 if (inq_result[7] & 0x60) 694 sdev->wdtr = 1; 695 if (inq_result[7] & 0x10) 696 sdev->sdtr = 1; 697 698 sprintf(sdev->devfs_name, "scsi/host%d/bus%d/target%d/lun%d", 699 sdev->host->host_no, sdev->channel, 700 sdev->id, sdev->lun); 701 702 /* 703 * End driverfs/devfs code. 704 */ 705 706 if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) && 707 !(*bflags & BLIST_NOTQ)) 708 sdev->tagged_supported = 1; 709 /* 710 * Some devices (Texel CD ROM drives) have handshaking problems 711 * when used with the Seagate controllers. borken is initialized 712 * to 1, and then set it to 0 here. 713 */ 714 if ((*bflags & BLIST_BORKEN) == 0) 715 sdev->borken = 0; 716 717 /* 718 * Apparently some really broken devices (contrary to the SCSI 719 * standards) need to be selected without asserting ATN 720 */ 721 if (*bflags & BLIST_SELECT_NO_ATN) 722 sdev->select_no_atn = 1; 723 724 /* 725 * Some devices may not want to have a start command automatically 726 * issued when a device is added. 727 */ 728 if (*bflags & BLIST_NOSTARTONADD) 729 sdev->no_start_on_add = 1; 730 731 if (*bflags & BLIST_SINGLELUN) 732 sdev->single_lun = 1; 733 734 735 sdev->use_10_for_rw = 1; 736 737 if (*bflags & BLIST_MS_SKIP_PAGE_08) 738 sdev->skip_ms_page_8 = 1; 739 740 if (*bflags & BLIST_MS_SKIP_PAGE_3F) 741 sdev->skip_ms_page_3f = 1; 742 743 if (*bflags & BLIST_USE_10_BYTE_MS) 744 sdev->use_10_for_ms = 1; 745 746 /* set the device running here so that slave configure 747 * may do I/O */ 748 scsi_device_set_state(sdev, SDEV_RUNNING); 749 750 if (*bflags & BLIST_MS_192_BYTES_FOR_3F) 751 sdev->use_192_bytes_for_3f = 1; 752 753 if (*bflags & BLIST_NOT_LOCKABLE) 754 sdev->lockable = 0; 755 756 if (*bflags & BLIST_RETRY_HWERROR) 757 sdev->retry_hwerror = 1; 758 759 transport_configure_device(&sdev->sdev_gendev); 760 761 if (sdev->host->hostt->slave_configure) 762 sdev->host->hostt->slave_configure(sdev); 763 764 /* 765 * Ok, the device is now all set up, we can 766 * register it and tell the rest of the kernel 767 * about it. 768 */ 769 if (scsi_sysfs_add_sdev(sdev) != 0) 770 return SCSI_SCAN_NO_RESPONSE; 771 772 return SCSI_SCAN_LUN_PRESENT; 773 } 774 775 static inline void scsi_destroy_sdev(struct scsi_device *sdev) 776 { 777 if (sdev->host->hostt->slave_destroy) 778 sdev->host->hostt->slave_destroy(sdev); 779 transport_destroy_device(&sdev->sdev_gendev); 780 put_device(&sdev->sdev_gendev); 781 } 782 783 784 /** 785 * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it 786 * @starget: pointer to target device structure 787 * @lun: LUN of target device 788 * @sdevscan: probe the LUN corresponding to this Scsi_Device 789 * @sdevnew: store the value of any new Scsi_Device allocated 790 * @bflagsp: store bflags here if not NULL 791 * 792 * Description: 793 * Call scsi_probe_lun, if a LUN with an attached device is found, 794 * allocate and set it up by calling scsi_add_lun. 795 * 796 * Return: 797 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a Scsi_Device 798 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is 799 * attached at the LUN 800 * SCSI_SCAN_LUN_PRESENT: a new Scsi_Device was allocated and initialized 801 **/ 802 static int scsi_probe_and_add_lun(struct scsi_target *starget, 803 uint lun, int *bflagsp, 804 struct scsi_device **sdevp, int rescan, 805 void *hostdata) 806 { 807 struct scsi_device *sdev; 808 unsigned char *result; 809 int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256; 810 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 811 812 /* 813 * The rescan flag is used as an optimization, the first scan of a 814 * host adapter calls into here with rescan == 0. 815 */ 816 sdev = scsi_device_lookup_by_target(starget, lun); 817 if (sdev) { 818 if (rescan || sdev->sdev_state != SDEV_CREATED) { 819 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO 820 "scsi scan: device exists on %s\n", 821 sdev->sdev_gendev.bus_id)); 822 if (sdevp) 823 *sdevp = sdev; 824 else 825 scsi_device_put(sdev); 826 827 if (bflagsp) 828 *bflagsp = scsi_get_device_flags(sdev, 829 sdev->vendor, 830 sdev->model); 831 return SCSI_SCAN_LUN_PRESENT; 832 } 833 scsi_device_put(sdev); 834 } else 835 sdev = scsi_alloc_sdev(starget, lun, hostdata); 836 if (!sdev) 837 goto out; 838 839 result = kmalloc(result_len, GFP_ATOMIC | 840 ((shost->unchecked_isa_dma) ? __GFP_DMA : 0)); 841 if (!result) 842 goto out_free_sdev; 843 844 if (scsi_probe_lun(sdev, result, result_len, &bflags)) 845 goto out_free_result; 846 847 /* 848 * result contains valid SCSI INQUIRY data. 849 */ 850 if ((result[0] >> 5) == 3) { 851 /* 852 * For a Peripheral qualifier 3 (011b), the SCSI 853 * spec says: The device server is not capable of 854 * supporting a physical device on this logical 855 * unit. 856 * 857 * For disks, this implies that there is no 858 * logical disk configured at sdev->lun, but there 859 * is a target id responding. 860 */ 861 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO 862 "scsi scan: peripheral qualifier of 3," 863 " no device added\n")); 864 res = SCSI_SCAN_TARGET_PRESENT; 865 goto out_free_result; 866 } 867 868 res = scsi_add_lun(sdev, result, &bflags); 869 if (res == SCSI_SCAN_LUN_PRESENT) { 870 if (bflags & BLIST_KEY) { 871 sdev->lockable = 0; 872 scsi_unlock_floptical(sdev, result); 873 } 874 if (bflagsp) 875 *bflagsp = bflags; 876 } 877 878 out_free_result: 879 kfree(result); 880 out_free_sdev: 881 if (res == SCSI_SCAN_LUN_PRESENT) { 882 if (sdevp) { 883 if (scsi_device_get(sdev) == 0) { 884 *sdevp = sdev; 885 } else { 886 __scsi_remove_device(sdev); 887 res = SCSI_SCAN_NO_RESPONSE; 888 } 889 } 890 } else 891 scsi_destroy_sdev(sdev); 892 out: 893 return res; 894 } 895 896 /** 897 * scsi_sequential_lun_scan - sequentially scan a SCSI target 898 * @starget: pointer to target structure to scan 899 * @bflags: black/white list flag for LUN 0 900 * @lun0_res: result of scanning LUN 0 901 * 902 * Description: 903 * Generally, scan from LUN 1 (LUN 0 is assumed to already have been 904 * scanned) to some maximum lun until a LUN is found with no device 905 * attached. Use the bflags to figure out any oddities. 906 * 907 * Modifies sdevscan->lun. 908 **/ 909 static void scsi_sequential_lun_scan(struct scsi_target *starget, 910 int bflags, int lun0_res, int scsi_level, 911 int rescan) 912 { 913 unsigned int sparse_lun, lun, max_dev_lun; 914 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 915 916 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of" 917 "%s\n", starget->dev.bus_id)); 918 919 max_dev_lun = min(max_scsi_luns, shost->max_lun); 920 /* 921 * If this device is known to support sparse multiple units, 922 * override the other settings, and scan all of them. Normally, 923 * SCSI-3 devices should be scanned via the REPORT LUNS. 924 */ 925 if (bflags & BLIST_SPARSELUN) { 926 max_dev_lun = shost->max_lun; 927 sparse_lun = 1; 928 } else 929 sparse_lun = 0; 930 931 /* 932 * If not sparse lun and no device attached at LUN 0 do not scan 933 * any further. 934 */ 935 if (!sparse_lun && (lun0_res != SCSI_SCAN_LUN_PRESENT)) 936 return; 937 938 /* 939 * If less than SCSI_1_CSS, and no special lun scaning, stop 940 * scanning; this matches 2.4 behaviour, but could just be a bug 941 * (to continue scanning a SCSI_1_CSS device). 942 * 943 * This test is broken. We might not have any device on lun0 for 944 * a sparselun device, and if that's the case then how would we 945 * know the real scsi_level, eh? It might make sense to just not 946 * scan any SCSI_1 device for non-0 luns, but that check would best 947 * go into scsi_alloc_sdev() and just have it return null when asked 948 * to alloc an sdev for lun > 0 on an already found SCSI_1 device. 949 * 950 if ((sdevscan->scsi_level < SCSI_1_CCS) && 951 ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN)) 952 == 0)) 953 return; 954 */ 955 /* 956 * If this device is known to support multiple units, override 957 * the other settings, and scan all of them. 958 */ 959 if (bflags & BLIST_FORCELUN) 960 max_dev_lun = shost->max_lun; 961 /* 962 * REGAL CDC-4X: avoid hang after LUN 4 963 */ 964 if (bflags & BLIST_MAX5LUN) 965 max_dev_lun = min(5U, max_dev_lun); 966 /* 967 * Do not scan SCSI-2 or lower device past LUN 7, unless 968 * BLIST_LARGELUN. 969 */ 970 if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN)) 971 max_dev_lun = min(8U, max_dev_lun); 972 973 /* 974 * We have already scanned LUN 0, so start at LUN 1. Keep scanning 975 * until we reach the max, or no LUN is found and we are not 976 * sparse_lun. 977 */ 978 for (lun = 1; lun < max_dev_lun; ++lun) 979 if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, 980 NULL) != SCSI_SCAN_LUN_PRESENT) && 981 !sparse_lun) 982 return; 983 } 984 985 /** 986 * scsilun_to_int: convert a scsi_lun to an int 987 * @scsilun: struct scsi_lun to be converted. 988 * 989 * Description: 990 * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered 991 * integer, and return the result. The caller must check for 992 * truncation before using this function. 993 * 994 * Notes: 995 * The struct scsi_lun is assumed to be four levels, with each level 996 * effectively containing a SCSI byte-ordered (big endian) short; the 997 * addressing bits of each level are ignored (the highest two bits). 998 * For a description of the LUN format, post SCSI-3 see the SCSI 999 * Architecture Model, for SCSI-3 see the SCSI Controller Commands. 1000 * 1001 * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns 1002 * the integer: 0x0b030a04 1003 **/ 1004 static int scsilun_to_int(struct scsi_lun *scsilun) 1005 { 1006 int i; 1007 unsigned int lun; 1008 1009 lun = 0; 1010 for (i = 0; i < sizeof(lun); i += 2) 1011 lun = lun | (((scsilun->scsi_lun[i] << 8) | 1012 scsilun->scsi_lun[i + 1]) << (i * 8)); 1013 return lun; 1014 } 1015 1016 /** 1017 * int_to_scsilun: reverts an int into a scsi_lun 1018 * @int: integer to be reverted 1019 * @scsilun: struct scsi_lun to be set. 1020 * 1021 * Description: 1022 * Reverts the functionality of the scsilun_to_int, which packed 1023 * an 8-byte lun value into an int. This routine unpacks the int 1024 * back into the lun value. 1025 * Note: the scsilun_to_int() routine does not truly handle all 1026 * 8bytes of the lun value. This functions restores only as much 1027 * as was set by the routine. 1028 * 1029 * Notes: 1030 * Given an integer : 0x0b030a04, this function returns a 1031 * scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00 1032 * 1033 **/ 1034 void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun) 1035 { 1036 int i; 1037 1038 memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun)); 1039 1040 for (i = 0; i < sizeof(lun); i += 2) { 1041 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF; 1042 scsilun->scsi_lun[i+1] = lun & 0xFF; 1043 lun = lun >> 16; 1044 } 1045 } 1046 EXPORT_SYMBOL(int_to_scsilun); 1047 1048 /** 1049 * scsi_report_lun_scan - Scan using SCSI REPORT LUN results 1050 * @sdevscan: scan the host, channel, and id of this Scsi_Device 1051 * 1052 * Description: 1053 * If @sdevscan is for a SCSI-3 or up device, send a REPORT LUN 1054 * command, and scan the resulting list of LUNs by calling 1055 * scsi_probe_and_add_lun. 1056 * 1057 * Modifies sdevscan->lun. 1058 * 1059 * Return: 1060 * 0: scan completed (or no memory, so further scanning is futile) 1061 * 1: no report lun scan, or not configured 1062 **/ 1063 static int scsi_report_lun_scan(struct scsi_target *starget, int bflags, 1064 int rescan) 1065 { 1066 char devname[64]; 1067 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 1068 unsigned int length; 1069 unsigned int lun; 1070 unsigned int num_luns; 1071 unsigned int retries; 1072 int result; 1073 struct scsi_lun *lunp, *lun_data; 1074 u8 *data; 1075 struct scsi_sense_hdr sshdr; 1076 struct scsi_device *sdev; 1077 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1078 1079 /* 1080 * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set. 1081 * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does 1082 * support more than 8 LUNs. 1083 */ 1084 if ((bflags & BLIST_NOREPORTLUN) || 1085 starget->scsi_level < SCSI_2 || 1086 (starget->scsi_level < SCSI_3 && 1087 (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8)) ) 1088 return 1; 1089 if (bflags & BLIST_NOLUN) 1090 return 0; 1091 1092 if (!(sdev = scsi_device_lookup_by_target(starget, 0))) { 1093 sdev = scsi_alloc_sdev(starget, 0, NULL); 1094 if (!sdev) 1095 return 0; 1096 if (scsi_device_get(sdev)) 1097 return 0; 1098 } 1099 1100 sprintf(devname, "host %d channel %d id %d", 1101 shost->host_no, sdev->channel, sdev->id); 1102 1103 /* 1104 * Allocate enough to hold the header (the same size as one scsi_lun) 1105 * plus the max number of luns we are requesting. 1106 * 1107 * Reallocating and trying again (with the exact amount we need) 1108 * would be nice, but then we need to somehow limit the size 1109 * allocated based on the available memory and the limits of 1110 * kmalloc - we don't want a kmalloc() failure of a huge value to 1111 * prevent us from finding any LUNs on this target. 1112 */ 1113 length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun); 1114 lun_data = kmalloc(length, GFP_ATOMIC | 1115 (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0)); 1116 if (!lun_data) { 1117 printk(ALLOC_FAILURE_MSG, __FUNCTION__); 1118 goto out; 1119 } 1120 1121 scsi_cmd[0] = REPORT_LUNS; 1122 1123 /* 1124 * bytes 1 - 5: reserved, set to zero. 1125 */ 1126 memset(&scsi_cmd[1], 0, 5); 1127 1128 /* 1129 * bytes 6 - 9: length of the command. 1130 */ 1131 scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff; 1132 scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff; 1133 scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff; 1134 scsi_cmd[9] = (unsigned char) length & 0xff; 1135 1136 scsi_cmd[10] = 0; /* reserved */ 1137 scsi_cmd[11] = 0; /* control */ 1138 1139 /* 1140 * We can get a UNIT ATTENTION, for example a power on/reset, so 1141 * retry a few times (like sd.c does for TEST UNIT READY). 1142 * Experience shows some combinations of adapter/devices get at 1143 * least two power on/resets. 1144 * 1145 * Illegal requests (for devices that do not support REPORT LUNS) 1146 * should come through as a check condition, and will not generate 1147 * a retry. 1148 */ 1149 for (retries = 0; retries < 3; retries++) { 1150 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending" 1151 " REPORT LUNS to %s (try %d)\n", devname, 1152 retries)); 1153 1154 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, 1155 lun_data, length, &sshdr, 1156 SCSI_TIMEOUT + 4 * HZ, 3); 1157 1158 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS" 1159 " %s (try %d) result 0x%x\n", result 1160 ? "failed" : "successful", retries, result)); 1161 if (result == 0) 1162 break; 1163 else if (scsi_sense_valid(&sshdr)) { 1164 if (sshdr.sense_key != UNIT_ATTENTION) 1165 break; 1166 } 1167 } 1168 1169 if (result) { 1170 /* 1171 * The device probably does not support a REPORT LUN command 1172 */ 1173 kfree(lun_data); 1174 return 1; 1175 } 1176 1177 /* 1178 * Get the length from the first four bytes of lun_data. 1179 */ 1180 data = (u8 *) lun_data->scsi_lun; 1181 length = ((data[0] << 24) | (data[1] << 16) | 1182 (data[2] << 8) | (data[3] << 0)); 1183 1184 num_luns = (length / sizeof(struct scsi_lun)); 1185 if (num_luns > max_scsi_report_luns) { 1186 printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)" 1187 " of %d luns reported, try increasing" 1188 " max_scsi_report_luns.\n", devname, 1189 max_scsi_report_luns, num_luns); 1190 num_luns = max_scsi_report_luns; 1191 } 1192 1193 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUN scan of" 1194 " host %d channel %d id %d\n", sdev->host->host_no, 1195 sdev->channel, sdev->id)); 1196 1197 /* 1198 * Scan the luns in lun_data. The entry at offset 0 is really 1199 * the header, so start at 1 and go up to and including num_luns. 1200 */ 1201 for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) { 1202 lun = scsilun_to_int(lunp); 1203 1204 /* 1205 * Check if the unused part of lunp is non-zero, and so 1206 * does not fit in lun. 1207 */ 1208 if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) { 1209 int i; 1210 1211 /* 1212 * Output an error displaying the LUN in byte order, 1213 * this differs from what linux would print for the 1214 * integer LUN value. 1215 */ 1216 printk(KERN_WARNING "scsi: %s lun 0x", devname); 1217 data = (char *)lunp->scsi_lun; 1218 for (i = 0; i < sizeof(struct scsi_lun); i++) 1219 printk("%02x", data[i]); 1220 printk(" has a LUN larger than currently supported.\n"); 1221 } else if (lun > sdev->host->max_lun) { 1222 printk(KERN_WARNING "scsi: %s lun%d has a LUN larger" 1223 " than allowed by the host adapter\n", 1224 devname, lun); 1225 } else { 1226 int res; 1227 1228 res = scsi_probe_and_add_lun(starget, 1229 lun, NULL, NULL, rescan, NULL); 1230 if (res == SCSI_SCAN_NO_RESPONSE) { 1231 /* 1232 * Got some results, but now none, abort. 1233 */ 1234 printk(KERN_ERR "scsi: Unexpected response" 1235 " from %s lun %d while scanning, scan" 1236 " aborted\n", devname, lun); 1237 break; 1238 } 1239 } 1240 } 1241 1242 kfree(lun_data); 1243 out: 1244 scsi_device_put(sdev); 1245 if (sdev->sdev_state == SDEV_CREATED) 1246 /* 1247 * the sdev we used didn't appear in the report luns scan 1248 */ 1249 scsi_destroy_sdev(sdev); 1250 return 0; 1251 } 1252 1253 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel, 1254 uint id, uint lun, void *hostdata) 1255 { 1256 struct scsi_device *sdev; 1257 struct device *parent = &shost->shost_gendev; 1258 int res; 1259 struct scsi_target *starget = scsi_alloc_target(parent, channel, id); 1260 1261 if (!starget) 1262 return ERR_PTR(-ENOMEM); 1263 1264 get_device(&starget->dev); 1265 down(&shost->scan_mutex); 1266 if (scsi_host_scan_allowed(shost)) { 1267 res = scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, 1268 hostdata); 1269 if (res != SCSI_SCAN_LUN_PRESENT) 1270 sdev = ERR_PTR(-ENODEV); 1271 } 1272 up(&shost->scan_mutex); 1273 scsi_target_reap(starget); 1274 put_device(&starget->dev); 1275 1276 return sdev; 1277 } 1278 EXPORT_SYMBOL(__scsi_add_device); 1279 1280 int scsi_add_device(struct Scsi_Host *host, uint channel, 1281 uint target, uint lun) 1282 { 1283 struct scsi_device *sdev = 1284 __scsi_add_device(host, channel, target, lun, NULL); 1285 if (IS_ERR(sdev)) 1286 return PTR_ERR(sdev); 1287 1288 scsi_device_put(sdev); 1289 return 0; 1290 } 1291 EXPORT_SYMBOL(scsi_add_device); 1292 1293 void scsi_rescan_device(struct device *dev) 1294 { 1295 struct scsi_driver *drv; 1296 1297 if (!dev->driver) 1298 return; 1299 1300 drv = to_scsi_driver(dev->driver); 1301 if (try_module_get(drv->owner)) { 1302 if (drv->rescan) 1303 drv->rescan(dev); 1304 module_put(drv->owner); 1305 } 1306 } 1307 EXPORT_SYMBOL(scsi_rescan_device); 1308 1309 static void __scsi_scan_target(struct device *parent, unsigned int channel, 1310 unsigned int id, unsigned int lun, int rescan) 1311 { 1312 struct Scsi_Host *shost = dev_to_shost(parent); 1313 int bflags = 0; 1314 int res; 1315 struct scsi_target *starget; 1316 1317 if (shost->this_id == id) 1318 /* 1319 * Don't scan the host adapter 1320 */ 1321 return; 1322 1323 starget = scsi_alloc_target(parent, channel, id); 1324 if (!starget) 1325 return; 1326 1327 get_device(&starget->dev); 1328 if (lun != SCAN_WILD_CARD) { 1329 /* 1330 * Scan for a specific host/chan/id/lun. 1331 */ 1332 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL); 1333 goto out_reap; 1334 } 1335 1336 /* 1337 * Scan LUN 0, if there is some response, scan further. Ideally, we 1338 * would not configure LUN 0 until all LUNs are scanned. 1339 */ 1340 res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL); 1341 if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) { 1342 if (scsi_report_lun_scan(starget, bflags, rescan) != 0) 1343 /* 1344 * The REPORT LUN did not scan the target, 1345 * do a sequential scan. 1346 */ 1347 scsi_sequential_lun_scan(starget, bflags, 1348 res, starget->scsi_level, rescan); 1349 } 1350 1351 out_reap: 1352 /* now determine if the target has any children at all 1353 * and if not, nuke it */ 1354 scsi_target_reap(starget); 1355 1356 put_device(&starget->dev); 1357 } 1358 1359 /** 1360 * scsi_scan_target - scan a target id, possibly including all LUNs on the 1361 * target. 1362 * @parent: host to scan 1363 * @channel: channel to scan 1364 * @id: target id to scan 1365 * @lun: Specific LUN to scan or SCAN_WILD_CARD 1366 * @rescan: passed to LUN scanning routines 1367 * 1368 * Description: 1369 * Scan the target id on @parent, @channel, and @id. Scan at least LUN 0, 1370 * and possibly all LUNs on the target id. 1371 * 1372 * First try a REPORT LUN scan, if that does not scan the target, do a 1373 * sequential scan of LUNs on the target id. 1374 **/ 1375 void scsi_scan_target(struct device *parent, unsigned int channel, 1376 unsigned int id, unsigned int lun, int rescan) 1377 { 1378 struct Scsi_Host *shost = dev_to_shost(parent); 1379 1380 down(&shost->scan_mutex); 1381 if (scsi_host_scan_allowed(shost)) 1382 __scsi_scan_target(parent, channel, id, lun, rescan); 1383 up(&shost->scan_mutex); 1384 } 1385 EXPORT_SYMBOL(scsi_scan_target); 1386 1387 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel, 1388 unsigned int id, unsigned int lun, int rescan) 1389 { 1390 uint order_id; 1391 1392 if (id == SCAN_WILD_CARD) 1393 for (id = 0; id < shost->max_id; ++id) { 1394 /* 1395 * XXX adapter drivers when possible (FCP, iSCSI) 1396 * could modify max_id to match the current max, 1397 * not the absolute max. 1398 * 1399 * XXX add a shost id iterator, so for example, 1400 * the FC ID can be the same as a target id 1401 * without a huge overhead of sparse id's. 1402 */ 1403 if (shost->reverse_ordering) 1404 /* 1405 * Scan from high to low id. 1406 */ 1407 order_id = shost->max_id - id - 1; 1408 else 1409 order_id = id; 1410 __scsi_scan_target(&shost->shost_gendev, channel, 1411 order_id, lun, rescan); 1412 } 1413 else 1414 __scsi_scan_target(&shost->shost_gendev, channel, 1415 id, lun, rescan); 1416 } 1417 1418 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel, 1419 unsigned int id, unsigned int lun, int rescan) 1420 { 1421 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "%s: <%u:%u:%u:%u>\n", 1422 __FUNCTION__, shost->host_no, channel, id, lun)); 1423 1424 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) || 1425 ((id != SCAN_WILD_CARD) && (id > shost->max_id)) || 1426 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun))) 1427 return -EINVAL; 1428 1429 down(&shost->scan_mutex); 1430 if (scsi_host_scan_allowed(shost)) { 1431 if (channel == SCAN_WILD_CARD) 1432 for (channel = 0; channel <= shost->max_channel; 1433 channel++) 1434 scsi_scan_channel(shost, channel, id, lun, 1435 rescan); 1436 else 1437 scsi_scan_channel(shost, channel, id, lun, rescan); 1438 } 1439 up(&shost->scan_mutex); 1440 1441 return 0; 1442 } 1443 1444 /** 1445 * scsi_scan_host - scan the given adapter 1446 * @shost: adapter to scan 1447 **/ 1448 void scsi_scan_host(struct Scsi_Host *shost) 1449 { 1450 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD, 1451 SCAN_WILD_CARD, 0); 1452 } 1453 EXPORT_SYMBOL(scsi_scan_host); 1454 1455 /** 1456 * scsi_scan_single_target - scan the given SCSI target 1457 * @shost: adapter to scan 1458 * @chan: channel to scan 1459 * @id: target id to scan 1460 **/ 1461 void scsi_scan_single_target(struct Scsi_Host *shost, 1462 unsigned int chan, unsigned int id) 1463 { 1464 scsi_scan_host_selected(shost, chan, id, SCAN_WILD_CARD, 1); 1465 } 1466 EXPORT_SYMBOL(scsi_scan_single_target); 1467 1468 void scsi_forget_host(struct Scsi_Host *shost) 1469 { 1470 struct scsi_device *sdev; 1471 unsigned long flags; 1472 1473 restart: 1474 spin_lock_irqsave(shost->host_lock, flags); 1475 list_for_each_entry(sdev, &shost->__devices, siblings) { 1476 if (sdev->sdev_state == SDEV_DEL) 1477 continue; 1478 spin_unlock_irqrestore(shost->host_lock, flags); 1479 __scsi_remove_device(sdev); 1480 goto restart; 1481 } 1482 spin_unlock_irqrestore(shost->host_lock, flags); 1483 } 1484 1485 /* 1486 * Function: scsi_get_host_dev() 1487 * 1488 * Purpose: Create a Scsi_Device that points to the host adapter itself. 1489 * 1490 * Arguments: SHpnt - Host that needs a Scsi_Device 1491 * 1492 * Lock status: None assumed. 1493 * 1494 * Returns: The Scsi_Device or NULL 1495 * 1496 * Notes: 1497 * Attach a single Scsi_Device to the Scsi_Host - this should 1498 * be made to look like a "pseudo-device" that points to the 1499 * HA itself. 1500 * 1501 * Note - this device is not accessible from any high-level 1502 * drivers (including generics), which is probably not 1503 * optimal. We can add hooks later to attach 1504 */ 1505 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost) 1506 { 1507 struct scsi_device *sdev = NULL; 1508 struct scsi_target *starget; 1509 1510 down(&shost->scan_mutex); 1511 if (!scsi_host_scan_allowed(shost)) 1512 goto out; 1513 starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id); 1514 if (!starget) 1515 goto out; 1516 1517 sdev = scsi_alloc_sdev(starget, 0, NULL); 1518 if (sdev) { 1519 sdev->sdev_gendev.parent = get_device(&starget->dev); 1520 sdev->borken = 0; 1521 } 1522 put_device(&starget->dev); 1523 out: 1524 up(&shost->scan_mutex); 1525 return sdev; 1526 } 1527 EXPORT_SYMBOL(scsi_get_host_dev); 1528 1529 /* 1530 * Function: scsi_free_host_dev() 1531 * 1532 * Purpose: Free a scsi_device that points to the host adapter itself. 1533 * 1534 * Arguments: SHpnt - Host that needs a Scsi_Device 1535 * 1536 * Lock status: None assumed. 1537 * 1538 * Returns: Nothing 1539 * 1540 * Notes: 1541 */ 1542 void scsi_free_host_dev(struct scsi_device *sdev) 1543 { 1544 BUG_ON(sdev->id != sdev->host->this_id); 1545 1546 scsi_destroy_sdev(sdev); 1547 } 1548 EXPORT_SYMBOL(scsi_free_host_dev); 1549 1550