drivers/mtd/nand/nand_base.c

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