scsi_scan.c 55.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11
/*
 * scsi_scan.c
 *
 * Copyright (C) 2000 Eric Youngdale,
 * Copyright (C) 2002 Patrick Mansfield
 *
 * The general scanning/probing algorithm is as follows, exceptions are
 * made to it depending on device specific flags, compilation options, and
 * global variable (boot or module load time) settings.
 *
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15 16 17 18 19
 *
 * For every id of every channel on the given host:
 *
 * 	Scan LUN 0; if the target responds to LUN 0 (even if there is no
 * 	device or storage attached to LUN 0):
 *
 * 		If LUN 0 has a device attached, allocate and setup a
20
 * 		scsi_device for it.
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26 27 28 29 30 31
 *
 * 		If target is SCSI-3 or up, issue a REPORT LUN, and scan
 * 		all of the LUNs returned by the REPORT LUN; else,
 * 		sequentially scan LUNs up until some maximum is reached,
 * 		or a LUN is seen that cannot have a device attached to it.
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/blkdev.h>
32 33 34
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/spinlock.h>
35
#include <linux/async.h>
36
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
37 38

#include <scsi/scsi.h>
39
#include <scsi/scsi_cmnd.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
#include <scsi/scsi_device.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_devinfo.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_eh.h>

#include "scsi_priv.h"
#include "scsi_logging.h"

#define ALLOC_FAILURE_MSG	KERN_ERR "%s: Allocation failure during" \
	" SCSI scanning, some SCSI devices might not be configured\n"

/*
 * Default timeout
 */
#define SCSI_TIMEOUT (2*HZ)

/*
59
 * Prefix values for the SCSI id's (stored in sysfs name field)
Linus Torvalds's avatar
Linus Torvalds committed
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
 */
#define SCSI_UID_SER_NUM 'S'
#define SCSI_UID_UNKNOWN 'Z'

/*
 * Return values of some of the scanning functions.
 *
 * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
 * includes allocation or general failures preventing IO from being sent.
 *
 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
 * on the given LUN.
 *
 * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
 * given LUN.
 */
#define SCSI_SCAN_NO_RESPONSE		0
#define SCSI_SCAN_TARGET_PRESENT	1
#define SCSI_SCAN_LUN_PRESENT		2

80
static const char *scsi_null_device_strs = "nullnullnullnull";
Linus Torvalds's avatar
Linus Torvalds committed
81 82 83 84 85 86 87 88 89

#define MAX_SCSI_LUNS	512

#ifdef CONFIG_SCSI_MULTI_LUN
static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
#else
static unsigned int max_scsi_luns = 1;
#endif

90
module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93
MODULE_PARM_DESC(max_luns,
		 "last scsi LUN (should be between 1 and 2^32-1)");

94 95 96 97 98 99 100
#ifdef CONFIG_SCSI_SCAN_ASYNC
#define SCSI_SCAN_TYPE_DEFAULT "async"
#else
#define SCSI_SCAN_TYPE_DEFAULT "sync"
#endif

static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
101 102 103 104

module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
MODULE_PARM_DESC(scan, "sync, async or none");

Linus Torvalds's avatar
Linus Torvalds committed
105 106 107 108 109 110 111 112 113
/*
 * max_scsi_report_luns: the maximum number of LUNS that will be
 * returned from the REPORT LUNS command. 8 times this value must
 * be allocated. In theory this could be up to an 8 byte value, but
 * in practice, the maximum number of LUNs suppored by any device
 * is about 16k.
 */
static unsigned int max_scsi_report_luns = 511;

114
module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
Linus Torvalds's avatar
Linus Torvalds committed
115 116 117 118
MODULE_PARM_DESC(max_report_luns,
		 "REPORT LUNS maximum number of LUNS received (should be"
		 " between 1 and 16384)");

119
static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
Linus Torvalds's avatar
Linus Torvalds committed
120

121
module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
Linus Torvalds's avatar
Linus Torvalds committed
122 123
MODULE_PARM_DESC(inq_timeout, 
		 "Timeout (in seconds) waiting for devices to answer INQUIRY."
124
		 " Default is 20. Some devices may need more; most need less.");
Linus Torvalds's avatar
Linus Torvalds committed
125

126
/* This lock protects only this list */
127 128 129 130 131 132 133 134 135 136 137 138
static DEFINE_SPINLOCK(async_scan_lock);
static LIST_HEAD(scanning_hosts);

struct async_scan_data {
	struct list_head list;
	struct Scsi_Host *shost;
	struct completion prev_finished;
};

/**
 * scsi_complete_async_scans - Wait for asynchronous scans to complete
 *
139 140 141 142
 * When this function returns, any host which started scanning before
 * this function was called will have finished its scan.  Hosts which
 * started scanning after this function was called may or may not have
 * finished.
143 144 145 146 147 148 149
 */
int scsi_complete_async_scans(void)
{
	struct async_scan_data *data;

	do {
		if (list_empty(&scanning_hosts))
150
			return 0;
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
		/* If we can't get memory immediately, that's OK.  Just
		 * sleep a little.  Even if we never get memory, the async
		 * scans will finish eventually.
		 */
		data = kmalloc(sizeof(*data), GFP_KERNEL);
		if (!data)
			msleep(1);
	} while (!data);

	data->shost = NULL;
	init_completion(&data->prev_finished);

	spin_lock(&async_scan_lock);
	/* Check that there's still somebody else on the list */
	if (list_empty(&scanning_hosts))
		goto done;
	list_add_tail(&data->list, &scanning_hosts);
	spin_unlock(&async_scan_lock);

	printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
	wait_for_completion(&data->prev_finished);

	spin_lock(&async_scan_lock);
	list_del(&data->list);
175 176 177 178 179
	if (!list_empty(&scanning_hosts)) {
		struct async_scan_data *next = list_entry(scanning_hosts.next,
				struct async_scan_data, list);
		complete(&next->prev_finished);
	}
180 181
 done:
	spin_unlock(&async_scan_lock);
182

183
	kfree(data);
184 185 186
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
187 188
/**
 * scsi_unlock_floptical - unlock device via a special MODE SENSE command
189
 * @sdev:	scsi device to send command to
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192
 * @result:	area to store the result of the MODE SENSE
 *
 * Description:
193
 *     Send a vendor specific MODE SENSE (not a MODE SELECT) command.
Linus Torvalds's avatar
Linus Torvalds committed
194 195
 *     Called for BLIST_KEY devices.
 **/
196
static void scsi_unlock_floptical(struct scsi_device *sdev,
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205
				  unsigned char *result)
{
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];

	printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
	scsi_cmd[0] = MODE_SENSE;
	scsi_cmd[1] = 0;
	scsi_cmd[2] = 0x2e;
	scsi_cmd[3] = 0;
206
	scsi_cmd[4] = 0x2a;     /* size */
Linus Torvalds's avatar
Linus Torvalds committed
207
	scsi_cmd[5] = 0;
208
	scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
209
			 SCSI_TIMEOUT, 3, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213
}

/**
 * scsi_alloc_sdev - allocate and setup a scsi_Device
214 215 216
 * @starget: which target to allocate a &scsi_device for
 * @lun: which lun
 * @hostdata: usually NULL and set by ->slave_alloc instead
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
 *
 * Description:
 *     Allocate, initialize for io, and return a pointer to a scsi_Device.
 *     Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
 *     adds scsi_Device to the appropriate list.
 *
 * Return value:
 *     scsi_Device pointer, or NULL on failure.
 **/
static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
					   unsigned int lun, void *hostdata)
{
	struct scsi_device *sdev;
	int display_failure_msg = 1, ret;
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
232
	extern void scsi_evt_thread(struct work_struct *work);
233
	extern void scsi_requeue_run_queue(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
234

235
	sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239 240 241 242 243
		       GFP_ATOMIC);
	if (!sdev)
		goto out;

	sdev->vendor = scsi_null_device_strs;
	sdev->model = scsi_null_device_strs;
	sdev->rev = scsi_null_device_strs;
	sdev->host = shost;
244
	sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
Linus Torvalds's avatar
Linus Torvalds committed
245 246 247 248 249 250 251 252
	sdev->id = starget->id;
	sdev->lun = lun;
	sdev->channel = starget->channel;
	sdev->sdev_state = SDEV_CREATED;
	INIT_LIST_HEAD(&sdev->siblings);
	INIT_LIST_HEAD(&sdev->same_target_siblings);
	INIT_LIST_HEAD(&sdev->cmd_list);
	INIT_LIST_HEAD(&sdev->starved_entry);
253
	INIT_LIST_HEAD(&sdev->event_list);
Linus Torvalds's avatar
Linus Torvalds committed
254
	spin_lock_init(&sdev->list_lock);
255
	INIT_WORK(&sdev->event_work, scsi_evt_thread);
256
	INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
Linus Torvalds's avatar
Linus Torvalds committed
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284

	sdev->sdev_gendev.parent = get_device(&starget->dev);
	sdev->sdev_target = starget;

	/* usually NULL and set by ->slave_alloc instead */
	sdev->hostdata = hostdata;

	/* if the device needs this changing, it may do so in the
	 * slave_configure function */
	sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;

	/*
	 * Some low level driver could use device->type
	 */
	sdev->type = -1;

	/*
	 * Assume that the device will have handshaking problems,
	 * and then fix this field later if it turns out it
	 * doesn't
	 */
	sdev->borken = 1;

	sdev->request_queue = scsi_alloc_queue(sdev);
	if (!sdev->request_queue) {
		/* release fn is set up in scsi_sysfs_device_initialise, so
		 * have to free and put manually here */
		put_device(&starget->dev);
285
		kfree(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
286 287
		goto out;
	}
288
	WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));
