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