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