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