scsi_scan.c 55.5 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>
37
#include <asm/unaligned.h>
Linus Torvalds's avatar
Linus Torvalds committed
38 39

#include <scsi/scsi.h>
40
#include <scsi/scsi_cmnd.h>
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
#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)

/*
60
 * Prefix values for the SCSI id's (stored in sysfs name field)
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
 */
#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

81
static const char *scsi_null_device_strs = "nullnullnullnull";
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84

#define MAX_SCSI_LUNS	512

85
static u64 max_scsi_luns = MAX_SCSI_LUNS;
Linus Torvalds's avatar
Linus Torvalds committed
86

87
module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR);
Linus Torvalds's avatar
Linus Torvalds committed
88
MODULE_PARM_DESC(max_luns,
89
		 "last scsi LUN (should be between 1 and 2^64-1)");
Linus Torvalds's avatar
Linus Torvalds committed
90

91 92 93 94 95 96
#ifdef CONFIG_SCSI_SCAN_ASYNC
#define SCSI_SCAN_TYPE_DEFAULT "async"
#else
#define SCSI_SCAN_TYPE_DEFAULT "sync"
#endif

Dan Williams's avatar
Dan Williams committed
97
char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
98 99 100 101

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

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

104
module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
Linus Torvalds's avatar
Linus Torvalds committed
105 106
MODULE_PARM_DESC(inq_timeout, 
		 "Timeout (in seconds) waiting for devices to answer INQUIRY."
107
		 " Default is 20. Some devices may need more; most need less.");
Linus Torvalds's avatar
Linus Torvalds committed
108

109
/* This lock protects only this list */
110 111 112 113 114 115 116 117 118 119 120 121
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
 *
122 123 124 125
 * 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.
126 127 128 129 130 131 132
 */
