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