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 #include <linux/utsrelease.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 UTS_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 endpoints we need. 735 * We are expecting a minimum of 2 endpoints - in and out (bulk). 736 * An optional interrupt 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 /* Is it a BULK endpoint? */ 743 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 744 == USB_ENDPOINT_XFER_BULK) { 745 /* BULK in or out? */ 746 if (ep->bEndpointAddress & USB_DIR_IN) 747 ep_in = ep; 748 else 749 ep_out = ep; 750 } 751 752 /* Is it an interrupt endpoint? */ 753 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 754 == USB_ENDPOINT_XFER_INT) { 755 ep_int = ep; 756 } 757 } 758 759 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 760 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 761 return -EIO; 762 } 763 764 /* Calculate and store the pipe values */ 765 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 766 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 767 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 768 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 769 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 770 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 771 if (ep_int) { 772 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 773 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 774 us->ep_bInterval = ep_int->bInterval; 775 } 776 return 0; 777 } 778 779 /* Initialize all the dynamic resources we need */ 780 static int usb_stor_acquire_resources(struct us_data *us) 781 { 782 int p; 783 struct task_struct *th; 784 785 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 786 if (!us->current_urb) { 787 US_DEBUGP("URB allocation failed\n"); 788 return -ENOMEM; 789 } 790 791 /* Just before we start our control thread, initialize 792 * the device if it needs initialization */ 793 if (us->unusual_dev->initFunction) { 794 p = us->unusual_dev->initFunction(us); 795 if (p) 796 return p; 797 } 798 799 /* Start up our control thread */ 800 th = kthread_create(usb_stor_control_thread, us, "usb-storage"); 801 if (IS_ERR(th)) { 802 printk(KERN_WARNING USB_STORAGE 803 "Unable to start control thread\n"); 804 return PTR_ERR(th); 805 } 806 807 /* Take a reference to the host for the control thread and 808 * count it among all the threads we have launched. Then 809 * start it up. */ 810 scsi_host_get(us_to_host(us)); 811 atomic_inc(&total_threads); 812 wake_up_process(th); 813 814 return 0; 815 } 816 817 /* Release all our dynamic resources */ 818 static void usb_stor_release_resources(struct us_data *us) 819 { 820 US_DEBUGP("-- %s\n", __FUNCTION__); 821 822 /* Tell the control thread to exit. The SCSI host must 823 * already have been removed so it won't try to queue 824 * any more commands. 825 */ 826 US_DEBUGP("-- sending exit command to thread\n"); 827 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 828 up(&us->sema); 829 830 /* Call the destructor routine, if it exists */ 831 if (us->extra_destructor) { 832 US_DEBUGP("-- calling extra_destructor()\n"); 833 us->extra_destructor(us->extra); 834 } 835 836 /* Free the extra data and the URB */ 837 kfree(us->extra); 838 usb_free_urb(us->current_urb); 839 } 840 841 /* Dissociate from the USB device */ 842 static void dissociate_dev(struct us_data *us) 843 { 844 US_DEBUGP("-- %s\n", __FUNCTION__); 845 846 kfree(us->sensebuf); 847 848 /* Free the device-related DMA-mapped buffers */ 849 if (us->cr) 850 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 851 us->cr_dma); 852 if (us->iobuf) 853 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 854 us->iobuf_dma); 855 856 /* Remove our private data from the interface */ 857 usb_set_intfdata(us->pusb_intf, NULL); 858 } 859 860 /* First stage of disconnect processing: stop all commands and remove 861 * the host */ 862 static void quiesce_and_remove_host(struct us_data *us) 863 { 864 struct Scsi_Host *host = us_to_host(us); 865 866 /* Prevent new USB transfers, stop the current command, and 867 * interrupt a SCSI-scan or device-reset delay */ 868 scsi_lock(host); 869 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 870 scsi_unlock(host); 871 usb_stor_stop_transport(us); 872 wake_up(&us->delay_wait); 873 874 /* It doesn't matter if the SCSI-scanning thread is still running. 875 * The thread will exit when it sees the DISCONNECTING flag. */ 876 877 /* queuecommand won't accept any new commands and the control 878 * thread won't execute a previously-queued command. If there 879 * is such a command pending, complete it with an error. */ 880 mutex_lock(&us->dev_mutex); 881 if (us->srb) { 882 us->srb->result = DID_NO_CONNECT << 16; 883 scsi_lock(host); 884 us->srb->scsi_done(us->srb); 885 us->srb = NULL; 886 scsi_unlock(host); 887 } 888 mutex_unlock(&us->dev_mutex); 889 890 /* Now we own no commands so it's safe to remove the SCSI host */ 891 scsi_remove_host(host); 892 } 893 894 /* Second stage of disconnect processing: deallocate all resources */ 895 static void release_everything(struct us_data *us) 896 { 897 usb_stor_release_resources(us); 898 dissociate_dev(us); 899 900 /* Drop our reference to the host; the SCSI core will free it 901 * (and "us" along with it) when the refcount becomes 0. */ 902 scsi_host_put(us_to_host(us)); 903 } 904 905 /* Thread to carry out delayed SCSI-device scanning */ 906 static int usb_stor_scan_thread(void * __us) 907 { 908 struct us_data *us = (struct us_data *)__us; 909 910 printk(KERN_DEBUG 911 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 912 913 /* Wait for the timeout to expire or for a disconnect */ 914 if (delay_use > 0) { 915 printk(KERN_DEBUG "usb-storage: waiting for device " 916 "to settle before scanning\n"); 917 retry: 918 wait_event_interruptible_timeout(us->delay_wait, 919 test_bit(US_FLIDX_DISCONNECTING, &us->flags), 920 delay_use * HZ); 921 if (try_to_freeze()) 922 goto retry; 923 } 924 925 /* If the device is still connected, perform the scanning */ 926 if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 927 928 /* For bulk-only devices, determine the max LUN value */ 929 if (us->protocol == US_PR_BULK && 930 !(us->flags & US_FL_SINGLE_LUN)) { 931 mutex_lock(&us->dev_mutex); 932 us->max_lun = usb_stor_Bulk_max_lun(us); 933 mutex_unlock(&us->dev_mutex); 934 } 935 scsi_scan_host(us_to_host(us)); 936 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 937 938 /* Should we unbind if no devices were detected? */ 939 } 940 941 scsi_host_put(us_to_host(us)); 942 complete_and_exit(&threads_gone, 0); 943 } 944 945 946 /* Probe to see if we can drive a newly-connected USB device */ 947 static int storage_probe(struct usb_interface *intf, 948 const struct usb_device_id *id) 949 { 950 struct Scsi_Host *host; 951 struct us_data *us; 952 int result; 953 struct task_struct *th; 954 955 if (usb_usual_check_type(id, USB_US_TYPE_STOR)) 956 return -ENXIO; 957 958 US_DEBUGP("USB Mass Storage device detected\n"); 959 960 /* 961 * Ask the SCSI layer to allocate a host structure, with extra 962 * space at the end for our private us_data structure. 963 */ 964 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 965 if (!host) { 966 printk(KERN_WARNING USB_STORAGE 967 "Unable to allocate the scsi host\n"); 968 return -ENOMEM; 969 } 970 971 us = host_to_us(host); 972 memset(us, 0, sizeof(struct us_data)); 973 mutex_init(&(us->dev_mutex)); 974 init_MUTEX_LOCKED(&(us->sema)); 975 init_completion(&(us->notify)); 976 init_waitqueue_head(&us->delay_wait); 977 978 /* Associate the us_data structure with the USB device */ 979 result = associate_dev(us, intf); 980 if (result) 981 goto BadDevice; 982 983 /* 984 * Get the unusual_devs entries and the descriptors 985 * 986 * id_index is calculated in the declaration to be the index number 987 * of the match from the usb_device_id table, so we can find the 988 * corresponding entry in the private table. 989 */ 990 result = get_device_info(us, id); 991 if (result) 992 goto BadDevice; 993 994 /* Get the transport, protocol, and pipe settings */ 995 result = get_transport(us); 996 if (result) 997 goto BadDevice; 998 result = get_protocol(us); 999 if (result) 1000 goto BadDevice; 1001 result = get_pipes(us); 1002 if (result) 1003 goto BadDevice; 1004 1005 /* Acquire all the other resources and add the host */ 1006 result = usb_stor_acquire_resources(us); 1007 if (result) 1008 goto BadDevice; 1009 result = scsi_add_host(host, &intf->dev); 1010 if (result) { 1011 printk(KERN_WARNING USB_STORAGE 1012 "Unable to add the scsi host\n"); 1013 goto BadDevice; 1014 } 1015 1016 /* Start up the thread for delayed SCSI-device scanning */ 1017 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 1018 if (IS_ERR(th)) { 1019 printk(KERN_WARNING USB_STORAGE 1020 "Unable to start the device-scanning thread\n"); 1021 quiesce_and_remove_host(us); 1022 result = PTR_ERR(th); 1023 goto BadDevice; 1024 } 1025 1026 /* Take a reference to the host for the scanning thread and 1027 * count it among all the threads we have launched. Then 1028 * start it up. */ 1029 scsi_host_get(us_to_host(us)); 1030 atomic_inc(&total_threads); 1031 wake_up_process(th); 1032 1033 return 0; 1034 1035 /* We come here if there are any problems */ 1036 BadDevice: 1037 US_DEBUGP("storage_probe() failed\n"); 1038 release_everything(us); 1039 return result; 1040 } 1041 1042 /* Handle a disconnect event from the USB core */ 1043 static void storage_disconnect(struct usb_interface *intf) 1044 { 1045 struct us_data *us = usb_get_intfdata(intf); 1046 1047 US_DEBUGP("storage_disconnect() called\n"); 1048 quiesce_and_remove_host(us); 1049 release_everything(us); 1050 } 1051 1052 /*********************************************************************** 1053 * Initialization and registration 1054 ***********************************************************************/ 1055 1056 static struct usb_driver usb_storage_driver = { 1057 .name = "usb-storage", 1058 .probe = storage_probe, 1059 .disconnect = storage_disconnect, 1060 #ifdef CONFIG_PM 1061 .suspend = storage_suspend, 1062 .resume = storage_resume, 1063 #endif 1064 .pre_reset = storage_pre_reset, 1065 .post_reset = storage_post_reset, 1066 .id_table = storage_usb_ids, 1067 }; 1068 1069 static int __init usb_stor_init(void) 1070 { 1071 int retval; 1072 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1073 1074 /* register the driver, return usb_register return code if error */ 1075 retval = usb_register(&usb_storage_driver); 1076 if (retval == 0) { 1077 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1078 usb_usual_set_present(USB_US_TYPE_STOR); 1079 } 1080 return retval; 1081 } 1082 1083 static void __exit usb_stor_exit(void) 1084 { 1085 US_DEBUGP("usb_stor_exit() called\n"); 1086 1087 /* Deregister the driver 1088 * This will cause disconnect() to be called for each 1089 * attached unit 1090 */ 1091 US_DEBUGP("-- calling usb_deregister()\n"); 1092 usb_deregister(&usb_storage_driver) ; 1093 1094 /* Don't return until all of our control and scanning threads 1095 * have exited. Since each thread signals threads_gone as its 1096 * last act, we have to call wait_for_completion the right number 1097 * of times. 1098 */ 1099 while (atomic_read(&total_threads) > 0) { 1100 wait_for_completion(&threads_gone); 1101 atomic_dec(&total_threads); 1102 } 1103 1104 usb_usual_clear_present(USB_US_TYPE_STOR); 1105 } 1106 1107 module_init(usb_stor_init); 1108 module_exit(usb_stor_exit); 1109