1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include <linux/errno.h>
45#include <linux/module.h>
46#include <linux/slab.h>
47
48#include <scsi/scsi.h>
49#include <scsi/scsi_cmnd.h>
50#include <scsi/scsi_device.h>
51
52#include "usb.h"
53#include "transport.h"
54#include "protocol.h"
55#include "debug.h"
56#include "scsiglue.h"
57
58#define DRV_NAME "ums-sddr09"
59
60MODULE_DESCRIPTION("Driver for SanDisk SDDR-09 SmartMedia reader");
61MODULE_AUTHOR("Andries Brouwer <aeb@cwi.nl>, Robert Baruch <autophile@starband.net>");
62MODULE_LICENSE("GPL");
63
64static int usb_stor_sddr09_dpcm_init(struct us_data *us);
65static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us);
66static int usb_stor_sddr09_init(struct us_data *us);
67
68
69
70
71
72#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
73 vendorName, productName, useProtocol, useTransport, \
74 initFunction, flags) \
75{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
76 .driver_info = (flags) }
77
78static struct usb_device_id sddr09_usb_ids[] = {
79# include "unusual_sddr09.h"
80 { }
81};
82MODULE_DEVICE_TABLE(usb, sddr09_usb_ids);
83
84#undef UNUSUAL_DEV
85
86
87
88
89#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
90 vendor_name, product_name, use_protocol, use_transport, \
91 init_function, Flags) \
92{ \
93 .vendorName = vendor_name, \
94 .productName = product_name, \
95 .useProtocol = use_protocol, \
96 .useTransport = use_transport, \
97 .initFunction = init_function, \
98}
99
100static struct us_unusual_dev sddr09_unusual_dev_list[] = {
101# include "unusual_sddr09.h"
102 { }
103};
104
105#undef UNUSUAL_DEV
106
107
108#define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
109#define LSB_of(s) ((s)&0xFF)
110#define MSB_of(s) ((s)>>8)
111
112
113
114
115
116
117
118
119struct nand_flash_dev {
120 int model_id;
121 int chipshift;
122 char pageshift;
123 char blockshift;
124 char zoneshift;
125
126 char pageadrlen;
127};
128
129
130
131
132#define NAND_MFR_AMD 0x01
133#define NAND_MFR_NATSEMI 0x8f
134#define NAND_MFR_TOSHIBA 0x98
135#define NAND_MFR_SAMSUNG 0xec
136
137static inline char *nand_flash_manufacturer(int manuf_id) {
138 switch(manuf_id) {
139 case NAND_MFR_AMD:
140 return "AMD";
141 case NAND_MFR_NATSEMI:
142 return "NATSEMI";
143 case NAND_MFR_TOSHIBA:
144 return "Toshiba";
145 case NAND_MFR_SAMSUNG:
146 return "Samsung";
147 default:
148 return "unknown";
149 }
150}
151
152
153
154
155
156
157
158
159static struct nand_flash_dev nand_flash_ids[] = {
160
161 { 0x6e, 20, 8, 4, 8, 2},
162 { 0xe8, 20, 8, 4, 8, 2},
163 { 0xec, 20, 8, 4, 8, 2},
164 { 0x64, 21, 8, 4, 9, 2},
165 { 0xea, 21, 8, 4, 9, 2},
166 { 0x6b, 22, 9, 4, 9, 2},
167 { 0xe3, 22, 9, 4, 9, 2},
168 { 0xe5, 22, 9, 4, 9, 2},
169 { 0xe6, 23, 9, 4, 10, 2},
170 { 0x73, 24, 9, 5, 10, 2},
171 { 0x75, 25, 9, 5, 10, 2},
172 { 0x76, 26, 9, 5, 10, 3},
173 { 0x79, 27, 9, 5, 10, 3},
174
175
176 { 0x5d, 21, 9, 4, 8, 2},
177 { 0xd5, 22, 9, 4, 9, 2},
178 { 0xd6, 23, 9, 4, 10, 2},
179 { 0x57, 24, 9, 4, 11, 2},
180 { 0x58, 25, 9, 4, 12, 2},
181 { 0,}
182};
183
184static struct nand_flash_dev *
185nand_find_id(unsigned char id) {
186 int i;
187
188 for (i = 0; i < ARRAY_SIZE(nand_flash_ids); i++)
189 if (nand_flash_ids[i].model_id == id)
190 return &(nand_flash_ids[i]);
191 return NULL;
192}
193
194
195
196
197static unsigned char parity[256];
198static unsigned char ecc2[256];
199
200static void nand_init_ecc(void) {
201 int i, j, a;
202
203 parity[0] = 0;
204 for (i = 1; i < 256; i++)
205 parity[i] = (parity[i&(i-1)] ^ 1);
206
207 for (i = 0; i < 256; i++) {
208 a = 0;
209 for (j = 0; j < 8; j++) {
210 if (i & (1<<j)) {
211 if ((j & 1) == 0)
212 a ^= 0x04;
213 if ((j & 2) == 0)
214 a ^= 0x10;
215 if ((j & 4) == 0)
216 a ^= 0x40;
217 }
218 }
219 ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0));
220 }
221}
222
223
224static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) {
225 int i, j, a;
226 unsigned char par = 0, bit, bits[8] = {0};
227
228
229 for (i = 0; i < 256; i++) {
230 par ^= data[i];
231 bit = parity[data[i]];
232 for (j = 0; j < 8; j++)
233 if ((i & (1<<j)) == 0)
234 bits[j] ^= bit;
235 }
236
237
238 a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0];
239 ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
240
241 a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4];
242 ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
243
244 ecc[2] = ecc2[par];
245}
246
247static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) {
248 return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]);
249}
250
251static void nand_store_ecc(unsigned char *data, unsigned char *ecc) {
252 memcpy(data, ecc, 3);
253}
254
255
256
257
258
259struct sddr09_card_info {
260 unsigned long capacity;
261 int pagesize;
262 int pageshift;
263 int blocksize;
264 int blockshift;
265 int blockmask;
266 int *lba_to_pba;
267 int *pba_to_lba;
268 int lbact;
269 int flags;
270#define SDDR09_WP 1
271};
272
273
274
275
276
277
278
279#define CONTROL_SHIFT 6
280
281
282
283
284
285
286#define LUN 1
287#define LUNBITS (LUN << 5)
288
289
290
291
292#define UNDEF 0xffffffff
293#define SPARE 0xfffffffe
294#define UNUSABLE 0xfffffffd
295
296static const int erase_bad_lba_entries = 0;
297
298
299
300static int
301sddr09_send_command(struct us_data *us,
302 unsigned char request,
303 unsigned char direction,
304 unsigned char *xfer_data,
305 unsigned int xfer_len) {
306 unsigned int pipe;
307 unsigned char requesttype = (0x41 | direction);
308 int rc;
309
310
311
312 if (direction == USB_DIR_IN)
313 pipe = us->recv_ctrl_pipe;
314 else
315 pipe = us->send_ctrl_pipe;
316
317 rc = usb_stor_ctrl_transfer(us, pipe, request, requesttype,
318 0, 0, xfer_data, xfer_len);
319 switch (rc) {
320 case USB_STOR_XFER_GOOD: return 0;
321 case USB_STOR_XFER_STALLED: return -EPIPE;
322 default: return -EIO;
323 }
324}
325
326static int
327sddr09_send_scsi_command(struct us_data *us,
328 unsigned char *command,
329 unsigned int command_len) {
330 return sddr09_send_command(us, 0, USB_DIR_OUT, command, command_len);
331}
332
333#if 0
334
335
336
337
338static int
339sddr09_test_unit_ready(struct us_data *us) {
340 unsigned char *command = us->iobuf;
341 int result;
342
343 memset(command, 0, 6);
344 command[1] = LUNBITS;
345
346 result = sddr09_send_scsi_command(us, command, 6);
347
348 usb_stor_dbg(us, "sddr09_test_unit_ready returns %d\n", result);
349
350 return result;
351}
352#endif
353
354
355
356
357
358
359static int
360sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) {
361 unsigned char *command = us->iobuf;
362 int result;
363
364 memset(command, 0, 12);
365 command[0] = 0x03;
366 command[1] = LUNBITS;
367 command[4] = buflen;
368
369 result = sddr09_send_scsi_command(us, command, 12);
370 if (result)
371 return result;
372
373 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
374 sensebuf, buflen, NULL);
375 return (result == USB_STOR_XFER_GOOD ? 0 : -EIO);
376}
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400static int
401sddr09_readX(struct us_data *us, int x, unsigned long fromaddress,
402 int nr_of_pages, int bulklen, unsigned char *buf,
403 int use_sg) {
404
405 unsigned char *command = us->iobuf;
406 int result;
407
408 command[0] = 0xE8;
409 command[1] = LUNBITS | x;
410 command[2] = MSB_of(fromaddress>>16);
411 command[3] = LSB_of(fromaddress>>16);
412 command[4] = MSB_of(fromaddress & 0xFFFF);
413 command[5] = LSB_of(fromaddress & 0xFFFF);
414 command[6] = 0;
415 command[7] = 0;
416 command[8] = 0;
417 command[9] = 0;
418 command[10] = MSB_of(nr_of_pages);
419 command[11] = LSB_of(nr_of_pages);
420
421 result = sddr09_send_scsi_command(us, command, 12);
422
423 if (result) {
424 usb_stor_dbg(us, "Result for send_control in sddr09_read2%d %d\n",
425 x, result);
426 return result;
427 }
428
429 result = usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe,
430 buf, bulklen, use_sg, NULL);
431
432 if (result != USB_STOR_XFER_GOOD) {
433 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_read2%d %d\n",
434 x, result);
435 return -EIO;
436 }
437 return 0;
438}
439
440
441
442
443
444
445
446
447
448
449static int
450sddr09_read20(struct us_data *us, unsigned long fromaddress,
451 int nr_of_pages, int pageshift, unsigned char *buf, int use_sg) {
452 int bulklen = nr_of_pages << pageshift;
453
454
455 return sddr09_readX(us, 0, fromaddress, nr_of_pages, bulklen,
456 buf, use_sg);
457}
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472static int
473sddr09_read21(struct us_data *us, unsigned long fromaddress,
474 int count, int controlshift, unsigned char *buf, int use_sg) {
475
476 int bulklen = (count << controlshift);
477 return sddr09_readX(us, 1, fromaddress, count, bulklen,
478 buf, use_sg);
479}
480
481
482
483
484
485
486
487
488
489
490static int
491sddr09_read22(struct us_data *us, unsigned long fromaddress,
492 int nr_of_pages, int pageshift, unsigned char *buf, int use_sg) {
493
494 int bulklen = (nr_of_pages << pageshift) + (nr_of_pages << CONTROL_SHIFT);
495 usb_stor_dbg(us, "reading %d pages, %d bytes\n", nr_of_pages, bulklen);
496 return sddr09_readX(us, 2, fromaddress, nr_of_pages, bulklen,
497 buf, use_sg);
498}
499
500#if 0
501
502
503
504
505
506
507
508
509
510
511
512
513
514static int
515sddr09_read23(struct us_data *us, unsigned long fromaddress,
516 int count, int controlshift, unsigned char *buf, int use_sg) {
517
518 int bulklen = (count << controlshift);
519 return sddr09_readX(us, 3, fromaddress, count, bulklen,
520 buf, use_sg);
521}
522#endif
523
524
525
526
527
528
529
530
531
532
533static int
534sddr09_erase(struct us_data *us, unsigned long Eaddress) {
535 unsigned char *command = us->iobuf;
536 int result;
537
538 usb_stor_dbg(us, "erase address %lu\n", Eaddress);
539
540 memset(command, 0, 12);
541 command[0] = 0xEA;
542 command[1] = LUNBITS;
543 command[6] = MSB_of(Eaddress>>16);
544 command[7] = LSB_of(Eaddress>>16);
545 command[8] = MSB_of(Eaddress & 0xFFFF);
546 command[9] = LSB_of(Eaddress & 0xFFFF);
547
548 result = sddr09_send_scsi_command(us, command, 12);
549
550 if (result)
551 usb_stor_dbg(us, "Result for send_control in sddr09_erase %d\n",
552 result);
553
554 return result;
555}
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582static int
583sddr09_writeX(struct us_data *us,
584 unsigned long Waddress, unsigned long Eaddress,
585 int nr_of_pages, int bulklen, unsigned char *buf, int use_sg) {
586
587 unsigned char *command = us->iobuf;
588 int result;
589
590 command[0] = 0xE9;
591 command[1] = LUNBITS;
592
593 command[2] = MSB_of(Waddress>>16);
594 command[3] = LSB_of(Waddress>>16);
595 command[4] = MSB_of(Waddress & 0xFFFF);
596 command[5] = LSB_of(Waddress & 0xFFFF);
597
598 command[6] = MSB_of(Eaddress>>16);
599 command[7] = LSB_of(Eaddress>>16);
600 command[8] = MSB_of(Eaddress & 0xFFFF);
601 command[9] = LSB_of(Eaddress & 0xFFFF);
602
603 command[10] = MSB_of(nr_of_pages);
604 command[11] = LSB_of(nr_of_pages);
605
606 result = sddr09_send_scsi_command(us, command, 12);
607
608 if (result) {
609 usb_stor_dbg(us, "Result for send_control in sddr09_writeX %d\n",
610 result);
611 return result;
612 }
613
614 result = usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe,
615 buf, bulklen, use_sg, NULL);
616
617 if (result != USB_STOR_XFER_GOOD) {
618 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_writeX %d\n",
619 result);
620 return -EIO;
621 }
622 return 0;
623}
624
625
626static int
627sddr09_write_inplace(struct us_data *us, unsigned long address,
628 int nr_of_pages, int pageshift, unsigned char *buf,
629 int use_sg) {
630 int bulklen = (nr_of_pages << pageshift) + (nr_of_pages << CONTROL_SHIFT);
631 return sddr09_writeX(us, address, address, nr_of_pages, bulklen,
632 buf, use_sg);
633}
634
635#if 0
636
637
638
639
640
641
642
643
644
645
646
647static int
648sddr09_read_sg_test_only(struct us_data *us) {
649 unsigned char *command = us->iobuf;
650 int result, bulklen, nsg, ct;
651 unsigned char *buf;
652 unsigned long address;
653
654 nsg = bulklen = 0;
655 command[0] = 0xE7;
656 command[1] = LUNBITS;
657 command[2] = 0;
658 address = 040000; ct = 1;
659 nsg++;
660 bulklen += (ct << 9);
661 command[4*nsg+2] = ct;
662 command[4*nsg+1] = ((address >> 9) & 0xFF);
663 command[4*nsg+0] = ((address >> 17) & 0xFF);
664 command[4*nsg-1] = ((address >> 25) & 0xFF);
665
666 address = 0340000; ct = 1;
667 nsg++;
668 bulklen += (ct << 9);
669 command[4*nsg+2] = ct;
670 command[4*nsg+1] = ((address >> 9) & 0xFF);
671 command[4*nsg+0] = ((address >> 17) & 0xFF);
672 command[4*nsg-1] = ((address >> 25) & 0xFF);
673
674 address = 01000000; ct = 2;
675 nsg++;
676 bulklen += (ct << 9);
677 command[4*nsg+2] = ct;
678 command[4*nsg+1] = ((address >> 9) & 0xFF);
679 command[4*nsg+0] = ((address >> 17) & 0xFF);
680 command[4*nsg-1] = ((address >> 25) & 0xFF);
681
682 command[2] = nsg;
683
684 result = sddr09_send_scsi_command(us, command, 4*nsg+3);
685
686 if (result) {
687 usb_stor_dbg(us, "Result for send_control in sddr09_read_sg %d\n",
688 result);
689 return result;
690 }
691
692 buf = kmalloc(bulklen, GFP_NOIO);
693 if (!buf)
694 return -ENOMEM;
695
696 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
697 buf, bulklen, NULL);
698 kfree(buf);
699 if (result != USB_STOR_XFER_GOOD) {
700 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_read_sg %d\n",
701 result);
702 return -EIO;
703 }
704
705 return 0;
706}
707#endif
708
709
710
711
712
713
714
715
716
717
718
719
720static int
721sddr09_read_status(struct us_data *us, unsigned char *status) {
722
723 unsigned char *command = us->iobuf;
724 unsigned char *data = us->iobuf;
725 int result;
726
727 usb_stor_dbg(us, "Reading status...\n");
728
729 memset(command, 0, 12);
730 command[0] = 0xEC;
731 command[1] = LUNBITS;
732
733 result = sddr09_send_scsi_command(us, command, 12);
734 if (result)
735 return result;
736
737 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
738 data, 64, NULL);
739 *status = data[0];
740 return (result == USB_STOR_XFER_GOOD ? 0 : -EIO);
741}
742
743static int
744sddr09_read_data(struct us_data *us,
745 unsigned long address,
746 unsigned int sectors) {
747
748 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
749 unsigned char *buffer;
750 unsigned int lba, maxlba, pba;
751 unsigned int page, pages;
752 unsigned int len, offset;
753 struct scatterlist *sg;
754 int result;
755
756
757 lba = address >> info->blockshift;
758 page = (address & info->blockmask);
759 maxlba = info->capacity >> (info->pageshift + info->blockshift);
760 if (lba >= maxlba)
761 return -EIO;
762
763
764
765
766
767 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
768 buffer = kmalloc(len, GFP_NOIO);
769 if (!buffer)
770 return -ENOMEM;
771
772
773
774
775 result = 0;
776 offset = 0;
777 sg = NULL;
778
779 while (sectors > 0) {
780
781
782 pages = min(sectors, info->blocksize - page);
783 len = pages << info->pageshift;
784
785
786 if (lba >= maxlba) {
787 usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n",
788 lba, maxlba);
789 result = -EIO;
790 break;
791 }
792
793
794 pba = info->lba_to_pba[lba];
795
796 if (pba == UNDEF) {
797
798 usb_stor_dbg(us, "Read %d zero pages (LBA %d) page %d\n",
799 pages, lba, page);
800
801
802
803
804
805
806
807
808 memset(buffer, 0, len);
809
810 } else {
811 usb_stor_dbg(us, "Read %d pages, from PBA %d (LBA %d) page %d\n",
812 pages, pba, lba, page);
813
814 address = ((pba << info->blockshift) + page) <<
815 info->pageshift;
816
817 result = sddr09_read20(us, address>>1,
818 pages, info->pageshift, buffer, 0);
819 if (result)
820 break;
821 }
822
823
824 usb_stor_access_xfer_buf(buffer, len, us->srb,
825 &sg, &offset, TO_XFER_BUF);
826
827 page = 0;
828 lba++;
829 sectors -= pages;
830 }
831
832 kfree(buffer);
833 return result;
834}
835
836static unsigned int
837sddr09_find_unused_pba(struct sddr09_card_info *info, unsigned int lba) {
838 static unsigned int lastpba = 1;
839 int zonestart, end, i;
840
841 zonestart = (lba/1000) << 10;
842 end = info->capacity >> (info->blockshift + info->pageshift);
843 end -= zonestart;
844 if (end > 1024)
845 end = 1024;
846
847 for (i = lastpba+1; i < end; i++) {
848 if (info->pba_to_lba[zonestart+i] == UNDEF) {
849 lastpba = i;
850 return zonestart+i;
851 }
852 }
853 for (i = 0; i <= lastpba; i++) {
854 if (info->pba_to_lba[zonestart+i] == UNDEF) {
855 lastpba = i;
856 return zonestart+i;
857 }
858 }
859 return 0;
860}
861
862static int
863sddr09_write_lba(struct us_data *us, unsigned int lba,
864 unsigned int page, unsigned int pages,
865 unsigned char *ptr, unsigned char *blockbuffer) {
866
867 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
868 unsigned long address;
869 unsigned int pba, lbap;
870 unsigned int pagelen;
871 unsigned char *bptr, *cptr, *xptr;
872 unsigned char ecc[3];
873 int i, result;
874
875 lbap = ((lba % 1000) << 1) | 0x1000;
876 if (parity[MSB_of(lbap) ^ LSB_of(lbap)])
877 lbap ^= 1;
878 pba = info->lba_to_pba[lba];
879
880 if (pba == UNDEF) {
881 pba = sddr09_find_unused_pba(info, lba);
882 if (!pba) {
883 printk(KERN_WARNING
884 "sddr09_write_lba: Out of unused blocks\n");
885 return -ENOSPC;
886 }
887 info->pba_to_lba[pba] = lba;
888 info->lba_to_pba[lba] = pba;
889 }
890
891 if (pba == 1) {
892
893
894
895
896 printk(KERN_WARNING "sddr09: avoid writing to pba 1\n");
897 return 0;
898 }
899
900 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
901
902
903 address = (pba << (info->pageshift + info->blockshift));
904 result = sddr09_read22(us, address>>1, info->blocksize,
905 info->pageshift, blockbuffer, 0);
906 if (result)
907 return result;
908
909
910 for (i = 0; i < info->blocksize; i++) {
911 bptr = blockbuffer + i*pagelen;
912 cptr = bptr + info->pagesize;
913 nand_compute_ecc(bptr, ecc);
914 if (!nand_compare_ecc(cptr+13, ecc)) {
915 usb_stor_dbg(us, "Warning: bad ecc in page %d- of pba %d\n",
916 i, pba);
917 nand_store_ecc(cptr+13, ecc);
918 }
919 nand_compute_ecc(bptr+(info->pagesize / 2), ecc);
920 if (!nand_compare_ecc(cptr+8, ecc)) {
921 usb_stor_dbg(us, "Warning: bad ecc in page %d+ of pba %d\n",
922 i, pba);
923 nand_store_ecc(cptr+8, ecc);
924 }
925 cptr[6] = cptr[11] = MSB_of(lbap);
926 cptr[7] = cptr[12] = LSB_of(lbap);
927 }
928
929
930 xptr = ptr;
931 for (i = page; i < page+pages; i++) {
932 bptr = blockbuffer + i*pagelen;
933 cptr = bptr + info->pagesize;
934 memcpy(bptr, xptr, info->pagesize);
935 xptr += info->pagesize;
936 nand_compute_ecc(bptr, ecc);
937 nand_store_ecc(cptr+13, ecc);
938 nand_compute_ecc(bptr+(info->pagesize / 2), ecc);
939 nand_store_ecc(cptr+8, ecc);
940 }
941
942 usb_stor_dbg(us, "Rewrite PBA %d (LBA %d)\n", pba, lba);
943
944 result = sddr09_write_inplace(us, address>>1, info->blocksize,
945 info->pageshift, blockbuffer, 0);
946
947 usb_stor_dbg(us, "sddr09_write_inplace returns %d\n", result);
948
949#if 0
950 {
951 unsigned char status = 0;
952 int result2 = sddr09_read_status(us, &status);
953 if (result2)
954 usb_stor_dbg(us, "cannot read status\n");
955 else if (status != 0xc0)
956 usb_stor_dbg(us, "status after write: 0x%x\n", status);
957 }
958#endif
959
960#if 0
961 {
962 int result2 = sddr09_test_unit_ready(us);
963 }
964#endif
965
966 return result;
967}
968
969static int
970sddr09_write_data(struct us_data *us,
971 unsigned long address,
972 unsigned int sectors) {
973
974 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
975 unsigned int lba, maxlba, page, pages;
976 unsigned int pagelen, blocklen;
977 unsigned char *blockbuffer;
978 unsigned char *buffer;
979 unsigned int len, offset;
980 struct scatterlist *sg;
981 int result;
982
983
984 lba = address >> info->blockshift;
985 page = (address & info->blockmask);
986 maxlba = info->capacity >> (info->pageshift + info->blockshift);
987 if (lba >= maxlba)
988 return -EIO;
989
990
991
992
993
994
995
996
997
998
999
1000 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
1001 blocklen = (pagelen << info->blockshift);
1002 blockbuffer = kmalloc(blocklen, GFP_NOIO);
1003 if (!blockbuffer)
1004 return -ENOMEM;
1005
1006
1007
1008
1009
1010
1011
1012 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
1013 buffer = kmalloc(len, GFP_NOIO);
1014 if (!buffer) {
1015 kfree(blockbuffer);
1016 return -ENOMEM;
1017 }
1018
1019 result = 0;
1020 offset = 0;
1021 sg = NULL;
1022
1023 while (sectors > 0) {
1024
1025
1026
1027 pages = min(sectors, info->blocksize - page);
1028 len = (pages << info->pageshift);
1029
1030
1031 if (lba >= maxlba) {
1032 usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n",
1033 lba, maxlba);
1034 result = -EIO;
1035 break;
1036 }
1037
1038
1039 usb_stor_access_xfer_buf(buffer, len, us->srb,
1040 &sg, &offset, FROM_XFER_BUF);
1041
1042 result = sddr09_write_lba(us, lba, page, pages,
1043 buffer, blockbuffer);
1044 if (result)
1045 break;
1046
1047 page = 0;
1048 lba++;
1049 sectors -= pages;
1050 }
1051
1052 kfree(buffer);
1053 kfree(blockbuffer);
1054
1055 return result;
1056}
1057
1058static int
1059sddr09_read_control(struct us_data *us,
1060 unsigned long address,
1061 unsigned int blocks,
1062 unsigned char *content,
1063 int use_sg) {
1064
1065 usb_stor_dbg(us, "Read control address %lu, blocks %d\n",
1066 address, blocks);
1067
1068 return sddr09_read21(us, address, blocks,
1069 CONTROL_SHIFT, content, use_sg);
1070}
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082static int
1083sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) {
1084 unsigned char *command = us->iobuf;
1085 unsigned char *content = us->iobuf;
1086 int result, i;
1087
1088 memset(command, 0, 12);
1089 command[0] = 0xED;
1090 command[1] = LUNBITS;
1091
1092 result = sddr09_send_scsi_command(us, command, 12);
1093 if (result)
1094 return result;
1095
1096 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1097 content, 64, NULL);
1098
1099 for (i = 0; i < 4; i++)
1100 deviceID[i] = content[i];
1101
1102 return (result == USB_STOR_XFER_GOOD ? 0 : -EIO);
1103}
1104
1105static int
1106sddr09_get_wp(struct us_data *us, struct sddr09_card_info *info) {
1107 int result;
1108 unsigned char status;
1109 const char *wp_fmt;
1110
1111 result = sddr09_read_status(us, &status);
1112 if (result) {
1113 usb_stor_dbg(us, "read_status fails\n");
1114 return result;
1115 }
1116 if ((status & 0x80) == 0) {
1117 info->flags |= SDDR09_WP;
1118 wp_fmt = " WP";
1119 } else {
1120 wp_fmt = "";
1121 }
1122 usb_stor_dbg(us, "status 0x%02X%s%s%s%s\n", status, wp_fmt,
1123 status & 0x40 ? " Ready" : "",
1124 status & LUNBITS ? " Suspended" : "",
1125 status & 0x01 ? " Error" : "");
1126
1127 return 0;
1128}
1129
1130#if 0
1131
1132
1133
1134
1135static int
1136sddr09_reset(struct us_data *us) {
1137
1138 unsigned char *command = us->iobuf;
1139
1140 memset(command, 0, 12);
1141 command[0] = 0xEB;
1142 command[1] = LUNBITS;
1143
1144 return sddr09_send_scsi_command(us, command, 12);
1145}
1146#endif
1147
1148static struct nand_flash_dev *
1149sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
1150 struct nand_flash_dev *cardinfo;
1151 unsigned char deviceID[4];
1152 char blurbtxt[256];
1153 int result;
1154
1155 usb_stor_dbg(us, "Reading capacity...\n");
1156
1157 result = sddr09_read_deviceID(us, deviceID);
1158
1159 if (result) {
1160 usb_stor_dbg(us, "Result of read_deviceID is %d\n", result);
1161 printk(KERN_WARNING "sddr09: could not read card info\n");
1162 return NULL;
1163 }
1164
1165 sprintf(blurbtxt, "sddr09: Found Flash card, ID = %4ph", deviceID);
1166
1167
1168 sprintf(blurbtxt + strlen(blurbtxt),
1169 ": Manuf. %s",
1170 nand_flash_manufacturer(deviceID[0]));
1171
1172
1173 cardinfo = nand_find_id(deviceID[1]);
1174 if (cardinfo) {
1175
1176
1177
1178
1179
1180 sprintf(blurbtxt + strlen(blurbtxt),
1181 ", %d MB", 1<<(cardinfo->chipshift - 20));
1182 } else {
1183 sprintf(blurbtxt + strlen(blurbtxt),
1184 ", type unrecognized");
1185 }
1186
1187
1188 if (deviceID[2] == 0xa5) {
1189 sprintf(blurbtxt + strlen(blurbtxt),
1190 ", 128-bit ID");
1191 }
1192
1193
1194 if (deviceID[3] == 0xc0) {
1195 sprintf(blurbtxt + strlen(blurbtxt),
1196 ", extra cmd");
1197 }
1198
1199 if (flags & SDDR09_WP)
1200 sprintf(blurbtxt + strlen(blurbtxt),
1201 ", WP");
1202
1203 printk(KERN_WARNING "%s\n", blurbtxt);
1204
1205 return cardinfo;
1206}
1207
1208static int
1209sddr09_read_map(struct us_data *us) {
1210
1211 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
1212 int numblocks, alloc_len, alloc_blocks;
1213 int i, j, result;
1214 unsigned char *buffer, *buffer_end, *ptr;
1215 unsigned int lba, lbact;
1216
1217 if (!info->capacity)
1218 return -1;
1219
1220
1221
1222
1223
1224
1225 numblocks = info->capacity >> (info->blockshift + info->pageshift);
1226
1227
1228
1229
1230
1231
1232#define SDDR09_READ_MAP_BUFSZ 65536
1233
1234 alloc_blocks = min(numblocks, SDDR09_READ_MAP_BUFSZ >> CONTROL_SHIFT);
1235 alloc_len = (alloc_blocks << CONTROL_SHIFT);
1236 buffer = kmalloc(alloc_len, GFP_NOIO);
1237 if (!buffer) {
1238 result = -1;
1239 goto done;
1240 }
1241 buffer_end = buffer + alloc_len;
1242
1243#undef SDDR09_READ_MAP_BUFSZ
1244
1245 kfree(info->lba_to_pba);
1246 kfree(info->pba_to_lba);
1247 info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1248 info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1249
1250 if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) {
1251 printk(KERN_WARNING "sddr09_read_map: out of memory\n");
1252 result = -1;
1253 goto done;
1254 }
1255
1256 for (i = 0; i < numblocks; i++)
1257 info->lba_to_pba[i] = info->pba_to_lba[i] = UNDEF;
1258
1259
1260
1261
1262
1263 ptr = buffer_end;
1264 for (i = 0; i < numblocks; i++) {
1265 ptr += (1 << CONTROL_SHIFT);
1266 if (ptr >= buffer_end) {
1267 unsigned long address;
1268
1269 address = i << (info->pageshift + info->blockshift);
1270 result = sddr09_read_control(
1271 us, address>>1,
1272 min(alloc_blocks, numblocks - i),
1273 buffer, 0);
1274 if (result) {
1275 result = -1;
1276 goto done;
1277 }
1278 ptr = buffer;
1279 }
1280
1281 if (i == 0 || i == 1) {
1282 info->pba_to_lba[i] = UNUSABLE;
1283 continue;
1284 }
1285
1286
1287 for (j = 0; j < 16; j++)
1288 if (ptr[j] != 0)
1289 goto nonz;
1290 info->pba_to_lba[i] = UNUSABLE;
1291 printk(KERN_WARNING "sddr09: PBA %d has no logical mapping\n",
1292 i);
1293 continue;
1294
1295 nonz:
1296
1297 for (j = 0; j < 16; j++)
1298 if (ptr[j] != 0xff)
1299 goto nonff;
1300 continue;
1301
1302 nonff:
1303
1304 if (j < 6) {
1305 printk(KERN_WARNING
1306 "sddr09: PBA %d has no logical mapping: "
1307 "reserved area = %02X%02X%02X%02X "
1308 "data status %02X block status %02X\n",
1309 i, ptr[0], ptr[1], ptr[2], ptr[3],
1310 ptr[4], ptr[5]);
1311 info->pba_to_lba[i] = UNUSABLE;
1312 continue;
1313 }
1314
1315 if ((ptr[6] >> 4) != 0x01) {
1316 printk(KERN_WARNING
1317 "sddr09: PBA %d has invalid address field "
1318 "%02X%02X/%02X%02X\n",
1319 i, ptr[6], ptr[7], ptr[11], ptr[12]);
1320 info->pba_to_lba[i] = UNUSABLE;
1321 continue;
1322 }
1323
1324
1325 if (parity[ptr[6] ^ ptr[7]]) {
1326 printk(KERN_WARNING
1327 "sddr09: Bad parity in LBA for block %d"
1328 " (%02X %02X)\n", i, ptr[6], ptr[7]);
1329 info->pba_to_lba[i] = UNUSABLE;
1330 continue;
1331 }
1332
1333 lba = short_pack(ptr[7], ptr[6]);
1334 lba = (lba & 0x07FF) >> 1;
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345 if (lba >= 1000) {
1346 printk(KERN_WARNING
1347 "sddr09: Bad low LBA %d for block %d\n",
1348 lba, i);
1349 goto possibly_erase;
1350 }
1351
1352 lba += 1000*(i/0x400);
1353
1354 if (info->lba_to_pba[lba] != UNDEF) {
1355 printk(KERN_WARNING
1356 "sddr09: LBA %d seen for PBA %d and %d\n",
1357 lba, info->lba_to_pba[lba], i);
1358 goto possibly_erase;
1359 }
1360
1361 info->pba_to_lba[i] = lba;
1362 info->lba_to_pba[lba] = i;
1363 continue;
1364
1365 possibly_erase:
1366 if (erase_bad_lba_entries) {
1367 unsigned long address;
1368
1369 address = (i << (info->pageshift + info->blockshift));
1370 sddr09_erase(us, address>>1);
1371 info->pba_to_lba[i] = UNDEF;
1372 } else
1373 info->pba_to_lba[i] = UNUSABLE;
1374 }
1375
1376
1377
1378
1379
1380
1381
1382 lbact = 0;
1383 for (i = 0; i < numblocks; i += 1024) {
1384 int ct = 0;
1385
1386 for (j = 0; j < 1024 && i+j < numblocks; j++) {
1387 if (info->pba_to_lba[i+j] != UNUSABLE) {
1388 if (ct >= 1000)
1389 info->pba_to_lba[i+j] = SPARE;
1390 else
1391 ct++;
1392 }
1393 }
1394 lbact += ct;
1395 }
1396 info->lbact = lbact;
1397 usb_stor_dbg(us, "Found %d LBA's\n", lbact);
1398 result = 0;
1399
1400 done:
1401 if (result != 0) {
1402 kfree(info->lba_to_pba);
1403 kfree(info->pba_to_lba);
1404 info->lba_to_pba = NULL;
1405 info->pba_to_lba = NULL;
1406 }
1407 kfree(buffer);
1408 return result;
1409}
1410
1411static void
1412sddr09_card_info_destructor(void *extra) {
1413 struct sddr09_card_info *info = (struct sddr09_card_info *)extra;
1414
1415 if (!info)
1416 return;
1417
1418 kfree(info->lba_to_pba);
1419 kfree(info->pba_to_lba);
1420}
1421
1422static int
1423sddr09_common_init(struct us_data *us) {
1424 int result;
1425
1426
1427 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
1428 usb_stor_dbg(us, "active config #%d != 1 ??\n",
1429 us->pusb_dev->actconfig->desc.bConfigurationValue);
1430 return -EINVAL;
1431 }
1432
1433 result = usb_reset_configuration(us->pusb_dev);
1434 usb_stor_dbg(us, "Result of usb_reset_configuration is %d\n", result);
1435 if (result == -EPIPE) {
1436 usb_stor_dbg(us, "-- stall on control interface\n");
1437 } else if (result != 0) {
1438
1439 usb_stor_dbg(us, "-- Unknown error. Rejecting device\n");
1440 return -EINVAL;
1441 }
1442
1443 us->extra = kzalloc(sizeof(struct sddr09_card_info), GFP_NOIO);
1444 if (!us->extra)
1445 return -ENOMEM;
1446 us->extra_destructor = sddr09_card_info_destructor;
1447
1448 nand_init_ecc();
1449 return 0;
1450}
1451
1452
1453
1454
1455
1456
1457
1458static int
1459usb_stor_sddr09_dpcm_init(struct us_data *us) {
1460 int result;
1461 unsigned char *data = us->iobuf;
1462
1463 result = sddr09_common_init(us);
1464 if (result)
1465 return result;
1466
1467 result = sddr09_send_command(us, 0x01, USB_DIR_IN, data, 2);
1468 if (result) {
1469 usb_stor_dbg(us, "send_command fails\n");
1470 return result;
1471 }
1472
1473 usb_stor_dbg(us, "%02X %02X\n", data[0], data[1]);
1474
1475
1476 result = sddr09_send_command(us, 0x08, USB_DIR_IN, data, 2);
1477 if (result) {
1478 usb_stor_dbg(us, "2nd send_command fails\n");
1479 return result;
1480 }
1481
1482 usb_stor_dbg(us, "%02X %02X\n", data[0], data[1]);
1483
1484
1485 result = sddr09_request_sense(us, data, 18);
1486 if (result == 0 && data[2] != 0) {
1487 int j;
1488 for (j=0; j<18; j++)
1489 printk(" %02X", data[j]);
1490 printk("\n");
1491
1492
1493
1494
1495
1496
1497
1498 }
1499
1500
1501
1502 return 0;
1503}
1504
1505
1506
1507
1508static int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
1509{
1510 int ret;
1511
1512 usb_stor_dbg(us, "LUN=%d\n", (u8)srb->device->lun);
1513
1514 switch (srb->device->lun) {
1515 case 0:
1516
1517
1518
1519
1520 ret = usb_stor_CB_transport(srb, us);
1521 break;
1522
1523 case 1:
1524
1525
1526
1527
1528
1529
1530
1531
1532 srb->device->lun = 0;
1533 ret = sddr09_transport(srb, us);
1534 srb->device->lun = 1;
1535 break;
1536
1537 default:
1538 usb_stor_dbg(us, "Invalid LUN %d\n", (u8)srb->device->lun);
1539 ret = USB_STOR_TRANSPORT_ERROR;
1540 break;
1541 }
1542 return ret;
1543}
1544
1545
1546
1547
1548
1549static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
1550{
1551 static unsigned char sensekey = 0, sensecode = 0;
1552 static unsigned char havefakesense = 0;
1553 int result, i;
1554 unsigned char *ptr = us->iobuf;
1555 unsigned long capacity;
1556 unsigned int page, pages;
1557
1558 struct sddr09_card_info *info;
1559
1560 static unsigned char inquiry_response[8] = {
1561 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
1562 };
1563
1564
1565 static unsigned char mode_page_01[19] = {
1566 0x00, 0x0F, 0x00, 0x0, 0x0, 0x0, 0x00,
1567 0x01, 0x0A,
1568 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1569 };
1570
1571 info = (struct sddr09_card_info *)us->extra;
1572
1573 if (srb->cmnd[0] == REQUEST_SENSE && havefakesense) {
1574
1575 memset(ptr, 0, 18);
1576 ptr[0] = 0x70;
1577 ptr[2] = sensekey;
1578 ptr[7] = 11;
1579 ptr[12] = sensecode;
1580 usb_stor_set_xfer_buf(ptr, 18, srb);
1581 sensekey = sensecode = havefakesense = 0;
1582 return USB_STOR_TRANSPORT_GOOD;
1583 }
1584
1585 havefakesense = 1;
1586
1587
1588
1589
1590
1591
1592 if (srb->cmnd[0] == INQUIRY) {
1593 memcpy(ptr, inquiry_response, 8);
1594 fill_inquiry_response(us, ptr, 36);
1595 return USB_STOR_TRANSPORT_GOOD;
1596 }
1597
1598 if (srb->cmnd[0] == READ_CAPACITY) {
1599 struct nand_flash_dev *cardinfo;
1600
1601 sddr09_get_wp(us, info);
1602
1603 cardinfo = sddr09_get_cardinfo(us, info->flags);
1604 if (!cardinfo) {
1605
1606 init_error:
1607 sensekey = 0x02;
1608 sensecode = 0x3a;
1609 return USB_STOR_TRANSPORT_FAILED;
1610 }
1611
1612 info->capacity = (1 << cardinfo->chipshift);
1613 info->pageshift = cardinfo->pageshift;
1614 info->pagesize = (1 << info->pageshift);
1615 info->blockshift = cardinfo->blockshift;
1616 info->blocksize = (1 << info->blockshift);
1617 info->blockmask = info->blocksize - 1;
1618
1619
1620 if (sddr09_read_map(us)) {
1621
1622 goto init_error;
1623 }
1624
1625
1626
1627 capacity = (info->lbact << info->blockshift) - 1;
1628
1629 ((__be32 *) ptr)[0] = cpu_to_be32(capacity);
1630
1631
1632
1633 ((__be32 *) ptr)[1] = cpu_to_be32(info->pagesize);
1634 usb_stor_set_xfer_buf(ptr, 8, srb);
1635
1636 return USB_STOR_TRANSPORT_GOOD;
1637 }
1638
1639 if (srb->cmnd[0] == MODE_SENSE_10) {
1640 int modepage = (srb->cmnd[2] & 0x3F);
1641
1642
1643
1644
1645
1646
1647 if (modepage == 0x01 || modepage == 0x3F) {
1648 usb_stor_dbg(us, "Dummy up request for mode page 0x%x\n",
1649 modepage);
1650
1651 memcpy(ptr, mode_page_01, sizeof(mode_page_01));
1652 ((__be16*)ptr)[0] = cpu_to_be16(sizeof(mode_page_01) - 2);
1653 ptr[3] = (info->flags & SDDR09_WP) ? 0x80 : 0;
1654 usb_stor_set_xfer_buf(ptr, sizeof(mode_page_01), srb);
1655 return USB_STOR_TRANSPORT_GOOD;
1656 }
1657
1658 sensekey = 0x05;
1659 sensecode = 0x24;
1660 return USB_STOR_TRANSPORT_FAILED;
1661 }
1662
1663 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)
1664 return USB_STOR_TRANSPORT_GOOD;
1665
1666 havefakesense = 0;
1667
1668 if (srb->cmnd[0] == READ_10) {
1669
1670 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1671 page <<= 16;
1672 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1673 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1674
1675 usb_stor_dbg(us, "READ_10: read page %d pagect %d\n",
1676 page, pages);
1677
1678 result = sddr09_read_data(us, page, pages);
1679 return (result == 0 ? USB_STOR_TRANSPORT_GOOD :
1680 USB_STOR_TRANSPORT_ERROR);
1681 }
1682
1683 if (srb->cmnd[0] == WRITE_10) {
1684
1685 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1686 page <<= 16;
1687 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1688 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1689
1690 usb_stor_dbg(us, "WRITE_10: write page %d pagect %d\n",
1691 page, pages);
1692
1693 result = sddr09_write_data(us, page, pages);
1694 return (result == 0 ? USB_STOR_TRANSPORT_GOOD :
1695 USB_STOR_TRANSPORT_ERROR);
1696 }
1697
1698
1699
1700
1701
1702 if (srb->cmnd[0] != TEST_UNIT_READY &&
1703 srb->cmnd[0] != REQUEST_SENSE) {
1704 sensekey = 0x05;
1705 sensecode = 0x20;
1706 havefakesense = 1;
1707 return USB_STOR_TRANSPORT_FAILED;
1708 }
1709
1710 for (; srb->cmd_len<12; srb->cmd_len++)
1711 srb->cmnd[srb->cmd_len] = 0;
1712
1713 srb->cmnd[1] = LUNBITS;
1714
1715 ptr[0] = 0;
1716 for (i=0; i<12; i++)
1717 sprintf(ptr+strlen(ptr), "%02X ", srb->cmnd[i]);
1718
1719 usb_stor_dbg(us, "Send control for command %s\n", ptr);
1720
1721 result = sddr09_send_scsi_command(us, srb->cmnd, 12);
1722 if (result) {
1723 usb_stor_dbg(us, "sddr09_send_scsi_command returns %d\n",
1724 result);
1725 return USB_STOR_TRANSPORT_ERROR;
1726 }
1727
1728 if (scsi_bufflen(srb) == 0)
1729 return USB_STOR_TRANSPORT_GOOD;
1730
1731 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1732 srb->sc_data_direction == DMA_FROM_DEVICE) {
1733 unsigned int pipe = (srb->sc_data_direction == DMA_TO_DEVICE)
1734 ? us->send_bulk_pipe : us->recv_bulk_pipe;
1735
1736 usb_stor_dbg(us, "%s %d bytes\n",
1737 (srb->sc_data_direction == DMA_TO_DEVICE) ?
1738 "sending" : "receiving",
1739 scsi_bufflen(srb));
1740
1741 result = usb_stor_bulk_srb(us, pipe, srb);
1742
1743 return (result == USB_STOR_XFER_GOOD ?
1744 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
1745 }
1746
1747 return USB_STOR_TRANSPORT_GOOD;
1748}
1749
1750
1751
1752
1753static int
1754usb_stor_sddr09_init(struct us_data *us) {
1755 return sddr09_common_init(us);
1756}
1757
1758static struct scsi_host_template sddr09_host_template;
1759
1760static int sddr09_probe(struct usb_interface *intf,
1761 const struct usb_device_id *id)
1762{
1763 struct us_data *us;
1764 int result;
1765
1766 result = usb_stor_probe1(&us, intf, id,
1767 (id - sddr09_usb_ids) + sddr09_unusual_dev_list,
1768 &sddr09_host_template);
1769 if (result)
1770 return result;
1771
1772 if (us->protocol == USB_PR_DPCM_USB) {
1773 us->transport_name = "Control/Bulk-EUSB/SDDR09";
1774 us->transport = dpcm_transport;
1775 us->transport_reset = usb_stor_CB_reset;
1776 us->max_lun = 1;
1777 } else {
1778 us->transport_name = "EUSB/SDDR09";
1779 us->transport = sddr09_transport;
1780 us->transport_reset = usb_stor_CB_reset;
1781 us->max_lun = 0;
1782 }
1783
1784 result = usb_stor_probe2(us);
1785 return result;
1786}
1787
1788static struct usb_driver sddr09_driver = {
1789 .name = DRV_NAME,
1790 .probe = sddr09_probe,
1791 .disconnect = usb_stor_disconnect,
1792 .suspend = usb_stor_suspend,
1793 .resume = usb_stor_resume,
1794 .reset_resume = usb_stor_reset_resume,
1795 .pre_reset = usb_stor_pre_reset,
1796 .post_reset = usb_stor_post_reset,
1797 .id_table = sddr09_usb_ids,
1798 .soft_unbind = 1,
1799 .no_dynamic_id = 1,
1800};
1801
1802module_usb_stor_driver(sddr09_driver, sddr09_host_template, DRV_NAME);
1803