1/* Driver for USB Mass Storage compliant devices 2 * 3 * $Id: usb.c,v 1.1.1.1 2007/08/03 18:53:03 Exp $ 4 * 5 * Current development and maintenance by: 6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 7 * 8 * Developed with the assistance of: 9 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) 10 * (c) 2003 Alan Stern (stern@rowland.harvard.edu) 11 * 12 * Initial work by: 13 * (c) 1999 Michael Gee (michael@linuxspecific.com) 14 * 15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com): 16 * (c) 2000 Yggdrasil Computing, Inc. 17 * 18 * This driver is based on the 'USB Mass Storage Class' document. This 19 * describes in detail the protocol used to communicate with such 20 * devices. Clearly, the designers had SCSI and ATAPI commands in 21 * mind when they created this document. The commands are all very 22 * similar to commands in the SCSI-II and ATAPI specifications. 23 * 24 * It is important to note that in a number of cases this class 25 * exhibits class-specific exemptions from the USB specification. 26 * Notably the usage of NAK, STALL and ACK differs from the norm, in 27 * that they are used to communicate wait, failed and OK on commands. 28 * 29 * Also, for certain devices, the interrupt endpoint is used to convey 30 * status of a command. 31 * 32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more 33 * information about this driver. 34 * 35 * This program is free software; you can redistribute it and/or modify it 36 * under the terms of the GNU General Public License as published by the 37 * Free Software Foundation; either version 2, or (at your option) any 38 * later version. 39 * 40 * This program is distributed in the hope that it will be useful, but 41 * WITHOUT ANY WARRANTY; without even the implied warranty of 42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 43 * General Public License for more details. 44 * 45 * You should have received a copy of the GNU General Public License along 46 * with this program; if not, write to the Free Software Foundation, Inc., 47 * 675 Mass Ave, Cambridge, MA 02139, USA. 48 */ 49 50#include <linux/sched.h> 51#include <linux/errno.h> 52#include <linux/freezer.h> 53#include <linux/module.h> 54#include <linux/init.h> 55#include <linux/slab.h> 56#include <linux/kthread.h> 57#include <linux/mutex.h> 58#include <linux/utsname.h> 59 60#include <scsi/scsi.h> 61#include <scsi/scsi_cmnd.h> 62#include <scsi/scsi_device.h> 63 64#include "usb.h" 65#include "scsiglue.h" 66#include "transport.h" 67#include "protocol.h" 68#include "debug.h" 69#include "initializers.h" 70 71#ifdef CONFIG_USB_STORAGE_USBAT 72#include "shuttle_usbat.h" 73#endif 74#ifdef CONFIG_USB_STORAGE_SDDR09 75#include "sddr09.h" 76#endif 77#ifdef CONFIG_USB_STORAGE_SDDR55 78#include "sddr55.h" 79#endif 80#ifdef CONFIG_USB_STORAGE_DPCM 81#include "dpcm.h" 82#endif 83#ifdef CONFIG_USB_STORAGE_FREECOM 84#include "freecom.h" 85#endif 86#ifdef CONFIG_USB_STORAGE_ISD200 87#include "isd200.h" 88#endif 89#ifdef CONFIG_USB_STORAGE_DATAFAB 90#include "datafab.h" 91#endif 92#ifdef CONFIG_USB_STORAGE_JUMPSHOT 93#include "jumpshot.h" 94#endif 95#ifdef CONFIG_USB_STORAGE_ONETOUCH 96#include "onetouch.h" 97#endif 98#ifdef CONFIG_USB_STORAGE_ALAUDA 99#include "alauda.h" 100#endif 101#ifdef CONFIG_USB_STORAGE_KARMA 102#include "karma.h" 103#endif 104 105/* Some informational data */ 106MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 107MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 108MODULE_LICENSE("GPL"); 109 110static unsigned int delay_use = 5; 111module_param(delay_use, uint, S_IRUGO | S_IWUSR); 112MODULE_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 */ 118static atomic_t total_threads = ATOMIC_INIT(0); 119static 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 138static 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 147MODULE_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 178static 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 190static 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 209static 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 231static 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 241static 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 mutex_unlock(&us->dev_mutex); 253} 254 255/* 256 * fill_inquiry_response takes an unsigned char array (which must 257 * be at least 36 characters) and populates the vendor name, 258 * product name, and revision fields. Then the array is copied 259 * into the SCSI command's response buffer (oddly enough 260 * called request_buffer). data_len contains the length of the 261 * data array, which again must be at least 36. 262 */ 263 264void fill_inquiry_response(struct us_data *us, unsigned char *data, 265 unsigned int data_len) 266{ 267 if (data_len<36) // You lose. 268 return; 269 270 if(data[0]&0x20) { /* USB device currently not connected. Return 271 peripheral qualifier 001b ("...however, the 272 physical device is not currently connected 273 to this logical unit") and leave vendor and 274 product identification empty. ("If the target 275 does store some of the INQUIRY data on the 276 device, it may return zeros or ASCII spaces 277 (20h) in those fields until the data is 278 available from the device."). */ 279 memset(data+8,0,28); 280 } else { 281 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 282 memcpy(data+8, us->unusual_dev->vendorName, 283 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 284 strlen(us->unusual_dev->vendorName)); 285 memcpy(data+16, us->unusual_dev->productName, 286 strlen(us->unusual_dev->productName) > 16 ? 16 : 287 strlen(us->unusual_dev->productName)); 288 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 289 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 290 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 291 data[35] = 0x30 + ((bcdDevice) & 0x0F); 292 } 293 294 usb_stor_set_xfer_buf(data, data_len, us->srb); 295} 296 297static int usb_stor_control_thread(void * __us) 298{ 299 struct us_data *us = (struct us_data *)__us; 300 struct Scsi_Host *host = us_to_host(us); 301 302 current->flags |= PF_NOFREEZE; 303 304 for(;;) { 305 US_DEBUGP("*** thread sleeping.\n"); 306 if(down_interruptible(&us->sema)) 307 break; 308 309 US_DEBUGP("*** thread awakened.\n"); 310 311 /* lock the device pointers */ 312 mutex_lock(&(us->dev_mutex)); 313 314 /* if the device has disconnected, we are free to exit */ 315 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 316 US_DEBUGP("-- exiting\n"); 317 mutex_unlock(&us->dev_mutex); 318 break; 319 } 320 321 /* lock access to the state */ 322 scsi_lock(host); 323 324 /* When we are called with no command pending, we're done */ 325 /*added by dennis start,12/04/2013,fix 3T/4T usb disk(NTFS) can't be mounted issue*/ 326 if (us->srb == NULL) { 327 scsi_unlock(host); 328 mutex_unlock(&us->dev_mutex); 329 US_DEBUGP("-- exiting\n"); 330 break; 331 } 332 /*added by dennis end,12/04/2013,fix 3T/4T usb disk(NTFS) can't be mounted issue*/ 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 { 397SkipForAbort: 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 scsi_host_put(host); 423 424 /* notify the exit routine that we're actually exiting now 425 * 426 * complete()/wait_for_completion() is similar to up()/down(), 427 * except that complete() is safe in the case where the structure 428 * is getting deleted in a parallel mode of execution (i.e. just 429 * after the down() -- that's necessary for the thread-shutdown 430 * case. 431 * 432 * complete_and_exit() goes even further than this -- it is safe in 433 * the case that the thread of the caller is going away (not just 434 * the structure) -- this is necessary for the module-remove case. 435 * This is important in preemption kernels, which transfer the flow 436 * of execution immediately upon a complete(). 437 */ 438 complete_and_exit(&threads_gone, 0); 439} 440 441/*********************************************************************** 442 * Device probing and disconnecting 443 ***********************************************************************/ 444 445/* Associate our private data with the USB device */ 446static int associate_dev(struct us_data *us, struct usb_interface *intf) 447{ 448 US_DEBUGP("-- %s\n", __FUNCTION__); 449 450 /* Fill in the device-related fields */ 451 us->pusb_dev = interface_to_usbdev(intf); 452 us->pusb_intf = intf; 453 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 454 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n", 455 le16_to_cpu(us->pusb_dev->descriptor.idVendor), 456 le16_to_cpu(us->pusb_dev->descriptor.idProduct), 457 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice)); 458 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n", 459 intf->cur_altsetting->desc.bInterfaceSubClass, 460 intf->cur_altsetting->desc.bInterfaceProtocol); 461 462 /* Store our private data in the interface */ 463 usb_set_intfdata(intf, us); 464 465 /* Allocate the device-related DMA-mapped buffers */ 466 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 467 GFP_KERNEL, &us->cr_dma); 468 if (!us->cr) { 469 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 470 return -ENOMEM; 471 } 472 473 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 474 GFP_KERNEL, &us->iobuf_dma); 475 if (!us->iobuf) { 476 US_DEBUGP("I/O buffer allocation failed\n"); 477 return -ENOMEM; 478 } 479 480 us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL); 481 if (!us->sensebuf) { 482 US_DEBUGP("Sense buffer allocation failed\n"); 483 return -ENOMEM; 484 } 485 return 0; 486} 487 488/* Find an unusual_dev descriptor (always succeeds in the current code) */ 489static struct us_unusual_dev *find_unusual(const struct usb_device_id *id) 490{ 491 const int id_index = id - storage_usb_ids; 492 return &us_unusual_dev_list[id_index]; 493} 494 495/* Get the unusual_devs entries and the string descriptors */ 496static int get_device_info(struct us_data *us, const struct usb_device_id *id) 497{ 498 struct usb_device *dev = us->pusb_dev; 499 struct usb_interface_descriptor *idesc = 500 &us->pusb_intf->cur_altsetting->desc; 501 struct us_unusual_dev *unusual_dev = find_unusual(id); 502 503 /* Store the entries */ 504 us->unusual_dev = unusual_dev; 505 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 506 idesc->bInterfaceSubClass : 507 unusual_dev->useProtocol; 508 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 509 idesc->bInterfaceProtocol : 510 unusual_dev->useTransport; 511 us->flags = USB_US_ORIG_FLAGS(id->driver_info); 512 513 if (us->flags & US_FL_IGNORE_DEVICE) { 514 printk(KERN_INFO USB_STORAGE "device ignored\n"); 515 return -ENODEV; 516 } 517 518 /* 519 * This flag is only needed when we're in high-speed, so let's 520 * disable it if we're in full-speed 521 */ 522 if (dev->speed != USB_SPEED_HIGH) 523 us->flags &= ~US_FL_GO_SLOW; 524 525 /* Log a message if a non-generic unusual_dev entry contains an 526 * unnecessary subclass or protocol override. This may stimulate 527 * reports from users that will help us remove unneeded entries 528 * from the unusual_devs.h table. 529 */ 530 if (id->idVendor || id->idProduct) { 531 static const char *msgs[3] = { 532 "an unneeded SubClass entry", 533 "an unneeded Protocol entry", 534 "unneeded SubClass and Protocol entries"}; 535 struct usb_device_descriptor *ddesc = &dev->descriptor; 536 int msg = -1; 537 538 if (unusual_dev->useProtocol != US_SC_DEVICE && 539 us->subclass == idesc->bInterfaceSubClass) 540 msg += 1; 541 if (unusual_dev->useTransport != US_PR_DEVICE && 542 us->protocol == idesc->bInterfaceProtocol) 543 msg += 2; 544 if (msg >= 0 && !(us->flags & US_FL_NEED_OVERRIDE)) 545 printk(KERN_NOTICE USB_STORAGE "This device " 546 "(%04x,%04x,%04x S %02x P %02x)" 547 " has %s in unusual_devs.h (kernel" 548 " %s)\n" 549 " Please send a copy of this message to " 550 "<linux-usb-devel@lists.sourceforge.net>\n", 551 le16_to_cpu(ddesc->idVendor), 552 le16_to_cpu(ddesc->idProduct), 553 le16_to_cpu(ddesc->bcdDevice), 554 idesc->bInterfaceSubClass, 555 idesc->bInterfaceProtocol, 556 msgs[msg], 557 utsname()->release); 558 } 559 560 return 0; 561} 562 563/* Get the transport settings */ 564static int get_transport(struct us_data *us) 565{ 566 switch (us->protocol) { 567 case US_PR_CB: 568 us->transport_name = "Control/Bulk"; 569 us->transport = usb_stor_CB_transport; 570 us->transport_reset = usb_stor_CB_reset; 571 us->max_lun = 7; 572 break; 573 574 case US_PR_CBI: 575 us->transport_name = "Control/Bulk/Interrupt"; 576 us->transport = usb_stor_CBI_transport; 577 us->transport_reset = usb_stor_CB_reset; 578 us->max_lun = 7; 579 break; 580 581 case US_PR_BULK: 582 us->transport_name = "Bulk"; 583 us->transport = usb_stor_Bulk_transport; 584 us->transport_reset = usb_stor_Bulk_reset; 585 break; 586 587#ifdef CONFIG_USB_STORAGE_USBAT 588 case US_PR_USBAT: 589 us->transport_name = "Shuttle USBAT"; 590 us->transport = usbat_transport; 591 us->transport_reset = usb_stor_CB_reset; 592 us->max_lun = 1; 593 break; 594#endif 595 596#ifdef CONFIG_USB_STORAGE_SDDR09 597 case US_PR_EUSB_SDDR09: 598 us->transport_name = "EUSB/SDDR09"; 599 us->transport = sddr09_transport; 600 us->transport_reset = usb_stor_CB_reset; 601 us->max_lun = 0; 602 break; 603#endif 604 605#ifdef CONFIG_USB_STORAGE_SDDR55 606 case US_PR_SDDR55: 607 us->transport_name = "SDDR55"; 608 us->transport = sddr55_transport; 609 us->transport_reset = sddr55_reset; 610 us->max_lun = 0; 611 break; 612#endif 613 614#ifdef CONFIG_USB_STORAGE_DPCM 615 case US_PR_DPCM_USB: 616 us->transport_name = "Control/Bulk-EUSB/SDDR09"; 617 us->transport = dpcm_transport; 618 us->transport_reset = usb_stor_CB_reset; 619 us->max_lun = 1; 620 break; 621#endif 622 623#ifdef CONFIG_USB_STORAGE_FREECOM 624 case US_PR_FREECOM: 625 us->transport_name = "Freecom"; 626 us->transport = freecom_transport; 627 us->transport_reset = usb_stor_freecom_reset; 628 us->max_lun = 0; 629 break; 630#endif 631 632#ifdef CONFIG_USB_STORAGE_DATAFAB 633 case US_PR_DATAFAB: 634 us->transport_name = "Datafab Bulk-Only"; 635 us->transport = datafab_transport; 636 us->transport_reset = usb_stor_Bulk_reset; 637 us->max_lun = 1; 638 break; 639#endif 640 641#ifdef CONFIG_USB_STORAGE_JUMPSHOT 642 case US_PR_JUMPSHOT: 643 us->transport_name = "Lexar Jumpshot Control/Bulk"; 644 us->transport = jumpshot_transport; 645 us->transport_reset = usb_stor_Bulk_reset; 646 us->max_lun = 1; 647 break; 648#endif 649 650#ifdef CONFIG_USB_STORAGE_ALAUDA 651 case US_PR_ALAUDA: 652 us->transport_name = "Alauda Control/Bulk"; 653 us->transport = alauda_transport; 654 us->transport_reset = usb_stor_Bulk_reset; 655 us->max_lun = 1; 656 break; 657#endif 658 659#ifdef CONFIG_USB_STORAGE_KARMA 660 case US_PR_KARMA: 661 us->transport_name = "Rio Karma/Bulk"; 662 us->transport = rio_karma_transport; 663 us->transport_reset = usb_stor_Bulk_reset; 664 break; 665#endif 666 667 default: 668 return -EIO; 669 } 670 US_DEBUGP("Transport: %s\n", us->transport_name); 671 672 /* fix for single-lun devices */ 673 if (us->flags & US_FL_SINGLE_LUN) 674 us->max_lun = 0; 675 return 0; 676} 677 678/* Get the protocol settings */ 679static int get_protocol(struct us_data *us) 680{ 681 switch (us->subclass) { 682 case US_SC_RBC: 683 us->protocol_name = "Reduced Block Commands (RBC)"; 684 us->proto_handler = usb_stor_transparent_scsi_command; 685 break; 686 687 case US_SC_8020: 688 us->protocol_name = "8020i"; 689 us->proto_handler = usb_stor_ATAPI_command; 690 us->max_lun = 0; 691 break; 692 693 case US_SC_QIC: 694 us->protocol_name = "QIC-157"; 695 us->proto_handler = usb_stor_qic157_command; 696 us->max_lun = 0; 697 break; 698 699 case US_SC_8070: 700 us->protocol_name = "8070i"; 701 us->proto_handler = usb_stor_ATAPI_command; 702 us->max_lun = 0; 703 break; 704 705 case US_SC_SCSI: 706 us->protocol_name = "Transparent SCSI"; 707 us->proto_handler = usb_stor_transparent_scsi_command; 708 break; 709 710 case US_SC_UFI: 711 us->protocol_name = "Uniform Floppy Interface (UFI)"; 712 us->proto_handler = usb_stor_ufi_command; 713 break; 714 715#ifdef CONFIG_USB_STORAGE_ISD200 716 case US_SC_ISD200: 717 us->protocol_name = "ISD200 ATA/ATAPI"; 718 us->proto_handler = isd200_ata_command; 719 break; 720#endif 721 722 default: 723 return -EIO; 724 } 725 US_DEBUGP("Protocol: %s\n", us->protocol_name); 726 return 0; 727} 728 729/* Get the pipe settings */ 730static int get_pipes(struct us_data *us) 731{ 732 struct usb_host_interface *altsetting = 733 us->pusb_intf->cur_altsetting; 734 int i; 735 struct usb_endpoint_descriptor *ep; 736 struct usb_endpoint_descriptor *ep_in = NULL; 737 struct usb_endpoint_descriptor *ep_out = NULL; 738 struct usb_endpoint_descriptor *ep_int = NULL; 739 740 /* 741 * Find the first endpoint of each type we need. 742 * We are expecting a minimum of 2 endpoints - in and out (bulk). 743 * An optional interrupt-in is OK (necessary for CBI protocol). 744 * We will ignore any others. 745 */ 746 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 747 ep = &altsetting->endpoint[i].desc; 748 749 if (usb_endpoint_xfer_bulk(ep)) { 750 if (usb_endpoint_dir_in(ep)) { 751 if (!ep_in) 752 ep_in = ep; 753 } else { 754 if (!ep_out) 755 ep_out = ep; 756 } 757 } 758 759 else if (usb_endpoint_is_int_in(ep)) { 760 if (!ep_int) 761 ep_int = ep; 762 } 763 } 764 765 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 766 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 767 return -EIO; 768 } 769 770 /* Calculate and store the pipe values */ 771 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 772 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 773 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 774 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 775 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 776 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 777 if (ep_int) { 778 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 779 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 780 us->ep_bInterval = ep_int->bInterval; 781 } 782 return 0; 783} 784 785/* Initialize all the dynamic resources we need */ 786static int usb_stor_acquire_resources(struct us_data *us) 787{ 788 int p; 789 struct task_struct *th; 790 791 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 792 if (!us->current_urb) { 793 US_DEBUGP("URB allocation failed\n"); 794 return -ENOMEM; 795 } 796 797 /* Just before we start our control thread, initialize 798 * the device if it needs initialization */ 799 if (us->unusual_dev->initFunction) { 800 p = us->unusual_dev->initFunction(us); 801 if (p) 802 return p; 803 } 804 805 /* Start up our control thread */ 806 th = kthread_create(usb_stor_control_thread, us, "usb-storage"); 807 if (IS_ERR(th)) { 808 printk(KERN_WARNING USB_STORAGE 809 "Unable to start control thread\n"); 810 return PTR_ERR(th); 811 } 812 813 /* Take a reference to the host for the control thread and 814 * count it among all the threads we have launched. Then 815 * start it up. */ 816 scsi_host_get(us_to_host(us)); 817 atomic_inc(&total_threads); 818 wake_up_process(th); 819 820 return 0; 821} 822 823/* Release all our dynamic resources */ 824static void usb_stor_release_resources(struct us_data *us) 825{ 826 US_DEBUGP("-- %s\n", __FUNCTION__); 827 828 /* Tell the control thread to exit. The SCSI host must 829 * already have been removed so it won't try to queue 830 * any more commands. 831 */ 832 US_DEBUGP("-- sending exit command to thread\n"); 833 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 834 up(&us->sema); 835 836 /* Call the destructor routine, if it exists */ 837 if (us->extra_destructor) { 838 US_DEBUGP("-- calling extra_destructor()\n"); 839 us->extra_destructor(us->extra); 840 } 841 842 /* Free the extra data and the URB */ 843 kfree(us->extra); 844 usb_free_urb(us->current_urb); 845} 846 847/* Dissociate from the USB device */ 848static void dissociate_dev(struct us_data *us) 849{ 850 US_DEBUGP("-- %s\n", __FUNCTION__); 851 852 kfree(us->sensebuf); 853 854 /* Free the device-related DMA-mapped buffers */ 855 if (us->cr) 856 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 857 us->cr_dma); 858 if (us->iobuf) 859 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 860 us->iobuf_dma); 861 862 /* Remove our private data from the interface */ 863 usb_set_intfdata(us->pusb_intf, NULL); 864} 865 866/* First stage of disconnect processing: stop all commands and remove 867 * the host */ 868static void quiesce_and_remove_host(struct us_data *us) 869{ 870 struct Scsi_Host *host = us_to_host(us); 871 872 /* Prevent new USB transfers, stop the current command, and 873 * interrupt a SCSI-scan or device-reset delay */ 874 scsi_lock(host); 875 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 876 scsi_unlock(host); 877 usb_stor_stop_transport(us); 878 wake_up(&us->delay_wait); 879 880 /* It doesn't matter if the SCSI-scanning thread is still running. 881 * The thread will exit when it sees the DISCONNECTING flag. */ 882 883 /* queuecommand won't accept any new commands and the control 884 * thread won't execute a previously-queued command. If there 885 * is such a command pending, complete it with an error. */ 886 mutex_lock(&us->dev_mutex); 887 if (us->srb) { 888 us->srb->result = DID_NO_CONNECT << 16; 889 scsi_lock(host); 890 us->srb->scsi_done(us->srb); 891 us->srb = NULL; 892 scsi_unlock(host); 893 } 894 mutex_unlock(&us->dev_mutex); 895 896 /* Now we own no commands so it's safe to remove the SCSI host */ 897 scsi_remove_host(host); 898} 899 900/* Second stage of disconnect processing: deallocate all resources */ 901static void release_everything(struct us_data *us) 902{ 903 usb_stor_release_resources(us); 904 dissociate_dev(us); 905 906 /* Drop our reference to the host; the SCSI core will free it 907 * (and "us" along with it) when the refcount becomes 0. */ 908 scsi_host_put(us_to_host(us)); 909} 910 911/* Thread to carry out delayed SCSI-device scanning */ 912static int usb_stor_scan_thread(void * __us) 913{ 914 struct us_data *us = (struct us_data *)__us; 915 916 printk(KERN_DEBUG 917 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 918 919 /* Wait for the timeout to expire or for a disconnect */ 920 if (delay_use > 0) { 921 printk(KERN_DEBUG "usb-storage: waiting for device " 922 "to settle before scanning\n"); 923retry: 924 wait_event_interruptible_timeout(us->delay_wait, 925 test_bit(US_FLIDX_DISCONNECTING, &us->flags), 926 delay_use * HZ); 927 if (try_to_freeze()) 928 goto retry; 929 } 930 931 /* If the device is still connected, perform the scanning */ 932 if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 933 934 /* For bulk-only devices, determine the max LUN value */ 935 if (us->protocol == US_PR_BULK && 936 !(us->flags & US_FL_SINGLE_LUN)) { 937 mutex_lock(&us->dev_mutex); 938 us->max_lun = usb_stor_Bulk_max_lun(us); 939 mutex_unlock(&us->dev_mutex); 940 } 941 scsi_scan_host(us_to_host(us)); 942 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 943 944 /* Should we unbind if no devices were detected? */ 945 } 946 947 scsi_host_put(us_to_host(us)); 948 complete_and_exit(&threads_gone, 0); 949} 950 951 952/* Probe to see if we can drive a newly-connected USB device */ 953static int storage_probe(struct usb_interface *intf, 954 const struct usb_device_id *id) 955{ 956 struct Scsi_Host *host; 957 struct us_data *us; 958 int result; 959 struct task_struct *th; 960 961 if (usb_usual_check_type(id, USB_US_TYPE_STOR)) 962 return -ENXIO; 963 964 US_DEBUGP("USB Mass Storage device detected\n"); 965 966 /* 967 * Ask the SCSI layer to allocate a host structure, with extra 968 * space at the end for our private us_data structure. 969 */ 970 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 971 if (!host) { 972 printk(KERN_WARNING USB_STORAGE 973 "Unable to allocate the scsi host\n"); 974 return -ENOMEM; 975 } 976 /*added by dennis start,12/04/2013,fix 3T/4T usb disk(NTFS) can't be mounted issue*/ 977 host->max_cmd_len = 16; 978 /*added by dennis end,12/04/2013,fix 3T/4T usb disk(NTFS) can't be mounted issue*/ 979 us = host_to_us(host); 980 memset(us, 0, sizeof(struct us_data)); 981 mutex_init(&(us->dev_mutex)); 982 init_MUTEX_LOCKED(&(us->sema)); 983 init_completion(&(us->notify)); 984 init_waitqueue_head(&us->delay_wait); 985 986 /* Associate the us_data structure with the USB device */ 987 result = associate_dev(us, intf); 988 if (result) 989 goto BadDevice; 990 991 /* 992 * Get the unusual_devs entries and the descriptors 993 * 994 * id_index is calculated in the declaration to be the index number 995 * of the match from the usb_device_id table, so we can find the 996 * corresponding entry in the private table. 997 */ 998 result = get_device_info(us, id); 999 if (result) 1000 goto BadDevice; 1001 1002 /* Get the transport, protocol, and pipe settings */ 1003 result = get_transport(us); 1004 if (result) 1005 goto BadDevice; 1006 result = get_protocol(us); 1007 if (result) 1008 goto BadDevice; 1009 result = get_pipes(us); 1010 if (result) 1011 goto BadDevice; 1012 1013 /* Acquire all the other resources and add the host */ 1014 result = usb_stor_acquire_resources(us); 1015 if (result) 1016 goto BadDevice; 1017 result = scsi_add_host(host, &intf->dev); 1018 if (result) { 1019 printk(KERN_WARNING USB_STORAGE 1020 "Unable to add the scsi host\n"); 1021 goto BadDevice; 1022 } 1023 1024 /* Start up the thread for delayed SCSI-device scanning */ 1025 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 1026 if (IS_ERR(th)) { 1027 printk(KERN_WARNING USB_STORAGE 1028 "Unable to start the device-scanning thread\n"); 1029 quiesce_and_remove_host(us); 1030 result = PTR_ERR(th); 1031 goto BadDevice; 1032 } 1033 1034 /* Take a reference to the host for the scanning thread and 1035 * count it among all the threads we have launched. Then 1036 * start it up. */ 1037 scsi_host_get(us_to_host(us)); 1038 atomic_inc(&total_threads); 1039 wake_up_process(th); 1040 1041 return 0; 1042 1043 /* We come here if there are any problems */ 1044BadDevice: 1045 US_DEBUGP("storage_probe() failed\n"); 1046 release_everything(us); 1047 return result; 1048} 1049 1050/* Handle a disconnect event from the USB core */ 1051static void storage_disconnect(struct usb_interface *intf) 1052{ 1053 struct us_data *us = usb_get_intfdata(intf); 1054 1055 US_DEBUGP("storage_disconnect() called\n"); 1056 quiesce_and_remove_host(us); 1057 release_everything(us); 1058} 1059 1060/*********************************************************************** 1061 * Initialization and registration 1062 ***********************************************************************/ 1063 1064static struct usb_driver usb_storage_driver = { 1065 .name = "usb-storage", 1066 .probe = storage_probe, 1067 .disconnect = storage_disconnect, 1068#ifdef CONFIG_PM 1069 .suspend = storage_suspend, 1070 .resume = storage_resume, 1071#endif 1072 .pre_reset = storage_pre_reset, 1073 .post_reset = storage_post_reset, 1074 .id_table = storage_usb_ids, 1075}; 1076 1077static int __init usb_stor_init(void) 1078{ 1079 int retval; 1080 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1081 1082 /* register the driver, return usb_register return code if error */ 1083 retval = usb_register(&usb_storage_driver); 1084 if (retval == 0) { 1085 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1086 usb_usual_set_present(USB_US_TYPE_STOR); 1087 } 1088 return retval; 1089} 1090 1091static void __exit usb_stor_exit(void) 1092{ 1093 US_DEBUGP("usb_stor_exit() called\n"); 1094 1095 /* Deregister the driver 1096 * This will cause disconnect() to be called for each 1097 * attached unit 1098 */ 1099 US_DEBUGP("-- calling usb_deregister()\n"); 1100 usb_deregister(&usb_storage_driver) ; 1101 1102 /* Don't return until all of our control and scanning threads 1103 * have exited. Since each thread signals threads_gone as its 1104 * last act, we have to call wait_for_completion the right number 1105 * of times. 1106 */ 1107 while (atomic_read(&total_threads) > 0) { 1108 wait_for_completion(&threads_gone); 1109 atomic_dec(&total_threads); 1110 } 1111 1112 usb_usual_clear_present(USB_US_TYPE_STOR); 1113} 1114 1115module_init(usb_stor_init); 1116module_exit(usb_stor_exit); 1117