int scsi_complete_async_scans(void)
{
	struct async_scan_data *data;

	do {
		if (list_empty(&scanning_hosts))
133
			return 0;
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
		/* 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);
158 159 160 161 162
	if (!list_empty(&scanning_hosts)) {
		struct async_scan_data *next = list_entry(scanning_hosts.next,
				struct async_scan_data, list);
		complete(&next->prev_finished);
	}
163 164
 done:
	spin_unlock(&async_scan_lock);
165

166
	kfree(data);
167 168 169
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
170 171
/**
 * scsi_unlock_floptical - unlock device via a special MODE SENSE command
172
 * @sdev:	scsi device to send command to
Linus Torvalds's avatar
Linus Torvalds committed
173 174 175
 * @result:	area to store the result of the MODE SENSE
 *
 * Description:
176
 *     Send a vendor specific MODE SENSE (not a MODE SELECT) command.
Linus Torvalds's avatar
Linus Torvalds committed
177 178
 *     Called for BLIST_KEY devices.
 **/
179
static void scsi_unlock_floptical(struct scsi_device *sdev,
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182 183
				  unsigned char *result)
{
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];

184
	sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n");
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188
	scsi_cmd[0] = MODE_SENSE;
	scsi_cmd[1] = 0;
	scsi_cmd[2] = 0x2e;
	scsi_cmd[3] = 0;
189
	scsi_cmd[4] = 0x2a;     /* size */
Linus Torvalds's avatar
Linus Torvalds committed
190
	scsi_cmd[5] = 0;
191
	scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
192
			 SCSI_TIMEOUT, 3, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195 196
}

/**
 * scsi_alloc_sdev - allocate and setup a scsi_Device
197 198 199
 * @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
200 201 202 203 204 205 206 207 208 209
 *
 * 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,
Hannes Reinecke's avatar
Hannes Reinecke committed
210
					   u64 lun, void *hostdata)
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214
{
	struct scsi_device *sdev;
	int display_failure_msg = 1, ret;
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
215
	extern void scsi_evt_thread(struct work_struct *work);
216
	extern void scsi_requeue_run_queue(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
217

218
	sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223 224 225 226
		       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;
227
	sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231 232 233 234 235
	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);
236
	INIT_LIST_HEAD(&sdev->event_list);
Linus Torvalds's avatar
Linus Torvalds committed
237
	spin_lock_init(&sdev->list_lock);
238
	INIT_WORK(&sdev->event_work, scsi_evt_thread);
239
	INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262

	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;

263 264 265 266
	if (shost_use_blk_mq(shost))
		sdev->request_queue = scsi_mq_alloc_queue(sdev);
	else
		sdev->request_queue = scsi_alloc_queue(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270
	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);
271
		kfree(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
272 273
		goto out;
	}
274
	WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));
Linus Torvalds's avatar
Linus Torvalds committed
275
	sdev->request_queue->queuedata = sdev;
276 277 278 279

	if (!shost_use_blk_mq(sdev->host) &&
	    (shost->bqt || shost->hostt->use_blk_tags)) {
		blk_queue_init_tags(sdev->request_queue,
280 281
				    sdev->host->cmd_per_lun, shost->bqt,
				    shost->hostt->tag_alloc_policy);
282
	}
283
	scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
Linus Torvalds's avatar
Linus Torvalds committed
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302

	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:
303
	__scsi_remove_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
304 305
out:
	if (display_failure_msg)
306
		printk(ALLOC_FAILURE_MSG, __func__);
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309
	return NULL;
}

310 311 312 313 314 315
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;

316
	starget->state = STARGET_DEL;
317 318 319 320 321 322 323 324 325
	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
326 327 328 329
static void scsi_target_dev_release(struct device *dev)
{
	struct device *parent = dev->parent;
	struct scsi_target *starget = to_scsi_target(dev);
330

Linus Torvalds's avatar
Linus Torvalds committed
331 332 333 334
	kfree(starget);
	put_device(parent);
}

335
static struct device_type scsi_target_type = {
336 337 338 339
	.name =		"scsi_target",
	.release =	scsi_target_dev_release,
};

Linus Torvalds's avatar
Linus Torvalds committed
340 341
int scsi_is_target_device(const struct device *dev)
{
342
	return dev->type == &scsi_target_type;
Linus Torvalds's avatar
Linus Torvalds committed
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
}
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;
}

367 368 369 370 371 372 373 374 375 376 377 378 379 380
/**
 * 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);

381 382 383 384 385 386 387 388 389
	/*
	 * if we get here and the target is still in the CREATED state that
	 * means it was allocated but never made visible (because a scan
	 * turned up no LUNs), so don't call device_del() on it.
	 */
	if (starget->state != STARGET_CREATED) {
		transport_remove_device(&starget->dev);
		device_del(&starget->dev);
	}
390 391 392 393 394 395 396 397
	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 511 512 513
	/*
	 * serious problem if this triggers: STARGET_DEL is only set in the if
	 * the reap_ref drops to zero, so we're trying to do another final put
	 * on an already released kref
	 */
514
	BUG_ON(starget->state == STARGET_DEL);
515
	scsi_target_reap_ref_put(starget);
Linus Torvalds's avatar
Linus Torvalds committed
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 542 543
/**
 * 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
544 545
/**
 * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
546
 * @sdev:	scsi_device to probe
Linus Torvalds's avatar
Linus Torvalds committed
547
 * @inq_result:	area to store the INQUIRY result
548
 * @result_len: len of inq_result
Linus Torvalds's avatar
Linus Torvalds committed
549 550 551
 * @bflags:	store any bflags found here
 *
 * Description:
552
 *     Probe the lun associated with @req using a standard SCSI INQUIRY;
Linus Torvalds's avatar
Linus Torvalds committed
553
 *
554
 *     If the INQUIRY is successful, zero is returned and the
Linus Torvalds's avatar
Linus Torvalds committed
555
 *     INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
556
 *     are copied to the scsi_device any flags value is stored in *@bflags.
Linus Torvalds's avatar
Linus Torvalds committed
557
 **/
558
static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
559
			  int result_len, int *bflags)
