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