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 #include <linux/sched.h> 49 #include <linux/errno.h> 50 #include <linux/freezer.h> 51 #include <linux/module.h> 52 #include <linux/init.h> 53 #include <linux/slab.h> 54 #include <linux/kthread.h> 55 #include <linux/mutex.h> 56 #include <linux/utsname.h> 57 58 #include <scsi/scsi.h> 59 #include <scsi/scsi_cmnd.h> 60 #include <scsi/scsi_device.h> 61 62 #include "usb.h" 63 #include "scsiglue.h" 64 #include "transport.h" 65 #include "protocol.h" 66 #include "debug.h" 67 #include "initializers.h" 68 69 #ifdef CONFIG_USB_STORAGE_ONETOUCH 70 #include "onetouch.h" 71 #endif 72 #ifdef CONFIG_USB_STORAGE_ALAUDA 73 #include "alauda.h" 74 #endif 75 #ifdef CONFIG_USB_STORAGE_KARMA 76 #include "karma.h" 77 #endif 78 #include "sierra_ms.h" 79 #include "option_ms.h" 80 81 /* Some informational data */ 82 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 83 MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 84 MODULE_LICENSE("GPL"); 85 86 static unsigned int delay_use = 5; 87 module_param(delay_use, uint, S_IRUGO | S_IWUSR); 88 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device"); 89 90 static char quirks[128]; 91 module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR); 92 MODULE_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 thorugh 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, use_type) \ 123 { \ 124 .useProtocol = use_protocol, \ 125 .useTransport = use_transport, \ 126 } 127 128 static struct us_unusual_dev us_unusual_dev_list[] = { 129 # include "unusual_devs.h" 130 { } /* Terminating entry */ 131 }; 132 133 #undef UNUSUAL_DEV 134 #undef COMPLIANT_DEV 135 #undef USUAL_DEV 136 137 138 #ifdef CONFIG_PM /* Minimal support for suspend and resume */ 139 140 int usb_stor_suspend(struct usb_interface *iface, pm_message_t message) 141 { 142 struct us_data *us = usb_get_intfdata(iface); 143 144 /* Wait until no command is running */ 145 mutex_lock(&us->dev_mutex); 146 147 US_DEBUGP("%s\n", __func__); 148 if (us->suspend_resume_hook) 149 (us->suspend_resume_hook)(us, US_SUSPEND); 150 151 /* When runtime PM is working, we'll set a flag to indicate 152 * whether we should autoresume when a SCSI request arrives. */ 153 154 mutex_unlock(&us->dev_mutex); 155 return 0; 156 } 157 EXPORT_SYMBOL_GPL(usb_stor_suspend); 158 159 int usb_stor_resume(struct usb_interface *iface) 160 { 161 struct us_data *us = usb_get_intfdata(iface); 162 163 mutex_lock(&us->dev_mutex); 164 165 US_DEBUGP("%s\n", __func__); 166 if (us->suspend_resume_hook) 167 (us->suspend_resume_hook)(us, US_RESUME); 168 169 mutex_unlock(&us->dev_mutex); 170 return 0; 171 } 172 EXPORT_SYMBOL_GPL(usb_stor_resume); 173 174 int usb_stor_reset_resume(struct usb_interface *iface) 175 { 176 struct us_data *us = usb_get_intfdata(iface); 177 178 US_DEBUGP("%s\n", __func__); 179 180 /* Report the reset to the SCSI core */ 181 usb_stor_report_bus_reset(us); 182 183 /* FIXME: Notify the subdrivers that they need to reinitialize 184 * the device */ 185 return 0; 186 } 187 EXPORT_SYMBOL_GPL(usb_stor_reset_resume); 188 189 #endif /* CONFIG_PM */ 190 191 /* 192 * The next two routines get called just before and just after 193 * a USB port reset, whether from this driver or a different one. 194 */ 195 196 int usb_stor_pre_reset(struct usb_interface *iface) 197 { 198 struct us_data *us = usb_get_intfdata(iface); 199 200 US_DEBUGP("%s\n", __func__); 201 202 /* Make sure no command runs during the reset */ 203 mutex_lock(&us->dev_mutex); 204 return 0; 205 } 206 EXPORT_SYMBOL_GPL(usb_stor_pre_reset); 207 208 int usb_stor_post_reset(struct usb_interface *iface) 209 { 210 struct us_data *us = usb_get_intfdata(iface); 211 212 US_DEBUGP("%s\n", __func__); 213 214 /* Report the reset to the SCSI core */ 215 usb_stor_report_bus_reset(us); 216 217 /* FIXME: Notify the subdrivers that they need to reinitialize 218 * the device */ 219 220 mutex_unlock(&us->dev_mutex); 221 return 0; 222 } 223 EXPORT_SYMBOL_GPL(usb_stor_post_reset); 224 225 /* 226 * fill_inquiry_response takes an unsigned char array (which must 227 * be at least 36 characters) and populates the vendor name, 228 * product name, and revision fields. Then the array is copied 229 * into the SCSI command's response buffer (oddly enough 230 * called request_buffer). data_len contains the length of the 231 * data array, which again must be at least 36. 232 */ 233 234 void fill_inquiry_response(struct us_data *us, unsigned char *data, 235 unsigned int data_len) 236 { 237 if (data_len<36) // You lose. 238 return; 239 240 if(data[0]&0x20) { /* USB device currently not connected. Return 241 peripheral qualifier 001b ("...however, the 242 physical device is not currently connected 243 to this logical unit") and leave vendor and 244 product identification empty. ("If the target 245 does store some of the INQUIRY data on the 246 device, it may return zeros or ASCII spaces 247 (20h) in those fields until the data is 248 available from the device."). */ 249 memset(data+8,0,28); 250 } else { 251 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 252 memcpy(data+8, us->unusual_dev->vendorName, 253 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 254 strlen(us->unusual_dev->vendorName)); 255 memcpy(data+16, us->unusual_dev->productName, 256 strlen(us->unusual_dev->productName) > 16 ? 16 : 257 strlen(us->unusual_dev->productName)); 258 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 259 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 260 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 261 data[35] = 0x30 + ((bcdDevice) & 0x0F); 262 } 263 264 usb_stor_set_xfer_buf(data, data_len, us->srb); 265 } 266 EXPORT_SYMBOL_GPL(fill_inquiry_response); 267 268 static int usb_stor_control_thread(void * __us) 269 { 270 struct us_data *us = (struct us_data *)__us; 271 struct Scsi_Host *host = us_to_host(us); 272 273 for(;;) { 274 US_DEBUGP("*** thread sleeping.\n"); 275 if (wait_for_completion_interruptible(&us->cmnd_ready)) 276 break; 277 278 US_DEBUGP("*** thread awakened.\n"); 279 280 /* lock the device pointers */ 281 mutex_lock(&(us->dev_mutex)); 282 283 /* lock access to the state */ 284 scsi_lock(host); 285 286 /* When we are called with no command pending, we're done */ 287 if (us->srb == NULL) { 288 scsi_unlock(host); 289 mutex_unlock(&us->dev_mutex); 290 US_DEBUGP("-- exiting\n"); 291 break; 292 } 293 294 /* has the command timed out *already* ? */ 295 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) { 296 us->srb->result = DID_ABORT << 16; 297 goto SkipForAbort; 298 } 299 300 scsi_unlock(host); 301 302 /* reject the command if the direction indicator 303 * is UNKNOWN 304 */ 305 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) { 306 US_DEBUGP("UNKNOWN data direction\n"); 307 us->srb->result = DID_ERROR << 16; 308 } 309 310 /* reject if target != 0 or if LUN is higher than 311 * the maximum known LUN 312 */ 313 else if (us->srb->device->id && 314 !(us->fflags & US_FL_SCM_MULT_TARG)) { 315 US_DEBUGP("Bad target number (%d:%d)\n", 316 us->srb->device->id, us->srb->device->lun); 317 us->srb->result = DID_BAD_TARGET << 16; 318 } 319 320 else if (us->srb->device->lun > us->max_lun) { 321 US_DEBUGP("Bad LUN (%d:%d)\n", 322 us->srb->device->id, us->srb->device->lun); 323 us->srb->result = DID_BAD_TARGET << 16; 324 } 325 326 /* Handle those devices which need us to fake 327 * their inquiry data */ 328 else if ((us->srb->cmnd[0] == INQUIRY) && 329 (us->fflags & US_FL_FIX_INQUIRY)) { 330 unsigned char data_ptr[36] = { 331 0x00, 0x80, 0x02, 0x02, 332 0x1F, 0x00, 0x00, 0x00}; 333 334 US_DEBUGP("Faking INQUIRY command\n"); 335 fill_inquiry_response(us, data_ptr, 36); 336 us->srb->result = SAM_STAT_GOOD; 337 } 338 339 /* we've got a command, let's do it! */ 340 else { 341 US_DEBUG(usb_stor_show_command(us->srb)); 342 us->proto_handler(us->srb, us); 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 device-related DMA-mapped buffers */ 415 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 416 GFP_KERNEL, &us->cr_dma); 417 if (!us->cr) { 418 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 419 return -ENOMEM; 420 } 421 422 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 423 GFP_KERNEL, &us->iobuf_dma); 424 if (!us->iobuf) { 425 US_DEBUGP("I/O buffer allocation failed\n"); 426 return -ENOMEM; 427 } 428 return 0; 429 } 430 431 /* Works only for digits and letters, but small and fast */ 432 #define TOLOWER(x) ((x) | 0x20) 433 434 /* Adjust device flags based on the "quirks=" module parameter */ 435 static void adjust_quirks(struct us_data *us) 436 { 437 char *p; 438 u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor); 439 u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct); 440 unsigned f = 0; 441 unsigned int mask = (US_FL_SANE_SENSE | 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 447 p = quirks; 448 while (*p) { 449 /* Each entry consists of VID:PID:flags */ 450 if (vid == simple_strtoul(p, &p, 16) && 451 *p == ':' && 452 pid == simple_strtoul(p+1, &p, 16) && 453 *p == ':') 454 break; 455 456 /* Move forward to the next entry */ 457 while (*p) { 458 if (*p++ == ',') 459 break; 460 } 461 } 462 if (!*p) /* No match */ 463 return; 464 465 /* Collect the flags */ 466 while (*++p && *p != ',') { 467 switch (TOLOWER(*p)) { 468 case 'a': 469 f |= US_FL_SANE_SENSE; 470 break; 471 case 'c': 472 f |= US_FL_FIX_CAPACITY; 473 break; 474 case 'h': 475 f |= US_FL_CAPACITY_HEURISTICS; 476 break; 477 case 'i': 478 f |= US_FL_IGNORE_DEVICE; 479 break; 480 case 'l': 481 f |= US_FL_NOT_LOCKABLE; 482 break; 483 case 'm': 484 f |= US_FL_MAX_SECTORS_64; 485 break; 486 case 'o': 487 f |= US_FL_CAPACITY_OK; 488 break; 489 case 'r': 490 f |= US_FL_IGNORE_RESIDUE; 491 break; 492 case 's': 493 f |= US_FL_SINGLE_LUN; 494 break; 495 case 'w': 496 f |= US_FL_NO_WP_DETECT; 497 break; 498 /* Ignore unrecognized flag characters */ 499 } 500 } 501 us->fflags = (us->fflags & ~mask) | f; 502 dev_info(&us->pusb_intf->dev, "Quirks match for " 503 "vid %04x pid %04x: %x\n", 504 vid, pid, f); 505 } 506 507 /* Get the unusual_devs entries and the string descriptors */ 508 static int get_device_info(struct us_data *us, const struct usb_device_id *id, 509 struct us_unusual_dev *unusual_dev) 510 { 511 struct usb_device *dev = us->pusb_dev; 512 struct usb_interface_descriptor *idesc = 513 &us->pusb_intf->cur_altsetting->desc; 514 515 /* Store the entries */ 516 us->unusual_dev = unusual_dev; 517 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 518 idesc->bInterfaceSubClass : 519 unusual_dev->useProtocol; 520 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 521 idesc->bInterfaceProtocol : 522 unusual_dev->useTransport; 523 us->fflags = USB_US_ORIG_FLAGS(id->driver_info); 524 adjust_quirks(us); 525 526 if (us->fflags & US_FL_IGNORE_DEVICE) { 527 printk(KERN_INFO USB_STORAGE "device ignored\n"); 528 return -ENODEV; 529 } 530 531 /* 532 * This flag is only needed when we're in high-speed, so let's 533 * disable it if we're in full-speed 534 */ 535 if (dev->speed != USB_SPEED_HIGH) 536 us->fflags &= ~US_FL_GO_SLOW; 537 538 /* Log a message if a non-generic unusual_dev entry contains an 539 * unnecessary subclass or protocol override. This may stimulate 540 * reports from users that will help us remove unneeded entries 541 * from the unusual_devs.h table. 542 */ 543 if (id->idVendor || id->idProduct) { 544 static const char *msgs[3] = { 545 "an unneeded SubClass entry", 546 "an unneeded Protocol entry", 547 "unneeded SubClass and Protocol entries"}; 548 struct usb_device_descriptor *ddesc = &dev->descriptor; 549 int msg = -1; 550 551 if (unusual_dev->useProtocol != US_SC_DEVICE && 552 us->subclass == idesc->bInterfaceSubClass) 553 msg += 1; 554 if (unusual_dev->useTransport != US_PR_DEVICE && 555 us->protocol == idesc->bInterfaceProtocol) 556 msg += 2; 557 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE)) 558 printk(KERN_NOTICE USB_STORAGE "This device " 559 "(%04x,%04x,%04x S %02x P %02x)" 560 " has %s in unusual_devs.h (kernel" 561 " %s)\n" 562 " Please send a copy of this message to " 563 "<linux-usb@vger.kernel.org> and " 564 "<usb-storage@lists.one-eyed-alien.net>\n", 565 le16_to_cpu(ddesc->idVendor), 566 le16_to_cpu(ddesc->idProduct), 567 le16_to_cpu(ddesc->bcdDevice), 568 idesc->bInterfaceSubClass, 569 idesc->bInterfaceProtocol, 570 msgs[msg], 571 utsname()->release); 572 } 573 574 return 0; 575 } 576 577 /* Get the transport settings */ 578 static void get_transport(struct us_data *us) 579 { 580 switch (us->protocol) { 581 case US_PR_CB: 582 us->transport_name = "Control/Bulk"; 583 us->transport = usb_stor_CB_transport; 584 us->transport_reset = usb_stor_CB_reset; 585 us->max_lun = 7; 586 break; 587 588 case US_PR_CBI: 589 us->transport_name = "Control/Bulk/Interrupt"; 590 us->transport = usb_stor_CB_transport; 591 us->transport_reset = usb_stor_CB_reset; 592 us->max_lun = 7; 593 break; 594 595 case US_PR_BULK: 596 us->transport_name = "Bulk"; 597 us->transport = usb_stor_Bulk_transport; 598 us->transport_reset = usb_stor_Bulk_reset; 599 break; 600 601 #ifdef CONFIG_USB_STORAGE_ALAUDA 602 case US_PR_ALAUDA: 603 us->transport_name = "Alauda Control/Bulk"; 604 us->transport = alauda_transport; 605 us->transport_reset = usb_stor_Bulk_reset; 606 us->max_lun = 1; 607 break; 608 #endif 609 610 #ifdef CONFIG_USB_STORAGE_KARMA 611 case US_PR_KARMA: 612 us->transport_name = "Rio Karma/Bulk"; 613 us->transport = rio_karma_transport; 614 us->transport_reset = usb_stor_Bulk_reset; 615 break; 616 #endif 617 618 } 619 } 620 621 /* Get the protocol settings */ 622 static void get_protocol(struct us_data *us) 623 { 624 switch (us->subclass) { 625 case US_SC_RBC: 626 us->protocol_name = "Reduced Block Commands (RBC)"; 627 us->proto_handler = usb_stor_transparent_scsi_command; 628 break; 629 630 case US_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 US_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 US_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 US_SC_SCSI: 649 us->protocol_name = "Transparent SCSI"; 650 us->proto_handler = usb_stor_transparent_scsi_command; 651 break; 652 653 case US_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 == US_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 printk(KERN_WARNING USB_STORAGE 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 device-related DMA-mapped buffers */ 779 if (us->cr) 780 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 781 us->cr_dma); 782 if (us->iobuf) 783 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 784 us->iobuf_dma); 785 786 /* Remove our private data from the interface */ 787 usb_set_intfdata(us->pusb_intf, NULL); 788 } 789 790 /* First stage of disconnect processing: stop SCSI scanning, 791 * remove the host, and stop accepting new commands 792 */ 793 static void quiesce_and_remove_host(struct us_data *us) 794 { 795 struct Scsi_Host *host = us_to_host(us); 796 797 /* If the device is really gone, cut short reset delays */ 798 if (us->pusb_dev->state == USB_STATE_NOTATTACHED) 799 set_bit(US_FLIDX_DISCONNECTING, &us->dflags); 800 801 /* Prevent SCSI-scanning (if it hasn't started yet) 802 * and wait for the SCSI-scanning thread to stop. 803 */ 804 set_bit(US_FLIDX_DONT_SCAN, &us->dflags); 805 wake_up(&us->delay_wait); 806 wait_for_completion(&us->scanning_done); 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 /* Thread to carry out delayed SCSI-device scanning */ 834 static int usb_stor_scan_thread(void * __us) 835 { 836 struct us_data *us = (struct us_data *)__us; 837 838 printk(KERN_DEBUG 839 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 840 841 set_freezable(); 842 /* Wait for the timeout to expire or for a disconnect */ 843 if (delay_use > 0) { 844 printk(KERN_DEBUG "usb-storage: waiting for device " 845 "to settle before scanning\n"); 846 wait_event_freezable_timeout(us->delay_wait, 847 test_bit(US_FLIDX_DONT_SCAN, &us->dflags), 848 delay_use * HZ); 849 } 850 851 /* If the device is still connected, perform the scanning */ 852 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) { 853 854 /* For bulk-only devices, determine the max LUN value */ 855 if (us->protocol == US_PR_BULK && 856 !(us->fflags & US_FL_SINGLE_LUN)) { 857 mutex_lock(&us->dev_mutex); 858 us->max_lun = usb_stor_Bulk_max_lun(us); 859 mutex_unlock(&us->dev_mutex); 860 } 861 scsi_scan_host(us_to_host(us)); 862 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 863 864 /* Should we unbind if no devices were detected? */ 865 } 866 867 complete_and_exit(&us->scanning_done, 0); 868 } 869 870 871 /* First part of general USB mass-storage probing */ 872 int usb_stor_probe1(struct us_data **pus, 873 struct usb_interface *intf, 874 const struct usb_device_id *id, 875 struct us_unusual_dev *unusual_dev) 876 { 877 struct Scsi_Host *host; 878 struct us_data *us; 879 int result; 880 881 US_DEBUGP("USB Mass Storage device detected\n"); 882 883 /* 884 * Ask the SCSI layer to allocate a host structure, with extra 885 * space at the end for our private us_data structure. 886 */ 887 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 888 if (!host) { 889 printk(KERN_WARNING USB_STORAGE 890 "Unable to allocate the scsi host\n"); 891 return -ENOMEM; 892 } 893 894 /* 895 * Allow 16-byte CDBs and thus > 2TB 896 */ 897 host->max_cmd_len = 16; 898 *pus = us = host_to_us(host); 899 memset(us, 0, sizeof(struct us_data)); 900 mutex_init(&(us->dev_mutex)); 901 init_completion(&us->cmnd_ready); 902 init_completion(&(us->notify)); 903 init_waitqueue_head(&us->delay_wait); 904 init_completion(&us->scanning_done); 905 906 /* Associate the us_data structure with the USB device */ 907 result = associate_dev(us, intf); 908 if (result) 909 goto BadDevice; 910 911 /* Get the unusual_devs entries and the descriptors */ 912 result = get_device_info(us, id, unusual_dev); 913 if (result) 914 goto BadDevice; 915 916 /* Get standard transport and protocol settings */ 917 get_transport(us); 918 get_protocol(us); 919 920 /* Give the caller a chance to fill in specialized transport 921 * or protocol settings. 922 */ 923 return 0; 924 925 BadDevice: 926 US_DEBUGP("storage_probe() failed\n"); 927 release_everything(us); 928 return result; 929 } 930 EXPORT_SYMBOL_GPL(usb_stor_probe1); 931 932 /* Second part of general USB mass-storage probing */ 933 int usb_stor_probe2(struct us_data *us) 934 { 935 struct task_struct *th; 936 int result; 937 938 /* Make sure the transport and protocol have both been set */ 939 if (!us->transport || !us->proto_handler) { 940 result = -ENXIO; 941 goto BadDevice; 942 } 943 US_DEBUGP("Transport: %s\n", us->transport_name); 944 US_DEBUGP("Protocol: %s\n", us->protocol_name); 945 946 /* fix for single-lun devices */ 947 if (us->fflags & US_FL_SINGLE_LUN) 948 us->max_lun = 0; 949 950 /* Find the endpoints and calculate pipe values */ 951 result = get_pipes(us); 952 if (result) 953 goto BadDevice; 954 955 /* Acquire all the other resources and add the host */ 956 result = usb_stor_acquire_resources(us); 957 if (result) 958 goto BadDevice; 959 result = scsi_add_host(us_to_host(us), &us->pusb_intf->dev); 960 if (result) { 961 printk(KERN_WARNING USB_STORAGE 962 "Unable to add the scsi host\n"); 963 goto BadDevice; 964 } 965 966 /* Start up the thread for delayed SCSI-device scanning */ 967 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 968 if (IS_ERR(th)) { 969 printk(KERN_WARNING USB_STORAGE 970 "Unable to start the device-scanning thread\n"); 971 complete(&us->scanning_done); 972 quiesce_and_remove_host(us); 973 result = PTR_ERR(th); 974 goto BadDevice; 975 } 976 977 wake_up_process(th); 978 979 return 0; 980 981 /* We come here if there are any problems */ 982 BadDevice: 983 US_DEBUGP("storage_probe() failed\n"); 984 release_everything(us); 985 return result; 986 } 987 EXPORT_SYMBOL_GPL(usb_stor_probe2); 988 989 /* Handle a USB mass-storage disconnect */ 990 void usb_stor_disconnect(struct usb_interface *intf) 991 { 992 struct us_data *us = usb_get_intfdata(intf); 993 994 US_DEBUGP("storage_disconnect() called\n"); 995 quiesce_and_remove_host(us); 996 release_everything(us); 997 } 998 EXPORT_SYMBOL_GPL(usb_stor_disconnect); 999 1000 /* The main probe routine for standard devices */ 1001 static int storage_probe(struct usb_interface *intf, 1002 const struct usb_device_id *id) 1003 { 1004 struct us_data *us; 1005 int result; 1006 1007 /* 1008 * If libusual is configured, let it decide whether a standard 1009 * device should be handled by usb-storage or by ub. 1010 * If the device isn't standard (is handled by a subdriver 1011 * module) then don't accept it. 1012 */ 1013 if (usb_usual_check_type(id, USB_US_TYPE_STOR) || 1014 usb_usual_ignore_device(intf)) 1015 return -ENXIO; 1016 1017 /* 1018 * Call the general probe procedures. 1019 * 1020 * The unusual_dev_list array is parallel to the usb_storage_usb_ids 1021 * table, so we use the index of the id entry to find the 1022 * corresponding unusual_devs entry. 1023 */ 1024 result = usb_stor_probe1(&us, intf, id, 1025 (id - usb_storage_usb_ids) + us_unusual_dev_list); 1026 if (result) 1027 return result; 1028 1029 /* No special transport or protocol settings in the main module */ 1030 1031 result = usb_stor_probe2(us); 1032 return result; 1033 } 1034 1035 /*********************************************************************** 1036 * Initialization and registration 1037 ***********************************************************************/ 1038 1039 static struct usb_driver usb_storage_driver = { 1040 .name = "usb-storage", 1041 .probe = storage_probe, 1042 .disconnect = usb_stor_disconnect, 1043 .suspend = usb_stor_suspend, 1044 .resume = usb_stor_resume, 1045 .reset_resume = usb_stor_reset_resume, 1046 .pre_reset = usb_stor_pre_reset, 1047 .post_reset = usb_stor_post_reset, 1048 .id_table = usb_storage_usb_ids, 1049 .soft_unbind = 1, 1050 }; 1051 1052 static int __init usb_stor_init(void) 1053 { 1054 int retval; 1055 1056 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1057 1058 /* register the driver, return usb_register return code if error */ 1059 retval = usb_register(&usb_storage_driver); 1060 if (retval == 0) { 1061 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1062 usb_usual_set_present(USB_US_TYPE_STOR); 1063 } 1064 return retval; 1065 } 1066 1067 static void __exit usb_stor_exit(void) 1068 { 1069 US_DEBUGP("usb_stor_exit() called\n"); 1070 1071 /* Deregister the driver 1072 * This will cause disconnect() to be called for each 1073 * attached unit 1074 */ 1075 US_DEBUGP("-- calling usb_deregister()\n"); 1076 usb_deregister(&usb_storage_driver) ; 1077 1078 usb_usual_clear_present(USB_US_TYPE_STOR); 1079 } 1080 1081 module_init(usb_stor_init); 1082 module_exit(usb_stor_exit); 1083