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/tech/nand.html
  11  *
  12  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  13  *                2002 Thomas Gleixner (tglx@linutronix.de)
  14  *
  15  *  02-08-2004  tglx: support for strange chips, which cannot auto increment
  16  *              pages on read / read_oob
  17  *
  18  *  03-17-2004  tglx: Check ready before auto increment check. Simon Bayes
  19  *              pointed this out, as he marked an auto increment capable chip
  20  *              as NOAUTOINCR in the board driver.
  21  *              Make reads over block boundaries work too
  22  *
  23  *  04-14-2004  tglx: first working version for 2k page size chips
  24  *
  25  *  05-19-2004  tglx: Basic support for Renesas AG-AND chips
  26  *
  27  *  09-24-2004  tglx: add support for hardware controllers (e.g. ECC) shared
  28  *              among multiple independend devices. Suggestions and initial patch
  29  *              from Ben Dooks <ben-mtd@fluff.org>
  30  *
  31  *  12-05-2004  dmarlin: add workaround for Renesas AG-AND chips "disturb" issue.
  32  *              Basically, any block not rewritten may lose data when surrounding blocks
  33  *              are rewritten many times.  JFFS2 ensures this doesn't happen for blocks
  34  *              it uses, but the Bad Block Table(s) may not be rewritten.  To ensure they
  35  *              do not lose data, force them to be rewritten when some of the surrounding
  36  *              blocks are erased.  Rather than tracking a specific nearby block (which
  37  *              could itself go bad), use a page address 'mask' to select several blocks
  38  *              in the same area, and rewrite the BBT when any of them are erased.
  39  *
  40  *  01-03-2005  dmarlin: added support for the device recovery command sequence for Renesas
  41  *              AG-AND chips.  If there was a sudden loss of power during an erase operation,
  42  *              a "device recovery" operation must be performed when power is restored
  43  *              to ensure correct operation.
  44  *
  45  *  01-20-2005  dmarlin: added support for optional hardware specific callback routine to
  46  *              perform extra error status checks on erase and write failures.  This required
  47  *              adding a wrapper function for nand_read_ecc.
  48  *
  49  * Credits:
  50  *      David Woodhouse for adding multichip support
  51  *
  52  *      Aleph One Ltd. and Toby Churchill Ltd. for supporting the
  53  *      rework for 2K page size chips
  54  *
  55  * TODO:
  56  *      Enable cached programming for 2k page size chips
  57  *      Check, if mtd->ecctype should be set to MTD_ECC_HW
  58  *      if we have HW ecc support.
  59  *      The AG-AND chips have nice features for speed improvement,
  60  *      which are not supported yet. Read / program 4 pages in one go.
  61  *
  62  * $Id: nand_base.c,v 1.141 2005/04/06 20:13:05 dbrown Exp $
  63  *
  64  * This program is free software; you can redistribute it and/or modify
  65  * it under the terms of the GNU General Public License version 2 as
  66  * published by the Free Software Foundation.
  67  *
  68  */
  69
  70 #include <linux/delay.h>
  71 #include <linux/errno.h>
  72 #include <linux/sched.h>
  73 #include <linux/slab.h>
  74 #include <linux/types.h>
  75 #include <linux/mtd/mtd.h>
  76 #include <linux/mtd/nand.h>
  77 #include <linux/mtd/nand_ecc.h>
  78 #include <linux/mtd/compatmac.h>
  79 #include <linux/interrupt.h>
  80 #include <linux/bitops.h>
  81 #include <asm/io.h>
  82
  83 #ifdef CONFIG_MTD_PARTITIONS
  84 #include <linux/mtd/partitions.h>
  85 #endif
  86
  87 /* Define default oob placement schemes for large and small page devices */
  88 static struct nand_oobinfo nand_oob_8 = {
  89         .useecc = MTD_NANDECC_AUTOPLACE,
  90         .eccbytes = 3,
  91         .eccpos = {0, 1, 2},
  92         .oobfree = { {3, 2}, {6, 2} }
  93 };
  94
  95 static struct nand_oobinfo nand_oob_16 = {
  96         .useecc = MTD_NANDECC_AUTOPLACE,
  97         .eccbytes = 6,
  98         .eccpos = {0, 1, 2, 3, 6, 7},
  99         .oobfree = { {8, 8} }
 100 };
 101
 102 static struct nand_oobinfo nand_oob_64 = {
 103         .useecc = MTD_NANDECC_AUTOPLACE,
 104         .eccbytes = 24,
 105         .eccpos = {
 106                 40, 41, 42, 43, 44, 45, 46, 47,
 107                 48, 49, 50, 51, 52, 53, 54, 55,
 108                 56, 57, 58, 59, 60, 61, 62, 63},
 109         .oobfree = { {2, 38} }
 110 };
 111
 112 /* This is used for padding purposes in nand_write_oob */
 113 static u_char ffchars[] = {
 114         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 115         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 116         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 117         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 118         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 119         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 120         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 121         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 122 };
 123
 124 /*
 125  * NAND low-level MTD interface functions
 126  */
 127 static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len);
 128 static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len);
 129 static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len);
 130
 131 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
 132 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
 133                           size_t * retlen, u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
 134 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
 135 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf);
 136 static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
 137                            size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
 138 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char *buf);
 139 static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs,
 140                         unsigned long count, loff_t to, size_t * retlen);
 141 static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs,
 142                         unsigned long count, loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
 143 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
 144 static void nand_sync (struct mtd_info *mtd);
 145
 146 /* Some internal functions */
 147 static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, u_char *oob_buf,
 148                 struct nand_oobinfo *oobsel, int mode);
 149 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
 150 static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
 151         u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode);
 152 #else
 153 #define nand_verify_pages(...) (0)
 154 #endif
 155
 156 static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state);
 157
 158 /**
 159  * nand_release_device - [GENERIC] release chip
 160  * @mtd:        MTD device structure
 161  *
 162  * Deselect, release chip lock and wake up anyone waiting on the device
 163  */
 164 static void nand_release_device (struct mtd_info *mtd)
 165 {
 166         struct nand_chip *this = mtd->priv;
 167
 168         /* De-select the NAND device */
 169         this->select_chip(mtd, -1);
 170         /* Do we have a hardware controller ? */
 171         if (this->controller) {
 172                 spin_lock(&this->controller->lock);
 173                 this->controller->active = NULL;
 174                 spin_unlock(&this->controller->lock);
 175         }
 176         /* Release the chip */
 177         spin_lock (&this->chip_lock);
 178         this->state = FL_READY;
 179         wake_up (&this->wq);
 180         spin_unlock (&this->chip_lock);
 181 }
 182
 183 /**
 184  * nand_read_byte - [DEFAULT] read one byte from the chip
 185  * @mtd:        MTD device structure
 186  *
 187  * Default read function for 8bit buswith
 188  */
 189 static u_char nand_read_byte(struct mtd_info *mtd)
 190 {
 191         struct nand_chip *this = mtd->priv;
 192         return readb(this->IO_ADDR_R);
 193 }
 194
 195 /**
 196  * nand_write_byte - [DEFAULT] write one byte to the chip
 197  * @mtd:        MTD device structure
 198  * @byte:       pointer to data byte to write
 199  *
 200  * Default write function for 8it buswith
 201  */
 202 static void nand_write_byte(struct mtd_info *mtd, u_char byte)
 203 {
 204         struct nand_chip *this = mtd->priv;
 205         writeb(byte, this->IO_ADDR_W);
 206 }
 207
 208 /**
 209  * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
 210  * @mtd:        MTD device structure
 211  *
 212  * Default read function for 16bit buswith with
 213  * endianess conversion
 214  */
 215 static u_char nand_read_byte16(struct mtd_info *mtd)
 216 {
 217         struct nand_chip *this = mtd->priv;
 218         return (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
 219 }
 220
 221 /**
 222  * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
 223  * @mtd:        MTD device structure
 224  * @byte:       pointer to data byte to write
 225  *
 226  * Default write function for 16bit buswith with
 227  * endianess conversion
 228  */
 229 static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
 230 {
 231         struct nand_chip *this = mtd->priv;
 232         writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
 233 }
 234
 235 /**
 236  * nand_read_word - [DEFAULT] read one word from the chip
 237  * @mtd:        MTD device structure
 238  *
 239  * Default read function for 16bit buswith without
 240  * endianess conversion
 241  */
 242 static u16 nand_read_word(struct mtd_info *mtd)
 243 {
 244         struct nand_chip *this = mtd->priv;
 245         return readw(this->IO_ADDR_R);
 246 }
 247
 248 /**
 249  * nand_write_word - [DEFAULT] write one word to the chip
 250  * @mtd:        MTD device structure
 251  * @word:       data word to write
 252  *
 253  * Default write function for 16bit buswith without
 254  * endianess conversion
 255  */
 256 static void nand_write_word(struct mtd_info *mtd, u16 word)
 257 {
 258         struct nand_chip *this = mtd->priv;
 259         writew(word, this->IO_ADDR_W);
 260 }
 261
 262 /**
 263  * nand_select_chip - [DEFAULT] control CE line
 264  * @mtd:        MTD device structure
 265  * @chip:       chipnumber to select, -1 for deselect
 266  *
 267  * Default select function for 1 chip devices.
 268  */
 269 static void nand_select_chip(struct mtd_info *mtd, int chip)
 270 {
 271         struct nand_chip *this = mtd->priv;
 272         switch(chip) {
 273         case -1:
 274                 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
 275                 break;
 276         case 0:
 277                 this->hwcontrol(mtd, NAND_CTL_SETNCE);
 278                 break;
 279
 280         default:
 281                 BUG();
 282         }
 283 }
 284
 285 /**
 286  * nand_write_buf - [DEFAULT] write buffer to chip
 287  * @mtd:        MTD device structure
 288  * @buf:        data buffer
 289  * @len:        number of bytes to write
 290  *
 291  * Default write function for 8bit buswith
 292  */
 293 static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 294 {
 295         int i;
 296         struct nand_chip *this = mtd->priv;
 297
 298         for (i=0; i<len; i++)
 299                 writeb(buf[i], this->IO_ADDR_W);
 300 }
 301
 302 /**
 303  * nand_read_buf - [DEFAULT] read chip data into buffer
 304  * @mtd:        MTD device structure
 305  * @buf:        buffer to store date
 306  * @len:        number of bytes to read
 307  *
 308  * Default read function for 8bit buswith
 309  */
 310 static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 311 {
 312         int i;
 313         struct nand_chip *this = mtd->priv;
 314
 315         for (i=0; i<len; i++)
 316                 buf[i] = readb(this->IO_ADDR_R);
 317 }
 318
 319 /**
 320  * nand_verify_buf - [DEFAULT] Verify chip data against buffer
 321  * @mtd:        MTD device structure
 322  * @buf:        buffer containing the data to compare
 323  * @len:        number of bytes to compare
 324  *
 325  * Default verify function for 8bit buswith
 326  */
 327 static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
 328 {
 329         int i;
 330         struct nand_chip *this = mtd->priv;
 331
 332         for (i=0; i<len; i++)
 333                 if (buf[i] != readb(this->IO_ADDR_R))
 334                         return -EFAULT;
 335
 336         return 0;
 337 }
 338
 339 /**
 340  * nand_write_buf16 - [DEFAULT] write buffer to chip
 341  * @mtd:        MTD device structure
 342  * @buf:        data buffer
 343  * @len:        number of bytes to write
 344  *
 345  * Default write function for 16bit buswith
 346  */
 347 static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 348 {
 349         int i;
 350         struct nand_chip *this = mtd->priv;
 351         u16 *p = (u16 *) buf;
 352         len >>= 1;
 353
 354         for (i=0; i<len; i++)
 355                 writew(p[i], this->IO_ADDR_W);
 356
 357 }
 358
 359 /**
 360  * nand_read_buf16 - [DEFAULT] read chip data into buffer
 361  * @mtd:        MTD device structure
 362  * @buf:        buffer to store date
 363  * @len:        number of bytes to read
 364  *
 365  * Default read function for 16bit buswith
 366  */
 367 static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
 368 {
 369         int i;
 370         struct nand_chip *this = mtd->priv;
 371         u16 *p = (u16 *) buf;
 372         len >>= 1;
 373
 374         for (i=0; i<len; i++)
 375                 p[i] = readw(this->IO_ADDR_R);
 376 }
 377
 378 /**
 379  * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
 380  * @mtd:        MTD device structure
 381  * @buf:        buffer containing the data to compare
 382  * @len:        number of bytes to compare
 383  *
 384  * Default verify function for 16bit buswith
 385  */
 386 static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 387 {
 388         int i;
 389         struct nand_chip *this = mtd->priv;
 390         u16 *p = (u16 *) buf;
 391         len >>= 1;
 392
 393         for (i=0; i<len; i++)
 394                 if (p[i] != readw(this->IO_ADDR_R))
 395                         return -EFAULT;
 396
 397         return 0;
 398 }
 399
 400 /**
 401  * nand_block_bad - [DEFAULT] Read bad block marker from the chip
 402  * @mtd:        MTD device structure
 403  * @ofs:        offset from device start
 404  * @getchip:    0, if the chip is already selected
 405  *
 406  * Check, if the block is bad.
 407  */
 408 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
 409 {
 410         int page, chipnr, res = 0;
 411         struct nand_chip *this = mtd->priv;
 412         u16 bad;
 413
 414         if (getchip) {
 415                 page = (int)(ofs >> this->page_shift);
 416                 chipnr = (int)(ofs >> this->chip_shift);
 417
 418                 /* Grab the lock and see if the device is available */
 419                 nand_get_device (this, mtd, FL_READING);
 420
 421                 /* Select the NAND device */
 422                 this->select_chip(mtd, chipnr);
 423         } else
 424                 page = (int) ofs;
 425
 426         if (this->options & NAND_BUSWIDTH_16) {
 427                 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
 428                 bad = cpu_to_le16(this->read_word(mtd));
 429                 if (this->badblockpos & 0x1)
 430                         bad >>= 1;
 431                 if ((bad & 0xFF) != 0xff)
 432                         res = 1;
 433         } else {
 434                 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
 435                 if (this->read_byte(mtd) != 0xff)
 436                         res = 1;
 437         }
 438
 439         if (getchip) {
 440                 /* Deselect and wake up anyone waiting on the device */
 441                 nand_release_device(mtd);
 442         }
 443
 444         return res;
 445 }
 446
 447 /**
 448  * nand_default_block_markbad - [DEFAULT] mark a block bad
 449  * @mtd:        MTD device structure
 450  * @ofs:        offset from device start
 451  *
 452  * This is the default implementation, which can be overridden by
 453  * a hardware specific driver.
 454 */
 455 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
 456 {
 457         struct nand_chip *this = mtd->priv;
 458         u_char buf[2] = {0, 0};
 459         size_t  retlen;
 460         int block;
 461
 462         /* Get block number */
 463         block = ((int) ofs) >> this->bbt_erase_shift;
 464         if (this->bbt)
 465                 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
 466
 467         /* Do we have a flash based bad block table ? */
 468         if (this->options & NAND_USE_FLASH_BBT)
 469                 return nand_update_bbt (mtd, ofs);
 470
 471         /* We write two bytes, so we dont have to mess with 16 bit access */
 472         ofs += mtd->oobsize + (this->badblockpos & ~0x01);
 473         return nand_write_oob (mtd, ofs , 2, &retlen, buf);
 474 }
 475
 476 /**
 477  * nand_check_wp - [GENERIC] check if the chip is write protected
 478  * @mtd:        MTD device structure
 479  * Check, if the device is write protected
 480  *
 481  * The function expects, that the device is already selected
 482  */
 483 static int nand_check_wp (struct mtd_info *mtd)
 484 {
 485         struct nand_chip *this = mtd->priv;
 486         /* Check the WP bit */
 487         this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
 488         return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
 489 }
 490
 491 /**
 492  * nand_block_checkbad - [GENERIC] Check if a block is marked bad
 493  * @mtd:        MTD device structure
 494  * @ofs:        offset from device start
 495  * @getchip:    0, if the chip is already selected
 496  * @allowbbt:   1, if its allowed to access the bbt area
 497  *
 498  * Check, if the block is bad. Either by reading the bad block table or
 499  * calling of the scan function.
 500  */
 501 static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
 502 {
 503         struct nand_chip *this = mtd->priv;
 504
 505         if (!this->bbt)
 506                 return this->block_bad(mtd, ofs, getchip);
 507
 508         /* Return info from the table */
 509         return nand_isbad_bbt (mtd, ofs, allowbbt);
 510 }
 511
 512 /*
 513  * Wait for the ready pin, after a command
 514  * The timeout is catched later.
 515  */
 516 static void nand_wait_ready(struct mtd_info *mtd)
 517 {
 518         struct nand_chip *this = mtd->priv;
 519         unsigned long   timeo = jiffies + 2;
 520
 521         /* wait until command is processed or timeout occures */
 522         do {
 523                 if (this->dev_ready(mtd))
 524                         return;
 525         } while (time_before(jiffies, timeo));
 526 }
 527
 528 /**
 529  * nand_command - [DEFAULT] Send command to NAND device
 530  * @mtd:        MTD device structure
 531  * @command:    the command to be sent
 532  * @column:     the column address for this command, -1 if none
 533  * @page_addr:  the page address for this command, -1 if none
 534  *
 535  * Send command to NAND device. This function is used for small page
 536  * devices (256/512 Bytes per page)
 537  */
 538 static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
 539 {
 540         register struct nand_chip *this = mtd->priv;
 541
 542         /* Begin command latch cycle */
 543         this->hwcontrol(mtd, NAND_CTL_SETCLE);
 544         /*
 545          * Write out the command to the device.
 546          */
 547         if (command == NAND_CMD_SEQIN) {
 548                 int readcmd;
 549
 550                 if (column >= mtd->oobblock) {
 551                         /* OOB area */
 552                         column -= mtd->oobblock;
 553                         readcmd = NAND_CMD_READOOB;
 554                 } else if (column < 256) {
 555                         /* First 256 bytes --> READ0 */
 556                         readcmd = NAND_CMD_READ0;
 557                 } else {
 558                         column -= 256;
 559                         readcmd = NAND_CMD_READ1;
 560                 }
 561                 this->write_byte(mtd, readcmd);
 562         }
 563         this->write_byte(mtd, command);
 564
 565         /* Set ALE and clear CLE to start address cycle */
 566         this->hwcontrol(mtd, NAND_CTL_CLRCLE);
 567
 568         if (column != -1 || page_addr != -1) {
 569                 this->hwcontrol(mtd, NAND_CTL_SETALE);
 570
 571                 /* Serially input address */
 572                 if (column != -1) {
 573                         /* Adjust columns for 16 bit buswidth */
 574                         if (this->options & NAND_BUSWIDTH_16)
 575                                 column >>= 1;
 576                         this->write_byte(mtd, column);
 577                 }
 578                 if (page_addr != -1) {
 579                         this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
 580                         this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
 581                         /* One more address cycle for devices > 32MiB */
 582                         if (this->chipsize > (32 << 20))
 583                                 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
 584                 }
 585                 /* Latch in address */
 586                 this->hwcontrol(mtd, NAND_CTL_CLRALE);
 587         }
 588
 589         /*
 590          * program and erase have their own busy handlers
 591          * status and sequential in needs no delay
 592         */
 593         switch (command) {
 594
 595         case NAND_CMD_PAGEPROG:
 596         case NAND_CMD_ERASE1:
 597         case NAND_CMD_ERASE2:
 598         case NAND_CMD_SEQIN:
 599         case NAND_CMD_STATUS:
 600                 return;
 601
 602         case NAND_CMD_RESET:
 603                 if (this->dev_ready)
 604                         break;
 605                 udelay(this->chip_delay);
 606                 this->hwcontrol(mtd, NAND_CTL_SETCLE);
 607                 this->write_byte(mtd, NAND_CMD_STATUS);
 608                 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
 609                 while ( !(this->read_byte(mtd) & NAND_STATUS_READY));
 610                 return;
 611
 612         /* This applies to read commands */
 613         default:
 614                 /*
 615                  * If we don't have access to the busy pin, we apply the given
 616                  * command delay
 617                 */
 618                 if (!this->dev_ready) {
 619                         udelay (this->chip_delay);
 620                         return;
 621                 }
 622         }
 623         /* Apply this short delay always to ensure that we do wait tWB in
 624          * any case on any machine. */
 625         ndelay (100);
 626
 627         nand_wait_ready(mtd);
 628 }
 629
 630 /**
 631  * nand_command_lp - [DEFAULT] Send command to NAND large page device
 632  * @mtd:        MTD device structure
 633  * @command:    the command to be sent
 634  * @column:     the column address for this command, -1 if none
 635  * @page_addr:  the page address for this command, -1 if none
 636  *
 637  * Send command to NAND device. This is the version for the new large page devices
 638  * We dont have the seperate regions as we have in the small page devices.
 639  * We must emulate NAND_CMD_READOOB to keep the code compatible.
 640  *
 641  */
 642 static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr)
 643 {
 644         register struct nand_chip *this = mtd->priv;
 645
 646         /* Emulate NAND_CMD_READOOB */
 647         if (command == NAND_CMD_READOOB) {
 648                 column += mtd->oobblock;
 649                 command = NAND_CMD_READ0;
 650         }
 651
 652
 653         /* Begin command latch cycle */
 654         this->hwcontrol(mtd, NAND_CTL_SETCLE);
 655         /* Write out the command to the device. */
 656         this->write_byte(mtd, (command & 0xff));
 657         /* End command latch cycle */
 658         this->hwcontrol(mtd, NAND_CTL_CLRCLE);
 659
 660         if (column != -1 || page_addr != -1) {
 661                 this->hwcontrol(mtd, NAND_CTL_SETALE);
 662
 663                 /* Serially input address */
 664                 if (column != -1) {
 665                         /* Adjust columns for 16 bit buswidth */
 666                         if (this->options & NAND_BUSWIDTH_16)
 667                                 column >>= 1;
 668                         this->write_byte(mtd, column & 0xff);
 669                         this->write_byte(mtd, column >> 8);
 670                 }
 671                 if (page_addr != -1) {
 672                         this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
 673                         this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
 674                         /* One more address cycle for devices > 128MiB */
 675                         if (this->chipsize > (128 << 20))
 676                                 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff));
 677                 }
 678                 /* Latch in address */
 679                 this->hwcontrol(mtd, NAND_CTL_CLRALE);
 680         }
 681
 682         /*
 683          * program and erase have their own busy handlers
 684          * status, sequential in, and deplete1 need no delay
 685          */
 686         switch (command) {
 687
 688         case NAND_CMD_CACHEDPROG:
 689         case NAND_CMD_PAGEPROG:
 690         case NAND_CMD_ERASE1:
 691         case NAND_CMD_ERASE2:
 692         case NAND_CMD_SEQIN:
 693         case NAND_CMD_STATUS:
 694         case NAND_CMD_DEPLETE1:
 695                 return;
 696
 697         /*
 698          * read error status commands require only a short delay
 699          */
 700         case NAND_CMD_STATUS_ERROR:
 701         case NAND_CMD_STATUS_ERROR0:
 702         case NAND_CMD_STATUS_ERROR1:
 703         case NAND_CMD_STATUS_ERROR2:
 704         case NAND_CMD_STATUS_ERROR3:
 705                 udelay(this->chip_delay);
 706                 return;
 707
 708         case NAND_CMD_RESET:
 709                 if (this->dev_ready)
 710                         break;
 711                 udelay(this->chip_delay);
 712                 this->hwcontrol(mtd, NAND_CTL_SETCLE);
 713                 this->write_byte(mtd, NAND_CMD_STATUS);
 714                 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
 715                 while ( !(this->read_byte(mtd) & NAND_STATUS_READY));
 716                 return;
 717
 718         case NAND_CMD_READ0:
 719                 /* Begin command latch cycle */
 720                 this->hwcontrol(mtd, NAND_CTL_SETCLE);
 721                 /* Write out the start read command */
 722                 this->write_byte(mtd, NAND_CMD_READSTART);
 723                 /* End command latch cycle */
 724                 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
 725                 /* Fall through into ready check */
 726
 727         /* This applies to read commands */
 728         default:
 729                 /*
 730                  * If we don't have access to the busy pin, we apply the given
 731                  * command delay
 732                 */
 733                 if (!this->dev_ready) {
 734                         udelay (this->chip_delay);
 735                         return;
 736                 }
 737         }
 738
 739         /* Apply this short delay always to ensure that we do wait tWB in
 740          * any case on any machine. */
 741         ndelay (100);
 742
 743         nand_wait_ready(mtd);
 744 }
 745
 746 /**
 747  * nand_get_device - [GENERIC] Get chip for selected access
 748  * @this:       the nand chip descriptor
 749  * @mtd:        MTD device structure
 750  * @new_state:  the state which is requested
 751  *
 752  * Get the device and lock it for exclusive access
 753  */
 754 static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state)
 755 {
 756         struct nand_chip *active = this;
 757
 758         DECLARE_WAITQUEUE (wait, current);
 759
 760         /*
 761          * Grab the lock and see if the device is available
 762         */
 763 retry:
 764         /* Hardware controller shared among independend devices */
 765         if (this->controller) {
 766                 spin_lock (&this->controller->lock);
 767                 if (this->controller->active)
 768                         active = this->controller->active;
 769                 else
 770                         this->controller->active = this;
 771                 spin_unlock (&this->controller->lock);
 772         }
 773
 774         if (active == this) {
 775                 spin_lock (&this->chip_lock);
 776                 if (this->state == FL_READY) {
 777                         this->state = new_state;
 778                         spin_unlock (&this->chip_lock);
 779                         return;
 780                 }
 781         }
 782         set_current_state (TASK_UNINTERRUPTIBLE);
 783         add_wait_queue (&active->wq, &wait);
 784         spin_unlock (&active->chip_lock);
 785         schedule ();
 786         remove_wait_queue (&active->wq, &wait);
 787         goto retry;
 788 }
 789
 790 /**
 791  * nand_wait - [DEFAULT]  wait until the command is done
 792  * @mtd:        MTD device structure
 793  * @this:       NAND chip structure
 794  * @state:      state to select the max. timeout value
 795  *
 796  * Wait for command done. This applies to erase and program only
 797  * Erase can take up to 400ms and program up to 20ms according to
 798  * general NAND and SmartMedia specs
 799  *
 800 */
 801 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
 802 {
 803
 804         unsigned long   timeo = jiffies;
 805         int     status;
 806
 807         if (state == FL_ERASING)
 808                  timeo += (HZ * 400) / 1000;
 809         else
 810                  timeo += (HZ * 20) / 1000;
 811
 812         /* Apply this short delay always to ensure that we do wait tWB in
 813          * any case on any machine. */
 814         ndelay (100);
 815
 816         if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
 817                 this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
 818         else
 819                 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
 820
 821         while (time_before(jiffies, timeo)) {
 822                 /* Check, if we were interrupted */
 823                 if (this->state != state)
 824                         return 0;
 825
 826                 if (this->dev_ready) {
 827                         if (this->dev_ready(mtd))
 828                                 break;
 829                 } else {
 830                         if (this->read_byte(mtd) & NAND_STATUS_READY)
 831                                 break;
 832                 }
 833                 cond_resched();
 834         }
 835         status = (int) this->read_byte(mtd);
 836         return status;
 837 }
 838
 839 /**
 840  * nand_write_page - [GENERIC] write one page
 841  * @mtd:        MTD device structure
 842  * @this:       NAND chip structure
 843  * @page:       startpage inside the chip, must be called with (page & this->pagemask)
 844  * @oob_buf:    out of band data buffer
 845  * @oobsel:     out of band selecttion structre
 846  * @cached:     1 = enable cached programming if supported by chip
 847  *
 848  * Nand_page_program function is used for write and writev !
 849  * This function will always program a full page of data
 850  * If you call it with a non page aligned buffer, you're lost :)
 851  *
 852  * Cached programming is not supported yet.
 853  */
 854 static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
 855         u_char *oob_buf,  struct nand_oobinfo *oobsel, int cached)
 856 {
 857         int     i, status;
 858         u_char  ecc_code[oobsel->eccbytes];
 859         int     eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
 860         int     *oob_config = oobsel->eccpos;
 861         int     datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
 862         int     eccbytes = 0;
 863
 864         /* FIXME: Enable cached programming */
 865         cached = 0;
 866
 867         /* Send command to begin auto page programming */
 868         this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
 869
 870         /* Write out complete page of data, take care of eccmode */
 871         switch (eccmode) {
 872         /* No ecc, write all */
 873         case NAND_ECC_NONE:
 874                 printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
 875                 this->write_buf(mtd, this->data_poi, mtd->oobblock);
 876                 break;
 877
 878         /* Software ecc 3/256, write all */
 879         case NAND_ECC_SOFT:
 880                 for (; eccsteps; eccsteps--) {
 881                         this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
 882                         for (i = 0; i < 3; i++, eccidx++)
 883                                 oob_buf[oob_config[eccidx]] = ecc_code[i];
 884                         datidx += this->eccsize;
 885                 }
 886                 this->write_buf(mtd, this->data_poi, mtd->oobblock);
 887                 break;
 888         default:
 889                 eccbytes = this->eccbytes;
 890                 for (; eccsteps; eccsteps--) {
 891                         /* enable hardware ecc logic for write */
 892                         this->enable_hwecc(mtd, NAND_ECC_WRITE);
 893                         this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
 894                         this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
 895                         for (i = 0; i < eccbytes; i++, eccidx++)
 896                                 oob_buf[oob_config[eccidx]] = ecc_code[i];
 897                         /* If the hardware ecc provides syndromes then
 898                          * the ecc code must be written immidiately after
 899                          * the data bytes (words) */
 900                         if (this->options & NAND_HWECC_SYNDROME)
 901                                 this->write_buf(mtd, ecc_code, eccbytes);
 902                         datidx += this->eccsize;
 903                 }
 904                 break;
 905         }
 906
 907         /* Write out OOB data */
 908         if (this->options & NAND_HWECC_SYNDROME)
 909                 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
 910         else
 911                 this->write_buf(mtd, oob_buf, mtd->oobsize);
 912
 913         /* Send command to actually program the data */
 914         this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
 915
 916         if (!cached) {
 917                 /* call wait ready function */
 918                 status = this->waitfunc (mtd, this, FL_WRITING);
 919
 920                 /* See if operation failed and additional status checks are available */
 921                 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
 922                         status = this->errstat(mtd, this, FL_WRITING, status, page);
 923                 }
 924
 925                 /* See if device thinks it succeeded */
 926                 if (status & NAND_STATUS_FAIL) {
 927                         DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
 928                         return -EIO;
 929                 }
 930         } else {
 931                 /* FIXME: Implement cached programming ! */
 932                 /* wait until cache is ready*/
 933                 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
 934         }
 935         return 0;
 936 }
 937
 938 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
 939 /**
 940  * nand_verify_pages - [GENERIC] verify the chip contents after a write
 941  * @mtd:        MTD device structure
 942  * @this:       NAND chip structure
 943  * @page:       startpage inside the chip, must be called with (page & this->pagemask)
 944  * @numpages:   number of pages to verify
 945  * @oob_buf:    out of band data buffer
 946  * @oobsel:     out of band selecttion structre
 947  * @chipnr:     number of the current chip
 948  * @oobmode:    1 = full buffer verify, 0 = ecc only
 949  *
 950  * The NAND device assumes that it is always writing to a cleanly erased page.
 951  * Hence, it performs its internal write verification only on bits that
 952  * transitioned from 1 to 0. The device does NOT verify the whole page on a
 953  * byte by byte basis. It is possible that the page was not completely erased
 954  * or the page is becoming unusable due to wear. The read with ECC would catch
 955  * the error later when the ECC page check fails, but we would rather catch
 956  * it early in the page write stage. Better to write no data than invalid data.
 957  */
 958 static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
 959         u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
 960 {
 961         int     i, j, datidx = 0, oobofs = 0, res = -EIO;
 962         int     eccsteps = this->eccsteps;
 963         int     hweccbytes;
 964         u_char  oobdata[mtd->oobsize];
 965
 966         hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
 967
 968         /* Send command to read back the first page */
 969         this->cmdfunc (mtd, NAND_CMD_READ0, 0, page);
 970
 971         for(;;) {
 972                 for (j = 0; j < eccsteps; j++) {
 973                         /* Loop through and verify the data */
 974                         if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
 975                                 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
 976                                 goto out;
 977                         }
 978                         datidx += mtd->eccsize;
 979                         /* Have we a hw generator layout ? */
 980                         if (!hweccbytes)
 981                                 continue;
 982                         if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
 983                                 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
 984                                 goto out;
 985                         }
 986                         oobofs += hweccbytes;
 987                 }
 988
 989                 /* check, if we must compare all data or if we just have to
 990                  * compare the ecc bytes
 991                  */
 992                 if (oobmode) {
 993                         if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
 994                                 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
 995                                 goto out;
 996                         }
 997                 } else {
 998                         /* Read always, else autoincrement fails */
 999                         this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
1000
1001                         if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
1002                                 int ecccnt = oobsel->eccbytes;
1003
1004                                 for (i = 0; i < ecccnt; i++) {
1005                                         int idx = oobsel->eccpos[i];
1006                                         if (oobdata[idx] != oob_buf[oobofs + idx] ) {
1007                                                 DEBUG (MTD_DEBUG_LEVEL0,
1008                                                 "%s: Failed ECC write "
1009                                                 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
1010                                                 goto out;
1011                                         }
1012                                 }
1013                         }
1014                 }
1015                 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1016                 page++;
1017                 numpages--;
1018
1019                 /* Apply delay or wait for ready/busy pin
1020                  * Do this before the AUTOINCR check, so no problems
1021                  * arise if a chip which does auto increment
1022                  * is marked as NOAUTOINCR by the board driver.
1023                  * Do this also before returning, so the chip is
1024                  * ready for the next command.
1025                 */
1026                 if (!this->dev_ready)
1027                         udelay (this->chip_delay);
1028                 else
1029                         nand_wait_ready(mtd);
1030
1031                 /* All done, return happy */
1032                 if (!numpages)
1033                         return 0;
1034
1035
1036                 /* Check, if the chip supports auto page increment */
1037                 if (!NAND_CANAUTOINCR(this))
1038                         this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1039         }
1040         /*
1041          * Terminate the read command. We come here in case of an error
1042          * So we must issue a reset command.
1043          */
1044 out:
1045         this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1);
1046         return res;
1047 }
1048 #endif
1049
1050 /**
1051  * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
1052  * @mtd:        MTD device structure
1053  * @from:       offset to read from
1054  * @len:        number of bytes to read
1055  * @retlen:     pointer to variable to store the number of read bytes
1056  * @buf:        the databuffer to put data
1057  *
1058  * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1059  * and flags = 0xff
1060  */
1061 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1062 {
1063         return nand_do_read_ecc (mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1064 }
1065
1066
1067 /**
1068  * nand_read_ecc - [MTD Interface] MTD compability function for nand_do_read_ecc
1069  * @mtd:        MTD device structure
1070  * @from:       offset to read from
1071  * @len:        number of bytes to read
1072  * @retlen:     pointer to variable to store the number of read bytes
1073  * @buf:        the databuffer to put data
1074  * @oob_buf:    filesystem supplied oob data buffer
1075  * @oobsel:     oob selection structure
1076  *
1077  * This function simply calls nand_do_read_ecc with flags = 0xff
1078  */
1079 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1080                           size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
1081 {
1082         /* use userspace supplied oobinfo, if zero */
1083         if (oobsel == NULL)
1084                 oobsel = &mtd->oobinfo;
1085         return nand_do_read_ecc(mtd, from, len, retlen, buf, oob_buf, oobsel, 0xff);
1086 }
1087
1088
1089 /**
1090  * nand_do_read_ecc - [MTD Interface] Read data with ECC
1091  * @mtd:        MTD device structure
1092  * @from:       offset to read from
1093  * @len:        number of bytes to read
1094  * @retlen:     pointer to variable to store the number of read bytes
1095  * @buf:        the databuffer to put data
1096  * @oob_buf:    filesystem supplied oob data buffer (can be NULL)
1097  * @oobsel:     oob selection structure
1098  * @flags:      flag to indicate if nand_get_device/nand_release_device should be preformed
1099  *              and how many corrected error bits are acceptable:
1100  *                bits 0..7 - number of tolerable errors
1101  *                bit  8    - 0 == do not get/release chip, 1 == get/release chip
1102  *
1103  * NAND read with ECC
1104  */
1105 int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1106                              size_t * retlen, u_char * buf, u_char * oob_buf,
1107                              struct nand_oobinfo *oobsel, int flags)
1108 {
1109
1110         int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1111         int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1112         struct nand_chip *this = mtd->priv;
1113         u_char *data_poi, *oob_data = oob_buf;
1114         u_char ecc_calc[oobsel->eccbytes];
1115         u_char ecc_code[oobsel->eccbytes];
1116         int eccmode, eccsteps;
1117         int     *oob_config, datidx;
1118         int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1119         int     eccbytes;
1120         int     compareecc = 1;
1121         int     oobreadlen;
1122
1123
1124         DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1125
1126         /* Do not allow reads past end of device */
1127         if ((from + len) > mtd->size) {
1128                 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1129                 *retlen = 0;
1130                 return -EINVAL;
1131         }
1132
1133         /* Grab the lock and see if the device is available */
1134         if (flags & NAND_GET_DEVICE)
1135                 nand_get_device (this, mtd, FL_READING);
1136
1137         /* Autoplace of oob data ? Use the default placement scheme */
1138         if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1139                 oobsel = this->autooob;
1140
1141         eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
1142         oob_config = oobsel->eccpos;
1143
1144         /* Select the NAND device */
1145         chipnr = (int)(from >> this->chip_shift);
1146         this->select_chip(mtd, chipnr);
1147
1148         /* First we calculate the starting page */
1149         realpage = (int) (from >> this->page_shift);
1150         page = realpage & this->pagemask;
1151
1152         /* Get raw starting column */
1153         col = from & (mtd->oobblock - 1);
1154
1155         end = mtd->oobblock;
1156         ecc = this->eccsize;
1157         eccbytes = this->eccbytes;
1158
1159         if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1160                 compareecc = 0;
1161
1162         oobreadlen = mtd->oobsize;
1163         if (this->options & NAND_HWECC_SYNDROME)
1164                 oobreadlen -= oobsel->eccbytes;
1165
1166         /* Loop until all data read */
1167         while (read < len) {
1168
1169                 int aligned = (!col && (len - read) >= end);
1170                 /*
1171                  * If the read is not page aligned, we have to read into data buffer
1172                  * due to ecc, else we read into return buffer direct
1173                  */
1174                 if (aligned)
1175                         data_poi = &buf[read];
1176                 else
1177                         data_poi = this->data_buf;
1178
1179                 /* Check, if we have this page in the buffer
1180                  *
1181                  * FIXME: Make it work when we must provide oob data too,
1182                  * check the usage of data_buf oob field
1183                  */
1184                 if (realpage == this->pagebuf && !oob_buf) {
1185                         /* aligned read ? */
1186                         if (aligned)
1187                                 memcpy (data_poi, this->data_buf, end);
1188                         goto readdata;
1189                 }
1190
1191                 /* Check, if we must send the read command */
1192                 if (sndcmd) {
1193                         this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1194                         sndcmd = 0;
1195                 }
1196
1197                 /* get oob area, if we have no oob buffer from fs-driver */
1198                 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1199                         oob_data = &this->data_buf[end];
1200
1201                 eccsteps = this->eccsteps;
1202
1203                 switch (eccmode) {
1204                 case NAND_ECC_NONE: {   /* No ECC, Read in a page */
1205                         static unsigned long lastwhinge = 0;
1206                         if ((lastwhinge / HZ) != (jiffies / HZ)) {
1207                                 printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
1208                                 lastwhinge = jiffies;
1209                         }
1210                         this->read_buf(mtd, data_poi, end);
1211                         break;
1212                 }
1213
1214                 case NAND_ECC_SOFT:     /* Software ECC 3/256: Read in a page + oob data */
1215                         this->read_buf(mtd, data_poi, end);
1216                         for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
1217                                 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
1218                         break;
1219
1220                 default:
1221                         for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
1222                                 this->enable_hwecc(mtd, NAND_ECC_READ);
1223                                 this->read_buf(mtd, &data_poi[datidx], ecc);
1224
1225                                 /* HW ecc with syndrome calculation must read the
1226                                  * syndrome from flash immidiately after the data */
1227                                 if (!compareecc) {
1228                                         /* Some hw ecc generators need to know when the
1229                                          * syndrome is read from flash */
1230                                         this->enable_hwecc(mtd, NAND_ECC_READSYN);
1231                                         this->read_buf(mtd, &oob_data[i], eccbytes);
1232                                         /* We calc error correction directly, it checks the hw
1233                                          * generator for an error, reads back the syndrome and
1234                                          * does the error correction on the fly */
1235                                         ecc_status = this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1236                                         if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1237                                                 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1238                                                         "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1239                                                 ecc_failed++;
1240                                         }
1241                                 } else {
1242                                         this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
1243                                 }
1244                         }
1245                         break;
1246                 }
1247
1248                 /* read oobdata */
1249                 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1250
1251                 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1252                 if (!compareecc)
1253                         goto readoob;
1254
1255                 /* Pick the ECC bytes out of the oob data */
1256                 for (j = 0; j < oobsel->eccbytes; j++)
1257                         ecc_code[j] = oob_data[oob_config[j]];
1258
1259                 /* correct data, if neccecary */
1260                 for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
1261                         ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1262
1263                         /* Get next chunk of ecc bytes */
1264                         j += eccbytes;
1265
1266                         /* Check, if we have a fs supplied oob-buffer,
1267                          * This is the legacy mode. Used by YAFFS1
1268                          * Should go away some day
1269                          */
1270                         if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1271                                 int *p = (int *)(&oob_data[mtd->oobsize]);
1272                                 p[i] = ecc_status;
1273                         }
1274
1275                         if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1276                                 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1277                                 ecc_failed++;
1278                         }
1279                 }
1280
1281         readoob:
1282                 /* check, if we have a fs supplied oob-buffer */
1283                 if (oob_buf) {
1284                         /* without autoplace. Legacy mode used by YAFFS1 */
1285                         switch(oobsel->useecc) {
1286                         case MTD_NANDECC_AUTOPLACE:
1287                                 /* Walk through the autoplace chunks */
1288                                 for (i = 0; oobsel->oobfree[i][1]; i++) {
1289                                         int from = oobsel->oobfree[i][0];
1290                                         int num = oobsel->oobfree[i][1];
1291                                         memcpy(&oob_buf[oob], &oob_data[from], num);
1292                                         oob += num;
1293                                 }
1294                                 break;
1295                         case MTD_NANDECC_PLACE:
1296                                 /* YAFFS1 legacy mode */
1297                                 oob_data += this->eccsteps * sizeof (int);
1298                         default:
1299                                 oob_data += mtd->oobsize;
1300                         }
1301                 }
1302         readdata:
1303                 /* Partial page read, transfer data into fs buffer */
1304                 if (!aligned) {
1305                         for (j = col; j < end && read < len; j++)
1306                                 buf[read++] = data_poi[j];
1307                         this->pagebuf = realpage;
1308                 } else
1309                         read += mtd->oobblock;
1310
1311                 /* Apply delay or wait for ready/busy pin
1312                  * Do this before the AUTOINCR check, so no problems
1313                  * arise if a chip which does auto increment
1314                  * is marked as NOAUTOINCR by the board driver.
1315                 */
1316                 if (!this->dev_ready)
1317                         udelay (this->chip_delay);
1318                 else
1319                         nand_wait_ready(mtd);
1320
1321                 if (read == len)
1322                         break;
1323
1324                 /* For subsequent reads align to page boundary. */
1325                 col = 0;
1326                 /* Increment page address */
1327                 realpage++;
1328
1329                 page = realpage & this->pagemask;
1330                 /* Check, if we cross a chip boundary */
1331                 if (!page) {
1332                         chipnr++;
1333                         this->select_chip(mtd, -1);
1334                         this->select_chip(mtd, chipnr);
1335                 }
1336                 /* Check, if the chip supports auto page increment
1337                  * or if we have hit a block boundary.
1338                 */
1339                 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1340                         sndcmd = 1;
1341         }
1342
1343         /* Deselect and wake up anyone waiting on the device */
1344         if (flags & NAND_GET_DEVICE)
1345                 nand_release_device(mtd);
1346
1347         /*
1348          * Return success, if no ECC failures, else -EBADMSG
1349          * fs driver will take care of that, because
1350          * retlen == desired len and result == -EBADMSG
1351          */
1352         *retlen = read;
1353         return ecc_failed ? -EBADMSG : 0;
1354 }
1355
1356 /**
1357  * nand_read_oob - [MTD Interface] NAND read out-of-band
1358  * @mtd:        MTD device structure
1359  * @from:       offset to read from
1360  * @len:        number of bytes to read
1361  * @retlen:     pointer to variable to store the number of read bytes
1362  * @buf:        the databuffer to put data
1363  *
1364  * NAND read out-of-band data from the spare area
1365  */
1366 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1367 {
1368         int i, col, page, chipnr;
1369         struct nand_chip *this = mtd->priv;
1370         int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1371
1372         DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1373
1374         /* Shift to get page */
1375         page = (int)(from >> this->page_shift);
1376         chipnr = (int)(from >> this->chip_shift);
1377
1378         /* Mask to get column */
1379         col = from & (mtd->oobsize - 1);
1380
1381         /* Initialize return length value */
1382         *retlen = 0;
1383
1384         /* Do not allow reads past end of device */
1385         if ((from + len) > mtd->size) {
1386                 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1387                 *retlen = 0;
1388                 return -EINVAL;
1389         }
1390
1391         /* Grab the lock and see if the device is available */
1392         nand_get_device (this, mtd , FL_READING);
1393
1394         /* Select the NAND device */
1395         this->select_chip(mtd, chipnr);
1396
1397         /* Send the read command */
1398         this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1399         /*
1400          * Read the data, if we read more than one page
1401          * oob data, let the device transfer the data !
1402          */
1403         i = 0;
1404         while (i < len) {
1405                 int thislen = mtd->oobsize - col;
1406                 thislen = min_t(int, thislen, len);
1407                 this->read_buf(mtd, &buf[i], thislen);
1408                 i += thislen;
1409
1410                 /* Apply delay or wait for ready/busy pin
1411                  * Do this before the AUTOINCR check, so no problems
1412                  * arise if a chip which does auto increment
1413                  * is marked as NOAUTOINCR by the board driver.
1414                 */
1415                 if (!this->dev_ready)
1416                         udelay (this->chip_delay);
1417                 else
1418                         nand_wait_ready(mtd);
1419
1420                 /* Read more ? */
1421                 if (i < len) {
1422                         page++;
1423                         col = 0;
1424
1425                         /* Check, if we cross a chip boundary */
1426                         if (!(page & this->pagemask)) {
1427                                 chipnr++;
1428                                 this->select_chip(mtd, -1);
1429                                 this->select_chip(mtd, chipnr);
1430                         }
1431
1432                         /* Check, if the chip supports auto page increment
1433                          * or if we have hit a block boundary.
1434                         */
1435                         if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1436                                 /* For subsequent page reads set offset to 0 */
1437                                 this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1438                         }
1439                 }
1440         }
1441
1442         /* Deselect and wake up anyone waiting on the device */
1443         nand_release_device(mtd);
1444
1445         /* Return happy */
1446         *retlen = len;
1447         return 0;
1448 }
1449
1450 /**
1451  * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1452  * @mtd:        MTD device structure
1453  * @buf:        temporary buffer
1454  * @from:       offset to read from
1455  * @len:        number of bytes to read
1456  * @ooblen:     number of oob data bytes to read
1457  *
1458  * Read raw data including oob into buffer
1459  */
1460 int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1461 {
1462         struct nand_chip *this = mtd->priv;
1463         int page = (int) (from >> this->page_shift);
1464         int chip = (int) (from >> this->chip_shift);
1465         int sndcmd = 1;
1466         int cnt = 0;
1467         int pagesize = mtd->oobblock + mtd->oobsize;
1468         int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1469
1470         /* Do not allow reads past end of device */
1471         if ((from + len) > mtd->size) {
1472                 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1473                 return -EINVAL;
1474         }
1475
1476         /* Grab the lock and see if the device is available */
1477         nand_get_device (this, mtd , FL_READING);
1478
1479         this->select_chip (mtd, chip);
1480
1481         /* Add requested oob length */
1482         len += ooblen;
1483
1484         while (len) {
1485                 if (sndcmd)
1486                         this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1487                 sndcmd = 0;
1488
1489                 this->read_buf (mtd, &buf[cnt], pagesize);
1490
1491                 len -= pagesize;
1492                 cnt += pagesize;
1493                 page++;
1494
1495                 if (!this->dev_ready)
1496                         udelay (this->chip_delay);
1497                 else
1498                         nand_wait_ready(mtd);
1499
1500                 /* Check, if the chip supports auto page increment */
1501                 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1502                         sndcmd = 1;
1503         }
1504
1505         /* Deselect and wake up anyone waiting on the device */
1506         nand_release_device(mtd);
1507         return 0;
1508 }
1509
1510
1511 /**
1512  * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1513  * @mtd:        MTD device structure
1514  * @fsbuf:      buffer given by fs driver
1515  * @oobsel:     out of band selection structre
1516  * @autoplace:  1 = place given buffer into the oob bytes
1517  * @numpages:   number of pages to prepare
1518  *
1519  * Return:
1520  * 1. Filesystem buffer available and autoplacement is off,
1521  *    return filesystem buffer
1522  * 2. No filesystem buffer or autoplace is off, return internal
1523  *    buffer
1524  * 3. Filesystem buffer is given and autoplace selected
1525  *    put data from fs buffer into internal buffer and
1526  *    retrun internal buffer
1527  *
1528  * Note: The internal buffer is filled with 0xff. This must
1529  * be done only once, when no autoplacement happens
1530  * Autoplacement sets the buffer dirty flag, which
1531  * forces the 0xff fill before using the buffer again.
1532  *
1533 */
1534 static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
1535                 int autoplace, int numpages)
1536 {
1537         struct nand_chip *this = mtd->priv;
1538         int i, len, ofs;
1539
1540         /* Zero copy fs supplied buffer */
1541         if (fsbuf && !autoplace)
1542                 return fsbuf;
1543
1544         /* Check, if the buffer must be filled with ff again */
1545         if (this->oobdirty) {
1546                 memset (this->oob_buf, 0xff,
1547                         mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1548                 this->oobdirty = 0;
1549         }
1550
1551         /* If we have no autoplacement or no fs buffer use the internal one */
1552         if (!autoplace || !fsbuf)
1553                 return this->oob_buf;
1554
1555         /* Walk through the pages and place the data */
1556         this->oobdirty = 1;
1557         ofs = 0;
1558         while (numpages--) {
1559                 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1560                         int to = ofs + oobsel->oobfree[i][0];
1561                         int num = oobsel->oobfree[i][1];
1562                         memcpy (&this->oob_buf[to], fsbuf, num);
1563                         len += num;
1564                         fsbuf += num;
1565                 }
1566                 ofs += mtd->oobavail;
1567         }
1568         return this->oob_buf;
1569 }
1570
1571 #define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
1572
1573 /**
1574  * nand_write - [MTD Interface] compability function for nand_write_ecc
1575  * @mtd:        MTD device structure
1576  * @to:         offset to write to
1577  * @len:        number of bytes to write
1578  * @retlen:     pointer to variable to store the number of written bytes
1579  * @buf:        the data to write
1580  *
1581  * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1582  *
1583 */
1584 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1585 {
1586         return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
1587 }
1588
1589 /**
1590  * nand_write_ecc - [MTD Interface] NAND write with ECC
1591  * @mtd:        MTD device structure
1592  * @to:         offset to write to
1593  * @len:        number of bytes to write
1594  * @retlen:     pointer to variable to store the number of written bytes
1595  * @buf:        the data to write
1596  * @eccbuf:     filesystem supplied oob data buffer
1597  * @oobsel:     oob selection structure
1598  *
1599  * NAND write with ECC
1600  */
1601 static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1602                            size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel)
1603 {
1604         int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1605         int autoplace = 0, numpages, totalpages;
1606         struct nand_chip *this = mtd->priv;
1607         u_char *oobbuf, *bufstart;
1608         int     ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1609
1610         DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1611
1612         /* Initialize retlen, in case of early exit */
1613         *retlen = 0;
1614
1615         /* Do not allow write past end of device */
1616         if ((to + len) > mtd->size) {
1617                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
1618                 return -EINVAL;
1619         }
1620
1621         /* reject writes, which are not page aligned */
1622         if (NOTALIGNED (to) || NOTALIGNED(len)) {
1623                 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1624                 return -EINVAL;
1625         }
1626
1627         /* Grab the lock and see if the device is available */
1628         nand_get_device (this, mtd, FL_WRITING);
1629
1630         /* Calculate chipnr */
1631         chipnr = (int)(to >> this->chip_shift);
1632         /* Select the NAND device */
1633         this->select_chip(mtd, chipnr);
1634
1635         /* Check, if it is write protected */
1636         if (nand_check_wp(mtd))
1637                 goto out;
1638
1639         /* if oobsel is NULL, use chip defaults */
1640         if (oobsel == NULL)
1641                 oobsel = &mtd->oobinfo;
1642
1643         /* Autoplace of oob data ? Use the default placement scheme */
1644         if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1645                 oobsel = this->autooob;
1646                 autoplace = 1;
1647         }
1648
1649         /* Setup variables and oob buffer */
1650         totalpages = len >> this->page_shift;
1651         page = (int) (to >> this->page_shift);
1652         /* Invalidate the page cache, if we write to the cached page */
1653         if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1654                 this->pagebuf = -1;
1655
1656         /* Set it relative to chip */
1657         page &= this->pagemask;
1658         startpage = page;
1659         /* Calc number of pages we can write in one go */
1660         numpages = min (ppblock - (startpage  & (ppblock - 1)), totalpages);
1661         oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages);
1662         bufstart = (u_char *)buf;
1663
1664         /* Loop until all data is written */
1665         while (written < len) {
1666
1667                 this->data_poi = (u_char*) &buf[written];
1668                 /* Write one page. If this is the last page to write
1669                  * or the last page in this block, then use the
1670                  * real pageprogram command, else select cached programming
1671                  * if supported by the chip.
1672                  */
1673                 ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1674                 if (ret) {
1675                         DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1676                         goto out;
1677                 }
1678                 /* Next oob page */
1679                 oob += mtd->oobsize;
1680                 /* Update written bytes count */
1681                 written += mtd->oobblock;
1682                 if (written == len)
1683                         goto cmp;
1684
1685                 /* Increment page address */
1686                 page++;
1687
1688                 /* Have we hit a block boundary ? Then we have to verify and
1689                  * if verify is ok, we have to setup the oob buffer for
1690                  * the next pages.
1691                 */
1692                 if (!(page & (ppblock - 1))){
1693                         int ofs;
1694                         this->data_poi = bufstart;
1695                         ret = nand_verify_pages (mtd, this, startpage,
1696                                 page - startpage,
1697                                 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1698                         if (ret) {
1699                                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1700                                 goto out;
1701                         }
1702                         *retlen = written;
1703
1704                         ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1705                         if (eccbuf)
1706                                 eccbuf += (page - startpage) * ofs;
1707                         totalpages -= page - startpage;
1708                         numpages = min (totalpages, ppblock);
1709                         page &= this->pagemask;
1710                         startpage = page;
1711                         oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
1712                                         autoplace, numpages);
1713                         /* Check, if we cross a chip boundary */
1714                         if (!page) {
1715                                 chipnr++;
1716                                 this->select_chip(mtd, -1);
1717                                 this->select_chip(mtd, chipnr);
1718                         }
1719                 }
1720         }
1721         /* Verify the remaining pages */
1722 cmp:
1723         this->data_poi = bufstart;
1724         ret = nand_verify_pages (mtd, this, startpage, totalpages,
1725                 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1726         if (!ret)
1727                 *retlen = written;
1728         else
1729                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1730
1731 out:
1732         /* Deselect and wake up anyone waiting on the device */
1733         nand_release_device(mtd);
1734
1735         return ret;
1736 }
1737
1738
1739 /**
1740  * nand_write_oob - [MTD Interface] NAND write out-of-band
1741  * @mtd:        MTD device structure
1742  * @to:         offset to write to
1743  * @len:        number of bytes to write
1744  * @retlen:     pointer to variable to store the number of written bytes
1745  * @buf:        the data to write
1746  *
1747  * NAND write out-of-band
1748  */
1749 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1750 {
1751         int column, page, status, ret = -EIO, chipnr;
1752         struct nand_chip *this = mtd->priv;
1753
1754         DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1755
1756         /* Shift to get page */
1757         page = (int) (to >> this->page_shift);
1758         chipnr = (int) (to >> this->chip_shift);
1759
1760         /* Mask to get column */
1761         column = to & (mtd->oobsize - 1);
1762
1763         /* Initialize return length value */
1764         *retlen = 0;
1765
1766         /* Do not allow write past end of page */
1767         if ((column + len) > mtd->oobsize) {
1768                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1769                 return -EINVAL;
1770         }
1771
1772         /* Grab the lock and see if the device is available */
1773         nand_get_device (this, mtd, FL_WRITING);
1774
1775         /* Select the NAND device */
1776         this->select_chip(mtd, chipnr);
1777
1778         /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1779            in one of my DiskOnChip 2000 test units) will clear the whole
1780            data page too if we don't do this. I have no clue why, but
1781            I seem to have 'fixed' it in the doc2000 driver in
1782            August 1999.  dwmw2. */
1783         this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1784
1785         /* Check, if it is write protected */
1786         if (nand_check_wp(mtd))
1787                 goto out;
1788
1789         /* Invalidate the page cache, if we write to the cached page */
1790         if (page == this->pagebuf)
1791                 this->pagebuf = -1;
1792
1793         if (NAND_MUST_PAD(this)) {
1794                 /* Write out desired data */
1795                 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1796                 /* prepad 0xff for partial programming */
1797                 this->write_buf(mtd, ffchars, column);
1798                 /* write data */
1799                 this->write_buf(mtd, buf, len);
1800                 /* postpad 0xff for partial programming */
1801                 this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));
1802         } else {
1803                 /* Write out desired data */
1804                 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1805                 /* write data */
1806                 this->write_buf(mtd, buf, len);
1807         }
1808         /* Send command to program the OOB data */
1809         this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);
1810
1811         status = this->waitfunc (mtd, this, FL_WRITING);
1812
1813         /* See if device thinks it succeeded */
1814         if (status & NAND_STATUS_FAIL) {
1815                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1816                 ret = -EIO;
1817                 goto out;
1818         }
1819         /* Return happy */
1820         *retlen = len;
1821
1822 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1823         /* Send command to read back the data */
1824         this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1825
1826         if (this->verify_buf(mtd, buf, len)) {
1827                 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1828                 ret = -EIO;
1829                 goto out;
1830         }
1831 #endif
1832         ret = 0;
1833 out:
1834         /* Deselect and wake up anyone waiting on the device */
1835         nand_release_device(mtd);
1836
1837         return ret;
1838 }
1839
1840
1841 /**
1842  * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1843  * @mtd:        MTD device structure
1844  * @vecs:       the iovectors to write
1845  * @count:      number of vectors
1846  * @to:         offset to write to
1847  * @retlen:     pointer to variable to store the number of written bytes
1848  *
1849  * NAND write with kvec. This just calls the ecc function
1850  */
1851 static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1852                 loff_t to, size_t * retlen)
1853 {
1854         return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));
1855 }
1856
1857 /**
1858  * nand_writev_ecc - [MTD Interface] write with iovec with ecc
1859  * @mtd:        MTD device structure
1860  * @vecs:       the iovectors to write
1861  * @count:      number of vectors
1862  * @to:         offset to write to
1863  * @retlen:     pointer to variable to store the number of written bytes
1864  * @eccbuf:     filesystem supplied oob data buffer
1865  * @oobsel:     oob selection structure
1866  *
1867  * NAND write with iovec with ecc
1868  */
1869 static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1870                 loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
1871 {
1872         int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1873         int oob, numpages, autoplace = 0, startpage;
1874         struct nand_chip *this = mtd->priv;
1875         int     ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1876         u_char *oobbuf, *bufstart;
1877
1878         /* Preset written len for early exit */
1879         *retlen = 0;
1880
1881         /* Calculate total length of data */
1882         total_len = 0;
1883         for (i = 0; i < count; i++)
1884                 total_len += (int) vecs[i].iov_len;
1885
1886         DEBUG (MTD_DEBUG_LEVEL3,
1887                "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
1888
1889         /* Do not allow write past end of page */
1890         if ((to + total_len) > mtd->size) {
1891                 DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1892                 return -EINVAL;
1893         }
1894
1895         /* reject writes, which are not page aligned */
1896         if (NOTALIGNED (to) || NOTALIGNED(total_len)) {
1897                 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1898                 return -EINVAL;
1899         }
1900
1901         /* Grab the lock and see if the device is available */
1902         nand_get_device (this, mtd, FL_WRITING);
1903
1904         /* Get the current chip-nr */
1905         chipnr = (int) (to >> this->chip_shift);
1906         /* Select the NAND device */
1907         this->select_chip(mtd, chipnr);
1908
1909         /* Check, if it is write protected */
1910         if (nand_check_wp(mtd))
1911                 goto out;
1912
1913         /* if oobsel is NULL, use chip defaults */
1914         if (oobsel == NULL)
1915                 oobsel = &mtd->oobinfo;
1916
1917         /* Autoplace of oob data ? Use the default placement scheme */
1918         if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1919                 oobsel = this->autooob;
1920                 autoplace = 1;
1921         }
1922
1923         /* Setup start page */
1924         page = (int) (to >> this->page_shift);
1925         /* Invalidate the page cache, if we write to the cached page */
1926         if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
1927                 this->pagebuf = -1;
1928
1929         startpage = page & this->pagemask;
1930
1931         /* Loop until all kvec' data has been written */
1932         len = 0;
1933         while (count) {
1934                 /* If the given tuple is >= pagesize then
1935                  * write it out from the iov
1936                  */
1937                 if ((vecs->iov_len - len) >= mtd->oobblock) {
1938                         /* Calc number of pages we can write
1939                          * out of this iov in one go */
1940                         numpages = (vecs->iov_len - len) >> this->page_shift;
1941                         /* Do not cross block boundaries */
1942                         numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);
1943                         oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1944                         bufstart = (u_char *)vecs->iov_base;
1945                         bufstart += len;
1946                         this->data_poi = bufstart;
1947                         oob = 0;
1948                         for (i = 1; i <= numpages; i++) {
1949                                 /* Write one page. If this is the last page to write
1950                                  * then use the real pageprogram command, else select
1951                                  * cached programming if supported by the chip.
1952                                  */
1953                                 ret = nand_write_page (mtd, this, page & this->pagemask,
1954                                         &oobbuf[oob], oobsel, i != numpages);
1955                                 if (ret)
1956                                         goto out;
1957                                 this->data_poi += mtd->oobblock;
1958                                 len += mtd->oobblock;
1959                                 oob += mtd->oobsize;
1960                                 page++;
1961                         }
1962                         /* Check, if we have to switch to the next tuple */
1963                         if (len >= (int) vecs->iov_len) {
1964                                 vecs++;
1965                                 len = 0;
1966                                 count--;
1967                         }
1968                 } else {
1969                         /* We must use the internal buffer, read data out of each
1970                          * tuple until we have a full page to write
1971                          */
1972                         int cnt = 0;
1973                         while (cnt < mtd->oobblock) {
1974                                 if (vecs->iov_base != NULL && vecs->iov_len)
1975                                         this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
1976                                 /* Check, if we have to switch to the next tuple */
1977                                 if (len >= (int) vecs->iov_len) {
1978                                         vecs++;
1979                                         len = 0;
1980                                         count--;
1981                                 }
1982                         }
1983                         this->pagebuf = page;
1984                         this->data_poi = this->data_buf;
1985                         bufstart = this->data_poi;
1986                         numpages = 1;
1987                         oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1988                         ret = nand_write_page (mtd, this, page & this->pagemask,
1989                                 oobbuf, oobsel, 0);
1990                         if (ret)
1991                                 goto out;
1992                         page++;
1993                 }
1994
1995                 this->data_poi = bufstart;
1996                 ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
1997                 if (ret)
1998                         goto out;
1999
2000                 written += mtd->oobblock * numpages;
2001                 /* All done ? */
2002                 if (!count)
2003                         break;
2004
2005                 startpage = page & this->pagemask;
2006                 /* Check, if we cross a chip boundary */
2007                 if (!startpage) {
2008                         chipnr++;
2009                         this->select_chip(mtd, -1);
2010                         this->select_chip(mtd, chipnr);
2011                 }
2012         }
2013         ret = 0;
2014 out:
2015         /* Deselect and wake up anyone waiting on the device */
2016         nand_release_device(mtd);
2017
2018         *retlen = written;
2019         return ret;
2020 }
2021
2022 /**
2023  * single_erease_cmd - [GENERIC] NAND standard block erase command function
2024  * @mtd:        MTD device structure
2025  * @page:       the page address of the block which will be erased
2026  *
2027  * Standard erase command for NAND chips
2028  */
2029 static void single_erase_cmd (struct mtd_info *mtd, int page)
2030 {
2031         struct nand_chip *this = mtd->priv;
2032         /* Send commands to erase a block */
2033         this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2034         this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2035 }
2036
2037 /**
2038  * multi_erease_cmd - [GENERIC] AND specific block erase command function
2039  * @mtd:        MTD device structure
2040  * @page:       the page address of the block which will be erased
2041  *
2042  * AND multi block erase command function
2043  * Erase 4 consecutive blocks
2044  */
2045 static void multi_erase_cmd (struct mtd_info *mtd, int page)
2046 {
2047         struct nand_chip *this = mtd->priv;
2048         /* Send commands to erase a block */
2049         this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2050         this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2051         this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2052         this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2053         this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2054 }
2055
2056 /**
2057  * nand_erase - [MTD Interface] erase block(s)
2058  * @mtd:        MTD device structure
2059  * @instr:      erase instruction
2060  *
2061  * Erase one ore more blocks
2062  */
2063 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
2064 {
2065         return nand_erase_nand (mtd, instr, 0);
2066 }
2067
2068 #define BBT_PAGE_MASK   0xffffff3f
2069 /**
2070  * nand_erase_intern - [NAND Interface] erase block(s)
2071  * @mtd:        MTD device structure
2072  * @instr:      erase instruction
2073  * @allowbbt:   allow erasing the bbt area
2074  *
2075  * Erase one ore more blocks
2076  */
2077 int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2078 {
2079         int page, len, status, pages_per_block, ret, chipnr;
2080         struct nand_chip *this = mtd->priv;
2081         int rewrite_bbt[NAND_MAX_CHIPS]={0};    /* flags to indicate the page, if bbt needs to be rewritten. */
2082         unsigned int bbt_masked_page;           /* bbt mask to compare to page being erased. */
2083                                                 /* It is used to see if the current page is in the same */
2084                                                 /*   256 block group and the same bank as the bbt. */
2085
2086         DEBUG (MTD_DEBUG_LEVEL3,
2087                "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
2088
2089         /* Start address must align on block boundary */
2090         if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2091                 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2092                 return -EINVAL;
2093         }
2094
2095         /* Length must align on block boundary */
2096         if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2097                 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2098                 return -EINVAL;
2099         }
2100
2101         /* Do not allow erase past end of device */
2102         if ((instr->len + instr->addr) > mtd->size) {
2103                 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2104                 return -EINVAL;
2105         }
2106
2107         instr->fail_addr = 0xffffffff;
2108
2109         /* Grab the lock and see if the device is available */
2110         nand_get_device (this, mtd, FL_ERASING);
2111
2112         /* Shift to get first page */
2113         page = (int) (instr->addr >> this->page_shift);
2114         chipnr = (int) (instr->addr >> this->chip_shift);
2115
2116         /* Calculate pages in each block */
2117         pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
2118
2119         /* Select the NAND device */
2120         this->select_chip(mtd, chipnr);
2121
2122         /* Check the WP bit */
2123         /* Check, if it is write protected */
2124         if (nand_check_wp(mtd)) {
2125                 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2126                 instr->state = MTD_ERASE_FAILED;
2127                 goto erase_exit;
2128         }
2129
2130         /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
2131         if (this->options & BBT_AUTO_REFRESH) {
2132                 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2133         } else {
2134                 bbt_masked_page = 0xffffffff;   /* should not match anything */
2135         }
2136
2137         /* Loop through the pages */
2138         len = instr->len;
2139
2140         instr->state = MTD_ERASING;
2141
2142         while (len) {
2143                 /* Check if we have a bad block, we do not erase bad blocks ! */
2144                 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2145                         printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2146                         instr->state = MTD_ERASE_FAILED;
2147                         goto erase_exit;
2148                 }
2149
2150                 /* Invalidate the page cache, if we erase the block which contains
2151                    the current cached page */
2152                 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2153                         this->pagebuf = -1;
2154
2155                 this->erase_cmd (mtd, page & this->pagemask);
2156
2157                 status = this->waitfunc (mtd, this, FL_ERASING);
2158
2159                 /* See if operation failed and additional status checks are available */
2160                 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
2161                         status = this->errstat(mtd, this, FL_ERASING, status, page);
2162                 }
2163
2164                 /* See if block erase succeeded */
2165                 if (status & NAND_STATUS_FAIL) {
2166                         DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2167                         instr->state = MTD_ERASE_FAILED;
2168                         instr->fail_addr = (page << this->page_shift);
2169                         goto erase_exit;
2170                 }
2171
2172                 /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
2173                 if (this->options & BBT_AUTO_REFRESH) {
2174                         if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
2175                              (page != this->bbt_td->pages[chipnr])) {
2176                                 rewrite_bbt[chipnr] = (page << this->page_shift);
2177                         }
2178                 }
2179
2180                 /* Increment page address and decrement length */
2181                 len -= (1 << this->phys_erase_shift);
2182                 page += pages_per_block;
2183
2184                 /* Check, if we cross a chip boundary */
2185                 if (len && !(page & this->pagemask)) {
2186                         chipnr++;
2187                         this->select_chip(mtd, -1);
2188                         this->select_chip(mtd, chipnr);
2189
2190                         /* if BBT requires refresh and BBT-PERCHIP,
2191                          *   set the BBT page mask to see if this BBT should be rewritten */
2192                         if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
2193                                 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2194                         }
2195
2196                 }
2197         }
2198         instr->state = MTD_ERASE_DONE;
2199
2200 erase_exit:
2201
2202         ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2203         /* Do call back function */
2204         if (!ret)
2205                 mtd_erase_callback(instr);
2206
2207         /* Deselect and wake up anyone waiting on the device */
2208         nand_release_device(mtd);
2209
2210         /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
2211         if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
2212                 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
2213                         if (rewrite_bbt[chipnr]) {
2214                                 /* update the BBT for chip */
2215                                 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2216                                         chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2217                                 nand_update_bbt (mtd, rewrite_bbt[chipnr]);
2218                         }
2219                 }
2220         }
2221
2222         /* Return more or less happy */
2223         return ret;
2224 }
2225
2226 /**
2227  * nand_sync - [MTD Interface] sync
2228  * @mtd:        MTD device structure
2229  *
2230  * Sync is actually a wait for chip ready function
2231  */
2232 static void nand_sync (struct mtd_info *mtd)
2233 {
2234         struct nand_chip *this = mtd->priv;
2235
2236         DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2237
2238         /* Grab the lock and see if the device is available */
2239         nand_get_device (this, mtd, FL_SYNCING);
2240         /* Release it and go back */
2241         nand_release_device (mtd);
2242 }
2243
2244
2245 /**
2246  * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2247  * @mtd:        MTD device structure
2248  * @ofs:        offset relative to mtd start
2249  */
2250 static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
2251 {
2252         /* Check for invalid offset */
2253         if (ofs > mtd->size)
2254                 return -EINVAL;
2255
2256         return nand_block_checkbad (mtd, ofs, 1, 0);
2257 }
2258
2259 /**
2260  * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2261  * @mtd:        MTD device structure
2262  * @ofs:        offset relative to mtd start
2263  */
2264 static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
2265 {
2266         struct nand_chip *this = mtd->priv;
2267         int ret;
2268
2269         if ((ret = nand_block_isbad(mtd, ofs))) {
2270                 /* If it was bad already, return success and do nothing. */
2271                 if (ret > 0)
2272                         return 0;
2273                 return ret;
2274         }
2275
2276         return this->block_markbad(mtd, ofs);
2277 }
2278
2279 /**
2280  * nand_scan - [NAND Interface] Scan for the NAND device
2281  * @mtd:        MTD device structure
2282  * @maxchips:   Number of chips to scan for
2283  *
2284  * This fills out all the not initialized function pointers
2285  * with the defaults.
2286  * The flash ID is read and the mtd/chip structures are
2287  * filled with the appropriate values. Buffers are allocated if
2288  * they are not provided by the board driver
2289  *
2290  */
2291 int nand_scan (struct mtd_info *mtd, int maxchips)
2292 {
2293         int i, nand_maf_id, nand_dev_id, busw, maf_id;
2294         struct nand_chip *this = mtd->priv;
2295
2296         /* Get buswidth to select the correct functions*/
2297         busw = this->options & NAND_BUSWIDTH_16;
2298
2299         /* check for proper chip_delay setup, set 20us if not */
2300         if (!this->chip_delay)
2301                 this->chip_delay = 20;
2302
2303         /* check, if a user supplied command function given */
2304         if (this->cmdfunc == NULL)
2305                 this->cmdfunc = nand_command;
2306
2307         /* check, if a user supplied wait function given */
2308         if (this->waitfunc == NULL)
2309                 this->waitfunc = nand_wait;
2310
2311         if (!this->select_chip)
2312                 this->select_chip = nand_select_chip;
2313         if (!this->write_byte)
2314                 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2315         if (!this->read_byte)
2316                 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2317         if (!this->write_word)
2318                 this->write_word = nand_write_word;
2319         if (!this->read_word)
2320                 this->read_word = nand_read_word;
2321         if (!this->block_bad)
2322                 this->block_bad = nand_block_bad;
2323         if (!this->block_markbad)
2324                 this->block_markbad = nand_default_block_markbad;
2325         if (!this->write_buf)
2326                 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2327         if (!this->read_buf)
2328                 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2329         if (!this->verify_buf)
2330                 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2331         if (!this->scan_bbt)
2332                 this->scan_bbt = nand_default_bbt;
2333
2334         /* Select the device */
2335         this->select_chip(mtd, 0);
2336
2337         /* Send the command for reading device ID */
2338         this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2339
2340         /* Read manufacturer and device IDs */
2341         nand_maf_id = this->read_byte(mtd);
2342         nand_dev_id = this->read_byte(mtd);
2343
2344         /* Print and store flash device information */
2345         for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2346
2347                 if (nand_dev_id != nand_flash_ids[i].id)
2348                         continue;
2349
2350                 if (!mtd->name) mtd->name = nand_flash_ids[i].name;
2351                 this->chipsize = nand_flash_ids[i].chipsize << 20;
2352
2353                 /* New devices have all the information in additional id bytes */
2354                 if (!nand_flash_ids[i].pagesize) {
2355                         int extid;
2356                         /* The 3rd id byte contains non relevant data ATM */
2357                         extid = this->read_byte(mtd);
2358                         /* The 4th id byte is the important one */
2359                         extid = this->read_byte(mtd);
2360                         /* Calc pagesize */
2361                         mtd->oobblock = 1024 << (extid & 0x3);
2362                         extid >>= 2;
2363                         /* Calc oobsize */
2364                         mtd->oobsize = (8 << (extid & 0x03)) * (mtd->oobblock / 512);
2365                         extid >>= 2;
2366                         /* Calc blocksize. Blocksize is multiples of 64KiB */
2367                         mtd->erasesize = (64 * 1024)  << (extid & 0x03);
2368                         extid >>= 2;
2369                         /* Get buswidth information */
2370                         busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2371
2372                 } else {
2373                         /* Old devices have this data hardcoded in the
2374                          * device id table */
2375                         mtd->erasesize = nand_flash_ids[i].erasesize;
2376                         mtd->oobblock = nand_flash_ids[i].pagesize;
2377                         mtd->oobsize = mtd->oobblock / 32;
2378                         busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2379                 }
2380
2381                 /* Try to identify manufacturer */
2382                 for (maf_id = 0; nand_manuf_ids[maf_id].id != 0x0; maf_id++) {
2383                         if (nand_manuf_ids[maf_id].id == nand_maf_id)
2384                                 break;
2385                 }
2386
2387                 /* Check, if buswidth is correct. Hardware drivers should set
2388                  * this correct ! */
2389                 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2390                         printk (KERN_INFO "NAND device: Manufacturer ID:"
2391                                 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
2392                                 nand_manuf_ids[maf_id].name , mtd->name);
2393                         printk (KERN_WARNING
2394                                 "NAND bus width %d instead %d bit\n",
2395                                         (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2396                                         busw ? 16 : 8);
2397                         this->select_chip(mtd, -1);
2398                         return 1;
2399                 }
2400
2401                 /* Calculate the address shift from the page size */
2402                 this->page_shift = ffs(mtd->oobblock) - 1;
2403                 this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
2404                 this->chip_shift = ffs(this->chipsize) - 1;
2405
2406                 /* Set the bad block position */
2407                 this->badblockpos = mtd->oobblock > 512 ?
2408                         NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2409
2410                 /* Get chip options, preserve non chip based options */
2411                 this->options &= ~NAND_CHIPOPTIONS_MSK;
2412                 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2413                 /* Set this as a default. Board drivers can override it, if neccecary */
2414                 this->options |= NAND_NO_AUTOINCR;
2415                 /* Check if this is a not a samsung device. Do not clear the options
2416                  * for chips which are not having an extended id.
2417                  */
2418                 if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2419                         this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2420
2421                 /* Check for AND chips with 4 page planes */
2422                 if (this->options & NAND_4PAGE_ARRAY)
2423                         this->erase_cmd = multi_erase_cmd;
2424                 else
2425                         this->erase_cmd = single_erase_cmd;
2426
2427                 /* Do not replace user supplied command function ! */
2428                 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2429                         this->cmdfunc = nand_command_lp;
2430
2431                 printk (KERN_INFO "NAND device: Manufacturer ID:"
2432                         " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
2433                         nand_manuf_ids[maf_id].name , nand_flash_ids[i].name);
2434                 break;
2435         }
2436
2437         if (!nand_flash_ids[i].name) {
2438                 printk (KERN_WARNING "No NAND device found!!!\n");
2439                 this->select_chip(mtd, -1);
2440                 return 1;
2441         }
2442
2443         for (i=1; i < maxchips; i++) {
2444                 this->select_chip(mtd, i);
2445
2446                 /* Send the command for reading device ID */
2447                 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2448
2449                 /* Read manufacturer and device IDs */
2450                 if (nand_maf_id != this->read_byte(mtd) ||
2451                     nand_dev_id != this->read_byte(mtd))
2452                         break;
2453         }
2454         if (i > 1)
2455                 printk(KERN_INFO "%d NAND chips detected\n", i);
2456
2457         /* Allocate buffers, if neccecary */
2458         if (!this->oob_buf) {
2459                 size_t len;
2460                 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
2461                 this->oob_buf = kmalloc (len, GFP_KERNEL);
2462                 if (!this->oob_buf) {
2463                         printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
2464                         return -ENOMEM;
2465                 }
2466                 this->options |= NAND_OOBBUF_ALLOC;
2467         }
2468
2469         if (!this->data_buf) {
2470                 size_t len;
2471                 len = mtd->oobblock + mtd->oobsize;
2472                 this->data_buf = kmalloc (len, GFP_KERNEL);
2473                 if (!this->data_buf) {
2474                         if (this->options & NAND_OOBBUF_ALLOC)
2475                                 kfree (this->oob_buf);
2476                         printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
2477                         return -ENOMEM;
2478                 }
2479                 this->options |= NAND_DATABUF_ALLOC;
2480         }
2481
2482         /* Store the number of chips and calc total size for mtd */
2483         this->numchips = i;
2484         mtd->size = i * this->chipsize;
2485         /* Convert chipsize to number of pages per chip -1. */
2486         this->pagemask = (this->chipsize >> this->page_shift) - 1;
2487         /* Preset the internal oob buffer */
2488         memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2489
2490         /* If no default placement scheme is given, select an
2491          * appropriate one */
2492         if (!this->autooob) {
2493                 /* Select the appropriate default oob placement scheme for
2494                  * placement agnostic filesystems */
2495                 switch (mtd->oobsize) {
2496                 case 8:
2497                         this->autooob = &nand_oob_8;
2498                         break;
2499                 case 16:
2500                         this->autooob = &nand_oob_16;
2501                         break;
2502                 case 64:
2503                         this->autooob = &nand_oob_64;
2504                         break;
2505                 default:
2506                         printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
2507                                 mtd->oobsize);
2508                         BUG();
2509                 }
2510         }
2511
2512         /* The number of bytes available for the filesystem to place fs dependend
2513          * oob data */
2514         mtd->oobavail = 0;
2515         for (i = 0; this->autooob->oobfree[i][1]; i++)
2516                 mtd->oobavail += this->autooob->oobfree[i][1];
2517
2518         /*
2519          * check ECC mode, default to software
2520          * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
2521          * fallback to software ECC
2522         */
2523         this->eccsize = 256;    /* set default eccsize */
2524         this->eccbytes = 3;
2525
2526         switch (this->eccmode) {
2527         case NAND_ECC_HW12_2048:
2528                 if (mtd->oobblock < 2048) {
2529                         printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
2530                                mtd->oobblock);
2531                         this->eccmode = NAND_ECC_SOFT;
2532                         this->calculate_ecc = nand_calculate_ecc;
2533                         this->correct_data = nand_correct_data;
2534                 } else
2535                         this->eccsize = 2048;
2536                 break;
2537
2538         case NAND_ECC_HW3_512:
2539         case NAND_ECC_HW6_512:
2540         case NAND_ECC_HW8_512:
2541                 if (mtd->oobblock == 256) {
2542                         printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
2543                         this->eccmode = NAND_ECC_SOFT;
2544                         this->calculate_ecc = nand_calculate_ecc;
2545                         this->correct_data = nand_correct_data;
2546                 } else
2547                         this->eccsize = 512; /* set eccsize to 512 */
2548                 break;
2549
2550         case NAND_ECC_HW3_256:
2551                 break;
2552
2553         case NAND_ECC_NONE:
2554                 printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
2555                 this->eccmode = NAND_ECC_NONE;
2556                 break;
2557
2558         case NAND_ECC_SOFT:
2559                 this->calculate_ecc = nand_calculate_ecc;
2560                 this->correct_data = nand_correct_data;
2561                 break;
2562
2563         default:
2564                 printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
2565                 BUG();
2566         }
2567
2568         /* Check hardware ecc function availability and adjust number of ecc bytes per
2569          * calculation step
2570         */
2571         switch (this->eccmode) {
2572         case NAND_ECC_HW12_2048:
2573                 this->eccbytes += 4;
2574         case NAND_ECC_HW8_512:
2575                 this->eccbytes += 2;
2576         case NAND_ECC_HW6_512:
2577                 this->eccbytes += 3;
2578         case NAND_ECC_HW3_512:
2579         case NAND_ECC_HW3_256:
2580                 if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
2581                         break;
2582                 printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
2583                 BUG();
2584         }
2585
2586         mtd->eccsize = this->eccsize;
2587
2588         /* Set the number of read / write steps for one page to ensure ECC generation */
2589         switch (this->eccmode) {
2590         case NAND_ECC_HW12_2048:
2591                 this->eccsteps = mtd->oobblock / 2048;
2592                 break;
2593         case NAND_ECC_HW3_512:
2594         case NAND_ECC_HW6_512:
2595         case NAND_ECC_HW8_512:
2596                 this->eccsteps = mtd->oobblock / 512;
2597                 break;
2598         case NAND_ECC_HW3_256:
2599         case NAND_ECC_SOFT:
2600                 this->eccsteps = mtd->oobblock / 256;
2601                 break;
2602
2603         case NAND_ECC_NONE:
2604                 this->eccsteps = 1;
2605                 break;
2606         }
2607
2608         /* Initialize state, waitqueue and spinlock */
2609         this->state = FL_READY;
2610         init_waitqueue_head (&this->wq);
2611         spin_lock_init (&this->chip_lock);
2612
2613         /* De-select the device */
2614         this->select_chip(mtd, -1);
2615
2616         /* Invalidate the pagebuffer reference */
2617         this->pagebuf = -1;
2618
2619         /* Fill in remaining MTD driver data */
2620         mtd->type = MTD_NANDFLASH;
2621         mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
2622         mtd->ecctype = MTD_ECC_SW;
2623         mtd->erase = nand_erase;
2624         mtd->point = NULL;
2625         mtd->unpoint = NULL;
2626         mtd->read = nand_read;
2627         mtd->write = nand_write;
2628         mtd->read_ecc = nand_read_ecc;
2629         mtd->write_ecc = nand_write_ecc;
2630         mtd->read_oob = nand_read_oob;
2631         mtd->write_oob = nand_write_oob;
2632         mtd->readv = NULL;
2633         mtd->writev = nand_writev;
2634         mtd->writev_ecc = nand_writev_ecc;
2635         mtd->sync = nand_sync;
2636         mtd->lock = NULL;
2637         mtd->unlock = NULL;
2638         mtd->suspend = NULL;
2639         mtd->resume = NULL;
2640         mtd->block_isbad = nand_block_isbad;
2641         mtd->block_markbad = nand_block_markbad;
2642
2643         /* and make the autooob the default one */
2644         memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2645
2646         mtd->owner = THIS_MODULE;
2647
2648         /* Check, if we should skip the bad block table scan */
2649         if (this->options & NAND_SKIP_BBTSCAN)
2650                 return 0;
2651
2652         /* Build bad block table */
2653         return this->scan_bbt (mtd);
2654 }
2655
2656 /**
2657  * nand_release - [NAND Interface] Free resources held by the NAND device
2658  * @mtd:        MTD device structure
2659 */
2660 void nand_release (struct mtd_info *mtd)
2661 {
2662         struct nand_chip *this = mtd->priv;
2663
2664 #ifdef CONFIG_MTD_PARTITIONS
2665         /* Deregister partitions */
2666         del_mtd_partitions (mtd);
2667 #endif
2668         /* Deregister the device */
2669         del_mtd_device (mtd);
2670
2671         /* Free bad block table memory, if allocated */
2672         if (this->bbt)
2673                 kfree (this->bbt);
2674         /* Buffer allocated by nand_scan ? */
2675         if (this->options & NAND_OOBBUF_ALLOC)
2676                 kfree (this->oob_buf);
2677         /* Buffer allocated by nand_scan ? */
2678         if (this->options & NAND_DATABUF_ALLOC)
2679                 kfree (this->data_buf);
2680 }
2681
2682 EXPORT_SYMBOL (nand_scan);
2683 EXPORT_SYMBOL (nand_release);
2684
2685 MODULE_LICENSE ("GPL");
2686 MODULE_AUTHOR ("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2687 MODULE_DESCRIPTION ("Generic NAND flash driver code");