Linus Torvalds's avatar
Linus Torvalds committed
560 561 562 563
{
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
	int first_inquiry_len, try_inquiry_len, next_inquiry_len;
	int response_len = 0;
564
	int pass, count, result;
Linus Torvalds's avatar
Linus Torvalds committed
565 566 567 568 569 570 571 572 573 574 575 576
	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:
577 578 579
	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
580 581 582

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

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

		memset(inq_result, 0, try_inquiry_len);
590 591

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

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

600
		if (result) {
Linus Torvalds's avatar
Linus Torvalds committed
601 602 603 604 605 606
			/*
			 * 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. 
			 */
607
			if ((driver_byte(result) & DRIVER_SENSE) &&
608
			    scsi_sense_valid(&sshdr)) {
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611 612 613 614
				if ((sshdr.sense_key == UNIT_ATTENTION) &&
				    ((sshdr.asc == 0x28) ||
				     (sshdr.asc == 0x29)) &&
				    (sshdr.ascq == 0))
					continue;
			}
615 616 617 618 619 620 621 622
		} 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
623 624 625 626
		}
		break;
	}

627
	if (result == 0) {
628 629 630 631 632
		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
633 634 635 636 637 638
		if (response_len > 255)
			response_len = first_inquiry_len;	/* sanity */

		/*
		 * Get any flags for this device.
		 *
639 640
		 * 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
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
		 * 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) {
667 668 669 670
		sdev_printk(KERN_INFO, sdev,
			    "scsi scan: %d byte inquiry failed.  "
			    "Consider BLIST_INQUIRY_36 for this device\n",
			    try_inquiry_len);
Linus Torvalds's avatar
Linus Torvalds committed
671 672 673 674 675 676 677 678 679 680

		/* 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. */
681 682
	if (result)
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
683 684 685 686 687 688 689 690 691 692 693 694 695

	/* 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.
	 *
696 697 698 699 700 701 702
	 * 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) {
703 704 705
		sdev_printk(KERN_INFO, sdev,
			    "scsi scan: INQUIRY result too short (%d),"
			    " using 36\n", sdev->inquiry_len);
706 707 708 709
		sdev->inquiry_len = 36;
	}

	/*
Linus Torvalds's avatar
Linus Torvalds committed
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
	 * 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++;
731
	sdev->sdev_target->scsi_level = sdev->scsi_level;
Linus Torvalds's avatar
Linus Torvalds committed
732

733 734 735 736 737 738 739 740 741 742
	/*
	 * If SCSI-2 or lower, and if the transport requires it,
	 * store the LUN value in CDB[1].
	 */
	sdev->lun_in_cdb = 0;
	if (sdev->scsi_level <= SCSI_2 &&
	    sdev->scsi_level != SCSI_UNKNOWN &&
	    !sdev->host->no_scsi2_lun_in_cdb)
		sdev->lun_in_cdb = 1;

743
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746
}

/**
747
 * scsi_add_lun - allocate and fully initialze a scsi_device
748
 * @sdev:	holds information to be stored in the new scsi_device
Linus Torvalds's avatar
Linus Torvalds committed
749 750
 * @inq_result:	holds the result of a previous INQUIRY to the LUN
 * @bflags:	black/white list flag
751
 * @async:	1 if this device is being scanned asynchronously
Linus Torvalds's avatar
Linus Torvalds committed
752 753
 *
 * Description:
754 755
 *     Initialize the scsi_device @sdev.  Optionally set fields based
 *     on values in *@bflags.
Linus Torvalds's avatar
Linus Torvalds committed
756 757
 *
 * Return:
758 759
 *     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
760
 **/
761
static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
762
		int *bflags, int async)