Linus Torvalds's avatar
Linus Torvalds committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
	sdev->request_queue->queuedata = sdev;
	scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);

	scsi_sysfs_device_initialize(sdev);

	if (shost->hostt->slave_alloc) {
		ret = shost->hostt->slave_alloc(sdev);
		if (ret) {
			/*
			 * if LLDD reports slave not present, don't clutter
			 * console with alloc failure messages
			 */
			if (ret == -ENXIO)
				display_failure_msg = 0;
			goto out_device_destroy;
		}
	}

	return sdev;

out_device_destroy:
310
	__scsi_remove_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
311 312
out:
	if (display_failure_msg)
313
		printk(ALLOC_FAILURE_MSG, __func__);
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316
	return NULL;
}

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
static void scsi_target_destroy(struct scsi_target *starget)
{
	struct device *dev = &starget->dev;
	struct Scsi_Host *shost = dev_to_shost(dev->parent);
	unsigned long flags;

	transport_destroy_device(dev);
	spin_lock_irqsave(shost->host_lock, flags);
	if (shost->hostt->target_destroy)
		shost->hostt->target_destroy(starget);
	list_del_init(&starget->siblings);
	spin_unlock_irqrestore(shost->host_lock, flags);
	put_device(dev);
}

Linus Torvalds's avatar
Linus Torvalds committed
332 333 334 335
static void scsi_target_dev_release(struct device *dev)
{
	struct device *parent = dev->parent;
	struct scsi_target *starget = to_scsi_target(dev);
336

Linus Torvalds's avatar
Linus Torvalds committed
337 338 339 340
	kfree(starget);
	put_device(parent);
}

341
static struct device_type scsi_target_type = {
342 343 344 345
	.name =		"scsi_target",
	.release =	scsi_target_dev_release,
};

Linus Torvalds's avatar
Linus Torvalds committed
346 347
int scsi_is_target_device(const struct device *dev)
{
348
	return dev->type == &scsi_target_type;
Linus Torvalds's avatar
Linus Torvalds committed
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
}
EXPORT_SYMBOL(scsi_is_target_device);

static struct scsi_target *__scsi_find_target(struct device *parent,
					      int channel, uint id)
{
	struct scsi_target *starget, *found_starget = NULL;
	struct Scsi_Host *shost = dev_to_shost(parent);
	/*
	 * Search for an existing target for this sdev.
	 */
	list_for_each_entry(starget, &shost->__targets, siblings) {
		if (starget->id == id &&
		    starget->channel == channel) {
			found_starget = starget;
			break;
		}
	}
	if (found_starget)
		get_device(&found_starget->dev);

	return found_starget;
}

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
/**
 * scsi_target_reap_ref_release - remove target from visibility
 * @kref: the reap_ref in the target being released
 *
 * Called on last put of reap_ref, which is the indication that no device
 * under this target is visible anymore, so render the target invisible in
 * sysfs.  Note: we have to be in user context here because the target reaps
 * should be done in places where the scsi device visibility is being removed.
 */
static void scsi_target_reap_ref_release(struct kref *kref)
{
	struct scsi_target *starget
		= container_of(kref, struct scsi_target, reap_ref);

	transport_remove_device(&starget->dev);
	device_del(&starget->dev);
	starget->state = STARGET_DEL;
	scsi_target_destroy(starget);
}

static void scsi_target_reap_ref_put(struct scsi_target *starget)
{
	kref_put(&starget->reap_ref, scsi_target_reap_ref_release);
}

398 399 400 401 402 403 404 405 406 407 408 409
/**
 * scsi_alloc_target - allocate a new or find an existing target
 * @parent:	parent of the target (need not be a scsi host)
 * @channel:	target channel number (zero if no channels)
 * @id:		target id number
 *
 * Return an existing target if one exists, provided it hasn't already
 * gone into STARGET_DEL state, otherwise allocate a new target.
 *
 * The target is returned with an incremented reference, so the caller
 * is responsible for both reaping and doing a last put
 */
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415 416 417
static struct scsi_target *scsi_alloc_target(struct device *parent,
					     int channel, uint id)
{
	struct Scsi_Host *shost = dev_to_shost(parent);
	struct device *dev = NULL;
	unsigned long flags;
	const int size = sizeof(struct scsi_target)
		+ shost->transportt->target_size;
418
	struct scsi_target *starget;
Linus Torvalds's avatar
Linus Torvalds committed
419
	struct scsi_target *found_target;
420
	int error, ref_got;
Linus Torvalds's avatar
Linus Torvalds committed
421

422
	starget = kzalloc(size, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
423
	if (!starget) {
424
		printk(KERN_ERR "%s: allocation failure\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
425 426 427 428
		return NULL;
	}
	dev = &starget->dev;
	device_initialize(dev);
429
	kref_init(&starget->reap_ref);
Linus Torvalds's avatar
Linus Torvalds committed
430
	dev->parent = get_device(parent);
431
	dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
432 433
	dev->bus = &scsi_bus_type;
	dev->type = &scsi_target_type;
Linus Torvalds's avatar
Linus Torvalds committed
434 435
	starget->id = id;
	starget->channel = channel;
436
	starget->can_queue = 0;
Linus Torvalds's avatar
Linus Torvalds committed
437 438
	INIT_LIST_HEAD(&starget->siblings);
	INIT_LIST_HEAD(&starget->devices);
439
	starget->state = STARGET_CREATED;
440
	starget->scsi_level = SCSI_2;
441
	starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
442
 retry:
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445 446 447 448 449 450 451
	spin_lock_irqsave(shost->host_lock, flags);

	found_target = __scsi_find_target(parent, channel, id);
	if (found_target)
		goto found;

	list_add_tail(&starget->siblings, &shost->__targets);
	spin_unlock_irqrestore(shost->host_lock, flags);
	/* allocate and add */
452 453
	transport_setup_device(dev);
	if (shost->hostt->target_alloc) {
454
		error = shost->hostt->target_alloc(starget);
455 456 457 458 459

		if(error) {
			dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
			/* don't want scsi_target_reap to do the final
			 * put because it will be under the host lock */
460
			scsi_target_destroy(starget);
461 462 463
			return NULL;
		}
	}
464
	get_device(dev);
465

Linus Torvalds's avatar
Linus Torvalds committed
466 467 468
	return starget;

 found:
469 470 471 472 473 474 475
	/*
	 * release routine already fired if kref is zero, so if we can still
	 * take the reference, the target must be alive.  If we can't, it must
	 * be dying and we need to wait for a new target
	 */
	ref_got = kref_get_unless_zero(&found_target->reap_ref);

Linus Torvalds's avatar
Linus Torvalds committed
476
	spin_unlock_irqrestore(shost->host_lock, flags);
477
	if (ref_got) {
478
		put_device(dev);
479 480
		return found_target;
	}
481 482 483 484 485 486 487 488 489
	/*
	 * Unfortunately, we found a dying target; need to wait until it's
	 * dead before we can get a new one.  There is an anomaly here.  We
	 * *should* call scsi_target_reap() to balance the kref_get() of the
	 * reap_ref above.  However, since the target being released, it's
	 * already invisible and the reap_ref is irrelevant.  If we call
	 * scsi_target_reap() we might spuriously do another device_del() on
	 * an already invisible target.
	 */
490
	put_device(&found_target->dev);
491 492 493 494 495
	/*
	 * length of time is irrelevant here, we just want to yield the CPU
	 * for a tick to avoid busy waiting for the target to die.
	 */
	msleep(1);
496
	goto retry;
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499 500 501 502 503 504 505 506 507 508
}

/**
 * scsi_target_reap - check to see if target is in use and destroy if not
 * @starget: target to be checked
 *
 * This is used after removing a LUN or doing a last put of the target
 * it checks atomically that nothing is using the target and removes
 * it if so.
 */
void scsi_target_reap(struct scsi_target *starget)
{
509 510
	BUG_ON(starget->state == STARGET_DEL);
	if (starget->state == STARGET_CREATED)
511 512
		scsi_target_destroy(starget);
	else
513
		scsi_target_reap_ref_put(starget);
Linus Torvalds's avatar
Linus Torvalds committed
514 515
}

516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
/**
 * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string
 * @s: INQUIRY result string to sanitize
 * @len: length of the string
 *
 * Description:
 *	The SCSI spec says that INQUIRY vendor, product, and revision
 *	strings must consist entirely of graphic ASCII characters,
 *	padded on the right with spaces.  Since not all devices obey
 *	this rule, we will replace non-graphic or non-ASCII characters
 *	with spaces.  Exception: a NUL character is interpreted as a
 *	string terminator, so all the following characters are set to
 *	spaces.
 **/
static void sanitize_inquiry_string(unsigned char *s, int len)
{
	int terminated = 0;

	for (; len > 0; (--len, ++s)) {
		if (*s == 0)
			terminated = 1;
		if (terminated || *s < 0x20 || *s > 0x7e)
			*s = ' ';
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
542 543
/**
 * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
544
 * @sdev:	scsi_device to probe
Linus Torvalds's avatar
Linus Torvalds committed
545
 * @inq_result:	area to store the INQUIRY result
546
 * @result_len: len of inq_result
Linus Torvalds's avatar
Linus Torvalds committed
547 548 549
 * @bflags:	store any bflags found here
 *
 * Description:
550
 *     Probe the lun associated with @req using a standard SCSI INQUIRY;
Linus Torvalds's avatar
Linus Torvalds committed
551
 *
552
 *     If the INQUIRY is successful, zero is returned and the
Linus Torvalds's avatar
Linus Torvalds committed
553
 *     INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
554
 *     are copied to the scsi_device any flags value is stored in *@bflags.
Linus Torvalds's avatar
Linus Torvalds committed
555
 **/
556
static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
557
			  int result_len, int *bflags)
Linus Torvalds's avatar
Linus Torvalds committed
558 559 560 561
{
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
	int first_inquiry_len, try_inquiry_len, next_inquiry_len;
	int response_len = 0;
562
	int pass, count, result;
Linus Torvalds's avatar
Linus Torvalds committed
563 564 565 566 567 568 569 570 571 572 573 574
	struct scsi_sense_hdr sshdr;

	*bflags = 0;

	/* Perform up to 3 passes.  The first pass uses a conservative
	 * transfer length of 36 unless sdev->inquiry_len specifies a
	 * different value. */
	first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
	try_inquiry_len = first_inquiry_len;
	pass = 1;

 next_pass:
575 576 577
	SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
				"scsi scan: INQUIRY pass %d length %d\n",
				pass, try_inquiry_len));
Linus Torvalds's avatar
Linus Torvalds committed
578 579 580

	/* Each pass gets up to three chances to ignore Unit Attention */
	for (count = 0; count < 3; ++count) {
581 582
		int resid;

Linus Torvalds's avatar
Linus Torvalds committed
583 584 585 586 587
		memset(scsi_cmd, 0, 6);
		scsi_cmd[0] = INQUIRY;
		scsi_cmd[4] = (unsigned char) try_inquiry_len;

		memset(inq_result, 0, try_inquiry_len);
588 589

		result = scsi_execute_req(sdev,  scsi_cmd, DMA_FROM_DEVICE,
590
					  inq_result, try_inquiry_len, &sshdr,
591
					  HZ / 2 + HZ * scsi_inq_timeout, 3,
592
					  &resid);
Linus Torvalds's avatar
Linus Torvalds committed
593 594 595

		SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "
				"with code 0x%x\n",
596
				result ? "failed" : "successful", result));
Linus Torvalds's avatar
Linus Torvalds committed
597

598
		if (result) {
Linus Torvalds's avatar
Linus Torvalds committed
599 600 601 602 603 604
			/*
			 * not-ready to ready transition [asc/ascq=0x28/0x0]
			 * or power-on, reset [asc/ascq=0x29/0x0], continue.
			 * INQUIRY should not yield UNIT_ATTENTION
			 * but many buggy devices do so anyway. 
			 */
605
			if ((driver_byte(result) & DRIVER_SENSE) &&
606
			    scsi_sense_valid(&sshdr)) {
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609 610 611 612
				if ((sshdr.sense_key == UNIT_ATTENTION) &&
				    ((sshdr.asc == 0x28) ||
				     (sshdr.asc == 0x29)) &&
				    (sshdr.ascq == 0))
					continue;
			}
613 614 615 616 617 618 619 620
		} else {
			/*
			 * if nothing was transferred, we try
			 * again. It's a workaround for some USB
			 * devices.
			 */
			if (resid == try_inquiry_len)
				continue;
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624
		}
		break;
	}

