drivers/mtd/nand/nand_base.c

   1 /*
   2  *  drivers/mtd/nand.c
   3  *
   4  *  Overview:
   5  *   This is the generic MTD driver for NAND flash devices. It should be
   6  *   capable of working with almost all NAND chips currently available.
   7  *   Basic support for AG-AND chips is provided.
   8  *
   9  *      Additional technical information is available on
  10  *      http://www.linux-mtd.infradead.org/doc/nand.html
  11  *
  12  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  13  *                2002-2006 Thomas Gleixner (tglx@linutronix.de)
  14  *
  15  *  Credits:
  16  *      David Woodhouse for adding multichip support
  17  *
  18  *      Aleph One Ltd. and Toby Churchill Ltd. for supporting the
  19  *      rework for 2K page size chips
  20  *
  21  *  TODO:
  22  *      Enable cached programming for 2k page size chips
  23  *      Check, if mtd->ecctype should be set to MTD_ECC_HW
  24  *      if we have HW ecc support.
  25  *      The AG-AND chips have nice features for speed improvement,
  26  *      which are not supported yet. Read / program 4 pages in one go.
  27  *      BBT table is not serialized, has to be fixed
  28  *
  29  * This program is free software; you can redistribute it and/or modify
  30  * it under the terms of the GNU General Public License version 2 as
  31  * published by the Free Software Foundation.
  32  *
  33  */
  34
  35 #include <common.h>
  36
  37 #define ENOTSUPP        524     /* Operation is not supported */
  38
  39 #include <malloc.h>
  40 #include <watchdog.h>
  41 #include <linux/err.h>
  42 #include <linux/compat.h>
  43 #include <linux/mtd/mtd.h>
  44 #include <linux/mtd/nand.h>
  45 #include <linux/mtd/nand_ecc.h>
  46 #include <linux/mtd/nand_bch.h>
  47
  48 #ifdef CONFIG_MTD_PARTITIONS
  49 #include <linux/mtd/partitions.h>
  50 #endif
  51
  52 #include <asm/io.h>
  53 #include <asm/errno.h>
  54
  55 /*
  56  * CONFIG_SYS_NAND_RESET_CNT is used as a timeout mechanism when resetting
  57  * a flash.  NAND flash is initialized prior to interrupts so standard timers
  58  * can't be used.  CONFIG_SYS_NAND_RESET_CNT should be set to a value
  59  * which is greater than (max NAND reset time / NAND status read time).
  60  * A conservative default of 200000 (500 us / 25 ns) is used as a default.
  61  */
  62 #ifndef CONFIG_SYS_NAND_RESET_CNT
  63 #define CONFIG_SYS_NAND_RESET_CNT 200000
  64 #endif
  65
  66 /* Define default oob placement schemes for large and small page devices */
  67 static struct nand_ecclayout nand_oob_8 = {
  68         .eccbytes = 3,
  69         .eccpos = {0, 1, 2},
  70         .oobfree = {
  71                 {.offset = 3,
  72                  .length = 2},
  73                 {.offset = 6,
  74                  .length = 2} }
  75 };
  76
  77 static struct nand_ecclayout nand_oob_16 = {
  78         .eccbytes = 6,
  79         .eccpos = {0, 1, 2, 3, 6, 7},
  80         .oobfree = {
  81                 {.offset = 8,
  82                  . length = 8} }
  83 };
  84
  85 static struct nand_ecclayout nand_oob_64 = {
  86         .eccbytes = 24,
  87         .eccpos = {
  88                    40, 41, 42, 43, 44, 45, 46, 47,
  89                    48, 49, 50, 51, 52, 53, 54, 55,
  90                    56, 57, 58, 59, 60, 61, 62, 63},
  91         .oobfree = {
  92                 {.offset = 2,
  93                  .length = 38} }
  94 };
  95
  96 static struct nand_ecclayout nand_oob_128 = {
  97         .eccbytes = 48,
  98         .eccpos = {
  99                    80, 81, 82, 83, 84, 85, 86, 87,
 100                    88, 89, 90, 91, 92, 93, 94, 95,
 101                    96, 97, 98, 99, 100, 101, 102, 103,
 102                    104, 105, 106, 107, 108, 109, 110, 111,
 103                    112, 113, 114, 115, 116, 117, 118, 119,
 104                    120, 121, 122, 123, 124, 125, 126, 127},
 105         .oobfree = {
 106                 {.offset = 2,
 107                  .length = 78} }
 108 };
 109
 110 static int nand_get_device(struct nand_chip *chip, struct mtd_info *mtd,
 111                            int new_state);
 112
 113 static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
 114                              struct mtd_oob_ops *ops);
 115
 116 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this);
 117
 118 static int check_offs_len(struct mtd_info *mtd,
 119                                         loff_t ofs, uint64_t len)
 120 {
 121         struct nand_chip *chip = mtd->priv;
 122         int ret = 0;
 123
 124         /* Start address must align on block boundary */
 125         if (ofs & ((1 << chip->phys_erase_shift) - 1)) {
 126                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Unaligned address\n", __func__);
 127                 ret = -EINVAL;
 128         }
 129
 130         /* Length must align on block boundary */
 131         if (len & ((1 << chip->phys_erase_shift) - 1)) {
 132                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Length not block aligned\n",
 133                                         __func__);
 134                 ret = -EINVAL;
 135         }
 136
 137         /* Do not allow past end of device */
 138         if (ofs + len > mtd->size) {
 139                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Past end of device\n",
 140                                         __func__);
 141                 ret = -EINVAL;
 142         }
 143
 144         return ret;
 145 }
 146
 147 /**
 148  * nand_release_device - [GENERIC] release chip
 149  * @mtd:        MTD device structure
 150  *
 151  * Deselect, release chip lock and wake up anyone waiting on the device
 152  */
 153 static void nand_release_device(struct mtd_info *mtd)
 154 {
 155         struct nand_chip *chip = mtd->priv;
 156
 157         /* De-select the NAND device */
 158         chip->select_chip(mtd, -1);
 159 }
 160
 161 /**
 162  * nand_read_byte - [DEFAULT] read one byte from the chip
 163  * @mtd:        MTD device structure
 164  *
 165  * Default read function for 8bit buswith
 166  */
 167 uint8_t nand_read_byte(struct mtd_info *mtd)
 168 {
 169         struct nand_chip *chip = mtd->priv;
 170         return readb(chip->IO_ADDR_R);
 171 }
 172
 173 /**
 174  * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
 175  * @mtd:        MTD device structure
 176  *
 177  * Default read function for 16bit buswith with
 178  * endianess conversion
 179  */
 180 static uint8_t nand_read_byte16(struct mtd_info *mtd)
 181 {
 182         struct nand_chip *chip = mtd->priv;
 183         return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R));
 184 }
 185
 186 /**
 187  * nand_read_word - [DEFAULT] read one word from the chip
 188  * @mtd:        MTD device structure
 189  *
 190  * Default read function for 16bit buswith without
 191  * endianess conversion
 192  */
 193 static u16 nand_read_word(struct mtd_info *mtd)
 194 {
 195         struct nand_chip *chip = mtd->priv;
 196         return readw(chip->IO_ADDR_R);
 197 }
 198
 199 /**
 200  * nand_select_chip - [DEFAULT] control CE line
 201  * @mtd:        MTD device structure
 202  * @chipnr:     chipnumber to select, -1 for deselect
 203  *
 204  * Default select function for 1 chip devices.
 205  */
 206 static void nand_select_chip(struct mtd_info *mtd, int chipnr)
 207 {
 208         struct nand_chip *chip = mtd->priv;
 209
 210         switch (chipnr) {
 211         case -1:
 212                 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
 213                 break;
 214         case 0:
 215                 break;
 216
 217         default:
 218                 BUG();
 219         }
 220 }
 221
 222 /**
 223  * nand_write_buf - [DEFAULT] write buffer to chip
 224  * @mtd:        MTD device structure
 225  * @buf:        data buffer
 226  * @len:        number of bytes to write
 227  *
 228  * Default write function for 8bit buswith
 229  */
 230 void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 231 {
 232         int i;
 233         struct nand_chip *chip = mtd->priv;
 234
 235         for (i = 0; i < len; i++)
 236                 writeb(buf[i], chip->IO_ADDR_W);
 237 }
 238
 239 /**
 240  * nand_read_buf - [DEFAULT] read chip data into buffer
 241  * @mtd:        MTD device structure
 242  * @buf:        buffer to store date
 243  * @len:        number of bytes to read
 244  *
 245  * Default read function for 8bit buswith
 246  */
 247 void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 248 {
 249         int i;
 250         struct nand_chip *chip = mtd->priv;
 251
 252         for (i = 0; i < len; i++)
 253                 buf[i] = readb(chip->IO_ADDR_R);
 254 }
 255
 256 /**
 257  * nand_verify_buf - [DEFAULT] Verify chip data against buffer
 258  * @mtd:        MTD device structure
 259  * @buf:        buffer containing the data to compare
 260  * @len:        number of bytes to compare
 261  *
 262  * Default verify function for 8bit buswith
 263  */
 264 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 265 {
 266         int i;
 267         struct nand_chip *chip = mtd->priv;
 268
 269         for (i = 0; i < len; i++)
 270                 if (buf[i] != readb(chip->IO_ADDR_R))
 271                         return -EFAULT;
 272         return 0;
 273 }
 274
 275 /**
 276  * nand_write_buf16 - [DEFAULT] write buffer to chip
 277  * @mtd:        MTD device structure
 278  * @buf:        data buffer
 279  * @len:        number of bytes to write
 280  *
 281  * Default write function for 16bit buswith
 282  */
 283 void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
 284 {
 285         int i;
 286         struct nand_chip *chip = mtd->priv;
 287         u16 *p = (u16 *) buf;
 288         len >>= 1;
 289
 290         for (i = 0; i < len; i++)
 291                 writew(p[i], chip->IO_ADDR_W);
 292
 293 }
 294
 295 /**
 296  * nand_read_buf16 - [DEFAULT] read chip data into buffer
 297  * @mtd:        MTD device structure
 298  * @buf:        buffer to store date
 299  * @len:        number of bytes to read
 300  *
 301  * Default read function for 16bit buswith
 302  */
 303 void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
 304 {
 305         int i;
 306         struct nand_chip *chip = mtd->priv;
 307         u16 *p = (u16 *) buf;
 308         len >>= 1;
 309
 310         for (i = 0; i < len; i++)
 311                 p[i] = readw(chip->IO_ADDR_R);
 312 }
 313
 314 /**
 315  * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
 316  * @mtd:        MTD device structure
 317  * @buf:        buffer containing the data to compare
 318  * @len:        number of bytes to compare
 319  *
 320  * Default verify function for 16bit buswith
 321  */
 322 static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
 323 {
 324         int i;
 325         struct nand_chip *chip = mtd->priv;
 326         u16 *p = (u16 *) buf;
 327         len >>= 1;
 328
 329         for (i = 0; i < len; i++)
 330                 if (p[i] != readw(chip->IO_ADDR_R))
 331                         return -EFAULT;
 332
 333         return 0;
 334 }
 335
 336 /**
 337  * nand_block_bad - [DEFAULT] Read bad block marker from the chip
 338  * @mtd:        MTD device structure
 339  * @ofs:        offset from device start
 340  * @getchip:    0, if the chip is already selected
 341  *
 342  * Check, if the block is bad.
 343  */
 344 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
 345 {
 346         int page, chipnr, res = 0;
 347         struct nand_chip *chip = mtd->priv;
 348         u16 bad;
 349
 350         if (chip->options & NAND_BBT_SCANLASTPAGE)
 351                 ofs += mtd->erasesize - mtd->writesize;
 352
 353         page = (int)(ofs >> chip->page_shift) & chip->pagemask;
 354
 355         if (getchip) {
 356                 chipnr = (int)(ofs >> chip->chip_shift);
 357
 358                 nand_get_device(chip, mtd, FL_READING);
 359
 360                 /* Select the NAND device */
 361                 chip->select_chip(mtd, chipnr);
 362         }
 363
 364         if (chip->options & NAND_BUSWIDTH_16) {
 365                 chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos & 0xFE,
 366                               page);
 367                 bad = cpu_to_le16(chip->read_word(mtd));
 368                 if (chip->badblockpos & 0x1)
 369                         bad >>= 8;
 370                 else
 371                         bad &= 0xFF;
 372         } else {
 373                 chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, page);
 374                 bad = chip->read_byte(mtd);
 375         }
 376
 377         if (likely(chip->badblockbits == 8))
 378                 res = bad != 0xFF;
 379         else
 380                 res = hweight8(bad) < chip->badblockbits;
 381
 382         if (getchip)
 383                 nand_release_device(mtd);
 384
 385         return res;
 386 }
 387
 388 /**
 389  * nand_default_block_markbad - [DEFAULT] mark a block bad
 390  * @mtd:        MTD device structure
 391  * @ofs:        offset from device start
 392  *
 393  * This is the default implementation, which can be overridden by
 394  * a hardware specific driver.
 395 */
 396 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
 397 {
 398         struct nand_chip *chip = mtd->priv;
 399         uint8_t buf[2] = { 0, 0 };
 400         int block, ret, i = 0;
 401
 402         if (chip->options & NAND_BBT_SCANLASTPAGE)
 403                 ofs += mtd->erasesize - mtd->writesize;
 404
 405         /* Get block number */
 406         block = (int)(ofs >> chip->bbt_erase_shift);
 407         if (chip->bbt)
 408                 chip->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
 409
 410         /* Do we have a flash based bad block table ? */
 411         if (chip->options & NAND_USE_FLASH_BBT)
 412                 ret = nand_update_bbt(mtd, ofs);
 413         else {
 414                 nand_get_device(chip, mtd, FL_WRITING);
 415
 416                 /* Write to first two pages and to byte 1 and 6 if necessary.
 417                  * If we write to more than one location, the first error
 418                  * encountered quits the procedure. We write two bytes per
 419                  * location, so we dont have to mess with 16 bit access.
 420                  */
 421                 do {
 422                         chip->ops.len = chip->ops.ooblen = 2;
 423                         chip->ops.datbuf = NULL;
 424                         chip->ops.oobbuf = buf;
 425                         chip->ops.ooboffs = chip->badblockpos & ~0x01;
 426
 427                         ret = nand_do_write_oob(mtd, ofs, &chip->ops);
 428
 429                         if (!ret && (chip->options & NAND_BBT_SCANBYTE1AND6)) {
 430                                 chip->ops.ooboffs = NAND_SMALL_BADBLOCK_POS
 431                                         & ~0x01;
 432                                 ret = nand_do_write_oob(mtd, ofs, &chip->ops);
 433                         }
 434                         i++;
 435                         ofs += mtd->writesize;
 436                 } while (!ret && (chip->options & NAND_BBT_SCAN2NDPAGE) &&
 437                                 i < 2);
 438
 439                 nand_release_device(mtd);
 440         }
 441         if (!ret)
 442                 mtd->ecc_stats.badblocks++;
 443
 444         return ret;
 445 }
 446
 447 /**
 448  * nand_check_wp - [GENERIC] check if the chip is write protected
 449  * @mtd:        MTD device structure
 450  * Check, if the device is write protected
 451  *
 452  * The function expects, that the device is already selected
 453  */
 454 static int nand_check_wp(struct mtd_info *mtd)
 455 {
 456         struct nand_chip *chip = mtd->priv;
 457
 458         /* broken xD cards report WP despite being writable */
 459         if (chip->options & NAND_BROKEN_XD)
 460                 return 0;
 461
 462         /* Check the WP bit */
 463         chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
 464         return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
 465 }
 466
 467 /**
 468  * nand_block_checkbad - [GENERIC] Check if a block is marked bad
 469  * @mtd:        MTD device structure
 470  * @ofs:        offset from device start
 471  * @getchip:    0, if the chip is already selected
 472  * @allowbbt:   1, if its allowed to access the bbt area
 473  *
 474  * Check, if the block is bad. Either by reading the bad block table or
 475  * calling of the scan function.
 476  */
 477 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
 478                                int allowbbt)
 479 {
 480         struct nand_chip *chip = mtd->priv;
 481
 482         if (!(chip->options & NAND_BBT_SCANNED)) {
 483                 chip->options |= NAND_BBT_SCANNED;
 484                 chip->scan_bbt(mtd);
 485         }
 486
 487         if (!chip->bbt)
 488                 return chip->block_bad(mtd, ofs, getchip);
 489
 490         /* Return info from the table */
 491         return nand_isbad_bbt(mtd, ofs, allowbbt);
 492 }
 493
 494 /*
 495  * Wait for the ready pin, after a command
 496  * The timeout is catched later.
 497  */
 498 void nand_wait_ready(struct mtd_info *mtd)
 499 {
 500         struct nand_chip *chip = mtd->priv;
 501         u32 timeo = (CONFIG_SYS_HZ * 20) / 1000;
 502         u32 time_start;
 503
 504         time_start = get_timer(0);
 505
 506         /* wait until command is processed or timeout occures */
 507         while (get_timer(time_start) < timeo) {
 508                 if (chip->dev_ready)
 509                         if (chip->dev_ready(mtd))
 510                                 break;
 511         }
 512 }
 513
 514 /**
 515  * nand_command - [DEFAULT] Send command to NAND device
 516  * @mtd:        MTD device structure
 517  * @command:    the command to be sent
 518  * @column:     the column address for this command, -1 if none
 519  * @page_addr:  the page address for this command, -1 if none
 520  *
 521  * Send command to NAND device. This function is used for small page
 522  * devices (256/512 Bytes per page)
 523  */
 524 static void nand_command(struct mtd_info *mtd, unsigned int command,
 525                          int column, int page_addr)
 526 {
 527         register struct nand_chip *chip = mtd->priv;
 528         int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
 529         uint32_t rst_sts_cnt = CONFIG_SYS_NAND_RESET_CNT;
 530
 531         /*
 532          * Write out the command to the device.
 533          */
 534         if (command == NAND_CMD_SEQIN) {
 535                 int readcmd;
 536
 537                 if (column >= mtd->writesize) {
 538                         /* OOB area */
 539                         column -= mtd->writesize;
 540                         readcmd = NAND_CMD_READOOB;
 541                 } else if (column < 256) {
 542                         /* First 256 bytes --> READ0 */
 543                         readcmd = NAND_CMD_READ0;
 544                 } else {
 545                         column -= 256;
 546                         readcmd = NAND_CMD_READ1;
 547                 }
 548                 chip->cmd_ctrl(mtd, readcmd, ctrl);
 549                 ctrl &= ~NAND_CTRL_CHANGE;
 550         }
 551         chip->cmd_ctrl(mtd, command, ctrl);
 552
 553         /*
 554          * Address cycle, when necessary
 555          */
 556         ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
 557         /* Serially input address */
 558         if (column != -1) {
 559                 /* Adjust columns for 16 bit buswidth */
 560                 if (chip->options & NAND_BUSWIDTH_16)
 561                         column >>= 1;
 562                 chip->cmd_ctrl(mtd, column, ctrl);
 563                 ctrl &= ~NAND_CTRL_CHANGE;
 564         }
 565         if (page_addr != -1) {
 566                 chip->cmd_ctrl(mtd, page_addr, ctrl);
 567                 ctrl &= ~NAND_CTRL_CHANGE;
 568                 chip->cmd_ctrl(mtd, page_addr >> 8, ctrl);
 569                 /* One more address cycle for devices > 32MiB */
 570                 if (chip->chipsize > (32 << 20))
 571                         chip->cmd_ctrl(mtd, page_addr >> 16, ctrl);
 572         }
 573         chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 574
 575         /*
 576          * program and erase have their own busy handlers
 577          * status and sequential in needs no delay
 578          */
 579         switch (command) {
 580
 581         case NAND_CMD_PAGEPROG:
 582         case NAND_CMD_ERASE1:
 583         case NAND_CMD_ERASE2:
 584         case NAND_CMD_SEQIN:
 585         case NAND_CMD_STATUS:
 586                 return;
 587
 588         case NAND_CMD_RESET:
 589                 if (chip->dev_ready)
 590                         break;
 591                 udelay(chip->chip_delay);
 592                 chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
 593                                NAND_CTRL_CLE | NAND_CTRL_CHANGE);
 594                 chip->cmd_ctrl(mtd,
 595                                NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 596                 while (!(chip->read_byte(mtd) & NAND_STATUS_READY) &&
 597                         (rst_sts_cnt--));
 598                 return;
 599
 600                 /* This applies to read commands */
 601         default:
 602                 /*
 603                  * If we don't have access to the busy pin, we apply the given
 604                  * command delay
 605                  */
 606                 if (!chip->dev_ready) {
 607                         udelay(chip->chip_delay);
 608                         return;
 609                 }
 610         }
 611         /* Apply this short delay always to ensure that we do wait tWB in
 612          * any case on any machine. */
 613         ndelay(100);
 614
 615         nand_wait_ready(mtd);
 616 }
 617
 618 /**
 619  * nand_command_lp - [DEFAULT] Send command to NAND large page device
 620  * @mtd:        MTD device structure
 621  * @command:    the command to be sent
 622  * @column:     the column address for this command, -1 if none
 623  * @page_addr:  the page address for this command, -1 if none
 624  *
 625  * Send command to NAND device. This is the version for the new large page
 626  * devices We dont have the separate regions as we have in the small page
 627  * devices.  We must emulate NAND_CMD_READOOB to keep the code compatible.
 628  */
 629 static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
 630                             int column, int page_addr)
 631 {
 632         register struct nand_chip *chip = mtd->priv;
 633         uint32_t rst_sts_cnt = CONFIG_SYS_NAND_RESET_CNT;
 634
 635         /* Emulate NAND_CMD_READOOB */
 636         if (command == NAND_CMD_READOOB) {
 637                 column += mtd->writesize;
 638                 command = NAND_CMD_READ0;
 639         }
 640
 641         /* Command latch cycle */
 642         chip->cmd_ctrl(mtd, command & 0xff,
 643                        NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
 644
 645         if (column != -1 || page_addr != -1) {
 646                 int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
 647
 648                 /* Serially input address */
 649                 if (column != -1) {
 650                         /* Adjust columns for 16 bit buswidth */
 651                         if (chip->options & NAND_BUSWIDTH_16)
 652                                 column >>= 1;
 653                         chip->cmd_ctrl(mtd, column, ctrl);
 654                         ctrl &= ~NAND_CTRL_CHANGE;
 655                         chip->cmd_ctrl(mtd, column >> 8, ctrl);
 656                 }
 657                 if (page_addr != -1) {
 658                         chip->cmd_ctrl(mtd, page_addr, ctrl);
 659                         chip->cmd_ctrl(mtd, page_addr >> 8,
 660                                        NAND_NCE | NAND_ALE);
 661                         /* One more address cycle for devices > 128MiB */
 662                         if (chip->chipsize > (128 << 20))
 663                                 chip->cmd_ctrl(mtd, page_addr >> 16,
 664                                                NAND_NCE | NAND_ALE);
 665                 }
 666         }
 667         chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 668
 669         /*
 670          * program and erase have their own busy handlers
 671          * status, sequential in, and deplete1 need no delay
 672          */
 673         switch (command) {
 674
 675         case NAND_CMD_CACHEDPROG:
 676         case NAND_CMD_PAGEPROG:
 677         case NAND_CMD_ERASE1:
 678         case NAND_CMD_ERASE2:
 679         case NAND_CMD_SEQIN:
 680         case NAND_CMD_RNDIN:
 681         case NAND_CMD_STATUS:
 682         case NAND_CMD_DEPLETE1:
 683                 return;
 684
 685                 /*
 686                  * read error status commands require only a short delay
 687                  */
 688         case NAND_CMD_STATUS_ERROR:
 689         case NAND_CMD_STATUS_ERROR0:
 690         case NAND_CMD_STATUS_ERROR1:
 691         case NAND_CMD_STATUS_ERROR2:
 692         case NAND_CMD_STATUS_ERROR3:
 693                 udelay(chip->chip_delay);
 694                 return;
 695
 696         case NAND_CMD_RESET:
 697                 if (chip->dev_ready)
 698                         break;
 699                 udelay(chip->chip_delay);
 700                 chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
 701                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
 702                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
 703                                NAND_NCE | NAND_CTRL_CHANGE);
 704                 while (!(chip->read_byte(mtd) & NAND_STATUS_READY) &&
 705                         (rst_sts_cnt--));
 706                 return;
 707
 708         case NAND_CMD_RNDOUT:
 709                 /* No ready / busy check necessary */
 710                 chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART,
 711                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
 712                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
 713                                NAND_NCE | NAND_CTRL_CHANGE);
 714                 return;
 715
 716         case NAND_CMD_READ0:
 717                 chip->cmd_ctrl(mtd, NAND_CMD_READSTART,
 718                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
 719                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
 720                                NAND_NCE | NAND_CTRL_CHANGE);
 721
 722                 /* This applies to read commands */
 723         default:
 724                 /*
 725                  * If we don't have access to the busy pin, we apply the given
 726                  * command delay
 727                  */
 728                 if (!chip->dev_ready) {
 729                         udelay(chip->chip_delay);
 730                         return;
 731                 }
 732         }
 733
 734         /* Apply this short delay always to ensure that we do wait tWB in
 735          * any case on any machine. */
 736         ndelay(100);
 737
 738         nand_wait_ready(mtd);
 739 }
 740
 741 /**
 742  * nand_get_device - [GENERIC] Get chip for selected access
 743  * @chip:       the nand chip descriptor
 744  * @mtd:        MTD device structure
 745  * @new_state:  the state which is requested
 746  *
 747  * Get the device and lock it for exclusive access
 748  */
 749 static int
 750 nand_get_device(struct nand_chip *chip, struct mtd_info *mtd, int new_state)
 751 {
 752         chip->state = new_state;
 753         return 0;
 754 }
 755
 756 /**
 757  * nand_wait - [DEFAULT]  wait until the command is done
 758  * @mtd:        MTD device structure
 759  * @chip:       NAND chip structure
 760  *
 761  * Wait for command done. This applies to erase and program only
 762  * Erase can take up to 400ms and program up to 20ms according to
 763  * general NAND and SmartMedia specs
 764  */
 765 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
 766 {
 767         unsigned long   timeo;
 768         int state = chip->state;
 769         u32 time_start;
 770
 771         if (state == FL_ERASING)
 772                 timeo = (CONFIG_SYS_HZ * 400) / 1000;
 773         else
 774                 timeo = (CONFIG_SYS_HZ * 20) / 1000;
 775
 776         if ((state == FL_ERASING) && (chip->options & NAND_IS_AND))
 777                 chip->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
 778         else
 779                 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
 780
 781         time_start = get_timer(0);
 782
 783         while (1) {
 784                 if (get_timer(time_start) > timeo) {
 785                         printf("Timeout!");
 786                         return 0x01;
 787                 }
 788
 789                 if (chip->dev_ready) {
 790                         if (chip->dev_ready(mtd))
 791                                 break;
 792                 } else {
 793                         if (chip->read_byte(mtd) & NAND_STATUS_READY)
 794                                 break;
 795                 }
 796         }
 797 #ifdef PPCHAMELON_NAND_TIMER_HACK
 798         time_start = get_timer(0);
 799         while (get_timer(time_start) < 10)
 800                 ;
 801 #endif /*  PPCHAMELON_NAND_TIMER_HACK */
 802
 803         return (int)chip->read_byte(mtd);
 804 }
 805
 806 /**
 807  * nand_read_page_raw - [Intern] read raw page data without ecc
 808  * @mtd:        mtd info structure
 809  * @chip:       nand chip info structure
 810  * @buf:        buffer to store read data
 811  * @page:       page number to read
 812  *
 813  * Not for syndrome calculating ecc controllers, which use a special oob layout
 814  */
 815 static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
 816                               uint8_t *buf, int page)
 817 {
 818         chip->read_buf(mtd, buf, mtd->writesize);
 819         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
 820         return 0;
 821 }
 822
 823 /**
 824  * nand_read_page_raw_syndrome - [Intern] read raw page data without ecc
 825  * @mtd:        mtd info structure
 826  * @chip:       nand chip info structure
 827  * @buf:        buffer to store read data
 828  * @page:       page number to read
 829  *
 830  * We need a special oob layout and handling even when OOB isn't used.
 831  */
 832 static int nand_read_page_raw_syndrome(struct mtd_info *mtd,
 833                                         struct nand_chip *chip,
 834                                         uint8_t *buf, int page)
 835 {
 836         int eccsize = chip->ecc.size;
 837         int eccbytes = chip->ecc.bytes;
 838         uint8_t *oob = chip->oob_poi;
 839         int steps, size;
 840
 841         for (steps = chip->ecc.steps; steps > 0; steps--) {
 842                 chip->read_buf(mtd, buf, eccsize);
 843                 buf += eccsize;
 844
 845                 if (chip->ecc.prepad) {
 846                         chip->read_buf(mtd, oob, chip->ecc.prepad);
 847                         oob += chip->ecc.prepad;
 848                 }
 849
 850                 chip->read_buf(mtd, oob, eccbytes);
 851                 oob += eccbytes;
 852
 853                 if (chip->ecc.postpad) {
 854                         chip->read_buf(mtd, oob, chip->ecc.postpad);
 855                         oob += chip->ecc.postpad;
 856                 }
 857         }
 858
 859         size = mtd->oobsize - (oob - chip->oob_poi);
 860         if (size)
 861                 chip->read_buf(mtd, oob, size);
 862
 863         return 0;
 864 }
 865
 866 /**
 867  * nand_read_page_swecc - [REPLACABLE] software ecc based page read function
 868  * @mtd:        mtd info structure
 869  * @chip:       nand chip info structure
 870  * @buf:        buffer to store read data
 871  * @page:       page number to read
 872  */
 873 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
 874                                 uint8_t *buf, int page)
 875 {
 876         int i, eccsize = chip->ecc.size;
 877         int eccbytes = chip->ecc.bytes;
 878         int eccsteps = chip->ecc.steps;
 879         uint8_t *p = buf;
 880         uint8_t *ecc_calc = chip->buffers->ecccalc;
 881         uint8_t *ecc_code = chip->buffers->ecccode;
 882         uint32_t *eccpos = chip->ecc.layout->eccpos;
 883
 884         chip->ecc.read_page_raw(mtd, chip, buf, page);
 885
 886         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
 887                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
 888
 889         for (i = 0; i < chip->ecc.total; i++)
 890                 ecc_code[i] = chip->oob_poi[eccpos[i]];
 891
 892         eccsteps = chip->ecc.steps;
 893         p = buf;
 894
 895         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 896                 int stat;
 897
 898                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
 899                 if (stat < 0)
 900                         mtd->ecc_stats.failed++;
 901                 else
 902                         mtd->ecc_stats.corrected += stat;
 903         }
 904         return 0;
 905 }
 906
 907 /**
 908  * nand_read_subpage - [REPLACABLE] software ecc based sub-page read function
 909  * @mtd:        mtd info structure
 910  * @chip:       nand chip info structure
 911  * @data_offs:  offset of requested data within the page
 912  * @readlen:    data length
 913  * @bufpoi:     buffer to store read data
 914  */
 915 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
 916                         uint32_t data_offs, uint32_t readlen, uint8_t *bufpoi)
 917 {
 918         int start_step, end_step, num_steps;
 919         uint32_t *eccpos = chip->ecc.layout->eccpos;
 920         uint8_t *p;
 921         int data_col_addr, i, gaps = 0;
 922         int datafrag_len, eccfrag_len, aligned_len, aligned_pos;
 923         int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1;
 924         int index = 0;
 925
 926         /* Column address wihin the page aligned to ECC size (256bytes). */
 927         start_step = data_offs / chip->ecc.size;
 928         end_step = (data_offs + readlen - 1) / chip->ecc.size;
 929         num_steps = end_step - start_step + 1;
 930
 931         /* Data size aligned to ECC ecc.size*/
 932         datafrag_len = num_steps * chip->ecc.size;
 933         eccfrag_len = num_steps * chip->ecc.bytes;
 934
 935         data_col_addr = start_step * chip->ecc.size;
 936         /* If we read not a page aligned data */
 937         if (data_col_addr != 0)
 938                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1);
 939
 940         p = bufpoi + data_col_addr;
 941         chip->read_buf(mtd, p, datafrag_len);
 942
 943         /* Calculate  ECC */
 944         for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
 945                 chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]);
 946
 947         /* The performance is faster if to position offsets
 948            according to ecc.pos. Let make sure here that
 949            there are no gaps in ecc positions */
 950         for (i = 0; i < eccfrag_len - 1; i++) {
 951                 if (eccpos[i + start_step * chip->ecc.bytes] + 1 !=
 952                         eccpos[i + start_step * chip->ecc.bytes + 1]) {
 953                         gaps = 1;
 954                         break;
 955                 }
 956         }
 957         if (gaps) {
 958                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1);
 959                 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
 960         } else {
 961                 /* send the command to read the particular ecc bytes */
 962                 /* take care about buswidth alignment in read_buf */
 963                 index = start_step * chip->ecc.bytes;
 964
 965                 aligned_pos = eccpos[index] & ~(busw - 1);
 966                 aligned_len = eccfrag_len;
 967                 if (eccpos[index] & (busw - 1))
 968                         aligned_len++;
 969                 if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1))
 970                         aligned_len++;
 971
 972                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
 973                                         mtd->writesize + aligned_pos, -1);
 974                 chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len);
 975         }
 976
 977         for (i = 0; i < eccfrag_len; i++)
 978                 chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]];
 979
 980         p = bufpoi + data_col_addr;
 981         for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
 982                 int stat;
 983
 984                 stat = chip->ecc.correct(mtd, p,
 985                         &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);
 986                 if (stat < 0)
 987                         mtd->ecc_stats.failed++;
 988                 else
 989                         mtd->ecc_stats.corrected += stat;
 990         }
 991         return 0;
 992 }
 993
 994 /**
 995  * nand_read_page_hwecc - [REPLACABLE] hardware ecc based page read function
 996  * @mtd:        mtd info structure
 997  * @chip:       nand chip info structure
 998  * @buf:        buffer to store read data
 999  * @page:       page number to read
1000  *
1001  * Not for syndrome calculating ecc controllers which need a special oob layout
1002  */
1003 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
1004                                 uint8_t *buf, int page)
1005 {
1006         int i, eccsize = chip->ecc.size;
1007         int eccbytes = chip->ecc.bytes;
1008         int eccsteps = chip->ecc.steps;
1009         uint8_t *p = buf;
1010         uint8_t *ecc_calc = chip->buffers->ecccalc;
1011         uint8_t *ecc_code = chip->buffers->ecccode;
1012         uint32_t *eccpos = chip->ecc.layout->eccpos;
1013
1014         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1015                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1016                 chip->read_buf(mtd, p, eccsize);
1017                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1018         }
1019         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1020
1021         for (i = 0; i < chip->ecc.total; i++)
1022                 ecc_code[i] = chip->oob_poi[eccpos[i]];
1023
1024         eccsteps = chip->ecc.steps;
1025         p = buf;
1026
1027         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1028                 int stat;
1029
1030                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
1031                 if (stat < 0)
1032                         mtd->ecc_stats.failed++;
1033                 else
1034                         mtd->ecc_stats.corrected += stat;
1035         }
1036         return 0;
1037 }
1038
1039 /**
1040  * nand_read_page_hwecc_oob_first - [REPLACABLE] hw ecc, read oob first
1041  * @mtd:        mtd info structure
1042  * @chip:       nand chip info structure
1043  * @buf:        buffer to store read data
1044  * @page:       page number to read
1045  *
1046  * Hardware ECC for large page chips, require OOB to be read first.
1047  * For this ECC mode, the write_page method is re-used from ECC_HW.
1048  * These methods read/write ECC from the OOB area, unlike the
1049  * ECC_HW_SYNDROME support with multiple ECC steps, follows the
1050  * "infix ECC" scheme and reads/writes ECC from the data area, by
1051  * overwriting the NAND manufacturer bad block markings.
1052  */
1053 static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
1054         struct nand_chip *chip, uint8_t *buf, int page)
1055 {
1056         int i, eccsize = chip->ecc.size;
1057         int eccbytes = chip->ecc.bytes;
1058         int eccsteps = chip->ecc.steps;
1059         uint8_t *p = buf;
1060         uint8_t *ecc_code = chip->buffers->ecccode;
1061         uint32_t *eccpos = chip->ecc.layout->eccpos;
1062         uint8_t *ecc_calc = chip->buffers->ecccalc;
1063
1064         /* Read the OOB area first */
1065         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
1066         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1067         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
1068
1069         for (i = 0; i < chip->ecc.total; i++)
1070                 ecc_code[i] = chip->oob_poi[eccpos[i]];
1071
1072         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1073                 int stat;
1074
1075                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1076                 chip->read_buf(mtd, p, eccsize);
1077                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1078
1079                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);
1080                 if (stat < 0)
1081                         mtd->ecc_stats.failed++;
1082                 else
1083                         mtd->ecc_stats.corrected += stat;
1084         }
1085         return 0;
1086 }
1087
1088 /**
1089  * nand_read_page_syndrome - [REPLACABLE] hardware ecc syndrom based page read
1090  * @mtd:        mtd info structure
1091  * @chip:       nand chip info structure
1092  * @buf:        buffer to store read data
1093  * @page:       page number to read
1094  *
1095  * The hw generator calculates the error syndrome automatically. Therefor
1096  * we need a special oob layout and handling.
1097  */
1098 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
1099                                    uint8_t *buf, int page)
1100 {
1101         int i, eccsize = chip->ecc.size;
1102         int eccbytes = chip->ecc.bytes;
1103         int eccsteps = chip->ecc.steps;
1104         uint8_t *p = buf;
1105         uint8_t *oob = chip->oob_poi;
1106
1107         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1108                 int stat;
1109
1110                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1111                 chip->read_buf(mtd, p, eccsize);
1112
1113                 if (chip->ecc.prepad) {
1114                         chip->read_buf(mtd, oob, chip->ecc.prepad);
1115                         oob += chip->ecc.prepad;
1116                 }
1117
1118                 chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
1119                 chip->read_buf(mtd, oob, eccbytes);
1120                 stat = chip->ecc.correct(mtd, p, oob, NULL);
1121
1122                 if (stat < 0)
1123                         mtd->ecc_stats.failed++;
1124                 else
1125                         mtd->ecc_stats.corrected += stat;
1126
1127                 oob += eccbytes;
1128
1129                 if (chip->ecc.postpad) {
1130                         chip->read_buf(mtd, oob, chip->ecc.postpad);
1131                         oob += chip->ecc.postpad;
1132                 }
1133         }
1134
1135         /* Calculate remaining oob bytes */
1136         i = mtd->oobsize - (oob - chip->oob_poi);
1137         if (i)
1138                 chip->read_buf(mtd, oob, i);
1139
1140         return 0;
1141 }
1142
1143 /**
1144  * nand_transfer_oob - [Internal] Transfer oob to client buffer
1145  * @chip:       nand chip structure
1146  * @oob:        oob destination address
1147  * @ops:        oob ops structure
1148  * @len:        size of oob to transfer
1149  */
1150 static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob,
1151                                   struct mtd_oob_ops *ops, size_t len)
1152 {
1153         switch (ops->mode) {
1154
1155         case MTD_OOB_PLACE:
1156         case MTD_OOB_RAW:
1157                 memcpy(oob, chip->oob_poi + ops->ooboffs, len);
1158                 return oob + len;
1159
1160         case MTD_OOB_AUTO: {
1161                 struct nand_oobfree *free = chip->ecc.layout->oobfree;
1162                 uint32_t boffs = 0, roffs = ops->ooboffs;
1163                 size_t bytes = 0;
1164
1165                 for (; free->length && len; free++, len -= bytes) {
1166                         /* Read request not from offset 0 ? */
1167                         if (unlikely(roffs)) {
1168                                 if (roffs >= free->length) {
1169                                         roffs -= free->length;
1170                                         continue;
1171                                 }
1172                                 boffs = free->offset + roffs;
1173                                 bytes = min_t(size_t, len,
1174                                               (free->length - roffs));
1175                                 roffs = 0;
1176                         } else {
1177                                 bytes = min_t(size_t, len, free->length);
1178                                 boffs = free->offset;
1179                         }
1180                         memcpy(oob, chip->oob_poi + boffs, bytes);
1181                         oob += bytes;
1182                 }
1183                 return oob;
1184         }
1185         default:
1186                 BUG();
1187         }
1188         return NULL;
1189 }
1190
1191 /**
1192  * nand_do_read_ops - [Internal] Read data with ECC
1193  *
1194  * @mtd:        MTD device structure
1195  * @from:       offset to read from
1196  * @ops:        oob ops structure
1197  *
1198  * Internal function. Called with chip held.
1199  */
1200 static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
1201                             struct mtd_oob_ops *ops)
1202 {
1203         int chipnr, page, realpage, col, bytes, aligned;
1204         struct nand_chip *chip = mtd->priv;
1205         struct mtd_ecc_stats stats;
1206         int blkcheck = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
1207         int sndcmd = 1;
1208         int ret = 0;
1209         uint32_t readlen = ops->len;
1210         uint32_t oobreadlen = ops->ooblen;
1211         uint32_t max_oobsize = ops->mode == MTD_OOB_AUTO ?
1212                 mtd->oobavail : mtd->oobsize;
1213
1214         uint8_t *bufpoi, *oob, *buf;
1215
1216         stats = mtd->ecc_stats;
1217
1218         chipnr = (int)(from >> chip->chip_shift);
1219         chip->select_chip(mtd, chipnr);
1220
1221         realpage = (int)(from >> chip->page_shift);
1222         page = realpage & chip->pagemask;
1223
1224         col = (int)(from & (mtd->writesize - 1));
1225
1226         buf = ops->datbuf;
1227         oob = ops->oobbuf;
1228
1229         while (1) {
1230                 WATCHDOG_RESET();
1231
1232                 bytes = min(mtd->writesize - col, readlen);
1233                 aligned = (bytes == mtd->writesize);
1234
1235                 /* Is the current page in the buffer ? */
1236                 if (realpage != chip->pagebuf || oob) {
1237                         bufpoi = aligned ? buf : chip->buffers->databuf;
1238
1239                         if (likely(sndcmd)) {
1240                                 chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1241                                 sndcmd = 0;
1242                         }
1243
1244                         /* Now read the page into the buffer */
1245                         if (unlikely(ops->mode == MTD_OOB_RAW))
1246                                 ret = chip->ecc.read_page_raw(mtd, chip,
1247                                                               bufpoi, page);
1248                         else if (!aligned && NAND_SUBPAGE_READ(chip) && !oob)
1249                                 ret = chip->ecc.read_subpage(mtd, chip,
1250                                                         col, bytes, bufpoi);
1251                         else
1252                                 ret = chip->ecc.read_page(mtd, chip, bufpoi,
1253                                                           page);
1254                         if (ret < 0)
1255                                 break;
1256
1257                         /* Transfer not aligned data */
1258                         if (!aligned) {
1259                                 if (!NAND_SUBPAGE_READ(chip) && !oob &&
1260                                     !(mtd->ecc_stats.failed - stats.failed))
1261                                         chip->pagebuf = realpage;
1262                                 memcpy(buf, chip->buffers->databuf + col, bytes);
1263                         }
1264
1265                         buf += bytes;
1266
1267                         if (unlikely(oob)) {
1268
1269                                 int toread = min(oobreadlen, max_oobsize);
1270
1271                                 if (toread) {
1272                                         oob = nand_transfer_oob(chip,
1273                                                 oob, ops, toread);
1274                                         oobreadlen -= toread;
1275                                 }
1276                         }
1277
1278                         if (!(chip->options & NAND_NO_READRDY)) {
1279                                 /*
1280                                  * Apply delay or wait for ready/busy pin. Do
1281                                  * this before the AUTOINCR check, so no
1282                                  * problems arise if a chip which does auto
1283                                  * increment is marked as NOAUTOINCR by the
1284                                  * board driver.
1285                                  */
1286                                 if (!chip->dev_ready)
1287                                         udelay(chip->chip_delay);
1288                                 else
1289                                         nand_wait_ready(mtd);
1290                         }
1291                 } else {
1292                         memcpy(buf, chip->buffers->databuf + col, bytes);
1293                         buf += bytes;
1294                 }
1295
1296                 readlen -= bytes;
1297
1298                 if (!readlen)
1299                         break;
1300
1301                 /* For subsequent reads align to page boundary. */
1302                 col = 0;
1303                 /* Increment page address */
1304                 realpage++;
1305
1306                 page = realpage & chip->pagemask;
1307                 /* Check, if we cross a chip boundary */
1308                 if (!page) {
1309                         chipnr++;
1310                         chip->select_chip(mtd, -1);
1311                         chip->select_chip(mtd, chipnr);
1312                 }
1313
1314                 /* Check, if the chip supports auto page increment
1315                  * or if we have hit a block boundary.
1316                  */
1317                 if (!NAND_CANAUTOINCR(chip) || !(page & blkcheck))
1318                         sndcmd = 1;
1319         }
1320
1321         ops->retlen = ops->len - (size_t) readlen;
1322         if (oob)
1323                 ops->oobretlen = ops->ooblen - oobreadlen;
1324
1325         if (ret)
1326                 return ret;
1327
1328         if (mtd->ecc_stats.failed - stats.failed)
1329                 return -EBADMSG;
1330
1331         return  mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
1332 }
1333
1334 /**
1335  * nand_read - [MTD Interface] MTD compatibility function for nand_do_read_ecc
1336  * @mtd:        MTD device structure
1337  * @from:       offset to read from
1338  * @len:        number of bytes to read
1339  * @retlen:     pointer to variable to store the number of read bytes
1340  * @buf:        the databuffer to put data
1341  *
1342  * Get hold of the chip and call nand_do_read
1343  */
1344 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
1345                      size_t *retlen, uint8_t *buf)
1346 {
1347         struct nand_chip *chip = mtd->priv;
1348         int ret;
1349
1350         /* Do not allow reads past end of device */
1351         if ((from + len) > mtd->size)
1352                 return -EINVAL;
1353         if (!len)
1354                 return 0;
1355
1356         nand_get_device(chip, mtd, FL_READING);
1357
1358         chip->ops.len = len;
1359         chip->ops.datbuf = buf;
1360         chip->ops.oobbuf = NULL;
1361
1362         ret = nand_do_read_ops(mtd, from, &chip->ops);
1363
1364         *retlen = chip->ops.retlen;
1365
1366         nand_release_device(mtd);
1367
1368         return ret;
1369 }
1370
1371 /**
1372  * nand_read_oob_std - [REPLACABLE] the most common OOB data read function
1373  * @mtd:        mtd info structure
1374  * @chip:       nand chip info structure
1375  * @page:       page number to read
1376  * @sndcmd:     flag whether to issue read command or not
1377  */
1378 static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
1379                              int page, int sndcmd)
1380 {
1381         if (sndcmd) {
1382                 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
1383                 sndcmd = 0;
1384         }
1385         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1386         return sndcmd;
1387 }
1388
1389 /**
1390  * nand_read_oob_syndrome - [REPLACABLE] OOB data read function for HW ECC
1391  *                          with syndromes
1392  * @mtd:        mtd info structure
1393  * @chip:       nand chip info structure
1394  * @page:       page number to read
1395  * @sndcmd:     flag whether to issue read command or not
1396  */
1397 static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
1398                                   int page, int sndcmd)
1399 {
1400         uint8_t *buf = chip->oob_poi;
1401         int length = mtd->oobsize;
1402         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
1403         int eccsize = chip->ecc.size;
1404         uint8_t *bufpoi = buf;
1405         int i, toread, sndrnd = 0, pos;
1406
1407         chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
1408         for (i = 0; i < chip->ecc.steps; i++) {
1409                 if (sndrnd) {
1410                         pos = eccsize + i * (eccsize + chunk);
1411                         if (mtd->writesize > 512)
1412                                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1);
1413                         else
1414                                 chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page);
1415                 } else
1416                         sndrnd = 1;
1417                 toread = min_t(int, length, chunk);
1418                 chip->read_buf(mtd, bufpoi, toread);
1419                 bufpoi += toread;
1420                 length -= toread;
1421         }
1422         if (length > 0)
1423                 chip->read_buf(mtd, bufpoi, length);
1424
1425         return 1;
1426 }
1427
1428 /**
1429  * nand_write_oob_std - [REPLACABLE] the most common OOB data write function
1430  * @mtd:        mtd info structure
1431  * @chip:       nand chip info structure
1432  * @page:       page number to write
1433  */
1434 static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
1435                               int page)
1436 {
1437         int status = 0;
1438         const uint8_t *buf = chip->oob_poi;
1439         int length = mtd->oobsize;
1440
1441         chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
1442         chip->write_buf(mtd, buf, length);
1443         /* Send command to program the OOB data */
1444         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1445
1446         status = chip->waitfunc(mtd, chip);
1447
1448         return status & NAND_STATUS_FAIL ? -EIO : 0;
1449 }
1450
1451 /**
1452  * nand_write_oob_syndrome - [REPLACABLE] OOB data write function for HW ECC
1453  *                           with syndrome - only for large page flash !
1454  * @mtd:        mtd info structure
1455  * @chip:       nand chip info structure
1456  * @page:       page number to write
1457  */
1458 static int nand_write_oob_syndrome(struct mtd_info *mtd,
1459                                    struct nand_chip *chip, int page)
1460 {
1461         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
1462         int eccsize = chip->ecc.size, length = mtd->oobsize;
1463         int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps;
1464         const uint8_t *bufpoi = chip->oob_poi;
1465
1466         /*
1467          * data-ecc-data-ecc ... ecc-oob
1468          * or
1469          * data-pad-ecc-pad-data-pad .... ecc-pad-oob
1470          */
1471         if (!chip->ecc.prepad && !chip->ecc.postpad) {
1472                 pos = steps * (eccsize + chunk);
1473                 steps = 0;
1474         } else
1475                 pos = eccsize;
1476
1477         chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
1478         for (i = 0; i < steps; i++) {
1479                 if (sndcmd) {
1480                         if (mtd->writesize <= 512) {
1481                                 uint32_t fill = 0xFFFFFFFF;
1482
1483                                 len = eccsize;
1484                                 while (len > 0) {
1485                                         int num = min_t(int, len, 4);
1486                                         chip->write_buf(mtd, (uint8_t *)&fill,
1487                                                         num);
1488                                         len -= num;
1489                                 }
1490                         } else {
1491                                 pos = eccsize + i * (eccsize + chunk);
1492                                 chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1);
1493                         }
1494                 } else
1495                         sndcmd = 1;
1496                 len = min_t(int, length, chunk);
1497                 chip->write_buf(mtd, bufpoi, len);
1498                 bufpoi += len;
1499                 length -= len;
1500         }
1501         if (length > 0)
1502                 chip->write_buf(mtd, bufpoi, length);
1503
1504         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1505         status = chip->waitfunc(mtd, chip);
1506
1507         return status & NAND_STATUS_FAIL ? -EIO : 0;
1508 }
1509
1510 /**
1511  * nand_do_read_oob - [Intern] NAND read out-of-band
1512  * @mtd:        MTD device structure
1513  * @from:       offset to read from
1514  * @ops:        oob operations description structure
1515  *
1516  * NAND read out-of-band data from the spare area
1517  */
1518 static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
1519                             struct mtd_oob_ops *ops)
1520 {
1521         int page, realpage, chipnr, sndcmd = 1;
1522         struct nand_chip *chip = mtd->priv;
1523         int blkcheck = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
1524         int readlen = ops->ooblen;
1525         int len;
1526         uint8_t *buf = ops->oobbuf;
1527
1528         MTDDEBUG(MTD_DEBUG_LEVEL3, "%s: from = 0x%08Lx, len = %i\n",
1529                         __func__, (unsigned long long)from, readlen);
1530
1531         if (ops->mode == MTD_OOB_AUTO)
1532                 len = chip->ecc.layout->oobavail;
1533         else
1534                 len = mtd->oobsize;
1535
1536         if (unlikely(ops->ooboffs >= len)) {
1537                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt to start read "
1538                                         "outside oob\n", __func__);
1539                 return -EINVAL;
1540         }
1541
1542         /* Do not allow reads past end of device */
1543         if (unlikely(from >= mtd->size ||
1544                      ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) -
1545                                         (from >> chip->page_shift)) * len)) {
1546                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt read beyond end "
1547                                         "of device\n", __func__);
1548                 return -EINVAL;
1549         }
1550
1551         chipnr = (int)(from >> chip->chip_shift);
1552         chip->select_chip(mtd, chipnr);
1553
1554         /* Shift to get page */
1555         realpage = (int)(from >> chip->page_shift);
1556         page = realpage & chip->pagemask;
1557
1558         while (1) {
1559                 WATCHDOG_RESET();
1560                 sndcmd = chip->ecc.read_oob(mtd, chip, page, sndcmd);
1561
1562                 len = min(len, readlen);
1563                 buf = nand_transfer_oob(chip, buf, ops, len);
1564
1565                 if (!(chip->options & NAND_NO_READRDY)) {
1566                         /*
1567                          * Apply delay or wait for ready/busy pin. Do this
1568                          * before the AUTOINCR check, so no problems arise if a
1569                          * chip which does auto increment is marked as
1570                          * NOAUTOINCR by the board driver.
1571                          */
1572                         if (!chip->dev_ready)
1573                                 udelay(chip->chip_delay);
1574                         else
1575                                 nand_wait_ready(mtd);
1576                 }
1577
1578                 readlen -= len;
1579                 if (!readlen)
1580                         break;
1581
1582                 /* Increment page address */
1583                 realpage++;
1584
1585                 page = realpage & chip->pagemask;
1586                 /* Check, if we cross a chip boundary */
1587                 if (!page) {
1588                         chipnr++;
1589                         chip->select_chip(mtd, -1);
1590                         chip->select_chip(mtd, chipnr);
1591                 }
1592
1593                 /* Check, if the chip supports auto page increment
1594                  * or if we have hit a block boundary.
1595                  */
1596                 if (!NAND_CANAUTOINCR(chip) || !(page & blkcheck))
1597                         sndcmd = 1;
1598         }
1599
1600         ops->oobretlen = ops->ooblen;
1601         return 0;
1602 }
1603
1604 /**
1605  * nand_read_oob - [MTD Interface] NAND read data and/or out-of-band
1606  * @mtd:        MTD device structure
1607  * @from:       offset to read from
1608  * @ops:        oob operation description structure
1609  *
1610  * NAND read data and/or out-of-band data
1611  */
1612 static int nand_read_oob(struct mtd_info *mtd, loff_t from,
1613                          struct mtd_oob_ops *ops)
1614 {
1615         struct nand_chip *chip = mtd->priv;
1616         int ret = -ENOTSUPP;
1617
1618         ops->retlen = 0;
1619
1620         /* Do not allow reads past end of device */
1621         if (ops->datbuf && (from + ops->len) > mtd->size) {
1622                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt read "
1623                                 "beyond end of device\n", __func__);
1624                 return -EINVAL;
1625         }
1626
1627         nand_get_device(chip, mtd, FL_READING);
1628
1629         switch (ops->mode) {
1630         case MTD_OOB_PLACE:
1631         case MTD_OOB_AUTO:
1632         case MTD_OOB_RAW:
1633                 break;
1634
1635         default:
1636                 goto out;
1637         }
1638
1639         if (!ops->datbuf)
1640                 ret = nand_do_read_oob(mtd, from, ops);
1641         else
1642                 ret = nand_do_read_ops(mtd, from, ops);
1643
1644 out:
1645         nand_release_device(mtd);
1646         return ret;
1647 }
1648
1649
1650 /**
1651  * nand_write_page_raw - [Intern] raw page write function
1652  * @mtd:        mtd info structure
1653  * @chip:       nand chip info structure
1654  * @buf:        data buffer
1655  *
1656  * Not for syndrome calculating ecc controllers, which use a special oob layout
1657  */
1658 static void nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
1659                                 const uint8_t *buf)
1660 {
1661         chip->write_buf(mtd, buf, mtd->writesize);
1662         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
1663 }
1664
1665 /**
1666  * nand_write_page_raw_syndrome - [Intern] raw page write function
1667  * @mtd:        mtd info structure
1668  * @chip:       nand chip info structure
1669  * @buf:        data buffer
1670  *
1671  * We need a special oob layout and handling even when ECC isn't checked.
1672  */
1673 static void nand_write_page_raw_syndrome(struct mtd_info *mtd,
1674                                         struct nand_chip *chip,
1675                                         const uint8_t *buf)
1676 {
1677         int eccsize = chip->ecc.size;
1678         int eccbytes = chip->ecc.bytes;
1679         uint8_t *oob = chip->oob_poi;
1680         int steps, size;
1681
1682         for (steps = chip->ecc.steps; steps > 0; steps--) {
1683                 chip->write_buf(mtd, buf, eccsize);
1684                 buf += eccsize;
1685
1686                 if (chip->ecc.prepad) {
1687                         chip->write_buf(mtd, oob, chip->ecc.prepad);
1688                         oob += chip->ecc.prepad;
1689                 }
1690
1691                 chip->read_buf(mtd, oob, eccbytes);
1692                 oob += eccbytes;
1693
1694                 if (chip->ecc.postpad) {
1695                         chip->write_buf(mtd, oob, chip->ecc.postpad);
1696                         oob += chip->ecc.postpad;
1697                 }
1698         }
1699
1700         size = mtd->oobsize - (oob - chip->oob_poi);
1701         if (size)
1702                 chip->write_buf(mtd, oob, size);
1703 }
1704 /**
1705  * nand_write_page_swecc - [REPLACABLE] software ecc based page write function
1706  * @mtd:        mtd info structure
1707  * @chip:       nand chip info structure
1708  * @buf:        data buffer
1709  */
1710 static void nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
1711                                   const uint8_t *buf)
1712 {
1713         int i, eccsize = chip->ecc.size;
1714         int eccbytes = chip->ecc.bytes;
1715         int eccsteps = chip->ecc.steps;
1716         uint8_t *ecc_calc = chip->buffers->ecccalc;
1717         const uint8_t *p = buf;
1718         uint32_t *eccpos = chip->ecc.layout->eccpos;
1719
1720         /* Software ecc calculation */
1721         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
1722                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1723
1724         for (i = 0; i < chip->ecc.total; i++)
1725                 chip->oob_poi[eccpos[i]] = ecc_calc[i];
1726
1727         chip->ecc.write_page_raw(mtd, chip, buf);
1728 }
1729
1730 /**
1731  * nand_write_page_hwecc - [REPLACABLE] hardware ecc based page write function
1732  * @mtd:        mtd info structure
1733  * @chip:       nand chip info structure
1734  * @buf:        data buffer
1735  */
1736 static void nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
1737                                   const uint8_t *buf)
1738 {
1739         int i, eccsize = chip->ecc.size;
1740         int eccbytes = chip->ecc.bytes;
1741         int eccsteps = chip->ecc.steps;
1742         uint8_t *ecc_calc = chip->buffers->ecccalc;
1743         const uint8_t *p = buf;
1744         uint32_t *eccpos = chip->ecc.layout->eccpos;
1745
1746         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1747                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
1748                 chip->write_buf(mtd, p, eccsize);
1749                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1750         }
1751
1752         for (i = 0; i < chip->ecc.total; i++)
1753                 chip->oob_poi[eccpos[i]] = ecc_calc[i];
1754
1755         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
1756 }
1757
1758 /**
1759  * nand_write_page_syndrome - [REPLACABLE] hardware ecc syndrom based page write
1760  * @mtd:        mtd info structure
1761  * @chip:       nand chip info structure
1762  * @buf:        data buffer
1763  *
1764  * The hw generator calculates the error syndrome automatically. Therefor
1765  * we need a special oob layout and handling.
1766  */
1767 static void nand_write_page_syndrome(struct mtd_info *mtd,
1768                                     struct nand_chip *chip, const uint8_t *buf)
1769 {
1770         int i, eccsize = chip->ecc.size;
1771         int eccbytes = chip->ecc.bytes;
1772         int eccsteps = chip->ecc.steps;
1773         const uint8_t *p = buf;
1774         uint8_t *oob = chip->oob_poi;
1775
1776         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1777
1778                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
1779                 chip->write_buf(mtd, p, eccsize);
1780
1781                 if (chip->ecc.prepad) {
1782                         chip->write_buf(mtd, oob, chip->ecc.prepad);
1783                         oob += chip->ecc.prepad;
1784                 }
1785
1786                 chip->ecc.calculate(mtd, p, oob);
1787                 chip->write_buf(mtd, oob, eccbytes);
1788                 oob += eccbytes;
1789
1790                 if (chip->ecc.postpad) {
1791                         chip->write_buf(mtd, oob, chip->ecc.postpad);
1792                         oob += chip->ecc.postpad;
1793                 }
1794         }
1795
1796         /* Calculate remaining oob bytes */
1797         i = mtd->oobsize - (oob - chip->oob_poi);
1798         if (i)
1799                 chip->write_buf(mtd, oob, i);
1800 }
1801
1802 /**
1803  * nand_write_page - [REPLACEABLE] write one page
1804  * @mtd:        MTD device structure
1805  * @chip:       NAND chip descriptor
1806  * @buf:        the data to write
1807  * @page:       page number to write
1808  * @cached:     cached programming
1809  * @raw:        use _raw version of write_page
1810  */
1811 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
1812                            const uint8_t *buf, int page, int cached, int raw)
1813 {
1814         int status;
1815
1816         chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
1817
1818         if (unlikely(raw))
1819                 chip->ecc.write_page_raw(mtd, chip, buf);
1820         else
1821                 chip->ecc.write_page(mtd, chip, buf);
1822
1823         /*
1824          * Cached progamming disabled for now, Not sure if its worth the
1825          * trouble. The speed gain is not very impressive. (2.3->2.6Mib/s)
1826          */
1827         cached = 0;
1828
1829         if (!cached || !(chip->options & NAND_CACHEPRG)) {
1830
1831                 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1832                 status = chip->waitfunc(mtd, chip);
1833                 /*
1834                  * See if operation failed and additional status checks are
1835                  * available
1836                  */
1837                 if ((status & NAND_STATUS_FAIL) && (chip->errstat))
1838                         status = chip->errstat(mtd, chip, FL_WRITING, status,
1839                                                page);
1840
1841                 if (status & NAND_STATUS_FAIL)
1842                         return -EIO;
1843         } else {
1844                 chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1);
1845                 status = chip->waitfunc(mtd, chip);
1846         }
1847
1848 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1849         /* Send command to read back the data */
1850         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
1851
1852         if (chip->verify_buf(mtd, buf, mtd->writesize))
1853                 return -EIO;
1854 #endif
1855         return 0;
1856 }
1857
1858 /**
1859  * nand_fill_oob - [Internal] Transfer client buffer to oob
1860  * @chip:       nand chip structure
1861  * @oob:        oob data buffer
1862  * @len:        oob data write length
1863  * @ops:        oob ops structure
1864  */
1865 static uint8_t *nand_fill_oob(struct nand_chip *chip, uint8_t *oob, size_t len,
1866                                                 struct mtd_oob_ops *ops)
1867 {
1868         switch (ops->mode) {
1869
1870         case MTD_OOB_PLACE:
1871         case MTD_OOB_RAW:
1872                 memcpy(chip->oob_poi + ops->ooboffs, oob, len);
1873                 return oob + len;
1874
1875         case MTD_OOB_AUTO: {
1876                 struct nand_oobfree *free = chip->ecc.layout->oobfree;
1877                 uint32_t boffs = 0, woffs = ops->ooboffs;
1878                 size_t bytes = 0;
1879
1880                 for (; free->length && len; free++, len -= bytes) {
1881                         /* Write request not from offset 0 ? */
1882                         if (unlikely(woffs)) {
1883                                 if (woffs >= free->length) {
1884                                         woffs -= free->length;
1885                                         continue;
1886                                 }
1887                                 boffs = free->offset + woffs;
1888                                 bytes = min_t(size_t, len,
1889                                               (free->length - woffs));
1890                                 woffs = 0;
1891                         } else {
1892                                 bytes = min_t(size_t, len, free->length);
1893                                 boffs = free->offset;
1894                         }
1895                         memcpy(chip->oob_poi + boffs, oob, bytes);
1896                         oob += bytes;
1897                 }
1898                 return oob;
1899         }
1900         default:
1901                 BUG();
1902         }
1903         return NULL;
1904 }
1905
1906 /**
1907  * nand_do_write_ops - [Internal] NAND write with ECC
1908  * @mtd:        MTD device structure
1909  * @to:         offset to write to
1910  * @ops:        oob operations description structure
1911  *
1912  * NAND write with ECC
1913  */
1914 static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
1915                              struct mtd_oob_ops *ops)
1916 {
1917         int chipnr, realpage, page, blockmask, column;
1918         struct nand_chip *chip = mtd->priv;
1919         uint32_t writelen = ops->len;
1920
1921         uint32_t oobwritelen = ops->ooblen;
1922         uint32_t oobmaxlen = ops->mode == MTD_OOB_AUTO ?
1923                                 mtd->oobavail : mtd->oobsize;
1924
1925         uint8_t *oob = ops->oobbuf;
1926         uint8_t *buf = ops->datbuf;
1927         int ret, subpage;
1928
1929         ops->retlen = 0;
1930         if (!writelen)
1931                 return 0;
1932
1933         column = to & (mtd->writesize - 1);
1934         subpage = column || (writelen & (mtd->writesize - 1));
1935
1936         if (subpage && oob)
1937                 return -EINVAL;
1938
1939         chipnr = (int)(to >> chip->chip_shift);
1940         chip->select_chip(mtd, chipnr);
1941
1942         /* Check, if it is write protected */
1943         if (nand_check_wp(mtd)) {
1944                 printk (KERN_NOTICE "nand_do_write_ops: Device is write protected\n");
1945                 return -EIO;
1946         }
1947
1948         realpage = (int)(to >> chip->page_shift);
1949         page = realpage & chip->pagemask;
1950         blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
1951
1952         /* Invalidate the page cache, when we write to the cached page */
1953         if (to <= (chip->pagebuf << chip->page_shift) &&
1954             (chip->pagebuf << chip->page_shift) < (to + ops->len))
1955                 chip->pagebuf = -1;
1956
1957         /* If we're not given explicit OOB data, let it be 0xFF */
1958         if (likely(!oob))
1959                 memset(chip->oob_poi, 0xff, mtd->oobsize);
1960
1961         /* Don't allow multipage oob writes with offset */
1962         if (oob && ops->ooboffs && (ops->ooboffs + ops->ooblen > oobmaxlen))
1963                 return -EINVAL;
1964
1965         while (1) {
1966                 WATCHDOG_RESET();
1967
1968                 int bytes = mtd->writesize;
1969                 int cached = writelen > bytes && page != blockmask;
1970                 uint8_t *wbuf = buf;
1971
1972                 /* Partial page write ? */
1973                 if (unlikely(column || writelen < (mtd->writesize - 1))) {
1974                         cached = 0;
1975                         bytes = min_t(int, bytes - column, (int) writelen);
1976                         chip->pagebuf = -1;
1977                         memset(chip->buffers->databuf, 0xff, mtd->writesize);
1978                         memcpy(&chip->buffers->databuf[column], buf, bytes);
1979                         wbuf = chip->buffers->databuf;
1980                 }
1981
1982                 if (unlikely(oob)) {
1983                         size_t len = min(oobwritelen, oobmaxlen);
1984                         oob = nand_fill_oob(chip, oob, len, ops);
1985                         oobwritelen -= len;
1986                 }
1987
1988                 ret = chip->write_page(mtd, chip, wbuf, page, cached,
1989                                        (ops->mode == MTD_OOB_RAW));
1990                 if (ret)
1991                         break;
1992
1993                 writelen -= bytes;
1994                 if (!writelen)
1995                         break;
1996
1997                 column = 0;
1998                 buf += bytes;
1999                 realpage++;
2000
2001                 page = realpage & chip->pagemask;
2002                 /* Check, if we cross a chip boundary */
2003                 if (!page) {
2004                         chipnr++;
2005                         chip->select_chip(mtd, -1);
2006                         chip->select_chip(mtd, chipnr);
2007                 }
2008         }
2009
2010         ops->retlen = ops->len - writelen;
2011         if (unlikely(oob))
2012                 ops->oobretlen = ops->ooblen;
2013         return ret;
2014 }
2015
2016 /**
2017  * nand_write - [MTD Interface] NAND write with ECC
2018  * @mtd:        MTD device structure
2019  * @to:         offset to write to
2020  * @len:        number of bytes to write
2021  * @retlen:     pointer to variable to store the number of written bytes
2022  * @buf:        the data to write
2023  *
2024  * NAND write with ECC
2025  */
2026 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
2027                           size_t *retlen, const uint8_t *buf)
2028 {
2029         struct nand_chip *chip = mtd->priv;
2030         int ret;
2031
2032         /* Do not allow writes past end of device */
2033         if ((to + len) > mtd->size)
2034                 return -EINVAL;
2035         if (!len)
2036                 return 0;
2037
2038         nand_get_device(chip, mtd, FL_WRITING);
2039
2040         chip->ops.len = len;
2041         chip->ops.datbuf = (uint8_t *)buf;
2042         chip->ops.oobbuf = NULL;
2043
2044         ret = nand_do_write_ops(mtd, to, &chip->ops);
2045
2046         *retlen = chip->ops.retlen;
2047
2048         nand_release_device(mtd);
2049
2050         return ret;
2051 }
2052
2053 /**
2054  * nand_do_write_oob - [MTD Interface] NAND write out-of-band
2055  * @mtd:        MTD device structure
2056  * @to:         offset to write to
2057  * @ops:        oob operation description structure
2058  *
2059  * NAND write out-of-band
2060  */
2061 static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
2062                              struct mtd_oob_ops *ops)
2063 {
2064         int chipnr, page, status, len;
2065         struct nand_chip *chip = mtd->priv;
2066
2067         MTDDEBUG(MTD_DEBUG_LEVEL3, "%s: to = 0x%08x, len = %i\n",
2068                          __func__, (unsigned int)to, (int)ops->ooblen);
2069
2070         if (ops->mode == MTD_OOB_AUTO)
2071                 len = chip->ecc.layout->oobavail;
2072         else
2073                 len = mtd->oobsize;
2074
2075         /* Do not allow write past end of page */
2076         if ((ops->ooboffs + ops->ooblen) > len) {
2077                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt to write "
2078                                 "past end of page\n", __func__);
2079                 return -EINVAL;
2080         }
2081
2082         if (unlikely(ops->ooboffs >= len)) {
2083                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt to start "
2084                                 "write outside oob\n", __func__);
2085                 return -EINVAL;
2086         }
2087
2088         /* Do not allow write past end of device */
2089         if (unlikely(to >= mtd->size ||
2090                      ops->ooboffs + ops->ooblen >
2091                         ((mtd->size >> chip->page_shift) -
2092                          (to >> chip->page_shift)) * len)) {
2093                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt write beyond "
2094                                 "end of device\n", __func__);
2095                 return -EINVAL;
2096         }
2097
2098         chipnr = (int)(to >> chip->chip_shift);
2099         chip->select_chip(mtd, chipnr);
2100
2101         /* Shift to get page */
2102         page = (int)(to >> chip->page_shift);
2103
2104         /*
2105          * Reset the chip. Some chips (like the Toshiba TC5832DC found in one
2106          * of my DiskOnChip 2000 test units) will clear the whole data page too
2107          * if we don't do this. I have no clue why, but I seem to have 'fixed'
2108          * it in the doc2000 driver in August 1999.  dwmw2.
2109          */
2110         chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
2111
2112         /* Check, if it is write protected */
2113         if (nand_check_wp(mtd))
2114                 return -EROFS;
2115
2116         /* Invalidate the page cache, if we write to the cached page */
2117         if (page == chip->pagebuf)
2118                 chip->pagebuf = -1;
2119
2120         memset(chip->oob_poi, 0xff, mtd->oobsize);
2121         nand_fill_oob(chip, ops->oobbuf, ops->ooblen, ops);
2122         status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask);
2123         memset(chip->oob_poi, 0xff, mtd->oobsize);
2124
2125         if (status)
2126                 return status;
2127
2128         ops->oobretlen = ops->ooblen;
2129
2130         return 0;
2131 }
2132
2133 /**
2134  * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band
2135  * @mtd:        MTD device structure
2136  * @to:         offset to write to
2137  * @ops:        oob operation description structure
2138  */
2139 static int nand_write_oob(struct mtd_info *mtd, loff_t to,
2140                           struct mtd_oob_ops *ops)
2141 {
2142         struct nand_chip *chip = mtd->priv;
2143         int ret = -ENOTSUPP;
2144
2145         ops->retlen = 0;
2146
2147         /* Do not allow writes past end of device */
2148         if (ops->datbuf && (to + ops->len) > mtd->size) {
2149                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Attempt write beyond "
2150                                 "end of device\n", __func__);
2151                 return -EINVAL;
2152         }
2153
2154         nand_get_device(chip, mtd, FL_WRITING);
2155
2156         switch (ops->mode) {
2157         case MTD_OOB_PLACE:
2158         case MTD_OOB_AUTO:
2159         case MTD_OOB_RAW:
2160                 break;
2161
2162         default:
2163                 goto out;
2164         }
2165
2166         if (!ops->datbuf)
2167                 ret = nand_do_write_oob(mtd, to, ops);
2168         else
2169                 ret = nand_do_write_ops(mtd, to, ops);
2170
2171 out:
2172         nand_release_device(mtd);
2173         return ret;
2174 }
2175
2176 /**
2177  * single_erease_cmd - [GENERIC] NAND standard block erase command function
2178  * @mtd:        MTD device structure
2179  * @page:       the page address of the block which will be erased
2180  *
2181  * Standard erase command for NAND chips
2182  */
2183 static void single_erase_cmd(struct mtd_info *mtd, int page)
2184 {
2185         struct nand_chip *chip = mtd->priv;
2186         /* Send commands to erase a block */
2187         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2188         chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2189 }
2190
2191 /**
2192  * multi_erease_cmd - [GENERIC] AND specific block erase command function
2193  * @mtd:        MTD device structure
2194  * @page:       the page address of the block which will be erased
2195  *
2196  * AND multi block erase command function
2197  * Erase 4 consecutive blocks
2198  */
2199 static void multi_erase_cmd(struct mtd_info *mtd, int page)
2200 {
2201         struct nand_chip *chip = mtd->priv;
2202         /* Send commands to erase a block */
2203         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2204         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2205         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2206         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2207         chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2208 }
2209
2210 /**
2211  * nand_erase - [MTD Interface] erase block(s)
2212  * @mtd:        MTD device structure
2213  * @instr:      erase instruction
2214  *
2215  * Erase one ore more blocks
2216  */
2217 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
2218 {
2219         return nand_erase_nand(mtd, instr, 0);
2220 }
2221
2222 #define BBT_PAGE_MASK   0xffffff3f
2223 /**
2224  * nand_erase_nand - [Internal] erase block(s)
2225  * @mtd:        MTD device structure
2226  * @instr:      erase instruction
2227  * @allowbbt:   allow erasing the bbt area
2228  *
2229  * Erase one ore more blocks
2230  */
2231 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
2232                     int allowbbt)
2233 {
2234         int page, status, pages_per_block, ret, chipnr;
2235         struct nand_chip *chip = mtd->priv;
2236         loff_t rewrite_bbt[CONFIG_SYS_NAND_MAX_CHIPS] = {0};
2237         unsigned int bbt_masked_page = 0xffffffff;
2238         loff_t len;
2239
2240         MTDDEBUG(MTD_DEBUG_LEVEL3, "%s: start = 0x%012llx, len = %llu\n",
2241                                 __func__, (unsigned long long)instr->addr,
2242                                 (unsigned long long)instr->len);
2243
2244         if (check_offs_len(mtd, instr->addr, instr->len))
2245                 return -EINVAL;
2246
2247         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2248
2249         /* Grab the lock and see if the device is available */
2250         nand_get_device(chip, mtd, FL_ERASING);
2251
2252         /* Shift to get first page */
2253         page = (int)(instr->addr >> chip->page_shift);
2254         chipnr = (int)(instr->addr >> chip->chip_shift);
2255
2256         /* Calculate pages in each block */
2257         pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift);
2258
2259         /* Select the NAND device */
2260         chip->select_chip(mtd, chipnr);
2261
2262         /* Check, if it is write protected */
2263         if (nand_check_wp(mtd)) {
2264                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Device is write protected!!!\n",
2265                                         __func__);
2266                 instr->state = MTD_ERASE_FAILED;
2267                 goto erase_exit;
2268         }
2269
2270         /*
2271          * If BBT requires refresh, set the BBT page mask to see if the BBT
2272          * should be rewritten. Otherwise the mask is set to 0xffffffff which
2273          * can not be matched. This is also done when the bbt is actually
2274          * erased to avoid recusrsive updates
2275          */
2276         if (chip->options & BBT_AUTO_REFRESH && !allowbbt)
2277                 bbt_masked_page = chip->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2278
2279         /* Loop through the pages */
2280         len = instr->len;
2281
2282         instr->state = MTD_ERASING;
2283
2284         while (len) {
2285                 WATCHDOG_RESET();
2286                 /*
2287                  * heck if we have a bad block, we do not erase bad blocks !
2288                  */
2289                 if (!instr->scrub && nand_block_checkbad(mtd, ((loff_t) page) <<
2290                                         chip->page_shift, 0, allowbbt)) {
2291                         printk(KERN_WARNING "%s: attempt to erase a bad block "
2292                                         "at page 0x%08x\n", __func__, page);
2293                         instr->state = MTD_ERASE_FAILED;
2294                         goto erase_exit;
2295                 }
2296
2297                 /*
2298                  * Invalidate the page cache, if we erase the block which
2299                  * contains the current cached page
2300                  */
2301                 if (page <= chip->pagebuf && chip->pagebuf <
2302                     (page + pages_per_block))
2303                         chip->pagebuf = -1;
2304
2305                 chip->erase_cmd(mtd, page & chip->pagemask);
2306
2307                 status = chip->waitfunc(mtd, chip);
2308
2309                 /*
2310                  * See if operation failed and additional status checks are
2311                  * available
2312                  */
2313                 if ((status & NAND_STATUS_FAIL) && (chip->errstat))
2314                         status = chip->errstat(mtd, chip, FL_ERASING,
2315                                                status, page);
2316
2317                 /* See if block erase succeeded */
2318                 if (status & NAND_STATUS_FAIL) {
2319                         MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: Failed erase, "
2320                                         "page 0x%08x\n", __func__, page);
2321                         instr->state = MTD_ERASE_FAILED;
2322                         instr->fail_addr =
2323                                 ((loff_t)page << chip->page_shift);
2324                         goto erase_exit;
2325                 }
2326
2327                 /*
2328                  * If BBT requires refresh, set the BBT rewrite flag to the
2329                  * page being erased
2330                  */
2331                 if (bbt_masked_page != 0xffffffff &&
2332                     (page & BBT_PAGE_MASK) == bbt_masked_page)
2333                         rewrite_bbt[chipnr] =
2334                                 ((loff_t)page << chip->page_shift);
2335
2336                 /* Increment page address and decrement length */
2337                 len -= (1 << chip->phys_erase_shift);
2338                 page += pages_per_block;
2339
2340                 /* Check, if we cross a chip boundary */
2341                 if (len && !(page & chip->pagemask)) {
2342                         chipnr++;
2343                         chip->select_chip(mtd, -1);
2344                         chip->select_chip(mtd, chipnr);
2345
2346                         /*
2347                          * If BBT requires refresh and BBT-PERCHIP, set the BBT
2348                          * page mask to see if this BBT should be rewritten
2349                          */
2350                         if (bbt_masked_page != 0xffffffff &&
2351                             (chip->bbt_td->options & NAND_BBT_PERCHIP))
2352                                 bbt_masked_page = chip->bbt_td->pages[chipnr] &
2353                                         BBT_PAGE_MASK;
2354                 }
2355         }
2356         instr->state = MTD_ERASE_DONE;
2357
2358 erase_exit:
2359
2360         ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2361
2362         /* Deselect and wake up anyone waiting on the device */
2363         nand_release_device(mtd);
2364
2365         /* Do call back function */
2366         if (!ret)
2367                 mtd_erase_callback(instr);
2368
2369         /*
2370          * If BBT requires refresh and erase was successful, rewrite any
2371          * selected bad block tables
2372          */
2373         if (bbt_masked_page == 0xffffffff || ret)
2374                 return ret;
2375
2376         for (chipnr = 0; chipnr < chip->numchips; chipnr++) {
2377                 if (!rewrite_bbt[chipnr])
2378                         continue;
2379                 /* update the BBT for chip */
2380                 MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: nand_update_bbt "
2381                         "(%d:0x%0llx 0x%0x)\n", __func__, chipnr,
2382                         rewrite_bbt[chipnr], chip->bbt_td->pages[chipnr]);
2383                 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2384         }
2385
2386         /* Return more or less happy */
2387         return ret;
2388 }
2389
2390 /**
2391  * nand_sync - [MTD Interface] sync
2392  * @mtd:        MTD device structure
2393  *
2394  * Sync is actually a wait for chip ready function
2395  */
2396 static void nand_sync(struct mtd_info *mtd)
2397 {
2398         struct nand_chip *chip = mtd->priv;
2399
2400         MTDDEBUG(MTD_DEBUG_LEVEL3, "%s: called\n", __func__);
2401
2402         /* Grab the lock and see if the device is available */
2403         nand_get_device(chip, mtd, FL_SYNCING);
2404         /* Release it and go back */
2405         nand_release_device(mtd);
2406 }
2407
2408 /**
2409  * nand_block_isbad - [MTD Interface] Check if block at offset is bad
2410  * @mtd:        MTD device structure
2411  * @offs:       offset relative to mtd start
2412  */
2413 static int nand_block_isbad(struct mtd_info *mtd, loff_t offs)
2414 {
2415         /* Check for invalid offset */
2416         if (offs > mtd->size)
2417                 return -EINVAL;
2418
2419         return nand_block_checkbad(mtd, offs, 1, 0);
2420 }
2421
2422 /**
2423  * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad
2424  * @mtd:        MTD device structure
2425  * @ofs:        offset relative to mtd start
2426  */
2427 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2428 {
2429         struct nand_chip *chip = mtd->priv;
2430         int ret;
2431
2432         ret = nand_block_isbad(mtd, ofs);
2433         if (ret) {
2434                 /* If it was bad already, return success and do nothing. */
2435                 if (ret > 0)
2436                         return 0;
2437                 return ret;
2438         }
2439
2440         return chip->block_markbad(mtd, ofs);
2441 }
2442
2443 /*
2444  * Set default functions
2445  */
2446 static void nand_set_defaults(struct nand_chip *chip, int busw)
2447 {
2448         /* check for proper chip_delay setup, set 20us if not */
2449         if (!chip->chip_delay)
2450                 chip->chip_delay = 20;
2451
2452         /* check, if a user supplied command function given */
2453         if (chip->cmdfunc == NULL)
2454                 chip->cmdfunc = nand_command;
2455
2456         /* check, if a user supplied wait function given */
2457         if (chip->waitfunc == NULL)
2458                 chip->waitfunc = nand_wait;
2459
2460         if (!chip->select_chip)
2461                 chip->select_chip = nand_select_chip;
2462         if (!chip->read_byte)
2463                 chip->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2464         if (!chip->read_word)
2465                 chip->read_word = nand_read_word;
2466         if (!chip->block_bad)
2467                 chip->block_bad = nand_block_bad;
2468         if (!chip->block_markbad)
2469                 chip->block_markbad = nand_default_block_markbad;
2470         if (!chip->write_buf)
2471                 chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2472         if (!chip->read_buf)
2473                 chip->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2474         if (!chip->verify_buf)
2475                 chip->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2476         if (!chip->scan_bbt)
2477                 chip->scan_bbt = nand_default_bbt;
2478         if (!chip->controller)
2479                 chip->controller = &chip->hwcontrol;
2480 }
2481
2482 #ifdef CONFIG_SYS_NAND_ONFI_DETECTION
2483 /*
2484  * sanitize ONFI strings so we can safely print them
2485  */
2486 static void sanitize_string(char *s, size_t len)
2487 {
2488         ssize_t i;
2489
2490         /* null terminate */
2491         s[len - 1] = 0;
2492
2493         /* remove non printable chars */
2494         for (i = 0; i < len - 1; i++) {
2495                 if (s[i] < ' ' || s[i] > 127)
2496                         s[i] = '?';
2497         }
2498
2499         /* remove trailing spaces */
2500         strim(s);
2501 }
2502
2503 static u16 onfi_crc16(u16 crc, u8 const *p, size_t len)
2504 {
2505         int i;
2506         while (len--) {
2507                 crc ^= *p++ << 8;
2508                 for (i = 0; i < 8; i++)
2509                         crc = (crc << 1) ^ ((crc & 0x8000) ? 0x8005 : 0);
2510         }
2511
2512         return crc;
2513 }
2514
2515 /*
2516  * Check if the NAND chip is ONFI compliant, returns 1 if it is, 0 otherwise
2517  */
2518 static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip,
2519                                         int *busw)
2520 {
2521         struct nand_onfi_params *p = &chip->onfi_params;
2522         int i;
2523         int val;
2524
2525         /* try ONFI for unknow chip or LP */
2526         chip->cmdfunc(mtd, NAND_CMD_READID, 0x20, -1);
2527         if (chip->read_byte(mtd) != 'O' || chip->read_byte(mtd) != 'N' ||
2528                 chip->read_byte(mtd) != 'F' || chip->read_byte(mtd) != 'I')
2529                 return 0;
2530
2531         printk(KERN_INFO "ONFI flash detected\n");
2532         chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1);
2533         for (i = 0; i < 3; i++) {
2534                 chip->read_buf(mtd, (uint8_t *)p, sizeof(*p));
2535                 if (onfi_crc16(ONFI_CRC_BASE, (uint8_t *)p, 254) ==
2536                                 le16_to_cpu(p->crc)) {
2537                         printk(KERN_INFO "ONFI param page %d valid\n", i);
2538                         break;
2539                 }
2540         }
2541
2542         if (i == 3)
2543                 return 0;
2544
2545         /* check version */
2546         val = le16_to_cpu(p->revision);
2547         if (val & (1 << 5))
2548                 chip->onfi_version = 23;
2549         else if (val & (1 << 4))
2550                 chip->onfi_version = 22;
2551         else if (val & (1 << 3))
2552                 chip->onfi_version = 21;
2553         else if (val & (1 << 2))
2554                 chip->onfi_version = 20;
2555         else if (val & (1 << 1))
2556                 chip->onfi_version = 10;
2557         else
2558                 chip->onfi_version = 0;
2559
2560         if (!chip->onfi_version) {
2561                 printk(KERN_INFO "%s: unsupported ONFI version: %d\n",
2562                                                                 __func__, val);
2563                 return 0;
2564         }
2565
2566         sanitize_string(p->manufacturer, sizeof(p->manufacturer));
2567         sanitize_string(p->model, sizeof(p->model));
2568         if (!mtd->name)
2569                 mtd->name = p->model;
2570         mtd->writesize = le32_to_cpu(p->byte_per_page);
2571         mtd->erasesize = le32_to_cpu(p->pages_per_block) * mtd->writesize;
2572         mtd->oobsize = le16_to_cpu(p->spare_bytes_per_page);
2573         chip->chipsize = (uint64_t)le32_to_cpu(p->blocks_per_lun) * mtd->erasesize;
2574         *busw = 0;
2575         if (le16_to_cpu(p->features) & 1)
2576                 *busw = NAND_BUSWIDTH_16;
2577
2578         chip->options &= ~NAND_CHIPOPTIONS_MSK;
2579         chip->options |= (NAND_NO_READRDY |
2580                         NAND_NO_AUTOINCR) & NAND_CHIPOPTIONS_MSK;
2581
2582         return 1;
2583 }
2584 #else
2585 static inline int nand_flash_detect_onfi(struct mtd_info *mtd,
2586                                         struct nand_chip *chip,
2587                                         int *busw)
2588 {
2589         return 0;
2590 }
2591 #endif
2592
2593 /*
2594  * Get the flash and manufacturer id and lookup if the type is supported
2595  */
2596 static const struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
2597                                                   struct nand_chip *chip,
2598                                                   int busw,
2599                                                   int *maf_id, int *dev_id,
2600                                                   const struct nand_flash_dev *type)
2601 {
2602         int i, maf_idx;
2603         u8 id_data[8];
2604         int ret;
2605
2606         /* Select the device */
2607         chip->select_chip(mtd, 0);
2608
2609         /*
2610          * Reset the chip, required by some chips (e.g. Micron MT29FxGxxxxx)
2611          * after power-up
2612          */
2613         chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
2614
2615         /* Send the command for reading device ID */
2616         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2617
2618         /* Read manufacturer and device IDs */
2619         *maf_id = chip->read_byte(mtd);
2620         *dev_id = chip->read_byte(mtd);
2621
2622         /* Try again to make sure, as some systems the bus-hold or other
2623          * interface concerns can cause random data which looks like a
2624          * possibly credible NAND flash to appear. If the two results do
2625          * not match, ignore the device completely.
2626          */
2627
2628         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2629
2630         for (i = 0; i < 2; i++)
2631                 id_data[i] = chip->read_byte(mtd);
2632
2633         if (id_data[0] != *maf_id || id_data[1] != *dev_id) {
2634                 printk(KERN_INFO "%s: second ID read did not match "
2635                        "%02x,%02x against %02x,%02x\n", __func__,
2636                        *maf_id, *dev_id, id_data[0], id_data[1]);
2637                 return ERR_PTR(-ENODEV);
2638         }
2639
2640         if (!type)
2641                 type = nand_flash_ids;
2642
2643         for (; type->name != NULL; type++)
2644                 if (*dev_id == type->id)
2645                         break;
2646
2647         chip->onfi_version = 0;
2648         if (!type->name || !type->pagesize) {
2649                 /* Check is chip is ONFI compliant */
2650                 ret = nand_flash_detect_onfi(mtd, chip, &busw);
2651                 if (ret)
2652                         goto ident_done;
2653         }
2654
2655         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2656
2657         /* Read entire ID string */
2658
2659         for (i = 0; i < 8; i++)
2660                 id_data[i] = chip->read_byte(mtd);
2661
2662         if (!type->name)
2663                 return ERR_PTR(-ENODEV);
2664
2665         if (!mtd->name)
2666                 mtd->name = type->name;
2667
2668         chip->chipsize = (uint64_t)type->chipsize << 20;
2669
2670         if (!type->pagesize && chip->init_size) {
2671                 /* set the pagesize, oobsize, erasesize by the driver*/
2672                 busw = chip->init_size(mtd, chip, id_data);
2673         } else if (!type->pagesize) {
2674                 int extid;
2675                 /* The 3rd id byte holds MLC / multichip data */
2676                 chip->cellinfo = id_data[2];
2677                 /* The 4th id byte is the important one */
2678                 extid = id_data[3];
2679
2680                 /*
2681                  * Field definitions are in the following datasheets:
2682                  * Old style (4,5 byte ID): Samsung K9GAG08U0M (p.32)
2683                  * New style   (6 byte ID): Samsung K9GBG08U0M (p.40)
2684                  *
2685                  * Check for wraparound + Samsung ID + nonzero 6th byte
2686                  * to decide what to do.
2687                  */
2688                 if (id_data[0] == id_data[6] && id_data[1] == id_data[7] &&
2689                                 id_data[0] == NAND_MFR_SAMSUNG &&
2690                                 (chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
2691                                 id_data[5] != 0x00) {
2692                         /* Calc pagesize */
2693                         mtd->writesize = 2048 << (extid & 0x03);
2694                         extid >>= 2;
2695                         /* Calc oobsize */
2696                         switch (extid & 0x03) {
2697                         case 1:
2698                                 mtd->oobsize = 128;
2699                                 break;
2700                         case 2:
2701                                 mtd->oobsize = 218;
2702                                 break;
2703                         case 3:
2704                                 mtd->oobsize = 400;
2705                                 break;
2706                         default:
2707                                 mtd->oobsize = 436;
2708                                 break;
2709                         }
2710                         extid >>= 2;
2711                         /* Calc blocksize */
2712                         mtd->erasesize = (128 * 1024) <<
2713                                 (((extid >> 1) & 0x04) | (extid & 0x03));
2714                         busw = 0;
2715                 } else {
2716                         /* Calc pagesize */
2717                         mtd->writesize = 1024 << (extid & 0x03);
2718                         extid >>= 2;
2719                         /* Calc oobsize */
2720                         mtd->oobsize = (8 << (extid & 0x01)) *
2721                                 (mtd->writesize >> 9);
2722                         extid >>= 2;
2723                         /* Calc blocksize. Blocksize is multiples of 64KiB */
2724                         mtd->erasesize = (64 * 1024) << (extid & 0x03);
2725                         extid >>= 2;
2726                         /* Get buswidth information */
2727                         busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2728                 }
2729         } else {
2730                 /*
2731                  * Old devices have chip data hardcoded in the device id table
2732                  */
2733                 mtd->erasesize = type->erasesize;
2734                 mtd->writesize = type->pagesize;
2735                 mtd->oobsize = mtd->writesize / 32;
2736                 busw = type->options & NAND_BUSWIDTH_16;
2737
2738                 /*
2739                  * Check for Spansion/AMD ID + repeating 5th, 6th byte since
2740                  * some Spansion chips have erasesize that conflicts with size
2741                  * listed in nand_ids table
2742                  * Data sheet (5 byte ID): Spansion S30ML-P ORNAND (p.39)
2743                  */
2744                 if (*maf_id == NAND_MFR_AMD && id_data[4] != 0x00 &&
2745                                 id_data[5] == 0x00 && id_data[6] == 0x00 &&
2746                                 id_data[7] == 0x00 && mtd->writesize == 512) {
2747                         mtd->erasesize = 128 * 1024;
2748                         mtd->erasesize <<= ((id_data[3] & 0x03) << 1);
2749                 }
2750         }
2751         /* Get chip options, preserve non chip based options */
2752         chip->options &= ~NAND_CHIPOPTIONS_MSK;
2753         chip->options |= type->options & NAND_CHIPOPTIONS_MSK;
2754
2755         /* Check if chip is a not a samsung device. Do not clear the
2756          * options for chips which are not having an extended id.
2757          */
2758         if (*maf_id != NAND_MFR_SAMSUNG && !type->pagesize)
2759                 chip->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2760 ident_done:
2761
2762         /*
2763          * Set chip as a default. Board drivers can override it, if necessary
2764          */
2765         chip->options |= NAND_NO_AUTOINCR;
2766
2767         /* Try to identify manufacturer */
2768         for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_idx++) {
2769                 if (nand_manuf_ids[maf_idx].id == *maf_id)
2770                         break;
2771         }
2772
2773         /*
2774          * Check, if buswidth is correct. Hardware drivers should set
2775          * chip correct !
2776          */
2777         if (busw != (chip->options & NAND_BUSWIDTH_16)) {
2778                 printk(KERN_INFO "NAND device: Manufacturer ID:"
2779                        " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
2780                        *dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
2781                 printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
2782                        (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,
2783                        busw ? 16 : 8);
2784                 return ERR_PTR(-EINVAL);
2785         }
2786
2787         /* Calculate the address shift from the page size */
2788         chip->page_shift = ffs(mtd->writesize) - 1;
2789         /* Convert chipsize to number of pages per chip -1. */
2790         chip->pagemask = (chip->chipsize >> chip->page_shift) - 1;
2791
2792         chip->bbt_erase_shift = chip->phys_erase_shift =
2793                 ffs(mtd->erasesize) - 1;
2794         if (chip->chipsize & 0xffffffff)
2795                 chip->chip_shift = ffs((unsigned)chip->chipsize) - 1;
2796         else {
2797                 chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32));
2798                 chip->chip_shift += 32 - 1;
2799         }
2800
2801         chip->badblockbits = 8;
2802
2803         /* Set the bad block position */
2804         if (mtd->writesize > 512 || (busw & NAND_BUSWIDTH_16))
2805                 chip->badblockpos = NAND_LARGE_BADBLOCK_POS;
2806         else
2807                 chip->badblockpos = NAND_SMALL_BADBLOCK_POS;
2808
2809         /*
2810          * Bad block marker is stored in the last page of each block
2811          * on Samsung and Hynix MLC devices; stored in first two pages
2812          * of each block on Micron devices with 2KiB pages and on
2813          * SLC Samsung, Hynix, Toshiba and AMD/Spansion. All others scan
2814          * only the first page.
2815          */
2816         if ((chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
2817                         (*maf_id == NAND_MFR_SAMSUNG ||
2818                          *maf_id == NAND_MFR_HYNIX))
2819                 chip->options |= NAND_BBT_SCANLASTPAGE;
2820         else if ((!(chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
2821                                 (*maf_id == NAND_MFR_SAMSUNG ||
2822                                  *maf_id == NAND_MFR_HYNIX ||
2823                                  *maf_id == NAND_MFR_TOSHIBA ||
2824                                  *maf_id == NAND_MFR_AMD)) ||
2825                         (mtd->writesize == 2048 &&
2826                          *maf_id == NAND_MFR_MICRON))
2827                 chip->options |= NAND_BBT_SCAN2NDPAGE;
2828
2829         /*
2830          * Numonyx/ST 2K pages, x8 bus use BOTH byte 1 and 6
2831          */
2832         if (!(busw & NAND_BUSWIDTH_16) &&
2833                         *maf_id == NAND_MFR_STMICRO &&
2834                         mtd->writesize == 2048) {
2835                 chip->options |= NAND_BBT_SCANBYTE1AND6;
2836                 chip->badblockpos = 0;
2837         }
2838
2839         /* Check for AND chips with 4 page planes */
2840         if (chip->options & NAND_4PAGE_ARRAY)
2841                 chip->erase_cmd = multi_erase_cmd;
2842         else
2843                 chip->erase_cmd = single_erase_cmd;
2844
2845         /* Do not replace user supplied command function ! */
2846         if (mtd->writesize > 512 && chip->cmdfunc == nand_command)
2847                 chip->cmdfunc = nand_command_lp;
2848
2849         /* TODO onfi flash name */
2850         MTDDEBUG (MTD_DEBUG_LEVEL0, "NAND device: Manufacturer ID:"
2851                 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, *dev_id,
2852                 nand_manuf_ids[maf_idx].name,
2853 #ifdef CONFIG_SYS_NAND_ONFI_DETECTION
2854                 chip->onfi_version ? chip->onfi_params.model : type->name);
2855 #else
2856                 type->name);
2857 #endif
2858
2859         return type;
2860 }
2861
2862 /**
2863  * nand_scan_ident - [NAND Interface] Scan for the NAND device
2864  * @mtd:             MTD device structure
2865  * @maxchips:        Number of chips to scan for
2866  * @table:           Alternative NAND ID table
2867  *
2868  * This is the first phase of the normal nand_scan() function. It
2869  * reads the flash ID and sets up MTD fields accordingly.
2870  *
2871  * The mtd->owner field must be set to the module of the caller.
2872  */
2873 int nand_scan_ident(struct mtd_info *mtd, int maxchips,
2874                     const struct nand_flash_dev *table)
2875 {
2876         int i, busw, nand_maf_id, nand_dev_id;
2877         struct nand_chip *chip = mtd->priv;
2878         const struct nand_flash_dev *type;
2879
2880         /* Get buswidth to select the correct functions */
2881         busw = chip->options & NAND_BUSWIDTH_16;
2882         /* Set the default functions */
2883         nand_set_defaults(chip, busw);
2884
2885         /* Read the flash type */
2886         type = nand_get_flash_type(mtd, chip, busw,
2887                                 &nand_maf_id, &nand_dev_id, table);
2888
2889         if (IS_ERR(type)) {
2890 #ifndef CONFIG_SYS_NAND_QUIET_TEST
2891                 printk(KERN_WARNING "No NAND device found!!!\n");
2892 #endif
2893                 chip->select_chip(mtd, -1);
2894                 return PTR_ERR(type);
2895         }
2896
2897         /* Check for a chip array */
2898         for (i = 1; i < maxchips; i++) {
2899                 chip->select_chip(mtd, i);
2900                 /* See comment in nand_get_flash_type for reset */
2901                 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
2902                 /* Send the command for reading device ID */
2903                 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2904                 /* Read manufacturer and device IDs */
2905                 if (nand_maf_id != chip->read_byte(mtd) ||
2906                     nand_dev_id != chip->read_byte(mtd))
2907                         break;
2908         }
2909 #ifdef DEBUG
2910         if (i > 1)
2911                 printk(KERN_INFO "%d NAND chips detected\n", i);
2912 #endif
2913
2914         /* Store the number of chips and calc total size for mtd */
2915         chip->numchips = i;
2916         mtd->size = i * chip->chipsize;
2917
2918         return 0;
2919 }
2920
2921
2922 /**
2923  * nand_scan_tail - [NAND Interface] Scan for the NAND device
2924  * @mtd:            MTD device structure
2925  *
2926  * This is the second phase of the normal nand_scan() function. It
2927  * fills out all the uninitialized function pointers with the defaults
2928  * and scans for a bad block table if appropriate.
2929  */
2930 int nand_scan_tail(struct mtd_info *mtd)
2931 {
2932         uint32_t dev_width;
2933         int i;
2934         struct nand_chip *chip = mtd->priv;
2935
2936         if (!(chip->options & NAND_OWN_BUFFERS))
2937                 chip->buffers = kmalloc(sizeof(*chip->buffers), GFP_KERNEL);
2938         if (!chip->buffers)
2939                 return -ENOMEM;
2940
2941         /* Set the internal oob buffer location, just after the page data */
2942         chip->oob_poi = chip->buffers->databuf + mtd->writesize;
2943
2944         dev_width = (chip->options & NAND_BUSWIDTH_16) >> 1;
2945
2946         /*
2947          * If no default placement scheme is given, select an appropriate one
2948          */
2949         if (!chip->ecc.layout && (chip->ecc.mode != NAND_ECC_SOFT_BCH)) {
2950                 switch (mtd->oobsize) {
2951                 case 8:
2952                         chip->ecc.layout = &nand_oob_8;
2953                         break;
2954                 case 16:
2955                         chip->ecc.layout = &nand_oob_16;
2956                         break;
2957                 case 64:
2958                         chip->ecc.layout = &nand_oob_64;
2959                         break;
2960                 case 128:
2961                         chip->ecc.layout = &nand_oob_128;
2962                         break;
2963                 default:
2964                         printk(KERN_WARNING "No oob scheme defined for "
2965                                "oobsize %d\n", mtd->oobsize);
2966                 }
2967         }
2968
2969         if (!chip->write_page)
2970                 chip->write_page = nand_write_page;
2971
2972         /*
2973          * check ECC mode, default to software if 3byte/512byte hardware ECC is
2974          * selected and we have 256 byte pagesize fallback to software ECC
2975          */
2976
2977         switch (chip->ecc.mode) {
2978         case NAND_ECC_HW_OOB_FIRST:
2979                 /* Similar to NAND_ECC_HW, but a separate read_page handle */
2980                 if (!chip->ecc.calculate || !chip->ecc.correct ||
2981                      !chip->ecc.hwctl) {
2982                         printk(KERN_WARNING "No ECC functions supplied; "
2983                                "Hardware ECC not possible\n");
2984                         BUG();
2985                 }
2986                 if (!chip->ecc.read_page)
2987                         chip->ecc.read_page = nand_read_page_hwecc_oob_first;
2988
2989         case NAND_ECC_HW:
2990                 /* Use standard hwecc read page function ? */
2991                 if (!chip->ecc.read_page)
2992                         chip->ecc.read_page = nand_read_page_hwecc;
2993                 if (!chip->ecc.write_page)
2994                         chip->ecc.write_page = nand_write_page_hwecc;
2995                 if (!chip->ecc.read_page_raw)
2996                         chip->ecc.read_page_raw = nand_read_page_raw;
2997                 if (!chip->ecc.write_page_raw)
2998                         chip->ecc.write_page_raw = nand_write_page_raw;
2999                 if (!chip->ecc.read_oob)
3000                         chip->ecc.read_oob = nand_read_oob_std;
3001                 if (!chip->ecc.write_oob)
3002                         chip->ecc.write_oob = nand_write_oob_std;
3003
3004         case NAND_ECC_HW_SYNDROME:
3005                 if ((!chip->ecc.calculate || !chip->ecc.correct ||
3006                      !chip->ecc.hwctl) &&
3007                     (!chip->ecc.read_page ||
3008                      chip->ecc.read_page == nand_read_page_hwecc ||
3009                      !chip->ecc.write_page ||
3010                      chip->ecc.write_page == nand_write_page_hwecc)) {
3011                         printk(KERN_WARNING "No ECC functions supplied; "
3012                                "Hardware ECC not possible\n");
3013                         BUG();
3014                 }
3015                 /* Use standard syndrome read/write page function ? */
3016                 if (!chip->ecc.read_page)
3017                         chip->ecc.read_page = nand_read_page_syndrome;
3018                 if (!chip->ecc.write_page)
3019                         chip->ecc.write_page = nand_write_page_syndrome;
3020                 if (!chip->ecc.read_page_raw)
3021                         chip->ecc.read_page_raw = nand_read_page_raw_syndrome;
3022                 if (!chip->ecc.write_page_raw)
3023                         chip->ecc.write_page_raw = nand_write_page_raw_syndrome;
3024                 if (!chip->ecc.read_oob)
3025                         chip->ecc.read_oob = nand_read_oob_syndrome;
3026                 if (!chip->ecc.write_oob)
3027                         chip->ecc.write_oob = nand_write_oob_syndrome;
3028
3029                 if (mtd->writesize >= chip->ecc.size)
3030                         break;
3031                 printk(KERN_WARNING "%d byte HW ECC not possible on "
3032                        "%d byte page size, fallback to SW ECC\n",
3033                        chip->ecc.size, mtd->writesize);
3034                 chip->ecc.mode = NAND_ECC_SOFT;
3035
3036         case NAND_ECC_SOFT:
3037                 chip->ecc.calculate = nand_calculate_ecc;
3038                 chip->ecc.correct = nand_correct_data;
3039                 chip->ecc.read_page = nand_read_page_swecc;
3040                 chip->ecc.read_subpage = nand_read_subpage;
3041                 chip->ecc.write_page = nand_write_page_swecc;
3042                 chip->ecc.read_page_raw = nand_read_page_raw;
3043                 chip->ecc.write_page_raw = nand_write_page_raw;
3044                 chip->ecc.read_oob = nand_read_oob_std;
3045                 chip->ecc.write_oob = nand_write_oob_std;
3046                 if (!chip->ecc.size)
3047                         chip->ecc.size = 256;
3048                 chip->ecc.bytes = 3;
3049                 break;
3050
3051         case NAND_ECC_SOFT_BCH:
3052                 if (!mtd_nand_has_bch()) {
3053                         printk(KERN_WARNING "CONFIG_MTD_ECC_BCH not enabled\n");
3054                         return -EINVAL;
3055                 }
3056                 chip->ecc.calculate = nand_bch_calculate_ecc;
3057                 chip->ecc.correct = nand_bch_correct_data;
3058                 chip->ecc.read_page = nand_read_page_swecc;
3059                 chip->ecc.read_subpage = nand_read_subpage;
3060                 chip->ecc.write_page = nand_write_page_swecc;
3061                 chip->ecc.read_page_raw = nand_read_page_raw;
3062                 chip->ecc.write_page_raw = nand_write_page_raw;
3063                 chip->ecc.read_oob = nand_read_oob_std;
3064                 chip->ecc.write_oob = nand_write_oob_std;
3065                 /*
3066                  * Board driver should supply ecc.size and ecc.bytes values to
3067                  * select how many bits are correctable; see nand_bch_init()
3068                  * for details.
3069                  * Otherwise, default to 4 bits for large page devices
3070                  */
3071                 if (!chip->ecc.size && (mtd->oobsize >= 64)) {
3072                         chip->ecc.size = 512;
3073                         chip->ecc.bytes = 7;
3074                 }
3075                 chip->ecc.priv = nand_bch_init(mtd,
3076                                                chip->ecc.size,
3077                                                chip->ecc.bytes,
3078                                                &chip->ecc.layout);
3079                 if (!chip->ecc.priv)
3080                         printk(KERN_WARNING "BCH ECC initialization failed!\n");
3081
3082                 break;
3083
3084         case NAND_ECC_NONE:
3085                 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
3086                        "This is not recommended !!\n");
3087                 chip->ecc.read_page = nand_read_page_raw;
3088                 chip->ecc.write_page = nand_write_page_raw;
3089                 chip->ecc.read_oob = nand_read_oob_std;
3090                 chip->ecc.read_page_raw = nand_read_page_raw;
3091                 chip->ecc.write_page_raw = nand_write_page_raw;
3092                 chip->ecc.write_oob = nand_write_oob_std;
3093                 chip->ecc.size = mtd->writesize;
3094                 chip->ecc.bytes = 0;
3095                 break;
3096
3097         default:
3098                 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
3099                        chip->ecc.mode);
3100                 BUG();
3101         }
3102
3103         /*
3104          * The number of bytes available for a client to place data into
3105          * the out of band area
3106          */
3107         chip->ecc.layout->oobavail = 0;
3108         for (i = 0; chip->ecc.layout->oobfree[i].length
3109                         && i < ARRAY_SIZE(chip->ecc.layout->oobfree); i++)
3110                 chip->ecc.layout->oobavail +=
3111                         chip->ecc.layout->oobfree[i].length;
3112         mtd->oobavail = chip->ecc.layout->oobavail;
3113
3114         /*
3115          * Set the number of read / write steps for one page depending on ECC
3116          * mode
3117          */
3118         chip->ecc.steps = mtd->writesize / chip->ecc.size;
3119         if (chip->ecc.steps * chip->ecc.size != mtd->writesize) {
3120                 printk(KERN_WARNING "Invalid ecc parameters\n");
3121                 BUG();
3122         }
3123         chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;
3124
3125         /*
3126          * Allow subpage writes up to ecc.steps. Not possible for MLC
3127          * FLASH.
3128          */
3129         if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&
3130             !(chip->cellinfo & NAND_CI_CELLTYPE_MSK)) {
3131                 switch (chip->ecc.steps) {
3132                 case 2:
3133                         mtd->subpage_sft = 1;
3134                         break;
3135                 case 4:
3136                 case 8:
3137                 case 16:
3138                         mtd->subpage_sft = 2;
3139                         break;
3140                 }
3141         }
3142         chip->subpagesize = mtd->writesize >> mtd->subpage_sft;
3143
3144         /* Initialize state */
3145         chip->state = FL_READY;
3146
3147         /* De-select the device */
3148         chip->select_chip(mtd, -1);
3149
3150         /* Invalidate the pagebuffer reference */
3151         chip->pagebuf = -1;
3152
3153         /* Fill in remaining MTD driver data */
3154         mtd->type = MTD_NANDFLASH;
3155         mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM :
3156                                                 MTD_CAP_NANDFLASH;
3157         mtd->erase = nand_erase;
3158         mtd->point = NULL;
3159         mtd->unpoint = NULL;
3160         mtd->read = nand_read;
3161         mtd->write = nand_write;
3162         mtd->read_oob = nand_read_oob;
3163         mtd->write_oob = nand_write_oob;
3164         mtd->sync = nand_sync;
3165         mtd->lock = NULL;
3166         mtd->unlock = NULL;
3167         mtd->block_isbad = nand_block_isbad;
3168         mtd->block_markbad = nand_block_markbad;
3169
3170         /* propagate ecc.layout to mtd_info */
3171         mtd->ecclayout = chip->ecc.layout;
3172
3173         /* Check, if we should skip the bad block table scan */
3174         if (chip->options & NAND_SKIP_BBTSCAN)
3175                 chip->options |= NAND_BBT_SCANNED;
3176
3177         return 0;
3178 }
3179
3180 /**
3181  * nand_scan - [NAND Interface] Scan for the NAND device
3182  * @mtd:        MTD device structure
3183  * @maxchips:   Number of chips to scan for
3184  *
3185  * This fills out all the uninitialized function pointers
3186  * with the defaults.
3187  * The flash ID is read and the mtd/chip structures are
3188  * filled with the appropriate values.
3189  * The mtd->owner field must be set to the module of the caller
3190  *
3191  */
3192 int nand_scan(struct mtd_info *mtd, int maxchips)
3193 {
3194         int ret;
3195
3196         ret = nand_scan_ident(mtd, maxchips, NULL);
3197         if (!ret)
3198                 ret = nand_scan_tail(mtd);
3199         return ret;
3200 }
3201
3202 /**
3203  * nand_release - [NAND Interface] Free resources held by the NAND device
3204  * @mtd:        MTD device structure
3205 */
3206 void nand_release(struct mtd_info *mtd)
3207 {
3208         struct nand_chip *chip = mtd->priv;
3209
3210         if (chip->ecc.mode == NAND_ECC_SOFT_BCH)
3211                 nand_bch_free((struct nand_bch_control *)chip->ecc.priv);
3212
3213 #ifdef CONFIG_MTD_PARTITIONS
3214         /* Deregister partitions */
3215         del_mtd_partitions(mtd);
3216 #endif
3217
3218         /* Free bad block table memory */
3219         kfree(chip->bbt);
3220         if (!(chip->options & NAND_OWN_BUFFERS))
3221                 kfree(chip->buffers);
3222
3223         /* Free bad block descriptor memory */
3224         if (chip->badblock_pattern && chip->badblock_pattern->options
3225                         & NAND_BBT_DYNAMICSTRUCT)
3226                 kfree(chip->badblock_pattern);
3227 }