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