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