625
	if (result == 0) {
626 627 628 629 630
		sanitize_inquiry_string(&inq_result[8], 8);
		sanitize_inquiry_string(&inq_result[16], 16);
		sanitize_inquiry_string(&inq_result[32], 4);

		response_len = inq_result[4] + 5;
Linus Torvalds's avatar
Linus Torvalds committed
631 632 633 634 635 636
		if (response_len > 255)
			response_len = first_inquiry_len;	/* sanity */

		/*
		 * Get any flags for this device.
		 *
637 638
		 * XXX add a bflags to scsi_device, and replace the
		 * corresponding bit fields in scsi_device, so bflags
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
		 * need not be passed as an argument.
		 */
		*bflags = scsi_get_device_flags(sdev, &inq_result[8],
				&inq_result[16]);

		/* When the first pass succeeds we gain information about
		 * what larger transfer lengths might work. */
		if (pass == 1) {
			if (BLIST_INQUIRY_36 & *bflags)
				next_inquiry_len = 36;
			else if (BLIST_INQUIRY_58 & *bflags)
				next_inquiry_len = 58;
			else if (sdev->inquiry_len)
				next_inquiry_len = sdev->inquiry_len;
			else
				next_inquiry_len = response_len;

			/* If more data is available perform the second pass */
			if (next_inquiry_len > try_inquiry_len) {
				try_inquiry_len = next_inquiry_len;
				pass = 2;
				goto next_pass;
			}
		}

	} else if (pass == 2) {
		printk(KERN_INFO "scsi scan: %d byte inquiry failed.  "
				"Consider BLIST_INQUIRY_36 for this device\n",
				try_inquiry_len);

		/* If this pass failed, the third pass goes back and transfers
		 * the same amount as we successfully got in the first pass. */
		try_inquiry_len = first_inquiry_len;
		pass = 3;
		goto next_pass;
	}

	/* If the last transfer attempt got an error, assume the
	 * peripheral doesn't exist or is dead. */
678 679
	if (result)
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
680 681 682 683 684 685 686 687 688 689 690 691 692

	/* Don't report any more data than the device says is valid */
	sdev->inquiry_len = min(try_inquiry_len, response_len);

	/*
	 * XXX Abort if the response length is less than 36? If less than
	 * 32, the lookup of the device flags (above) could be invalid,
	 * and it would be possible to take an incorrect action - we do
	 * not want to hang because of a short INQUIRY. On the flip side,
	 * if the device is spun down or becoming ready (and so it gives a
	 * short INQUIRY), an abort here prevents any further use of the
	 * device, including spin up.
	 *
693 694 695 696 697 698 699 700 701 702 703 704 705
	 * On the whole, the best approach seems to be to assume the first
	 * 36 bytes are valid no matter what the device says.  That's
	 * better than copying < 36 bytes to the inquiry-result buffer
	 * and displaying garbage for the Vendor, Product, or Revision
	 * strings.
	 */
	if (sdev->inquiry_len < 36) {
		printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
				" using 36\n", sdev->inquiry_len);
		sdev->inquiry_len = 36;
	}

	/*
Linus Torvalds's avatar
Linus Torvalds committed
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
	 * Related to the above issue:
	 *
	 * XXX Devices (disk or all?) should be sent a TEST UNIT READY,
	 * and if not ready, sent a START_STOP to start (maybe spin up) and
	 * then send the INQUIRY again, since the INQUIRY can change after
	 * a device is initialized.
	 *
	 * Ideally, start a device if explicitly asked to do so.  This
	 * assumes that a device is spun up on power on, spun down on
	 * request, and then spun up on request.
	 */

	/*
	 * The scanning code needs to know the scsi_level, even if no
	 * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
	 * non-zero LUNs can be scanned.
	 */
	sdev->scsi_level = inq_result[2] & 0x07;
	if (sdev->scsi_level >= 2 ||
	    (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
		sdev->scsi_level++;
727
	sdev->sdev_target->scsi_level = sdev->scsi_level;
Linus Torvalds's avatar
Linus Torvalds committed
728

729
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
730 731 732
}

/**
733
 * scsi_add_lun - allocate and fully initialze a scsi_device
734
 * @sdev:	holds information to be stored in the new scsi_device
Linus Torvalds's avatar
Linus Torvalds committed
735 736
 * @inq_result:	holds the result of a previous INQUIRY to the LUN
 * @bflags:	black/white list flag
737
 * @async:	1 if this device is being scanned asynchronously
Linus Torvalds's avatar
Linus Torvalds committed
738 739
 *
 * Description:
740 741
 *     Initialize the scsi_device @sdev.  Optionally set fields based
 *     on values in *@bflags.
Linus Torvalds's avatar
Linus Torvalds committed
742 743
 *
 * Return:
744 745
 *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
 *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
Linus Torvalds's avatar
Linus Torvalds committed
746
 **/
747
static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
748
		int *bflags, int async)
