common/cmd_doc.c

   1 /*
   2  * Driver for Disk-On-Chip 2000 and Millennium
   3  * (c) 1999 Machine Vision Holdings, Inc.
   4  * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
   5  *
   6  * $Id: doc2000.c,v 1.46 2001/10/02 15:05:13 dwmw2 Exp $
   7  */
   8
   9 #include <common.h>
  10 #include <config.h>
  11 #include <command.h>
  12 #include <malloc.h>
  13 #include <asm/io.h>
  14
  15 #ifdef CONFIG_SHOW_BOOT_PROGRESS
  16 # include <status_led.h>
  17 # define SHOW_BOOT_PROGRESS(arg)        show_boot_progress(arg)
  18 #else
  19 # define SHOW_BOOT_PROGRESS(arg)
  20 #endif
  21
  22 #if (CONFIG_COMMANDS & CFG_CMD_DOC)
  23
  24 #include <linux/mtd/nftl.h>
  25 #include <linux/mtd/nand.h>
  26 #include <linux/mtd/nand_ids.h>
  27 #include <linux/mtd/doc2000.h>
  28 #include <linux/mtd/nftl.h>
  29
  30 #ifdef CFG_DOC_SUPPORT_2000
  31 #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
  32 #else
  33 #define DoC_is_2000(doc) (0)
  34 #endif
  35
  36 #ifdef CFG_DOC_SUPPORT_MILLENNIUM
  37 #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
  38 #else
  39 #define DoC_is_Millennium(doc) (0)
  40 #endif
  41
  42 /* CFG_DOC_PASSIVE_PROBE:
  43    In order to ensure that the BIOS checksum is correct at boot time, and
  44    hence that the onboard BIOS extension gets executed, the DiskOnChip
  45    goes into reset mode when it is read sequentially: all registers
  46    return 0xff until the chip is woken up again by writing to the
  47    DOCControl register.
  48
  49    Unfortunately, this means that the probe for the DiskOnChip is unsafe,
  50    because one of the first things it does is write to where it thinks
  51    the DOCControl register should be - which may well be shared memory
  52    for another device. I've had machines which lock up when this is
  53    attempted. Hence the possibility to do a passive probe, which will fail
  54    to detect a chip in reset mode, but is at least guaranteed not to lock
  55    the machine.
  56
  57    If you have this problem, uncomment the following line:
  58 #define CFG_DOC_PASSIVE_PROBE
  59 */
  60
  61 #undef  DOC_DEBUG
  62 #undef  ECC_DEBUG
  63 #undef  PSYCHO_DEBUG
  64 #undef  NFTL_DEBUG
  65
  66 static struct DiskOnChip doc_dev_desc[CFG_MAX_DOC_DEVICE];
  67
  68 /* Current DOC Device   */
  69 static int curr_device = -1;
  70
  71 /* ------------------------------------------------------------------------- */
  72
  73 int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
  74 {
  75     int rcode = 0;
  76
  77     switch (argc) {
  78     case 0:
  79     case 1:
  80         printf ("Usage:\n%s\n", cmdtp->usage);
  81         return 1;
  82     case 2:
  83         if (strcmp(argv[1],"info") == 0) {
  84                 int i;
  85
  86                 putc ('\n');
  87
  88                 for (i=0; i<CFG_MAX_DOC_DEVICE; ++i) {
  89                         if(doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN)
  90                                 continue; /* list only known devices */
  91                         printf ("Device %d: ", i);
  92                         doc_print(&doc_dev_desc[i]);
  93                 }
  94                 return 0;
  95
  96         } else if (strcmp(argv[1],"device") == 0) {
  97                 if ((curr_device < 0) || (curr_device >= CFG_MAX_DOC_DEVICE)) {
  98                         puts ("\nno devices available\n");
  99                         return 1;
 100                 }
 101                 printf ("\nDevice %d: ", curr_device);
 102                 doc_print(&doc_dev_desc[curr_device]);
 103                 return 0;
 104         }
 105         printf ("Usage:\n%s\n", cmdtp->usage);
 106         return 1;
 107     case 3:
 108         if (strcmp(argv[1],"device") == 0) {
 109                 int dev = (int)simple_strtoul(argv[2], NULL, 10);
 110
 111                 printf ("\nDevice %d: ", dev);
 112                 if (dev >= CFG_MAX_DOC_DEVICE) {
 113                         puts ("unknown device\n");
 114                         return 1;
 115                 }
 116                 doc_print(&doc_dev_desc[dev]);
 117                 /*doc_print (dev);*/
 118
 119                 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
 120                         return 1;
 121                 }
 122
 123                 curr_device = dev;
 124
 125                 puts ("... is now current device\n");
 126
 127                 return 0;
 128         }
 129
 130         printf ("Usage:\n%s\n", cmdtp->usage);
 131         return 1;
 132     default:
 133         /* at least 4 args */
 134
 135         if (strcmp(argv[1],"read") == 0 || strcmp(argv[1],"write") == 0) {
 136                 ulong addr = simple_strtoul(argv[2], NULL, 16);
 137                 ulong off  = simple_strtoul(argv[3], NULL, 16);
 138                 ulong size = simple_strtoul(argv[4], NULL, 16);
 139                 int cmd    = (strcmp(argv[1],"read") == 0);
 140                 int ret, total;
 141
 142                 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
 143                         cmd ? "read" : "write", curr_device, off, size);
 144
 145                 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
 146                              &total, (u_char*)addr);
 147
 148                 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
 149                         ret ? "ERROR" : "OK");
 150
 151                 return ret;
 152         } else if (strcmp(argv[1],"erase") == 0) {
 153                 ulong off = simple_strtoul(argv[2], NULL, 16);
 154                 ulong size = simple_strtoul(argv[3], NULL, 16);
 155                 int ret;
 156
 157                 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
 158                         curr_device, off, size);
 159
 160                 ret = doc_erase (doc_dev_desc + curr_device, off, size);
 161
 162                 printf("%s\n", ret ? "ERROR" : "OK");
 163
 164                 return ret;
 165         } else {
 166                 printf ("Usage:\n%s\n", cmdtp->usage);
 167                 rcode = 1;
 168         }
 169
 170         return rcode;
 171     }
 172 }
 173 U_BOOT_CMD(
 174         doc,    5,      1,      do_doc,
 175         "doc     - Disk-On-Chip sub-system\n",
 176         "info  - show available DOC devices\n"
 177         "doc device [dev] - show or set current device\n"
 178         "doc read  addr off size\n"
 179         "doc write addr off size - read/write `size'"
 180         " bytes starting at offset `off'\n"
 181         "    to/from memory address `addr'\n"
 182         "doc erase off size - erase `size' bytes of DOC from offset `off'\n"
 183 );
 184
 185 int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 186 {
 187         char *boot_device = NULL;
 188         char *ep;
 189         int dev;
 190         ulong cnt;
 191         ulong addr;
 192         ulong offset = 0;
 193         image_header_t *hdr;
 194         int rcode = 0;
 195
 196         switch (argc) {
 197         case 1:
 198                 addr = CFG_LOAD_ADDR;
 199                 boot_device = getenv ("bootdevice");
 200                 break;
 201         case 2:
 202                 addr = simple_strtoul(argv[1], NULL, 16);
 203                 boot_device = getenv ("bootdevice");
 204                 break;
 205         case 3:
 206                 addr = simple_strtoul(argv[1], NULL, 16);
 207                 boot_device = argv[2];
 208                 break;
 209         case 4:
 210                 addr = simple_strtoul(argv[1], NULL, 16);
 211                 boot_device = argv[2];
 212                 offset = simple_strtoul(argv[3], NULL, 16);
 213                 break;
 214         default:
 215                 printf ("Usage:\n%s\n", cmdtp->usage);
 216                 SHOW_BOOT_PROGRESS (-1);
 217                 return 1;
 218         }
 219
 220         if (!boot_device) {
 221                 puts ("\n** No boot device **\n");
 222                 SHOW_BOOT_PROGRESS (-1);
 223                 return 1;
 224         }
 225
 226         dev = simple_strtoul(boot_device, &ep, 16);
 227
 228         if ((dev >= CFG_MAX_DOC_DEVICE) ||
 229             (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN)) {
 230                 printf ("\n** Device %d not available\n", dev);
 231                 SHOW_BOOT_PROGRESS (-1);
 232                 return 1;
 233         }
 234
 235         printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
 236                 dev, doc_dev_desc[dev].name, doc_dev_desc[dev].physadr,
 237                 offset);
 238
 239         if (doc_rw (doc_dev_desc + dev, 1, offset,
 240                     SECTORSIZE, NULL, (u_char *)addr)) {
 241                 printf ("** Read error on %d\n", dev);
 242                 SHOW_BOOT_PROGRESS (-1);
 243                 return 1;
 244         }
 245
 246         hdr = (image_header_t *)addr;
 247
 248         if (hdr->ih_magic == IH_MAGIC) {
 249
 250                 print_image_hdr (hdr);
 251
 252                 cnt = (hdr->ih_size + sizeof(image_header_t));
 253                 cnt -= SECTORSIZE;
 254         } else {
 255                 puts ("\n** Bad Magic Number **\n");
 256                 SHOW_BOOT_PROGRESS (-1);
 257                 return 1;
 258         }
 259
 260         if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
 261                     NULL, (u_char *)(addr+SECTORSIZE))) {
 262                 printf ("** Read error on %d\n", dev);
 263                 SHOW_BOOT_PROGRESS (-1);
 264                 return 1;
 265         }
 266
 267         /* Loading ok, update default load address */
 268
 269         load_addr = addr;
 270
 271         /* Check if we should attempt an auto-start */
 272         if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
 273                 char *local_args[2];
 274                 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
 275
 276                 local_args[0] = argv[0];
 277                 local_args[1] = NULL;
 278
 279                 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
 280
 281                 do_bootm (cmdtp, 0, 1, local_args);
 282                 rcode = 1;
 283         }
 284         return rcode;
 285 }
 286
 287 U_BOOT_CMD(
 288         docboot,        4,      1,      do_docboot,
 289         "docboot - boot from DOC device\n",
 290         "loadAddr dev\n"
 291 );
 292
 293 int doc_rw (struct DiskOnChip* this, int cmd,
 294             loff_t from, size_t len,
 295             size_t * retlen, u_char * buf)
 296 {
 297         int noecc, ret = 0, n, total = 0;
 298         char eccbuf[6];
 299
 300         while(len) {
 301                 /* The ECC will not be calculated correctly if
 302                    less than 512 is written or read */
 303                 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
 304
 305                 if (cmd)
 306                         ret = doc_read_ecc(this, from, len,
 307                                            &n, (u_char*)buf,
 308                                            noecc ? NULL : eccbuf);
 309                 else
 310                         ret = doc_write_ecc(this, from, len,
 311                                             &n, (u_char*)buf,
 312                                             noecc ? NULL : eccbuf);
 313
 314                 if (ret)
 315                         break;
 316
 317                 from  += n;
 318                 buf   += n;
 319                 total += n;
 320                 len   -= n;
 321         }
 322
 323         if (retlen)
 324                 *retlen = total;
 325
 326         return ret;
 327 }
 328
 329 void doc_print(struct DiskOnChip *this) {
 330         printf("%s at 0x%lX,\n"
 331                "\t  %d chip%s %s, size %d MB, \n"
 332                "\t  total size %ld MB, sector size %ld kB\n",
 333                this->name, this->physadr, this->numchips,
 334                this->numchips>1 ? "s" : "", this->chips_name,
 335                1 << (this->chipshift - 20),
 336                this->totlen >> 20, this->erasesize >> 10);
 337
 338         if (this->nftl_found) {
 339                 struct NFTLrecord *nftl = &this->nftl;
 340                 unsigned long bin_size, flash_size;
 341
 342                 bin_size = nftl->nb_boot_blocks * this->erasesize;
 343                 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
 344
 345                 printf("\t  NFTL boot record:\n"
 346                        "\t    Binary partition: size %ld%s\n"
 347                        "\t    Flash disk partition: size %ld%s, offset 0x%lx\n",
 348                        bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
 349                        bin_size > (1 << 20) ? "MB" : "kB",
 350                        flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
 351                        flash_size > (1 << 20) ? "MB" : "kB", bin_size);
 352         } else {
 353                 puts ("\t  No NFTL boot record found.\n");
 354         }
 355 }
 356
 357 /* ------------------------------------------------------------------------- */
 358
 359 /* This function is needed to avoid calls of the __ashrdi3 function. */
 360 static int shr(int val, int shift) {
 361         return val >> shift;
 362 }
 363
 364 /* Perform the required delay cycles by reading from the appropriate register */
 365 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
 366 {
 367         volatile char dummy;
 368         int i;
 369
 370         for (i = 0; i < cycles; i++) {
 371                 if (DoC_is_Millennium(doc))
 372                         dummy = ReadDOC(doc->virtadr, NOP);
 373                 else
 374                         dummy = ReadDOC(doc->virtadr, DOCStatus);
 375         }
 376
 377 }
 378
 379 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
 380 static int _DoC_WaitReady(struct DiskOnChip *doc)
 381 {
 382         unsigned long docptr = doc->virtadr;
 383         unsigned long start = get_timer(0);
 384
 385 #ifdef PSYCHO_DEBUG
 386         puts ("_DoC_WaitReady called for out-of-line wait\n");
 387 #endif
 388
 389         /* Out-of-line routine to wait for chip response */
 390         while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
 391 #ifdef CFG_DOC_SHORT_TIMEOUT
 392                 /* it seems that after a certain time the DoC deasserts
 393                  * the CDSN_CTRL_FR_B although it is not ready...
 394                  * using a short timout solve this (timer increments every ms) */
 395                 if (get_timer(start) > 10) {
 396                         return DOC_ETIMEOUT;
 397                 }
 398 #else
 399                 if (get_timer(start) > 10 * 1000) {
 400                         puts ("_DoC_WaitReady timed out.\n");
 401                         return DOC_ETIMEOUT;
 402                 }
 403 #endif
 404                 udelay(1);
 405         }
 406
 407         return 0;
 408 }
 409
 410 static int DoC_WaitReady(struct DiskOnChip *doc)
 411 {
 412         unsigned long docptr = doc->virtadr;
 413         /* This is inline, to optimise the common case, where it's ready instantly */
 414         int ret = 0;
 415
 416         /* 4 read form NOP register should be issued in prior to the read from CDSNControl
 417            see Software Requirement 11.4 item 2. */
 418         DoC_Delay(doc, 4);
 419
 420         if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
 421                 /* Call the out-of-line routine to wait */
 422                 ret = _DoC_WaitReady(doc);
 423
 424         /* issue 2 read from NOP register after reading from CDSNControl register
 425            see Software Requirement 11.4 item 2. */
 426         DoC_Delay(doc, 2);
 427
 428         return ret;
 429 }
 430
 431 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
 432    bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
 433    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
 434
 435 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
 436                               unsigned char xtraflags)
 437 {
 438         unsigned long docptr = doc->virtadr;
 439
 440         if (DoC_is_2000(doc))
 441                 xtraflags |= CDSN_CTRL_FLASH_IO;
 442
 443         /* Assert the CLE (Command Latch Enable) line to the flash chip */
 444         WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
 445         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 446
 447         if (DoC_is_Millennium(doc))
 448                 WriteDOC(command, docptr, CDSNSlowIO);
 449
 450         /* Send the command */
 451         WriteDOC_(command, docptr, doc->ioreg);
 452
 453         /* Lower the CLE line */
 454         WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
 455         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 456
 457         /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
 458         return DoC_WaitReady(doc);
 459 }
 460
 461 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
 462    bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
 463    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
 464
 465 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
 466                        unsigned char xtraflags1, unsigned char xtraflags2)
 467 {
 468         unsigned long docptr;
 469         int i;
 470
 471         docptr = doc->virtadr;
 472
 473         if (DoC_is_2000(doc))
 474                 xtraflags1 |= CDSN_CTRL_FLASH_IO;
 475
 476         /* Assert the ALE (Address Latch Enable) line to the flash chip */
 477         WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
 478
 479         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 480
 481         /* Send the address */
 482         /* Devices with 256-byte page are addressed as:
 483            Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
 484            * there is no device on the market with page256
 485            and more than 24 bits.
 486            Devices with 512-byte page are addressed as:
 487            Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
 488            * 25-31 is sent only if the chip support it.
 489            * bit 8 changes the read command to be sent
 490            (NAND_CMD_READ0 or NAND_CMD_READ1).
 491          */
 492
 493         if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
 494                 if (DoC_is_Millennium(doc))
 495                         WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
 496                 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
 497         }
 498
 499         if (doc->page256) {
 500                 ofs = ofs >> 8;
 501         } else {
 502                 ofs = ofs >> 9;
 503         }
 504
 505         if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
 506                 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
 507                         if (DoC_is_Millennium(doc))
 508                                 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
 509                         WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
 510                 }
 511         }
 512
 513         DoC_Delay(doc, 2);      /* Needed for some slow flash chips. mf. */
 514
 515         /* FIXME: The SlowIO's for millennium could be replaced by
 516            a single WritePipeTerm here. mf. */
 517
 518         /* Lower the ALE line */
 519         WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
 520                  CDSNControl);
 521
 522         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 523
 524         /* Wait for the chip to respond - Software requirement 11.4.1 */
 525         return DoC_WaitReady(doc);
 526 }
 527
 528 /* Read a buffer from DoC, taking care of Millennium oddities */
 529 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
 530 {
 531         volatile int dummy;
 532         int modulus = 0xffff;
 533         unsigned long docptr;
 534         int i;
 535
 536         docptr = doc->virtadr;
 537
 538         if (len <= 0)
 539                 return;
 540
 541         if (DoC_is_Millennium(doc)) {
 542                 /* Read the data via the internal pipeline through CDSN IO register,
 543                    see Pipelined Read Operations 11.3 */
 544                 dummy = ReadDOC(docptr, ReadPipeInit);
 545
 546                 /* Millennium should use the LastDataRead register - Pipeline Reads */
 547                 len--;
 548
 549                 /* This is needed for correctly ECC calculation */
 550                 modulus = 0xff;
 551         }
 552
 553         for (i = 0; i < len; i++)
 554                 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
 555
 556         if (DoC_is_Millennium(doc)) {
 557                 buf[i] = ReadDOC(docptr, LastDataRead);
 558         }
 559 }
 560
 561 /* Write a buffer to DoC, taking care of Millennium oddities */
 562 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
 563 {
 564         unsigned long docptr;
 565         int i;
 566
 567         docptr = doc->virtadr;
 568
 569         if (len <= 0)
 570                 return;
 571
 572         for (i = 0; i < len; i++)
 573                 WriteDOC_(buf[i], docptr, doc->ioreg + i);
 574
 575         if (DoC_is_Millennium(doc)) {
 576                 WriteDOC(0x00, docptr, WritePipeTerm);
 577         }
 578 }
 579
 580
 581 /* DoC_SelectChip: Select a given flash chip within the current floor */
 582
 583 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
 584 {
 585         unsigned long docptr = doc->virtadr;
 586
 587         /* Software requirement 11.4.4 before writing DeviceSelect */
 588         /* Deassert the CE line to eliminate glitches on the FCE# outputs */
 589         WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
 590         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 591
 592         /* Select the individual flash chip requested */
 593         WriteDOC(chip, docptr, CDSNDeviceSelect);
 594         DoC_Delay(doc, 4);
 595
 596         /* Reassert the CE line */
 597         WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
 598                  CDSNControl);
 599         DoC_Delay(doc, 4);      /* Software requirement 11.4.3 for Millennium */
 600
 601         /* Wait for it to be ready */
 602         return DoC_WaitReady(doc);
 603 }
 604
 605 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
 606
 607 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
 608 {
 609         unsigned long docptr = doc->virtadr;
 610
 611         /* Select the floor (bank) of chips required */
 612         WriteDOC(floor, docptr, FloorSelect);
 613
 614         /* Wait for the chip to be ready */
 615         return DoC_WaitReady(doc);
 616 }
 617
 618 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
 619
 620 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
 621 {
 622         int mfr, id, i;
 623         volatile char dummy;
 624
 625         /* Page in the required floor/chip */
 626         DoC_SelectFloor(doc, floor);
 627         DoC_SelectChip(doc, chip);
 628
 629         /* Reset the chip */
 630         if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
 631 #ifdef DOC_DEBUG
 632                 printf("DoC_Command (reset) for %d,%d returned true\n",
 633                        floor, chip);
 634 #endif
 635                 return 0;
 636         }
 637
 638
 639         /* Read the NAND chip ID: 1. Send ReadID command */
 640         if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
 641 #ifdef DOC_DEBUG
 642                 printf("DoC_Command (ReadID) for %d,%d returned true\n",
 643                        floor, chip);
 644 #endif
 645                 return 0;
 646         }
 647
 648         /* Read the NAND chip ID: 2. Send address byte zero */
 649         DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
 650
 651         /* Read the manufacturer and device id codes from the device */
 652
 653         /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
 654         dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
 655         DoC_Delay(doc, 2);
 656         mfr = ReadDOC_(doc->virtadr, doc->ioreg);
 657
 658         /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
 659         dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
 660         DoC_Delay(doc, 2);
 661         id = ReadDOC_(doc->virtadr, doc->ioreg);
 662
 663         /* No response - return failure */
 664         if (mfr == 0xff || mfr == 0)
 665                 return 0;
 666
 667         /* Check it's the same as the first chip we identified.
 668          * M-Systems say that any given DiskOnChip device should only
 669          * contain _one_ type of flash part, although that's not a
 670          * hardware restriction. */
 671         if (doc->mfr) {
 672                 if (doc->mfr == mfr && doc->id == id)
 673                         return 1;       /* This is another the same the first */
 674                 else
 675                         printf("Flash chip at floor %d, chip %d is different:\n",
 676                                floor, chip);
 677         }
 678
 679         /* Print and store the manufacturer and ID codes. */
 680         for (i = 0; nand_flash_ids[i].name != NULL; i++) {
 681                 if (mfr == nand_flash_ids[i].manufacture_id &&
 682                     id == nand_flash_ids[i].model_id) {
 683 #ifdef DOC_DEBUG
 684                         printf("Flash chip found: Manufacturer ID: %2.2X, "
 685                                "Chip ID: %2.2X (%s)\n", mfr, id,
 686                                nand_flash_ids[i].name);
 687 #endif
 688                         if (!doc->mfr) {
 689                                 doc->mfr = mfr;
 690                                 doc->id = id;
 691                                 doc->chipshift =
 692                                     nand_flash_ids[i].chipshift;
 693                                 doc->page256 = nand_flash_ids[i].page256;
 694                                 doc->pageadrlen =
 695                                     nand_flash_ids[i].pageadrlen;
 696                                 doc->erasesize =
 697                                     nand_flash_ids[i].erasesize;
 698                                 doc->chips_name =
 699                                     nand_flash_ids[i].name;
 700                                 return 1;
 701                         }
 702                         return 0;
 703                 }
 704         }
 705
 706
 707 #ifdef DOC_DEBUG
 708         /* We haven't fully identified the chip. Print as much as we know. */
 709         printf("Unknown flash chip found: %2.2X %2.2X\n",
 710                id, mfr);
 711 #endif
 712
 713         return 0;
 714 }
 715
 716 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
 717
 718 static void DoC_ScanChips(struct DiskOnChip *this)
 719 {
 720         int floor, chip;
 721         int numchips[MAX_FLOORS];
 722         int maxchips = MAX_CHIPS;
 723         int ret = 1;
 724
 725         this->numchips = 0;
 726         this->mfr = 0;
 727         this->id = 0;
 728
 729         if (DoC_is_Millennium(this))
 730                 maxchips = MAX_CHIPS_MIL;
 731
 732         /* For each floor, find the number of valid chips it contains */
 733         for (floor = 0; floor < MAX_FLOORS; floor++) {
 734                 ret = 1;
 735                 numchips[floor] = 0;
 736                 for (chip = 0; chip < maxchips && ret != 0; chip++) {
 737
 738                         ret = DoC_IdentChip(this, floor, chip);
 739                         if (ret) {
 740                                 numchips[floor]++;
 741                                 this->numchips++;
 742                         }
 743                 }
 744         }
 745
 746         /* If there are none at all that we recognise, bail */
 747         if (!this->numchips) {
 748                 puts ("No flash chips recognised.\n");
 749                 return;
 750         }
 751
 752         /* Allocate an array to hold the information for each chip */
 753         this->chips = malloc(sizeof(struct Nand) * this->numchips);
 754         if (!this->chips) {
 755                 puts ("No memory for allocating chip info structures\n");
 756                 return;
 757         }
 758
 759         ret = 0;
 760
 761         /* Fill out the chip array with {floor, chipno} for each
 762          * detected chip in the device. */
 763         for (floor = 0; floor < MAX_FLOORS; floor++) {
 764                 for (chip = 0; chip < numchips[floor]; chip++) {
 765                         this->chips[ret].floor = floor;
 766                         this->chips[ret].chip = chip;
 767                         this->chips[ret].curadr = 0;
 768                         this->chips[ret].curmode = 0x50;
 769                         ret++;
 770                 }
 771         }
 772
 773         /* Calculate and print the total size of the device */
 774         this->totlen = this->numchips * (1 << this->chipshift);
 775
 776 #ifdef DOC_DEBUG
 777         printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
 778                this->numchips, this->totlen >> 20);
 779 #endif
 780 }
 781
 782 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
 783  *      various device information of the NFTL partition and Bad Unit Table. Update
 784  *      the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
 785  *      is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
 786  */
 787 static int find_boot_record(struct NFTLrecord *nftl)
 788 {
 789         struct nftl_uci1 h1;
 790         struct nftl_oob oob;
 791         unsigned int block, boot_record_count = 0;
 792         int retlen;
 793         u8 buf[SECTORSIZE];
 794         struct NFTLMediaHeader *mh = &nftl->MediaHdr;
 795         unsigned int i;
 796
 797         nftl->MediaUnit = BLOCK_NIL;
 798         nftl->SpareMediaUnit = BLOCK_NIL;
 799
 800         /* search for a valid boot record */
 801         for (block = 0; block < nftl->nb_blocks; block++) {
 802                 int ret;
 803
 804                 /* Check for ANAND header first. Then can whinge if it's found but later
 805                    checks fail */
 806                 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
 807                                         &retlen, buf, NULL))) {
 808                         static int warncount = 5;
 809
 810                         if (warncount) {
 811                                 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
 812                                 if (!--warncount)
 813                                         puts ("Further failures for this block will not be printed\n");
 814                         }
 815                         continue;
 816                 }
 817
 818                 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
 819                         /* ANAND\0 not found. Continue */
 820 #ifdef PSYCHO_DEBUG
 821                         printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
 822 #endif
 823                         continue;
 824                 }
 825
 826 #ifdef NFTL_DEBUG
 827                 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
 828 #endif
 829
 830                 /* To be safer with BIOS, also use erase mark as discriminant */
 831                 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
 832                                 8, &retlen, (char *)&h1) < 0)) {
 833 #ifdef NFTL_DEBUG
 834                         printf("ANAND header found at 0x%x, but OOB data read failed\n",
 835                                block * nftl->EraseSize);
 836 #endif
 837                         continue;
 838                 }
 839
 840                 /* OK, we like it. */
 841
 842                 if (boot_record_count) {
 843                         /* We've already processed one. So we just check if
 844                            this one is the same as the first one we found */
 845                         if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
 846 #ifdef NFTL_DEBUG
 847                                 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
 848                                        nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
 849 #endif
 850                                 /* if (debug) Print both side by side */
 851                                 return -1;
 852                         }
 853                         if (boot_record_count == 1)
 854                                 nftl->SpareMediaUnit = block;
 855
 856                         boot_record_count++;
 857                         continue;
 858                 }
 859
 860                 /* This is the first we've seen. Copy the media header structure into place */
 861                 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
 862
 863                 /* Do some sanity checks on it */
 864                 if (mh->UnitSizeFactor == 0) {
 865 #ifdef NFTL_DEBUG
 866                         puts ("UnitSizeFactor 0x00 detected.\n"
 867                               "This violates the spec but we think we know what it means...\n");
 868 #endif
 869                 } else if (mh->UnitSizeFactor != 0xff) {
 870                         printf ("Sorry, we don't support UnitSizeFactor "
 871                               "of != 1 yet.\n");
 872                         return -1;
 873                 }
 874
 875                 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
 876                 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
 877                         printf ("NFTL Media Header sanity check failed:\n"
 878                                 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
 879                                 nftl->nb_boot_blocks, nftl->nb_blocks);
 880                         return -1;
 881                 }
 882
 883                 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
 884                 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
 885                         printf ("NFTL Media Header sanity check failed:\n"
 886                                 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
 887                                 nftl->numvunits,
 888                                 nftl->nb_blocks,
 889                                 nftl->nb_boot_blocks);
 890                         return -1;
 891                 }
 892
 893                 nftl->nr_sects  = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
 894
 895                 /* If we're not using the last sectors in the device for some reason,
 896                    reduce nb_blocks accordingly so we forget they're there */
 897                 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
 898
 899                 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
 900                 for (i = 0; i < nftl->nb_blocks; i++) {
 901                         if ((i & (SECTORSIZE - 1)) == 0) {
 902                                 /* read one sector for every SECTORSIZE of blocks */
 903                                 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
 904                                                        i + SECTORSIZE, SECTORSIZE,
 905                                                        &retlen, buf, (char *)&oob)) < 0) {
 906                                         puts ("Read of bad sector table failed\n");
 907                                         return -1;
 908                                 }
 909                         }
 910                         /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
 911                         if (buf[i & (SECTORSIZE - 1)] != 0xff)
 912                                 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 913                 }
 914
 915                 nftl->MediaUnit = block;
 916                 boot_record_count++;
 917
 918         } /* foreach (block) */
 919
 920         return boot_record_count?0:-1;
 921 }
 922
 923 /* This routine is made available to other mtd code via
 924  * inter_module_register.  It must only be accessed through
 925  * inter_module_get which will bump the use count of this module.  The
 926  * addresses passed back in mtd are valid as long as the use count of
 927  * this module is non-zero, i.e. between inter_module_get and
 928  * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
 929  */
 930 static void DoC2k_init(struct DiskOnChip* this)
 931 {
 932         struct NFTLrecord *nftl;
 933
 934         switch (this->ChipID) {
 935         case DOC_ChipID_Doc2k:
 936                 this->name = "DiskOnChip 2000";
 937                 this->ioreg = DoC_2k_CDSN_IO;
 938                 break;
 939         case DOC_ChipID_DocMil:
 940                 this->name = "DiskOnChip Millennium";
 941                 this->ioreg = DoC_Mil_CDSN_IO;
 942                 break;
 943         }
 944
 945 #ifdef DOC_DEBUG
 946         printf("%s found at address 0x%lX\n", this->name,
 947                this->physadr);
 948 #endif
 949
 950         this->totlen = 0;
 951         this->numchips = 0;
 952
 953         this->curfloor = -1;
 954         this->curchip = -1;
 955
 956         /* Ident all the chips present. */
 957         DoC_ScanChips(this);
 958         if ((!this->numchips) || (!this->chips))
 959                 return;
 960
 961         nftl = &this->nftl;
 962
 963         /* Get physical parameters */
 964         nftl->EraseSize = this->erasesize;
 965         nftl->nb_blocks = this->totlen / this->erasesize;
 966         nftl->mtd = this;
 967
 968         if (find_boot_record(nftl) != 0)
 969                 this->nftl_found = 0;
 970         else
 971                 this->nftl_found = 1;
 972
 973         printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
 974 }
 975
 976 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
 977                  size_t * retlen, u_char * buf, u_char * eccbuf)
 978 {
 979         unsigned long docptr;
 980         struct Nand *mychip;
 981         unsigned char syndrome[6];
 982         volatile char dummy;
 983         int i, len256 = 0, ret=0;
 984
 985         docptr = this->virtadr;
 986
 987         /* Don't allow read past end of device */
 988         if (from >= this->totlen) {
 989                 puts ("Out of flash\n");
 990                 return DOC_EINVAL;
 991         }
 992
 993         /* Don't allow a single read to cross a 512-byte block boundary */
 994         if (from + len > ((from | 0x1ff) + 1))
 995                 len = ((from | 0x1ff) + 1) - from;
 996
 997         /* The ECC will not be calculated correctly if less than 512 is read */
 998         if (len != 0x200 && eccbuf)
 999                 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1000                        (long) from, (long) len);
