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 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB 105 #include "cypress_atacb.h" 106 #endif 107 108 /* Some informational data */ 109 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 110 MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 111 MODULE_LICENSE("GPL"); 112 113 static unsigned int delay_use = 5; 114 module_param(delay_use, uint, S_IRUGO | S_IWUSR); 115 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device"); 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", __func__); 194 if (us->suspend_resume_hook) 195 (us->suspend_resume_hook)(us, US_SUSPEND); 196 197 /* When runtime PM is working, we'll set a flag to indicate 198 * whether we should autoresume when a SCSI request arrives. */ 199 200 mutex_unlock(&us->dev_mutex); 201 return 0; 202 } 203 204 static int storage_resume(struct usb_interface *iface) 205 { 206 struct us_data *us = usb_get_intfdata(iface); 207 208 mutex_lock(&us->dev_mutex); 209 210 US_DEBUGP("%s\n", __func__); 211 if (us->suspend_resume_hook) 212 (us->suspend_resume_hook)(us, US_RESUME); 213 214 mutex_unlock(&us->dev_mutex); 215 return 0; 216 } 217 218 static int storage_reset_resume(struct usb_interface *iface) 219 { 220 struct us_data *us = usb_get_intfdata(iface); 221 222 US_DEBUGP("%s\n", __func__); 223 224 /* Report the reset to the SCSI core */ 225 usb_stor_report_bus_reset(us); 226 227 /* FIXME: Notify the subdrivers that they need to reinitialize 228 * the device */ 229 return 0; 230 } 231 232 #endif /* CONFIG_PM */ 233 234 /* 235 * The next two routines get called just before and just after 236 * a USB port reset, whether from this driver or a different one. 237 */ 238 239 static int storage_pre_reset(struct usb_interface *iface) 240 { 241 struct us_data *us = usb_get_intfdata(iface); 242 243 US_DEBUGP("%s\n", __func__); 244 245 /* Make sure no command runs during the reset */ 246 mutex_lock(&us->dev_mutex); 247 return 0; 248 } 249 250 static int storage_post_reset(struct usb_interface *iface) 251 { 252 struct us_data *us = usb_get_intfdata(iface); 253 254 US_DEBUGP("%s\n", __func__); 255 256 /* Report the reset to the SCSI core */ 257 usb_stor_report_bus_reset(us); 258 259 /* FIXME: Notify the subdrivers that they need to reinitialize 260 * the device */ 261 262 mutex_unlock(&us->dev_mutex); 263 return 0; 264 } 265 266 /* 267 * fill_inquiry_response takes an unsigned char array (which must 268 * be at least 36 characters) and populates the vendor name, 269 * product name, and revision fields. Then the array is copied 270 * into the SCSI command's response buffer (oddly enough 271 * called request_buffer). data_len contains the length of the 272 * data array, which again must be at least 36. 273 */ 274 275 void fill_inquiry_response(struct us_data *us, unsigned char *data, 276 unsigned int data_len) 277 { 278 if (data_len<36) // You lose. 279 return; 280 281 if(data[0]&0x20) { /* USB device currently not connected. Return 282 peripheral qualifier 001b ("...however, the 283 physical device is not currently connected 284 to this logical unit") and leave vendor and 285 product identification empty. ("If the target 286 does store some of the INQUIRY data on the 287 device, it may return zeros or ASCII spaces 288 (20h) in those fields until the data is 289 available from the device."). */ 290 memset(data+8,0,28); 291 } else { 292 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 293 memcpy(data+8, us->unusual_dev->vendorName, 294 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 295 strlen(us->unusual_dev->vendorName)); 296 memcpy(data+16, us->unusual_dev->productName, 297 strlen(us->unusual_dev->productName) > 16 ? 16 : 298 strlen(us->unusual_dev->productName)); 299 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 300 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 301 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 302 data[35] = 0x30 + ((bcdDevice) & 0x0F); 303 } 304 305 usb_stor_set_xfer_buf(data, data_len, us->srb); 306 } 307 308 static int usb_stor_control_thread(void * __us) 309 { 310 struct us_data *us = (struct us_data *)__us; 311 struct Scsi_Host *host = us_to_host(us); 312 313 for(;;) { 314 US_DEBUGP("*** thread sleeping.\n"); 315 if(down_interruptible(&us->sema)) 316 break; 317 318 US_DEBUGP("*** thread awakened.\n"); 319 320 /* lock the device pointers */ 321 mutex_lock(&(us->dev_mutex)); 322 323 /* if the device has disconnected, we are free to exit */ 324 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 325 US_DEBUGP("-- exiting\n"); 326 mutex_unlock(&us->dev_mutex); 327 break; 328 } 329 330 /* lock access to the state */ 331 scsi_lock(host); 332 333 /* has the command timed out *already* ? */ 334 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) { 335 us->srb->result = DID_ABORT << 16; 336 goto SkipForAbort; 337 } 338 339 scsi_unlock(host); 340 341 /* reject the command if the direction indicator 342 * is UNKNOWN 343 */ 344 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) { 345 US_DEBUGP("UNKNOWN data direction\n"); 346 us->srb->result = DID_ERROR << 16; 347 } 348 349 /* reject if target != 0 or if LUN is higher than 350 * the maximum known LUN 351 */ 352 else if (us->srb->device->id && 353 !(us->flags & US_FL_SCM_MULT_TARG)) { 354 US_DEBUGP("Bad target number (%d:%d)\n", 355 us->srb->device->id, us->srb->device->lun); 356 us->srb->result = DID_BAD_TARGET << 16; 357 } 358 359 else if (us->srb->device->lun > us->max_lun) { 360 US_DEBUGP("Bad LUN (%d:%d)\n", 361 us->srb->device->id, us->srb->device->lun); 362 us->srb->result = DID_BAD_TARGET << 16; 363 } 364 365 /* Handle those devices which need us to fake 366 * their inquiry data */ 367 else if ((us->srb->cmnd[0] == INQUIRY) && 368 (us->flags & US_FL_FIX_INQUIRY)) { 369 unsigned char data_ptr[36] = { 370 0x00, 0x80, 0x02, 0x02, 371 0x1F, 0x00, 0x00, 0x00}; 372 373 US_DEBUGP("Faking INQUIRY command\n"); 374 fill_inquiry_response(us, data_ptr, 36); 375 us->srb->result = SAM_STAT_GOOD; 376 } 377 378 /* we've got a command, let's do it! */ 379 else { 380 US_DEBUG(usb_stor_show_command(us->srb)); 381 us->proto_handler(us->srb, us); 382 } 383 384 /* lock access to the state */ 385 scsi_lock(host); 386 387 /* did the command already complete because of a disconnect? */ 388 if (!us->srb) 389 ; /* nothing to do */ 390 391 /* indicate that the command is done */ 392 else if (us->srb->result != DID_ABORT << 16) { 393 US_DEBUGP("scsi cmd done, result=0x%x\n", 394 us->srb->result); 395 us->srb->scsi_done(us->srb); 396 } else { 397 SkipForAbort: 398 US_DEBUGP("scsi command aborted\n"); 399 } 400 401 /* If an abort request was received we need to signal that 402 * the abort has finished. The proper test for this is 403 * the TIMED_OUT flag, not srb->result == DID_ABORT, because 404 * the timeout might have occurred after the command had 405 * already completed with a different result code. */ 406 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) { 407 complete(&(us->notify)); 408 409 /* Allow USB transfers to resume */ 410 clear_bit(US_FLIDX_ABORTING, &us->flags); 411 clear_bit(US_FLIDX_TIMED_OUT, &us->flags); 412 } 413 414 /* finished working on this command */ 415 us->srb = NULL; 416 scsi_unlock(host); 417 418 /* unlock the device pointers */ 419 mutex_unlock(&us->dev_mutex); 420 } /* for (;;) */ 421 422 /* Wait until we are told to stop */ 423 for (;;) { 424 set_current_state(TASK_INTERRUPTIBLE); 425 if (kthread_should_stop()) 426 break; 427 schedule(); 428 } 429 __set_current_state(TASK_RUNNING); 430 return 0; 431 } 432 433 /*********************************************************************** 434 * Device probing and disconnecting 435 ***********************************************************************/ 436 437 /* Associate our private data with the USB device */ 438 static int associate_dev(struct us_data *us, struct usb_interface *intf) 439 { 440 US_DEBUGP("-- %s\n", __func__); 441 442 /* Fill in the device-related fields */ 443 us->pusb_dev = interface_to_usbdev(intf); 444 us->pusb_intf = intf; 445 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 446 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n", 447 le16_to_cpu(us->pusb_dev->descriptor.idVendor), 448 le16_to_cpu(us->pusb_dev->descriptor.idProduct), 449 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice)); 450 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n", 451 intf->cur_altsetting->desc.bInterfaceSubClass, 452 intf->cur_altsetting->desc.bInterfaceProtocol); 453 454 /* Store our private data in the interface */ 455 usb_set_intfdata(intf, us); 456 457 /* Allocate the device-related DMA-mapped buffers */ 458 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 459 GFP_KERNEL, &us->cr_dma); 460 if (!us->cr) { 461 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 462 return -ENOMEM; 463 } 464 465 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 466 GFP_KERNEL, &us->iobuf_dma); 467 if (!us->iobuf) { 468 US_DEBUGP("I/O buffer allocation failed\n"); 469 return -ENOMEM; 470 } 471 472 us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL); 473 if (!us->sensebuf) { 474 US_DEBUGP("Sense buffer allocation failed\n"); 475 return -ENOMEM; 476 } 477 return 0; 478 } 479 480 /* Find an unusual_dev descriptor (always succeeds in the current code) */ 481 static struct us_unusual_dev *find_unusual(const struct usb_device_id *id) 482 { 483 const int id_index = id - storage_usb_ids; 484 return &us_unusual_dev_list[id_index]; 485 } 486 487 /* Get the unusual_devs entries and the string descriptors */ 488 static int get_device_info(struct us_data *us, const struct usb_device_id *id) 489 { 490 struct usb_device *dev = us->pusb_dev; 491 struct usb_interface_descriptor *idesc = 492 &us->pusb_intf->cur_altsetting->desc; 493 struct us_unusual_dev *unusual_dev = find_unusual(id); 494 495 /* Store the entries */ 496 us->unusual_dev = unusual_dev; 497 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 498 idesc->bInterfaceSubClass : 499 unusual_dev->useProtocol; 500 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 501 idesc->bInterfaceProtocol : 502 unusual_dev->useTransport; 503 us->flags = USB_US_ORIG_FLAGS(id->driver_info); 504 505 if (us->flags & US_FL_IGNORE_DEVICE) { 506 printk(KERN_INFO USB_STORAGE "device ignored\n"); 507 return -ENODEV; 508 } 509 510 /* 511 * This flag is only needed when we're in high-speed, so let's 512 * disable it if we're in full-speed 513 */ 514 if (dev->speed != USB_SPEED_HIGH) 515 us->flags &= ~US_FL_GO_SLOW; 516 517 /* Log a message if a non-generic unusual_dev entry contains an 518 * unnecessary subclass or protocol override. This may stimulate 519 * reports from users that will help us remove unneeded entries 520 * from the unusual_devs.h table. 521 */ 522 if (id->idVendor || id->idProduct) { 523 static const char *msgs[3] = { 524 "an unneeded SubClass entry", 525 "an unneeded Protocol entry", 526 "unneeded SubClass and Protocol entries"}; 527 struct usb_device_descriptor *ddesc = &dev->descriptor; 528 int msg = -1; 529 530 if (unusual_dev->useProtocol != US_SC_DEVICE && 531 us->subclass == idesc->bInterfaceSubClass) 532 msg += 1; 533 if (unusual_dev->useTransport != US_PR_DEVICE && 534 us->protocol == idesc->bInterfaceProtocol) 535 msg += 2; 536 if (msg >= 0 && !(us->flags & US_FL_NEED_OVERRIDE)) 537 printk(KERN_NOTICE USB_STORAGE "This device " 538 "(%04x,%04x,%04x S %02x P %02x)" 539 " has %s in unusual_devs.h (kernel" 540 " %s)\n" 541 " Please send a copy of this message to " 542 "<linux-usb-devel@lists.sourceforge.net>\n", 543 le16_to_cpu(ddesc->idVendor), 544 le16_to_cpu(ddesc->idProduct), 545 le16_to_cpu(ddesc->bcdDevice), 546 idesc->bInterfaceSubClass, 547 idesc->bInterfaceProtocol, 548 msgs[msg], 549 utsname()->release); 550 } 551 552 return 0; 553 } 554 555 /* Get the transport settings */ 556 static int get_transport(struct us_data *us) 557 { 558 switch (us->protocol) { 559 case US_PR_CB: 560 us->transport_name = "Control/Bulk"; 561 us->transport = usb_stor_CB_transport; 562 us->transport_reset = usb_stor_CB_reset; 563 us->max_lun = 7; 564 break; 565 566 case US_PR_CBI: 567 us->transport_name = "Control/Bulk/Interrupt"; 568 us->transport = usb_stor_CBI_transport; 569 us->transport_reset = usb_stor_CB_reset; 570 us->max_lun = 7; 571 break; 572 573 case US_PR_BULK: 574 us->transport_name = "Bulk"; 575 us->transport = usb_stor_Bulk_transport; 576 us->transport_reset = usb_stor_Bulk_reset; 577 break; 578 579 #ifdef CONFIG_USB_STORAGE_USBAT 580 case US_PR_USBAT: 581 us->transport_name = "Shuttle USBAT"; 582 us->transport = usbat_transport; 583 us->transport_reset = usb_stor_CB_reset; 584 us->max_lun = 1; 585 break; 586 #endif 587 588 #ifdef CONFIG_USB_STORAGE_SDDR09 589 case US_PR_EUSB_SDDR09: 590 us->transport_name = "EUSB/SDDR09"; 591 us->transport = sddr09_transport; 592 us->transport_reset = usb_stor_CB_reset; 593 us->max_lun = 0; 594 break; 595 #endif 596 597 #ifdef CONFIG_USB_STORAGE_SDDR55 598 case US_PR_SDDR55: 599 us->transport_name = "SDDR55"; 600 us->transport = sddr55_transport; 601 us->transport_reset = sddr55_reset; 602 us->max_lun = 0; 603 break; 604 #endif 605 606 #ifdef CONFIG_USB_STORAGE_DPCM 607 case US_PR_DPCM_USB: 608 us->transport_name = "Control/Bulk-EUSB/SDDR09"; 609 us->transport = dpcm_transport; 610 us->transport_reset = usb_stor_CB_reset; 611 us->max_lun = 1; 612 break; 613 #endif 614 615 #ifdef CONFIG_USB_STORAGE_FREECOM 616 case US_PR_FREECOM: 617 us->transport_name = "Freecom"; 618 us->transport = freecom_transport; 619 us->transport_reset = usb_stor_freecom_reset; 620 us->max_lun = 0; 621 break; 622 #endif 623 624 #ifdef CONFIG_USB_STORAGE_DATAFAB 625 case US_PR_DATAFAB: 626 us->transport_name = "Datafab Bulk-Only"; 627 us->transport = datafab_transport; 628 us->transport_reset = usb_stor_Bulk_reset; 629 us->max_lun = 1; 630 break; 631 #endif 632 633 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 634 case US_PR_JUMPSHOT: 635 us->transport_name = "Lexar Jumpshot Control/Bulk"; 636 us->transport = jumpshot_transport; 637 us->transport_reset = usb_stor_Bulk_reset; 638 us->max_lun = 1; 639 break; 640 #endif 641 642 #ifdef CONFIG_USB_STORAGE_ALAUDA 643 case US_PR_ALAUDA: 644 us->transport_name = "Alauda Control/Bulk"; 645 us->transport = alauda_transport; 646 us->transport_reset = usb_stor_Bulk_reset; 647 us->max_lun = 1; 648 break; 649 #endif 650 651 #ifdef CONFIG_USB_STORAGE_KARMA 652 case US_PR_KARMA: 653 us->transport_name = "Rio Karma/Bulk"; 654 us->transport = rio_karma_transport; 655 us->transport_reset = usb_stor_Bulk_reset; 656 break; 657 #endif 658 659 default: 660 return -EIO; 661 } 662 US_DEBUGP("Transport: %s\n", us->transport_name); 663 664 /* fix for single-lun devices */ 665 if (us->flags & US_FL_SINGLE_LUN) 666 us->max_lun = 0; 667 return 0; 668 } 669 670 /* Get the protocol settings */ 671 static int get_protocol(struct us_data *us) 672 { 673 switch (us->subclass) { 674 case US_SC_RBC: 675 us->protocol_name = "Reduced Block Commands (RBC)"; 676 us->proto_handler = usb_stor_transparent_scsi_command; 677 break; 678 679 case US_SC_8020: 680 us->protocol_name = "8020i"; 681 us->proto_handler = usb_stor_ATAPI_command; 682 us->max_lun = 0; 683 break; 684 685 case US_SC_QIC: 686 us->protocol_name = "QIC-157"; 687 us->proto_handler = usb_stor_qic157_command; 688 us->max_lun = 0; 689 break; 690 691 case US_SC_8070: 692 us->protocol_name = "8070i"; 693 us->proto_handler = usb_stor_ATAPI_command; 694 us->max_lun = 0; 695 break; 696 697 case US_SC_SCSI: 698 us->protocol_name = "Transparent SCSI"; 699 us->proto_handler = usb_stor_transparent_scsi_command; 700 break; 701 702 case US_SC_UFI: 703 us->protocol_name = "Uniform Floppy Interface (UFI)"; 704 us->proto_handler = usb_stor_ufi_command; 705 break; 706 707 #ifdef CONFIG_USB_STORAGE_ISD200 708 case US_SC_ISD200: 709 us->protocol_name = "ISD200 ATA/ATAPI"; 710 us->proto_handler = isd200_ata_command; 711 break; 712 #endif 713 714 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB 715 case US_SC_CYP_ATACB: 716 us->protocol_name = "Transparent SCSI with Cypress ATACB"; 717 us->proto_handler = cypress_atacb_passthrough; 718 break; 719 #endif 720 721 default: 722 return -EIO; 723 } 724 US_DEBUGP("Protocol: %s\n", us->protocol_name); 725 return 0; 726 } 727 728 /* Get the pipe settings */ 729 static int get_pipes(struct us_data *us) 730 { 731 struct usb_host_interface *altsetting = 732 us->pusb_intf->cur_altsetting; 733 int i; 734 struct usb_endpoint_descriptor *ep; 735 struct usb_endpoint_descriptor *ep_in = NULL; 736 struct usb_endpoint_descriptor *ep_out = NULL; 737 struct usb_endpoint_descriptor *ep_int = NULL; 738 739 /* 740 * Find the first endpoint of each type we need. 741 * We are expecting a minimum of 2 endpoints - in and out (bulk). 742 * An optional interrupt-in is OK (necessary for CBI protocol). 743 * We will ignore any others. 744 */ 745 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 746 ep = &altsetting->endpoint[i].desc; 747 748 if (usb_endpoint_xfer_bulk(ep)) { 749 if (usb_endpoint_dir_in(ep)) { 750 if (!ep_in) 751 ep_in = ep; 752 } else { 753 if (!ep_out) 754 ep_out = ep; 755 } 756 } 757 758 else if (usb_endpoint_is_int_in(ep)) { 759 if (!ep_int) 760 ep_int = ep; 761 } 762 } 763 764 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 765 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 766 return -EIO; 767 } 768 769 /* Calculate and store the pipe values */ 770 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 771 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 772 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 773 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 774 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 775 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 776 if (ep_int) { 777 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 778 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 779 us->ep_bInterval = ep_int->bInterval; 780 } 781 return 0; 782 } 783 784 /* Initialize all the dynamic resources we need */ 785 static int usb_stor_acquire_resources(struct us_data *us) 786 { 787 int p; 788 struct task_struct *th; 789 790 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 791 if (!us->current_urb) { 792 US_DEBUGP("URB allocation failed\n"); 793 return -ENOMEM; 794 } 795 796 /* Just before we start our control thread, initialize 797 * the device if it needs initialization */ 798 if (us->unusual_dev->initFunction) { 799 p = us->unusual_dev->initFunction(us); 800 if (p) 801 return p; 802 } 803 804 /* Start up our control thread */ 805 th = kthread_run(usb_stor_control_thread, us, "usb-storage"); 806 if (IS_ERR(th)) { 807 printk(KERN_WARNING USB_STORAGE 808 "Unable to start control thread\n"); 809 return PTR_ERR(th); 810 } 811 us->ctl_thread = 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", __func__); 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 if (us->ctl_thread) 829 kthread_stop(us->ctl_thread); 830 831 /* Call the destructor routine, if it exists */ 832 if (us->extra_destructor) { 833 US_DEBUGP("-- calling extra_destructor()\n"); 834 us->extra_destructor(us->extra); 835 } 836 837 /* Free the extra data and the URB */ 838 kfree(us->extra); 839 usb_free_urb(us->current_urb); 840 } 841 842 /* Dissociate from the USB device */ 843 static void dissociate_dev(struct us_data *us) 844 { 845 US_DEBUGP("-- %s\n", __func__); 846 847 kfree(us->sensebuf); 848 849 /* Free the device-related DMA-mapped buffers */ 850 if (us->cr) 851 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 852 us->cr_dma); 853 if (us->iobuf) 854 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 855 us->iobuf_dma); 856 857 /* Remove our private data from the interface */ 858 usb_set_intfdata(us->pusb_intf, NULL); 859 } 860 861 /* First stage of disconnect processing: stop all commands and remove 862 * the host */ 863 static void quiesce_and_remove_host(struct us_data *us) 864 { 865 struct Scsi_Host *host = us_to_host(us); 866 867 /* Prevent new USB transfers, stop the current command, and 868 * interrupt a SCSI-scan or device-reset delay */ 869 scsi_lock(host); 870 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 871 scsi_unlock(host); 872 usb_stor_stop_transport(us); 873 wake_up(&us->delay_wait); 874 875 /* queuecommand won't accept any new commands and the control 876 * thread won't execute a previously-queued command. If there 877 * is such a command pending, complete it with an error. */ 878 mutex_lock(&us->dev_mutex); 879 if (us->srb) { 880 us->srb->result = DID_NO_CONNECT << 16; 881 scsi_lock(host); 882 us->srb->scsi_done(us->srb); 883 us->srb = NULL; 884 complete(&us->notify); /* in case of an abort */ 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 /* Wait for the SCSI-scanning thread to stop */ 893 wait_for_completion(&us->scanning_done); 894 } 895 896 /* Second stage of disconnect processing: deallocate all resources */ 897 static void release_everything(struct us_data *us) 898 { 899 usb_stor_release_resources(us); 900 dissociate_dev(us); 901 902 /* Drop our reference to the host; the SCSI core will free it 903 * (and "us" along with it) when the refcount becomes 0. */ 904 scsi_host_put(us_to_host(us)); 905 } 906 907 /* Thread to carry out delayed SCSI-device scanning */ 908 static int usb_stor_scan_thread(void * __us) 909 { 910 struct us_data *us = (struct us_data *)__us; 911 912 printk(KERN_DEBUG 913 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 914 915 set_freezable(); 916 /* Wait for the timeout to expire or for a disconnect */ 917 if (delay_use > 0) { 918 printk(KERN_DEBUG "usb-storage: waiting for device " 919 "to settle before scanning\n"); 920 wait_event_freezable_timeout(us->delay_wait, 921 test_bit(US_FLIDX_DISCONNECTING, &us->flags), 922 delay_use * HZ); 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 complete_and_exit(&us->scanning_done, 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 /* 971 * Allow 16-byte CDBs and thus > 2TB 972 */ 973 host->max_cmd_len = 16; 974 us = host_to_us(host); 975 memset(us, 0, sizeof(struct us_data)); 976 mutex_init(&(us->dev_mutex)); 977 init_MUTEX_LOCKED(&(us->sema)); 978 init_completion(&(us->notify)); 979 init_waitqueue_head(&us->delay_wait); 980 init_completion(&us->scanning_done); 981 982 /* Associate the us_data structure with the USB device */ 983 result = associate_dev(us, intf); 984 if (result) 985 goto BadDevice; 986 987 /* 988 * Get the unusual_devs entries and the descriptors 989 * 990 * id_index is calculated in the declaration to be the index number 991 * of the match from the usb_device_id table, so we can find the 992 * corresponding entry in the private table. 993 */ 994 result = get_device_info(us, id); 995 if (result) 996 goto BadDevice; 997 998 /* Get the transport, protocol, and pipe settings */ 999 result = get_transport(us); 1000 if (result) 1001 goto BadDevice; 1002 result = get_protocol(us); 1003 if (result) 1004 goto BadDevice; 1005 result = get_pipes(us); 1006 if (result) 1007 goto BadDevice; 1008 1009 /* Acquire all the other resources and add the host */ 1010 result = usb_stor_acquire_resources(us); 1011 if (result) 1012 goto BadDevice; 1013 result = scsi_add_host(host, &intf->dev); 1014 if (result) { 1015 printk(KERN_WARNING USB_STORAGE 1016 "Unable to add the scsi host\n"); 1017 goto BadDevice; 1018 } 1019 1020 /* Start up the thread for delayed SCSI-device scanning */ 1021 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 1022 if (IS_ERR(th)) { 1023 printk(KERN_WARNING USB_STORAGE 1024 "Unable to start the device-scanning thread\n"); 1025 quiesce_and_remove_host(us); 1026 result = PTR_ERR(th); 1027 goto BadDevice; 1028 } 1029 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 .reset_resume = storage_reset_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 usb_usual_clear_present(USB_US_TYPE_STOR); 1095 } 1096 1097 module_init(usb_stor_init); 1098 module_exit(usb_stor_exit); 1099