Linus Torvalds's avatar
Linus Torvalds committed
763
{
764 765
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
766 767 768 769 770 771 772 773 774 775
	/*
	 * 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.
	 */
776 777 778 779 780 781 782 783 784 785 786 787 788 789

	/*
	 * 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
790 791 792 793 794 795
		return SCSI_SCAN_NO_RESPONSE;

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

796 797 798 799 800 801 802 803 804 805
	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
806
	if (*bflags & BLIST_ISROM) {
807 808 809 810 811
		sdev->type = TYPE_ROM;
		sdev->removable = 1;
	} else {
		sdev->type = (inq_result[0] & 0x1f);
		sdev->removable = (inq_result[1] & 0x80) >> 7;
812 813 814 815 816 817 818 819 820 821 822 823 824

		/*
		 * some devices may respond with wrong type for
		 * well-known logical units. Force well-known type
		 * to enumerate them correctly.
		 */
		if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {
			sdev_printk(KERN_WARNING, sdev,
				"%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n",
				__func__, sdev->type, (unsigned int)sdev->lun);
			sdev->type = TYPE_WLUN;
		}

825
	}
Linus Torvalds's avatar
Linus Torvalds committed
826

827 828 829 830 831 832 833 834 835
	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
836 837 838 839 840 841 842 843 844
	/*
	 * 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
845
	 * scsi_device for a PQ of 1
Linus Torvalds's avatar
Linus Torvalds committed
846 847 848 849 850 851 852 853 854 855
	 *
	 * 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);

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

864
	sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
865 866 867 868 869
			"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
870
	if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
871
	    !(*bflags & BLIST_NOTQ)) {
Linus Torvalds's avatar
Linus Torvalds committed
872
		sdev->tagged_supported = 1;
873 874
		sdev->simple_tags = 1;
	}
875

Linus Torvalds's avatar
Linus Torvalds committed
876 877 878 879 880 881 882 883
	/*
	 * 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;

884 885 886
	if (*bflags & BLIST_NO_ULD_ATTACH)
		sdev->no_uld_attach = 1;

Linus Torvalds's avatar
Linus Torvalds committed
887 888 889 890 891 892 893
	/*
	 * 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;

894 895 896 897 898
	/*
	 * Maximum 512 sector transfer length
	 * broken RA4x00 Compaq Disk Array
	 */
	if (*bflags & BLIST_MAX_512)
899
		blk_queue_max_hw_sectors(sdev->request_queue, 512);
900 901 902 903 904 905
	/*
	 * Max 1024 sector transfer length for targets that report incorrect
	 * max/optimal lengths and relied on the old block layer safe default
	 */
	else if (*bflags & BLIST_MAX_1024)
		blk_queue_max_hw_sectors(sdev->request_queue, 1024);
906

Linus Torvalds's avatar
Linus Torvalds committed
907 908 909 910 911 912 913 914
	/*
	 * 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)
915
		scsi_target(sdev)->single_lun = 1;
Linus Torvalds's avatar
Linus Torvalds committed
916 917 918 919 920 921 922 923 924 925 926 927

	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;

928 929 930 931 932 933
	/* some devices don't like REPORT SUPPORTED OPERATION CODES
	 * and will simply timeout causing sd_mod init to take a very
	 * very long time */
	if (*bflags & BLIST_NO_RSOC)
		sdev->no_report_opcodes = 1;

Linus Torvalds's avatar
Linus Torvalds committed
934 935
	/* set the device running here so that slave configure
	 * may do I/O */
936 937 938 939 940 941 942 943 944 945 946
	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
947 948 949 950 951 952 953 954 955 956

	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;

957 958 959
	if (*bflags & BLIST_NO_DIF)
		sdev->no_dif = 1;

960 961
	sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

962 963 964
	if (*bflags & BLIST_TRY_VPD_PAGES)
		sdev->try_vpd_pages = 1;
	else if (*bflags & BLIST_SKIP_VPD_PAGES)
965 966
		sdev->skip_vpd_pages = 1;

Linus Torvalds's avatar
Linus Torvalds committed
967 968
	transport_configure_device(&sdev->sdev_gendev);

