1/* Driver for USB Mass Storage compliant devices
 
   2 *
   3 * Current development and maintenance by:
   4 *   (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
   5 *
   6 * Developed with the assistance of:
   7 *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
   8 *   (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu)
   9 *
  10 * Initial work by:
  11 *   (c) 1999 Michael Gee (michael@linuxspecific.com)
  12 *
  13 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
  14 *   (c) 2000 Yggdrasil Computing, Inc.
  15 *
  16 * This driver is based on the 'USB Mass Storage Class' document. This
  17 * describes in detail the protocol used to communicate with such
  18 * devices.  Clearly, the designers had SCSI and ATAPI commands in
  19 * mind when they created this document.  The commands are all very
  20 * similar to commands in the SCSI-II and ATAPI specifications.
  21 *
  22 * It is important to note that in a number of cases this class
  23 * exhibits class-specific exemptions from the USB specification.
  24 * Notably the usage of NAK, STALL and ACK differs from the norm, in
  25 * that they are used to communicate wait, failed and OK on commands.
  26 *
  27 * Also, for certain devices, the interrupt endpoint is used to convey
  28 * status of a command.
  29 *
  30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
  31 * information about this driver.
  32 *
  33 * This program is free software; you can redistribute it and/or modify it
  34 * under the terms of the GNU General Public License as published by the
  35 * Free Software Foundation; either version 2, or (at your option) any
  36 * later version.
  37 *
  38 * This program is distributed in the hope that it will be useful, but
  39 * WITHOUT ANY WARRANTY; without even the implied warranty of
  40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41 * General Public License for more details.
  42 *
  43 * You should have received a copy of the GNU General Public License along
  44 * with this program; if not, write to the Free Software Foundation, Inc.,
  45 * 675 Mass Ave, Cambridge, MA 02139, USA.
  46 */
  47
  48#ifdef CONFIG_USB_STORAGE_DEBUG
  49#define DEBUG
  50#endif
  51
  52#include <linux/sched.h>
  53#include <linux/errno.h>
  54#include <linux/freezer.h>
  55#include <linux/module.h>
  56#include <linux/slab.h>
  57#include <linux/kthread.h>
  58#include <linux/mutex.h>
  59#include <linux/utsname.h>
  60
  61#include <scsi/scsi.h>
  62#include <scsi/scsi_cmnd.h>
  63#include <scsi/scsi_device.h>
  64
  65#include "usb.h"
  66#include "scsiglue.h"
  67#include "transport.h"
  68#include "protocol.h"
  69#include "debug.h"
  70#include "initializers.h"
  71
  72#include "sierra_ms.h"
  73#include "option_ms.h"
  74
  75#if IS_ENABLED(CONFIG_USB_UAS)
  76#include "uas-detect.h"
  77#endif
  78
  79#define DRV_NAME "usb-storage"
  80
  81/* Some informational data */
  82MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
  83MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
  84MODULE_LICENSE("GPL");
  85
  86static unsigned int delay_use = 1;
  87module_param(delay_use, uint, S_IRUGO | S_IWUSR);
  88MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
  89
  90static char quirks[128];
  91module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
  92MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
  93
  94
  95/*
  96 * The entries in this table correspond, line for line,
  97 * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
  98 */
  99
 100/* The vendor name should be kept at eight characters or less, and
 
 101 * the product name should be kept at 16 characters or less. If a device
 102 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
 103 * normally generated by a device through the INQUIRY response will be
 104 * taken from this list, and this is the reason for the above size
 105 * restriction. However, if the flag is not present, then you
 106 * are free to use as many characters as you like.
 107 */
 108
 109#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
 110		    vendor_name, product_name, use_protocol, use_transport, \
 111		    init_function, Flags) \
 112{ \
 113	.vendorName = vendor_name,	\
 114	.productName = product_name,	\
 115	.useProtocol = use_protocol,	\
 116	.useTransport = use_transport,	\
 117	.initFunction = init_function,	\
 118}
 119
 120#define COMPLIANT_DEV	UNUSUAL_DEV
 121
 122#define USUAL_DEV(use_protocol, use_transport) \
 123{ \
 124	.useProtocol = use_protocol,	\
 125	.useTransport = use_transport,	\
 126}
 127
 128#define UNUSUAL_VENDOR_INTF(idVendor, cl, sc, pr, \
 129		vendor_name, product_name, use_protocol, use_transport, \
 130		init_function, Flags) \
 131{ \
 132	.vendorName = vendor_name,	\
 133	.productName = product_name,	\
 134	.useProtocol = use_protocol,	\
 135	.useTransport = use_transport,	\
 136	.initFunction = init_function,	\
 137}
 138
 139static struct us_unusual_dev us_unusual_dev_list[] = {
 140#	include "unusual_devs.h"
 141	{ }		/* Terminating entry */
 142};
 143
 144static struct us_unusual_dev for_dynamic_ids =
 145		USUAL_DEV(USB_SC_SCSI, USB_PR_BULK);
 146
 147#undef UNUSUAL_DEV
 148#undef COMPLIANT_DEV
 149#undef USUAL_DEV
 150#undef UNUSUAL_VENDOR_INTF
 151
 152#ifdef CONFIG_LOCKDEP
 153
 154static struct lock_class_key us_interface_key[USB_MAXINTERFACES];
 155
 156static void us_set_lock_class(struct mutex *mutex,
 157		struct usb_interface *intf)
 158{
 159	struct usb_device *udev = interface_to_usbdev(intf);
 160	struct usb_host_config *config = udev->actconfig;
 161	int i;
 162
 163	for (i = 0; i < config->desc.bNumInterfaces; i++) {
 164		if (config->interface[i] == intf)
 165			break;
 166	}
 167
 168	BUG_ON(i == config->desc.bNumInterfaces);
 169
 170	lockdep_set_class(mutex, &us_interface_key[i]);
 171}
 172
 173#else
 174
 175static void us_set_lock_class(struct mutex *mutex,
 176		struct usb_interface *intf)
 177{
 178}
 179
 180#endif
 181
 182#ifdef CONFIG_PM	/* Minimal support for suspend and resume */
 183
 184int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
 185{
 186	struct us_data *us = usb_get_intfdata(iface);
 187
 188	/* Wait until no command is running */
 189	mutex_lock(&us->dev_mutex);
 190
 191	if (us->suspend_resume_hook)
 192		(us->suspend_resume_hook)(us, US_SUSPEND);
 193
 194	/* When runtime PM is working, we'll set a flag to indicate
 195	 * whether we should autoresume when a SCSI request arrives. */
 
 
 196
 197	mutex_unlock(&us->dev_mutex);
 198	return 0;
 199}
 200EXPORT_SYMBOL_GPL(usb_stor_suspend);
 201
 202int usb_stor_resume(struct usb_interface *iface)
 203{
 204	struct us_data *us = usb_get_intfdata(iface);
 205
 206	mutex_lock(&us->dev_mutex);
 207
 208	if (us->suspend_resume_hook)
 209		(us->suspend_resume_hook)(us, US_RESUME);
 210
 211	mutex_unlock(&us->dev_mutex);
 212	return 0;
 213}
 214EXPORT_SYMBOL_GPL(usb_stor_resume);
 215
 216int usb_stor_reset_resume(struct usb_interface *iface)
 217{
 218	struct us_data *us = usb_get_intfdata(iface);
 219
 220	/* Report the reset to the SCSI core */
 221	usb_stor_report_bus_reset(us);
 222
 223	/* FIXME: Notify the subdrivers that they need to reinitialize
 224	 * the device */
 
 
 225	return 0;
 226}
 227EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
 228
 229#endif /* CONFIG_PM */
 230
 231/*
 232 * The next two routines get called just before and just after
 233 * a USB port reset, whether from this driver or a different one.
 234 */
 235
 236int usb_stor_pre_reset(struct usb_interface *iface)
 237{
 238	struct us_data *us = usb_get_intfdata(iface);
 239
 240	/* Make sure no command runs during the reset */
 241	mutex_lock(&us->dev_mutex);
 242	return 0;
 243}
 244EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
 245
 246int usb_stor_post_reset(struct usb_interface *iface)
 247{
 248	struct us_data *us = usb_get_intfdata(iface);
 249
 250	/* Report the reset to the SCSI core */
 251	usb_stor_report_bus_reset(us);
 252
 253	/* FIXME: Notify the subdrivers that they need to reinitialize
 254	 * the device */
 
 
 255
 256	mutex_unlock(&us->dev_mutex);
 257	return 0;
 258}
 259EXPORT_SYMBOL_GPL(usb_stor_post_reset);
 260
 261/*
 262 * fill_inquiry_response takes an unsigned char array (which must
 263 * be at least 36 characters) and populates the vendor name,
 264 * product name, and revision fields. Then the array is copied
 265 * into the SCSI command's response buffer (oddly enough
 266 * called request_buffer). data_len contains the length of the
 267 * data array, which again must be at least 36.
 268 */
 269
 270void fill_inquiry_response(struct us_data *us, unsigned char *data,
 271		unsigned int data_len)
 272{
 273	if (data_len < 36) /* You lose. */
 274		return;
 275
 276	memset(data+8, ' ', 28);
 277	if (data[0]&0x20) { /* USB device currently not connected. Return
 278			      peripheral qualifier 001b ("...however, the
 279			      physical device is not currently connected
 280			      to this logical unit") and leave vendor and
 281			      product identification empty. ("If the target
 282			      does store some of the INQUIRY data on the
 283			      device, it may return zeros or ASCII spaces
 284			      (20h) in those fields until the data is
 285			      available from the device."). */
 
 
 286	} else {
 287		u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
 288		int n;
 289
 290		n = strlen(us->unusual_dev->vendorName);
 291		memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
 292		n = strlen(us->unusual_dev->productName);
 293		memcpy(data+16, us->unusual_dev->productName, min(16, n));
 294
 295		data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
 296		data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
 297		data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
 298		data[35] = 0x30 + ((bcdDevice) & 0x0F);
 299	}
 300
 301	usb_stor_set_xfer_buf(data, data_len, us->srb);
 302}
 303EXPORT_SYMBOL_GPL(fill_inquiry_response);
 304
 305static int usb_stor_control_thread(void * __us)
 306{
 307	struct us_data *us = (struct us_data *)__us;
 308	struct Scsi_Host *host = us_to_host(us);
 309
 310	for (;;) {
 311		usb_stor_dbg(us, "*** thread sleeping\n");
 312		if (wait_for_completion_interruptible(&us->cmnd_ready))
 313			break;
 314
 315		usb_stor_dbg(us, "*** thread awakened\n");
 316
 317		/* lock the device pointers */
 318		mutex_lock(&(us->dev_mutex));
 319
 320		/* lock access to the state */
 321		scsi_lock(host);
 322
 323		/* When we are called with no command pending, we're done */
 324		if (us->srb == NULL) {
 325			scsi_unlock(host);
 326			mutex_unlock(&us->dev_mutex);
 327			usb_stor_dbg(us, "-- exiting\n");
 328			break;
 329		}
 330
 331		/* has the command timed out *already* ? */
 332		if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
 333			us->srb->result = DID_ABORT << 16;
 334			goto SkipForAbort;
 335		}
 336
 337		scsi_unlock(host);
 338
 339		/* reject the command if the direction indicator
 
 340		 * is UNKNOWN
 341		 */
 342		if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
 343			usb_stor_dbg(us, "UNKNOWN data direction\n");
 344			us->srb->result = DID_ERROR << 16;
 345		}
 346
 347		/* reject if target != 0 or if LUN is higher than
 
 348		 * the maximum known LUN
 349		 */
 350		else if (us->srb->device->id &&
 351				!(us->fflags & US_FL_SCM_MULT_TARG)) {
 352			usb_stor_dbg(us, "Bad target number (%d:%llu)\n",
 353				     us->srb->device->id,
 354				     us->srb->device->lun);
 355			us->srb->result = DID_BAD_TARGET << 16;
 356		}
 357
 358		else if (us->srb->device->lun > us->max_lun) {
 359			usb_stor_dbg(us, "Bad LUN (%d:%llu)\n",
 360				     us->srb->device->id,
 361				     us->srb->device->lun);
 362			us->srb->result = DID_BAD_TARGET << 16;
 363		}
 364
 365		/* Handle those devices which need us to fake
 366		 * their inquiry data */
 
 
 367		else if ((us->srb->cmnd[0] == INQUIRY) &&
 368			    (us->fflags & US_FL_FIX_INQUIRY)) {
 369			unsigned char data_ptr[36] = {
 370			    0x00, 0x80, 0x02, 0x02,
 371			    0x1F, 0x00, 0x00, 0x00};
 372
 373			usb_stor_dbg(us, "Faking INQUIRY command\n");
 374			fill_inquiry_response(us, data_ptr, 36);
 375			us->srb->result = SAM_STAT_GOOD;
 376		}
 377
 378		/* we've got a command, let's do it! */
 379		else {
 380			US_DEBUG(usb_stor_show_command(us, us->srb));
 381			us->proto_handler(us->srb, us);
 382			usb_mark_last_busy(us->pusb_dev);
 383		}
 384
 385		/* lock access to the state */
 386		scsi_lock(host);
 387
 388		/* indicate that the command is done */
 389		if (us->srb->result != DID_ABORT << 16) {
 390			usb_stor_dbg(us, "scsi cmd done, result=0x%x\n",
 391				     us->srb->result);
 392			us->srb->scsi_done(us->srb);
 393		} else {
 394SkipForAbort:
 395			usb_stor_dbg(us, "scsi command aborted\n");
 396		}
 397
 398		/* If an abort request was received we need to signal that
 
 399		 * the abort has finished.  The proper test for this is
 400		 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
 401		 * the timeout might have occurred after the command had
 402		 * already completed with a different result code. */
 
 403		if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
 404			complete(&(us->notify));
 405
 406			/* Allow USB transfers to resume */
 407			clear_bit(US_FLIDX_ABORTING, &us->dflags);
 408			clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
 409		}
 410
 411		/* finished working on this command */
 412		us->srb = NULL;
 413		scsi_unlock(host);
 414
 415		/* unlock the device pointers */
 416		mutex_unlock(&us->dev_mutex);
 417	} /* for (;;) */
 418
 419	/* Wait until we are told to stop */
 420	for (;;) {
 421		set_current_state(TASK_INTERRUPTIBLE);
 422		if (kthread_should_stop())
 423			break;
 424		schedule();
 425	}
 426	__set_current_state(TASK_RUNNING);
 427	return 0;
 428}
 429
 430/***********************************************************************
 431 * Device probing and disconnecting
 432 ***********************************************************************/
 433
 434/* Associate our private data with the USB device */
 435static int associate_dev(struct us_data *us, struct usb_interface *intf)
 436{
 437	/* Fill in the device-related fields */
 438	us->pusb_dev = interface_to_usbdev(intf);
 439	us->pusb_intf = intf;
 440	us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
 441	usb_stor_dbg(us, "Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
 442		     le16_to_cpu(us->pusb_dev->descriptor.idVendor),
 443		     le16_to_cpu(us->pusb_dev->descriptor.idProduct),
 444		     le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
 445	usb_stor_dbg(us, "Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
 446		     intf->cur_altsetting->desc.bInterfaceSubClass,
 447		     intf->cur_altsetting->desc.bInterfaceProtocol);
 448
 449	/* Store our private data in the interface */
 450	usb_set_intfdata(intf, us);
 451
 452	/* Allocate the control/setup and DMA-mapped buffers */
 453	us->cr = kmalloc(sizeof(*us->cr), GFP_KERNEL);
 454	if (!us->cr)
 455		return -ENOMEM;
 456
 457	us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE,
 458			GFP_KERNEL, &us->iobuf_dma);
 459	if (!us->iobuf) {
 460		usb_stor_dbg(us, "I/O buffer allocation failed\n");
 461		return -ENOMEM;
 462	}
 463	return 0;
 464}
 465
 466/* Works only for digits and letters, but small and fast */
 467#define TOLOWER(x) ((x) | 0x20)
 468
 469/* Adjust device flags based on the "quirks=" module parameter */
 470void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
 471{
 472	char *p;
 473	u16 vid = le16_to_cpu(udev->descriptor.idVendor);
 474	u16 pid = le16_to_cpu(udev->descriptor.idProduct);
 475	unsigned f = 0;
 476	unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
 477			US_FL_FIX_CAPACITY | US_FL_IGNORE_UAS |
 478			US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
 479			US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
 480			US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
 481			US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
 482			US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
 483			US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE |
 484			US_FL_NO_ATA_1X | US_FL_NO_REPORT_OPCODES |
 485			US_FL_MAX_SECTORS_240 | US_FL_NO_REPORT_LUNS);
 
 486
 487	p = quirks;
 488	while (*p) {
 489		/* Each entry consists of VID:PID:flags */
 490		if (vid == simple_strtoul(p, &p, 16) &&
 491				*p == ':' &&
 492				pid == simple_strtoul(p+1, &p, 16) &&
 493				*p == ':')
 494			break;
 495
 496		/* Move forward to the next entry */
 497		while (*p) {
 498			if (*p++ == ',')
 499				break;
 500		}
 501	}
 502	if (!*p)	/* No match */
 503		return;
 504
 505	/* Collect the flags */
 506	while (*++p && *p != ',') {
 507		switch (TOLOWER(*p)) {
 508		case 'a':
 509			f |= US_FL_SANE_SENSE;
 510			break;
 511		case 'b':
 512			f |= US_FL_BAD_SENSE;
 513			break;
 514		case 'c':
 515			f |= US_FL_FIX_CAPACITY;
 516			break;
 517		case 'd':
 518			f |= US_FL_NO_READ_DISC_INFO;
 519			break;
 520		case 'e':
 521			f |= US_FL_NO_READ_CAPACITY_16;
 522			break;
 523		case 'f':
 524			f |= US_FL_NO_REPORT_OPCODES;
 525			break;
 526		case 'g':
 527			f |= US_FL_MAX_SECTORS_240;
 528			break;
 529		case 'h':
 530			f |= US_FL_CAPACITY_HEURISTICS;
 531			break;
 532		case 'i':
 533			f |= US_FL_IGNORE_DEVICE;
 534			break;
 535		case 'j':
 536			f |= US_FL_NO_REPORT_LUNS;
 537			break;
 538		case 'l':
 539			f |= US_FL_NOT_LOCKABLE;
 540			break;
 541		case 'm':
 542			f |= US_FL_MAX_SECTORS_64;
 543			break;
 544		case 'n':
 545			f |= US_FL_INITIAL_READ10;
 546			break;
 547		case 'o':
 548			f |= US_FL_CAPACITY_OK;
 549			break;
 550		case 'p':
 551			f |= US_FL_WRITE_CACHE;
 552			break;
 553		case 'r':
 554			f |= US_FL_IGNORE_RESIDUE;
 555			break;
 556		case 's':
 557			f |= US_FL_SINGLE_LUN;
 558			break;
 559		case 't':
 560			f |= US_FL_NO_ATA_1X;
 561			break;
 562		case 'u':
 563			f |= US_FL_IGNORE_UAS;
 564			break;
 565		case 'w':
 566			f |= US_FL_NO_WP_DETECT;
 567			break;
 
 
 
 568		/* Ignore unrecognized flag characters */
 569		}
 570	}
 571	*fflags = (*fflags & ~mask) | f;
 572}
 573EXPORT_SYMBOL_GPL(usb_stor_adjust_quirks);
 574
 575/* Get the unusual_devs entries and the string descriptors */
 576static int get_device_info(struct us_data *us, const struct usb_device_id *id,
 577		struct us_unusual_dev *unusual_dev)
 578{
 579	struct usb_device *dev = us->pusb_dev;
 580	struct usb_interface_descriptor *idesc =
 581		&us->pusb_intf->cur_altsetting->desc;
 582	struct device *pdev = &us->pusb_intf->dev;
 583
 584	/* Store the entries */
 585	us->unusual_dev = unusual_dev;
 586	us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
 587			idesc->bInterfaceSubClass :
 588			unusual_dev->useProtocol;
 589	us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
 590			idesc->bInterfaceProtocol :
 591			unusual_dev->useTransport;
 592	us->fflags = id->driver_info;
 593	usb_stor_adjust_quirks(us->pusb_dev, &us->fflags);
 594
 595	if (us->fflags & US_FL_IGNORE_DEVICE) {
 596		dev_info(pdev, "device ignored\n");
 597		return -ENODEV;
 598	}
 599
 600	/*
 601	 * This flag is only needed when we're in high-speed, so let's
 602	 * disable it if we're in full-speed
 603	 */
 604	if (dev->speed != USB_SPEED_HIGH)
 605		us->fflags &= ~US_FL_GO_SLOW;
 606
 607	if (us->fflags)
 608		dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
 609				le16_to_cpu(dev->descriptor.idVendor),
 610				le16_to_cpu(dev->descriptor.idProduct),
 611				us->fflags);
 612
 613	/* Log a message if a non-generic unusual_dev entry contains an
 
 614	 * unnecessary subclass or protocol override.  This may stimulate
 615	 * reports from users that will help us remove unneeded entries
 616	 * from the unusual_devs.h table.
 617	 */
 618	if (id->idVendor || id->idProduct) {
 619		static const char *msgs[3] = {
 620			"an unneeded SubClass entry",
 621			"an unneeded Protocol entry",
 622			"unneeded SubClass and Protocol entries"};
 623		struct usb_device_descriptor *ddesc = &dev->descriptor;
 624		int msg = -1;
 625
 626		if (unusual_dev->useProtocol != USB_SC_DEVICE &&
 627			us->subclass == idesc->bInterfaceSubClass)
 628			msg += 1;
 629		if (unusual_dev->useTransport != USB_PR_DEVICE &&
 630			us->protocol == idesc->bInterfaceProtocol)
 631			msg += 2;
 632		if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
 633			dev_notice(pdev, "This device "
 634					"(%04x,%04x,%04x S %02x P %02x)"
 635					" has %s in unusual_devs.h (kernel"
 636					" %s)\n"
 637					"   Please send a copy of this message to "
 638					"<linux-usb@vger.kernel.org> and "
 639					"<usb-storage@lists.one-eyed-alien.net>\n",
 640					le16_to_cpu(ddesc->idVendor),
 641					le16_to_cpu(ddesc->idProduct),
 642					le16_to_cpu(ddesc->bcdDevice),
 643					idesc->bInterfaceSubClass,
 644					idesc->bInterfaceProtocol,
 645					msgs[msg],
 646					utsname()->release);
 647	}
 648
 649	return 0;
 650}
 651
 652/* Get the transport settings */
 653static void get_transport(struct us_data *us)
 654{
 655	switch (us->protocol) {
 656	case USB_PR_CB:
 657		us->transport_name = "Control/Bulk";
 658		us->transport = usb_stor_CB_transport;
 659		us->transport_reset = usb_stor_CB_reset;
 660		us->max_lun = 7;
 661		break;
 662
 663	case USB_PR_CBI:
 664		us->transport_name = "Control/Bulk/Interrupt";
 665		us->transport = usb_stor_CB_transport;
 666		us->transport_reset = usb_stor_CB_reset;
 667		us->max_lun = 7;
 668		break;
 669
 670	case USB_PR_BULK:
 671		us->transport_name = "Bulk";
 672		us->transport = usb_stor_Bulk_transport;
 673		us->transport_reset = usb_stor_Bulk_reset;
 674		break;
 675	}
 676}
 677
 678/* Get the protocol settings */
 679static void get_protocol(struct us_data *us)
 680{
 681	switch (us->subclass) {
 682	case USB_SC_RBC:
 683		us->protocol_name = "Reduced Block Commands (RBC)";
 684		us->proto_handler = usb_stor_transparent_scsi_command;
 685		break;
 686
 687	case USB_SC_8020:
 688		us->protocol_name = "8020i";
 689		us->proto_handler = usb_stor_pad12_command;
 690		us->max_lun = 0;
 691		break;
 692
 693	case USB_SC_QIC:
 694		us->protocol_name = "QIC-157";
 695		us->proto_handler = usb_stor_pad12_command;
 696		us->max_lun = 0;
 697		break;
 698
 699	case USB_SC_8070:
 700		us->protocol_name = "8070i";
 701		us->proto_handler = usb_stor_pad12_command;
 702		us->max_lun = 0;
 703		break;
 704
 705	case USB_SC_SCSI:
 706		us->protocol_name = "Transparent SCSI";
 707		us->proto_handler = usb_stor_transparent_scsi_command;
 708		break;
 709
 710	case USB_SC_UFI:
 711		us->protocol_name = "Uniform Floppy Interface (UFI)";
 712		us->proto_handler = usb_stor_ufi_command;
 713		break;
 714	}
 715}
 716
 717/* Get the pipe settings */
 718static int get_pipes(struct us_data *us)
 719{
 720	struct usb_host_interface *altsetting =
 721		us->pusb_intf->cur_altsetting;
 722	int i;
 723	struct usb_endpoint_descriptor *ep;
 724	struct usb_endpoint_descriptor *ep_in = NULL;
 725	struct usb_endpoint_descriptor *ep_out = NULL;
 726	struct usb_endpoint_descriptor *ep_int = NULL;
 727
 728	/*
 729	 * Find the first endpoint of each type we need.
 730	 * We are expecting a minimum of 2 endpoints - in and out (bulk).
 731	 * An optional interrupt-in is OK (necessary for CBI protocol).
 732	 * We will ignore any others.
 733	 */
 734	for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
 735		ep = &altsetting->endpoint[i].desc;
 736
 737		if (usb_endpoint_xfer_bulk(ep)) {
 738			if (usb_endpoint_dir_in(ep)) {
 739				if (!ep_in)
 740					ep_in = ep;
 741			} else {
 742				if (!ep_out)
 743					ep_out = ep;
 744			}
 745		}
 746
 747		else if (usb_endpoint_is_int_in(ep)) {
 748			if (!ep_int)
 749				ep_int = ep;
 750		}
 751	}
 752
 753	if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
 754		usb_stor_dbg(us, "Endpoint sanity check failed! Rejecting dev.\n");
 755		return -EIO;
 756	}
 757
 758	/* Calculate and store the pipe values */
 759	us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
 760	us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
 761	us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
 762		usb_endpoint_num(ep_out));
 763	us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
 764		usb_endpoint_num(ep_in));
 765	if (ep_int) {
 766		us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
 767			usb_endpoint_num(ep_int));
 768		us->ep_bInterval = ep_int->bInterval;
 769	}
 770	return 0;
 771}
 772
 773/* Initialize all the dynamic resources we need */
 774static int usb_stor_acquire_resources(struct us_data *us)
 775{
 776	int p;
 777	struct task_struct *th;
 778
 779	us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
 780	if (!us->current_urb) {
 781		usb_stor_dbg(us, "URB allocation failed\n");
 782		return -ENOMEM;
 783	}
 784
 785	/* Just before we start our control thread, initialize
 786	 * the device if it needs initialization */
 
 
 787	if (us->unusual_dev->initFunction) {
 788		p = us->unusual_dev->initFunction(us);
 789		if (p)
 790			return p;
 791	}
 792
 793	/* Start up our control thread */
 794	th = kthread_run(usb_stor_control_thread, us, "usb-storage");
 795	if (IS_ERR(th)) {
 796		dev_warn(&us->pusb_intf->dev,
 797				"Unable to start control thread\n");
 798		return PTR_ERR(th);
 799	}
 800	us->ctl_thread = th;
 801
 802	return 0;
 803}
 804
 805/* Release all our dynamic resources */
 806static void usb_stor_release_resources(struct us_data *us)
 807{
 808	/* Tell the control thread to exit.  The SCSI host must
 
 809	 * already have been removed and the DISCONNECTING flag set
 810	 * so that we won't accept any more commands.
 811	 */
 812	usb_stor_dbg(us, "-- sending exit command to thread\n");
 813	complete(&us->cmnd_ready);
 814	if (us->ctl_thread)
 815		kthread_stop(us->ctl_thread);
 816
 817	/* Call the destructor routine, if it exists */
 818	if (us->extra_destructor) {
 819		usb_stor_dbg(us, "-- calling extra_destructor()\n");
 820		us->extra_destructor(us->extra);
 821	}
 822
 823	/* Free the extra data and the URB */
 824	kfree(us->extra);
 825	usb_free_urb(us->current_urb);
 826}
 827
 828/* Dissociate from the USB device */
 829static void dissociate_dev(struct us_data *us)
 830{
 831	/* Free the buffers */
 832	kfree(us->cr);
 833	usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
 834
 835	/* Remove our private data from the interface */
 836	usb_set_intfdata(us->pusb_intf, NULL);
 837}
 838
 839/* First stage of disconnect processing: stop SCSI scanning,
 
 840 * remove the host, and stop accepting new commands
 841 */
 842static void quiesce_and_remove_host(struct us_data *us)
 843{
 844	struct Scsi_Host *host = us_to_host(us);
 845
 846	/* If the device is really gone, cut short reset delays */
 847	if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
 848		set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 849		wake_up(&us->delay_wait);
 850	}
 851
 852	/* Prevent SCSI scanning (if it hasn't started yet)
 
 853	 * or wait for the SCSI-scanning routine to stop.
 854	 */
 855	cancel_delayed_work_sync(&us->scan_dwork);
 856
 857	/* Balance autopm calls if scanning was cancelled */
 858	if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
 859		usb_autopm_put_interface_no_suspend(us->pusb_intf);
 860
 861	/* Removing the host will perform an orderly shutdown: caches
 
 862	 * synchronized, disks spun down, etc.
 863	 */
 864	scsi_remove_host(host);
 865
 866	/* Prevent any new commands from being accepted and cut short
 
 867	 * reset delays.
 868	 */
 869	scsi_lock(host);
 870	set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 871	scsi_unlock(host);
 872	wake_up(&us->delay_wait);
 873}
 874
 875/* Second stage of disconnect processing: deallocate all resources */
 876static void release_everything(struct us_data *us)
 877{
 878	usb_stor_release_resources(us);
 879	dissociate_dev(us);
 880
 881	/* Drop our reference to the host; the SCSI core will free it
 882	 * (and "us" along with it) when the refcount becomes 0. */
 
 
 883	scsi_host_put(us_to_host(us));
 884}
 885
 886/* Delayed-work routine to carry out SCSI-device scanning */
 887static void usb_stor_scan_dwork(struct work_struct *work)
 888{
 889	struct us_data *us = container_of(work, struct us_data,
 890			scan_dwork.work);
 891	struct device *dev = &us->pusb_intf->dev;
 892
 893	dev_dbg(dev, "starting scan\n");
 894
 895	/* For bulk-only devices, determine the max LUN value */
 896	if (us->protocol == USB_PR_BULK &&
 897	    !(us->fflags & US_FL_SINGLE_LUN) &&
 898	    !(us->fflags & US_FL_SCM_MULT_TARG)) {
 899		mutex_lock(&us->dev_mutex);
 900		us->max_lun = usb_stor_Bulk_max_lun(us);
 901		/*
 902		 * Allow proper scanning of devices that present more than 8 LUNs
 903		 * While not affecting other devices that may need the previous behavior
 
 904		 */
 905		if (us->max_lun >= 8)
 906			us_to_host(us)->max_lun = us->max_lun+1;
 907		mutex_unlock(&us->dev_mutex);
 908	}
 909	scsi_scan_host(us_to_host(us));
 910	dev_dbg(dev, "scan complete\n");
 911
 912	/* Should we unbind if no devices were detected? */
 913
 914	usb_autopm_put_interface(us->pusb_intf);
 915	clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
 916}
 917
 918static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
 919{
 920	struct usb_device *usb_dev = interface_to_usbdev(intf);
 921
 922	if (usb_dev->bus->sg_tablesize) {
 923		return usb_dev->bus->sg_tablesize;
 924	}
 925	return SG_ALL;
 926}
 927
 928/* First part of general USB mass-storage probing */
 929int usb_stor_probe1(struct us_data **pus,
 930		struct usb_interface *intf,
 931		const struct usb_device_id *id,
 932		struct us_unusual_dev *unusual_dev,
 933		struct scsi_host_template *sht)
 934{
 935	struct Scsi_Host *host;
 936	struct us_data *us;
 937	int result;
 938
 939	dev_info(&intf->dev, "USB Mass Storage device detected\n");
 940
 941	/*
 942	 * Ask the SCSI layer to allocate a host structure, with extra
 943	 * space at the end for our private us_data structure.
 944	 */
 945	host = scsi_host_alloc(sht, sizeof(*us));
 946	if (!host) {
 947		dev_warn(&intf->dev, "Unable to allocate the scsi host\n");
 948		return -ENOMEM;
 949	}
 950
 951	/*
 952	 * Allow 16-byte CDBs and thus > 2TB
 953	 */
 954	host->max_cmd_len = 16;
 955	host->sg_tablesize = usb_stor_sg_tablesize(intf);
 956	*pus = us = host_to_us(host);
 957	mutex_init(&(us->dev_mutex));
 958	us_set_lock_class(&us->dev_mutex, intf);
 959	init_completion(&us->cmnd_ready);
 960	init_completion(&(us->notify));
 961	init_waitqueue_head(&us->delay_wait);
 962	INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
 963
 964	/* Associate the us_data structure with the USB device */
 965	result = associate_dev(us, intf);
 966	if (result)
 967		goto BadDevice;
 968
 969	/* Get the unusual_devs entries and the descriptors */
 970	result = get_device_info(us, id, unusual_dev);
 971	if (result)
 972		goto BadDevice;
 973
 974	/* Get standard transport and protocol settings */
 975	get_transport(us);
 976	get_protocol(us);
 977
 978	/* Give the caller a chance to fill in specialized transport
 
 979	 * or protocol settings.
 980	 */
 981	return 0;
 982
 983BadDevice:
 984	usb_stor_dbg(us, "storage_probe() failed\n");
 985	release_everything(us);
 986	return result;
 987}
 988EXPORT_SYMBOL_GPL(usb_stor_probe1);
 989
 990/* Second part of general USB mass-storage probing */
 991int usb_stor_probe2(struct us_data *us)
 992{
 993	int result;
 994	struct device *dev = &us->pusb_intf->dev;
 995
 996	/* Make sure the transport and protocol have both been set */
 997	if (!us->transport || !us->proto_handler) {
 998		result = -ENXIO;
 999		goto BadDevice;
1000	}
1001	usb_stor_dbg(us, "Transport: %s\n", us->transport_name);
1002	usb_stor_dbg(us, "Protocol: %s\n", us->protocol_name);
1003
1004	if (us->fflags & US_FL_SCM_MULT_TARG) {
1005		/*
1006		 * SCM eUSCSI bridge devices can have different numbers
1007		 * of LUNs on different targets; allow all to be probed.
1008		 */
1009		us->max_lun = 7;
1010		/* The eUSCSI itself has ID 7, so avoid scanning that */
1011		us_to_host(us)->this_id = 7;
1012		/* max_id is 8 initially, so no need to set it here */
1013	} else {
1014		/* In the normal case there is only a single target */
1015		us_to_host(us)->max_id = 1;
1016		/*
1017		 * Like Windows, we won't store the LUN bits in CDB[1] for
1018		 * SCSI-2 devices using the Bulk-Only transport (even though
1019		 * this violates the SCSI spec).
1020		 */
1021		if (us->transport == usb_stor_Bulk_transport)
1022			us_to_host(us)->no_scsi2_lun_in_cdb = 1;
1023	}
1024
1025	/* fix for single-lun devices */
1026	if (us->fflags & US_FL_SINGLE_LUN)
1027		us->max_lun = 0;
1028
1029	/* Find the endpoints and calculate pipe values */
1030	result = get_pipes(us);
1031	if (result)
1032		goto BadDevice;
1033
1034	/*
1035	 * If the device returns invalid data for the first READ(10)
1036	 * command, indicate the command should be retried.
1037	 */
1038	if (us->fflags & US_FL_INITIAL_READ10)
1039		set_bit(US_FLIDX_REDO_READ10, &us->dflags);
1040
1041	/* Acquire all the other resources and add the host */
1042	result = usb_stor_acquire_resources(us);
1043	if (result)
1044		goto BadDevice;
 
1045	snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
1046					dev_name(&us->pusb_intf->dev));
1047	result = scsi_add_host(us_to_host(us), dev);
1048	if (result) {
1049		dev_warn(dev,
1050				"Unable to add the scsi host\n");
1051		goto BadDevice;
1052	}
1053
1054	/* Submit the delayed_work for SCSI-device scanning */
1055	usb_autopm_get_interface_no_resume(us->pusb_intf);
1056	set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
1057
1058	if (delay_use > 0)
1059		dev_dbg(dev, "waiting for device to settle before scanning\n");
1060	queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1061			delay_use * HZ);
1062	return 0;
1063
1064	/* We come here if there are any problems */
 
 
1065BadDevice:
1066	usb_stor_dbg(us, "storage_probe() failed\n");
1067	release_everything(us);
1068	return result;
1069}
1070EXPORT_SYMBOL_GPL(usb_stor_probe2);
1071
1072/* Handle a USB mass-storage disconnect */
1073void usb_stor_disconnect(struct usb_interface *intf)
1074{
1075	struct us_data *us = usb_get_intfdata(intf);
1076
1077	quiesce_and_remove_host(us);
1078	release_everything(us);
1079}
1080EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1081
1082static struct scsi_host_template usb_stor_host_template;
1083
1084/* The main probe routine for standard devices */
1085static int storage_probe(struct usb_interface *intf,
1086			 const struct usb_device_id *id)
1087{
1088	struct us_unusual_dev *unusual_dev;
1089	struct us_data *us;
1090	int result;
1091	int size;
1092
1093	/* If uas is enabled and this device can do uas then ignore it. */
1094#if IS_ENABLED(CONFIG_USB_UAS)
1095	if (uas_use_uas_driver(intf, id, NULL))
1096		return -ENXIO;
1097#endif
1098
1099	/*
1100	 * If the device isn't standard (is handled by a subdriver
1101	 * module) then don't accept it.
1102	 */
1103	if (usb_usual_ignore_device(intf))
1104		return -ENXIO;
1105
1106	/*
1107	 * Call the general probe procedures.
1108	 *
1109	 * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1110	 * table, so we use the index of the id entry to find the
1111	 * corresponding unusual_devs entry.
1112	 */
1113
1114	size = ARRAY_SIZE(us_unusual_dev_list);
1115	if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1116		unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1117	} else {
1118		unusual_dev = &for_dynamic_ids;
1119
1120		dev_dbg(&intf->dev, "Use Bulk-Only transport with the Transparent SCSI protocol for dynamic id: 0x%04x 0x%04x\n",
1121			id->idVendor, id->idProduct);
1122	}
1123
1124	result = usb_stor_probe1(&us, intf, id, unusual_dev,
1125				 &usb_stor_host_template);
1126	if (result)
1127		return result;
1128
1129	/* No special transport or protocol settings in the main module */
1130
1131	result = usb_stor_probe2(us);
1132	return result;
1133}
1134
1135static struct usb_driver usb_storage_driver = {
1136	.name =		DRV_NAME,
1137	.probe =	storage_probe,
1138	.disconnect =	usb_stor_disconnect,
1139	.suspend =	usb_stor_suspend,
1140	.resume =	usb_stor_resume,
1141	.reset_resume =	usb_stor_reset_resume,
1142	.pre_reset =	usb_stor_pre_reset,
1143	.post_reset =	usb_stor_post_reset,
1144	.id_table =	usb_storage_usb_ids,
1145	.supports_autosuspend = 1,
1146	.soft_unbind =	1,
1147};
1148
1149module_usb_stor_driver(usb_storage_driver, usb_stor_host_template, DRV_NAME);