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