969
	if (sdev->host->hostt->slave_configure) {
970
		ret = sdev->host->hostt->slave_configure(sdev);
971 972 973 974 975 976 977 978 979 980 981 982
		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
983

984 985 986
	if (sdev->scsi_level >= SCSI_3)
		scsi_attach_vpd(sdev);

987 988
	sdev->max_queue_depth = sdev->queue_depth;

Linus Torvalds's avatar
Linus Torvalds committed
989 990 991 992 993
	/*
	 * Ok, the device is now all set up, we can
	 * register it and tell the rest of the kernel
	 * about it.
	 */
994
	if (!async && scsi_sysfs_add_sdev(sdev) != 0)
995
		return SCSI_SCAN_NO_RESPONSE;
Linus Torvalds's avatar
Linus Torvalds committed
996 997 998 999

	return SCSI_SCAN_LUN_PRESENT;
}

1000
#ifdef CONFIG_SCSI_LOGGING
1001
/** 
1002
 * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
1003 1004 1005 1006 1007
 * @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
 */
1008
static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
1009 1010 1011
				   unsigned first, unsigned end)
{
	unsigned term = 0, idx;
1012 1013 1014

	for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
		if (inq[idx+first] > ' ') {
1015 1016 1017 1018 1019 1020 1021 1022 1023
			buf[idx] = inq[idx+first];
			term = idx+1;
		} else {
			buf[idx] = ' ';
		}
	}
	buf[term] = 0;
	return buf;
}
1024
#endif
1025

Linus Torvalds's avatar
Linus Torvalds committed
1026 1027 1028 1029 1030
/**
 * 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
1031 1032 1033
 * @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
1034 1035 1036 1037 1038 1039
 *
 * 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:
1040
 *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
Linus Torvalds's avatar
Linus Torvalds committed
1041 1042
 *     SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
 *         attached at the LUN
1043
 *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
Linus Torvalds's avatar
Linus Torvalds committed
1044 1045
 **/
static int scsi_probe_and_add_lun(struct scsi_target *starget,
Hannes Reinecke's avatar
Hannes Reinecke committed
1046
				  u64 lun, int *bflagsp,
Linus Torvalds's avatar
Linus Torvalds committed
1047 1048 1049 1050 1051
				  struct scsi_device **sdevp, int rescan,
				  void *hostdata)
{
	struct scsi_device *sdev;
	unsigned char *result;
1052
	int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
Linus Torvalds's avatar
Linus Torvalds committed
1053 1054 1055 1056 1057 1058
	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.
	 */
1059 1060
	sdev = scsi_device_lookup_by_target(starget, lun);
	if (sdev) {
1061
		if (rescan || !scsi_device_created(sdev)) {
1062
			SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
Linus Torvalds's avatar
Linus Torvalds committed
1063
				"scsi scan: device exists on %s\n",
1064
				dev_name(&sdev->sdev_gendev)));
Linus Torvalds's avatar
Linus Torvalds committed
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
			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;
		}
1076 1077 1078
		scsi_device_put(sdev);
	} else
		sdev = scsi_alloc_sdev(starget, lun, hostdata);
Linus Torvalds's avatar
Linus Torvalds committed
1079 1080
	if (!sdev)
		goto out;
1081 1082

	result = kmalloc(result_len, GFP_ATOMIC |
Al Viro's avatar
Al Viro committed
1083
			((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
Linus Torvalds's avatar
Linus Torvalds committed
1084
	if (!result)
1085
		goto out_free_sdev;
Linus Torvalds's avatar
Linus Torvalds committed
1086

1087
	if (scsi_probe_lun(sdev, result, result_len, &bflags))
Linus Torvalds's avatar
Linus Torvalds committed
1088 1089
		goto out_free_result;

1090 1091
	if (bflagsp)
		*bflagsp = bflags;
Linus Torvalds's avatar
Linus Torvalds committed
1092 1093 1094
	/*
	 * result contains valid SCSI INQUIRY data.
	 */
1095
	if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
Linus Torvalds's avatar
Linus Torvalds committed
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
		/*
		 * 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.
		 */
1106 1107 1108 1109
		SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
				   " peripheral qualifier of 3, device not"
				   " added\n"))
		if (lun == 0) {
1110 1111 1112 1113 1114
			SCSI_LOG_SCAN_BUS(1, {
				unsigned char vend[9];
				unsigned char mod[17];

				sdev_printk(KERN_INFO, sdev,
1115
					"scsi scan: consider passing scsi_mod."
1116
					"dev_flags=%s:%s:0x240 or 0x1000240\n",
1117
					scsi_inq_str(vend, result, 8, 16),
1118 1119
					scsi_inq_str(mod, result, 16, 32));
			});
1120

1121
		}
1122

Linus Torvalds's avatar
Linus Torvalds committed
1123 1124 1125 1126
		res = SCSI_SCAN_TARGET_PRESENT;
		goto out_free_result;
	}

