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.
9 * Additional technical information is available on
10 * http://www.linux-mtd.infradead.org/tech/nand.html
12 * Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
13 * 2002 Thomas Gleixner (tglx@linutronix.de)
15 * 02-08-2004 tglx: support for strange chips, which cannot auto increment
16 * pages on read / read_oob
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
23 * 04-14-2004 tglx: first working version for 2k page size chips
25 * 05-19-2004 tglx: Basic support for Renesas AG-AND chips
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>
32 * David Woodhouse for adding multichip support
34 * Aleph One Ltd. and Toby Churchill Ltd. for supporting the
35 * rework for 2K page size chips
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.
44 * $Id: nand_base.c,v 1.126 2004/12/13 11:22:25 lavinen Exp $
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.
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>
67 #ifdef CONFIG_MTD_PARTITIONS
68 #include <linux/mtd/partitions.h>
74 #ifdef CONFIG_NEW_NAND_CODE
76 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
80 #include <linux/mtd/compat.h>
81 #include <linux/mtd/mtd.h>
82 #include <linux/mtd/nand.h>
83 #include <linux/mtd/nand_ecc.h>
86 #include <asm/errno.h>
88 #ifdef CONFIG_JFFS2_NAND
89 #include <jffs2/jffs2.h>
92 /* Define default oob placement schemes for large and small page devices */
93 static struct nand_oobinfo nand_oob_8 = {
94 .useecc = MTD_NANDECC_AUTOPLACE,
97 .oobfree = { {3, 2}, {6, 2} }
100 static struct nand_oobinfo nand_oob_16 = {
101 .useecc = MTD_NANDECC_AUTOPLACE,
103 .eccpos = {0, 1, 2, 3, 6, 7},
104 .oobfree = { {8, 8} }
107 static struct nand_oobinfo nand_oob_64 = {
108 .useecc = MTD_NANDECC_AUTOPLACE,
111 40, 41, 42, 43, 44, 45, 46, 47,
112 48, 49, 50, 51, 52, 53, 54, 55,
113 56, 57, 58, 59, 60, 61, 62, 63},
114 .oobfree = { {2, 38} }
117 /* This is used for padding purposes in nand_write_oob */
118 static u_char ffchars[] = {
119 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
120 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
121 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
122 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
123 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
124 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
125 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
126 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
130 * NAND low-level MTD interface functions
132 static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len);
133 static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len);
134 static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len);
136 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
137 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
138 size_t * retlen, u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
139 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
140 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf);
141 static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
142 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
143 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char *buf);
146 static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs,
147 unsigned long count, loff_t to, size_t * retlen);
148 static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs,
149 unsigned long count, loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
151 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
152 static void nand_sync (struct mtd_info *mtd);
154 /* Some internal functions */
155 static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, u_char *oob_buf,
156 struct nand_oobinfo *oobsel, int mode);
157 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
158 static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
159 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode);
161 #define nand_verify_pages(...) (0)
164 static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state);
167 * nand_release_device - [GENERIC] release chip
168 * @mtd: MTD device structure
170 * Deselect, release chip lock and wake up anyone waiting on the device
174 static void nand_release_device (struct mtd_info *mtd)
176 struct nand_chip *this = mtd->priv;
178 /* De-select the NAND device */
179 this->select_chip(mtd, -1);
180 /* Do we have a hardware controller ? */
181 if (this->controller) {
182 spin_lock(&this->controller->lock);
183 this->controller->active = NULL;
184 spin_unlock(&this->controller->lock);
186 /* Release the chip */
187 spin_lock (&this->chip_lock);
188 this->state = FL_READY;
190 spin_unlock (&this->chip_lock);
193 static void nand_release_device (struct mtd_info *mtd)
195 struct nand_chip *this = mtd->priv;
196 this->select_chip(mtd, -1); /* De-select the NAND device */
201 * nand_read_byte - [DEFAULT] read one byte from the chip
202 * @mtd: MTD device structure
204 * Default read function for 8bit buswith
206 static u_char nand_read_byte(struct mtd_info *mtd)
208 struct nand_chip *this = mtd->priv;
209 return readb(this->IO_ADDR_R);
213 * nand_write_byte - [DEFAULT] write one byte to the chip
214 * @mtd: MTD device structure
215 * @byte: pointer to data byte to write
217 * Default write function for 8it buswith
219 static void nand_write_byte(struct mtd_info *mtd, u_char byte)
221 struct nand_chip *this = mtd->priv;
222 writeb(byte, this->IO_ADDR_W);
226 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
227 * @mtd: MTD device structure
229 * Default read function for 16bit buswith with
230 * endianess conversion
232 static u_char nand_read_byte16(struct mtd_info *mtd)
234 struct nand_chip *this = mtd->priv;
235 return (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
239 * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
240 * @mtd: MTD device structure
241 * @byte: pointer to data byte to write
243 * Default write function for 16bit buswith with
244 * endianess conversion
246 static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
248 struct nand_chip *this = mtd->priv;
249 writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
253 * nand_read_word - [DEFAULT] read one word from the chip
254 * @mtd: MTD device structure
256 * Default read function for 16bit buswith without
257 * endianess conversion
259 static u16 nand_read_word(struct mtd_info *mtd)
261 struct nand_chip *this = mtd->priv;
262 return readw(this->IO_ADDR_R);
266 * nand_write_word - [DEFAULT] write one word to the chip
267 * @mtd: MTD device structure
268 * @word: data word to write
270 * Default write function for 16bit buswith without
271 * endianess conversion
273 static void nand_write_word(struct mtd_info *mtd, u16 word)
275 struct nand_chip *this = mtd->priv;
276 writew(word, this->IO_ADDR_W);
280 * nand_select_chip - [DEFAULT] control CE line
281 * @mtd: MTD device structure
282 * @chip: chipnumber to select, -1 for deselect
284 * Default select function for 1 chip devices.
286 static void nand_select_chip(struct mtd_info *mtd, int chip)
288 struct nand_chip *this = mtd->priv;
291 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
294 this->hwcontrol(mtd, NAND_CTL_SETNCE);
303 * nand_write_buf - [DEFAULT] write buffer to chip
304 * @mtd: MTD device structure
306 * @len: number of bytes to write
308 * Default write function for 8bit buswith
310 static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
313 struct nand_chip *this = mtd->priv;
315 for (i=0; i<len; i++)
316 writeb(buf[i], this->IO_ADDR_W);
320 * nand_read_buf - [DEFAULT] read chip data into buffer
321 * @mtd: MTD device structure
322 * @buf: buffer to store date
323 * @len: number of bytes to read
325 * Default read function for 8bit buswith
327 static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
330 struct nand_chip *this = mtd->priv;
332 for (i=0; i<len; i++)
333 buf[i] = readb(this->IO_ADDR_R);
337 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
338 * @mtd: MTD device structure
339 * @buf: buffer containing the data to compare
340 * @len: number of bytes to compare
342 * Default verify function for 8bit buswith
344 static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
347 struct nand_chip *this = mtd->priv;
349 for (i=0; i<len; i++)
350 if (buf[i] != readb(this->IO_ADDR_R))
357 * nand_write_buf16 - [DEFAULT] write buffer to chip
358 * @mtd: MTD device structure
360 * @len: number of bytes to write
362 * Default write function for 16bit buswith
364 static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
367 struct nand_chip *this = mtd->priv;
368 u16 *p = (u16 *) buf;
371 for (i=0; i<len; i++)
372 writew(p[i], this->IO_ADDR_W);
377 * nand_read_buf16 - [DEFAULT] read chip data into buffer
378 * @mtd: MTD device structure
379 * @buf: buffer to store date
380 * @len: number of bytes to read
382 * Default read function for 16bit buswith
384 static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
387 struct nand_chip *this = mtd->priv;
388 u16 *p = (u16 *) buf;
391 for (i=0; i<len; i++)
392 p[i] = readw(this->IO_ADDR_R);
396 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
397 * @mtd: MTD device structure
398 * @buf: buffer containing the data to compare
399 * @len: number of bytes to compare
401 * Default verify function for 16bit buswith
403 static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
406 struct nand_chip *this = mtd->priv;
407 u16 *p = (u16 *) buf;
410 for (i=0; i<len; i++)
411 if (p[i] != readw(this->IO_ADDR_R))
418 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
419 * @mtd: MTD device structure
420 * @ofs: offset from device start
421 * @getchip: 0, if the chip is already selected
423 * Check, if the block is bad.
425 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
427 int page, chipnr, res = 0;
428 struct nand_chip *this = mtd->priv;
432 page = (int)(ofs >> this->page_shift);
433 chipnr = (int)(ofs >> this->chip_shift);
435 /* Grab the lock and see if the device is available */
436 nand_get_device (this, mtd, FL_READING);
438 /* Select the NAND device */
439 this->select_chip(mtd, chipnr);
443 if (this->options & NAND_BUSWIDTH_16) {
444 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
445 bad = cpu_to_le16(this->read_word(mtd));
446 if (this->badblockpos & 0x1)
448 if ((bad & 0xFF) != 0xff)
451 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
452 if (this->read_byte(mtd) != 0xff)
457 /* Deselect and wake up anyone waiting on the device */
458 nand_release_device(mtd);
465 * nand_default_block_markbad - [DEFAULT] mark a block bad
466 * @mtd: MTD device structure
467 * @ofs: offset from device start
469 * This is the default implementation, which can be overridden by
470 * a hardware specific driver.
472 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
474 struct nand_chip *this = mtd->priv;
475 u_char buf[2] = {0, 0};
479 /* Get block number */
480 block = ((int) ofs) >> this->bbt_erase_shift;
481 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
483 /* Do we have a flash based bad block table ? */
484 if (this->options & NAND_USE_FLASH_BBT)
485 return nand_update_bbt (mtd, ofs);
487 /* We write two bytes, so we dont have to mess with 16 bit access */
488 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
489 return nand_write_oob (mtd, ofs , 2, &retlen, buf);
493 * nand_check_wp - [GENERIC] check if the chip is write protected
494 * @mtd: MTD device structure
495 * Check, if the device is write protected
497 * The function expects, that the device is already selected
499 static int nand_check_wp (struct mtd_info *mtd)
501 struct nand_chip *this = mtd->priv;
502 /* Check the WP bit */
503 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
504 return (this->read_byte(mtd) & 0x80) ? 0 : 1;
508 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
509 * @mtd: MTD device structure
510 * @ofs: offset from device start
511 * @getchip: 0, if the chip is already selected
512 * @allowbbt: 1, if its allowed to access the bbt area
514 * Check, if the block is bad. Either by reading the bad block table or
515 * calling of the scan function.
517 static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
519 struct nand_chip *this = mtd->priv;
522 return this->block_bad(mtd, ofs, getchip);
524 /* Return info from the table */
525 return nand_isbad_bbt (mtd, ofs, allowbbt);
529 * nand_command - [DEFAULT] Send command to NAND device
530 * @mtd: MTD device structure
531 * @command: the command to be sent
532 * @column: the column address for this command, -1 if none
533 * @page_addr: the page address for this command, -1 if none
535 * Send command to NAND device. This function is used for small page
536 * devices (256/512 Bytes per page)
538 static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
540 register struct nand_chip *this = mtd->priv;
542 /* Begin command latch cycle */
543 this->hwcontrol(mtd, NAND_CTL_SETCLE);
545 * Write out the command to the device.
547 if (command == NAND_CMD_SEQIN) {
550 if (column >= mtd->oobblock) {
552 column -= mtd->oobblock;
553 readcmd = NAND_CMD_READOOB;
554 } else if (column < 256) {
555 /* First 256 bytes --> READ0 */
556 readcmd = NAND_CMD_READ0;
559 readcmd = NAND_CMD_READ1;
561 this->write_byte(mtd, readcmd);
563 this->write_byte(mtd, command);
565 /* Set ALE and clear CLE to start address cycle */
566 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
568 if (column != -1 || page_addr != -1) {
569 this->hwcontrol(mtd, NAND_CTL_SETALE);
571 /* Serially input address */
573 /* Adjust columns for 16 bit buswidth */
574 if (this->options & NAND_BUSWIDTH_16)
576 this->write_byte(mtd, column);
578 if (page_addr != -1) {
579 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
580 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
581 /* One more address cycle for devices > 32MiB */
582 if (this->chipsize > (32 << 20))
583 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
585 /* Latch in address */
586 this->hwcontrol(mtd, NAND_CTL_CLRALE);
590 * program and erase have their own busy handlers
591 * status and sequential in needs no delay
595 case NAND_CMD_PAGEPROG:
596 case NAND_CMD_ERASE1:
597 case NAND_CMD_ERASE2:
599 case NAND_CMD_STATUS:
605 udelay(this->chip_delay);
606 this->hwcontrol(mtd, NAND_CTL_SETCLE);
607 this->write_byte(mtd, NAND_CMD_STATUS);
608 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
609 while ( !(this->read_byte(mtd) & 0x40));
612 /* This applies to read commands */
615 * If we don't have access to the busy pin, we apply the given
618 if (!this->dev_ready) {
619 udelay (this->chip_delay);
624 /* Apply this short delay always to ensure that we do wait tWB in
625 * any case on any machine. */
627 /* wait until command is processed */
628 while (!this->dev_ready(mtd));
632 * nand_command_lp - [DEFAULT] Send command to NAND large page device
633 * @mtd: MTD device structure
634 * @command: the command to be sent
635 * @column: the column address for this command, -1 if none
636 * @page_addr: the page address for this command, -1 if none
638 * Send command to NAND device. This is the version for the new large page devices
639 * We dont have the seperate regions as we have in the small page devices.
640 * We must emulate NAND_CMD_READOOB to keep the code compatible.
643 static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr)
645 register struct nand_chip *this = mtd->priv;
647 /* Emulate NAND_CMD_READOOB */
648 if (command == NAND_CMD_READOOB) {
649 column += mtd->oobblock;
650 command = NAND_CMD_READ0;
654 /* Begin command latch cycle */
655 this->hwcontrol(mtd, NAND_CTL_SETCLE);
656 /* Write out the command to the device. */
657 this->write_byte(mtd, command);
658 /* End command latch cycle */
659 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
661 if (column != -1 || page_addr != -1) {
662 this->hwcontrol(mtd, NAND_CTL_SETALE);
664 /* Serially input address */
666 /* Adjust columns for 16 bit buswidth */
667 if (this->options & NAND_BUSWIDTH_16)
669 this->write_byte(mtd, column & 0xff);
670 this->write_byte(mtd, column >> 8);
672 if (page_addr != -1) {
673 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
674 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
675 /* One more address cycle for devices > 128MiB */
676 if (this->chipsize > (128 << 20))
677 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff));
679 /* Latch in address */
680 this->hwcontrol(mtd, NAND_CTL_CLRALE);
684 * program and erase have their own busy handlers
685 * status and sequential in needs no delay
689 case NAND_CMD_CACHEDPROG:
690 case NAND_CMD_PAGEPROG:
691 case NAND_CMD_ERASE1:
692 case NAND_CMD_ERASE2:
694 case NAND_CMD_STATUS:
701 udelay(this->chip_delay);
702 this->hwcontrol(mtd, NAND_CTL_SETCLE);
703 this->write_byte(mtd, NAND_CMD_STATUS);
704 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
705 while ( !(this->read_byte(mtd) & 0x40));
709 /* Begin command latch cycle */
710 this->hwcontrol(mtd, NAND_CTL_SETCLE);
711 /* Write out the start read command */
712 this->write_byte(mtd, NAND_CMD_READSTART);
713 /* End command latch cycle */
714 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
715 /* Fall through into ready check */
717 /* This applies to read commands */
720 * If we don't have access to the busy pin, we apply the given
723 if (!this->dev_ready) {
724 udelay (this->chip_delay);
729 /* Apply this short delay always to ensure that we do wait tWB in
730 * any case on any machine. */
732 /* wait until command is processed */
733 while (!this->dev_ready(mtd));
737 * nand_get_device - [GENERIC] Get chip for selected access
738 * @this: the nand chip descriptor
739 * @mtd: MTD device structure
740 * @new_state: the state which is requested
742 * Get the device and lock it for exclusive access
746 static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state)
748 struct nand_chip *active = this;
750 DECLARE_WAITQUEUE (wait, current);
753 * Grab the lock and see if the device is available
756 /* Hardware controller shared among independend devices */
757 if (this->controller) {
758 spin_lock (&this->controller->lock);
759 if (this->controller->active)
760 active = this->controller->active;
762 this->controller->active = this;
763 spin_unlock (&this->controller->lock);
766 if (active == this) {
767 spin_lock (&this->chip_lock);
768 if (this->state == FL_READY) {
769 this->state = new_state;
770 spin_unlock (&this->chip_lock);
774 set_current_state (TASK_UNINTERRUPTIBLE);
775 add_wait_queue (&active->wq, &wait);
776 spin_unlock (&active->chip_lock);
778 remove_wait_queue (&active->wq, &wait);
782 static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state) {}
786 * nand_wait - [DEFAULT] wait until the command is done
787 * @mtd: MTD device structure
788 * @this: NAND chip structure
789 * @state: state to select the max. timeout value
791 * Wait for command done. This applies to erase and program only
792 * Erase can take up to 400ms and program up to 20ms according to
793 * general NAND and SmartMedia specs
798 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
800 unsigned long timeo = jiffies;
803 if (state == FL_ERASING)
804 timeo += (HZ * 400) / 1000;
806 timeo += (HZ * 20) / 1000;
808 /* Apply this short delay always to ensure that we do wait tWB in
809 * any case on any machine. */
812 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
813 this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
815 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
817 while (time_before(jiffies, timeo)) {
818 /* Check, if we were interrupted */
819 if (this->state != state)
822 if (this->dev_ready) {
823 if (this->dev_ready(mtd))
826 if (this->read_byte(mtd) & NAND_STATUS_READY)
831 status = (int) this->read_byte(mtd);
837 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
841 if (state == FL_ERASING)
842 timeo = CFG_HZ * 400;
846 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
847 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
849 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
854 if (get_timer(0) > timeo) {
859 if (this->dev_ready) {
860 if (this->dev_ready(mtd))
863 if (this->read_byte(mtd) & NAND_STATUS_READY)
868 /* XXX nand device 1 on dave (PPChameleonEVB) needs more time */
870 while (get_timer(0) < 10);
872 return this->read_byte(mtd);
877 * nand_write_page - [GENERIC] write one page
878 * @mtd: MTD device structure
879 * @this: NAND chip structure
880 * @page: startpage inside the chip, must be called with (page & this->pagemask)
881 * @oob_buf: out of band data buffer
882 * @oobsel: out of band selecttion structre
883 * @cached: 1 = enable cached programming if supported by chip
885 * Nand_page_program function is used for write and writev !
886 * This function will always program a full page of data
887 * If you call it with a non page aligned buffer, you're lost :)
889 * Cached programming is not supported yet.
891 static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
892 u_char *oob_buf, struct nand_oobinfo *oobsel, int cached)
896 int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
897 int *oob_config = oobsel->eccpos;
898 int datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
901 /* FIXME: Enable cached programming */
904 /* Send command to begin auto page programming */
905 this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
907 /* Write out complete page of data, take care of eccmode */
909 /* No ecc, write all */
911 printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
912 this->write_buf(mtd, this->data_poi, mtd->oobblock);
915 /* Software ecc 3/256, write all */
917 for (; eccsteps; eccsteps--) {
918 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
919 for (i = 0; i < 3; i++, eccidx++)
920 oob_buf[oob_config[eccidx]] = ecc_code[i];
921 datidx += this->eccsize;
923 this->write_buf(mtd, this->data_poi, mtd->oobblock);
926 eccbytes = this->eccbytes;
927 for (; eccsteps; eccsteps--) {
928 /* enable hardware ecc logic for write */
929 this->enable_hwecc(mtd, NAND_ECC_WRITE);
930 this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
931 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
932 for (i = 0; i < eccbytes; i++, eccidx++)
933 oob_buf[oob_config[eccidx]] = ecc_code[i];
934 /* If the hardware ecc provides syndromes then
935 * the ecc code must be written immidiately after
936 * the data bytes (words) */
937 if (this->options & NAND_HWECC_SYNDROME)
938 this->write_buf(mtd, ecc_code, eccbytes);
939 datidx += this->eccsize;
944 /* Write out OOB data */
945 if (this->options & NAND_HWECC_SYNDROME)
946 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
948 this->write_buf(mtd, oob_buf, mtd->oobsize);
950 /* Send command to actually program the data */
951 this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
954 /* call wait ready function */
955 status = this->waitfunc (mtd, this, FL_WRITING);
956 /* See if device thinks it succeeded */
958 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
962 /* FIXME: Implement cached programming ! */
963 /* wait until cache is ready*/
964 /* status = this->waitfunc (mtd, this, FL_CACHEDRPG); */
969 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
971 * nand_verify_pages - [GENERIC] verify the chip contents after a write
972 * @mtd: MTD device structure
973 * @this: NAND chip structure
974 * @page: startpage inside the chip, must be called with (page & this->pagemask)
975 * @numpages: number of pages to verify
976 * @oob_buf: out of band data buffer
977 * @oobsel: out of band selecttion structre
978 * @chipnr: number of the current chip
979 * @oobmode: 1 = full buffer verify, 0 = ecc only
981 * The NAND device assumes that it is always writing to a cleanly erased page.
982 * Hence, it performs its internal write verification only on bits that
983 * transitioned from 1 to 0. The device does NOT verify the whole page on a
984 * byte by byte basis. It is possible that the page was not completely erased
985 * or the page is becoming unusable due to wear. The read with ECC would catch
986 * the error later when the ECC page check fails, but we would rather catch
987 * it early in the page write stage. Better to write no data than invalid data.
989 static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
990 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
992 int i, j, datidx = 0, oobofs = 0, res = -EIO;
993 int eccsteps = this->eccsteps;
997 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
999 /* Send command to read back the first page */
1000 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page);
1003 for (j = 0; j < eccsteps; j++) {
1004 /* Loop through and verify the data */
1005 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
1006 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1009 datidx += mtd->eccsize;
1010 /* Have we a hw generator layout ? */
1013 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
1014 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1017 oobofs += hweccbytes;
1020 /* check, if we must compare all data or if we just have to
1021 * compare the ecc bytes
1024 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
1025 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1029 /* Read always, else autoincrement fails */
1030 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
1032 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
1033 int ecccnt = oobsel->eccbytes;
1035 for (i = 0; i < ecccnt; i++) {
1036 int idx = oobsel->eccpos[i];
1037 if (oobdata[idx] != oob_buf[oobofs + idx] ) {
1038 DEBUG (MTD_DEBUG_LEVEL0,
1039 "%s: Failed ECC write "
1040 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
1046 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1050 /* Apply delay or wait for ready/busy pin
1051 * Do this before the AUTOINCR check, so no problems
1052 * arise if a chip which does auto increment
1053 * is marked as NOAUTOINCR by the board driver.
1054 * Do this also before returning, so the chip is
1055 * ready for the next command.
1057 if (!this->dev_ready)
1058 udelay (this->chip_delay);
1060 while (!this->dev_ready(mtd));
1062 /* All done, return happy */
1067 /* Check, if the chip supports auto page increment */
1068 if (!NAND_CANAUTOINCR(this))
1069 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1072 * Terminate the read command. We come here in case of an error
1073 * So we must issue a reset command.
1076 this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1);
1082 * nand_read - [MTD Interface] MTD compability function for nand_read_ecc
1083 * @mtd: MTD device structure
1084 * @from: offset to read from
1085 * @len: number of bytes to read
1086 * @retlen: pointer to variable to store the number of read bytes
1087 * @buf: the databuffer to put data
1089 * This function simply calls nand_read_ecc with oob buffer and oobsel = NULL
1091 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1093 return nand_read_ecc (mtd, from, len, retlen, buf, NULL, NULL);
1098 * nand_read_ecc - [MTD Interface] Read data with ECC
1099 * @mtd: MTD device structure
1100 * @from: offset to read from
1101 * @len: number of bytes to read
1102 * @retlen: pointer to variable to store the number of read bytes
1103 * @buf: the databuffer to put data
1104 * @oob_buf: filesystem supplied oob data buffer
1105 * @oobsel: oob selection structure
1107 * NAND read with ECC
1109 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1110 size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
1112 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1113 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1114 struct nand_chip *this = mtd->priv;
1115 u_char *data_poi, *oob_data = oob_buf;
1116 u_char ecc_calc[32];
1117 u_char ecc_code[32];
1118 int eccmode, eccsteps;
1119 int *oob_config, datidx;
1120 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1126 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
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");
1135 /* Grab the lock and see if the device is available */
1136 nand_get_device (this, mtd ,FL_READING);
1138 /* use userspace supplied oobinfo, if zero */
1140 oobsel = &mtd->oobinfo;
1142 /* Autoplace of oob data ? Use the default placement scheme */
1143 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1144 oobsel = this->autooob;
1146 eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
1147 oob_config = oobsel->eccpos;
1149 /* Select the NAND device */
1150 chipnr = (int)(from >> this->chip_shift);
1151 this->select_chip(mtd, chipnr);
1153 /* First we calculate the starting page */
1154 realpage = (int) (from >> this->page_shift);
1155 page = realpage & this->pagemask;
1157 /* Get raw starting column */
1158 col = from & (mtd->oobblock - 1);
1160 end = mtd->oobblock;
1161 ecc = this->eccsize;
1162 eccbytes = this->eccbytes;
1164 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1167 oobreadlen = mtd->oobsize;
1168 if (this->options & NAND_HWECC_SYNDROME)
1169 oobreadlen -= oobsel->eccbytes;
1171 /* Loop until all data read */
1172 while (read < len) {
1174 int aligned = (!col && (len - read) >= end);
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
1180 data_poi = &buf[read];
1182 data_poi = this->data_buf;
1184 /* Check, if we have this page in the buffer
1186 * FIXME: Make it work when we must provide oob data too,
1187 * check the usage of data_buf oob field
1189 if (realpage == this->pagebuf && !oob_buf) {
1190 /* aligned read ? */
1192 memcpy (data_poi, this->data_buf, end);
1196 /* Check, if we must send the read command */
1198 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
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];
1207 eccsteps = this->eccsteps;
1210 case NAND_ECC_NONE: { /* No ECC, Read in a page */
1211 /* XXX U-BOOT XXX */
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;
1219 puts("Reading data from NAND FLASH without ECC is not recommended\n");
1221 this->read_buf(mtd, data_poi, end);
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]);
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);
1236 /* HW ecc with syndrome calculation must read the
1237 * syndrome from flash immidiately after the data */
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);
1252 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
1259 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1261 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
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]];
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]);
1273 /* Get next chunk of ecc bytes */
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
1280 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1281 int *p = (int *)(&oob_data[mtd->oobsize]);
1285 if (ecc_status == -1) {
1286 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1292 /* check, if we have a fs supplied oob-buffer */
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);
1305 oob += mtd->oobavail;
1307 case MTD_NANDECC_PLACE:
1308 /* YAFFS1 legacy mode */
1309 oob_data += this->eccsteps * sizeof (int);
1311 oob_data += mtd->oobsize;
1315 /* Partial page read, transfer data into fs buffer */
1317 for (j = col; j < end && read < len; j++)
1318 buf[read++] = data_poi[j];
1319 this->pagebuf = realpage;
1321 read += mtd->oobblock;
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.
1328 if (!this->dev_ready)
1329 udelay (this->chip_delay);
1331 while (!this->dev_ready(mtd));
1336 /* For subsequent reads align to page boundary. */
1338 /* Increment page address */
1341 page = realpage & this->pagemask;
1342 /* Check, if we cross a chip boundary */
1345 this->select_chip(mtd, -1);
1346 this->select_chip(mtd, chipnr);
1348 /* Check, if the chip supports auto page increment
1349 * or if we have hit a block boundary.
1351 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1355 /* Deselect and wake up anyone waiting on the device */
1356 nand_release_device(mtd);
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
1364 return ecc_failed ? -EBADMSG : 0;
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
1375 * NAND read out-of-band data from the spare area
1377 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
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;
1383 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1385 /* Shift to get page */
1386 page = (int)(from >> this->page_shift);
1387 chipnr = (int)(from >> this->chip_shift);
1389 /* Mask to get column */
1390 col = from & (mtd->oobsize - 1);
1392 /* Initialize return length value */
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");
1402 /* Grab the lock and see if the device is available */
1403 nand_get_device (this, mtd , FL_READING);
1405 /* Select the NAND device */
1406 this->select_chip(mtd, chipnr);
1408 /* Send the read command */
1409 this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1411 * Read the data, if we read more than one page
1412 * oob data, let the device transfer the data !
1416 int thislen = mtd->oobsize - col;
1417 thislen = min_t(int, thislen, len);
1418 this->read_buf(mtd, &buf[i], thislen);
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.
1426 if (!this->dev_ready)
1427 udelay (this->chip_delay);
1429 while (!this->dev_ready(mtd));
1436 /* Check, if we cross a chip boundary */
1437 if (!(page & this->pagemask)) {
1439 this->select_chip(mtd, -1);
1440 this->select_chip(mtd, chipnr);
1443 /* Check, if the chip supports auto page increment
1444 * or if we have hit a block boundary.
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);
1453 /* Deselect and wake up anyone waiting on the device */
1454 nand_release_device(mtd);
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
1469 * Read raw data including oob into buffer
1471 int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1473 struct nand_chip *this = mtd->priv;
1474 int page = (int) (from >> this->page_shift);
1475 int chip = (int) (from >> this->chip_shift);
1478 int pagesize = mtd->oobblock + mtd->oobsize;
1479 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
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");
1487 /* Grab the lock and see if the device is available */
1488 nand_get_device (this, mtd , FL_READING);
1490 this->select_chip (mtd, chip);
1492 /* Add requested oob length */
1497 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1500 this->read_buf (mtd, &buf[cnt], pagesize);
1506 if (!this->dev_ready)
1507 udelay (this->chip_delay);
1509 while (!this->dev_ready(mtd));
1511 /* Check, if the chip supports auto page increment */
1512 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1516 /* Deselect and wake up anyone waiting on the device */
1517 nand_release_device(mtd);
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
1531 * 1. Filesystem buffer available and autoplacement is off,
1532 * return filesystem buffer
1533 * 2. No filesystem buffer or autoplace is off, return internal
1535 * 3. Filesystem buffer is given and autoplace selected
1536 * put data from fs buffer into internal buffer and
1537 * retrun internal buffer
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.
1545 static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
1546 int autoplace, int numpages)
1548 struct nand_chip *this = mtd->priv;
1551 /* Zero copy fs supplied buffer */
1552 if (fsbuf && !autoplace)
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));
1562 /* If we have no autoplacement or no fs buffer use the internal one */
1563 if (!autoplace || !fsbuf)
1564 return this->oob_buf;
1566 /* Walk through the pages and place the data */
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);
1577 ofs += mtd->oobavail;
1579 return this->oob_buf;
1582 #define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
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
1592 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1595 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1597 return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
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
1610 * NAND write with ECC
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)
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));
1621 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1623 /* Initialize retlen, in case of early exit */
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");
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");
1638 /* Grab the lock and see if the device is available */
1639 nand_get_device (this, mtd, FL_WRITING);
1641 /* Calculate chipnr */
1642 chipnr = (int)(to >> this->chip_shift);
1643 /* Select the NAND device */
1644 this->select_chip(mtd, chipnr);
1646 /* Check, if it is write protected */
1647 if (nand_check_wp(mtd))
1650 /* if oobsel is NULL, use chip defaults */
1652 oobsel = &mtd->oobinfo;
1654 /* Autoplace of oob data ? Use the default placement scheme */
1655 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1656 oobsel = this->autooob;
1659 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
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))
1669 /* Set it relative to chip */
1670 page &= this->pagemask;
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;
1677 /* Loop until all data is written */
1678 while (written < len) {
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.
1686 ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1688 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1692 oob += mtd->oobsize;
1693 /* Update written bytes count */
1694 written += mtd->oobblock;
1698 /* Increment page address */
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
1705 if (!(page & (ppblock - 1))){
1707 this->data_poi = bufstart;
1708 ret = nand_verify_pages (mtd, this, startpage,
1710 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1712 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1717 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1719 eccbuf += (page - startpage) * ofs;
1720 totalpages -= page - startpage;
1721 numpages = min (totalpages, ppblock);
1722 page &= this->pagemask;
1726 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
1727 autoplace, numpages);
1728 /* Check, if we cross a chip boundary */
1731 this->select_chip(mtd, -1);
1732 this->select_chip(mtd, chipnr);
1736 /* Verify the remaining pages */
1738 this->data_poi = bufstart;
1739 ret = nand_verify_pages (mtd, this, startpage, totalpages,
1740 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1744 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1747 /* Deselect and wake up anyone waiting on the device */
1748 nand_release_device(mtd);
1755 * nand_write_oob - [MTD Interface] NAND write out-of-band
1756 * @mtd: MTD device structure
1757 * @to: offset to write to
1758 * @len: number of bytes to write
1759 * @retlen: pointer to variable to store the number of written bytes
1760 * @buf: the data to write
1762 * NAND write out-of-band
1764 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1766 int column, page, status, ret = -EIO, chipnr;
1767 struct nand_chip *this = mtd->priv;
1769 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1771 /* Shift to get page */
1772 page = (int) (to >> this->page_shift);
1773 chipnr = (int) (to >> this->chip_shift);
1775 /* Mask to get column */
1776 column = to & (mtd->oobsize - 1);
1778 /* Initialize return length value */
1781 /* Do not allow write past end of page */
1782 if ((column + len) > mtd->oobsize) {
1783 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1787 /* Grab the lock and see if the device is available */
1788 nand_get_device (this, mtd, FL_WRITING);
1790 /* Select the NAND device */
1791 this->select_chip(mtd, chipnr);
1793 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1794 in one of my DiskOnChip 2000 test units) will clear the whole
1795 data page too if we don't do this. I have no clue why, but
1796 I seem to have 'fixed' it in the doc2000 driver in
1797 August 1999. dwmw2. */
1798 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1800 /* Check, if it is write protected */
1801 if (nand_check_wp(mtd))
1804 /* Invalidate the page cache, if we write to the cached page */
1805 if (page == this->pagebuf)
1808 if (NAND_MUST_PAD(this)) {
1809 /* Write out desired data */
1810 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1811 /* prepad 0xff for partial programming */
1812 this->write_buf(mtd, ffchars, column);
1814 this->write_buf(mtd, buf, len);
1815 /* postpad 0xff for partial programming */
1816 this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));
1818 /* Write out desired data */
1819 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1821 this->write_buf(mtd, buf, len);
1823 /* Send command to program the OOB data */
1824 this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);
1826 status = this->waitfunc (mtd, this, FL_WRITING);
1828 /* See if device thinks it succeeded */
1829 if (status & 0x01) {
1830 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1837 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1838 /* Send command to read back the data */
1839 this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1841 if (this->verify_buf(mtd, buf, len)) {
1842 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1849 /* Deselect and wake up anyone waiting on the device */
1850 nand_release_device(mtd);
1855 /* XXX U-BOOT XXX */
1858 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1859 * @mtd: MTD device structure
1860 * @vecs: the iovectors to write
1861 * @count: number of vectors
1862 * @to: offset to write to
1863 * @retlen: pointer to variable to store the number of written bytes
1865 * NAND write with kvec. This just calls the ecc function
1867 static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1868 loff_t to, size_t * retlen)
1870 return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));
1874 * nand_writev_ecc - [MTD Interface] write with iovec with ecc
1875 * @mtd: MTD device structure
1876 * @vecs: the iovectors to write
1877 * @count: number of vectors
1878 * @to: offset to write to
1879 * @retlen: pointer to variable to store the number of written bytes
1880 * @eccbuf: filesystem supplied oob data buffer
1881 * @oobsel: oob selection structure
1883 * NAND write with iovec with ecc
1885 static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1886 loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
1888 int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1889 int oob, numpages, autoplace = 0, startpage;
1890 struct nand_chip *this = mtd->priv;
1891 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1892 u_char *oobbuf, *bufstart;
1894 /* Preset written len for early exit */
1897 /* Calculate total length of data */
1899 for (i = 0; i < count; i++)
1900 total_len += (int) vecs[i].iov_len;
1902 DEBUG (MTD_DEBUG_LEVEL3,
1903 "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
1905 /* Do not allow write past end of page */
1906 if ((to + total_len) > mtd->size) {
1907 DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1911 /* reject writes, which are not page aligned */
1912 if (NOTALIGNED (to) || NOTALIGNED(total_len)) {
1913 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1917 /* Grab the lock and see if the device is available */
1918 nand_get_device (this, mtd, FL_WRITING);
1920 /* Get the current chip-nr */
1921 chipnr = (int) (to >> this->chip_shift);
1922 /* Select the NAND device */
1923 this->select_chip(mtd, chipnr);
1925 /* Check, if it is write protected */
1926 if (nand_check_wp(mtd))
1929 /* if oobsel is NULL, use chip defaults */
1931 oobsel = &mtd->oobinfo;
1933 /* Autoplace of oob data ? Use the default placement scheme */
1934 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1935 oobsel = this->autooob;
1938 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1941 /* Setup start page */
1942 page = (int) (to >> this->page_shift);
1943 /* Invalidate the page cache, if we write to the cached page */
1944 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
1947 startpage = page & this->pagemask;
1949 /* Loop until all kvec' data has been written */
1952 /* If the given tuple is >= pagesize then
1953 * write it out from the iov
1955 if ((vecs->iov_len - len) >= mtd->oobblock) {
1956 /* Calc number of pages we can write
1957 * out of this iov in one go */
1958 numpages = (vecs->iov_len - len) >> this->page_shift;
1959 /* Do not cross block boundaries */
1960 numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);
1961 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1962 bufstart = (u_char *)vecs->iov_base;
1964 this->data_poi = bufstart;
1966 for (i = 1; i <= numpages; i++) {
1967 /* Write one page. If this is the last page to write
1968 * then use the real pageprogram command, else select
1969 * cached programming if supported by the chip.
1971 ret = nand_write_page (mtd, this, page & this->pagemask,
1972 &oobbuf[oob], oobsel, i != numpages);
1975 this->data_poi += mtd->oobblock;
1976 len += mtd->oobblock;
1977 oob += mtd->oobsize;
1980 /* Check, if we have to switch to the next tuple */
1981 if (len >= (int) vecs->iov_len) {
1987 /* We must use the internal buffer, read data out of each
1988 * tuple until we have a full page to write
1991 while (cnt < mtd->oobblock) {
1992 if (vecs->iov_base != NULL && vecs->iov_len)
1993 this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
1994 /* Check, if we have to switch to the next tuple */
1995 if (len >= (int) vecs->iov_len) {
2001 this->pagebuf = page;
2002 this->data_poi = this->data_buf;
2003 bufstart = this->data_poi;
2005 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
2006 ret = nand_write_page (mtd, this, page & this->pagemask,
2013 this->data_poi = bufstart;
2014 ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
2018 written += mtd->oobblock * numpages;
2023 startpage = page & this->pagemask;
2024 /* Check, if we cross a chip boundary */
2027 this->select_chip(mtd, -1);
2028 this->select_chip(mtd, chipnr);
2033 /* Deselect and wake up anyone waiting on the device */
2034 nand_release_device(mtd);
2042 * single_erease_cmd - [GENERIC] NAND standard block erase command function
2043 * @mtd: MTD device structure
2044 * @page: the page address of the block which will be erased
2046 * Standard erase command for NAND chips
2048 static void single_erase_cmd (struct mtd_info *mtd, int page)
2050 struct nand_chip *this = mtd->priv;
2051 /* Send commands to erase a block */
2052 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2053 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2057 * multi_erease_cmd - [GENERIC] AND specific block erase command function
2058 * @mtd: MTD device structure
2059 * @page: the page address of the block which will be erased
2061 * AND multi block erase command function
2062 * Erase 4 consecutive blocks
2064 static void multi_erase_cmd (struct mtd_info *mtd, int page)
2066 struct nand_chip *this = mtd->priv;
2067 /* Send commands to erase a block */
2068 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
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_ERASE2, -1, -1);
2076 * nand_erase - [MTD Interface] erase block(s)
2077 * @mtd: MTD device structure
2078 * @instr: erase instruction
2080 * Erase one ore more blocks
2082 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
2084 return nand_erase_nand (mtd, instr, 0);
2088 * nand_erase_intern - [NAND Interface] erase block(s)
2089 * @mtd: MTD device structure
2090 * @instr: erase instruction
2091 * @allowbbt: allow erasing the bbt area
2093 * Erase one ore more blocks
2095 int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2097 int page, len, status, pages_per_block, ret, chipnr;
2098 struct nand_chip *this = mtd->priv;
2100 DEBUG (MTD_DEBUG_LEVEL3,
2101 "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
2103 /* Start address must align on block boundary */
2104 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2105 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2109 /* Length must align on block boundary */
2110 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2111 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2115 /* Do not allow erase past end of device */
2116 if ((instr->len + instr->addr) > mtd->size) {
2117 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2121 instr->fail_addr = 0xffffffff;
2123 /* Grab the lock and see if the device is available */
2124 nand_get_device (this, mtd, FL_ERASING);
2126 /* Shift to get first page */
2127 page = (int) (instr->addr >> this->page_shift);
2128 chipnr = (int) (instr->addr >> this->chip_shift);
2130 /* Calculate pages in each block */
2131 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
2133 /* Select the NAND device */
2134 this->select_chip(mtd, chipnr);
2136 /* Check the WP bit */
2137 /* Check, if it is write protected */
2138 if (nand_check_wp(mtd)) {
2139 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2140 instr->state = MTD_ERASE_FAILED;
2144 /* Loop through the pages */
2147 instr->state = MTD_ERASING;
2150 #ifndef NAND_ALLOW_ERASE_ALL
2151 /* Check if we have a bad block, we do not erase bad blocks ! */
2152 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2153 printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2154 instr->state = MTD_ERASE_FAILED;
2158 /* Invalidate the page cache, if we erase the block which contains
2159 the current cached page */
2160 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2163 this->erase_cmd (mtd, page & this->pagemask);
2165 status = this->waitfunc (mtd, this, FL_ERASING);
2167 /* See if block erase succeeded */
2168 if (status & 0x01) {
2169 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2170 instr->state = MTD_ERASE_FAILED;
2171 instr->fail_addr = (page << this->page_shift);
2175 /* Increment page address and decrement length */
2176 len -= (1 << this->phys_erase_shift);
2177 page += pages_per_block;
2179 /* Check, if we cross a chip boundary */
2180 if (len && !(page & this->pagemask)) {
2182 this->select_chip(mtd, -1);
2183 this->select_chip(mtd, chipnr);
2186 instr->state = MTD_ERASE_DONE;
2190 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2191 /* Do call back function */
2193 mtd_erase_callback(instr);
2195 /* Deselect and wake up anyone waiting on the device */
2196 nand_release_device(mtd);
2198 /* Return more or less happy */
2203 * nand_sync - [MTD Interface] sync
2204 * @mtd: MTD device structure
2206 * Sync is actually a wait for chip ready function
2208 static void nand_sync (struct mtd_info *mtd)
2210 struct nand_chip *this = mtd->priv;
2212 DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2214 /* Grab the lock and see if the device is available */
2215 nand_get_device (this, mtd, FL_SYNCING);
2216 /* Release it and go back */
2217 nand_release_device (mtd);
2222 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2223 * @mtd: MTD device structure
2224 * @ofs: offset relative to mtd start
2226 static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
2228 /* Check for invalid offset */
2229 if (ofs > mtd->size)
2232 return nand_block_checkbad (mtd, ofs, 1, 0);
2236 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2237 * @mtd: MTD device structure
2238 * @ofs: offset relative to mtd start
2240 static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
2242 struct nand_chip *this = mtd->priv;
2245 if ((ret = nand_block_isbad(mtd, ofs))) {
2246 /* If it was bad already, return success and do nothing. */
2252 return this->block_markbad(mtd, ofs);
2256 * nand_scan - [NAND Interface] Scan for the NAND device
2257 * @mtd: MTD device structure
2258 * @maxchips: Number of chips to scan for
2260 * This fills out all the not initialized function pointers
2261 * with the defaults.
2262 * The flash ID is read and the mtd/chip structures are
2263 * filled with the appropriate values. Buffers are allocated if
2264 * they are not provided by the board driver
2267 int nand_scan (struct mtd_info *mtd, int maxchips)
2269 int i, j, nand_maf_id, nand_dev_id, busw;
2270 struct nand_chip *this = mtd->priv;
2272 /* Get buswidth to select the correct functions*/
2273 busw = this->options & NAND_BUSWIDTH_16;
2275 /* check for proper chip_delay setup, set 20us if not */
2276 if (!this->chip_delay)
2277 this->chip_delay = 20;
2279 /* check, if a user supplied command function given */
2280 if (this->cmdfunc == NULL)
2281 this->cmdfunc = nand_command;
2283 /* check, if a user supplied wait function given */
2284 if (this->waitfunc == NULL)
2285 this->waitfunc = nand_wait;
2287 if (!this->select_chip)
2288 this->select_chip = nand_select_chip;
2289 if (!this->write_byte)
2290 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2291 if (!this->read_byte)
2292 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2293 if (!this->write_word)
2294 this->write_word = nand_write_word;
2295 if (!this->read_word)
2296 this->read_word = nand_read_word;
2297 if (!this->block_bad)
2298 this->block_bad = nand_block_bad;
2299 if (!this->block_markbad)
2300 this->block_markbad = nand_default_block_markbad;
2301 if (!this->write_buf)
2302 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2303 if (!this->read_buf)
2304 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2305 if (!this->verify_buf)
2306 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2307 if (!this->scan_bbt)
2308 this->scan_bbt = nand_default_bbt;
2310 /* Select the device */
2311 this->select_chip(mtd, 0);
2313 /* Send the command for reading device ID */
2314 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2316 /* Read manufacturer and device IDs */
2317 nand_maf_id = this->read_byte(mtd);
2318 nand_dev_id = this->read_byte(mtd);
2320 /* Print and store flash device information */
2321 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2323 if (nand_dev_id != nand_flash_ids[i].id)
2326 if (!mtd->name) mtd->name = nand_flash_ids[i].name;
2327 this->chipsize = nand_flash_ids[i].chipsize << 20;
2329 /* New devices have all the information in additional id bytes */
2330 if (!nand_flash_ids[i].pagesize) {
2332 /* The 3rd id byte contains non relevant data ATM */
2333 extid = this->read_byte(mtd);
2334 /* The 4th id byte is the important one */
2335 extid = this->read_byte(mtd);
2337 mtd->oobblock = 1024 << (extid & 0x3);
2340 mtd->oobsize = (8 << (extid & 0x03)) * (mtd->oobblock / 512);
2342 /* Calc blocksize. Blocksize is multiples of 64KiB */
2343 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2345 /* Get buswidth information */
2346 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2349 /* Old devices have this data hardcoded in the
2350 * device id table */
2351 mtd->erasesize = nand_flash_ids[i].erasesize;
2352 mtd->oobblock = nand_flash_ids[i].pagesize;
2353 mtd->oobsize = mtd->oobblock / 32;
2354 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2357 /* Check, if buswidth is correct. Hardware drivers should set
2359 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2360 printk (KERN_INFO "NAND device: Manufacturer ID:"
2361 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
2362 nand_manuf_ids[i].name , mtd->name);
2363 printk (KERN_WARNING
2364 "NAND bus width %d instead %d bit\n",
2365 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2367 this->select_chip(mtd, -1);
2371 /* Calculate the address shift from the page size */
2372 this->page_shift = ffs(mtd->oobblock) - 1;
2373 this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
2374 this->chip_shift = ffs(this->chipsize) - 1;
2376 /* Set the bad block position */
2377 this->badblockpos = mtd->oobblock > 512 ?
2378 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2380 /* Get chip options, preserve non chip based options */
2381 this->options &= ~NAND_CHIPOPTIONS_MSK;
2382 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2383 /* Set this as a default. Board drivers can override it, if neccecary */
2384 this->options |= NAND_NO_AUTOINCR;
2385 /* Check if this is a not a samsung device. Do not clear the options
2386 * for chips which are not having an extended id.
2388 if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2389 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2391 /* Check for AND chips with 4 page planes */
2392 if (this->options & NAND_4PAGE_ARRAY)
2393 this->erase_cmd = multi_erase_cmd;
2395 this->erase_cmd = single_erase_cmd;
2397 /* Do not replace user supplied command function ! */
2398 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2399 this->cmdfunc = nand_command_lp;
2401 /* Try to identify manufacturer */
2402 for (j = 0; nand_manuf_ids[j].id != 0x0; j++) {
2403 if (nand_manuf_ids[j].id == nand_maf_id)
2409 if (!nand_flash_ids[i].name) {
2410 printk (KERN_WARNING "No NAND device found!!!\n");
2411 this->select_chip(mtd, -1);
2415 for (i=1; i < maxchips; i++) {
2416 this->select_chip(mtd, i);
2418 /* Send the command for reading device ID */
2419 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2421 /* Read manufacturer and device IDs */
2422 if (nand_maf_id != this->read_byte(mtd) ||
2423 nand_dev_id != this->read_byte(mtd))
2427 printk(KERN_INFO "%d NAND chips detected\n", i);
2429 /* Allocate buffers, if neccecary */
2430 if (!this->oob_buf) {
2432 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
2433 this->oob_buf = kmalloc (len, GFP_KERNEL);
2434 if (!this->oob_buf) {
2435 printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
2438 this->options |= NAND_OOBBUF_ALLOC;
2441 if (!this->data_buf) {
2443 len = mtd->oobblock + mtd->oobsize;
2444 this->data_buf = kmalloc (len, GFP_KERNEL);
2445 if (!this->data_buf) {
2446 if (this->options & NAND_OOBBUF_ALLOC)
2447 kfree (this->oob_buf);
2448 printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
2451 this->options |= NAND_DATABUF_ALLOC;
2454 /* Store the number of chips and calc total size for mtd */
2456 mtd->size = i * this->chipsize;
2457 /* Convert chipsize to number of pages per chip -1. */
2458 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2459 /* Preset the internal oob buffer */
2460 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2462 /* If no default placement scheme is given, select an
2463 * appropriate one */
2464 if (!this->autooob) {
2465 /* Select the appropriate default oob placement scheme for
2466 * placement agnostic filesystems */
2467 switch (mtd->oobsize) {
2469 this->autooob = &nand_oob_8;
2472 this->autooob = &nand_oob_16;
2475 this->autooob = &nand_oob_64;
2478 printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
2484 /* The number of bytes available for the filesystem to place fs dependend
2486 if (this->options & NAND_BUSWIDTH_16) {
2487 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 2);
2488 if (this->autooob->eccbytes & 0x01)
2491 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 1);
2494 * check ECC mode, default to software
2495 * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
2496 * fallback to software ECC
2498 this->eccsize = 256; /* set default eccsize */
2501 switch (this->eccmode) {
2502 case NAND_ECC_HW12_2048:
2503 if (mtd->oobblock < 2048) {
2504 printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
2506 this->eccmode = NAND_ECC_SOFT;
2507 this->calculate_ecc = nand_calculate_ecc;
2508 this->correct_data = nand_correct_data;
2510 this->eccsize = 2048;
2513 case NAND_ECC_HW3_512:
2514 case NAND_ECC_HW6_512:
2515 case NAND_ECC_HW8_512:
2516 if (mtd->oobblock == 256) {
2517 printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
2518 this->eccmode = NAND_ECC_SOFT;
2519 this->calculate_ecc = nand_calculate_ecc;
2520 this->correct_data = nand_correct_data;
2522 this->eccsize = 512; /* set eccsize to 512 */
2525 case NAND_ECC_HW3_256:
2529 printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
2530 this->eccmode = NAND_ECC_NONE;
2534 this->calculate_ecc = nand_calculate_ecc;
2535 this->correct_data = nand_correct_data;
2539 printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
2543 /* Check hardware ecc function availability and adjust number of ecc bytes per
2546 switch (this->eccmode) {
2547 case NAND_ECC_HW12_2048:
2548 this->eccbytes += 4;
2549 case NAND_ECC_HW8_512:
2550 this->eccbytes += 2;
2551 case NAND_ECC_HW6_512:
2552 this->eccbytes += 3;
2553 case NAND_ECC_HW3_512:
2554 case NAND_ECC_HW3_256:
2555 if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
2557 printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
2561 mtd->eccsize = this->eccsize;
2563 /* Set the number of read / write steps for one page to ensure ECC generation */
2564 switch (this->eccmode) {
2565 case NAND_ECC_HW12_2048:
2566 this->eccsteps = mtd->oobblock / 2048;
2568 case NAND_ECC_HW3_512:
2569 case NAND_ECC_HW6_512:
2570 case NAND_ECC_HW8_512:
2571 this->eccsteps = mtd->oobblock / 512;
2573 case NAND_ECC_HW3_256:
2575 this->eccsteps = mtd->oobblock / 256;
2583 /* XXX U-BOOT XXX */
2585 /* Initialize state, waitqueue and spinlock */
2586 this->state = FL_READY;
2587 init_waitqueue_head (&this->wq);
2588 spin_lock_init (&this->chip_lock);
2591 /* De-select the device */
2592 this->select_chip(mtd, -1);
2594 /* Invalidate the pagebuffer reference */
2597 /* Fill in remaining MTD driver data */
2598 mtd->type = MTD_NANDFLASH;
2599 mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
2600 mtd->ecctype = MTD_ECC_SW;
2601 mtd->erase = nand_erase;
2603 mtd->unpoint = NULL;
2604 mtd->read = nand_read;
2605 mtd->write = nand_write;
2606 mtd->read_ecc = nand_read_ecc;
2607 mtd->write_ecc = nand_write_ecc;
2608 mtd->read_oob = nand_read_oob;
2609 mtd->write_oob = nand_write_oob;
2610 /* XXX U-BOOT XXX */
2613 mtd->writev = nand_writev;
2614 mtd->writev_ecc = nand_writev_ecc;
2616 mtd->sync = nand_sync;
2617 /* XXX U-BOOT XXX */
2621 mtd->suspend = NULL;
2624 mtd->block_isbad = nand_block_isbad;
2625 mtd->block_markbad = nand_block_markbad;
2627 /* and make the autooob the default one */
2628 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2629 /* XXX U-BOOT XXX */
2631 mtd->owner = THIS_MODULE;
2633 /* Build bad block table */
2634 return this->scan_bbt (mtd);
2638 * nand_release - [NAND Interface] Free resources held by the NAND device
2639 * @mtd: MTD device structure
2641 void nand_release (struct mtd_info *mtd)
2643 struct nand_chip *this = mtd->priv;
2645 #ifdef CONFIG_MTD_PARTITIONS
2646 /* Deregister partitions */
2647 del_mtd_partitions (mtd);
2649 /* Deregister the device */
2650 /* XXX U-BOOT XXX */
2652 del_mtd_device (mtd);
2654 /* Free bad block table memory, if allocated */
2657 /* Buffer allocated by nand_scan ? */
2658 if (this->options & NAND_OOBBUF_ALLOC)
2659 kfree (this->oob_buf);
2660 /* Buffer allocated by nand_scan ? */
2661 if (this->options & NAND_DATABUF_ALLOC)
2662 kfree (this->data_buf);
2666 #endif /* CONFIG_NEW_NAND_CODE */