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