drivers/usb/storage/sddr09.c

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