1 /* Driver for USB Mass Storage compliant devices 2 * 3 * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $ 4 * 5 * Current development and maintenance by: 6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 7 * 8 * Developed with the assistance of: 9 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) 10 * (c) 2003 Alan Stern (stern@rowland.harvard.edu) 11 * 12 * Initial work by: 13 * (c) 1999 Michael Gee (michael@linuxspecific.com) 14 * 15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com): 16 * (c) 2000 Yggdrasil Computing, Inc. 17 * 18 * This driver is based on the 'USB Mass Storage Class' document. This 19 * describes in detail the protocol used to communicate with such 20 * devices. Clearly, the designers had SCSI and ATAPI commands in 21 * mind when they created this document. The commands are all very 22 * similar to commands in the SCSI-II and ATAPI specifications. 23 * 24 * It is important to note that in a number of cases this class 25 * exhibits class-specific exemptions from the USB specification. 26 * Notably the usage of NAK, STALL and ACK differs from the norm, in 27 * that they are used to communicate wait, failed and OK on commands. 28 * 29 * Also, for certain devices, the interrupt endpoint is used to convey 30 * status of a command. 31 * 32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more 33 * information about this driver. 34 * 35 * This program is free software; you can redistribute it and/or modify it 36 * under the terms of the GNU General Public License as published by the 37 * Free Software Foundation; either version 2, or (at your option) any 38 * later version. 39 * 40 * This program is distributed in the hope that it will be useful, but 41 * WITHOUT ANY WARRANTY; without even the implied warranty of 42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 43 * General Public License for more details. 44 * 45 * You should have received a copy of the GNU General Public License along 46 * with this program; if not, write to the Free Software Foundation, Inc., 47 * 675 Mass Ave, Cambridge, MA 02139, USA. 48 */ 49 50 #include <linux/config.h> 51 #include <linux/sched.h> 52 #include <linux/errno.h> 53 #include <linux/suspend.h> 54 #include <linux/module.h> 55 #include <linux/init.h> 56 #include <linux/slab.h> 57 #include <linux/kthread.h> 58 #include <linux/mutex.h> 59 60 #include <scsi/scsi.h> 61 #include <scsi/scsi_cmnd.h> 62 #include <scsi/scsi_device.h> 63 64 #include "usb.h" 65 #include "scsiglue.h" 66 #include "transport.h" 67 #include "protocol.h" 68 #include "debug.h" 69 #include "initializers.h" 70 71 #ifdef CONFIG_USB_STORAGE_USBAT 72 #include "shuttle_usbat.h" 73 #endif 74 #ifdef CONFIG_USB_STORAGE_SDDR09 75 #include "sddr09.h" 76 #endif 77 #ifdef CONFIG_USB_STORAGE_SDDR55 78 #include "sddr55.h" 79 #endif 80 #ifdef CONFIG_USB_STORAGE_DPCM 81 #include "dpcm.h" 82 #endif 83 #ifdef CONFIG_USB_STORAGE_FREECOM 84 #include "freecom.h" 85 #endif 86 #ifdef CONFIG_USB_STORAGE_ISD200 87 #include "isd200.h" 88 #endif 89 #ifdef CONFIG_USB_STORAGE_DATAFAB 90 #include "datafab.h" 91 #endif 92 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 93 #include "jumpshot.h" 94 #endif 95 #ifdef CONFIG_USB_STORAGE_ONETOUCH 96 #include "onetouch.h" 97 #endif 98 #ifdef CONFIG_USB_STORAGE_ALAUDA 99 #include "alauda.h" 100 #endif 101 102 /* Some informational data */ 103 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 104 MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 105 MODULE_LICENSE("GPL"); 106 107 static unsigned int delay_use = 5; 108 module_param(delay_use, uint, S_IRUGO | S_IWUSR); 109 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device"); 110 111 112 /* These are used to make sure the module doesn't unload before all the 113 * threads have exited. 114 */ 115 static atomic_t total_threads = ATOMIC_INIT(0); 116 static DECLARE_COMPLETION(threads_gone); 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", __FUNCTION__); 195 if (us->suspend_resume_hook) 196 (us->suspend_resume_hook)(us, US_SUSPEND); 197 iface->dev.power.power_state.event = message.event; 198 199 /* When runtime PM is working, we'll set a flag to indicate 200 * whether we should autoresume when a SCSI request arrives. */ 201 202 mutex_unlock(&us->dev_mutex); 203 return 0; 204 } 205 206 static int storage_resume(struct usb_interface *iface) 207 { 208 struct us_data *us = usb_get_intfdata(iface); 209 210 mutex_lock(&us->dev_mutex); 211 212 US_DEBUGP("%s\n", __FUNCTION__); 213 if (us->suspend_resume_hook) 214 (us->suspend_resume_hook)(us, US_RESUME); 215 iface->dev.power.power_state.event = PM_EVENT_ON; 216 217 mutex_unlock(&us->dev_mutex); 218 return 0; 219 } 220 221 #endif /* CONFIG_PM */ 222 223 /* 224 * The next two routines get called just before and just after 225 * a USB port reset, whether from this driver or a different one. 226 */ 227 228 static void storage_pre_reset(struct usb_interface *iface) 229 { 230 struct us_data *us = usb_get_intfdata(iface); 231 232 US_DEBUGP("%s\n", __FUNCTION__); 233 234 /* Make sure no command runs during the reset */ 235 mutex_lock(&us->dev_mutex); 236 } 237 238 static void storage_post_reset(struct usb_interface *iface) 239 { 240 struct us_data *us = usb_get_intfdata(iface); 241 242 US_DEBUGP("%s\n", __FUNCTION__); 243 244 /* Report the reset to the SCSI core */ 245 scsi_lock(us_to_host(us)); 246 usb_stor_report_bus_reset(us); 247 scsi_unlock(us_to_host(us)); 248 249 /* FIXME: Notify the subdrivers that they need to reinitialize 250 * the device */ 251 mutex_unlock(&us->dev_mutex); 252 } 253 254 /* 255 * fill_inquiry_response takes an unsigned char array (which must 256 * be at least 36 characters) and populates the vendor name, 257 * product name, and revision fields. Then the array is copied 258 * into the SCSI command's response buffer (oddly enough 259 * called request_buffer). data_len contains the length of the 260 * data array, which again must be at least 36. 261 */ 262 263 void fill_inquiry_response(struct us_data *us, unsigned char *data, 264 unsigned int data_len) 265 { 266 if (data_len<36) // You lose. 267 return; 268 269 if(data[0]&0x20) { /* USB device currently not connected. Return 270 peripheral qualifier 001b ("...however, the 271 physical device is not currently connected 272 to this logical unit") and leave vendor and 273 product identification empty. ("If the target 274 does store some of the INQUIRY data on the 275 device, it may return zeros or ASCII spaces 276 (20h) in those fields until the data is 277 available from the device."). */ 278 memset(data+8,0,28); 279 } else { 280 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 281 memcpy(data+8, us->unusual_dev->vendorName, 282 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 283 strlen(us->unusual_dev->vendorName)); 284 memcpy(data+16, us->unusual_dev->productName, 285 strlen(us->unusual_dev->productName) > 16 ? 16 : 286 strlen(us->unusual_dev->productName)); 287 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 288 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 289 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 290 data[35] = 0x30 + ((bcdDevice) & 0x0F); 291 } 292 293 usb_stor_set_xfer_buf(data, data_len, us->srb); 294 } 295 296 static int usb_stor_control_thread(void * __us) 297 { 298 struct us_data *us = (struct us_data *)__us; 299 struct Scsi_Host *host = us_to_host(us); 300 301 current->flags |= PF_NOFREEZE; 302 303 for(;;) { 304 US_DEBUGP("*** thread sleeping.\n"); 305 if(down_interruptible(&us->sema)) 306 break; 307 308 US_DEBUGP("*** thread awakened.\n"); 309 310 /* lock the device pointers */ 311 mutex_lock(&(us->dev_mutex)); 312 313 /* if the device has disconnected, we are free to exit */ 314 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 315 US_DEBUGP("-- exiting\n"); 316 mutex_unlock(&us->dev_mutex); 317 break; 318 } 319 320 /* lock access to the state */ 321 scsi_lock(host); 322 323 /* has the command timed out *already* ? */ 324 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) { 325 us->srb->result = DID_ABORT << 16; 326 goto SkipForAbort; 327 } 328 329 scsi_unlock(host); 330 331 /* reject the command if the direction indicator 332 * is UNKNOWN 333 */ 334 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) { 335 US_DEBUGP("UNKNOWN data direction\n"); 336 us->srb->result = DID_ERROR << 16; 337 } 338 339 /* reject if target != 0 or if LUN is higher than 340 * the maximum known LUN 341 */ 342 else if (us->srb->device->id && 343 !(us->flags & US_FL_SCM_MULT_TARG)) { 344 US_DEBUGP("Bad target number (%d:%d)\n", 345 us->srb->device->id, us->srb->device->lun); 346 us->srb->result = DID_BAD_TARGET << 16; 347 } 348 349 else if (us->srb->device->lun > us->max_lun) { 350 US_DEBUGP("Bad LUN (%d:%d)\n", 351 us->srb->device->id, us->srb->device->lun); 352 us->srb->result = DID_BAD_TARGET << 16; 353 } 354 355 /* Handle those devices which need us to fake 356 * their inquiry data */ 357 else if ((us->srb->cmnd[0] == INQUIRY) && 358 (us->flags & US_FL_FIX_INQUIRY)) { 359 unsigned char data_ptr[36] = { 360 0x00, 0x80, 0x02, 0x02, 361 0x1F, 0x00, 0x00, 0x00}; 362 363 US_DEBUGP("Faking INQUIRY command\n"); 364 fill_inquiry_response(us, data_ptr, 36); 365 us->srb->result = SAM_STAT_GOOD; 366 } 367 368 /* we've got a command, let's do it! */ 369 else { 370 US_DEBUG(usb_stor_show_command(us->srb)); 371 us->proto_handler(us->srb, us); 372 } 373 374 /* lock access to the state */ 375 scsi_lock(host); 376 377 /* indicate that the command is done */ 378 if (us->srb->result != DID_ABORT << 16) { 379 US_DEBUGP("scsi cmd done, result=0x%x\n", 380 us->srb->result); 381 us->srb->scsi_done(us->srb); 382 } else { 383 SkipForAbort: 384 US_DEBUGP("scsi command aborted\n"); 385 } 386 387 /* If an abort request was received we need to signal that 388 * the abort has finished. The proper test for this is 389 * the TIMED_OUT flag, not srb->result == DID_ABORT, because 390 * the timeout might have occurred after the command had 391 * already completed with a different result code. */ 392 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) { 393 complete(&(us->notify)); 394 395 /* Allow USB transfers to resume */ 396 clear_bit(US_FLIDX_ABORTING, &us->flags); 397 clear_bit(US_FLIDX_TIMED_OUT, &us->flags); 398 } 399 400 /* finished working on this command */ 401 us->srb = NULL; 402 scsi_unlock(host); 403 404 /* unlock the device pointers */ 405 mutex_unlock(&us->dev_mutex); 406 } /* for (;;) */ 407 408 scsi_host_put(host); 409 410 /* notify the exit routine that we're actually exiting now 411 * 412 * complete()/wait_for_completion() is similar to up()/down(), 413 * except that complete() is safe in the case where the structure 414 * is getting deleted in a parallel mode of execution (i.e. just 415 * after the down() -- that's necessary for the thread-shutdown 416 * case. 417 * 418 * complete_and_exit() goes even further than this -- it is safe in 419 * the case that the thread of the caller is going away (not just 420 * the structure) -- this is necessary for the module-remove case. 421 * This is important in preemption kernels, which transfer the flow 422 * of execution immediately upon a complete(). 423 */ 424 complete_and_exit(&threads_gone, 0); 425 } 426 427 /*********************************************************************** 428 * Device probing and disconnecting 429 ***********************************************************************/ 430 431 /* Associate our private data with the USB device */ 432 static int associate_dev(struct us_data *us, struct usb_interface *intf) 433 { 434 US_DEBUGP("-- %s\n", __FUNCTION__); 435 436 /* Fill in the device-related fields */ 437 us->pusb_dev = interface_to_usbdev(intf); 438 us->pusb_intf = intf; 439 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 440 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n", 441 le16_to_cpu(us->pusb_dev->descriptor.idVendor), 442 le16_to_cpu(us->pusb_dev->descriptor.idProduct), 443 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice)); 444 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n", 445 intf->cur_altsetting->desc.bInterfaceSubClass, 446 intf->cur_altsetting->desc.bInterfaceProtocol); 447 448 /* Store our private data in the interface */ 449 usb_set_intfdata(intf, us); 450 451 /* Allocate the device-related DMA-mapped buffers */ 452 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 453 GFP_KERNEL, &us->cr_dma); 454 if (!us->cr) { 455 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 456 return -ENOMEM; 457 } 458 459 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 460 GFP_KERNEL, &us->iobuf_dma); 461 if (!us->iobuf) { 462 US_DEBUGP("I/O buffer allocation failed\n"); 463 return -ENOMEM; 464 } 465 466 us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL); 467 if (!us->sensebuf) { 468 US_DEBUGP("Sense buffer allocation failed\n"); 469 return -ENOMEM; 470 } 471 return 0; 472 } 473 474 /* Find an unusual_dev descriptor (always succeeds in the current code) */ 475 static struct us_unusual_dev *find_unusual(const struct usb_device_id *id) 476 { 477 const int id_index = id - storage_usb_ids; 478 return &us_unusual_dev_list[id_index]; 479 } 480 481 /* Get the unusual_devs entries and the string descriptors */ 482 static void get_device_info(struct us_data *us, const struct usb_device_id *id) 483 { 484 struct usb_device *dev = us->pusb_dev; 485 struct usb_interface_descriptor *idesc = 486 &us->pusb_intf->cur_altsetting->desc; 487 struct us_unusual_dev *unusual_dev = find_unusual(id); 488 489 /* Store the entries */ 490 us->unusual_dev = unusual_dev; 491 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 492 idesc->bInterfaceSubClass : 493 unusual_dev->useProtocol; 494 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 495 idesc->bInterfaceProtocol : 496 unusual_dev->useTransport; 497 us->flags = USB_US_ORIG_FLAGS(id->driver_info); 498 499 /* 500 * This flag is only needed when we're in high-speed, so let's 501 * disable it if we're in full-speed 502 */ 503 if (dev->speed != USB_SPEED_HIGH) 504 us->flags &= ~US_FL_GO_SLOW; 505 506 /* Log a message if a non-generic unusual_dev entry contains an 507 * unnecessary subclass or protocol override. This may stimulate 508 * reports from users that will help us remove unneeded entries 509 * from the unusual_devs.h table. 510 */ 511 if (id->idVendor || id->idProduct) { 512 static const char *msgs[3] = { 513 "an unneeded SubClass entry", 514 "an unneeded Protocol entry", 515 "unneeded SubClass and Protocol entries"}; 516 struct usb_device_descriptor *ddesc = &dev->descriptor; 517 int msg = -1; 518 519 if (unusual_dev->useProtocol != US_SC_DEVICE && 520 us->subclass == idesc->bInterfaceSubClass) 521 msg += 1; 522 if (unusual_dev->useTransport != US_PR_DEVICE && 523 us->protocol == idesc->bInterfaceProtocol) 524 msg += 2; 525 if (msg >= 0 && !(us->flags & US_FL_NEED_OVERRIDE)) 526 printk(KERN_NOTICE USB_STORAGE "This device " 527 "(%04x,%04x,%04x S %02x P %02x)" 528 " has %s in unusual_devs.h\n" 529 " Please send a copy of this message to " 530 "<linux-usb-devel@lists.sourceforge.net>\n", 531 le16_to_cpu(ddesc->idVendor), 532 le16_to_cpu(ddesc->idProduct), 533 le16_to_cpu(ddesc->bcdDevice), 534 idesc->bInterfaceSubClass, 535 idesc->bInterfaceProtocol, 536 msgs[msg]); 537 } 538 } 539 540 /* Get the transport settings */ 541 static int get_transport(struct us_data *us) 542 { 543 switch (us->protocol) { 544 case US_PR_CB: 545 us->transport_name = "Control/Bulk"; 546 us->transport = usb_stor_CB_transport; 547 us->transport_reset = usb_stor_CB_reset; 548 us->max_lun = 7; 549 break; 550 551 case US_PR_CBI: 552 us->transport_name = "Control/Bulk/Interrupt"; 553 us->transport = usb_stor_CBI_transport; 554 us->transport_reset = usb_stor_CB_reset; 555 us->max_lun = 7; 556 break; 557 558 case US_PR_BULK: 559 us->transport_name = "Bulk"; 560 us->transport = usb_stor_Bulk_transport; 561 us->transport_reset = usb_stor_Bulk_reset; 562 break; 563 564 #ifdef CONFIG_USB_STORAGE_USBAT 565 case US_PR_USBAT: 566 us->transport_name = "Shuttle USBAT"; 567 us->transport = usbat_transport; 568 us->transport_reset = usb_stor_CB_reset; 569 us->max_lun = 1; 570 break; 571 #endif 572 573 #ifdef CONFIG_USB_STORAGE_SDDR09 574 case US_PR_EUSB_SDDR09: 575 us->transport_name = "EUSB/SDDR09"; 576 us->transport = sddr09_transport; 577 us->transport_reset = usb_stor_CB_reset; 578 us->max_lun = 0; 579 break; 580 #endif 581 582 #ifdef CONFIG_USB_STORAGE_SDDR55 583 case US_PR_SDDR55: 584 us->transport_name = "SDDR55"; 585 us->transport = sddr55_transport; 586 us->transport_reset = sddr55_reset; 587 us->max_lun = 0; 588 break; 589 #endif 590 591 #ifdef CONFIG_USB_STORAGE_DPCM 592 case US_PR_DPCM_USB: 593 us->transport_name = "Control/Bulk-EUSB/SDDR09"; 594 us->transport = dpcm_transport; 595 us->transport_reset = usb_stor_CB_reset; 596 us->max_lun = 1; 597 break; 598 #endif 599 600 #ifdef CONFIG_USB_STORAGE_FREECOM 601 case US_PR_FREECOM: 602 us->transport_name = "Freecom"; 603 us->transport = freecom_transport; 604 us->transport_reset = usb_stor_freecom_reset; 605 us->max_lun = 0; 606 break; 607 #endif 608 609 #ifdef CONFIG_USB_STORAGE_DATAFAB 610 case US_PR_DATAFAB: 611 us->transport_name = "Datafab Bulk-Only"; 612 us->transport = datafab_transport; 613 us->transport_reset = usb_stor_Bulk_reset; 614 us->max_lun = 1; 615 break; 616 #endif 617 618 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 619 case US_PR_JUMPSHOT: 620 us->transport_name = "Lexar Jumpshot Control/Bulk"; 621 us->transport = jumpshot_transport; 622 us->transport_reset = usb_stor_Bulk_reset; 623 us->max_lun = 1; 624 break; 625 #endif 626 627 #ifdef CONFIG_USB_STORAGE_ALAUDA 628 case US_PR_ALAUDA: 629 us->transport_name = "Alauda Control/Bulk"; 630 us->transport = alauda_transport; 631 us->transport_reset = usb_stor_Bulk_reset; 632 us->max_lun = 1; 633 break; 634 #endif 635 636 default: 637 return -EIO; 638 } 639 US_DEBUGP("Transport: %s\n", us->transport_name); 640 641 /* fix for single-lun devices */ 642 if (us->flags & US_FL_SINGLE_LUN) 643 us->max_lun = 0; 644 return 0; 645 } 646 647 /* Get the protocol settings */ 648 static int get_protocol(struct us_data *us) 649 { 650 switch (us->subclass) { 651 case US_SC_RBC: 652 us->protocol_name = "Reduced Block Commands (RBC)"; 653 us->proto_handler = usb_stor_transparent_scsi_command; 654 break; 655 656 case US_SC_8020: 657 us->protocol_name = "8020i"; 658 us->proto_handler = usb_stor_ATAPI_command; 659 us->max_lun = 0; 660 break; 661 662 case US_SC_QIC: 663 us->protocol_name = "QIC-157"; 664 us->proto_handler = usb_stor_qic157_command; 665 us->max_lun = 0; 666 break; 667 668 case US_SC_8070: 669 us->protocol_name = "8070i"; 670 us->proto_handler = usb_stor_ATAPI_command; 671 us->max_lun = 0; 672 break; 673 674 case US_SC_SCSI: 675 us->protocol_name = "Transparent SCSI"; 676 us->proto_handler = usb_stor_transparent_scsi_command; 677 break; 678 679 case US_SC_UFI: 680 us->protocol_name = "Uniform Floppy Interface (UFI)"; 681 us->proto_handler = usb_stor_ufi_command; 682 break; 683 684 #ifdef CONFIG_USB_STORAGE_ISD200 685 case US_SC_ISD200: 686 us->protocol_name = "ISD200 ATA/ATAPI"; 687 us->proto_handler = isd200_ata_command; 688 break; 689 #endif 690 691 default: 692 return -EIO; 693 } 694 US_DEBUGP("Protocol: %s\n", us->protocol_name); 695 return 0; 696 } 697 698 /* Get the pipe settings */ 699 static int get_pipes(struct us_data *us) 700 { 701 struct usb_host_interface *altsetting = 702 us->pusb_intf->cur_altsetting; 703 int i; 704 struct usb_endpoint_descriptor *ep; 705 struct usb_endpoint_descriptor *ep_in = NULL; 706 struct usb_endpoint_descriptor *ep_out = NULL; 707 struct usb_endpoint_descriptor *ep_int = NULL; 708 709 /* 710 * Find the endpoints we need. 711 * We are expecting a minimum of 2 endpoints - in and out (bulk). 712 * An optional interrupt is OK (necessary for CBI protocol). 713 * We will ignore any others. 714 */ 715 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 716 ep = &altsetting->endpoint[i].desc; 717 718 /* Is it a BULK endpoint? */ 719 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 720 == USB_ENDPOINT_XFER_BULK) { 721 /* BULK in or out? */ 722 if (ep->bEndpointAddress & USB_DIR_IN) 723 ep_in = ep; 724 else 725 ep_out = ep; 726 } 727 728 /* Is it an interrupt endpoint? */ 729 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 730 == USB_ENDPOINT_XFER_INT) { 731 ep_int = ep; 732 } 733 } 734 735 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 736 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 737 return -EIO; 738 } 739 740 /* Calculate and store the pipe values */ 741 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 742 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 743 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 744 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 745 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 746 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 747 if (ep_int) { 748 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 749 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 750 us->ep_bInterval = ep_int->bInterval; 751 } 752 return 0; 753 } 754 755 /* Initialize all the dynamic resources we need */ 756 static int usb_stor_acquire_resources(struct us_data *us) 757 { 758 int p; 759 struct task_struct *th; 760 761 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 762 if (!us->current_urb) { 763 US_DEBUGP("URB allocation failed\n"); 764 return -ENOMEM; 765 } 766 767 /* Just before we start our control thread, initialize 768 * the device if it needs initialization */ 769 if (us->unusual_dev->initFunction) { 770 p = us->unusual_dev->initFunction(us); 771 if (p) 772 return p; 773 } 774 775 /* Start up our control thread */ 776 th = kthread_create(usb_stor_control_thread, us, "usb-storage"); 777 if (IS_ERR(th)) { 778 printk(KERN_WARNING USB_STORAGE 779 "Unable to start control thread\n"); 780 return PTR_ERR(th); 781 } 782 783 /* Take a reference to the host for the control thread and 784 * count it among all the threads we have launched. Then 785 * start it up. */ 786 scsi_host_get(us_to_host(us)); 787 atomic_inc(&total_threads); 788 wake_up_process(th); 789 790 return 0; 791 } 792 793 /* Release all our dynamic resources */ 794 static void usb_stor_release_resources(struct us_data *us) 795 { 796 US_DEBUGP("-- %s\n", __FUNCTION__); 797 798 /* Tell the control thread to exit. The SCSI host must 799 * already have been removed so it won't try to queue 800 * any more commands. 801 */ 802 US_DEBUGP("-- sending exit command to thread\n"); 803 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 804 up(&us->sema); 805 806 /* Call the destructor routine, if it exists */ 807 if (us->extra_destructor) { 808 US_DEBUGP("-- calling extra_destructor()\n"); 809 us->extra_destructor(us->extra); 810 } 811 812 /* Free the extra data and the URB */ 813 kfree(us->extra); 814 usb_free_urb(us->current_urb); 815 } 816 817 /* Dissociate from the USB device */ 818 static void dissociate_dev(struct us_data *us) 819 { 820 US_DEBUGP("-- %s\n", __FUNCTION__); 821 822 kfree(us->sensebuf); 823 824 /* Free the device-related DMA-mapped buffers */ 825 if (us->cr) 826 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 827 us->cr_dma); 828 if (us->iobuf) 829 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 830 us->iobuf_dma); 831 832 /* Remove our private data from the interface */ 833 usb_set_intfdata(us->pusb_intf, NULL); 834 } 835 836 /* First stage of disconnect processing: stop all commands and remove 837 * the host */ 838 static void quiesce_and_remove_host(struct us_data *us) 839 { 840 /* Prevent new USB transfers, stop the current command, and 841 * interrupt a SCSI-scan or device-reset delay */ 842 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 843 usb_stor_stop_transport(us); 844 wake_up(&us->delay_wait); 845 846 /* It doesn't matter if the SCSI-scanning thread is still running. 847 * The thread will exit when it sees the DISCONNECTING flag. */ 848 849 /* Wait for the current command to finish, then remove the host */ 850 mutex_lock(&us->dev_mutex); 851 mutex_unlock(&us->dev_mutex); 852 853 /* queuecommand won't accept any new commands and the control 854 * thread won't execute a previously-queued command. If there 855 * is such a command pending, complete it with an error. */ 856 if (us->srb) { 857 us->srb->result = DID_NO_CONNECT << 16; 858 scsi_lock(us_to_host(us)); 859 us->srb->scsi_done(us->srb); 860 us->srb = NULL; 861 scsi_unlock(us_to_host(us)); 862 } 863 864 /* Now we own no commands so it's safe to remove the SCSI host */ 865 scsi_remove_host(us_to_host(us)); 866 } 867 868 /* Second stage of disconnect processing: deallocate all resources */ 869 static void release_everything(struct us_data *us) 870 { 871 usb_stor_release_resources(us); 872 dissociate_dev(us); 873 874 /* Drop our reference to the host; the SCSI core will free it 875 * (and "us" along with it) when the refcount becomes 0. */ 876 scsi_host_put(us_to_host(us)); 877 } 878 879 /* Thread to carry out delayed SCSI-device scanning */ 880 static int usb_stor_scan_thread(void * __us) 881 { 882 struct us_data *us = (struct us_data *)__us; 883 884 printk(KERN_DEBUG 885 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 886 887 /* Wait for the timeout to expire or for a disconnect */ 888 if (delay_use > 0) { 889 printk(KERN_DEBUG "usb-storage: waiting for device " 890 "to settle before scanning\n"); 891 retry: 892 wait_event_interruptible_timeout(us->delay_wait, 893 test_bit(US_FLIDX_DISCONNECTING, &us->flags), 894 delay_use * HZ); 895 if (try_to_freeze()) 896 goto retry; 897 } 898 899 /* If the device is still connected, perform the scanning */ 900 if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 901 902 /* For bulk-only devices, determine the max LUN value */ 903 if (us->protocol == US_PR_BULK && 904 !(us->flags & US_FL_SINGLE_LUN)) { 905 mutex_lock(&us->dev_mutex); 906 us->max_lun = usb_stor_Bulk_max_lun(us); 907 mutex_unlock(&us->dev_mutex); 908 } 909 scsi_scan_host(us_to_host(us)); 910 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 911 912 /* Should we unbind if no devices were detected? */ 913 } 914 915 scsi_host_put(us_to_host(us)); 916 complete_and_exit(&threads_gone, 0); 917 } 918 919 920 /* Probe to see if we can drive a newly-connected USB device */ 921 static int storage_probe(struct usb_interface *intf, 922 const struct usb_device_id *id) 923 { 924 struct Scsi_Host *host; 925 struct us_data *us; 926 int result; 927 struct task_struct *th; 928 929 if (usb_usual_check_type(id, USB_US_TYPE_STOR)) 930 return -ENXIO; 931 932 US_DEBUGP("USB Mass Storage device detected\n"); 933 934 /* 935 * Ask the SCSI layer to allocate a host structure, with extra 936 * space at the end for our private us_data structure. 937 */ 938 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 939 if (!host) { 940 printk(KERN_WARNING USB_STORAGE 941 "Unable to allocate the scsi host\n"); 942 return -ENOMEM; 943 } 944 945 us = host_to_us(host); 946 memset(us, 0, sizeof(struct us_data)); 947 mutex_init(&(us->dev_mutex)); 948 init_MUTEX_LOCKED(&(us->sema)); 949 init_completion(&(us->notify)); 950 init_waitqueue_head(&us->delay_wait); 951 952 /* Associate the us_data structure with the USB device */ 953 result = associate_dev(us, intf); 954 if (result) 955 goto BadDevice; 956 957 /* 958 * Get the unusual_devs entries and the descriptors 959 * 960 * id_index is calculated in the declaration to be the index number 961 * of the match from the usb_device_id table, so we can find the 962 * corresponding entry in the private table. 963 */ 964 get_device_info(us, id); 965 966 /* Get the transport, protocol, and pipe settings */ 967 result = get_transport(us); 968 if (result) 969 goto BadDevice; 970 result = get_protocol(us); 971 if (result) 972 goto BadDevice; 973 result = get_pipes(us); 974 if (result) 975 goto BadDevice; 976 977 /* Acquire all the other resources and add the host */ 978 result = usb_stor_acquire_resources(us); 979 if (result) 980 goto BadDevice; 981 result = scsi_add_host(host, &intf->dev); 982 if (result) { 983 printk(KERN_WARNING USB_STORAGE 984 "Unable to add the scsi host\n"); 985 goto BadDevice; 986 } 987 988 /* Start up the thread for delayed SCSI-device scanning */ 989 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 990 if (IS_ERR(th)) { 991 printk(KERN_WARNING USB_STORAGE 992 "Unable to start the device-scanning thread\n"); 993 quiesce_and_remove_host(us); 994 result = PTR_ERR(th); 995 goto BadDevice; 996 } 997 998 /* Take a reference to the host for the scanning thread and 999 * count it among all the threads we have launched. Then 1000 * start it up. */ 1001 scsi_host_get(us_to_host(us)); 1002 atomic_inc(&total_threads); 1003 wake_up_process(th); 1004 1005 return 0; 1006 1007 /* We come here if there are any problems */ 1008 BadDevice: 1009 US_DEBUGP("storage_probe() failed\n"); 1010 release_everything(us); 1011 return result; 1012 } 1013 1014 /* Handle a disconnect event from the USB core */ 1015 static void storage_disconnect(struct usb_interface *intf) 1016 { 1017 struct us_data *us = usb_get_intfdata(intf); 1018 1019 US_DEBUGP("storage_disconnect() called\n"); 1020 quiesce_and_remove_host(us); 1021 release_everything(us); 1022 } 1023 1024 /*********************************************************************** 1025 * Initialization and registration 1026 ***********************************************************************/ 1027 1028 static struct usb_driver usb_storage_driver = { 1029 .name = "usb-storage", 1030 .probe = storage_probe, 1031 .disconnect = storage_disconnect, 1032 #ifdef CONFIG_PM 1033 .suspend = storage_suspend, 1034 .resume = storage_resume, 1035 #endif 1036 .pre_reset = storage_pre_reset, 1037 .post_reset = storage_post_reset, 1038 .id_table = storage_usb_ids, 1039 }; 1040 1041 static int __init usb_stor_init(void) 1042 { 1043 int retval; 1044 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1045 1046 /* register the driver, return usb_register return code if error */ 1047 retval = usb_register(&usb_storage_driver); 1048 if (retval == 0) { 1049 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1050 usb_usual_set_present(USB_US_TYPE_STOR); 1051 } 1052 return retval; 1053 } 1054 1055 static void __exit usb_stor_exit(void) 1056 { 1057 US_DEBUGP("usb_stor_exit() called\n"); 1058 1059 /* Deregister the driver 1060 * This will cause disconnect() to be called for each 1061 * attached unit 1062 */ 1063 US_DEBUGP("-- calling usb_deregister()\n"); 1064 usb_deregister(&usb_storage_driver) ; 1065 1066 /* Don't return until all of our control and scanning threads 1067 * have exited. Since each thread signals threads_gone as its 1068 * last act, we have to call wait_for_completion the right number 1069 * of times. 1070 */ 1071 while (atomic_read(&total_threads) > 0) { 1072 wait_for_completion(&threads_gone); 1073 atomic_dec(&total_threads); 1074 } 1075 1076 usb_usual_clear_present(USB_US_TYPE_STOR); 1077 } 1078 1079 module_init(usb_stor_init); 1080 module_exit(usb_stor_exit); 1081