1127
	/*
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
	 * 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)
1145
	 */
1146
	if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
1147 1148
	    (result[0] & 0x1f) == 0x1f &&
	    !scsi_is_wlun(lun)) {
1149
		SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
1150 1151 1152 1153 1154 1155
					"scsi scan: peripheral device type"
					" of 31, no device added\n"));
		res = SCSI_SCAN_TARGET_PRESENT;
		goto out_free_result;
	}

1156
	res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159
	if (res == SCSI_SCAN_LUN_PRESENT) {
		if (bflags & BLIST_KEY) {
			sdev->lockable = 0;
1160
			scsi_unlock_floptical(sdev, result);
Linus Torvalds's avatar
Linus Torvalds committed
1161 1162 1163 1164 1165 1166 1167 1168
		}
	}

 out_free_result:
	kfree(result);
 out_free_sdev:
	if (res == SCSI_SCAN_LUN_PRESENT) {
		if (sdevp) {
1169 1170 1171 1172 1173 1174
			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
1175
		}
1176
	} else
1177
		__scsi_remove_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
1178 1179 1180 1181 1182 1183 1184 1185
 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
1186 1187
 * @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
1188 1189 1190 1191 1192 1193 1194 1195 1196
 *
 * 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,
1197
				     int bflags, int scsi_level, int rescan)
