1 /* Driver for SanDisk SDDR-09 SmartMedia reader
3 * (c) 2000, 2001 Robert Baruch (autophile@starband.net)
4 * (c) 2002 Andries Brouwer (aeb@cwi.nl)
5 * Developed with the assistance of:
6 * (c) 2002 Alan Stern <stern@rowland.org>
8 * The SanDisk SDDR-09 SmartMedia reader uses the Shuttle EUSB-01 chip.
9 * This chip is a programmable USB controller. In the SDDR-09, it has
10 * been programmed to obey a certain limited set of SCSI commands.
11 * This driver translates the "real" SCSI commands to the SDDR-09 SCSI
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2, or (at your option) any
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 675 Mass Ave, Cambridge, MA 02139, USA.
30 * Known vendor commands: 12 bytes, first byte is opcode
32 * E7: read scatter gather
40 * EF: compute checksum (?)
43 #include <linux/errno.h>
44 #include <linux/module.h>
45 #include <linux/slab.h>
47 #include <scsi/scsi.h>
48 #include <scsi/scsi_cmnd.h>
49 #include <scsi/scsi_device.h>
52 #include "transport.h"
56 MODULE_DESCRIPTION("Driver for SanDisk SDDR-09 SmartMedia reader");
57 MODULE_AUTHOR("Andries Brouwer <aeb@cwi.nl>, Robert Baruch <autophile@starband.net>");
58 MODULE_LICENSE("GPL");
60 static int usb_stor_sddr09_dpcm_init(struct us_data *us);
61 static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us);
62 static int usb_stor_sddr09_init(struct us_data *us);
66 * The table of devices
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) }
74 static struct usb_device_id sddr09_usb_ids[] = {
75 # include "unusual_sddr09.h"
76 { } /* Terminating entry */
78 MODULE_DEVICE_TABLE(usb, sddr09_usb_ids);
85 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
86 vendor_name, product_name, use_protocol, use_transport, \
87 init_function, Flags) \
89 .vendorName = vendor_name, \
90 .productName = product_name, \
91 .useProtocol = use_protocol, \
92 .useTransport = use_transport, \
93 .initFunction = init_function, \
96 static struct us_unusual_dev sddr09_unusual_dev_list[] = {
97 # include "unusual_sddr09.h"
98 { } /* Terminating entry */
104 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
105 #define LSB_of(s) ((s)&0xFF)
106 #define MSB_of(s) ((s)>>8)
109 * First some stuff that does not belong here:
110 * data on SmartMedia and other cards, completely
111 * unrelated to this driver.
112 * Similar stuff occurs in <linux/mtd/nand_ids.h>.
115 struct nand_flash_dev {
117 int chipshift; /* 1<<cs bytes total capacity */
118 char pageshift; /* 1<<ps bytes in a page */
119 char blockshift; /* 1<<bs pages in an erase block */
120 char zoneshift; /* 1<<zs blocks in a zone */
121 /* # of logical blocks is 125/128 of this */
122 char pageadrlen; /* length of an address in bytes - 1 */
126 * NAND Flash Manufacturer ID Codes
128 #define NAND_MFR_AMD 0x01
129 #define NAND_MFR_NATSEMI 0x8f
130 #define NAND_MFR_TOSHIBA 0x98
131 #define NAND_MFR_SAMSUNG 0xec
133 static inline char *nand_flash_manufacturer(int manuf_id) {
137 case NAND_MFR_NATSEMI:
139 case NAND_MFR_TOSHIBA:
141 case NAND_MFR_SAMSUNG:
149 * It looks like it is unnecessary to attach manufacturer to the
150 * remaining data: SSFDC prescribes manufacturer-independent id codes.
152 * 256 MB NAND flash has a 5-byte ID with 2nd byte 0xaa, 0xba, 0xca or 0xda.
155 static struct nand_flash_dev nand_flash_ids[] = {
157 { 0x6e, 20, 8, 4, 8, 2}, /* 1 MB */
158 { 0xe8, 20, 8, 4, 8, 2}, /* 1 MB */
159 { 0xec, 20, 8, 4, 8, 2}, /* 1 MB */
160 { 0x64, 21, 8, 4, 9, 2}, /* 2 MB */
161 { 0xea, 21, 8, 4, 9, 2}, /* 2 MB */
162 { 0x6b, 22, 9, 4, 9, 2}, /* 4 MB */
163 { 0xe3, 22, 9, 4, 9, 2}, /* 4 MB */
164 { 0xe5, 22, 9, 4, 9, 2}, /* 4 MB */
165 { 0xe6, 23, 9, 4, 10, 2}, /* 8 MB */
166 { 0x73, 24, 9, 5, 10, 2}, /* 16 MB */
167 { 0x75, 25, 9, 5, 10, 2}, /* 32 MB */
168 { 0x76, 26, 9, 5, 10, 3}, /* 64 MB */
169 { 0x79, 27, 9, 5, 10, 3}, /* 128 MB */
172 { 0x5d, 21, 9, 4, 8, 2}, /* 2 MB */
173 { 0xd5, 22, 9, 4, 9, 2}, /* 4 MB */
174 { 0xd6, 23, 9, 4, 10, 2}, /* 8 MB */
175 { 0x57, 24, 9, 4, 11, 2}, /* 16 MB */
176 { 0x58, 25, 9, 4, 12, 2}, /* 32 MB */
180 static struct nand_flash_dev *
181 nand_find_id(unsigned char id) {
184 for (i = 0; i < ARRAY_SIZE(nand_flash_ids); i++)
185 if (nand_flash_ids[i].model_id == id)
186 return &(nand_flash_ids[i]);
193 static unsigned char parity[256];
194 static unsigned char ecc2[256];
196 static void nand_init_ecc(void) {
200 for (i = 1; i < 256; i++)
201 parity[i] = (parity[i&(i-1)] ^ 1);
203 for (i = 0; i < 256; i++) {
205 for (j = 0; j < 8; j++) {
215 ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0));
219 /* compute 3-byte ecc on 256 bytes */
220 static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) {
222 unsigned char par, bit, bits[8];
225 for (j = 0; j < 8; j++)
228 /* collect 16 checksum bits */
229 for (i = 0; i < 256; i++) {
231 bit = parity[data[i]];
232 for (j = 0; j < 8; j++)
233 if ((i & (1<<j)) == 0)
237 /* put 4+4+4 = 12 bits in the ecc */
238 a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0];
239 ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
241 a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4];
242 ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
247 static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) {
248 return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]);
251 static void nand_store_ecc(unsigned char *data, unsigned char *ecc) {
252 memcpy(data, ecc, 3);
256 * The actual driver starts here.
259 struct sddr09_card_info {
260 unsigned long capacity; /* Size of card in bytes */
261 int pagesize; /* Size of page in bytes */
262 int pageshift; /* log2 of pagesize */
263 int blocksize; /* Size of block in pages */
264 int blockshift; /* log2 of blocksize */
265 int blockmask; /* 2^blockshift - 1 */
266 int *lba_to_pba; /* logical to physical map */
267 int *pba_to_lba; /* physical to logical map */
268 int lbact; /* number of available pages */
270 #define SDDR09_WP 1 /* write protected */
274 * On my 16MB card, control blocks have size 64 (16 real control bytes,
275 * and 48 junk bytes). In reality of course the card uses 16 control bytes,
276 * so the reader makes up the remaining 48. Don't know whether these numbers
277 * depend on the card. For now a constant.
279 #define CONTROL_SHIFT 6
282 * On my Combo CF/SM reader, the SM reader has LUN 1.
283 * (and things fail with LUN 0).
284 * It seems LUN is irrelevant for others.
287 #define LUNBITS (LUN << 5)
290 * LBA and PBA are unsigned ints. Special values.
292 #define UNDEF 0xffffffff
293 #define SPARE 0xfffffffe
294 #define UNUSABLE 0xfffffffd
296 static const int erase_bad_lba_entries = 0;
298 /* send vendor interface command (0x41) */
299 /* called for requests 0, 1, 8 */
301 sddr09_send_command(struct us_data *us,
302 unsigned char request,
303 unsigned char direction,
304 unsigned char *xfer_data,
305 unsigned int xfer_len) {
307 unsigned char requesttype = (0x41 | direction);
310 // Get the receive or send control pipe number
312 if (direction == USB_DIR_IN)
313 pipe = us->recv_ctrl_pipe;
315 pipe = us->send_ctrl_pipe;
317 rc = usb_stor_ctrl_transfer(us, pipe, request, requesttype,
318 0, 0, xfer_data, xfer_len);
320 case USB_STOR_XFER_GOOD: return 0;
321 case USB_STOR_XFER_STALLED: return -EPIPE;
322 default: return -EIO;
327 sddr09_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);
335 * Test Unit Ready Command: 12 bytes.
339 sddr09_test_unit_ready(struct us_data *us) {
340 unsigned char *command = us->iobuf;
343 memset(command, 0, 6);
344 command[1] = LUNBITS;
346 result = sddr09_send_scsi_command(us, command, 6);
348 usb_stor_dbg(us, "sddr09_test_unit_ready returns %d\n", result);
355 * Request Sense Command: 12 bytes.
357 * byte 4: data length
360 sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) {
361 unsigned char *command = us->iobuf;
364 memset(command, 0, 12);
366 command[1] = LUNBITS;
369 result = sddr09_send_scsi_command(us, command, 12);
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);
379 * Read Command: 12 bytes.
381 * byte 1: last two bits: 00: read data, 01: read blockwise control,
382 * 10: read both, 11: read pagewise control.
383 * It turns out we need values 20, 21, 22, 23 here (LUN 1).
384 * bytes 2-5: address (interpretation depends on byte 1, see below)
385 * bytes 10-11: count (idem)
387 * A page has 512 data bytes and 64 control bytes (16 control and 48 junk).
388 * A read data command gets data in 512-byte pages.
389 * A read control command gets control in 64-byte chunks.
390 * A read both command gets data+control in 576-byte chunks.
392 * Blocks are groups of 32 pages, and read blockwise control jumps to the
393 * next block, while read pagewise control jumps to the next page after
394 * reading a group of 64 control bytes.
395 * [Here 512 = 1<<pageshift, 32 = 1<<blockshift, 64 is constant?]
397 * (1 MB and 2 MB cards are a bit different, but I have only a 16 MB card.)
401 sddr09_readX(struct us_data *us, int x, unsigned long fromaddress,
402 int nr_of_pages, int bulklen, unsigned char *buf,
405 unsigned char *command = us->iobuf;
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);
418 command[10] = MSB_of(nr_of_pages);
419 command[11] = LSB_of(nr_of_pages);
421 result = sddr09_send_scsi_command(us, command, 12);
424 usb_stor_dbg(us, "Result for send_control in sddr09_read2%d %d\n",
429 result = usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe,
430 buf, bulklen, use_sg, NULL);
432 if (result != USB_STOR_XFER_GOOD) {
433 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_read2%d %d\n",
443 * fromaddress counts data shorts:
444 * increasing it by 256 shifts the bytestream by 512 bytes;
445 * the last 8 bits are ignored.
447 * nr_of_pages counts pages of size (1 << pageshift).
450 sddr09_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;
454 /* The last 8 bits of fromaddress are ignored. */
455 return sddr09_readX(us, 0, fromaddress, nr_of_pages, bulklen,
460 * Read Blockwise Control
462 * fromaddress gives the starting position (as in read data;
463 * the last 8 bits are ignored); increasing it by 32*256 shifts
464 * the output stream by 64 bytes.
466 * count counts control groups of size (1 << controlshift).
467 * For me, controlshift = 6. Is this constant?
469 * After getting one control group, jump to the next block
470 * (fromaddress += 8192).
473 sddr09_read21(struct us_data *us, unsigned long fromaddress,
474 int count, int controlshift, unsigned char *buf, int use_sg) {
476 int bulklen = (count << controlshift);
477 return sddr09_readX(us, 1, fromaddress, count, bulklen,
482 * Read both Data and Control
484 * fromaddress counts data shorts, ignoring control:
485 * increasing it by 256 shifts the bytestream by 576 = 512+64 bytes;
486 * the last 8 bits are ignored.
488 * nr_of_pages counts pages of size (1 << pageshift) + (1 << controlshift).
491 sddr09_read22(struct us_data *us, unsigned long fromaddress,
492 int nr_of_pages, int pageshift, unsigned char *buf, int use_sg) {
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,
502 * Read Pagewise Control
504 * fromaddress gives the starting position (as in read data;
505 * the last 8 bits are ignored); increasing it by 256 shifts
506 * the output stream by 64 bytes.
508 * count counts control groups of size (1 << controlshift).
509 * For me, controlshift = 6. Is this constant?
511 * After getting one control group, jump to the next page
512 * (fromaddress += 256).
515 sddr09_read23(struct us_data *us, unsigned long fromaddress,
516 int count, int controlshift, unsigned char *buf, int use_sg) {
518 int bulklen = (count << controlshift);
519 return sddr09_readX(us, 3, fromaddress, count, bulklen,
525 * Erase Command: 12 bytes.
527 * bytes 6-9: erase address (big-endian, counting shorts, sector aligned).
529 * Always precisely one block is erased; bytes 2-5 and 10-11 are ignored.
530 * The byte address being erased is 2*Eaddress.
531 * The CIS cannot be erased.
534 sddr09_erase(struct us_data *us, unsigned long Eaddress) {
535 unsigned char *command = us->iobuf;
538 usb_stor_dbg(us, "erase address %lu\n", Eaddress);
540 memset(command, 0, 12);
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);
548 result = sddr09_send_scsi_command(us, command, 12);
551 usb_stor_dbg(us, "Result for send_control in sddr09_erase %d\n",
558 * Write CIS Command: 12 bytes.
560 * bytes 2-5: write address in shorts
561 * bytes 10-11: sector count
563 * This writes at the indicated address. Don't know how it differs
564 * from E9. Maybe it does not erase? However, it will also write to
567 * When two such commands on the same page follow each other directly,
568 * the second one is not done.
572 * Write Command: 12 bytes.
574 * bytes 2-5: write address (big-endian, counting shorts, sector aligned).
575 * bytes 6-9: erase address (big-endian, counting shorts, sector aligned).
576 * bytes 10-11: sector count (big-endian, in 512-byte sectors).
578 * If write address equals erase address, the erase is done first,
579 * otherwise the write is done first. When erase address equals zero
583 sddr09_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) {
587 unsigned char *command = us->iobuf;
591 command[1] = LUNBITS;
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);
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);
603 command[10] = MSB_of(nr_of_pages);
604 command[11] = LSB_of(nr_of_pages);
606 result = sddr09_send_scsi_command(us, command, 12);
609 usb_stor_dbg(us, "Result for send_control in sddr09_writeX %d\n",
614 result = usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe,
615 buf, bulklen, use_sg, NULL);
617 if (result != USB_STOR_XFER_GOOD) {
618 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_writeX %d\n",
625 /* erase address, write same address */
627 sddr09_write_inplace(struct us_data *us, unsigned long address,
628 int nr_of_pages, int pageshift, unsigned char *buf,
630 int bulklen = (nr_of_pages << pageshift) + (nr_of_pages << CONTROL_SHIFT);
631 return sddr09_writeX(us, address, address, nr_of_pages, bulklen,
637 * Read Scatter Gather Command: 3+4n bytes.
640 * bytes 4i-1,4i,4i+1: page address
641 * byte 4i+2: page count
644 * This reads several pages from the card to a single memory buffer.
645 * The last two bits of byte 1 have the same meaning as for E8.
648 sddr09_read_sg_test_only(struct us_data *us) {
649 unsigned char *command = us->iobuf;
650 int result, bulklen, nsg, ct;
652 unsigned long address;
656 command[1] = LUNBITS;
658 address = 040000; ct = 1;
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);
666 address = 0340000; ct = 1;
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);
674 address = 01000000; ct = 2;
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);
684 result = sddr09_send_scsi_command(us, command, 4*nsg+3);
687 usb_stor_dbg(us, "Result for send_control in sddr09_read_sg %d\n",
692 buf = kmalloc(bulklen, GFP_NOIO);
696 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
699 if (result != USB_STOR_XFER_GOOD) {
700 usb_stor_dbg(us, "Result for bulk_transfer in sddr09_read_sg %d\n",
710 * Read Status Command: 12 bytes.
713 * Returns 64 bytes, all zero except for the first.
715 * bit 5: 1: Suspended
717 * bit 7: 1: Not write-protected
721 sddr09_read_status(struct us_data *us, unsigned char *status) {
723 unsigned char *command = us->iobuf;
724 unsigned char *data = us->iobuf;
727 usb_stor_dbg(us, "Reading status...\n");
729 memset(command, 0, 12);
731 command[1] = LUNBITS;
733 result = sddr09_send_scsi_command(us, command, 12);
737 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
740 return (result == USB_STOR_XFER_GOOD ? 0 : -EIO);
744 sddr09_read_data(struct us_data *us,
745 unsigned long address,
746 unsigned int sectors) {
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;
756 // Figure out the initial LBA and page
757 lba = address >> info->blockshift;
758 page = (address & info->blockmask);
759 maxlba = info->capacity >> (info->pageshift + info->blockshift);
763 // Since we only read in one block at a time, we have to create
764 // a bounce buffer and move the data a piece at a time between the
765 // bounce buffer and the actual transfer buffer.
767 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
768 buffer = kmalloc(len, GFP_NOIO);
769 if (buffer == NULL) {
770 printk(KERN_WARNING "sddr09_read_data: Out of memory\n");
774 // This could be made much more efficient by checking for
775 // contiguous LBA's. Another exercise left to the student.
781 while (sectors > 0) {
783 /* Find number of pages we can read in this block */
784 pages = min(sectors, info->blocksize - page);
785 len = pages << info->pageshift;
787 /* Not overflowing capacity? */
789 usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n",
795 /* Find where this lba lives on disk */
796 pba = info->lba_to_pba[lba];
798 if (pba == UNDEF) { /* this lba was never written */
800 usb_stor_dbg(us, "Read %d zero pages (LBA %d) page %d\n",
803 /* This is not really an error. It just means
804 that the block has never been written.
805 Instead of returning an error
806 it is better to return all zero data. */
808 memset(buffer, 0, len);
811 usb_stor_dbg(us, "Read %d pages, from PBA %d (LBA %d) page %d\n",
812 pages, pba, lba, page);
814 address = ((pba << info->blockshift) + page) <<
817 result = sddr09_read20(us, address>>1,
818 pages, info->pageshift, buffer, 0);
823 // Store the data in the transfer buffer
824 usb_stor_access_xfer_buf(buffer, len, us->srb,
825 &sg, &offset, TO_XFER_BUF);
837 sddr09_find_unused_pba(struct sddr09_card_info *info, unsigned int lba) {
838 static unsigned int lastpba = 1;
839 int zonestart, end, i;
841 zonestart = (lba/1000) << 10;
842 end = info->capacity >> (info->blockshift + info->pageshift);
847 for (i = lastpba+1; i < end; i++) {
848 if (info->pba_to_lba[zonestart+i] == UNDEF) {
853 for (i = 0; i <= lastpba; i++) {
854 if (info->pba_to_lba[zonestart+i] == UNDEF) {
863 sddr09_write_lba(struct us_data *us, unsigned int lba,
864 unsigned int page, unsigned int pages,
865 unsigned char *ptr, unsigned char *blockbuffer) {
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, isnew;
875 lbap = ((lba % 1000) << 1) | 0x1000;
876 if (parity[MSB_of(lbap) ^ LSB_of(lbap)])
878 pba = info->lba_to_pba[lba];
882 pba = sddr09_find_unused_pba(info, lba);
885 "sddr09_write_lba: Out of unused blocks\n");
888 info->pba_to_lba[pba] = lba;
889 info->lba_to_pba[lba] = pba;
894 /* Maybe it is impossible to write to PBA 1.
895 Fake success, but don't do anything. */
896 printk(KERN_WARNING "sddr09: avoid writing to pba 1\n");
900 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
902 /* read old contents */
903 address = (pba << (info->pageshift + info->blockshift));
904 result = sddr09_read22(us, address>>1, info->blocksize,
905 info->pageshift, blockbuffer, 0);
909 /* check old contents and fill lba */
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",
917 nand_store_ecc(cptr+13, ecc);
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",
923 nand_store_ecc(cptr+8, ecc);
925 cptr[6] = cptr[11] = MSB_of(lbap);
926 cptr[7] = cptr[12] = LSB_of(lbap);
929 /* copy in new stuff and compute ECC */
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);
942 usb_stor_dbg(us, "Rewrite PBA %d (LBA %d)\n", pba, lba);
944 result = sddr09_write_inplace(us, address>>1, info->blocksize,
945 info->pageshift, blockbuffer, 0);
947 usb_stor_dbg(us, "sddr09_write_inplace returns %d\n", result);
951 unsigned char status = 0;
952 int result2 = sddr09_read_status(us, &status);
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);
962 int result2 = sddr09_test_unit_ready(us);
970 sddr09_write_data(struct us_data *us,
971 unsigned long address,
972 unsigned int sectors) {
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;
983 // Figure out the initial LBA and page
984 lba = address >> info->blockshift;
985 page = (address & info->blockmask);
986 maxlba = info->capacity >> (info->pageshift + info->blockshift);
990 // blockbuffer is used for reading in the old data, overwriting
991 // with the new data, and performing ECC calculations
993 /* TODO: instead of doing kmalloc/kfree for each write,
994 add a bufferpointer to the info structure */
996 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
997 blocklen = (pagelen << info->blockshift);
998 blockbuffer = kmalloc(blocklen, GFP_NOIO);
1000 printk(KERN_WARNING "sddr09_write_data: Out of memory\n");
1004 // Since we don't write the user data directly to the device,
1005 // we have to create a bounce buffer and move the data a piece
1006 // at a time between the bounce buffer and the actual transfer buffer.
1008 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
1009 buffer = kmalloc(len, GFP_NOIO);
1010 if (buffer == NULL) {
1011 printk(KERN_WARNING "sddr09_write_data: Out of memory\n");
1020 while (sectors > 0) {
1022 // Write as many sectors as possible in this block
1024 pages = min(sectors, info->blocksize - page);
1025 len = (pages << info->pageshift);
1027 /* Not overflowing capacity? */
1028 if (lba >= maxlba) {
1029 usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n",
1035 // Get the data from the transfer buffer
1036 usb_stor_access_xfer_buf(buffer, len, us->srb,
1037 &sg, &offset, FROM_XFER_BUF);
1039 result = sddr09_write_lba(us, lba, page, pages,
1040 buffer, blockbuffer);
1056 sddr09_read_control(struct us_data *us,
1057 unsigned long address,
1058 unsigned int blocks,
1059 unsigned char *content,
1062 usb_stor_dbg(us, "Read control address %lu, blocks %d\n",
1065 return sddr09_read21(us, address, blocks,
1066 CONTROL_SHIFT, content, use_sg);
1070 * Read Device ID Command: 12 bytes.
1071 * byte 0: opcode: ED
1073 * Returns 2 bytes: Manufacturer ID and Device ID.
1074 * On more recent cards 3 bytes: the third byte is an option code A5
1075 * signifying that the secret command to read an 128-bit ID is available.
1076 * On still more recent cards 4 bytes: the fourth byte C0 means that
1077 * a second read ID cmd is available.
1080 sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) {
1081 unsigned char *command = us->iobuf;
1082 unsigned char *content = us->iobuf;
1085 memset(command, 0, 12);
1087 command[1] = LUNBITS;
1089 result = sddr09_send_scsi_command(us, command, 12);
1093 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1096 for (i = 0; i < 4; i++)
1097 deviceID[i] = content[i];
1099 return (result == USB_STOR_XFER_GOOD ? 0 : -EIO);
1103 sddr09_get_wp(struct us_data *us, struct sddr09_card_info *info) {
1105 unsigned char status;
1107 result = sddr09_read_status(us, &status);
1109 usb_stor_dbg(us, "read_status fails\n");
1112 usb_stor_dbg(us, "status 0x%02X", status);
1113 if ((status & 0x80) == 0) {
1114 info->flags |= SDDR09_WP; /* write protected */
1118 US_DEBUGPX(" Ready");
1119 if (status & LUNBITS)
1120 US_DEBUGPX(" Suspended");
1122 US_DEBUGPX(" Error");
1129 * Reset Command: 12 bytes.
1130 * byte 0: opcode: EB
1133 sddr09_reset(struct us_data *us) {
1135 unsigned char *command = us->iobuf;
1137 memset(command, 0, 12);
1139 command[1] = LUNBITS;
1141 return sddr09_send_scsi_command(us, command, 12);
1145 static struct nand_flash_dev *
1146 sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
1147 struct nand_flash_dev *cardinfo;
1148 unsigned char deviceID[4];
1152 usb_stor_dbg(us, "Reading capacity...\n");
1154 result = sddr09_read_deviceID(us, deviceID);
1157 usb_stor_dbg(us, "Result of read_deviceID is %d\n", result);
1158 printk(KERN_WARNING "sddr09: could not read card info\n");
1162 sprintf(blurbtxt, "sddr09: Found Flash card, ID = %02X %02X %02X %02X",
1163 deviceID[0], deviceID[1], deviceID[2], deviceID[3]);
1165 /* Byte 0 is the manufacturer */
1166 sprintf(blurbtxt + strlen(blurbtxt),
1168 nand_flash_manufacturer(deviceID[0]));
1170 /* Byte 1 is the device type */
1171 cardinfo = nand_find_id(deviceID[1]);
1173 /* MB or MiB? It is neither. A 16 MB card has
1174 17301504 raw bytes, of which 16384000 are
1175 usable for user data. */
1176 sprintf(blurbtxt + strlen(blurbtxt),
1177 ", %d MB", 1<<(cardinfo->chipshift - 20));
1179 sprintf(blurbtxt + strlen(blurbtxt),
1180 ", type unrecognized");
1183 /* Byte 2 is code to signal availability of 128-bit ID */
1184 if (deviceID[2] == 0xa5) {
1185 sprintf(blurbtxt + strlen(blurbtxt),
1189 /* Byte 3 announces the availability of another read ID command */
1190 if (deviceID[3] == 0xc0) {
1191 sprintf(blurbtxt + strlen(blurbtxt),
1195 if (flags & SDDR09_WP)
1196 sprintf(blurbtxt + strlen(blurbtxt),
1199 printk(KERN_WARNING "%s\n", blurbtxt);
1205 sddr09_read_map(struct us_data *us) {
1207 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
1208 int numblocks, alloc_len, alloc_blocks;
1210 unsigned char *buffer, *buffer_end, *ptr;
1211 unsigned int lba, lbact;
1213 if (!info->capacity)
1216 // size of a block is 1 << (blockshift + pageshift) bytes
1217 // divide into the total capacity to get the number of blocks
1219 numblocks = info->capacity >> (info->blockshift + info->pageshift);
1221 // read 64 bytes for every block (actually 1 << CONTROL_SHIFT)
1222 // but only use a 64 KB buffer
1223 // buffer size used must be a multiple of (1 << CONTROL_SHIFT)
1224 #define SDDR09_READ_MAP_BUFSZ 65536
1226 alloc_blocks = min(numblocks, SDDR09_READ_MAP_BUFSZ >> CONTROL_SHIFT);
1227 alloc_len = (alloc_blocks << CONTROL_SHIFT);
1228 buffer = kmalloc(alloc_len, GFP_NOIO);
1229 if (buffer == NULL) {
1230 printk(KERN_WARNING "sddr09_read_map: out of memory\n");
1234 buffer_end = buffer + alloc_len;
1236 #undef SDDR09_READ_MAP_BUFSZ
1238 kfree(info->lba_to_pba);
1239 kfree(info->pba_to_lba);
1240 info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1241 info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1243 if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) {
1244 printk(KERN_WARNING "sddr09_read_map: out of memory\n");
1249 for (i = 0; i < numblocks; i++)
1250 info->lba_to_pba[i] = info->pba_to_lba[i] = UNDEF;
1253 * Define lba-pba translation table
1257 for (i = 0; i < numblocks; i++) {
1258 ptr += (1 << CONTROL_SHIFT);
1259 if (ptr >= buffer_end) {
1260 unsigned long address;
1262 address = i << (info->pageshift + info->blockshift);
1263 result = sddr09_read_control(
1265 min(alloc_blocks, numblocks - i),
1274 if (i == 0 || i == 1) {
1275 info->pba_to_lba[i] = UNUSABLE;
1279 /* special PBAs have control field 0^16 */
1280 for (j = 0; j < 16; j++)
1283 info->pba_to_lba[i] = UNUSABLE;
1284 printk(KERN_WARNING "sddr09: PBA %d has no logical mapping\n",
1289 /* unwritten PBAs have control field FF^16 */
1290 for (j = 0; j < 16; j++)
1296 /* normal PBAs start with six FFs */
1299 "sddr09: PBA %d has no logical mapping: "
1300 "reserved area = %02X%02X%02X%02X "
1301 "data status %02X block status %02X\n",
1302 i, ptr[0], ptr[1], ptr[2], ptr[3],
1304 info->pba_to_lba[i] = UNUSABLE;
1308 if ((ptr[6] >> 4) != 0x01) {
1310 "sddr09: PBA %d has invalid address field "
1311 "%02X%02X/%02X%02X\n",
1312 i, ptr[6], ptr[7], ptr[11], ptr[12]);
1313 info->pba_to_lba[i] = UNUSABLE;
1317 /* check even parity */
1318 if (parity[ptr[6] ^ ptr[7]]) {
1320 "sddr09: Bad parity in LBA for block %d"
1321 " (%02X %02X)\n", i, ptr[6], ptr[7]);
1322 info->pba_to_lba[i] = UNUSABLE;
1326 lba = short_pack(ptr[7], ptr[6]);
1327 lba = (lba & 0x07FF) >> 1;
1330 * Every 1024 physical blocks ("zone"), the LBA numbers
1331 * go back to zero, but are within a higher block of LBA's.
1332 * Also, there is a maximum of 1000 LBA's per zone.
1333 * In other words, in PBA 1024-2047 you will find LBA 0-999
1334 * which are really LBA 1000-1999. This allows for 24 bad
1335 * or special physical blocks per zone.
1340 "sddr09: Bad low LBA %d for block %d\n",
1342 goto possibly_erase;
1345 lba += 1000*(i/0x400);
1347 if (info->lba_to_pba[lba] != UNDEF) {
1349 "sddr09: LBA %d seen for PBA %d and %d\n",
1350 lba, info->lba_to_pba[lba], i);
1351 goto possibly_erase;
1354 info->pba_to_lba[i] = lba;
1355 info->lba_to_pba[lba] = i;
1359 if (erase_bad_lba_entries) {
1360 unsigned long address;
1362 address = (i << (info->pageshift + info->blockshift));
1363 sddr09_erase(us, address>>1);
1364 info->pba_to_lba[i] = UNDEF;
1366 info->pba_to_lba[i] = UNUSABLE;
1370 * Approximate capacity. This is not entirely correct yet,
1371 * since a zone with less than 1000 usable pages leads to
1372 * missing LBAs. Especially if it is the last zone, some
1373 * LBAs can be past capacity.
1376 for (i = 0; i < numblocks; i += 1024) {
1379 for (j = 0; j < 1024 && i+j < numblocks; j++) {
1380 if (info->pba_to_lba[i+j] != UNUSABLE) {
1382 info->pba_to_lba[i+j] = SPARE;
1389 info->lbact = lbact;
1390 usb_stor_dbg(us, "Found %d LBA's\n", lbact);
1395 kfree(info->lba_to_pba);
1396 kfree(info->pba_to_lba);
1397 info->lba_to_pba = NULL;
1398 info->pba_to_lba = NULL;
1405 sddr09_card_info_destructor(void *extra) {
1406 struct sddr09_card_info *info = (struct sddr09_card_info *)extra;
1411 kfree(info->lba_to_pba);
1412 kfree(info->pba_to_lba);
1416 sddr09_common_init(struct us_data *us) {
1419 /* set the configuration -- STALL is an acceptable response here */
1420 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
1421 usb_stor_dbg(us, "active config #%d != 1 ??\n",
1422 us->pusb_dev->actconfig->desc.bConfigurationValue);
1426 result = usb_reset_configuration(us->pusb_dev);
1427 usb_stor_dbg(us, "Result of usb_reset_configuration is %d\n", result);
1428 if (result == -EPIPE) {
1429 usb_stor_dbg(us, "-- stall on control interface\n");
1430 } else if (result != 0) {
1431 /* it's not a stall, but another error -- time to bail */
1432 usb_stor_dbg(us, "-- Unknown error. Rejecting device\n");
1436 us->extra = kzalloc(sizeof(struct sddr09_card_info), GFP_NOIO);
1439 us->extra_destructor = sddr09_card_info_destructor;
1447 * This is needed at a very early stage. If this is not listed in the
1448 * unusual devices list but called from here then LUN 0 of the combo reader
1449 * is not recognized. But I do not know what precisely these calls do.
1452 usb_stor_sddr09_dpcm_init(struct us_data *us) {
1454 unsigned char *data = us->iobuf;
1456 result = sddr09_common_init(us);
1460 result = sddr09_send_command(us, 0x01, USB_DIR_IN, data, 2);
1462 usb_stor_dbg(us, "send_command fails\n");
1466 usb_stor_dbg(us, "%02X %02X\n", data[0], data[1]);
1469 result = sddr09_send_command(us, 0x08, USB_DIR_IN, data, 2);
1471 usb_stor_dbg(us, "2nd send_command fails\n");
1475 usb_stor_dbg(us, "%02X %02X\n", data[0], data[1]);
1478 result = sddr09_request_sense(us, data, 18);
1479 if (result == 0 && data[2] != 0) {
1481 for (j=0; j<18; j++)
1482 printk(" %02X", data[j]);
1484 // get 70 00 00 00 00 00 00 * 00 00 00 00 00 00
1485 // 70: current command
1486 // sense key 0, sense code 0, extd sense code 0
1487 // additional transfer length * = sizeof(data) - 7
1488 // Or: 70 00 06 00 00 00 00 0b 00 00 00 00 28 00 00 00 00 00
1489 // sense key 06, sense code 28: unit attention,
1490 // not ready to ready transition
1495 return 0; /* not result */
1499 * Transport for the Microtech DPCM-USB
1501 static int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
1505 usb_stor_dbg(us, "LUN=%d\n", srb->device->lun);
1507 switch (srb->device->lun) {
1511 * LUN 0 corresponds to the CompactFlash card reader.
1513 ret = usb_stor_CB_transport(srb, us);
1519 * LUN 1 corresponds to the SmartMedia card reader.
1523 * Set the LUN to 0 (just in case).
1525 srb->device->lun = 0;
1526 ret = sddr09_transport(srb, us);
1527 srb->device->lun = 1;
1531 usb_stor_dbg(us, "Invalid LUN %d\n", srb->device->lun);
1532 ret = USB_STOR_TRANSPORT_ERROR;
1540 * Transport for the Sandisk SDDR-09
1542 static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
1544 static unsigned char sensekey = 0, sensecode = 0;
1545 static unsigned char havefakesense = 0;
1547 unsigned char *ptr = us->iobuf;
1548 unsigned long capacity;
1549 unsigned int page, pages;
1551 struct sddr09_card_info *info;
1553 static unsigned char inquiry_response[8] = {
1554 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
1557 /* note: no block descriptor support */
1558 static unsigned char mode_page_01[19] = {
1559 0x00, 0x0F, 0x00, 0x0, 0x0, 0x0, 0x00,
1561 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1564 info = (struct sddr09_card_info *)us->extra;
1566 if (srb->cmnd[0] == REQUEST_SENSE && havefakesense) {
1567 /* for a faked command, we have to follow with a faked sense */
1572 ptr[12] = sensecode;
1573 usb_stor_set_xfer_buf(ptr, 18, srb);
1574 sensekey = sensecode = havefakesense = 0;
1575 return USB_STOR_TRANSPORT_GOOD;
1580 /* Dummy up a response for INQUIRY since SDDR09 doesn't
1581 respond to INQUIRY commands */
1583 if (srb->cmnd[0] == INQUIRY) {
1584 memcpy(ptr, inquiry_response, 8);
1585 fill_inquiry_response(us, ptr, 36);
1586 return USB_STOR_TRANSPORT_GOOD;
1589 if (srb->cmnd[0] == READ_CAPACITY) {
1590 struct nand_flash_dev *cardinfo;
1592 sddr09_get_wp(us, info); /* read WP bit */
1594 cardinfo = sddr09_get_cardinfo(us, info->flags);
1596 /* probably no media */
1598 sensekey = 0x02; /* not ready */
1599 sensecode = 0x3a; /* medium not present */
1600 return USB_STOR_TRANSPORT_FAILED;
1603 info->capacity = (1 << cardinfo->chipshift);
1604 info->pageshift = cardinfo->pageshift;
1605 info->pagesize = (1 << info->pageshift);
1606 info->blockshift = cardinfo->blockshift;
1607 info->blocksize = (1 << info->blockshift);
1608 info->blockmask = info->blocksize - 1;
1610 // map initialization, must follow get_cardinfo()
1611 if (sddr09_read_map(us)) {
1612 /* probably out of memory */
1618 capacity = (info->lbact << info->blockshift) - 1;
1620 ((__be32 *) ptr)[0] = cpu_to_be32(capacity);
1624 ((__be32 *) ptr)[1] = cpu_to_be32(info->pagesize);
1625 usb_stor_set_xfer_buf(ptr, 8, srb);
1627 return USB_STOR_TRANSPORT_GOOD;
1630 if (srb->cmnd[0] == MODE_SENSE_10) {
1631 int modepage = (srb->cmnd[2] & 0x3F);
1633 /* They ask for the Read/Write error recovery page,
1634 or for all pages. */
1635 /* %% We should check DBD %% */
1636 if (modepage == 0x01 || modepage == 0x3F) {
1637 usb_stor_dbg(us, "Dummy up request for mode page 0x%x\n",
1640 memcpy(ptr, mode_page_01, sizeof(mode_page_01));
1641 ((__be16*)ptr)[0] = cpu_to_be16(sizeof(mode_page_01) - 2);
1642 ptr[3] = (info->flags & SDDR09_WP) ? 0x80 : 0;
1643 usb_stor_set_xfer_buf(ptr, sizeof(mode_page_01), srb);
1644 return USB_STOR_TRANSPORT_GOOD;
1647 sensekey = 0x05; /* illegal request */
1648 sensecode = 0x24; /* invalid field in CDB */
1649 return USB_STOR_TRANSPORT_FAILED;
1652 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)
1653 return USB_STOR_TRANSPORT_GOOD;
1657 if (srb->cmnd[0] == READ_10) {
1659 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1661 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1662 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1664 usb_stor_dbg(us, "READ_10: read page %d pagect %d\n",
1667 result = sddr09_read_data(us, page, pages);
1668 return (result == 0 ? USB_STOR_TRANSPORT_GOOD :
1669 USB_STOR_TRANSPORT_ERROR);
1672 if (srb->cmnd[0] == WRITE_10) {
1674 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1676 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1677 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1679 usb_stor_dbg(us, "WRITE_10: write page %d pagect %d\n",
1682 result = sddr09_write_data(us, page, pages);
1683 return (result == 0 ? USB_STOR_TRANSPORT_GOOD :
1684 USB_STOR_TRANSPORT_ERROR);
1687 /* catch-all for all other commands, except
1688 * pass TEST_UNIT_READY and REQUEST_SENSE through
1690 if (srb->cmnd[0] != TEST_UNIT_READY &&
1691 srb->cmnd[0] != REQUEST_SENSE) {
1692 sensekey = 0x05; /* illegal request */
1693 sensecode = 0x20; /* invalid command */
1695 return USB_STOR_TRANSPORT_FAILED;
1698 for (; srb->cmd_len<12; srb->cmd_len++)
1699 srb->cmnd[srb->cmd_len] = 0;
1701 srb->cmnd[1] = LUNBITS;
1704 for (i=0; i<12; i++)
1705 sprintf(ptr+strlen(ptr), "%02X ", srb->cmnd[i]);
1707 usb_stor_dbg(us, "Send control for command %s\n", ptr);
1709 result = sddr09_send_scsi_command(us, srb->cmnd, 12);
1711 usb_stor_dbg(us, "sddr09_send_scsi_command returns %d\n",
1713 return USB_STOR_TRANSPORT_ERROR;
1716 if (scsi_bufflen(srb) == 0)
1717 return USB_STOR_TRANSPORT_GOOD;
1719 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1720 srb->sc_data_direction == DMA_FROM_DEVICE) {
1721 unsigned int pipe = (srb->sc_data_direction == DMA_TO_DEVICE)
1722 ? us->send_bulk_pipe : us->recv_bulk_pipe;
1724 usb_stor_dbg(us, "%s %d bytes\n",
1725 (srb->sc_data_direction == DMA_TO_DEVICE) ?
1726 "sending" : "receiving",
1729 result = usb_stor_bulk_srb(us, pipe, srb);
1731 return (result == USB_STOR_XFER_GOOD ?
1732 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
1735 return USB_STOR_TRANSPORT_GOOD;
1739 * Initialization routine for the sddr09 subdriver
1742 usb_stor_sddr09_init(struct us_data *us) {
1743 return sddr09_common_init(us);
1746 static int sddr09_probe(struct usb_interface *intf,
1747 const struct usb_device_id *id)
1752 result = usb_stor_probe1(&us, intf, id,
1753 (id - sddr09_usb_ids) + sddr09_unusual_dev_list);
1757 if (us->protocol == USB_PR_DPCM_USB) {
1758 us->transport_name = "Control/Bulk-EUSB/SDDR09";
1759 us->transport = dpcm_transport;
1760 us->transport_reset = usb_stor_CB_reset;
1763 us->transport_name = "EUSB/SDDR09";
1764 us->transport = sddr09_transport;
1765 us->transport_reset = usb_stor_CB_reset;
1769 result = usb_stor_probe2(us);
1773 static struct usb_driver sddr09_driver = {
1774 .name = "ums-sddr09",
1775 .probe = sddr09_probe,
1776 .disconnect = usb_stor_disconnect,
1777 .suspend = usb_stor_suspend,
1778 .resume = usb_stor_resume,
1779 .reset_resume = usb_stor_reset_resume,
1780 .pre_reset = usb_stor_pre_reset,
1781 .post_reset = usb_stor_post_reset,
1782 .id_table = sddr09_usb_ids,
1787 module_usb_driver(sddr09_driver);