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