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