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