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