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