1001
1002 #ifdef PSYCHO_DEBUG
1003         printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1004 #endif
1005
1006         /* Find the chip which is to be used and select it */
1007         mychip = &this->chips[shr(from, this->chipshift)];
1008
1009         if (this->curfloor != mychip->floor) {
1010                 DoC_SelectFloor(this, mychip->floor);
1011                 DoC_SelectChip(this, mychip->chip);
1012         } else if (this->curchip != mychip->chip) {
1013                 DoC_SelectChip(this, mychip->chip);
1014         }
1015
1016         this->curfloor = mychip->floor;
1017         this->curchip = mychip->chip;
1018
1019         DoC_Command(this,
1020                     (!this->page256
1021                      && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1022                     CDSN_CTRL_WP);
1023         DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1024                     CDSN_CTRL_ECC_IO);
1025
1026         if (eccbuf) {
1027                 /* Prime the ECC engine */
1028                 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1029                 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1030         } else {
1031                 /* disable the ECC engine */
1032                 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1033                 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1034         }
1035
1036         /* treat crossing 256-byte sector for 2M x 8bits devices */
1037         if (this->page256 && from + len > (from | 0xff) + 1) {
1038                 len256 = (from | 0xff) + 1 - from;
1039                 DoC_ReadBuf(this, buf, len256);
1040
1041                 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1042                 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1043                             CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1044         }
1045
1046         DoC_ReadBuf(this, &buf[len256], len - len256);
1047
1048         /* Let the caller know we completed it */
1049         *retlen = len;
1050
1051         if (eccbuf) {
1052                 /* Read the ECC data through the DiskOnChip ECC logic */
1053                 /* Note: this will work even with 2M x 8bit devices as   */
1054                 /*       they have 8 bytes of OOB per 256 page. mf.      */
1055                 DoC_ReadBuf(this, eccbuf, 6);
1056
1057                 /* Flush the pipeline */
1058                 if (DoC_is_Millennium(this)) {
1059                         dummy = ReadDOC(docptr, ECCConf);
1060                         dummy = ReadDOC(docptr, ECCConf);
1061                         i = ReadDOC(docptr, ECCConf);
1062                 } else {
1063                         dummy = ReadDOC(docptr, 2k_ECCStatus);
1064                         dummy = ReadDOC(docptr, 2k_ECCStatus);
1065                         i = ReadDOC(docptr, 2k_ECCStatus);
1066                 }
1067
1068                 /* Check the ECC Status */
1069                 if (i & 0x80) {
1070                         int nb_errors;
1071                         /* There was an ECC error */
1072 #ifdef ECC_DEBUG
1073                         printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1074 #endif
1075                         /* Read the ECC syndrom through the DiskOnChip ECC logic.
1076                            These syndrome will be all ZERO when there is no error */
1077                         for (i = 0; i < 6; i++) {
1078                                 syndrome[i] =
1079                                     ReadDOC(docptr, ECCSyndrome0 + i);
1080                         }
1081                         nb_errors = doc_decode_ecc(buf, syndrome);
1082
1083 #ifdef ECC_DEBUG
1084                         printf("Errors corrected: %x\n", nb_errors);
1085 #endif
1086                         if (nb_errors < 0) {
1087                                 /* We return error, but have actually done the read. Not that
1088                                    this can be told to user-space, via sys_read(), but at least
1089                                    MTD-aware stuff can know about it by checking *retlen */
1090                                 printf("ECC Errors at %lx\n", (long)from);
1091                                 ret = DOC_EECC;
1092                         }
1093                 }
1094
1095 #ifdef PSYCHO_DEBUG
1096                 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1097                              (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1098                              eccbuf[3], eccbuf[4], eccbuf[5]);
1099 #endif
1100
1101                 /* disable the ECC engine */
1102                 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1103         }
1104
1105         /* according to 11.4.1, we need to wait for the busy line
1106          * drop if we read to the end of the page.  */
1107         if(0 == ((from + *retlen) & 0x1ff))
1108         {
1109             DoC_WaitReady(this);
1110         }
1111
1112         return ret;
1113 }
1114
1115 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1116                   size_t * retlen, const u_char * buf,
1117                   u_char * eccbuf)
1118 {
1119         int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1120         unsigned long docptr;
1121         volatile char dummy;
1122         int len256 = 0;
1123         struct Nand *mychip;
1124
1125         docptr = this->virtadr;
1126
1127         /* Don't allow write past end of device */
1128         if (to >= this->totlen) {
1129                 puts ("Out of flash\n");
1130                 return DOC_EINVAL;
1131         }
1132
1133         /* Don't allow a single write to cross a 512-byte block boundary */
1134         if (to + len > ((to | 0x1ff) + 1))
1135                 len = ((to | 0x1ff) + 1) - to;
1136
1137         /* The ECC will not be calculated correctly if less than 512 is written */
1138         if (len != 0x200 && eccbuf)
1139                 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1140                        (long) to, (long) len);
1141
1142         /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1143
1144         /* Find the chip which is to be used and select it */
1145         mychip = &this->chips[shr(to, this->chipshift)];
1146
1147         if (this->curfloor != mychip->floor) {
1148                 DoC_SelectFloor(this, mychip->floor);
1149                 DoC_SelectChip(this, mychip->chip);
1150         } else if (this->curchip != mychip->chip) {
1151                 DoC_SelectChip(this, mychip->chip);
1152         }
1153
1154         this->curfloor = mychip->floor;
1155         this->curchip = mychip->chip;
1156
1157         /* Set device to main plane of flash */
1158         DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1159         DoC_Command(this,
1160                     (!this->page256
1161                      && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1162                     CDSN_CTRL_WP);
1163
1164         DoC_Command(this, NAND_CMD_SEQIN, 0);
1165         DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1166
1167         if (eccbuf) {
1168                 /* Prime the ECC engine */
1169                 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1170                 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1171         } else {
1172                 /* disable the ECC engine */
1173                 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1174                 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1175         }
1176
1177         /* treat crossing 256-byte sector for 2M x 8bits devices */
1178         if (this->page256 && to + len > (to | 0xff) + 1) {
1179                 len256 = (to | 0xff) + 1 - to;
1180                 DoC_WriteBuf(this, buf, len256);
1181
1182                 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1183
1184                 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1185                 /* There's an implicit DoC_WaitReady() in DoC_Command */
1186
1187                 dummy = ReadDOC(docptr, CDSNSlowIO);
1188                 DoC_Delay(this, 2);
1189
1190                 if (ReadDOC_(docptr, this->ioreg) & 1) {
1191                         puts ("Error programming flash\n");
1192                         /* Error in programming */
1193                         *retlen = 0;
1194                         return DOC_EIO;
1195                 }
1196
1197                 DoC_Command(this, NAND_CMD_SEQIN, 0);
1198                 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1199                             CDSN_CTRL_ECC_IO);
1200         }
1201
1202         DoC_WriteBuf(this, &buf[len256], len - len256);
1203
1204         if (eccbuf) {
1205                 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1206                          CDSNControl);
1207
1208                 if (DoC_is_Millennium(this)) {
1209                         WriteDOC(0, docptr, NOP);
1210                         WriteDOC(0, docptr, NOP);
1211                         WriteDOC(0, docptr, NOP);
1212                 } else {
1213                         WriteDOC_(0, docptr, this->ioreg);
1214                         WriteDOC_(0, docptr, this->ioreg);
1215                         WriteDOC_(0, docptr, this->ioreg);
1216                 }
1217
1218                 /* Read the ECC data through the DiskOnChip ECC logic */
1219                 for (di = 0; di < 6; di++) {
1220                         eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1221                 }
1222
1223                 /* Reset the ECC engine */
1224                 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1225
1226 #ifdef PSYCHO_DEBUG
1227                 printf
1228                     ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1229                      (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1230                      eccbuf[4], eccbuf[5]);
1231 #endif
1232         }
1233
1234         DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1235
1236         DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1237         /* There's an implicit DoC_WaitReady() in DoC_Command */
1238
1239         dummy = ReadDOC(docptr, CDSNSlowIO);
1240         DoC_Delay(this, 2);
1241
1242         if (ReadDOC_(docptr, this->ioreg) & 1) {
1243                 puts ("Error programming flash\n");
1244                 /* Error in programming */
1245                 *retlen = 0;
1246                 return DOC_EIO;
1247         }
1248
1249         /* Let the caller know we completed it */
1250         *retlen = len;
1251
1252         if (eccbuf) {
1253                 unsigned char x[8];
1254                 size_t dummy;
1255                 int ret;
1256
1257                 /* Write the ECC data to flash */
1258                 for (di=0; di<6; di++)
1259                         x[di] = eccbuf[di];
1260
1261                 x[6]=0x55;
1262                 x[7]=0x55;
1263
1264                 ret = doc_write_oob(this, to, 8, &dummy, x);
1265                 return ret;
1266         }
1267         return 0;
1268 }
1269
1270 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1271                  size_t * retlen, u_char * buf)
1272 {
1273         int len256 = 0, ret;
1274         unsigned long docptr;
1275         struct Nand *mychip;
1276
1277         docptr = this->virtadr;
1278
1279         mychip = &this->chips[shr(ofs, this->chipshift)];
1280
1281         if (this->curfloor != mychip->floor) {
1282                 DoC_SelectFloor(this, mychip->floor);
1283                 DoC_SelectChip(this, mychip->chip);
1284         } else if (this->curchip != mychip->chip) {
1285                 DoC_SelectChip(this, mychip->chip);
1286         }
1287         this->curfloor = mychip->floor;
1288         this->curchip = mychip->chip;
1289
1290         /* update address for 2M x 8bit devices. OOB starts on the second */
1291         /* page to maintain compatibility with doc_read_ecc. */
1292         if (this->page256) {
1293                 if (!(ofs & 0x8))
1294                         ofs += 0x100;
1295                 else
1296                         ofs -= 0x8;
1297         }
1298
1299         DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1300         DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1301
1302         /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1303         /* Note: datasheet says it should automaticaly wrap to the */
1304         /*       next OOB block, but it didn't work here. mf.      */
1305         if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1306                 len256 = (ofs | 0x7) + 1 - ofs;
1307                 DoC_ReadBuf(this, buf, len256);
1308
1309                 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1310                 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1311                             CDSN_CTRL_WP, 0);
1312         }
1313
1314         DoC_ReadBuf(this, &buf[len256], len - len256);
1315
1316         *retlen = len;
1317         /* Reading the full OOB data drops us off of the end of the page,
1318          * causing the flash device to go into busy mode, so we need
1319          * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1320
1321         ret = DoC_WaitReady(this);
1322
1323         return ret;
1324
1325 }
1326
1327 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1328                   size_t * retlen, const u_char * buf)
1329 {
1330         int len256 = 0;
1331         unsigned long docptr = this->virtadr;
1332         struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1333         volatile int dummy;
1334
1335 #ifdef PSYCHO_DEBUG
1336         printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1337                (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1338                buf[8], buf[9], buf[14],buf[15]);
1339 #endif
1340
1341         /* Find the chip which is to be used and select it */
1342         if (this->curfloor != mychip->floor) {
1343                 DoC_SelectFloor(this, mychip->floor);
1344                 DoC_SelectChip(this, mychip->chip);
1345         } else if (this->curchip != mychip->chip) {
1346                 DoC_SelectChip(this, mychip->chip);
1347         }
1348         this->curfloor = mychip->floor;
1349         this->curchip = mychip->chip;
1350
1351         /* disable the ECC engine */
1352         WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1353         WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1354
1355         /* Reset the chip, see Software Requirement 11.4 item 1. */
1356         DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1357
1358         /* issue the Read2 command to set the pointer to the Spare Data Area. */
1359         DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1360
1361         /* update address for 2M x 8bit devices. OOB starts on the second */
1362         /* page to maintain compatibility with doc_read_ecc. */
1363         if (this->page256) {
1364                 if (!(ofs & 0x8))
1365                         ofs += 0x100;
1366                 else
1367                         ofs -= 0x8;
1368         }
1369
1370         /* issue the Serial Data In command to initial the Page Program process */
1371         DoC_Command(this, NAND_CMD_SEQIN, 0);
1372         DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1373
1374         /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1375         /* Note: datasheet says it should automaticaly wrap to the */
1376         /*       next OOB block, but it didn't work here. mf.      */
1377         if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1378                 len256 = (ofs | 0x7) + 1 - ofs;
1379                 DoC_WriteBuf(this, buf, len256);
1380
1381                 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1382                 DoC_Command(this, NAND_CMD_STATUS, 0);
1383                 /* DoC_WaitReady() is implicit in DoC_Command */
1384
1385                 dummy = ReadDOC(docptr, CDSNSlowIO);
1386                 DoC_Delay(this, 2);
1387
1388                 if (ReadDOC_(docptr, this->ioreg) & 1) {
1389                         puts ("Error programming oob data\n");
1390                         /* There was an error */
1391                         *retlen = 0;
1392                         return DOC_EIO;
1393                 }
1394                 DoC_Command(this, NAND_CMD_SEQIN, 0);
1395                 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1396         }
1397
1398         DoC_WriteBuf(this, &buf[len256], len - len256);
1399
1400         DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1401         DoC_Command(this, NAND_CMD_STATUS, 0);
1402         /* DoC_WaitReady() is implicit in DoC_Command */
1403
1404         dummy = ReadDOC(docptr, CDSNSlowIO);
1405         DoC_Delay(this, 2);
1406
1407         if (ReadDOC_(docptr, this->ioreg) & 1) {
1408                 puts ("Error programming oob data\n");
1409                 /* There was an error */
1410                 *retlen = 0;
1411                 return DOC_EIO;
1412         }
1413
1414         *retlen = len;
1415         return 0;
1416
1417 }
1418
1419 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1420 {
1421         volatile int dummy;
1422         unsigned long docptr;
1423         struct Nand *mychip;
1424
1425         if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1426                 puts ("Offset and size must be sector aligned\n");
1427                 return DOC_EINVAL;
1428         }
1429
1430         docptr = this->virtadr;
1431
1432         /* FIXME: Do this in the background. Use timers or schedule_task() */
1433         while(len) {
1434                 mychip = &this->chips[shr(ofs, this->chipshift)];
1435
1436                 if (this->curfloor != mychip->floor) {
1437                         DoC_SelectFloor(this, mychip->floor);
1438                         DoC_SelectChip(this, mychip->chip);
1439                 } else if (this->curchip != mychip->chip) {
1440                         DoC_SelectChip(this, mychip->chip);
1441                 }
1442                 this->curfloor = mychip->floor;
1443                 this->curchip = mychip->chip;
1444
1445                 DoC_Command(this, NAND_CMD_ERASE1, 0);
1446                 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1447                 DoC_Command(this, NAND_CMD_ERASE2, 0);
1448
1449                 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1450
1451                 dummy = ReadDOC(docptr, CDSNSlowIO);
1452                 DoC_Delay(this, 2);
1453
1454                 if (ReadDOC_(docptr, this->ioreg) & 1) {
1455                         printf("Error erasing at 0x%lx\n", (long)ofs);
1456                         /* There was an error */
1457                         goto callback;
1458                 }
1459                 ofs += this->erasesize;
1460                 len -= this->erasesize;
1461         }
1462
1463  callback:
1464         return 0;
1465 }
1466
1467 static inline int doccheck(unsigned long potential, unsigned long physadr)
1468 {
1469         unsigned long window=potential;
1470         unsigned char tmp, ChipID;
1471 #ifndef DOC_PASSIVE_PROBE
1472         unsigned char tmp2;
1473 #endif
1474
1475         /* Routine copied from the Linux DOC driver */
1476
1477 #ifdef CFG_DOCPROBE_55AA
1478         /* Check for 0x55 0xAA signature at beginning of window,
1479            this is no longer true once we remove the IPL (for Millennium */
1480         if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1481                 return 0;
1482 #endif /* CFG_DOCPROBE_55AA */
1483
1484 #ifndef DOC_PASSIVE_PROBE
1485         /* It's not possible to cleanly detect the DiskOnChip - the
1486          * bootup procedure will put the device into reset mode, and
1487          * it's not possible to talk to it without actually writing
1488          * to the DOCControl register. So we store the current contents
1489          * of the DOCControl register's location, in case we later decide
1490          * that it's not a DiskOnChip, and want to put it back how we
1491          * found it.
1492          */
1493         tmp2 = ReadDOC(window, DOCControl);
1494
1495         /* Reset the DiskOnChip ASIC */
1496         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1497                  window, DOCControl);
1498         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1499                  window, DOCControl);
1500
1501         /* Enable the DiskOnChip ASIC */
1502         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1503                  window, DOCControl);
1504         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1505                  window, DOCControl);
1506 #endif /* !DOC_PASSIVE_PROBE */
1507
1508         ChipID = ReadDOC(window, ChipID);
1509
1510         switch (ChipID) {
1511         case DOC_ChipID_Doc2k:
1512                 /* Check the TOGGLE bit in the ECC register */
1513                 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1514                 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1515                                 return ChipID;
1516                 break;
1517
1518         case DOC_ChipID_DocMil:
1519                 /* Check the TOGGLE bit in the ECC register */
1520                 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1521                 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1522                                 return ChipID;
1523                 break;
1524
1525         default:
1526 #ifndef CFG_DOCPROBE_55AA
1527 /*
1528  * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1529  * the DOC is missing
1530  */
1531 # if 0
1532                 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1533                        ChipID, physadr);
1534 # endif
1535 #endif
1536 #ifndef DOC_PASSIVE_PROBE
1537                 /* Put back the contents of the DOCControl register, in case it's not
1538                  * actually a DiskOnChip.
1539                  */
1540                 WriteDOC(tmp2, window, DOCControl);
1541 #endif
1542                 return 0;
1543         }
1544
1545         puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1546
1547 #ifndef DOC_PASSIVE_PROBE
1548         /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1549         WriteDOC(tmp2, window, DOCControl);
1550 #endif
1551         return 0;
1552 }
1553
1554 void doc_probe(unsigned long physadr)
1555 {
1556         struct DiskOnChip *this = NULL;
1557         int i=0, ChipID;
1558
1559         if ((ChipID = doccheck(physadr, physadr))) {
1560
1561                 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1562                         if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1563                                 this = doc_dev_desc + i;
1564                                 break;
1565                         }
1566                 }
1567
1568                 if (!this) {
1569                         puts ("Cannot allocate memory for data structures.\n");
1570                         return;
1571                 }
1572
1573                 if (curr_device == -1)
1574                         curr_device = i;
1575
1576                 memset((char *)this, 0, sizeof(struct DiskOnChip));
1577
1578                 this->virtadr = physadr;
1579                 this->physadr = physadr;
1580                 this->ChipID = ChipID;
1581
1582                 DoC2k_init(this);
1583         } else {
1584                 puts ("No DiskOnChip found\n");
1585         }
1586 }
1587
1588 #endif /* (CONFIG_COMMANDS & CFG_CMD_DOC) */