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