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