drivers/usb/storage/sddr09.c

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