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