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