Linus Torvalds's avatar
Linus Torvalds committed
1198
{
Hannes Reinecke's avatar
Hannes Reinecke committed
1199 1200
	uint max_dev_lun;
	u64 sparse_lun, lun;
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202
	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

1203 1204
	SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget,
		"scsi scan: Sequential scan\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218

	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;

	/*
1219
	 * If less than SCSI_1_CCS, and no special lun scanning, stop
Linus Torvalds's avatar
Linus Torvalds committed
1220
	 * scanning; this matches 2.4 behaviour, but could just be a bug
1221
	 * (to continue scanning a SCSI_1_CCS device).
Linus Torvalds's avatar
Linus Torvalds committed
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
	 *
	 * 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);

1253 1254 1255 1256 1257 1258
	/*
	 * Stop scanning at 255 unless BLIST_SCSI3LUN
	 */
	if (!(bflags & BLIST_SCSI3LUN))
		max_dev_lun = min(256U, max_dev_lun);

Linus Torvalds's avatar
Linus Torvalds committed
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	/*
	 * 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;
}

/**
1272
 * scsilun_to_int - convert a scsi_lun to an int
Linus Torvalds's avatar
Linus Torvalds committed
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
 * @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:
 *     For a description of the LUN format, post SCSI-3 see the SCSI
 *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
 *
1284 1285 1286 1287 1288 1289
 *     Given a struct scsi_lun of: d2 04 0b 03 00 00 00 00, this function
 *     returns the integer: 0x0b03d204
 *
 *     This encoding will return a standard integer LUN for LUNs smaller
 *     than 256, which typically use a single level LUN structure with
 *     addressing method 0.
Linus Torvalds's avatar
Linus Torvalds committed
1290
 **/
Hannes Reinecke's avatar
Hannes Reinecke committed
1291
u64 scsilun_to_int(struct scsi_lun *scsilun)
Linus Torvalds's avatar
Linus Torvalds committed
1292 1293
{
	int i;
Hannes Reinecke's avatar
Hannes Reinecke committed
1294
	u64 lun;
Linus Torvalds's avatar
Linus Torvalds committed
1295 1296 1297

	lun = 0;
	for (i = 0; i < sizeof(lun); i += 2)
1298 1299
		lun = lun | (((u64)scsilun->scsi_lun[i] << ((i + 1) * 8)) |
			     ((u64)scsilun->scsi_lun[i + 1] << (i * 8)));
Linus Torvalds's avatar
Linus Torvalds committed
1300 1301
	return lun;
}
1302
EXPORT_SYMBOL(scsilun_to_int);
Linus Torvalds's avatar
Linus Torvalds committed
1303

1304
/**
1305
 * int_to_scsilun - reverts an int into a scsi_lun
1306
 * @lun:        integer to be reverted
1307 1308 1309 1310 1311 1312 1313 1314
 * @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.
 *
 * Notes:
1315 1316
 *     Given an integer : 0x0b03d204,  this function returns a
 *     struct scsi_lun of: d2 04 0b 03 00 00 00 00
1317 1318
 *
 **/
Hannes Reinecke's avatar
Hannes Reinecke committed
1319
void int_to_scsilun(u64 lun, struct scsi_lun *scsilun)
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
{
	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
1333 1334
/**
 * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
1335 1336 1337
 * @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
1338 1339
 *
 * Description:
1340 1341
 *   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
1342
 *
1343 1344 1345 1346
 *   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.
1347
 *   If starget->no_report_luns is set, return 1 always.
Linus Torvalds's avatar
Linus Torvalds committed
1348 1349 1350
 *
 * Return:
 *     0: scan completed (or no memory, so further scanning is futile)
1351
 *     1: could not scan with REPORT LUN
Linus Torvalds's avatar
Linus Torvalds committed
1352
 **/
1353
static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
Linus Torvalds's avatar
Linus Torvalds committed
1354 1355 1356 1357 1358
				int rescan)
{
	char devname[64];
	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
	unsigned int length;
Hannes Reinecke's avatar
Hannes Reinecke committed
1359
	u64 lun;
Linus Torvalds's avatar
Linus Torvalds committed
1360 1361
	unsigned int num_luns;
	unsigned int retries;
1362
	int result;
Linus Torvalds's avatar
Linus Torvalds committed
1363 1364
	struct scsi_lun *lunp, *lun_data;
	struct scsi_sense_hdr sshdr;
1365 1366
	struct scsi_device *sdev;
	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1367
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1368 1369 1370 1371 1372

	/*
	 * 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.
1373
	 * Don't attempt if the target doesn't support REPORT LUNS.
Linus Torvalds's avatar
Linus Torvalds committed
1374
	 */
1375 1376 1377 1378 1379 1380 1381
	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
1382 1383 1384
		return 1;
	if (bflags & BLIST_NOLUN)
		return 0;
1385 1386
	if (starget->no_report_luns)
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1387

1388 1389 1390 1391
	if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
		sdev = scsi_alloc_sdev(starget, 0, NULL);
		if (!sdev)
			return 0;
1392 1393
		if (scsi_device_get(sdev)) {
			__scsi_remove_device(sdev);
1394
			return 0;
1395
		}
1396 1397
	}

Linus Torvalds's avatar
Linus Torvalds committed
1398
	sprintf(devname, "host %d channel %d id %d",
1399
		shost->host_no, sdev->channel, sdev->id);
Linus Torvalds's avatar
Linus Torvalds committed
1400 1401 1402

	/*
	 * Allocate enough to hold the header (the same size as one scsi_lun)
1403 1404
	 * plus the number of luns we are requesting.  511 was the default
	 * value of the now removed max_report_luns parameter.
Linus Torvalds's avatar
Linus Torvalds committed
1405
	 */
1406 1407
	length = (511 + 1) * sizeof(struct scsi_lun);
retry:
1408
	lun_data = kmalloc(length, GFP_KERNEL |
Linus Torvalds's avatar
Linus Torvalds committed
1409
			   (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1410
	if (!lun_data) {
1411
		printk(ALLOC_FAILURE_MSG, __func__);
1412
		goto out;
1413
	}
Linus Torvalds's avatar
Linus Torvalds committed
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424

	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.
	 */
1425
	put_unaligned_be32(length, &scsi_cmd[6]);
Linus Torvalds's avatar
Linus Torvalds committed
1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440

	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++) {
1441 1442
		SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
				"scsi scan: Sending REPORT LUNS to (try %d)\n",
Linus Torvalds's avatar
Linus Torvalds committed
1443
				retries));
1444 1445

		result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1446
					  lun_data, length, &sshdr,
1447
					  SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1448

1449 1450 1451 1452 1453
		SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
				"scsi scan: REPORT LUNS"
				" %s (try %d) result 0x%x\n",
				result ?  "failed" : "successful",
				retries, result));
