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