Linus Torvalds's avatar
Linus Torvalds committed
749
{
750 751
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
752 753 754 755 756 757 758 759 760 761
	/*
	 * XXX do not save the inquiry, since it can change underneath us,
	 * save just vendor/model/rev.
	 *
	 * Rather than save it and have an ioctl that retrieves the saved
	 * value, have an ioctl that executes the same INQUIRY code used
	 * in scsi_probe_lun, let user level programs doing INQUIRY
	 * scanning run at their own risk, or supply a user level program
	 * that can correctly scan.
	 */
762 763 764 765 766 767 768 769 770 771 772 773 774 775

	/*
	 * Copy at least 36 bytes of INQUIRY data, so that we don't
	 * dereference unallocated memory when accessing the Vendor,
	 * Product, and Revision strings.  Badly behaved devices may set
	 * the INQUIRY Additional Length byte to a small value, indicating
	 * these strings are invalid, but often they contain plausible data
	 * nonetheless.  It doesn't matter if the device sent < 36 bytes
	 * total, since scsi_probe_lun() initializes inq_result with 0s.
	 */
	sdev->inquiry = kmemdup(inq_result,
				max_t(size_t, sdev->inquiry_len, 36),
				GFP_ATOMIC);
	if (sdev->inquiry == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
776 777 778 779 780 781
		return SCSI_SCAN_NO_RESPONSE;

	sdev->vendor = (char *) (sdev->inquiry + 8);
	sdev->model = (char *) (sdev->inquiry + 16);
	sdev->rev = (char *) (sdev->inquiry + 32);

782 783 784 785 786 787 788 789 790 791
	if (strncmp(sdev->vendor, "ATA     ", 8) == 0) {
		/*
		 * sata emulation layer device.  This is a hack to work around
		 * the SATL power management specifications which state that
		 * when the SATL detects the device has gone into standby
		 * mode, it shall respond with NOT READY.
		 */
		sdev->allow_restart = 1;
	}

Linus Torvalds's avatar
Linus Torvalds committed
792
	if (*bflags & BLIST_ISROM) {
793 794 795 796 797 798
		sdev->type = TYPE_ROM;
		sdev->removable = 1;
	} else {
		sdev->type = (inq_result[0] & 0x1f);
		sdev->removable = (inq_result[1] & 0x80) >> 7;
	}
Linus Torvalds's avatar
Linus Torvalds committed
799

800
	switch (sdev->type) {
801
	case TYPE_RBC:
Linus Torvalds's avatar
Linus Torvalds committed
802 803 804 805 806 807 808 809 810
	case TYPE_TAPE:
	case TYPE_DISK:
	case TYPE_PRINTER:
	case TYPE_MOD:
	case TYPE_PROCESSOR:
	case TYPE_SCANNER:
	case TYPE_MEDIUM_CHANGER:
	case TYPE_ENCLOSURE:
	case TYPE_COMM:
811
	case TYPE_RAID:
Boaz Harrosh's avatar
Boaz Harrosh committed
812
	case TYPE_OSD:
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815
		sdev->writeable = 1;
		break;
	case TYPE_ROM:
816
	case TYPE_WORM:
Linus Torvalds's avatar
Linus Torvalds committed
817 818 819 820 821 822
		sdev->writeable = 0;
		break;
	default:
		printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
	}

823 824 825 826 827 828 829 830 831
	if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
		/* RBC and MMC devices can return SCSI-3 compliance and yet
		 * still not support REPORT LUNS, so make them act as
		 * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
		 * specifically set */
		if ((*bflags & BLIST_REPORTLUN2) == 0)
			*bflags |= BLIST_NOREPORTLUN;
	}

Linus Torvalds's avatar
Linus Torvalds committed
832 833 834 835 836 837 838 839 840
	/*
	 * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
	 * spec says: The device server is capable of supporting the
	 * specified peripheral device type on this logical unit. However,
	 * the physical device is not currently connected to this logical
	 * unit.
	 *
	 * The above is vague, as it implies that we could treat 001 and
	 * 011 the same. Stay compatible with previous code, and create a
841
	 * scsi_device for a PQ of 1
Linus Torvalds's avatar
Linus Torvalds committed
842 843 844 845 846 847 848 849 850 851
	 *
	 * Don't set the device offline here; rather let the upper
	 * level drivers eval the PQ to decide whether they should
	 * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
	 */ 

	sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
	sdev->lockable = sdev->removable;
	sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);

852 853
	if (sdev->scsi_level >= SCSI_3 ||
			(sdev->inquiry_len > 56 && inq_result[56] & 0x04))
Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859
		sdev->ppr = 1;
	if (inq_result[7] & 0x60)
		sdev->wdtr = 1;
	if (inq_result[7] & 0x10)
		sdev->sdtr = 1;

860
	sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
861 862 863 864 865
			"ANSI: %d%s\n", scsi_device_type(sdev->type),
			sdev->vendor, sdev->model, sdev->rev,
			sdev->inq_periph_qual, inq_result[2] & 0x07,
			(inq_result[3] & 0x0f) == 1 ? " CCS" : "");

Linus Torvalds's avatar
Linus Torvalds committed
866 867 868
	if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
	    !(*bflags & BLIST_NOTQ))
		sdev->tagged_supported = 1;
869

Linus Torvalds's avatar
Linus Torvalds committed
870 871 872 873 874 875 876 877
	/*
	 * Some devices (Texel CD ROM drives) have handshaking problems
	 * when used with the Seagate controllers. borken is initialized
	 * to 1, and then set it to 0 here.
	 */
	if ((*bflags & BLIST_BORKEN) == 0)
		sdev->borken = 0;

878 879 880
	if (*bflags & BLIST_NO_ULD_ATTACH)
		sdev->no_uld_attach = 1;

Linus Torvalds's avatar
Linus Torvalds committed
881 882 883 884 885 886 887
	/*
	 * Apparently some really broken devices (contrary to the SCSI
	 * standards) need to be selected without asserting ATN
	 */
	if (*bflags & BLIST_SELECT_NO_ATN)
		sdev->select_no_atn = 1;

888 889 890 891 892
	/*
	 * Maximum 512 sector transfer length
	 * broken RA4x00 Compaq Disk Array
	 */
	if (*bflags & BLIST_MAX_512)
893
		blk_queue_max_hw_sectors(sdev->request_queue, 512);
894

Linus Torvalds's avatar
Linus Torvalds committed
895 896 897 898 899 900 901 902
	/*
	 * Some devices may not want to have a start command automatically
	 * issued when a device is added.
	 */
	if (*bflags & BLIST_NOSTARTONADD)
		sdev->no_start_on_add = 1;

	if (*bflags & BLIST_SINGLELUN)
903
		scsi_target(sdev)->single_lun = 1;
Linus Torvalds's avatar
Linus Torvalds committed
904 905 906 907 908 909 910 911 912 913 914 915 916 917

	sdev->use_10_for_rw = 1;

	if (*bflags & BLIST_MS_SKIP_PAGE_08)
		sdev->skip_ms_page_8 = 1;

	if (*bflags & BLIST_MS_SKIP_PAGE_3F)
		sdev->skip_ms_page_3f = 1;

	if (*bflags & BLIST_USE_10_BYTE_MS)
		sdev->use_10_for_ms = 1;

	/* set the device running here so that slave configure
	 * may do I/O */
