?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc/fadump: Do not allow hot-remove memory from fadump reserved area.
[linux/fpc-iii.git] / drivers / usb / storage / jumpshot.c
blob917f170c4124f71fb79fbb6257e2a32d376cb0fa
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);
Linux with added FPC-III support