1454
		if (result == 0)
Linus Torvalds's avatar
Linus Torvalds committed
1455
			break;
1456
		else if (scsi_sense_valid(&sshdr)) {
Linus Torvalds's avatar
Linus Torvalds committed
1457 1458 1459 1460 1461
			if (sshdr.sense_key != UNIT_ATTENTION)
				break;
		}
	}

1462
	if (result) {
Linus Torvalds's avatar
Linus Torvalds committed
1463 1464 1465
		/*
		 * The device probably does not support a REPORT LUN command
		 */
1466 1467
		ret = 1;
		goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
1468 1469 1470 1471 1472
	}

	/*
	 * Get the length from the first four bytes of lun_data.
	 */
1473 1474 1475 1476 1477 1478 1479
	if (get_unaligned_be32(lun_data->scsi_lun) +
	    sizeof(struct scsi_lun) > length) {
		length = get_unaligned_be32(lun_data->scsi_lun) +
			 sizeof(struct scsi_lun);
		kfree(lun_data);
		goto retry;
	}
1480
	length = get_unaligned_be32(lun_data->scsi_lun);
Linus Torvalds's avatar
Linus Torvalds committed
1481 1482 1483

	num_luns = (length / sizeof(struct scsi_lun));

1484 1485
	SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
		"scsi scan: REPORT LUN scan\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1486 1487 1488 1489 1490 1491 1492 1493

	/*
	 * 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);

Hannes Reinecke's avatar
Hannes Reinecke committed
1494
		if (lun > sdev->host->max_lun) {
1495 1496 1497
			sdev_printk(KERN_WARNING, sdev,
				    "lun%llu has a LUN larger than"
				    " allowed by the host adapter\n", lun);
Linus Torvalds's avatar
Linus Torvalds committed
1498 1499 1500 1501 1502 1503 1504 1505 1506
		} 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.
				 */
1507 1508
				sdev_printk(KERN_ERR, sdev,
					"Unexpected response"
Hannes Reinecke's avatar
Hannes Reinecke committed
1509 1510
					" from lun %llu while scanning, scan"
					" aborted\n", (unsigned long long)lun);
Linus Torvalds's avatar
Linus Torvalds committed
1511 1512 1513 1514 1515
				break;
			}
		}
	}

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

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

1535 1536 1537
	if (strncmp(scsi_scan_type, "none", 4) == 0)
		return ERR_PTR(-ENODEV);

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

1543
	mutex_lock(&shost->scan_mutex);
1544 1545 1546
	if (!shost->async_scan)
		scsi_complete_async_scans();

1547
	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1548
		scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1549 1550
		scsi_autopm_put_host(shost);
	}
1551
	mutex_unlock(&shost->scan_mutex);
1552
	scsi_autopm_put_target(starget);
1553 1554 1555 1556
	/*
	 * 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
1557 1558 1559 1560 1561 1562 1563
	scsi_target_reap(starget);
	put_device(&starget->dev);

	return sdev;
}
EXPORT_SYMBOL(__scsi_add_device);

1564
int scsi_add_device(struct Scsi_Host *host, uint channel,
Hannes Reinecke's avatar