918 919 920 921 922 923 924 925 926 927 928
	ret = scsi_device_set_state(sdev, SDEV_RUNNING);
	if (ret) {
		ret = scsi_device_set_state(sdev, SDEV_BLOCK);

		if (ret) {
			sdev_printk(KERN_ERR, sdev,
				    "in wrong state %s to complete scan\n",
				    scsi_device_state_name(sdev->sdev_state));
			return SCSI_SCAN_NO_RESPONSE;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
929 930 931 932 933 934 935 936 937 938

	if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
		sdev->use_192_bytes_for_3f = 1;

	if (*bflags & BLIST_NOT_LOCKABLE)
		sdev->lockable = 0;

	if (*bflags & BLIST_RETRY_HWERROR)
		sdev->retry_hwerror = 1;

939 940 941
	if (*bflags & BLIST_NO_DIF)
		sdev->no_dif = 1;

942 943
	sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

944 945 946
	if (*bflags & BLIST_SKIP_VPD_PAGES)
		sdev->skip_vpd_pages = 1;

Linus Torvalds's avatar
Linus Torvalds committed
947 948
	transport_configure_device(&sdev->sdev_gendev);

949
	if (sdev->host->hostt->slave_configure) {
950
		ret = sdev->host->hostt->slave_configure(sdev);
951 952 953 954 955 956 957 958 959 960 961 962
		if (ret) {
			/*
			 * if LLDD reports slave not present, don't clutter
			 * console with alloc failure messages
			 */
			if (ret != -ENXIO) {
				sdev_printk(KERN_ERR, sdev,
					"failed to configure device\n");
			}
			return SCSI_SCAN_NO_RESPONSE;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
963

964 965
	sdev->max_queue_depth = sdev->queue_depth;

Linus Torvalds's avatar
Linus Torvalds committed
966 967 968 969 970
	/*
	 * Ok, the device is now all set up, we can
	 * register it and tell the rest of the kernel
	 * about it.
	 */
971
	if (!async && scsi_sysfs_add_sdev(sdev) != 0)
972
		return SCSI_SCAN_NO_RESPONSE;
Linus Torvalds's avatar
Linus Torvalds committed
973 974 975 976

	return SCSI_SCAN_LUN_PRESENT;
}

977
#ifdef CONFIG_SCSI_LOGGING
978
/** 
979
 * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
980 981 982 983 984
 * @buf:   Output buffer with at least end-first+1 bytes of space
 * @inq:   Inquiry buffer (input)
 * @first: Offset of string into inq
 * @end:   Index after last character in inq
 */
985
static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
986 987 988
				   unsigned first, unsigned end)
{
	unsigned term = 0, idx;
989 990 991

	for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
		if (inq[idx+first] > ' ') {
992 993 994 995 996 997 998 999 1000
			buf[idx] = inq[idx+first];
			term = idx+1;
		} else {
			buf[idx] = ' ';
		}
	}
	buf[term] = 0;
	return buf;
}
1001
#endif
1002

Linus Torvalds's avatar
Linus Torvalds committed
1003 1004 1005 1006 1007
/**
 * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
 * @starget:	pointer to target device structure
 * @lun:	LUN of target device
 * @bflagsp:	store bflags here if not NULL
1008 1009 1010
 * @sdevp:	probe the LUN corresponding to this scsi_device
 * @rescan:     if nonzero skip some code only needed on first scan
 * @hostdata:	passed to scsi_alloc_sdev()
Linus Torvalds's avatar
Linus Torvalds committed
1011 1012 1013 1014 1015 1016
 *
 * Description:
 *     Call scsi_probe_lun, if a LUN with an attached device is found,
 *     allocate and set it up by calling scsi_add_lun.
 *
 * Return:
1017
 *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
Linus Torvalds's avatar
Linus Torvalds committed
1018 1019
 *     SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
 *         attached at the LUN
1020
 *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
Linus Torvalds's avatar
Linus Torvalds committed
1021 1022 1023 1024 1025 1026 1027 1028
 **/
static int scsi_probe_and_add_lun(struct scsi_target *starget,
				  uint lun, int *bflagsp,
				  struct scsi_device **sdevp, int rescan,
				  void *hostdata)
{
	struct scsi_device *sdev;
	unsigned char *result;
1029
	int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
Linus Torvalds's avatar
Linus Torvalds committed
1030 1031 1032 1033 1034 1035
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	/*
	 * The rescan flag is used as an optimization, the first scan of a
	 * host adapter calls into here with rescan == 0.
	 */
1036 1037
	sdev = scsi_device_lookup_by_target(starget, lun);
	if (sdev) {
1038
		if (rescan || !scsi_device_created(sdev)) {
Linus Torvalds's avatar
Linus Torvalds committed
1039 1040
			SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
				"scsi scan: device exists on %s\n",
1041
				dev_name(&sdev->sdev_gendev)));
Linus Torvalds's avatar
Linus Torvalds committed
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
			if (sdevp)
				*sdevp = sdev;
			else
				scsi_device_put(sdev);

			if (bflagsp)
				*bflagsp = scsi_get_device_flags(sdev,
								 sdev->vendor,
								 sdev->model);
			return SCSI_SCAN_LUN_PRESENT;
		}
1053 1054 1055
		scsi_device_put(sdev);
	} else
		sdev = scsi_alloc_sdev(starget, lun, hostdata);
Linus Torvalds's avatar
Linus Torvalds committed
1056 1057
	if (!sdev)
		goto out;
1058 1059

	result = kmalloc(result_len, GFP_ATOMIC |
Al Viro's avatar
Al Viro committed
1060
			((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
Linus Torvalds's avatar
Linus Torvalds committed
1061
	if (!result)
1062
		goto out_free_sdev;
Linus Torvalds's avatar
Linus Torvalds committed
1063

1064
	if (scsi_probe_lun(sdev, result, result_len, &bflags))
Linus Torvalds's avatar
Linus Torvalds committed
1065 1066
		goto out_free_result;

1067 1068
	if (bflagsp)
		*bflagsp = bflags;
Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071
	/*
	 * result contains valid SCSI INQUIRY data.
	 */
Kurt Garloff's avatar
Kurt Garloff committed
1072
	if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
Linus Torvalds's avatar
Linus Torvalds committed
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
		/*
		 * For a Peripheral qualifier 3 (011b), the SCSI
		 * spec says: The device server is not capable of
		 * supporting a physical device on this logical
		 * unit.
		 *
		 * For disks, this implies that there is no
		 * logical disk configured at sdev->lun, but there
		 * is a target id responding.
		 */
1083 1084 1085 1086
		SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
				   " peripheral qualifier of 3, device not"
				   " added\n"))
		if (lun == 0) {
1087 1088 1089 1090 1091
			SCSI_LOG_SCAN_BUS(1, {
				unsigned char vend[9];
				unsigned char mod[17];

				sdev_printk(KERN_INFO, sdev,
1092
					"scsi scan: consider passing scsi_mod."
1093
					"dev_flags=%s:%s:0x240 or 0x1000240\n",
1094
					scsi_inq_str(vend, result, 8, 16),
1095 1096
					scsi_inq_str(mod, result, 16, 32));
			});
1097

1098
		}
1099

Linus Torvalds's avatar
Linus Torvalds committed
1100 1101 1102 1103
		res = SCSI_SCAN_TARGET_PRESENT;
		goto out_free_result;
	}

1104
	/*
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	 * Some targets may set slight variations of PQ and PDT to signal
	 * that no LUN is present, so don't add sdev in these cases.
	 * Two specific examples are:
	 * 1) NetApp targets: return PQ=1, PDT=0x1f
	 * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
	 *    in the UFI 1.0 spec (we cannot rely on reserved bits).
	 *
	 * References:
	 * 1) SCSI SPC-3, pp. 145-146
	 * PQ=1: "A peripheral device having the specified peripheral
	 * device type is not connected to this logical unit. However, the
	 * device server is capable of supporting the specified peripheral
	 * device type on this logical unit."
	 * PDT=0x1f: "Unknown or no device type"
	 * 2) USB UFI 1.0, p. 20
	 * PDT=00h Direct-access device (floppy)
	 * PDT=1Fh none (no FDD connected to the requested logical unit)
1122
	 */
1123
	if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
1124 1125
	    (result[0] & 0x1f) == 0x1f &&
	    !scsi_is_wlun(lun)) {
1126 1127 1128 1129 1130 1131 1132
		SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
					"scsi scan: peripheral device type"
					" of 31, no device added\n"));
		res = SCSI_SCAN_TARGET_PRESENT;
		goto out_free_result;
	}

1133
	res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
Linus Torvalds's avatar
Linus Torvalds committed
1134 1135 1136
	if (res == SCSI_SCAN_LUN_PRESENT) {
		if (bflags & BLIST_KEY) {
			sdev->lockable = 0;
1137
			scsi_unlock_floptical(sdev, result);
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139 1140 1141 1142 1143 1144 1145
		}
	}

 out_free_result:
	kfree(result);
 out_free_sdev:
	if (res == SCSI_SCAN_LUN_PRESENT) {
		if (sdevp) {
1146 1147 1148 1149 1150 1151
			if (scsi_device_get(sdev) == 0) {
				*sdevp = sdev;
			} else {
				__scsi_remove_device(sdev);
				res = SCSI_SCAN_NO_RESPONSE;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1152
		}
1153
	} else
1154
		__scsi_remove_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158 1159 1160 1161 1162
 out:
	return res;
}

/**
 * scsi_sequential_lun_scan - sequentially scan a SCSI target
 * @starget:	pointer to target structure to scan
 * @bflags:	black/white list flag for LUN 0
1163 1164
 * @scsi_level: Which version of the standard does this device adhere to
 * @rescan:     passed to scsi_probe_add_lun()
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166 1167 1168 1169 1170 1171 1172 1173
 *
 * Description:
 *     Generally, scan from LUN 1 (LUN 0 is assumed to already have been
 *     scanned) to some maximum lun until a LUN is found with no device
 *     attached. Use the bflags to figure out any oddities.
 *
 *     Modifies sdevscan->lun.
 **/
static void scsi_sequential_lun_scan(struct scsi_target *starget,
1174
				     int bflags, int scsi_level, int rescan)
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177 1178 1179
{
	unsigned int sparse_lun, lun, max_dev_lun;
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
1180
				    "%s\n", dev_name(&starget->dev)));
