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