jumpshot.c revision 9d35214b415812372a7b1ba1091097b043837604
1/* Driver for Lexar "Jumpshot" Compact Flash reader 2 * 3 * jumpshot driver v0.1: 4 * 5 * First release 6 * 7 * Current development and maintenance by: 8 * (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org) 9 * 10 * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver 11 * which I used as a template for this driver. 12 * 13 * Some bugfixes and scatter-gather code by Gregory P. Smith 14 * (greg-usb@electricrain.com) 15 * 16 * Fix for media change by Joerg Schneider (js@joergschneider.com) 17 * 18 * Developed with the assistance of: 19 * 20 * (C) 2002 Alan Stern <stern@rowland.org> 21 * 22 * This program is free software; you can redistribute it and/or modify it 23 * under the terms of the GNU General Public License as published by the 24 * Free Software Foundation; either version 2, or (at your option) any 25 * later version. 26 * 27 * This program is distributed in the hope that it will be useful, but 28 * WITHOUT ANY WARRANTY; without even the implied warranty of 29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 30 * General Public License for more details. 31 * 32 * You should have received a copy of the GNU General Public License along 33 * with this program; if not, write to the Free Software Foundation, Inc., 34 * 675 Mass Ave, Cambridge, MA 02139, USA. 35 */ 36 37 /* 38 * This driver attempts to support the Lexar Jumpshot USB CompactFlash 39 * reader. Like many other USB CompactFlash readers, the Jumpshot contains 40 * a USB-to-ATA chip. 41 * 42 * This driver supports reading and writing. If you're truly paranoid, 43 * however, you can force the driver into a write-protected state by setting 44 * the WP enable bits in jumpshot_handle_mode_sense. See the comments 45 * in that routine. 46 */ 47 48#include <linux/errno.h> 49#include <linux/module.h> 50#include <linux/slab.h> 51 52#include <scsi/scsi.h> 53#include <scsi/scsi_cmnd.h> 54 55#include "usb.h" 56#include "transport.h" 57#include "protocol.h" 58#include "debug.h" 59 60 61MODULE_DESCRIPTION("Driver for Lexar \"Jumpshot\" Compact Flash reader"); 62MODULE_AUTHOR("Jimmie Mayfield <mayfield+usb@sackheads.org>"); 63MODULE_LICENSE("GPL"); 64 65/* 66 * The table of devices 67 */ 68#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 69 vendorName, productName, useProtocol, useTransport, \ 70 initFunction, flags) \ 71{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 72 .driver_info = (flags)|(USB_US_TYPE_STOR<<24) } 73 74static struct usb_device_id jumpshot_usb_ids[] = { 75# include "unusual_jumpshot.h" 76 { } /* Terminating entry */ 77}; 78MODULE_DEVICE_TABLE(usb, jumpshot_usb_ids); 79 80#undef UNUSUAL_DEV 81 82/* 83 * The flags table 84 */ 85#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 86 vendor_name, product_name, use_protocol, use_transport, \ 87 init_function, Flags) \ 88{ \ 89 .vendorName = vendor_name, \ 90 .productName = product_name, \ 91 .useProtocol = use_protocol, \ 92 .useTransport = use_transport, \ 93 .initFunction = init_function, \ 94} 95 96static struct us_unusual_dev jumpshot_unusual_dev_list[] = { 97# include "unusual_jumpshot.h" 98 { } /* Terminating entry */ 99}; 100 101#undef UNUSUAL_DEV 102 103 104struct jumpshot_info { 105 unsigned long sectors; /* total sector count */ 106 unsigned long ssize; /* sector size in bytes */ 107 108 /* the following aren't used yet */ 109 unsigned char sense_key; 110 unsigned long sense_asc; /* additional sense code */ 111 unsigned long sense_ascq; /* additional sense code qualifier */ 112}; 113 114static inline int jumpshot_bulk_read(struct us_data *us, 115 unsigned char *data, 116 unsigned int len) 117{ 118 if (len == 0) 119 return USB_STOR_XFER_GOOD; 120 121 US_DEBUGP("jumpshot_bulk_read: len = %d\n", len); 122 return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 123 data, len, NULL); 124} 125 126 127static inline int jumpshot_bulk_write(struct us_data *us, 128 unsigned char *data, 129 unsigned int len) 130{ 131 if (len == 0) 132 return USB_STOR_XFER_GOOD; 133 134 US_DEBUGP("jumpshot_bulk_write: len = %d\n", len); 135 return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 136 data, len, NULL); 137} 138 139 140static int jumpshot_get_status(struct us_data *us) 141{ 142 int rc; 143 144 if (!us) 145 return USB_STOR_TRANSPORT_ERROR; 146 147 // send the setup 148 rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, 149 0, 0xA0, 0, 7, us->iobuf, 1); 150 151 if (rc != USB_STOR_XFER_GOOD) 152 return USB_STOR_TRANSPORT_ERROR; 153 154 if (us->iobuf[0] != 0x50) { 155 US_DEBUGP("jumpshot_get_status: 0x%2x\n", 156 us->iobuf[0]); 157 return USB_STOR_TRANSPORT_ERROR; 158 } 159 160 return USB_STOR_TRANSPORT_GOOD; 161} 162 163static int jumpshot_read_data(struct us_data *us, 164 struct jumpshot_info *info, 165 u32 sector, 166 u32 sectors) 167{ 168 unsigned char *command = us->iobuf; 169 unsigned char *buffer; 170 unsigned char thistime; 171 unsigned int totallen, alloclen; 172 int len, result; 173 unsigned int sg_offset = 0; 174 struct scatterlist *sg = NULL; 175 176 // we're working in LBA mode. according to the ATA spec, 177 // we can support up to 28-bit addressing. I don't know if Jumpshot 178 // supports beyond 24-bit addressing. It's kind of hard to test 179 // since it requires > 8GB CF card. 180 181 if (sector > 0x0FFFFFFF) 182 return USB_STOR_TRANSPORT_ERROR; 183 184 totallen = sectors * info->ssize; 185 186 // Since we don't read more than 64 KB at a time, we have to create 187 // a bounce buffer and move the data a piece at a time between the 188 // bounce buffer and the actual transfer buffer. 189 190 alloclen = min(totallen, 65536u); 191 buffer = kmalloc(alloclen, GFP_NOIO); 192 if (buffer == NULL) 193 return USB_STOR_TRANSPORT_ERROR; 194 195 do { 196 // loop, never allocate or transfer more than 64k at once 197 // (min(128k, 255*info->ssize) is the real limit) 198 len = min(totallen, alloclen); 199 thistime = (len / info->ssize) & 0xff; 200 201 command[0] = 0; 202 command[1] = thistime; 203 command[2] = sector & 0xFF; 204 command[3] = (sector >> 8) & 0xFF; 205 command[4] = (sector >> 16) & 0xFF; 206 207 command[5] = 0xE0 | ((sector >> 24) & 0x0F); 208 command[6] = 0x20; 209 210 // send the setup + command 211 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, 212 0, 0x20, 0, 1, command, 7); 213 if (result != USB_STOR_XFER_GOOD) 214 goto leave; 215 216 // read the result 217 result = jumpshot_bulk_read(us, buffer, len); 218 if (result != USB_STOR_XFER_GOOD) 219 goto leave; 220 221 US_DEBUGP("jumpshot_read_data: %d bytes\n", len); 222 223 // Store the data in the transfer buffer 224 usb_stor_access_xfer_buf(buffer, len, us->srb, 225 &sg, &sg_offset, TO_XFER_BUF); 226 227 sector += thistime; 228 totallen -= len; 229 } while (totallen > 0); 230 231 kfree(buffer); 232 return USB_STOR_TRANSPORT_GOOD; 233 234 leave: 235 kfree(buffer); 236 return USB_STOR_TRANSPORT_ERROR; 237} 238 239 240static int jumpshot_write_data(struct us_data *us, 241 struct jumpshot_info *info, 242 u32 sector, 243 u32 sectors) 244{ 245 unsigned char *command = us->iobuf; 246 unsigned char *buffer; 247 unsigned char thistime; 248 unsigned int totallen, alloclen; 249 int len, result, waitcount; 250 unsigned int sg_offset = 0; 251 struct scatterlist *sg = NULL; 252 253 // we're working in LBA mode. according to the ATA spec, 254 // we can support up to 28-bit addressing. I don't know if Jumpshot 255 // supports beyond 24-bit addressing. It's kind of hard to test 256 // since it requires > 8GB CF card. 257 // 258 if (sector > 0x0FFFFFFF) 259 return USB_STOR_TRANSPORT_ERROR; 260 261 totallen = sectors * info->ssize; 262 263 // Since we don't write more than 64 KB at a time, we have to create 264 // a bounce buffer and move the data a piece at a time between the 265 // bounce buffer and the actual transfer buffer. 266 267 alloclen = min(totallen, 65536u); 268 buffer = kmalloc(alloclen, GFP_NOIO); 269 if (buffer == NULL) 270 return USB_STOR_TRANSPORT_ERROR; 271 272 do { 273 // loop, never allocate or transfer more than 64k at once 274 // (min(128k, 255*info->ssize) is the real limit) 275 276 len = min(totallen, alloclen); 277 thistime = (len / info->ssize) & 0xff; 278 279 // Get the data from the transfer buffer 280 usb_stor_access_xfer_buf(buffer, len, us->srb, 281 &sg, &sg_offset, FROM_XFER_BUF); 282 283 command[0] = 0; 284 command[1] = thistime; 285 command[2] = sector & 0xFF; 286 command[3] = (sector >> 8) & 0xFF; 287 command[4] = (sector >> 16) & 0xFF; 288 289 command[5] = 0xE0 | ((sector >> 24) & 0x0F); 290 command[6] = 0x30; 291 292 // send the setup + command 293 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, 294 0, 0x20, 0, 1, command, 7); 295 if (result != USB_STOR_XFER_GOOD) 296 goto leave; 297 298 // send the data 299 result = jumpshot_bulk_write(us, buffer, len); 300 if (result != USB_STOR_XFER_GOOD) 301 goto leave; 302 303 // read the result. apparently the bulk write can complete 304 // before the jumpshot drive is finished writing. so we loop 305 // here until we get a good return code 306 waitcount = 0; 307 do { 308 result = jumpshot_get_status(us); 309 if (result != USB_STOR_TRANSPORT_GOOD) { 310 // I have not experimented to find the smallest value. 311 // 312 msleep(50); 313 } 314 } while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10)); 315 316 if (result != USB_STOR_TRANSPORT_GOOD) 317 US_DEBUGP("jumpshot_write_data: Gah! Waitcount = 10. Bad write!?\n"); 318 319 sector += thistime; 320 totallen -= len; 321 } while (totallen > 0); 322 323 kfree(buffer); 324 return result; 325 326 leave: 327 kfree(buffer); 328 return USB_STOR_TRANSPORT_ERROR; 329} 330 331static int jumpshot_id_device(struct us_data *us, 332 struct jumpshot_info *info) 333{ 334 unsigned char *command = us->iobuf; 335 unsigned char *reply; 336 int rc; 337 338 if (!info) 339 return USB_STOR_TRANSPORT_ERROR; 340 341 command[0] = 0xE0; 342 command[1] = 0xEC; 343 reply = kmalloc(512, GFP_NOIO); 344 if (!reply) 345 return USB_STOR_TRANSPORT_ERROR; 346 347 // send the setup 348 rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, 349 0, 0x20, 0, 6, command, 2); 350 351 if (rc != USB_STOR_XFER_GOOD) { 352 US_DEBUGP("jumpshot_id_device: Gah! " 353 "send_control for read_capacity failed\n"); 354 rc = USB_STOR_TRANSPORT_ERROR; 355 goto leave; 356 } 357 358 // read the reply 359 rc = jumpshot_bulk_read(us, reply, 512); 360 if (rc != USB_STOR_XFER_GOOD) { 361 rc = USB_STOR_TRANSPORT_ERROR; 362 goto leave; 363 } 364 365 info->sectors = ((u32)(reply[117]) << 24) | 366 ((u32)(reply[116]) << 16) | 367 ((u32)(reply[115]) << 8) | 368 ((u32)(reply[114]) ); 369 370 rc = USB_STOR_TRANSPORT_GOOD; 371 372 leave: 373 kfree(reply); 374 return rc; 375} 376 377static int jumpshot_handle_mode_sense(struct us_data *us, 378 struct scsi_cmnd * srb, 379 int sense_6) 380{ 381 static unsigned char rw_err_page[12] = { 382 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0 383 }; 384 static unsigned char cache_page[12] = { 385 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0 386 }; 387 static unsigned char rbac_page[12] = { 388 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0 389 }; 390 static unsigned char timer_page[8] = { 391 0x1C, 0x6, 0, 0, 0, 0 392 }; 393 unsigned char pc, page_code; 394 unsigned int i = 0; 395 struct jumpshot_info *info = (struct jumpshot_info *) (us->extra); 396 unsigned char *ptr = us->iobuf; 397 398 pc = srb->cmnd[2] >> 6; 399 page_code = srb->cmnd[2] & 0x3F; 400 401 switch (pc) { 402 case 0x0: 403 US_DEBUGP("jumpshot_handle_mode_sense: Current values\n"); 404 break; 405 case 0x1: 406 US_DEBUGP("jumpshot_handle_mode_sense: Changeable values\n"); 407 break; 408 case 0x2: 409 US_DEBUGP("jumpshot_handle_mode_sense: Default values\n"); 410 break; 411 case 0x3: 412 US_DEBUGP("jumpshot_handle_mode_sense: Saves values\n"); 413 break; 414 } 415 416 memset(ptr, 0, 8); 417 if (sense_6) { 418 ptr[2] = 0x00; // WP enable: 0x80 419 i = 4; 420 } else { 421 ptr[3] = 0x00; // WP enable: 0x80 422 i = 8; 423 } 424 425 switch (page_code) { 426 case 0x0: 427 // vendor-specific mode 428 info->sense_key = 0x05; 429 info->sense_asc = 0x24; 430 info->sense_ascq = 0x00; 431 return USB_STOR_TRANSPORT_FAILED; 432 433 case 0x1: 434 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 435 i += sizeof(rw_err_page); 436 break; 437 438 case 0x8: 439 memcpy(ptr + i, cache_page, sizeof(cache_page)); 440 i += sizeof(cache_page); 441 break; 442 443 case 0x1B: 444 memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 445 i += sizeof(rbac_page); 446 break; 447 448 case 0x1C: 449 memcpy(ptr + i, timer_page, sizeof(timer_page)); 450 i += sizeof(timer_page); 451 break; 452 453 case 0x3F: 454 memcpy(ptr + i, timer_page, sizeof(timer_page)); 455 i += sizeof(timer_page); 456 memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 457 i += sizeof(rbac_page); 458 memcpy(ptr + i, cache_page, sizeof(cache_page)); 459 i += sizeof(cache_page); 460 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 461 i += sizeof(rw_err_page); 462 break; 463 } 464 465 if (sense_6) 466 ptr[0] = i - 1; 467 else 468 ((__be16 *) ptr)[0] = cpu_to_be16(i - 2); 469 usb_stor_set_xfer_buf(ptr, i, srb); 470 471 return USB_STOR_TRANSPORT_GOOD; 472} 473 474 475static void jumpshot_info_destructor(void *extra) 476{ 477 // this routine is a placeholder... 478 // currently, we don't allocate any extra blocks so we're okay 479} 480 481 482 483// Transport for the Lexar 'Jumpshot' 484// 485static int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us) 486{ 487 struct jumpshot_info *info; 488 int rc; 489 unsigned long block, blocks; 490 unsigned char *ptr = us->iobuf; 491 static unsigned char inquiry_response[8] = { 492 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 493 }; 494 495 if (!us->extra) { 496 us->extra = kzalloc(sizeof(struct jumpshot_info), GFP_NOIO); 497 if (!us->extra) { 498 US_DEBUGP("jumpshot_transport: Gah! Can't allocate storage for jumpshot info struct!\n"); 499 return USB_STOR_TRANSPORT_ERROR; 500 } 501 us->extra_destructor = jumpshot_info_destructor; 502 } 503 504 info = (struct jumpshot_info *) (us->extra); 505 506 if (srb->cmnd[0] == INQUIRY) { 507 US_DEBUGP("jumpshot_transport: INQUIRY. Returning bogus response.\n"); 508 memcpy(ptr, inquiry_response, sizeof(inquiry_response)); 509 fill_inquiry_response(us, ptr, 36); 510 return USB_STOR_TRANSPORT_GOOD; 511 } 512 513 if (srb->cmnd[0] == READ_CAPACITY) { 514 info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec 515 516 rc = jumpshot_get_status(us); 517 if (rc != USB_STOR_TRANSPORT_GOOD) 518 return rc; 519 520 rc = jumpshot_id_device(us, info); 521 if (rc != USB_STOR_TRANSPORT_GOOD) 522 return rc; 523 524 US_DEBUGP("jumpshot_transport: READ_CAPACITY: %ld sectors, %ld bytes per sector\n", 525 info->sectors, info->ssize); 526 527 // build the reply 528 // 529 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1); 530 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize); 531 usb_stor_set_xfer_buf(ptr, 8, srb); 532 533 return USB_STOR_TRANSPORT_GOOD; 534 } 535 536 if (srb->cmnd[0] == MODE_SELECT_10) { 537 US_DEBUGP("jumpshot_transport: Gah! MODE_SELECT_10.\n"); 538 return USB_STOR_TRANSPORT_ERROR; 539 } 540 541 if (srb->cmnd[0] == READ_10) { 542 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 543 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 544 545 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 546 547 US_DEBUGP("jumpshot_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks); 548 return jumpshot_read_data(us, info, block, blocks); 549 } 550 551 if (srb->cmnd[0] == READ_12) { 552 // I don't think we'll ever see a READ_12 but support it anyway... 553 // 554 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 555 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 556 557 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 558 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 559 560 US_DEBUGP("jumpshot_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks); 561 return jumpshot_read_data(us, info, block, blocks); 562 } 563 564 if (srb->cmnd[0] == WRITE_10) { 565 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 566 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 567 568 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 569 570 US_DEBUGP("jumpshot_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks); 571 return jumpshot_write_data(us, info, block, blocks); 572 } 573 574 if (srb->cmnd[0] == WRITE_12) { 575 // I don't think we'll ever see a WRITE_12 but support it anyway... 576 // 577 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 578 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 579 580 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 581 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 582 583 US_DEBUGP("jumpshot_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks); 584 return jumpshot_write_data(us, info, block, blocks); 585 } 586 587 588 if (srb->cmnd[0] == TEST_UNIT_READY) { 589 US_DEBUGP("jumpshot_transport: TEST_UNIT_READY.\n"); 590 return jumpshot_get_status(us); 591 } 592 593 if (srb->cmnd[0] == REQUEST_SENSE) { 594 US_DEBUGP("jumpshot_transport: REQUEST_SENSE.\n"); 595 596 memset(ptr, 0, 18); 597 ptr[0] = 0xF0; 598 ptr[2] = info->sense_key; 599 ptr[7] = 11; 600 ptr[12] = info->sense_asc; 601 ptr[13] = info->sense_ascq; 602 usb_stor_set_xfer_buf(ptr, 18, srb); 603 604 return USB_STOR_TRANSPORT_GOOD; 605 } 606 607 if (srb->cmnd[0] == MODE_SENSE) { 608 US_DEBUGP("jumpshot_transport: MODE_SENSE_6 detected\n"); 609 return jumpshot_handle_mode_sense(us, srb, 1); 610 } 611 612 if (srb->cmnd[0] == MODE_SENSE_10) { 613 US_DEBUGP("jumpshot_transport: MODE_SENSE_10 detected\n"); 614 return jumpshot_handle_mode_sense(us, srb, 0); 615 } 616 617 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 618 // sure. whatever. not like we can stop the user from popping 619 // the media out of the device (no locking doors, etc) 620 // 621 return USB_STOR_TRANSPORT_GOOD; 622 } 623 624 if (srb->cmnd[0] == START_STOP) { 625 /* this is used by sd.c'check_scsidisk_media_change to detect 626 media change */ 627 US_DEBUGP("jumpshot_transport: START_STOP.\n"); 628 /* the first jumpshot_id_device after a media change returns 629 an error (determined experimentally) */ 630 rc = jumpshot_id_device(us, info); 631 if (rc == USB_STOR_TRANSPORT_GOOD) { 632 info->sense_key = NO_SENSE; 633 srb->result = SUCCESS; 634 } else { 635 info->sense_key = UNIT_ATTENTION; 636 srb->result = SAM_STAT_CHECK_CONDITION; 637 } 638 return rc; 639 } 640 641 US_DEBUGP("jumpshot_transport: Gah! Unknown command: %d (0x%x)\n", 642 srb->cmnd[0], srb->cmnd[0]); 643 info->sense_key = 0x05; 644 info->sense_asc = 0x20; 645 info->sense_ascq = 0x00; 646 return USB_STOR_TRANSPORT_FAILED; 647} 648 649static int jumpshot_probe(struct usb_interface *intf, 650 const struct usb_device_id *id) 651{ 652 struct us_data *us; 653 int result; 654 655 result = usb_stor_probe1(&us, intf, id, 656 (id - jumpshot_usb_ids) + jumpshot_unusual_dev_list); 657 if (result) 658 return result; 659 660 us->transport_name = "Lexar Jumpshot Control/Bulk"; 661 us->transport = jumpshot_transport; 662 us->transport_reset = usb_stor_Bulk_reset; 663 us->max_lun = 1; 664 665 result = usb_stor_probe2(us); 666 return result; 667} 668 669static struct usb_driver jumpshot_driver = { 670 .name = "ums-jumpshot", 671 .probe = jumpshot_probe, 672 .disconnect = usb_stor_disconnect, 673 .suspend = usb_stor_suspend, 674 .resume = usb_stor_resume, 675 .reset_resume = usb_stor_reset_resume, 676 .pre_reset = usb_stor_pre_reset, 677 .post_reset = usb_stor_post_reset, 678 .id_table = jumpshot_usb_ids, 679 .soft_unbind = 1, 680}; 681 682static int __init jumpshot_init(void) 683{ 684 return usb_register(&jumpshot_driver); 685} 686 687static void __exit jumpshot_exit(void) 688{ 689 usb_deregister(&jumpshot_driver); 690} 691 692module_init(jumpshot_init); 693module_exit(jumpshot_exit); 694