Linus Torvalds's avatar
Linus Torvalds committed
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241

	max_dev_lun = min(max_scsi_luns, shost->max_lun);
	/*
	 * If this device is known to support sparse multiple units,
	 * override the other settings, and scan all of them. Normally,
	 * SCSI-3 devices should be scanned via the REPORT LUNS.
	 */
	if (bflags & BLIST_SPARSELUN) {
		max_dev_lun = shost->max_lun;
		sparse_lun = 1;
	} else
		sparse_lun = 0;

	/*
	 * If less than SCSI_1_CSS, and no special lun scaning, stop
	 * scanning; this matches 2.4 behaviour, but could just be a bug
	 * (to continue scanning a SCSI_1_CSS device).
	 *
	 * This test is broken.  We might not have any device on lun0 for
	 * a sparselun device, and if that's the case then how would we
	 * know the real scsi_level, eh?  It might make sense to just not
	 * scan any SCSI_1 device for non-0 luns, but that check would best
	 * go into scsi_alloc_sdev() and just have it return null when asked
	 * to alloc an sdev for lun > 0 on an already found SCSI_1 device.
	 *
	if ((sdevscan->scsi_level < SCSI_1_CCS) &&
	    ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
	     == 0))
		return;
	 */
	/*
	 * If this device is known to support multiple units, override
	 * the other settings, and scan all of them.
	 */
	if (bflags & BLIST_FORCELUN)
		max_dev_lun = shost->max_lun;
	/*
	 * REGAL CDC-4X: avoid hang after LUN 4
	 */
	if (bflags & BLIST_MAX5LUN)
		max_dev_lun = min(5U, max_dev_lun);
	/*
	 * Do not scan SCSI-2 or lower device past LUN 7, unless
	 * BLIST_LARGELUN.
	 */
	if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
		max_dev_lun = min(8U, max_dev_lun);

	/*
	 * We have already scanned LUN 0, so start at LUN 1. Keep scanning
	 * until we reach the max, or no LUN is found and we are not
	 * sparse_lun.
	 */
	for (lun = 1; lun < max_dev_lun; ++lun)
		if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
					    NULL) != SCSI_SCAN_LUN_PRESENT) &&
		    !sparse_lun)
			return;
}

/**
1242
 * scsilun_to_int - convert a scsi_lun to an int
Linus Torvalds's avatar
Linus Torvalds committed
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
 * @scsilun:	struct scsi_lun to be converted.
 *
 * Description:
 *     Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
 *     integer, and return the result. The caller must check for
 *     truncation before using this function.
 *
 * Notes:
 *     The struct scsi_lun is assumed to be four levels, with each level
 *     effectively containing a SCSI byte-ordered (big endian) short; the
 *     addressing bits of each level are ignored (the highest two bits).
 *     For a description of the LUN format, post SCSI-3 see the SCSI
 *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
 *
 *     Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
 *     the integer: 0x0b030a04
 **/
1260
int scsilun_to_int(struct scsi_lun *scsilun)
Linus Torvalds's avatar
Linus Torvalds committed
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
{
	int i;
	unsigned int lun;

	lun = 0;
	for (i = 0; i < sizeof(lun); i += 2)
		lun = lun | (((scsilun->scsi_lun[i] << 8) |
			      scsilun->scsi_lun[i + 1]) << (i * 8));
	return lun;
}
1271
EXPORT_SYMBOL(scsilun_to_int);
Linus Torvalds's avatar
Linus Torvalds committed
1272

1273
/**
1274
 * int_to_scsilun - reverts an int into a scsi_lun
1275
 * @lun:        integer to be reverted
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
 * @scsilun:	struct scsi_lun to be set.
 *
 * Description:
 *     Reverts the functionality of the scsilun_to_int, which packed
 *     an 8-byte lun value into an int. This routine unpacks the int
 *     back into the lun value.
 *     Note: the scsilun_to_int() routine does not truly handle all
 *     8bytes of the lun value. This functions restores only as much
 *     as was set by the routine.
 *
 * Notes:
 *     Given an integer : 0x0b030a04,  this function returns a
 *     scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00
 *
 **/
void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
{
	int i;

	memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));

	for (i = 0; i < sizeof(lun); i += 2) {
		scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
		scsilun->scsi_lun[i+1] = lun & 0xFF;
		lun = lun >> 16;
	}
}
EXPORT_SYMBOL(int_to_scsilun);

Linus Torvalds's avatar
Linus Torvalds committed
1305 1306
/**
 * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
1307 1308 1309
 * @starget: which target
 * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
 * @rescan: nonzero if we can skip code only needed on first scan
Linus Torvalds's avatar
Linus Torvalds committed
1310 1311
 *
 * Description:
1312 1313
 *   Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
 *   Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
Linus Torvalds's avatar
Linus Torvalds committed
1314
 *
1315 1316 1317 1318
 *   If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
 *   LUNs even if it's older than SCSI-3.
 *   If BLIST_NOREPORTLUN is set, return 1 always.
 *   If BLIST_NOLUN is set, return 0 always.
1319
 *   If starget->no_report_luns is set, return 1 always.
Linus Torvalds's avatar
Linus Torvalds committed
1320 1321 1322
 *
 * Return:
 *     0: scan completed (or no memory, so further scanning is futile)
1323
 *     1: could not scan with REPORT LUN
Linus Torvalds's avatar
Linus Torvalds committed
1324
 **/
1325
static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
Linus Torvalds's avatar
Linus Torvalds committed
1326 1327 1328 1329 1330 1331 1332 1333
				int rescan)
{
	char devname[64];
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
	unsigned int length;
	unsigned int lun;
	unsigned int num_luns;
	unsigned int retries;
1334
	int result;
Linus Torvalds's avatar
Linus Torvalds committed
1335 1336 1337
	struct scsi_lun *lunp, *lun_data;
	u8 *data;
	struct scsi_sense_hdr sshdr;
1338 1339
	struct scsi_device *sdev;
	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1340
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1341 1342 1343 1344 1345

	/*
	 * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
	 * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
	 * support more than 8 LUNs.
1346
	 * Don't attempt if the target doesn't support REPORT LUNS.
Linus Torvalds's avatar
Linus Torvalds committed
1347
	 */
1348 1349 1350 1351 1352 1353 1354
	if (bflags & BLIST_NOREPORTLUN)
		return 1;
	if (starget->scsi_level < SCSI_2 &&
	    starget->scsi_level != SCSI_UNKNOWN)
		return 1;
	if (starget->scsi_level < SCSI_3 &&
	    (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
Linus Torvalds's avatar
Linus Torvalds committed
1355 1356 1357
		return 1;
	if (bflags & BLIST_NOLUN)
		return 0;
1358 1359
	if (starget->no_report_luns)
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1360

1361 1362 1363 1364
	if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
		sdev = scsi_alloc_sdev(starget, 0, NULL);
		if (!sdev)
			return 0;
1365 1366
		if (scsi_device_get(sdev)) {
			__scsi_remove_device(sdev);
1367
			return 0;
1368
		}
1369 1370
	}

Linus Torvalds's avatar
Linus Torvalds committed
1371
	sprintf(devname, "host %d channel %d id %d",
1372
		shost->host_no, sdev->channel, sdev->id);
Linus Torvalds's avatar
Linus Torvalds committed
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386

	/*
	 * Allocate enough to hold the header (the same size as one scsi_lun)
	 * plus the max number of luns we are requesting.
	 *
	 * Reallocating and trying again (with the exact amount we need)
	 * would be nice, but then we need to somehow limit the size
	 * allocated based on the available memory and the limits of
	 * kmalloc - we don't want a kmalloc() failure of a huge value to
	 * prevent us from finding any LUNs on this target.
	 */
	length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
	lun_data = kmalloc(length, GFP_ATOMIC |
			   (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1387
	if (!lun_data) {
1388
		printk(ALLOC_FAILURE_MSG, __func__);
1389
		goto out;
1390
	}
Linus Torvalds's avatar
Linus Torvalds committed
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423

	scsi_cmd[0] = REPORT_LUNS;

	/*
	 * bytes 1 - 5: reserved, set to zero.
	 */
	memset(&scsi_cmd[1], 0, 5);

	/*
	 * bytes 6 - 9: length of the command.
	 */
	scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
	scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
	scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
	scsi_cmd[9] = (unsigned char) length & 0xff;

	scsi_cmd[10] = 0;	/* reserved */
	scsi_cmd[11] = 0;	/* control */

	/*
	 * We can get a UNIT ATTENTION, for example a power on/reset, so
	 * retry a few times (like sd.c does for TEST UNIT READY).
	 * Experience shows some combinations of adapter/devices get at
	 * least two power on/resets.
	 *
	 * Illegal requests (for devices that do not support REPORT LUNS)
	 * should come through as a check condition, and will not generate
	 * a retry.
	 */
	for (retries = 0; retries < 3; retries++) {
		SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"
				" REPORT LUNS to %s (try %d)\n", devname,
				retries));
1424 1425

		result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1426
					  lun_data, length, &sshdr,
1427
					  SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1428

Linus Torvalds's avatar
Linus Torvalds committed
1429
		SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
1430 1431 1432
				" %s (try %d) result 0x%x\n", result
				?  "failed" : "successful", retries, result));
		if (result == 0)
Linus Torvalds's avatar
Linus Torvalds committed
1433
			break;
1434
		else if (scsi_sense_valid(&sshdr)) {
Linus Torvalds's avatar
Linus Torvalds committed
1435 1436 1437 1438 1439
			if (sshdr.sense_key != UNIT_ATTENTION)
				break;
		}
	}

1440
	if (result) {
Linus Torvalds's avatar
Linus Torvalds committed
1441 1442 1443
		/*
		 * The device probably does not support a REPORT LUN command
		 */
1444 1445
		ret = 1;
		goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
	}

	/*
	 * Get the length from the first four bytes of lun_data.
	 */
	data = (u8 *) lun_data->scsi_lun;
	length = ((data[0] << 24) | (data[1] << 16) |
		  (data[2] << 8) | (data[3] << 0));

	num_luns = (length / sizeof(struct scsi_lun));
	if (num_luns > max_scsi_report_luns) {
		printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
		       " of %d luns reported, try increasing"
		       " max_scsi_report_luns.\n", devname,
		       max_scsi_report_luns, num_luns);
		num_luns = max_scsi_report_luns;
	}

