1 /* Driver for SanDisk SDDR-09 SmartMedia reader
3 * $Id: sddr09.c,v 1.24 2002/04/22 03:39:43 mdharm Exp $
4 * (c) 2000, 2001 Robert Baruch (autophile@starband.net)
5 * (c) 2002 Andries Brouwer (aeb@cwi.nl)
6 * Developed with the assistance of:
7 * (c) 2002 Alan Stern <stern@rowland.org>
9 * The SanDisk SDDR-09 SmartMedia reader uses the Shuttle EUSB-01 chip.
10 * This chip is a programmable USB controller. In the SDDR-09, it has
11 * been programmed to obey a certain limited set of SCSI commands.
12 * This driver translates the "real" SCSI commands to the SDDR-09 SCSI
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 2, or (at your option) any
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * General Public License for more details.
25 * You should have received a copy of the GNU General Public License along
26 * with this program; if not, write to the Free Software Foundation, Inc.,
27 * 675 Mass Ave, Cambridge, MA 02139, USA.
31 * Known vendor commands: 12 bytes, first byte is opcode
33 * E7: read scatter gather
41 * EF: compute checksum (?)
44 #include <linux/sched.h>
45 #include <linux/errno.h>
46 #include <linux/slab.h>
48 #include <scsi/scsi.h>
49 #include <scsi/scsi_cmnd.h>
52 #include "transport.h"
58 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
59 #define LSB_of(s) ((s)&0xFF)
60 #define MSB_of(s) ((s)>>8)
62 /* #define US_DEBUGP printk */
65 * First some stuff that does not belong here:
66 * data on SmartMedia and other cards, completely
67 * unrelated to this driver.
68 * Similar stuff occurs in <linux/mtd/nand_ids.h>.
71 struct nand_flash_dev {
73 int chipshift; /* 1<<cs bytes total capacity */
74 char pageshift; /* 1<<ps bytes in a page */
75 char blockshift; /* 1<<bs pages in an erase block */
76 char zoneshift; /* 1<<zs blocks in a zone */
77 /* # of logical blocks is 125/128 of this */
78 char pageadrlen; /* length of an address in bytes - 1 */
82 * NAND Flash Manufacturer ID Codes
84 #define NAND_MFR_AMD 0x01
85 #define NAND_MFR_NATSEMI 0x8f
86 #define NAND_MFR_TOSHIBA 0x98
87 #define NAND_MFR_SAMSUNG 0xec
89 static inline char *nand_flash_manufacturer(int manuf_id) {
93 case NAND_MFR_NATSEMI:
95 case NAND_MFR_TOSHIBA:
97 case NAND_MFR_SAMSUNG:
105 * It looks like it is unnecessary to attach manufacturer to the
106 * remaining data: SSFDC prescribes manufacturer-independent id codes.
108 * 256 MB NAND flash has a 5-byte ID with 2nd byte 0xaa, 0xba, 0xca or 0xda.
111 static struct nand_flash_dev nand_flash_ids[] = {
113 { 0x6e, 20, 8, 4, 8, 2}, /* 1 MB */
114 { 0xe8, 20, 8, 4, 8, 2}, /* 1 MB */
115 { 0xec, 20, 8, 4, 8, 2}, /* 1 MB */
116 { 0x64, 21, 8, 4, 9, 2}, /* 2 MB */
117 { 0xea, 21, 8, 4, 9, 2}, /* 2 MB */
118 { 0x6b, 22, 9, 4, 9, 2}, /* 4 MB */
119 { 0xe3, 22, 9, 4, 9, 2}, /* 4 MB */
120 { 0xe5, 22, 9, 4, 9, 2}, /* 4 MB */
121 { 0xe6, 23, 9, 4, 10, 2}, /* 8 MB */
122 { 0x73, 24, 9, 5, 10, 2}, /* 16 MB */
123 { 0x75, 25, 9, 5, 10, 2}, /* 32 MB */
124 { 0x76, 26, 9, 5, 10, 3}, /* 64 MB */
125 { 0x79, 27, 9, 5, 10, 3}, /* 128 MB */
128 { 0x5d, 21, 9, 4, 8, 2}, /* 2 MB */
129 { 0xd5, 22, 9, 4, 9, 2}, /* 4 MB */
130 { 0xd6, 23, 9, 4, 10, 2}, /* 8 MB */
131 { 0x57, 24, 9, 4, 11, 2}, /* 16 MB */
132 { 0x58, 25, 9, 4, 12, 2}, /* 32 MB */
136 #define SIZE(a) (sizeof(a)/sizeof((a)[0]))
138 static struct nand_flash_dev *
139 nand_find_id(unsigned char id) {
142 for (i = 0; i < SIZE(nand_flash_ids); i++)
143 if (nand_flash_ids[i].model_id == id)
144 return &(nand_flash_ids[i]);
151 static unsigned char parity[256];
152 static unsigned char ecc2[256];
154 static void nand_init_ecc(void) {
158 for (i = 1; i < 256; i++)
159 parity[i] = (parity[i&(i-1)] ^ 1);
161 for (i = 0; i < 256; i++) {
163 for (j = 0; j < 8; j++) {
173 ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0));
177 /* compute 3-byte ecc on 256 bytes */
178 static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) {
180 unsigned char par, bit, bits[8];
183 for (j = 0; j < 8; j++)
186 /* collect 16 checksum bits */
187 for (i = 0; i < 256; i++) {
189 bit = parity[data[i]];
190 for (j = 0; j < 8; j++)
191 if ((i & (1<<j)) == 0)
195 /* put 4+4+4 = 12 bits in the ecc */
196 a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0];
197 ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
199 a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4];
200 ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
205 static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) {
206 return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]);
209 static void nand_store_ecc(unsigned char *data, unsigned char *ecc) {
210 memcpy(data, ecc, 3);
214 * The actual driver starts here.
217 struct sddr09_card_info {
218 unsigned long capacity; /* Size of card in bytes */
219 int pagesize; /* Size of page in bytes */
220 int pageshift; /* log2 of pagesize */
221 int blocksize; /* Size of block in pages */
222 int blockshift; /* log2 of blocksize */
223 int blockmask; /* 2^blockshift - 1 */
224 int *lba_to_pba; /* logical to physical map */
225 int *pba_to_lba; /* physical to logical map */
226 int lbact; /* number of available pages */
228 #define SDDR09_WP 1 /* write protected */
232 * On my 16MB card, control blocks have size 64 (16 real control bytes,
233 * and 48 junk bytes). In reality of course the card uses 16 control bytes,
234 * so the reader makes up the remaining 48. Don't know whether these numbers
235 * depend on the card. For now a constant.
237 #define CONTROL_SHIFT 6
240 * On my Combo CF/SM reader, the SM reader has LUN 1.
241 * (and things fail with LUN 0).
242 * It seems LUN is irrelevant for others.
245 #define LUNBITS (LUN << 5)
248 * LBA and PBA are unsigned ints. Special values.
250 #define UNDEF 0xffffffff
251 #define SPARE 0xfffffffe
252 #define UNUSABLE 0xfffffffd
254 static const int erase_bad_lba_entries = 0;
256 /* send vendor interface command (0x41) */
257 /* called for requests 0, 1, 8 */
259 sddr09_send_command(struct us_data *us,
260 unsigned char request,
261 unsigned char direction,
262 unsigned char *xfer_data,
263 unsigned int xfer_len) {
265 unsigned char requesttype = (0x41 | direction);
268 // Get the receive or send control pipe number
270 if (direction == USB_DIR_IN)
271 pipe = us->recv_ctrl_pipe;
273 pipe = us->send_ctrl_pipe;
275 rc = usb_stor_ctrl_transfer(us, pipe, request, requesttype,
276 0, 0, xfer_data, xfer_len);
277 return (rc == USB_STOR_XFER_GOOD ? USB_STOR_TRANSPORT_GOOD :
278 USB_STOR_TRANSPORT_ERROR);
282 sddr09_send_scsi_command(struct us_data *us,
283 unsigned char *command,
284 unsigned int command_len) {
285 return sddr09_send_command(us, 0, USB_DIR_OUT, command, command_len);
290 * Test Unit Ready Command: 12 bytes.
294 sddr09_test_unit_ready(struct us_data *us) {
295 unsigned char *command = us->iobuf;
298 memset(command, 0, 6);
299 command[1] = LUNBITS;
301 result = sddr09_send_scsi_command(us, command, 6);
303 US_DEBUGP("sddr09_test_unit_ready returns %d\n", result);
310 * Request Sense Command: 12 bytes.
312 * byte 4: data length
315 sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) {
316 unsigned char *command = us->iobuf;
319 memset(command, 0, 12);
321 command[1] = LUNBITS;
324 result = sddr09_send_scsi_command(us, command, 12);
325 if (result != USB_STOR_TRANSPORT_GOOD) {
326 US_DEBUGP("request sense failed\n");
330 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
331 sensebuf, buflen, NULL);
332 if (result != USB_STOR_XFER_GOOD) {
333 US_DEBUGP("request sense bulk in failed\n");
334 return USB_STOR_TRANSPORT_ERROR;
336 US_DEBUGP("request sense worked\n");
337 return USB_STOR_TRANSPORT_GOOD;
342 * Read Command: 12 bytes.
344 * byte 1: last two bits: 00: read data, 01: read blockwise control,
345 * 10: read both, 11: read pagewise control.
346 * It turns out we need values 20, 21, 22, 23 here (LUN 1).
347 * bytes 2-5: address (interpretation depends on byte 1, see below)
348 * bytes 10-11: count (idem)
350 * A page has 512 data bytes and 64 control bytes (16 control and 48 junk).
351 * A read data command gets data in 512-byte pages.
352 * A read control command gets control in 64-byte chunks.
353 * A read both command gets data+control in 576-byte chunks.
355 * Blocks are groups of 32 pages, and read blockwise control jumps to the
356 * next block, while read pagewise control jumps to the next page after
357 * reading a group of 64 control bytes.
358 * [Here 512 = 1<<pageshift, 32 = 1<<blockshift, 64 is constant?]
360 * (1 MB and 2 MB cards are a bit different, but I have only a 16 MB card.)
364 sddr09_readX(struct us_data *us, int x, unsigned long fromaddress,
365 int nr_of_pages, int bulklen, unsigned char *buf,
368 unsigned char *command = us->iobuf;
372 command[1] = LUNBITS | x;
373 command[2] = MSB_of(fromaddress>>16);
374 command[3] = LSB_of(fromaddress>>16);
375 command[4] = MSB_of(fromaddress & 0xFFFF);
376 command[5] = LSB_of(fromaddress & 0xFFFF);
381 command[10] = MSB_of(nr_of_pages);
382 command[11] = LSB_of(nr_of_pages);
384 result = sddr09_send_scsi_command(us, command, 12);
386 if (result != USB_STOR_TRANSPORT_GOOD) {
387 US_DEBUGP("Result for send_control in sddr09_read2%d %d\n",
392 result = usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe,
393 buf, bulklen, use_sg, NULL);
395 if (result != USB_STOR_XFER_GOOD) {
396 US_DEBUGP("Result for bulk_transfer in sddr09_read2%d %d\n",
398 return USB_STOR_TRANSPORT_ERROR;
400 return USB_STOR_TRANSPORT_GOOD;
406 * fromaddress counts data shorts:
407 * increasing it by 256 shifts the bytestream by 512 bytes;
408 * the last 8 bits are ignored.
410 * nr_of_pages counts pages of size (1 << pageshift).
413 sddr09_read20(struct us_data *us, unsigned long fromaddress,
414 int nr_of_pages, int pageshift, unsigned char *buf, int use_sg) {
415 int bulklen = nr_of_pages << pageshift;
417 /* The last 8 bits of fromaddress are ignored. */
418 return sddr09_readX(us, 0, fromaddress, nr_of_pages, bulklen,
423 * Read Blockwise Control
425 * fromaddress gives the starting position (as in read data;
426 * the last 8 bits are ignored); increasing it by 32*256 shifts
427 * the output stream by 64 bytes.
429 * count counts control groups of size (1 << controlshift).
430 * For me, controlshift = 6. Is this constant?
432 * After getting one control group, jump to the next block
433 * (fromaddress += 8192).
436 sddr09_read21(struct us_data *us, unsigned long fromaddress,
437 int count, int controlshift, unsigned char *buf, int use_sg) {
439 int bulklen = (count << controlshift);
440 return sddr09_readX(us, 1, fromaddress, count, bulklen,
445 * Read both Data and Control
447 * fromaddress counts data shorts, ignoring control:
448 * increasing it by 256 shifts the bytestream by 576 = 512+64 bytes;
449 * the last 8 bits are ignored.
451 * nr_of_pages counts pages of size (1 << pageshift) + (1 << controlshift).
454 sddr09_read22(struct us_data *us, unsigned long fromaddress,
455 int nr_of_pages, int pageshift, unsigned char *buf, int use_sg) {
457 int bulklen = (nr_of_pages << pageshift) + (nr_of_pages << CONTROL_SHIFT);
458 US_DEBUGP("sddr09_read22: reading %d pages, %d bytes\n",
459 nr_of_pages, bulklen);
460 return sddr09_readX(us, 2, fromaddress, nr_of_pages, bulklen,
466 * Read Pagewise Control
468 * fromaddress gives the starting position (as in read data;
469 * the last 8 bits are ignored); increasing it by 256 shifts
470 * the output stream by 64 bytes.
472 * count counts control groups of size (1 << controlshift).
473 * For me, controlshift = 6. Is this constant?
475 * After getting one control group, jump to the next page
476 * (fromaddress += 256).
479 sddr09_read23(struct us_data *us, unsigned long fromaddress,
480 int count, int controlshift, unsigned char *buf, int use_sg) {
482 int bulklen = (count << controlshift);
483 return sddr09_readX(us, 3, fromaddress, count, bulklen,
489 * Erase Command: 12 bytes.
491 * bytes 6-9: erase address (big-endian, counting shorts, sector aligned).
493 * Always precisely one block is erased; bytes 2-5 and 10-11 are ignored.
494 * The byte address being erased is 2*Eaddress.
495 * The CIS cannot be erased.
498 sddr09_erase(struct us_data *us, unsigned long Eaddress) {
499 unsigned char *command = us->iobuf;
502 US_DEBUGP("sddr09_erase: erase address %lu\n", Eaddress);
504 memset(command, 0, 12);
506 command[1] = LUNBITS;
507 command[6] = MSB_of(Eaddress>>16);
508 command[7] = LSB_of(Eaddress>>16);
509 command[8] = MSB_of(Eaddress & 0xFFFF);
510 command[9] = LSB_of(Eaddress & 0xFFFF);
512 result = sddr09_send_scsi_command(us, command, 12);
514 if (result != USB_STOR_TRANSPORT_GOOD)
515 US_DEBUGP("Result for send_control in sddr09_erase %d\n",
522 * Write CIS Command: 12 bytes.
524 * bytes 2-5: write address in shorts
525 * bytes 10-11: sector count
527 * This writes at the indicated address. Don't know how it differs
528 * from E9. Maybe it does not erase? However, it will also write to
531 * When two such commands on the same page follow each other directly,
532 * the second one is not done.
536 * Write Command: 12 bytes.
538 * bytes 2-5: write address (big-endian, counting shorts, sector aligned).
539 * bytes 6-9: erase address (big-endian, counting shorts, sector aligned).
540 * bytes 10-11: sector count (big-endian, in 512-byte sectors).
542 * If write address equals erase address, the erase is done first,
543 * otherwise the write is done first. When erase address equals zero
547 sddr09_writeX(struct us_data *us,
548 unsigned long Waddress, unsigned long Eaddress,
549 int nr_of_pages, int bulklen, unsigned char *buf, int use_sg) {
551 unsigned char *command = us->iobuf;
555 command[1] = LUNBITS;
557 command[2] = MSB_of(Waddress>>16);
558 command[3] = LSB_of(Waddress>>16);
559 command[4] = MSB_of(Waddress & 0xFFFF);
560 command[5] = LSB_of(Waddress & 0xFFFF);
562 command[6] = MSB_of(Eaddress>>16);
563 command[7] = LSB_of(Eaddress>>16);
564 command[8] = MSB_of(Eaddress & 0xFFFF);
565 command[9] = LSB_of(Eaddress & 0xFFFF);
567 command[10] = MSB_of(nr_of_pages);
568 command[11] = LSB_of(nr_of_pages);
570 result = sddr09_send_scsi_command(us, command, 12);
572 if (result != USB_STOR_TRANSPORT_GOOD) {
573 US_DEBUGP("Result for send_control in sddr09_writeX %d\n",
578 result = usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe,
579 buf, bulklen, use_sg, NULL);
581 if (result != USB_STOR_XFER_GOOD) {
582 US_DEBUGP("Result for bulk_transfer in sddr09_writeX %d\n",
584 return USB_STOR_TRANSPORT_ERROR;
586 return USB_STOR_TRANSPORT_GOOD;
589 /* erase address, write same address */
591 sddr09_write_inplace(struct us_data *us, unsigned long address,
592 int nr_of_pages, int pageshift, unsigned char *buf,
594 int bulklen = (nr_of_pages << pageshift) + (nr_of_pages << CONTROL_SHIFT);
595 return sddr09_writeX(us, address, address, nr_of_pages, bulklen,
601 * Read Scatter Gather Command: 3+4n bytes.
604 * bytes 4i-1,4i,4i+1: page address
605 * byte 4i+2: page count
608 * This reads several pages from the card to a single memory buffer.
609 * The last two bits of byte 1 have the same meaning as for E8.
612 sddr09_read_sg_test_only(struct us_data *us) {
613 unsigned char *command = us->iobuf;
614 int result, bulklen, nsg, ct;
616 unsigned long address;
620 command[1] = LUNBITS;
622 address = 040000; ct = 1;
624 bulklen += (ct << 9);
625 command[4*nsg+2] = ct;
626 command[4*nsg+1] = ((address >> 9) & 0xFF);
627 command[4*nsg+0] = ((address >> 17) & 0xFF);
628 command[4*nsg-1] = ((address >> 25) & 0xFF);
630 address = 0340000; ct = 1;
632 bulklen += (ct << 9);
633 command[4*nsg+2] = ct;
634 command[4*nsg+1] = ((address >> 9) & 0xFF);
635 command[4*nsg+0] = ((address >> 17) & 0xFF);
636 command[4*nsg-1] = ((address >> 25) & 0xFF);
638 address = 01000000; ct = 2;
640 bulklen += (ct << 9);
641 command[4*nsg+2] = ct;
642 command[4*nsg+1] = ((address >> 9) & 0xFF);
643 command[4*nsg+0] = ((address >> 17) & 0xFF);
644 command[4*nsg-1] = ((address >> 25) & 0xFF);
648 result = sddr09_send_scsi_command(us, command, 4*nsg+3);
650 if (result != USB_STOR_TRANSPORT_GOOD) {
651 US_DEBUGP("Result for send_control in sddr09_read_sg %d\n",
656 buf = (unsigned char *) kmalloc(bulklen, GFP_NOIO);
658 return USB_STOR_TRANSPORT_ERROR;
660 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
663 if (result != USB_STOR_XFER_GOOD) {
664 US_DEBUGP("Result for bulk_transfer in sddr09_read_sg %d\n",
666 return USB_STOR_TRANSPORT_ERROR;
669 return USB_STOR_TRANSPORT_GOOD;
674 * Read Status Command: 12 bytes.
677 * Returns 64 bytes, all zero except for the first.
679 * bit 5: 1: Suspended
681 * bit 7: 1: Not write-protected
685 sddr09_read_status(struct us_data *us, unsigned char *status) {
687 unsigned char *command = us->iobuf;
688 unsigned char *data = us->iobuf;
691 US_DEBUGP("Reading status...\n");
693 memset(command, 0, 12);
695 command[1] = LUNBITS;
697 result = sddr09_send_scsi_command(us, command, 12);
698 if (result != USB_STOR_TRANSPORT_GOOD)
701 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
704 return (result == USB_STOR_XFER_GOOD ?
705 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
709 sddr09_read_data(struct us_data *us,
710 unsigned long address,
711 unsigned int sectors) {
713 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
714 unsigned char *buffer;
715 unsigned int lba, maxlba, pba;
716 unsigned int page, pages;
717 unsigned int len, index, offset;
720 // Since we only read in one block at a time, we have to create
721 // a bounce buffer and move the data a piece at a time between the
722 // bounce buffer and the actual transfer buffer.
724 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
725 buffer = kmalloc(len, GFP_NOIO);
726 if (buffer == NULL) {
727 printk("sddr09_read_data: Out of memory\n");
728 return USB_STOR_TRANSPORT_ERROR;
731 // Figure out the initial LBA and page
732 lba = address >> info->blockshift;
733 page = (address & info->blockmask);
734 maxlba = info->capacity >> (info->pageshift + info->blockshift);
736 // This could be made much more efficient by checking for
737 // contiguous LBA's. Another exercise left to the student.
739 result = USB_STOR_TRANSPORT_GOOD;
742 while (sectors > 0) {
744 /* Find number of pages we can read in this block */
745 pages = min(sectors, info->blocksize - page);
746 len = pages << info->pageshift;
748 /* Not overflowing capacity? */
750 US_DEBUGP("Error: Requested lba %u exceeds "
751 "maximum %u\n", lba, maxlba);
752 result = USB_STOR_TRANSPORT_ERROR;
756 /* Find where this lba lives on disk */
757 pba = info->lba_to_pba[lba];
759 if (pba == UNDEF) { /* this lba was never written */
761 US_DEBUGP("Read %d zero pages (LBA %d) page %d\n",
764 /* This is not really an error. It just means
765 that the block has never been written.
766 Instead of returning USB_STOR_TRANSPORT_ERROR
767 it is better to return all zero data. */
769 memset(buffer, 0, len);
772 US_DEBUGP("Read %d pages, from PBA %d"
773 " (LBA %d) page %d\n",
774 pages, pba, lba, page);
776 address = ((pba << info->blockshift) + page) <<
779 result = sddr09_read20(us, address>>1,
780 pages, info->pageshift, buffer, 0);
781 if (result != USB_STOR_TRANSPORT_GOOD)
785 // Store the data in the transfer buffer
786 usb_stor_access_xfer_buf(buffer, len, us->srb,
787 &index, &offset, TO_XFER_BUF);
799 sddr09_find_unused_pba(struct sddr09_card_info *info, unsigned int lba) {
800 static unsigned int lastpba = 1;
801 int zonestart, end, i;
803 zonestart = (lba/1000) << 10;
804 end = info->capacity >> (info->blockshift + info->pageshift);
809 for (i = lastpba+1; i < end; i++) {
810 if (info->pba_to_lba[zonestart+i] == UNDEF) {
815 for (i = 0; i <= lastpba; i++) {
816 if (info->pba_to_lba[zonestart+i] == UNDEF) {
825 sddr09_write_lba(struct us_data *us, unsigned int lba,
826 unsigned int page, unsigned int pages,
827 unsigned char *ptr, unsigned char *blockbuffer) {
829 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
830 unsigned long address;
831 unsigned int pba, lbap;
832 unsigned int pagelen;
833 unsigned char *bptr, *cptr, *xptr;
834 unsigned char ecc[3];
835 int i, result, isnew;
837 lbap = ((lba % 1000) << 1) | 0x1000;
838 if (parity[MSB_of(lbap) ^ LSB_of(lbap)])
840 pba = info->lba_to_pba[lba];
844 pba = sddr09_find_unused_pba(info, lba);
846 printk("sddr09_write_lba: Out of unused blocks\n");
847 return USB_STOR_TRANSPORT_ERROR;
849 info->pba_to_lba[pba] = lba;
850 info->lba_to_pba[lba] = pba;
855 /* Maybe it is impossible to write to PBA 1.
856 Fake success, but don't do anything. */
857 printk("sddr09: avoid writing to pba 1\n");
858 return USB_STOR_TRANSPORT_GOOD;
861 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
863 /* read old contents */
864 address = (pba << (info->pageshift + info->blockshift));
865 result = sddr09_read22(us, address>>1, info->blocksize,
866 info->pageshift, blockbuffer, 0);
867 if (result != USB_STOR_TRANSPORT_GOOD)
870 /* check old contents and fill lba */
871 for (i = 0; i < info->blocksize; i++) {
872 bptr = blockbuffer + i*pagelen;
873 cptr = bptr + info->pagesize;
874 nand_compute_ecc(bptr, ecc);
875 if (!nand_compare_ecc(cptr+13, ecc)) {
876 US_DEBUGP("Warning: bad ecc in page %d- of pba %d\n",
878 nand_store_ecc(cptr+13, ecc);
880 nand_compute_ecc(bptr+(info->pagesize / 2), ecc);
881 if (!nand_compare_ecc(cptr+8, ecc)) {
882 US_DEBUGP("Warning: bad ecc in page %d+ of pba %d\n",
884 nand_store_ecc(cptr+8, ecc);
886 cptr[6] = cptr[11] = MSB_of(lbap);
887 cptr[7] = cptr[12] = LSB_of(lbap);
890 /* copy in new stuff and compute ECC */
892 for (i = page; i < page+pages; i++) {
893 bptr = blockbuffer + i*pagelen;
894 cptr = bptr + info->pagesize;
895 memcpy(bptr, xptr, info->pagesize);
896 xptr += info->pagesize;
897 nand_compute_ecc(bptr, ecc);
898 nand_store_ecc(cptr+13, ecc);
899 nand_compute_ecc(bptr+(info->pagesize / 2), ecc);
900 nand_store_ecc(cptr+8, ecc);
903 US_DEBUGP("Rewrite PBA %d (LBA %d)\n", pba, lba);
905 result = sddr09_write_inplace(us, address>>1, info->blocksize,
906 info->pageshift, blockbuffer, 0);
908 US_DEBUGP("sddr09_write_inplace returns %d\n", result);
912 unsigned char status = 0;
913 int result2 = sddr09_read_status(us, &status);
914 if (result2 != USB_STOR_TRANSPORT_GOOD)
915 US_DEBUGP("sddr09_write_inplace: cannot read status\n");
916 else if (status != 0xc0)
917 US_DEBUGP("sddr09_write_inplace: status after write: 0x%x\n",
924 int result2 = sddr09_test_unit_ready(us);
932 sddr09_write_data(struct us_data *us,
933 unsigned long address,
934 unsigned int sectors) {
936 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
937 unsigned int lba, page, pages;
938 unsigned int pagelen, blocklen;
939 unsigned char *blockbuffer;
940 unsigned char *buffer;
941 unsigned int len, index, offset;
944 // blockbuffer is used for reading in the old data, overwriting
945 // with the new data, and performing ECC calculations
947 /* TODO: instead of doing kmalloc/kfree for each write,
948 add a bufferpointer to the info structure */
950 pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT);
951 blocklen = (pagelen << info->blockshift);
952 blockbuffer = kmalloc(blocklen, GFP_NOIO);
954 printk("sddr09_write_data: Out of memory\n");
955 return USB_STOR_TRANSPORT_ERROR;
958 // Since we don't write the user data directly to the device,
959 // we have to create a bounce buffer and move the data a piece
960 // at a time between the bounce buffer and the actual transfer buffer.
962 len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
963 buffer = kmalloc(len, GFP_NOIO);
964 if (buffer == NULL) {
965 printk("sddr09_write_data: Out of memory\n");
967 return USB_STOR_TRANSPORT_ERROR;
970 // Figure out the initial LBA and page
971 lba = address >> info->blockshift;
972 page = (address & info->blockmask);
974 result = USB_STOR_TRANSPORT_GOOD;
977 while (sectors > 0) {
979 // Write as many sectors as possible in this block
981 pages = min(sectors, info->blocksize - page);
982 len = (pages << info->pageshift);
984 // Get the data from the transfer buffer
985 usb_stor_access_xfer_buf(buffer, len, us->srb,
986 &index, &offset, FROM_XFER_BUF);
988 result = sddr09_write_lba(us, lba, page, pages,
989 buffer, blockbuffer);
990 if (result != USB_STOR_TRANSPORT_GOOD)
1005 sddr09_read_control(struct us_data *us,
1006 unsigned long address,
1007 unsigned int blocks,
1008 unsigned char *content,
1011 US_DEBUGP("Read control address %lu, blocks %d\n",
1014 return sddr09_read21(us, address, blocks,
1015 CONTROL_SHIFT, content, use_sg);
1019 * Read Device ID Command: 12 bytes.
1020 * byte 0: opcode: ED
1022 * Returns 2 bytes: Manufacturer ID and Device ID.
1023 * On more recent cards 3 bytes: the third byte is an option code A5
1024 * signifying that the secret command to read an 128-bit ID is available.
1025 * On still more recent cards 4 bytes: the fourth byte C0 means that
1026 * a second read ID cmd is available.
1029 sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) {
1030 unsigned char *command = us->iobuf;
1031 unsigned char *content = us->iobuf;
1034 memset(command, 0, 12);
1036 command[1] = LUNBITS;
1038 result = sddr09_send_scsi_command(us, command, 12);
1039 if (result != USB_STOR_TRANSPORT_GOOD)
1042 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1045 for (i = 0; i < 4; i++)
1046 deviceID[i] = content[i];
1048 return (result == USB_STOR_XFER_GOOD ?
1049 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
1053 sddr09_get_wp(struct us_data *us, struct sddr09_card_info *info) {
1055 unsigned char status;
1057 result = sddr09_read_status(us, &status);
1058 if (result != USB_STOR_TRANSPORT_GOOD) {
1059 US_DEBUGP("sddr09_get_wp: read_status fails\n");
1062 US_DEBUGP("sddr09_get_wp: status 0x%02X", status);
1063 if ((status & 0x80) == 0) {
1064 info->flags |= SDDR09_WP; /* write protected */
1068 US_DEBUGP(" Ready");
1069 if (status & LUNBITS)
1070 US_DEBUGP(" Suspended");
1072 US_DEBUGP(" Error");
1074 return USB_STOR_TRANSPORT_GOOD;
1079 * Reset Command: 12 bytes.
1080 * byte 0: opcode: EB
1083 sddr09_reset(struct us_data *us) {
1085 unsigned char *command = us->iobuf;
1087 memset(command, 0, 12);
1089 command[1] = LUNBITS;
1091 return sddr09_send_scsi_command(us, command, 12);
1095 static struct nand_flash_dev *
1096 sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
1097 struct nand_flash_dev *cardinfo;
1098 unsigned char deviceID[4];
1102 US_DEBUGP("Reading capacity...\n");
1104 result = sddr09_read_deviceID(us, deviceID);
1106 if (result != USB_STOR_TRANSPORT_GOOD) {
1107 US_DEBUGP("Result of read_deviceID is %d\n", result);
1108 printk("sddr09: could not read card info\n");
1112 sprintf(blurbtxt, "sddr09: Found Flash card, ID = %02X %02X %02X %02X",
1113 deviceID[0], deviceID[1], deviceID[2], deviceID[3]);
1115 /* Byte 0 is the manufacturer */
1116 sprintf(blurbtxt + strlen(blurbtxt),
1118 nand_flash_manufacturer(deviceID[0]));
1120 /* Byte 1 is the device type */
1121 cardinfo = nand_find_id(deviceID[1]);
1123 /* MB or MiB? It is neither. A 16 MB card has
1124 17301504 raw bytes, of which 16384000 are
1125 usable for user data. */
1126 sprintf(blurbtxt + strlen(blurbtxt),
1127 ", %d MB", 1<<(cardinfo->chipshift - 20));
1129 sprintf(blurbtxt + strlen(blurbtxt),
1130 ", type unrecognized");
1133 /* Byte 2 is code to signal availability of 128-bit ID */
1134 if (deviceID[2] == 0xa5) {
1135 sprintf(blurbtxt + strlen(blurbtxt),
1139 /* Byte 3 announces the availability of another read ID command */
1140 if (deviceID[3] == 0xc0) {
1141 sprintf(blurbtxt + strlen(blurbtxt),
1145 if (flags & SDDR09_WP)
1146 sprintf(blurbtxt + strlen(blurbtxt),
1149 printk("%s\n", blurbtxt);
1155 sddr09_read_map(struct us_data *us) {
1157 struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra;
1158 int numblocks, alloc_len, alloc_blocks;
1160 unsigned char *buffer, *buffer_end, *ptr;
1161 unsigned int lba, lbact;
1163 if (!info->capacity)
1166 // size of a block is 1 << (blockshift + pageshift) bytes
1167 // divide into the total capacity to get the number of blocks
1169 numblocks = info->capacity >> (info->blockshift + info->pageshift);
1171 // read 64 bytes for every block (actually 1 << CONTROL_SHIFT)
1172 // but only use a 64 KB buffer
1173 // buffer size used must be a multiple of (1 << CONTROL_SHIFT)
1174 #define SDDR09_READ_MAP_BUFSZ 65536
1176 alloc_blocks = min(numblocks, SDDR09_READ_MAP_BUFSZ >> CONTROL_SHIFT);
1177 alloc_len = (alloc_blocks << CONTROL_SHIFT);
1178 buffer = kmalloc(alloc_len, GFP_NOIO);
1179 if (buffer == NULL) {
1180 printk("sddr09_read_map: out of memory\n");
1184 buffer_end = buffer + alloc_len;
1186 #undef SDDR09_READ_MAP_BUFSZ
1188 kfree(info->lba_to_pba);
1189 kfree(info->pba_to_lba);
1190 info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1191 info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
1193 if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) {
1194 printk("sddr09_read_map: out of memory\n");
1199 for (i = 0; i < numblocks; i++)
1200 info->lba_to_pba[i] = info->pba_to_lba[i] = UNDEF;
1203 * Define lba-pba translation table
1207 for (i = 0; i < numblocks; i++) {
1208 ptr += (1 << CONTROL_SHIFT);
1209 if (ptr >= buffer_end) {
1210 unsigned long address;
1212 address = i << (info->pageshift + info->blockshift);
1213 result = sddr09_read_control(
1215 min(alloc_blocks, numblocks - i),
1217 if (result != USB_STOR_TRANSPORT_GOOD) {
1224 if (i == 0 || i == 1) {
1225 info->pba_to_lba[i] = UNUSABLE;
1229 /* special PBAs have control field 0^16 */
1230 for (j = 0; j < 16; j++)
1233 info->pba_to_lba[i] = UNUSABLE;
1234 printk("sddr09: PBA %d has no logical mapping\n", i);
1238 /* unwritten PBAs have control field FF^16 */
1239 for (j = 0; j < 16; j++)
1245 /* normal PBAs start with six FFs */
1247 printk("sddr09: PBA %d has no logical mapping: "
1248 "reserved area = %02X%02X%02X%02X "
1249 "data status %02X block status %02X\n",
1250 i, ptr[0], ptr[1], ptr[2], ptr[3],
1252 info->pba_to_lba[i] = UNUSABLE;
1256 if ((ptr[6] >> 4) != 0x01) {
1257 printk("sddr09: PBA %d has invalid address field "
1258 "%02X%02X/%02X%02X\n",
1259 i, ptr[6], ptr[7], ptr[11], ptr[12]);
1260 info->pba_to_lba[i] = UNUSABLE;
1264 /* check even parity */
1265 if (parity[ptr[6] ^ ptr[7]]) {
1266 printk("sddr09: Bad parity in LBA for block %d"
1267 " (%02X %02X)\n", i, ptr[6], ptr[7]);
1268 info->pba_to_lba[i] = UNUSABLE;
1272 lba = short_pack(ptr[7], ptr[6]);
1273 lba = (lba & 0x07FF) >> 1;
1276 * Every 1024 physical blocks ("zone"), the LBA numbers
1277 * go back to zero, but are within a higher block of LBA's.
1278 * Also, there is a maximum of 1000 LBA's per zone.
1279 * In other words, in PBA 1024-2047 you will find LBA 0-999
1280 * which are really LBA 1000-1999. This allows for 24 bad
1281 * or special physical blocks per zone.
1285 printk("sddr09: Bad low LBA %d for block %d\n",
1287 goto possibly_erase;
1290 lba += 1000*(i/0x400);
1292 if (info->lba_to_pba[lba] != UNDEF) {
1293 printk("sddr09: LBA %d seen for PBA %d and %d\n",
1294 lba, info->lba_to_pba[lba], i);
1295 goto possibly_erase;
1298 info->pba_to_lba[i] = lba;
1299 info->lba_to_pba[lba] = i;
1303 if (erase_bad_lba_entries) {
1304 unsigned long address;
1306 address = (i << (info->pageshift + info->blockshift));
1307 sddr09_erase(us, address>>1);
1308 info->pba_to_lba[i] = UNDEF;
1310 info->pba_to_lba[i] = UNUSABLE;
1314 * Approximate capacity. This is not entirely correct yet,
1315 * since a zone with less than 1000 usable pages leads to
1316 * missing LBAs. Especially if it is the last zone, some
1317 * LBAs can be past capacity.
1320 for (i = 0; i < numblocks; i += 1024) {
1323 for (j = 0; j < 1024 && i+j < numblocks; j++) {
1324 if (info->pba_to_lba[i+j] != UNUSABLE) {
1326 info->pba_to_lba[i+j] = SPARE;
1333 info->lbact = lbact;
1334 US_DEBUGP("Found %d LBA's\n", lbact);
1339 kfree(info->lba_to_pba);
1340 kfree(info->pba_to_lba);
1341 info->lba_to_pba = NULL;
1342 info->pba_to_lba = NULL;
1349 sddr09_card_info_destructor(void *extra) {
1350 struct sddr09_card_info *info = (struct sddr09_card_info *)extra;
1355 kfree(info->lba_to_pba);
1356 kfree(info->pba_to_lba);
1360 sddr09_common_init(struct us_data *us) {
1363 /* set the configuration -- STALL is an acceptable response here */
1364 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
1365 US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev
1366 ->actconfig->desc.bConfigurationValue);
1370 result = usb_reset_configuration(us->pusb_dev);
1371 US_DEBUGP("Result of usb_reset_configuration is %d\n", result);
1372 if (result == -EPIPE) {
1373 US_DEBUGP("-- stall on control interface\n");
1374 } else if (result != 0) {
1375 /* it's not a stall, but another error -- time to bail */
1376 US_DEBUGP("-- Unknown error. Rejecting device\n");
1380 us->extra = kzalloc(sizeof(struct sddr09_card_info), GFP_NOIO);
1383 us->extra_destructor = sddr09_card_info_destructor;
1391 * This is needed at a very early stage. If this is not listed in the
1392 * unusual devices list but called from here then LUN 0 of the combo reader
1393 * is not recognized. But I do not know what precisely these calls do.
1396 usb_stor_sddr09_dpcm_init(struct us_data *us) {
1398 unsigned char *data = us->iobuf;
1400 result = sddr09_common_init(us);
1404 result = sddr09_send_command(us, 0x01, USB_DIR_IN, data, 2);
1405 if (result != USB_STOR_TRANSPORT_GOOD) {
1406 US_DEBUGP("sddr09_init: send_command fails\n");
1410 US_DEBUGP("SDDR09init: %02X %02X\n", data[0], data[1]);
1413 result = sddr09_send_command(us, 0x08, USB_DIR_IN, data, 2);
1414 if (result != USB_STOR_TRANSPORT_GOOD) {
1415 US_DEBUGP("sddr09_init: 2nd send_command fails\n");
1419 US_DEBUGP("SDDR09init: %02X %02X\n", data[0], data[1]);
1422 result = sddr09_request_sense(us, data, 18);
1423 if (result == USB_STOR_TRANSPORT_GOOD && data[2] != 0) {
1425 for (j=0; j<18; j++)
1426 printk(" %02X", data[j]);
1428 // get 70 00 00 00 00 00 00 * 00 00 00 00 00 00
1429 // 70: current command
1430 // sense key 0, sense code 0, extd sense code 0
1431 // additional transfer length * = sizeof(data) - 7
1432 // Or: 70 00 06 00 00 00 00 0b 00 00 00 00 28 00 00 00 00 00
1433 // sense key 06, sense code 28: unit attention,
1434 // not ready to ready transition
1439 return 0; /* not result */
1443 * Transport for the Sandisk SDDR-09
1445 int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
1447 static unsigned char sensekey = 0, sensecode = 0;
1448 static unsigned char havefakesense = 0;
1450 unsigned char *ptr = us->iobuf;
1451 unsigned long capacity;
1452 unsigned int page, pages;
1454 struct sddr09_card_info *info;
1456 static unsigned char inquiry_response[8] = {
1457 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
1460 /* note: no block descriptor support */
1461 static unsigned char mode_page_01[19] = {
1462 0x00, 0x0F, 0x00, 0x0, 0x0, 0x0, 0x00,
1464 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1467 info = (struct sddr09_card_info *)us->extra;
1469 if (srb->cmnd[0] == REQUEST_SENSE && havefakesense) {
1470 /* for a faked command, we have to follow with a faked sense */
1475 ptr[12] = sensecode;
1476 usb_stor_set_xfer_buf(ptr, 18, srb);
1477 sensekey = sensecode = havefakesense = 0;
1478 return USB_STOR_TRANSPORT_GOOD;
1483 /* Dummy up a response for INQUIRY since SDDR09 doesn't
1484 respond to INQUIRY commands */
1486 if (srb->cmnd[0] == INQUIRY) {
1487 memcpy(ptr, inquiry_response, 8);
1488 fill_inquiry_response(us, ptr, 36);
1489 return USB_STOR_TRANSPORT_GOOD;
1492 if (srb->cmnd[0] == READ_CAPACITY) {
1493 struct nand_flash_dev *cardinfo;
1495 sddr09_get_wp(us, info); /* read WP bit */
1497 cardinfo = sddr09_get_cardinfo(us, info->flags);
1499 /* probably no media */
1501 sensekey = 0x02; /* not ready */
1502 sensecode = 0x3a; /* medium not present */
1503 return USB_STOR_TRANSPORT_FAILED;
1506 info->capacity = (1 << cardinfo->chipshift);
1507 info->pageshift = cardinfo->pageshift;
1508 info->pagesize = (1 << info->pageshift);
1509 info->blockshift = cardinfo->blockshift;
1510 info->blocksize = (1 << info->blockshift);
1511 info->blockmask = info->blocksize - 1;
1513 // map initialization, must follow get_cardinfo()
1514 if (sddr09_read_map(us)) {
1515 /* probably out of memory */
1521 capacity = (info->lbact << info->blockshift) - 1;
1523 ((__be32 *) ptr)[0] = cpu_to_be32(capacity);
1527 ((__be32 *) ptr)[1] = cpu_to_be32(info->pagesize);
1528 usb_stor_set_xfer_buf(ptr, 8, srb);
1530 return USB_STOR_TRANSPORT_GOOD;
1533 if (srb->cmnd[0] == MODE_SENSE_10) {
1534 int modepage = (srb->cmnd[2] & 0x3F);
1536 /* They ask for the Read/Write error recovery page,
1537 or for all pages. */
1538 /* %% We should check DBD %% */
1539 if (modepage == 0x01 || modepage == 0x3F) {
1540 US_DEBUGP("SDDR09: Dummy up request for "
1541 "mode page 0x%x\n", modepage);
1543 memcpy(ptr, mode_page_01, sizeof(mode_page_01));
1544 ((__be16*)ptr)[0] = cpu_to_be16(sizeof(mode_page_01) - 2);
1545 ptr[3] = (info->flags & SDDR09_WP) ? 0x80 : 0;
1546 usb_stor_set_xfer_buf(ptr, sizeof(mode_page_01), srb);
1547 return USB_STOR_TRANSPORT_GOOD;
1550 sensekey = 0x05; /* illegal request */
1551 sensecode = 0x24; /* invalid field in CDB */
1552 return USB_STOR_TRANSPORT_FAILED;
1555 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL)
1556 return USB_STOR_TRANSPORT_GOOD;
1560 if (srb->cmnd[0] == READ_10) {
1562 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1564 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1565 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1567 US_DEBUGP("READ_10: read page %d pagect %d\n",
1570 return sddr09_read_data(us, page, pages);
1573 if (srb->cmnd[0] == WRITE_10) {
1575 page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1577 page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1578 pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1580 US_DEBUGP("WRITE_10: write page %d pagect %d\n",
1583 return sddr09_write_data(us, page, pages);
1586 /* catch-all for all other commands, except
1587 * pass TEST_UNIT_READY and REQUEST_SENSE through
1589 if (srb->cmnd[0] != TEST_UNIT_READY &&
1590 srb->cmnd[0] != REQUEST_SENSE) {
1591 sensekey = 0x05; /* illegal request */
1592 sensecode = 0x20; /* invalid command */
1594 return USB_STOR_TRANSPORT_FAILED;
1597 for (; srb->cmd_len<12; srb->cmd_len++)
1598 srb->cmnd[srb->cmd_len] = 0;
1600 srb->cmnd[1] = LUNBITS;
1603 for (i=0; i<12; i++)
1604 sprintf(ptr+strlen(ptr), "%02X ", srb->cmnd[i]);
1606 US_DEBUGP("SDDR09: Send control for command %s\n", ptr);
1608 result = sddr09_send_scsi_command(us, srb->cmnd, 12);
1609 if (result != USB_STOR_TRANSPORT_GOOD) {
1610 US_DEBUGP("sddr09_transport: sddr09_send_scsi_command "
1611 "returns %d\n", result);
1615 if (srb->request_bufflen == 0)
1616 return USB_STOR_TRANSPORT_GOOD;
1618 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1619 srb->sc_data_direction == DMA_FROM_DEVICE) {
1620 unsigned int pipe = (srb->sc_data_direction == DMA_TO_DEVICE)
1621 ? us->send_bulk_pipe : us->recv_bulk_pipe;
1623 US_DEBUGP("SDDR09: %s %d bytes\n",
1624 (srb->sc_data_direction == DMA_TO_DEVICE) ?
1625 "sending" : "receiving",
1626 srb->request_bufflen);
1628 result = usb_stor_bulk_transfer_sg(us, pipe,
1629 srb->request_buffer,
1630 srb->request_bufflen,
1631 srb->use_sg, &srb->resid);
1633 return (result == USB_STOR_XFER_GOOD ?
1634 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
1637 return USB_STOR_TRANSPORT_GOOD;
1641 * Initialization routine for the sddr09 subdriver
1644 usb_stor_sddr09_init(struct us_data *us) {
1645 return sddr09_common_init(us);