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
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
74struct 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);
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) }
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 usb_stor_dbg(us, "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 usb_stor_dbg(us, "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 usb_stor_dbg(us, "0x%2x\n", us->iobuf[0]);
156 return USB_STOR_TRANSPORT_ERROR;
157 }
158
159 return USB_STOR_TRANSPORT_GOOD;
160}
161
162static int jumpshot_read_data(struct us_data *us,
163 struct jumpshot_info *info,
164 u32 sector,
165 u32 sectors)
166{
167 unsigned char *command = us->iobuf;
168 unsigned char *buffer;
169 unsigned char thistime;
170 unsigned int totallen, alloclen;
171 int len, result;
172 unsigned int sg_offset = 0;
173 struct scatterlist *sg = NULL;
174
175 // we're working in LBA mode. according to the ATA spec,
176 // we can support up to 28-bit addressing. I don't know if Jumpshot
177 // supports beyond 24-bit addressing. It's kind of hard to test
178 // since it requires > 8GB CF card.
179
180 if (sector > 0x0FFFFFFF)
181 return USB_STOR_TRANSPORT_ERROR;
182
183 totallen = sectors * info->ssize;
184
185 // Since we don't read more than 64 KB at a time, we have to create
186 // a bounce buffer and move the data a piece at a time between the
187 // bounce buffer and the actual transfer buffer.
188
189 alloclen = min(totallen, 65536u);
190 buffer = kmalloc(alloclen, GFP_NOIO);
191 if (buffer == NULL)
192 return USB_STOR_TRANSPORT_ERROR;
193
194 do {
195 // loop, never allocate or transfer more than 64k at once
196 // (min(128k, 255*info->ssize) is the real limit)
197 len = min(totallen, alloclen);
198 thistime = (len / info->ssize) & 0xff;
199
200 command[0] = 0;
201 command[1] = thistime;
202 command[2] = sector & 0xFF;
203 command[3] = (sector >> 8) & 0xFF;
204 command[4] = (sector >> 16) & 0xFF;
205
206 command[5] = 0xE0 | ((sector >> 24) & 0x0F);
207 command[6] = 0x20;
208
209 // send the setup + command
210 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
211 0, 0x20, 0, 1, command, 7);
212 if (result != USB_STOR_XFER_GOOD)
213 goto leave;
214
215 // read the result
216 result = jumpshot_bulk_read(us, buffer, len);
217 if (result != USB_STOR_XFER_GOOD)
218 goto leave;
219
220 usb_stor_dbg(us, "%d bytes\n", len);
221
222 // Store the data in the transfer buffer
223 usb_stor_access_xfer_buf(buffer, len, us->srb,
224 &sg, &sg_offset, TO_XFER_BUF);
225
226 sector += thistime;
227 totallen -= len;
228 } while (totallen > 0);
229
230 kfree(buffer);
231 return USB_STOR_TRANSPORT_GOOD;
232
233 leave:
234 kfree(buffer);
235 return USB_STOR_TRANSPORT_ERROR;
236}
237
238
239static int jumpshot_write_data(struct us_data *us,
240 struct jumpshot_info *info,
241 u32 sector,
242 u32 sectors)
243{
244 unsigned char *command = us->iobuf;
245 unsigned char *buffer;
246 unsigned char thistime;
247 unsigned int totallen, alloclen;
248 int len, result, waitcount;
249 unsigned int sg_offset = 0;
250 struct scatterlist *sg = NULL;
251
252 // we're working in LBA mode. according to the ATA spec,
253 // we can support up to 28-bit addressing. I don't know if Jumpshot
254 // supports beyond 24-bit addressing. It's kind of hard to test
255 // since it requires > 8GB CF card.
256 //
257 if (sector > 0x0FFFFFFF)
258 return USB_STOR_TRANSPORT_ERROR;
259
260 totallen = sectors * info->ssize;
261
262 // Since we don't write more than 64 KB at a time, we have to create
263 // a bounce buffer and move the data a piece at a time between the
264 // bounce buffer and the actual transfer buffer.
265
266 alloclen = min(totallen, 65536u);
267 buffer = kmalloc(alloclen, GFP_NOIO);
268 if (buffer == NULL)
269 return USB_STOR_TRANSPORT_ERROR;
270
271 do {
272 // loop, never allocate or transfer more than 64k at once
273 // (min(128k, 255*info->ssize) is the real limit)
274
275 len = min(totallen, alloclen);
276 thistime = (len / info->ssize) & 0xff;
277
278 // Get the data from the transfer buffer
279 usb_stor_access_xfer_buf(buffer, len, us->srb,
280 &sg, &sg_offset, FROM_XFER_BUF);
281
282 command[0] = 0;
283 command[1] = thistime;
284 command[2] = sector & 0xFF;
285 command[3] = (sector >> 8) & 0xFF;
286 command[4] = (sector >> 16) & 0xFF;
287
288 command[5] = 0xE0 | ((sector >> 24) & 0x0F);
289 command[6] = 0x30;
290
291 // send the setup + command
292 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
293 0, 0x20, 0, 1, command, 7);
294 if (result != USB_STOR_XFER_GOOD)
295 goto leave;
296
297 // send the data
298 result = jumpshot_bulk_write(us, buffer, len);
299 if (result != USB_STOR_XFER_GOOD)
300 goto leave;
301
302 // read the result. apparently the bulk write can complete
303 // before the jumpshot drive is finished writing. so we loop
304 // here until we get a good return code
305 waitcount = 0;
306 do {
307 result = jumpshot_get_status(us);
308 if (result != USB_STOR_TRANSPORT_GOOD) {
309 // I have not experimented to find the smallest value.
310 //
311 msleep(50);
312 }
313 } while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));
314
315 if (result != USB_STOR_TRANSPORT_GOOD)
316 usb_stor_dbg(us, "Gah! Waitcount = 10. Bad write!?\n");
317
318 sector += thistime;
319 totallen -= len;
320 } while (totallen > 0);
321
322 kfree(buffer);
323 return result;
324
325 leave:
326 kfree(buffer);
327 return USB_STOR_TRANSPORT_ERROR;
328}
329
330static int jumpshot_id_device(struct us_data *us,
331 struct jumpshot_info *info)
332{
333 unsigned char *command = us->iobuf;
334 unsigned char *reply;
335 int rc;
336
337 if (!info)
338 return USB_STOR_TRANSPORT_ERROR;
339
340 command[0] = 0xE0;
341 command[1] = 0xEC;
342 reply = kmalloc(512, GFP_NOIO);
343 if (!reply)
344 return USB_STOR_TRANSPORT_ERROR;
345
346 // send the setup
347 rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
348 0, 0x20, 0, 6, command, 2);
349
350 if (rc != USB_STOR_XFER_GOOD) {
351 usb_stor_dbg(us, "Gah! send_control for read_capacity failed\n");
352 rc = USB_STOR_TRANSPORT_ERROR;
353 goto leave;
354 }
355
356 // read the reply
357 rc = jumpshot_bulk_read(us, reply, 512);
358 if (rc != USB_STOR_XFER_GOOD) {
359 rc = USB_STOR_TRANSPORT_ERROR;
360 goto leave;
361 }
362
363 info->sectors = ((u32)(reply[117]) << 24) |
364 ((u32)(reply[116]) << 16) |
365 ((u32)(reply[115]) << 8) |
366 ((u32)(reply[114]) );
367
368 rc = USB_STOR_TRANSPORT_GOOD;
369
370 leave:
371 kfree(reply);
372 return rc;
373}
374
375static int jumpshot_handle_mode_sense(struct us_data *us,
376 struct scsi_cmnd * srb,
377 int sense_6)
378{
379 static unsigned char rw_err_page[12] = {
380 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
381 };
382 static unsigned char cache_page[12] = {
383 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
384 };
385 static unsigned char rbac_page[12] = {
386 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
387 };
388 static unsigned char timer_page[8] = {
389 0x1C, 0x6, 0, 0, 0, 0
390 };
391 unsigned char pc, page_code;
392 unsigned int i = 0;
393 struct jumpshot_info *info = (struct jumpshot_info *) (us->extra);
394 unsigned char *ptr = us->iobuf;
395
396 pc = srb->cmnd[2] >> 6;
397 page_code = srb->cmnd[2] & 0x3F;
398
399 switch (pc) {
400 case 0x0:
401 usb_stor_dbg(us, "Current values\n");
402 break;
403 case 0x1:
404 usb_stor_dbg(us, "Changeable values\n");
405 break;
406 case 0x2:
407 usb_stor_dbg(us, "Default values\n");
408 break;
409 case 0x3:
410 usb_stor_dbg(us, "Saves values\n");
411 break;
412 }
413
414 memset(ptr, 0, 8);
415 if (sense_6) {
416 ptr[2] = 0x00; // WP enable: 0x80
417 i = 4;
418 } else {
419 ptr[3] = 0x00; // WP enable: 0x80
420 i = 8;
421 }
422
423 switch (page_code) {
424 case 0x0:
425 // vendor-specific mode
426 info->sense_key = 0x05;
427 info->sense_asc = 0x24;
428 info->sense_ascq = 0x00;
429 return USB_STOR_TRANSPORT_FAILED;
430
431 case 0x1:
432 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
433 i += sizeof(rw_err_page);
434 break;
435
436 case 0x8:
437 memcpy(ptr + i, cache_page, sizeof(cache_page));
438 i += sizeof(cache_page);
439 break;
440
441 case 0x1B:
442 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
443 i += sizeof(rbac_page);
444 break;
445
446 case 0x1C:
447 memcpy(ptr + i, timer_page, sizeof(timer_page));
448 i += sizeof(timer_page);
449 break;
450
451 case 0x3F:
452 memcpy(ptr + i, timer_page, sizeof(timer_page));
453 i += sizeof(timer_page);
454 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
455 i += sizeof(rbac_page);
456 memcpy(ptr + i, cache_page, sizeof(cache_page));
457 i += sizeof(cache_page);
458 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
459 i += sizeof(rw_err_page);
460 break;
461 }
462
463 if (sense_6)
464 ptr[0] = i - 1;
465 else
466 ((__be16 *) ptr)[0] = cpu_to_be16(i - 2);
467 usb_stor_set_xfer_buf(ptr, i, srb);
468
469 return USB_STOR_TRANSPORT_GOOD;
470}
471
472
473static void jumpshot_info_destructor(void *extra)
474{
475 // this routine is a placeholder...
476 // currently, we don't allocate any extra blocks so we're okay
477}
478
479
480
481// Transport for the Lexar 'Jumpshot'
482//
483static int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us)
484{
485 struct jumpshot_info *info;
486 int rc;
487 unsigned long block, blocks;
488 unsigned char *ptr = us->iobuf;
489 static unsigned char inquiry_response[8] = {
490 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
491 };
492
493 if (!us->extra) {
494 us->extra = kzalloc(sizeof(struct jumpshot_info), GFP_NOIO);
495 if (!us->extra)
496 return USB_STOR_TRANSPORT_ERROR;
497
498 us->extra_destructor = jumpshot_info_destructor;
499 }
500
501 info = (struct jumpshot_info *) (us->extra);
502
503 if (srb->cmnd[0] == INQUIRY) {
504 usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
505 memcpy(ptr, inquiry_response, sizeof(inquiry_response));
506 fill_inquiry_response(us, ptr, 36);
507 return USB_STOR_TRANSPORT_GOOD;
508 }
509
510 if (srb->cmnd[0] == READ_CAPACITY) {
511 info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec
512
513 rc = jumpshot_get_status(us);
514 if (rc != USB_STOR_TRANSPORT_GOOD)
515 return rc;
516
517 rc = jumpshot_id_device(us, info);
518 if (rc != USB_STOR_TRANSPORT_GOOD)
519 return rc;
520
521 usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
522 info->sectors, info->ssize);
523
524 // build the reply
525 //
526 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
527 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
528 usb_stor_set_xfer_buf(ptr, 8, srb);
529
530 return USB_STOR_TRANSPORT_GOOD;
531 }
532
533 if (srb->cmnd[0] == MODE_SELECT_10) {
534 usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
535 return USB_STOR_TRANSPORT_ERROR;
536 }
537
538 if (srb->cmnd[0] == READ_10) {
539 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
540 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
541
542 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
543
544 usb_stor_dbg(us, "READ_10: read block 0x%04lx count %ld\n",
545 block, blocks);
546 return jumpshot_read_data(us, info, block, blocks);
547 }
548
549 if (srb->cmnd[0] == READ_12) {
550 // I don't think we'll ever see a READ_12 but support it anyway...
551 //
552 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
553 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
554
555 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
556 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9]));
557
558 usb_stor_dbg(us, "READ_12: read block 0x%04lx count %ld\n",
559 block, blocks);
560 return jumpshot_read_data(us, info, block, blocks);
561 }
562
563 if (srb->cmnd[0] == WRITE_10) {
564 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
565 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
566
567 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
568
569 usb_stor_dbg(us, "WRITE_10: write block 0x%04lx count %ld\n",
570 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 usb_stor_dbg(us, "WRITE_12: write block 0x%04lx count %ld\n",
584 block, blocks);
585 return jumpshot_write_data(us, info, block, blocks);
586 }
587
588
589 if (srb->cmnd[0] == TEST_UNIT_READY) {
590 usb_stor_dbg(us, "TEST_UNIT_READY\n");
591 return jumpshot_get_status(us);
592 }
593
594 if (srb->cmnd[0] == REQUEST_SENSE) {
595 usb_stor_dbg(us, "REQUEST_SENSE\n");
596
597 memset(ptr, 0, 18);
598 ptr[0] = 0xF0;
599 ptr[2] = info->sense_key;
600 ptr[7] = 11;
601 ptr[12] = info->sense_asc;
602 ptr[13] = info->sense_ascq;
603 usb_stor_set_xfer_buf(ptr, 18, srb);
604
605 return USB_STOR_TRANSPORT_GOOD;
606 }
607
608 if (srb->cmnd[0] == MODE_SENSE) {
609 usb_stor_dbg(us, "MODE_SENSE_6 detected\n");
610 return jumpshot_handle_mode_sense(us, srb, 1);
611 }
612
613 if (srb->cmnd[0] == MODE_SENSE_10) {
614 usb_stor_dbg(us, "MODE_SENSE_10 detected\n");
615 return jumpshot_handle_mode_sense(us, srb, 0);
616 }
617
618 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
619 // sure. whatever. not like we can stop the user from popping
620 // the media out of the device (no locking doors, etc)
621 //
622 return USB_STOR_TRANSPORT_GOOD;
623 }
624
625 if (srb->cmnd[0] == START_STOP) {
626 /* this is used by sd.c'check_scsidisk_media_change to detect
627 media change */
628 usb_stor_dbg(us, "START_STOP\n");
629 /* the first jumpshot_id_device after a media change returns
630 an error (determined experimentally) */
631 rc = jumpshot_id_device(us, info);
632 if (rc == USB_STOR_TRANSPORT_GOOD) {
633 info->sense_key = NO_SENSE;
634 srb->result = SUCCESS;
635 } else {
636 info->sense_key = UNIT_ATTENTION;
637 srb->result = SAM_STAT_CHECK_CONDITION;
638 }
639 return rc;
640 }
641
642 usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
643 srb->cmnd[0], srb->cmnd[0]);
644 info->sense_key = 0x05;
645 info->sense_asc = 0x20;
646 info->sense_ascq = 0x00;
647 return USB_STOR_TRANSPORT_FAILED;
648}
649
650static int jumpshot_probe(struct usb_interface *intf,
651 const struct usb_device_id *id)
652{
653 struct us_data *us;
654 int result;
655
656 result = usb_stor_probe1(&us, intf, id,
657 (id - jumpshot_usb_ids) + jumpshot_unusual_dev_list);
658 if (result)
659 return result;
660
661 us->transport_name = "Lexar Jumpshot Control/Bulk";
662 us->transport = jumpshot_transport;
663 us->transport_reset = usb_stor_Bulk_reset;
664 us->max_lun = 1;
665
666 result = usb_stor_probe2(us);
667 return result;
668}
669
670static struct usb_driver jumpshot_driver = {
671 .name = "ums-jumpshot",
672 .probe = jumpshot_probe,
673 .disconnect = usb_stor_disconnect,
674 .suspend = usb_stor_suspend,
675 .resume = usb_stor_resume,
676 .reset_resume = usb_stor_reset_resume,
677 .pre_reset = usb_stor_pre_reset,
678 .post_reset = usb_stor_post_reset,
679 .id_table = jumpshot_usb_ids,
680 .soft_unbind = 1,
681 .no_dynamic_id = 1,
682};
683
684module_usb_driver(jumpshot_driver);