1464 1465
	SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
		"scsi scan: REPORT LUN scan\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503

	/*
	 * Scan the luns in lun_data. The entry at offset 0 is really
	 * the header, so start at 1 and go up to and including num_luns.
	 */
	for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
		lun = scsilun_to_int(lunp);

		/*
		 * Check if the unused part of lunp is non-zero, and so
		 * does not fit in lun.
		 */
		if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
			int i;

			/*
			 * Output an error displaying the LUN in byte order,
			 * this differs from what linux would print for the
			 * integer LUN value.
			 */
			printk(KERN_WARNING "scsi: %s lun 0x", devname);
			data = (char *)lunp->scsi_lun;
			for (i = 0; i < sizeof(struct scsi_lun); i++)
				printk("%02x", data[i]);
			printk(" has a LUN larger than currently supported.\n");
		} else if (lun > sdev->host->max_lun) {
			printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
			       " than allowed by the host adapter\n",
			       devname, lun);
		} else {
			int res;

			res = scsi_probe_and_add_lun(starget,
				lun, NULL, NULL, rescan, NULL);
			if (res == SCSI_SCAN_NO_RESPONSE) {
				/*
				 * Got some results, but now none, abort.
				 */
1504 1505 1506 1507
				sdev_printk(KERN_ERR, sdev,
					"Unexpected response"
				        " from lun %d while scanning, scan"
				        " aborted\n", lun);
Linus Torvalds's avatar
Linus Torvalds committed
1508 1509 1510 1511 1512
				break;
			}
		}
	}

1513
 out_err:
Linus Torvalds's avatar
Linus Torvalds committed
1514 1515
	kfree(lun_data);
 out:
1516
	scsi_device_put(sdev);
1517
	if (scsi_device_created(sdev))
1518 1519 1520
		/*
		 * the sdev we used didn't appear in the report luns scan
		 */
1521
		__scsi_remove_device(sdev);
1522
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1523 1524 1525 1526 1527
}

struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
				      uint id, uint lun, void *hostdata)
{
1528
	struct scsi_device *sdev = ERR_PTR(-ENODEV);
Linus Torvalds's avatar
Linus Torvalds committed
1529
	struct device *parent = &shost->shost_gendev;
1530
	struct scsi_target *starget;
Linus Torvalds's avatar
Linus Torvalds committed
1531

1532 1533 1534
	if (strncmp(scsi_scan_type, "none", 4) == 0)
		return ERR_PTR(-ENODEV);

1535
	starget = scsi_alloc_target(parent, channel, id);
Linus Torvalds's avatar
Linus Torvalds committed
1536 1537
	if (!starget)
		return ERR_PTR(-ENOMEM);
1538
	scsi_autopm_get_target(starget);
Linus Torvalds's avatar
Linus Torvalds committed
1539

1540
	mutex_lock(&shost->scan_mutex);
1541 1542 1543
	if (!shost->async_scan)
		scsi_complete_async_scans();

1544
	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1545
		scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1546 1547
		scsi_autopm_put_host(shost);
	}
1548
	mutex_unlock(&shost->scan_mutex);
1549
	scsi_autopm_put_target(starget);
1550 1551 1552 1553
	/*
	 * paired with scsi_alloc_target().  Target will be destroyed unless
	 * scsi_probe_and_add_lun made an underlying device visible
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1554 1555 1556 1557 1558 1559 1560
	scsi_target_reap(starget);
	put_device(&starget->dev);

	return sdev;
}
EXPORT_SYMBOL(__scsi_add_device);

1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
int scsi_add_device(struct Scsi_Host *host, uint channel,
		    uint target, uint lun)
{
	struct scsi_device *sdev = 
		__scsi_add_device(host, channel, target, lun, NULL);
	if (IS_ERR(sdev))
		return PTR_ERR(sdev);

	scsi_device_put(sdev);
	return 0;
}
EXPORT_SYMBOL(scsi_add_device);

Linus Torvalds's avatar
Linus Torvalds committed
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
void scsi_rescan_device(struct device *dev)
{
	struct scsi_driver *drv;
	
	if (!dev->driver)
		return;

	drv = to_scsi_driver(dev->driver);
	if (try_module_get(drv->owner)) {
		if (drv->rescan)
			drv->rescan(dev);
		module_put(drv->owner);
	}
}
EXPORT_SYMBOL(scsi_rescan_device);

1590 1591
static void __scsi_scan_target(struct device *parent, unsigned int channel,
		unsigned int id, unsigned int lun, int rescan)
Linus Torvalds's avatar
Linus Torvalds committed
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
{
	struct Scsi_Host *shost = dev_to_shost(parent);
	int bflags = 0;
	int res;
	struct scsi_target *starget;

	if (shost->this_id == id)
		/*
		 * Don't scan the host adapter
		 */
		return;

	starget = scsi_alloc_target(parent, channel, id);
	if (!starget)
		return;
1607
	scsi_autopm_get_target(starget);
Linus Torvalds's avatar
Linus Torvalds committed
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620

	if (lun != SCAN_WILD_CARD) {
		/*
		 * Scan for a specific host/chan/id/lun.
		 */
		scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
		goto out_reap;
	}

	/*
	 * Scan LUN 0, if there is some response, scan further. Ideally, we
	 * would not configure LUN 0 until all LUNs are scanned.
	 */
1621 1622 1623
	res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
	if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
		if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
1624 1625 1626 1627 1628
			/*
			 * The REPORT LUN did not scan the target,
			 * do a sequential scan.
			 */
			scsi_sequential_lun_scan(starget, bflags,
1629
						 starget->scsi_level, rescan);
Linus Torvalds's avatar
Linus Torvalds committed
1630 1631 1632
	}

 out_reap:
1633
	scsi_autopm_put_target(starget);
1634 1635 1636 1637
	/*
	 * paired with scsi_alloc_target(): determine if the target has
	 * any children at all and if not, nuke it
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1638 1639 1640 1641
	scsi_target_reap(starget);

	put_device(&starget->dev);
}
1642 1643

/**
Randy Dunlap's avatar
Randy Dunlap committed
1644
 * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
 * @parent:	host to scan
 * @channel:	channel to scan
 * @id:		target id to scan
 * @lun:	Specific LUN to scan or SCAN_WILD_CARD
 * @rescan:	passed to LUN scanning routines
 *
 * Description:
 *     Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
 *     and possibly all LUNs on the target id.
 *
 *     First try a REPORT LUN scan, if that does not scan the target, do a
 *     sequential scan of LUNs on the target id.
 **/
void scsi_scan_target(struct device *parent, unsigned int channel,
		      unsigned int id, unsigned int lun, int rescan)
{
	struct Scsi_Host *shost = dev_to_shost(parent);

1663 1664 1665
	if (strncmp(scsi_scan_type, "none", 4) == 0)
		return;

1666
	mutex_lock(&shost->scan_mutex);
1667 1668 1669
	if (!shost->async_scan)
		scsi_complete_async_scans();

1670
	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1671
		__scsi_scan_target(parent, channel, id, lun, rescan);
1672 1673
		scsi_autopm_put_host(shost);
	}
1674
	mutex_unlock(&shost->scan_mutex);
1675
}
Linus Torvalds's avatar
Linus Torvalds committed
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
EXPORT_SYMBOL(scsi_scan_target);

static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
			      unsigned int id, unsigned int lun, int rescan)
{
	uint order_id;

	if (id == SCAN_WILD_CARD)
		for (id = 0; id < shost->max_id; ++id) {
			/*
			 * XXX adapter drivers when possible (FCP, iSCSI)
			 * could modify max_id to match the current max,
			 * not the absolute max.
			 *
			 * XXX add a shost id iterator, so for example,
			 * the FC ID can be the same as a target id
			 * without a huge overhead of sparse id's.
			 */
			if (shost->reverse_ordering)
				/*
				 * Scan from high to low id.
				 */
				order_id = shost->max_id - id - 1;
			else
				order_id = id;
1701 1702
			__scsi_scan_target(&shost->shost_gendev, channel,
					order_id, lun, rescan);
Linus Torvalds's avatar
Linus Torvalds committed
1703 1704
		}
	else
1705 1706
		__scsi_scan_target(&shost->shost_gendev, channel,
				id, lun, rescan);
Linus Torvalds's avatar
Linus Torvalds committed
1707 1708 1709 1710 1711
}

int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
			    unsigned int id, unsigned int lun, int rescan)
{
1712 1713
	SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
		"%s: <%u:%u:%u>\n",
1714
		__func__, channel, id, lun));
Linus Torvalds's avatar
Linus Torvalds committed
1715 1716

	if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
1717
	    ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
Linus Torvalds's avatar
Linus Torvalds committed
1718 1719 1720
	    ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
		return -EINVAL;

1721
	mutex_lock(&shost->scan_mutex);
1722 1723 1724
	if (!shost->async_scan)
		scsi_complete_async_scans();

1725
	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1726 1727 1728 1729 1730 1731
		if (channel == SCAN_WILD_CARD)
			for (channel = 0; channel <= shost->max_channel;
			     channel++)
				scsi_scan_channel(shost, channel, id, lun,
						  rescan);
		else
Linus Torvalds's avatar
Linus Torvalds committed
1732
			scsi_scan_channel(shost, channel, id, lun, rescan);
1733
		scsi_autopm_put_host(shost);
1734
	}
1735
	mutex_unlock(&shost->scan_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1736 1737 1738 1739

	return 0;
}

1740 1741 1742 1743
static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
{
	struct scsi_device *sdev;
	shost_for_each_device(sdev, shost) {
1744 1745 1746
		/* target removed before the device could be added */
		if (sdev->sdev_state == SDEV_DEL)
			continue;
1747 1748
		if (!scsi_host_scan_allowed(shost) ||
		    scsi_sysfs_add_sdev(sdev) != 0)
1749
			__scsi_remove_device(sdev);
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
	}
}

/**
 * scsi_prep_async_scan - prepare for an async scan
 * @shost: the host which will be scanned
 * Returns: a cookie to be passed to scsi_finish_async_scan()
 *
 * Tells the midlayer this host is going to do an asynchronous scan.
 * It reserves the host's position in the scanning list and ensures
 * that other asynchronous scans started after this one won't affect the
 * ordering of the discovered devices.
 */
1763
static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1764 1765
{
	struct async_scan_data *data;
1766
	unsigned long flags;
1767 1768 1769 1770 1771

	if (strncmp(scsi_scan_type, "sync", 4) == 0)
		return NULL;

	if (shost->async_scan) {
1772
		printk("%s called twice for host %d", __func__,
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
				shost->host_no);
		dump_stack();
		return NULL;
	}

	data = kmalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		goto err;
	data->shost = scsi_host_get(shost);
	if (!data->shost)
		goto err;
	init_completion(&data->prev_finished);

1786 1787
	mutex_lock(&shost->scan_mutex);
	spin_lock_irqsave(shost->host_lock, flags);
1788
	shost->async_scan = 1;
1789 1790 1791 1792
	spin_unlock_irqrestore(shost->host_lock, flags);
	mutex_unlock(&shost->scan_mutex);

	spin_lock(&async_scan_lock);
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
	if (list_empty(&scanning_hosts))
		complete(&data->prev_finished);
	list_add_tail(&data->list, &scanning_hosts);
	spin_unlock(&async_scan_lock);

	return data;

 err:
	kfree(data);
	return NULL;
}

/**
 * scsi_finish_async_scan - asynchronous scan has finished
 * @data: cookie returned from earlier call to scsi_prep_async_scan()
 *
 * All the devices currently attached to this host have been found.
 * This function announces all the devices it has found to the rest
 * of the system.
 */
1813
static void scsi_finish_async_scan(struct async_scan_data *data)
1814 1815
{
	struct Scsi_Host *shost;
1816
	unsigned long flags;
1817 1818 1819 1820 1821

	if (!data)
		return;

	shost = data->shost;
1822 1823 1824

	mutex_lock(&shost->scan_mutex);

1825
	if (!shost->async_scan) {
1826
		printk("%s called twice for host %d", __func__,
1827 1828
				shost->host_no);
		dump_stack();
1829
		mutex_unlock(&shost->scan_mutex);
1830 1831 1832 1833 1834 1835 1836
		return;
	}

	wait_for_completion(&data->prev_finished);

	scsi_sysfs_add_devices(shost);

1837
	spin_lock_irqsave(shost->host_lock, flags);
1838
	shost->async_scan = 0;
1839 1840 1841 1842 1843
	spin_unlock_irqrestore(shost->host_lock, flags);

	mutex_unlock(&shost->scan_mutex);

	spin_lock(&async_scan_lock);
1844 1845 1846 1847 1848 1849 1850 1851
	list_del(&data->list);
	if (!list_empty(&scanning_hosts)) {
		struct async_scan_data *next = list_entry(scanning_hosts.next,
				struct async_scan_data, list);
		complete(&next->prev_finished);
	}
	spin_unlock(&async_scan_lock);

1852
	scsi_autopm_put_host(shost);
1853 1854 1855 1856
	scsi_host_put(shost);
	kfree(data);
}

1857
static void do_scsi_scan_host(struct Scsi_Host *shost)
1858
{
1859 1860 1861 1862 1863 1864 1865 1866 1867
	if (shost->hostt->scan_finished) {
		unsigned long start = jiffies;
		if (shost->hostt->scan_start)
			shost->hostt->scan_start(shost);

		while (!shost->hostt->scan_finished(shost, jiffies - start))
			msleep(10);
	} else {
		scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1868
				SCAN_WILD_CARD, 0);
1869 1870
	}
}
1871

1872
static void do_scan_async(void *_data, async_cookie_t c)
1873 1874
{
	struct async_scan_data *data = _data;
1875 1876 1877
	struct Scsi_Host *shost = data->shost;

	do_scsi_scan_host(shost);
1878 1879 1880
	scsi_finish_async_scan(data);
}

Linus Torvalds's avatar
Linus Torvalds committed
1881 1882 1883 1884 1885 1886
/**
 * scsi_scan_host - scan the given adapter
 * @shost:	adapter to scan
 **/
void scsi_scan_host(struct Scsi_Host *shost)
{
1887 1888 1889 1890
	struct async_scan_data *data;

	if (strncmp(scsi_scan_type, "none", 4) == 0)
		return;
1891 1892
	if (scsi_autopm_get_host(shost) < 0)
		return;
1893 1894 1895

	data = scsi_prep_async_scan(shost);
	if (!data) {
1896
		do_scsi_scan_host(shost);
1897
		scsi_autopm_put_host(shost);
1898 1899
		return;
	}
1900

1901 1902 1903 1904 1905
	/* register with the async subsystem so wait_for_device_probe()
	 * will flush this work
	 */
	async_schedule(do_scan_async, data);

1906
	/* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */
Linus Torvalds's avatar
Linus Torvalds committed
1907 1908 1909 1910 1911
}
EXPORT_SYMBOL(scsi_scan_host);

void scsi_forget_host(struct Scsi_Host *shost)
{
1912
	struct scsi_device *sdev;
Linus Torvalds's avatar
Linus Torvalds committed
1913 1914
	unsigned long flags;

1915
 restart:
Linus Torvalds's avatar
Linus Torvalds committed
1916
	spin_lock_irqsave(shost->host_lock, flags);
1917 1918 1919
	list_for_each_entry(sdev, &shost->__devices, siblings) {
		if (sdev->sdev_state == SDEV_DEL)
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
1920
		spin_unlock_irqrestore(shost->host_lock, flags);
1921 1922
		__scsi_remove_device(sdev);
		goto restart;
Linus Torvalds's avatar
Linus Torvalds committed
1923 1924 1925 1926
	}
	spin_unlock_irqrestore(shost->host_lock, flags);
}

1927 1928 1929
/**
 * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself
 * @shost: Host that needs a scsi_device
Linus Torvalds's avatar
Linus Torvalds committed
1930 1931 1932
 *
 * Lock status: None assumed.
 *
1933
 * Returns:     The scsi_device or NULL
Linus Torvalds's avatar
Linus Torvalds committed
1934 1935
 *
 * Notes:
1936
 *	Attach a single scsi_device to the Scsi_Host - this should
Linus Torvalds's avatar
Linus Torvalds committed
1937 1938 1939 1940 1941
 *	be made to look like a "pseudo-device" that points to the
 *	HA itself.
 *
 *	Note - this device is not accessible from any high-level
 *	drivers (including generics), which is probably not
1942
 *	optimal.  We can add hooks later to attach.
Linus Torvalds's avatar
Linus Torvalds committed
1943 1944 1945
 */
struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
{
1946
	struct scsi_device *sdev = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1947 1948
	struct scsi_target *starget;

1949
	mutex_lock(&shost->scan_mutex);
1950 1951
	if (!scsi_host_scan_allowed(shost))
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1952 1953
	starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
	if (!starget)
1954
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1955 1956

	sdev = scsi_alloc_sdev(starget, 0, NULL);
1957
	if (sdev)
Linus Torvalds's avatar
Linus Torvalds committed
1958
		sdev->borken = 0;
1959
	else
1960
		scsi_target_reap(starget);
Linus Torvalds's avatar
Linus Torvalds committed
1961
	put_device(&starget->dev);
1962
 out:
1963
	mutex_unlock(&shost->scan_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1964 1965 1966 1967
	return sdev;
}
EXPORT_SYMBOL(scsi_get_host_dev);

1968 1969 1970
/**
 * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself
 * @sdev: Host device to be freed
Linus Torvalds's avatar
Linus Torvalds committed
1971 1972 1973 1974 1975 1976 1977 1978 1979
 *
 * Lock status: None assumed.
 *
 * Returns:     Nothing
 */
void scsi_free_host_dev(struct scsi_device *sdev)
{
	BUG_ON(sdev->id != sdev->host->this_id);

1980
	__scsi_remove_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
1981 1982 1983
}
EXPORT_SYMBOL(scsi_free_host_dev);