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
29 * patch from Ben Dooks <ben-mtd@fluff.org>
31 * 12-05-2004 dmarlin: add workaround for Renesas AG-AND chips "disturb"
32 * issue. Basically, any block not rewritten may lose data when
33 * surrounding blocks are rewritten many times. JFFS2 ensures
34 * this doesn't happen for blocks it uses, but the Bad Block
35 * Table(s) may not be rewritten. To ensure they do not lose
36 * data, force them to be rewritten when some of the surrounding
37 * blocks are erased. Rather than tracking a specific nearby
38 * block (which could itself go bad), use a page address 'mask' to
39 * select several blocks in the same area, and rewrite the BBT
40 * when any of them are erased.
42 * 01-03-2005 dmarlin: added support for the device recovery command sequence
43 * for Renesas AG-AND chips. If there was a sudden loss of power
44 * during an erase operation, a "device recovery" operation must
45 * be performed when power is restored to ensure correct
48 * 01-20-2005 dmarlin: added support for optional hardware specific callback
49 * routine to perform extra error status checks on erase and write
50 * failures. This required adding a wrapper function for
53 * 08-20-2005 vwool: suspend/resume added
56 * David Woodhouse for adding multichip support
58 * Aleph One Ltd. and Toby Churchill Ltd. for supporting the
59 * rework for 2K page size chips
62 * Enable cached programming for 2k page size chips
63 * Check, if mtd->ecctype should be set to MTD_ECC_HW
64 * if we have HW ecc support.
65 * The AG-AND chips have nice features for speed improvement,
66 * which are not supported yet. Read / program 4 pages in one go.
68 * $Id: nand_base.c,v 1.150 2005/09/15 13:58:48 vwool Exp $
70 * This program is free software; you can redistribute it and/or modify
71 * it under the terms of the GNU General Public License version 2 as
72 * published by the Free Software Foundation.
76 #include <linux/module.h>
77 #include <linux/delay.h>
78 #include <linux/errno.h>
79 #include <linux/err.h>
80 #include <linux/sched.h>
81 #include <linux/slab.h>
82 #include <linux/types.h>
83 #include <linux/mtd/mtd.h>
84 #include <linux/mtd/nand.h>
85 #include <linux/mtd/nand_ecc.h>
86 #include <linux/mtd/compatmac.h>
87 #include <linux/interrupt.h>
88 #include <linux/bitops.h>
89 #include <linux/leds.h>
92 #ifdef CONFIG_MTD_PARTITIONS
93 #include <linux/mtd/partitions.h>
96 /* Define default oob placement schemes for large and small page devices */
97 static struct nand_oobinfo nand_oob_8 = {
98 .useecc = MTD_NANDECC_AUTOPLACE,
101 .oobfree = {{3, 2}, {6, 2}}
104 static struct nand_oobinfo nand_oob_16 = {
105 .useecc = MTD_NANDECC_AUTOPLACE,
107 .eccpos = {0, 1, 2, 3, 6, 7},
111 static struct nand_oobinfo nand_oob_64 = {
112 .useecc = MTD_NANDECC_AUTOPLACE,
115 40, 41, 42, 43, 44, 45, 46, 47,
116 48, 49, 50, 51, 52, 53, 54, 55,
117 56, 57, 58, 59, 60, 61, 62, 63},
121 /* This is used for padding purposes in nand_write_oob */
122 static uint8_t ffchars[] = {
123 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
124 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
125 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
126 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
127 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
128 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
129 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
130 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
134 * NAND low-level MTD interface functions
136 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len);
137 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len);
138 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len);
140 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
141 size_t *retlen, uint8_t *buf);
142 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
143 size_t *retlen, uint8_t *buf);
144 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
145 size_t *retlen, const uint8_t *buf);
146 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
147 size_t *retlen, const uint8_t *buf);
148 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr);
149 static void nand_sync(struct mtd_info *mtd);
151 /* Some internal functions */
152 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this,
153 int page, uint8_t * oob_buf,
154 struct nand_oobinfo *oobsel, int mode);
155 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
156 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this,
157 int page, int numpages, uint8_t *oob_buf,
158 struct nand_oobinfo *oobsel, int chipnr,
161 #define nand_verify_pages(...) (0)
164 static int nand_get_device(struct nand_chip *this, struct mtd_info *mtd,
168 * nand_release_device - [GENERIC] release chip
169 * @mtd: MTD device structure
171 * Deselect, release chip lock and wake up anyone waiting on the device
173 static void nand_release_device(struct mtd_info *mtd)
175 struct nand_chip *this = mtd->priv;
177 /* De-select the NAND device */
178 this->select_chip(mtd, -1);
180 /* Release the controller and the chip */
181 spin_lock(&this->controller->lock);
182 this->controller->active = NULL;
183 this->state = FL_READY;
184 wake_up(&this->controller->wq);
185 spin_unlock(&this->controller->lock);
189 * nand_read_byte - [DEFAULT] read one byte from the chip
190 * @mtd: MTD device structure
192 * Default read function for 8bit buswith
194 static uint8_t nand_read_byte(struct mtd_info *mtd)
196 struct nand_chip *this = mtd->priv;
197 return readb(this->IO_ADDR_R);
201 * nand_write_byte - [DEFAULT] write one byte to the chip
202 * @mtd: MTD device structure
203 * @byte: pointer to data byte to write
205 * Default write function for 8it buswith
207 static void nand_write_byte(struct mtd_info *mtd, uint8_t byte)
209 struct nand_chip *this = mtd->priv;
210 writeb(byte, this->IO_ADDR_W);
214 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
215 * @mtd: MTD device structure
217 * Default read function for 16bit buswith with
218 * endianess conversion
220 static uint8_t nand_read_byte16(struct mtd_info *mtd)
222 struct nand_chip *this = mtd->priv;
223 return (uint8_t) cpu_to_le16(readw(this->IO_ADDR_R));
227 * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
228 * @mtd: MTD device structure
229 * @byte: pointer to data byte to write
231 * Default write function for 16bit buswith with
232 * endianess conversion
234 static void nand_write_byte16(struct mtd_info *mtd, uint8_t byte)
236 struct nand_chip *this = mtd->priv;
237 writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
241 * nand_read_word - [DEFAULT] read one word from the chip
242 * @mtd: MTD device structure
244 * Default read function for 16bit buswith without
245 * endianess conversion
247 static u16 nand_read_word(struct mtd_info *mtd)
249 struct nand_chip *this = mtd->priv;
250 return readw(this->IO_ADDR_R);
254 * nand_write_word - [DEFAULT] write one word to the chip
255 * @mtd: MTD device structure
256 * @word: data word to write
258 * Default write function for 16bit buswith without
259 * endianess conversion
261 static void nand_write_word(struct mtd_info *mtd, u16 word)
263 struct nand_chip *this = mtd->priv;
264 writew(word, this->IO_ADDR_W);
268 * nand_select_chip - [DEFAULT] control CE line
269 * @mtd: MTD device structure
270 * @chip: chipnumber to select, -1 for deselect
272 * Default select function for 1 chip devices.
274 static void nand_select_chip(struct mtd_info *mtd, int chip)
276 struct nand_chip *this = mtd->priv;
279 this->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
282 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
291 * nand_write_buf - [DEFAULT] write buffer to chip
292 * @mtd: MTD device structure
294 * @len: number of bytes to write
296 * Default write function for 8bit buswith
298 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
301 struct nand_chip *this = mtd->priv;
303 for (i = 0; i < len; i++)
304 writeb(buf[i], this->IO_ADDR_W);
308 * nand_read_buf - [DEFAULT] read chip data into buffer
309 * @mtd: MTD device structure
310 * @buf: buffer to store date
311 * @len: number of bytes to read
313 * Default read function for 8bit buswith
315 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
318 struct nand_chip *this = mtd->priv;
320 for (i = 0; i < len; i++)
321 buf[i] = readb(this->IO_ADDR_R);
325 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
326 * @mtd: MTD device structure
327 * @buf: buffer containing the data to compare
328 * @len: number of bytes to compare
330 * Default verify function for 8bit buswith
332 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
335 struct nand_chip *this = mtd->priv;
337 for (i = 0; i < len; i++)
338 if (buf[i] != readb(this->IO_ADDR_R))
345 * nand_write_buf16 - [DEFAULT] write buffer to chip
346 * @mtd: MTD device structure
348 * @len: number of bytes to write
350 * Default write function for 16bit buswith
352 static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
355 struct nand_chip *this = mtd->priv;
356 u16 *p = (u16 *) buf;
359 for (i = 0; i < len; i++)
360 writew(p[i], this->IO_ADDR_W);
365 * nand_read_buf16 - [DEFAULT] read chip data into buffer
366 * @mtd: MTD device structure
367 * @buf: buffer to store date
368 * @len: number of bytes to read
370 * Default read function for 16bit buswith
372 static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
375 struct nand_chip *this = mtd->priv;
376 u16 *p = (u16 *) buf;
379 for (i = 0; i < len; i++)
380 p[i] = readw(this->IO_ADDR_R);
384 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
385 * @mtd: MTD device structure
386 * @buf: buffer containing the data to compare
387 * @len: number of bytes to compare
389 * Default verify function for 16bit buswith
391 static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
394 struct nand_chip *this = mtd->priv;
395 u16 *p = (u16 *) buf;
398 for (i = 0; i < len; i++)
399 if (p[i] != readw(this->IO_ADDR_R))
406 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
407 * @mtd: MTD device structure
408 * @ofs: offset from device start
409 * @getchip: 0, if the chip is already selected
411 * Check, if the block is bad.
413 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
415 int page, chipnr, res = 0;
416 struct nand_chip *this = mtd->priv;
420 page = (int)(ofs >> this->page_shift);
421 chipnr = (int)(ofs >> this->chip_shift);
423 /* Grab the lock and see if the device is available */
424 nand_get_device(this, mtd, FL_READING);
426 /* Select the NAND device */
427 this->select_chip(mtd, chipnr);
431 if (this->options & NAND_BUSWIDTH_16) {
432 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE,
433 page & this->pagemask);
434 bad = cpu_to_le16(this->read_word(mtd));
435 if (this->badblockpos & 0x1)
437 if ((bad & 0xFF) != 0xff)
440 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos,
441 page & this->pagemask);
442 if (this->read_byte(mtd) != 0xff)
447 /* Deselect and wake up anyone waiting on the device */
448 nand_release_device(mtd);
455 * nand_default_block_markbad - [DEFAULT] mark a block bad
456 * @mtd: MTD device structure
457 * @ofs: offset from device start
459 * This is the default implementation, which can be overridden by
460 * a hardware specific driver.
462 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
464 struct nand_chip *this = mtd->priv;
465 uint8_t buf[2] = { 0, 0 };
469 /* Get block number */
470 block = ((int)ofs) >> this->bbt_erase_shift;
472 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
474 /* Do we have a flash based bad block table ? */
475 if (this->options & NAND_USE_FLASH_BBT)
476 return nand_update_bbt(mtd, ofs);
478 /* We write two bytes, so we dont have to mess with 16 bit access */
479 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
480 return nand_write_oob(mtd, ofs, 2, &retlen, buf);
484 * nand_check_wp - [GENERIC] check if the chip is write protected
485 * @mtd: MTD device structure
486 * Check, if the device is write protected
488 * The function expects, that the device is already selected
490 static int nand_check_wp(struct mtd_info *mtd)
492 struct nand_chip *this = mtd->priv;
493 /* Check the WP bit */
494 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
495 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
499 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
500 * @mtd: MTD device structure
501 * @ofs: offset from device start
502 * @getchip: 0, if the chip is already selected
503 * @allowbbt: 1, if its allowed to access the bbt area
505 * Check, if the block is bad. Either by reading the bad block table or
506 * calling of the scan function.
508 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
511 struct nand_chip *this = mtd->priv;
514 return this->block_bad(mtd, ofs, getchip);
516 /* Return info from the table */
517 return nand_isbad_bbt(mtd, ofs, allowbbt);
520 DEFINE_LED_TRIGGER(nand_led_trigger);
523 * Wait for the ready pin, after a command
524 * The timeout is catched later.
526 static void nand_wait_ready(struct mtd_info *mtd)
528 struct nand_chip *this = mtd->priv;
529 unsigned long timeo = jiffies + 2;
531 led_trigger_event(nand_led_trigger, LED_FULL);
532 /* wait until command is processed or timeout occures */
534 if (this->dev_ready(mtd))
536 touch_softlockup_watchdog();
537 } while (time_before(jiffies, timeo));
538 led_trigger_event(nand_led_trigger, LED_OFF);
542 * nand_command - [DEFAULT] Send command to NAND device
543 * @mtd: MTD device structure
544 * @command: the command to be sent
545 * @column: the column address for this command, -1 if none
546 * @page_addr: the page address for this command, -1 if none
548 * Send command to NAND device. This function is used for small page
549 * devices (256/512 Bytes per page)
551 static void nand_command(struct mtd_info *mtd, unsigned int command,
552 int column, int page_addr)
554 register struct nand_chip *this = mtd->priv;
555 int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
558 * Write out the command to the device.
560 if (command == NAND_CMD_SEQIN) {
563 if (column >= mtd->writesize) {
565 column -= mtd->writesize;
566 readcmd = NAND_CMD_READOOB;
567 } else if (column < 256) {
568 /* First 256 bytes --> READ0 */
569 readcmd = NAND_CMD_READ0;
572 readcmd = NAND_CMD_READ1;
574 this->cmd_ctrl(mtd, readcmd, ctrl);
575 ctrl &= ~NAND_CTRL_CHANGE;
577 this->cmd_ctrl(mtd, command, ctrl);
580 * Address cycle, when necessary
582 ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
583 /* Serially input address */
585 /* Adjust columns for 16 bit buswidth */
586 if (this->options & NAND_BUSWIDTH_16)
588 this->cmd_ctrl(mtd, column, ctrl);
589 ctrl &= ~NAND_CTRL_CHANGE;
591 if (page_addr != -1) {
592 this->cmd_ctrl(mtd, page_addr, ctrl);
593 ctrl &= ~NAND_CTRL_CHANGE;
594 this->cmd_ctrl(mtd, page_addr >> 8, ctrl);
595 /* One more address cycle for devices > 32MiB */
596 if (this->chipsize > (32 << 20))
597 this->cmd_ctrl(mtd, page_addr >> 16, ctrl);
599 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
602 * program and erase have their own busy handlers
603 * status and sequential in needs no delay
607 case NAND_CMD_PAGEPROG:
608 case NAND_CMD_ERASE1:
609 case NAND_CMD_ERASE2:
611 case NAND_CMD_STATUS:
612 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
618 udelay(this->chip_delay);
619 this->cmd_ctrl(mtd, NAND_CMD_STATUS,
620 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
621 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
622 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
625 /* This applies to read commands */
628 * If we don't have access to the busy pin, we apply the given
631 if (!this->dev_ready) {
632 udelay(this->chip_delay);
636 /* Apply this short delay always to ensure that we do wait tWB in
637 * any case on any machine. */
640 nand_wait_ready(mtd);
644 * nand_command_lp - [DEFAULT] Send command to NAND large page device
645 * @mtd: MTD device structure
646 * @command: the command to be sent
647 * @column: the column address for this command, -1 if none
648 * @page_addr: the page address for this command, -1 if none
650 * Send command to NAND device. This is the version for the new large page
651 * devices We dont have the separate regions as we have in the small page
652 * devices. We must emulate NAND_CMD_READOOB to keep the code compatible.
655 static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
656 int column, int page_addr)
658 register struct nand_chip *this = mtd->priv;
660 /* Emulate NAND_CMD_READOOB */
661 if (command == NAND_CMD_READOOB) {
662 column += mtd->writesize;
663 command = NAND_CMD_READ0;
666 /* Command latch cycle */
667 this->cmd_ctrl(mtd, command & 0xff,
668 NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
670 if (column != -1 || page_addr != -1) {
671 int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
673 /* Serially input address */
675 /* Adjust columns for 16 bit buswidth */
676 if (this->options & NAND_BUSWIDTH_16)
678 this->cmd_ctrl(mtd, column, ctrl);
679 ctrl &= ~NAND_CTRL_CHANGE;
680 this->cmd_ctrl(mtd, column >> 8, ctrl);
682 if (page_addr != -1) {
683 this->cmd_ctrl(mtd, page_addr, ctrl);
684 this->cmd_ctrl(mtd, page_addr >> 8,
685 NAND_NCE | NAND_ALE);
686 /* One more address cycle for devices > 128MiB */
687 if (this->chipsize > (128 << 20))
688 this->cmd_ctrl(mtd, page_addr >> 16,
689 NAND_NCE | NAND_ALE);
692 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
695 * program and erase have their own busy handlers
696 * status, sequential in, and deplete1 need no delay
700 case NAND_CMD_CACHEDPROG:
701 case NAND_CMD_PAGEPROG:
702 case NAND_CMD_ERASE1:
703 case NAND_CMD_ERASE2:
705 case NAND_CMD_STATUS:
706 case NAND_CMD_DEPLETE1:
710 * read error status commands require only a short delay
712 case NAND_CMD_STATUS_ERROR:
713 case NAND_CMD_STATUS_ERROR0:
714 case NAND_CMD_STATUS_ERROR1:
715 case NAND_CMD_STATUS_ERROR2:
716 case NAND_CMD_STATUS_ERROR3:
717 udelay(this->chip_delay);
723 udelay(this->chip_delay);
724 this->cmd_ctrl(mtd, NAND_CMD_STATUS, NAND_NCE | NAND_CLE);
725 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
726 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
730 this->cmd_ctrl(mtd, NAND_CMD_READSTART, NAND_NCE | NAND_CLE);
731 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
733 /* This applies to read commands */
736 * If we don't have access to the busy pin, we apply the given
739 if (!this->dev_ready) {
740 udelay(this->chip_delay);
745 /* Apply this short delay always to ensure that we do wait tWB in
746 * any case on any machine. */
749 nand_wait_ready(mtd);
753 * nand_get_device - [GENERIC] Get chip for selected access
754 * @this: the nand chip descriptor
755 * @mtd: MTD device structure
756 * @new_state: the state which is requested
758 * Get the device and lock it for exclusive access
761 nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state)
763 spinlock_t *lock = &this->controller->lock;
764 wait_queue_head_t *wq = &this->controller->wq;
765 DECLARE_WAITQUEUE(wait, current);
769 /* Hardware controller shared among independend devices */
770 /* Hardware controller shared among independend devices */
771 if (!this->controller->active)
772 this->controller->active = this;
774 if (this->controller->active == this && this->state == FL_READY) {
775 this->state = new_state;
779 if (new_state == FL_PM_SUSPENDED) {
781 return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
783 set_current_state(TASK_UNINTERRUPTIBLE);
784 add_wait_queue(wq, &wait);
787 remove_wait_queue(wq, &wait);
792 * nand_wait - [DEFAULT] wait until the command is done
793 * @mtd: MTD device structure
794 * @this: NAND chip structure
795 * @state: state to select the max. timeout value
797 * Wait for command done. This applies to erase and program only
798 * Erase can take up to 400ms and program up to 20ms according to
799 * general NAND and SmartMedia specs
802 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
805 unsigned long timeo = jiffies;
808 if (state == FL_ERASING)
809 timeo += (HZ * 400) / 1000;
811 timeo += (HZ * 20) / 1000;
813 led_trigger_event(nand_led_trigger, LED_FULL);
815 /* Apply this short delay always to ensure that we do wait tWB in
816 * any case on any machine. */
819 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
820 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
822 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
824 while (time_before(jiffies, timeo)) {
825 /* Check, if we were interrupted */
826 if (this->state != state)
829 if (this->dev_ready) {
830 if (this->dev_ready(mtd))
833 if (this->read_byte(mtd) & NAND_STATUS_READY)
838 led_trigger_event(nand_led_trigger, LED_OFF);
840 status = (int)this->read_byte(mtd);
845 * nand_write_page - [GENERIC] write one page
846 * @mtd: MTD device structure
847 * @this: NAND chip structure
848 * @page: startpage inside the chip, must be called with (page & this->pagemask)
849 * @oob_buf: out of band data buffer
850 * @oobsel: out of band selecttion structre
851 * @cached: 1 = enable cached programming if supported by chip
853 * Nand_page_program function is used for write and writev !
854 * This function will always program a full page of data
855 * If you call it with a non page aligned buffer, you're lost :)
857 * Cached programming is not supported yet.
859 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page,
860 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int cached)
863 uint8_t ecc_code[32];
864 int eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
865 int *oob_config = oobsel->eccpos;
866 int datidx = 0, eccidx = 0, eccsteps = this->ecc.steps;
869 /* FIXME: Enable cached programming */
872 /* Send command to begin auto page programming */
873 this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
875 /* Write out complete page of data, take care of eccmode */
877 /* No ecc, write all */
879 printk(KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
880 this->write_buf(mtd, this->data_poi, mtd->writesize);
883 /* Software ecc 3/256, write all */
885 for (; eccsteps; eccsteps--) {
886 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
887 for (i = 0; i < 3; i++, eccidx++)
888 oob_buf[oob_config[eccidx]] = ecc_code[i];
889 datidx += this->ecc.size;
891 this->write_buf(mtd, this->data_poi, mtd->writesize);
894 eccbytes = this->ecc.bytes;
895 for (; eccsteps; eccsteps--) {
896 /* enable hardware ecc logic for write */
897 this->ecc.hwctl(mtd, NAND_ECC_WRITE);
898 this->write_buf(mtd, &this->data_poi[datidx], this->ecc.size);
899 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
900 for (i = 0; i < eccbytes; i++, eccidx++)
901 oob_buf[oob_config[eccidx]] = ecc_code[i];
902 /* If the hardware ecc provides syndromes then
903 * the ecc code must be written immidiately after
904 * the data bytes (words) */
905 if (this->options & NAND_HWECC_SYNDROME)
906 this->write_buf(mtd, ecc_code, eccbytes);
907 datidx += this->ecc.size;
912 /* Write out OOB data */
913 if (this->options & NAND_HWECC_SYNDROME)
914 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
916 this->write_buf(mtd, oob_buf, mtd->oobsize);
918 /* Send command to actually program the data */
919 this->cmdfunc(mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
922 /* call wait ready function */
923 status = this->waitfunc(mtd, this, FL_WRITING);
925 /* See if operation failed and additional status checks are available */
926 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
927 status = this->errstat(mtd, this, FL_WRITING, status, page);
930 /* See if device thinks it succeeded */
931 if (status & NAND_STATUS_FAIL) {
932 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
936 /* FIXME: Implement cached programming ! */
937 /* wait until cache is ready */
938 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
943 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
945 * nand_verify_pages - [GENERIC] verify the chip contents after a write
946 * @mtd: MTD device structure
947 * @this: NAND chip structure
948 * @page: startpage inside the chip, must be called with (page & this->pagemask)
949 * @numpages: number of pages to verify
950 * @oob_buf: out of band data buffer
951 * @oobsel: out of band selecttion structre
952 * @chipnr: number of the current chip
953 * @oobmode: 1 = full buffer verify, 0 = ecc only
955 * The NAND device assumes that it is always writing to a cleanly erased page.
956 * Hence, it performs its internal write verification only on bits that
957 * transitioned from 1 to 0. The device does NOT verify the whole page on a
958 * byte by byte basis. It is possible that the page was not completely erased
959 * or the page is becoming unusable due to wear. The read with ECC would catch
960 * the error later when the ECC page check fails, but we would rather catch
961 * it early in the page write stage. Better to write no data than invalid data.
963 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
964 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
966 int i, j, datidx = 0, oobofs = 0, res = -EIO;
967 int eccsteps = this->eccsteps;
971 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
973 /* Send command to read back the first page */
974 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
977 for (j = 0; j < eccsteps; j++) {
978 /* Loop through and verify the data */
979 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
980 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
983 datidx += mtd->eccsize;
984 /* Have we a hw generator layout ? */
987 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
988 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
991 oobofs += hweccbytes;
994 /* check, if we must compare all data or if we just have to
995 * compare the ecc bytes
998 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
999 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1003 /* Read always, else autoincrement fails */
1004 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
1006 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
1007 int ecccnt = oobsel->eccbytes;
1009 for (i = 0; i < ecccnt; i++) {
1010 int idx = oobsel->eccpos[i];
1011 if (oobdata[idx] != oob_buf[oobofs + idx]) {
1012 DEBUG(MTD_DEBUG_LEVEL0, "%s: Failed ECC write verify, page 0x%08x, %6i bytes were succesful\n",
1013 __FUNCTION__, page, i);
1019 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1023 /* Apply delay or wait for ready/busy pin
1024 * Do this before the AUTOINCR check, so no problems
1025 * arise if a chip which does auto increment
1026 * is marked as NOAUTOINCR by the board driver.
1027 * Do this also before returning, so the chip is
1028 * ready for the next command.
1030 if (!this->dev_ready)
1031 udelay(this->chip_delay);
1033 nand_wait_ready(mtd);
1035 /* All done, return happy */
1039 /* Check, if the chip supports auto page increment */
1040 if (!NAND_CANAUTOINCR(this))
1041 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1044 * Terminate the read command. We come here in case of an error
1045 * So we must issue a reset command.
1048 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1054 * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
1055 * @mtd: MTD device structure
1056 * @from: offset to read from
1057 * @len: number of bytes to read
1058 * @retlen: pointer to variable to store the number of read bytes
1059 * @buf: the databuffer to put data
1061 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1064 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1066 return nand_do_read_ecc(mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1070 * nand_do_read_ecc - [MTD Interface] Read data with ECC
1071 * @mtd: MTD device structure
1072 * @from: offset to read from
1073 * @len: number of bytes to read
1074 * @retlen: pointer to variable to store the number of read bytes
1075 * @buf: the databuffer to put data
1076 * @oob_buf: filesystem supplied oob data buffer (can be NULL)
1077 * @oobsel: oob selection structure
1078 * @flags: flag to indicate if nand_get_device/nand_release_device should be preformed
1079 * and how many corrected error bits are acceptable:
1080 * bits 0..7 - number of tolerable errors
1081 * bit 8 - 0 == do not get/release chip, 1 == get/release chip
1083 * NAND read with ECC
1085 int nand_do_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1086 size_t *retlen, uint8_t *buf, uint8_t *oob_buf, struct nand_oobinfo *oobsel, int flags)
1089 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1090 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1091 struct nand_chip *this = mtd->priv;
1092 uint8_t *data_poi, *oob_data = oob_buf;
1093 uint8_t ecc_calc[32];
1094 uint8_t ecc_code[32];
1095 int eccmode, eccsteps;
1096 int *oob_config, datidx;
1097 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1102 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1104 /* Do not allow reads past end of device */
1105 if ((from + len) > mtd->size) {
1106 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1111 /* Grab the lock and see if the device is available */
1112 if (flags & NAND_GET_DEVICE)
1113 nand_get_device(this, mtd, FL_READING);
1115 /* Autoplace of oob data ? Use the default placement scheme */
1116 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1117 oobsel = this->autooob;
1119 eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
1120 oob_config = oobsel->eccpos;
1122 /* Select the NAND device */
1123 chipnr = (int)(from >> this->chip_shift);
1124 this->select_chip(mtd, chipnr);
1126 /* First we calculate the starting page */
1127 realpage = (int)(from >> this->page_shift);
1128 page = realpage & this->pagemask;
1130 /* Get raw starting column */
1131 col = from & (mtd->writesize - 1);
1133 end = mtd->writesize;
1134 ecc = this->ecc.size;
1135 eccbytes = this->ecc.bytes;
1137 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1140 oobreadlen = mtd->oobsize;
1141 if (this->options & NAND_HWECC_SYNDROME)
1142 oobreadlen -= oobsel->eccbytes;
1144 /* Loop until all data read */
1145 while (read < len) {
1147 int aligned = (!col && (len - read) >= end);
1149 * If the read is not page aligned, we have to read into data buffer
1150 * due to ecc, else we read into return buffer direct
1153 data_poi = &buf[read];
1155 data_poi = this->data_buf;
1157 /* Check, if we have this page in the buffer
1159 * FIXME: Make it work when we must provide oob data too,
1160 * check the usage of data_buf oob field
1162 if (realpage == this->pagebuf && !oob_buf) {
1163 /* aligned read ? */
1165 memcpy(data_poi, this->data_buf, end);
1169 /* Check, if we must send the read command */
1171 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1175 /* get oob area, if we have no oob buffer from fs-driver */
1176 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1177 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1178 oob_data = &this->data_buf[end];
1180 eccsteps = this->ecc.steps;
1183 case NAND_ECC_NONE:{
1184 /* No ECC, Read in a page */
1185 static unsigned long lastwhinge = 0;
1186 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1188 "Reading data from NAND FLASH without ECC is not recommended\n");
1189 lastwhinge = jiffies;
1191 this->read_buf(mtd, data_poi, end);
1195 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1196 this->read_buf(mtd, data_poi, end);
1197 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += 3, datidx += ecc)
1198 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1202 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += eccbytes, datidx += ecc) {
1203 this->ecc.hwctl(mtd, NAND_ECC_READ);
1204 this->read_buf(mtd, &data_poi[datidx], ecc);
1206 /* HW ecc with syndrome calculation must read the
1207 * syndrome from flash immidiately after the data */
1209 /* Some hw ecc generators need to know when the
1210 * syndrome is read from flash */
1211 this->ecc.hwctl(mtd, NAND_ECC_READSYN);
1212 this->read_buf(mtd, &oob_data[i], eccbytes);
1213 /* We calc error correction directly, it checks the hw
1214 * generator for an error, reads back the syndrome and
1215 * does the error correction on the fly */
1216 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1217 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1218 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1219 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1223 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1230 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1232 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1236 /* Pick the ECC bytes out of the oob data */
1237 for (j = 0; j < oobsel->eccbytes; j++)
1238 ecc_code[j] = oob_data[oob_config[j]];
1240 /* correct data, if necessary */
1241 for (i = 0, j = 0, datidx = 0; i < this->ecc.steps; i++, datidx += ecc) {
1242 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1244 /* Get next chunk of ecc bytes */
1247 /* Check, if we have a fs supplied oob-buffer,
1248 * This is the legacy mode. Used by YAFFS1
1249 * Should go away some day
1251 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1252 int *p = (int *)(&oob_data[mtd->oobsize]);
1256 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1257 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1263 /* check, if we have a fs supplied oob-buffer */
1265 /* without autoplace. Legacy mode used by YAFFS1 */
1266 switch (oobsel->useecc) {
1267 case MTD_NANDECC_AUTOPLACE:
1268 case MTD_NANDECC_AUTOPL_USR:
1269 /* Walk through the autoplace chunks */
1270 for (i = 0; oobsel->oobfree[i][1]; i++) {
1271 int from = oobsel->oobfree[i][0];
1272 int num = oobsel->oobfree[i][1];
1273 memcpy(&oob_buf[oob], &oob_data[from], num);
1277 case MTD_NANDECC_PLACE:
1278 /* YAFFS1 legacy mode */
1279 oob_data += this->ecc.steps * sizeof(int);
1281 oob_data += mtd->oobsize;
1285 /* Partial page read, transfer data into fs buffer */
1287 for (j = col; j < end && read < len; j++)
1288 buf[read++] = data_poi[j];
1289 this->pagebuf = realpage;
1291 read += mtd->writesize;
1293 /* Apply delay or wait for ready/busy pin
1294 * Do this before the AUTOINCR check, so no problems
1295 * arise if a chip which does auto increment
1296 * is marked as NOAUTOINCR by the board driver.
1298 if (!this->dev_ready)
1299 udelay(this->chip_delay);
1301 nand_wait_ready(mtd);
1306 /* For subsequent reads align to page boundary. */
1308 /* Increment page address */
1311 page = realpage & this->pagemask;
1312 /* Check, if we cross a chip boundary */
1315 this->select_chip(mtd, -1);
1316 this->select_chip(mtd, chipnr);
1318 /* Check, if the chip supports auto page increment
1319 * or if we have hit a block boundary.
1321 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1325 /* Deselect and wake up anyone waiting on the device */
1326 if (flags & NAND_GET_DEVICE)
1327 nand_release_device(mtd);
1330 * Return success, if no ECC failures, else -EBADMSG
1331 * fs driver will take care of that, because
1332 * retlen == desired len and result == -EBADMSG
1335 return ecc_failed ? -EBADMSG : 0;
1339 * nand_read_oob - [MTD Interface] NAND read out-of-band
1340 * @mtd: MTD device structure
1341 * @from: offset to read from
1342 * @len: number of bytes to read
1343 * @retlen: pointer to variable to store the number of read bytes
1344 * @buf: the databuffer to put data
1346 * NAND read out-of-band data from the spare area
1348 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1350 int i, col, page, chipnr;
1351 struct nand_chip *this = mtd->priv;
1352 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1354 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1356 /* Shift to get page */
1357 page = (int)(from >> this->page_shift);
1358 chipnr = (int)(from >> this->chip_shift);
1360 /* Mask to get column */
1361 col = from & (mtd->oobsize - 1);
1363 /* Initialize return length value */
1366 /* Do not allow reads past end of device */
1367 if ((from + len) > mtd->size) {
1368 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1373 /* Grab the lock and see if the device is available */
1374 nand_get_device(this, mtd, FL_READING);
1376 /* Select the NAND device */
1377 this->select_chip(mtd, chipnr);
1379 /* Send the read command */
1380 this->cmdfunc(mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1382 * Read the data, if we read more than one page
1383 * oob data, let the device transfer the data !
1387 int thislen = mtd->oobsize - col;
1388 thislen = min_t(int, thislen, len);
1389 this->read_buf(mtd, &buf[i], thislen);
1397 /* Check, if we cross a chip boundary */
1398 if (!(page & this->pagemask)) {
1400 this->select_chip(mtd, -1);
1401 this->select_chip(mtd, chipnr);
1404 /* Apply delay or wait for ready/busy pin
1405 * Do this before the AUTOINCR check, so no problems
1406 * arise if a chip which does auto increment
1407 * is marked as NOAUTOINCR by the board driver.
1409 if (!this->dev_ready)
1410 udelay(this->chip_delay);
1412 nand_wait_ready(mtd);
1414 /* Check, if the chip supports auto page increment
1415 * or if we have hit a block boundary.
1417 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1418 /* For subsequent page reads set offset to 0 */
1419 this->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1424 /* Deselect and wake up anyone waiting on the device */
1425 nand_release_device(mtd);
1433 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1434 * @mtd: MTD device structure
1435 * @buf: temporary buffer
1436 * @from: offset to read from
1437 * @len: number of bytes to read
1438 * @ooblen: number of oob data bytes to read
1440 * Read raw data including oob into buffer
1442 int nand_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1444 struct nand_chip *this = mtd->priv;
1445 int page = (int)(from >> this->page_shift);
1446 int chip = (int)(from >> this->chip_shift);
1449 int pagesize = mtd->writesize + mtd->oobsize;
1450 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1452 /* Do not allow reads past end of device */
1453 if ((from + len) > mtd->size) {
1454 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1458 /* Grab the lock and see if the device is available */
1459 nand_get_device(this, mtd, FL_READING);
1461 this->select_chip(mtd, chip);
1463 /* Add requested oob length */
1468 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1471 this->read_buf(mtd, &buf[cnt], pagesize);
1477 if (!this->dev_ready)
1478 udelay(this->chip_delay);
1480 nand_wait_ready(mtd);
1482 /* Check, if the chip supports auto page increment */
1483 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1487 /* Deselect and wake up anyone waiting on the device */
1488 nand_release_device(mtd);
1493 * nand_write_raw - [GENERIC] Write raw data including oob
1494 * @mtd: MTD device structure
1495 * @buf: source buffer
1496 * @to: offset to write to
1497 * @len: number of bytes to write
1498 * @buf: source buffer
1501 * Write raw data including oob
1503 int nand_write_raw(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1504 uint8_t *buf, uint8_t *oob)
1506 struct nand_chip *this = mtd->priv;
1507 int page = (int)(to >> this->page_shift);
1508 int chip = (int)(to >> this->chip_shift);
1513 /* Do not allow writes past end of device */
1514 if ((to + len) > mtd->size) {
1515 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt write "
1516 "beyond end of device\n");
1520 /* Grab the lock and see if the device is available */
1521 nand_get_device(this, mtd, FL_WRITING);
1523 this->select_chip(mtd, chip);
1524 this->data_poi = buf;
1526 while (len != *retlen) {
1527 ret = nand_write_page(mtd, this, page, oob, &mtd->oobinfo, 0);
1531 *retlen += mtd->writesize;
1532 this->data_poi += mtd->writesize;
1533 oob += mtd->oobsize;
1536 /* Deselect and wake up anyone waiting on the device */
1537 nand_release_device(mtd);
1540 EXPORT_SYMBOL_GPL(nand_write_raw);
1543 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1544 * @mtd: MTD device structure
1545 * @fsbuf: buffer given by fs driver
1546 * @oobsel: out of band selection structre
1547 * @autoplace: 1 = place given buffer into the oob bytes
1548 * @numpages: number of pages to prepare
1551 * 1. Filesystem buffer available and autoplacement is off,
1552 * return filesystem buffer
1553 * 2. No filesystem buffer or autoplace is off, return internal
1555 * 3. Filesystem buffer is given and autoplace selected
1556 * put data from fs buffer into internal buffer and
1557 * retrun internal buffer
1559 * Note: The internal buffer is filled with 0xff. This must
1560 * be done only once, when no autoplacement happens
1561 * Autoplacement sets the buffer dirty flag, which
1562 * forces the 0xff fill before using the buffer again.
1565 static uint8_t *nand_prepare_oobbuf(struct mtd_info *mtd, uint8_t *fsbuf, struct nand_oobinfo *oobsel,
1566 int autoplace, int numpages)
1568 struct nand_chip *this = mtd->priv;
1571 /* Zero copy fs supplied buffer */
1572 if (fsbuf && !autoplace)
1575 /* Check, if the buffer must be filled with ff again */
1576 if (this->oobdirty) {
1577 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1581 /* If we have no autoplacement or no fs buffer use the internal one */
1582 if (!autoplace || !fsbuf)
1583 return this->oob_buf;
1585 /* Walk through the pages and place the data */
1588 while (numpages--) {
1589 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1590 int to = ofs + oobsel->oobfree[i][0];
1591 int num = oobsel->oobfree[i][1];
1592 memcpy(&this->oob_buf[to], fsbuf, num);
1596 ofs += mtd->oobavail;
1598 return this->oob_buf;
1601 #define NOTALIGNED(x) (x & (mtd->writesize-1)) != 0
1604 * nand_write - [MTD Interface] NAND write with ECC
1605 * @mtd: MTD device structure
1606 * @to: offset to write to
1607 * @len: number of bytes to write
1608 * @retlen: pointer to variable to store the number of written bytes
1609 * @buf: the data to write
1611 * NAND write with ECC
1613 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
1614 size_t *retlen, const uint8_t *buf)
1616 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1617 int autoplace = 0, numpages, totalpages;
1618 struct nand_chip *this = mtd->priv;
1619 uint8_t *oobbuf, *bufstart, *eccbuf = NULL;
1620 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1621 struct nand_oobinfo *oobsel = &mtd->oobinfo;
1623 DEBUG(MTD_DEBUG_LEVEL3, "nand_write: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1625 /* Initialize retlen, in case of early exit */
1628 /* Do not allow write past end of device */
1629 if ((to + len) > mtd->size) {
1630 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: Attempt to write past end of page\n");
1634 /* reject writes, which are not page aligned */
1635 if (NOTALIGNED(to) || NOTALIGNED(len)) {
1636 printk(KERN_NOTICE "nand_write: Attempt to write not page aligned data\n");
1640 /* Grab the lock and see if the device is available */
1641 nand_get_device(this, mtd, FL_WRITING);
1643 /* Calculate chipnr */
1644 chipnr = (int)(to >> this->chip_shift);
1645 /* Select the NAND device */
1646 this->select_chip(mtd, chipnr);
1648 /* Check, if it is write protected */
1649 if (nand_check_wp(mtd))
1652 /* Autoplace of oob data ? Use the default placement scheme */
1653 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1654 oobsel = this->autooob;
1657 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1660 /* Setup variables and oob buffer */
1661 totalpages = len >> this->page_shift;
1662 page = (int)(to >> this->page_shift);
1663 /* Invalidate the page cache, if we write to the cached page */
1664 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1667 /* Set it relative to chip */
1668 page &= this->pagemask;
1670 /* Calc number of pages we can write in one go */
1671 numpages = min(ppblock - (startpage & (ppblock - 1)), totalpages);
1672 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1673 bufstart = (uint8_t *) buf;
1675 /* Loop until all data is written */
1676 while (written < len) {
1678 this->data_poi = (uint8_t *) &buf[written];
1679 /* Write one page. If this is the last page to write
1680 * or the last page in this block, then use the
1681 * real pageprogram command, else select cached programming
1682 * if supported by the chip.
1684 ret = nand_write_page(mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1686 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: write_page failed %d\n", ret);
1690 oob += mtd->oobsize;
1691 /* Update written bytes count */
1692 written += mtd->writesize;
1696 /* Increment page address */
1699 /* Have we hit a block boundary ? Then we have to verify and
1700 * if verify is ok, we have to setup the oob buffer for
1703 if (!(page & (ppblock - 1))) {
1705 this->data_poi = bufstart;
1706 ret = nand_verify_pages(mtd, this, startpage, page - startpage,
1707 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1709 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1714 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1716 eccbuf += (page - startpage) * ofs;
1717 totalpages -= page - startpage;
1718 numpages = min(totalpages, ppblock);
1719 page &= this->pagemask;
1721 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1723 /* Check, if we cross a chip boundary */
1726 this->select_chip(mtd, -1);
1727 this->select_chip(mtd, chipnr);
1731 /* Verify the remaining pages */
1733 this->data_poi = bufstart;
1734 ret = nand_verify_pages(mtd, this, startpage, totalpages, oobbuf, oobsel, chipnr, (eccbuf != NULL));
1738 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1741 /* Deselect and wake up anyone waiting on the device */
1742 nand_release_device(mtd);
1748 * nand_write_oob - [MTD Interface] NAND write out-of-band
1749 * @mtd: MTD device structure
1750 * @to: offset to write to
1751 * @len: number of bytes to write
1752 * @retlen: pointer to variable to store the number of written bytes
1753 * @buf: the data to write
1755 * NAND write out-of-band
1757 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const uint8_t *buf)
1759 int column, page, status, ret = -EIO, chipnr;
1760 struct nand_chip *this = mtd->priv;
1762 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1764 /* Shift to get page */
1765 page = (int)(to >> this->page_shift);
1766 chipnr = (int)(to >> this->chip_shift);
1768 /* Mask to get column */
1769 column = to & (mtd->oobsize - 1);
1771 /* Initialize return length value */
1774 /* Do not allow write past end of page */
1775 if ((column + len) > mtd->oobsize) {
1776 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1780 /* Grab the lock and see if the device is available */
1781 nand_get_device(this, mtd, FL_WRITING);
1783 /* Select the NAND device */
1784 this->select_chip(mtd, chipnr);
1786 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1787 in one of my DiskOnChip 2000 test units) will clear the whole
1788 data page too if we don't do this. I have no clue why, but
1789 I seem to have 'fixed' it in the doc2000 driver in
1790 August 1999. dwmw2. */
1791 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1793 /* Check, if it is write protected */
1794 if (nand_check_wp(mtd))
1797 /* Invalidate the page cache, if we write to the cached page */
1798 if (page == this->pagebuf)
1801 if (NAND_MUST_PAD(this)) {
1802 /* Write out desired data */
1803 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page & this->pagemask);
1804 /* prepad 0xff for partial programming */
1805 this->write_buf(mtd, ffchars, column);
1807 this->write_buf(mtd, buf, len);
1808 /* postpad 0xff for partial programming */
1809 this->write_buf(mtd, ffchars, mtd->oobsize - (len + column));
1811 /* Write out desired data */
1812 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize + column, page & this->pagemask);
1814 this->write_buf(mtd, buf, len);
1816 /* Send command to program the OOB data */
1817 this->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1819 status = this->waitfunc(mtd, this, FL_WRITING);
1821 /* See if device thinks it succeeded */
1822 if (status & NAND_STATUS_FAIL) {
1823 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1830 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1831 /* Send command to read back the data */
1832 this->cmdfunc(mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1834 if (this->verify_buf(mtd, buf, len)) {
1835 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1842 /* Deselect and wake up anyone waiting on the device */
1843 nand_release_device(mtd);
1849 * single_erease_cmd - [GENERIC] NAND standard block erase command function
1850 * @mtd: MTD device structure
1851 * @page: the page address of the block which will be erased
1853 * Standard erase command for NAND chips
1855 static void single_erase_cmd(struct mtd_info *mtd, int page)
1857 struct nand_chip *this = mtd->priv;
1858 /* Send commands to erase a block */
1859 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1860 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1864 * multi_erease_cmd - [GENERIC] AND specific block erase command function
1865 * @mtd: MTD device structure
1866 * @page: the page address of the block which will be erased
1868 * AND multi block erase command function
1869 * Erase 4 consecutive blocks
1871 static void multi_erase_cmd(struct mtd_info *mtd, int page)
1873 struct nand_chip *this = mtd->priv;
1874 /* Send commands to erase a block */
1875 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1876 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1877 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1878 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1879 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1883 * nand_erase - [MTD Interface] erase block(s)
1884 * @mtd: MTD device structure
1885 * @instr: erase instruction
1887 * Erase one ore more blocks
1889 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
1891 return nand_erase_nand(mtd, instr, 0);
1894 #define BBT_PAGE_MASK 0xffffff3f
1896 * nand_erase_intern - [NAND Interface] erase block(s)
1897 * @mtd: MTD device structure
1898 * @instr: erase instruction
1899 * @allowbbt: allow erasing the bbt area
1901 * Erase one ore more blocks
1903 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
1905 int page, len, status, pages_per_block, ret, chipnr;
1906 struct nand_chip *this = mtd->priv;
1907 int rewrite_bbt[NAND_MAX_CHIPS]={0}; /* flags to indicate the page, if bbt needs to be rewritten. */
1908 unsigned int bbt_masked_page; /* bbt mask to compare to page being erased. */
1909 /* It is used to see if the current page is in the same */
1910 /* 256 block group and the same bank as the bbt. */
1912 DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n", (unsigned int)instr->addr, (unsigned int)instr->len);
1914 /* Start address must align on block boundary */
1915 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
1916 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
1920 /* Length must align on block boundary */
1921 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
1922 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
1926 /* Do not allow erase past end of device */
1927 if ((instr->len + instr->addr) > mtd->size) {
1928 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
1932 instr->fail_addr = 0xffffffff;
1934 /* Grab the lock and see if the device is available */
1935 nand_get_device(this, mtd, FL_ERASING);
1937 /* Shift to get first page */
1938 page = (int)(instr->addr >> this->page_shift);
1939 chipnr = (int)(instr->addr >> this->chip_shift);
1941 /* Calculate pages in each block */
1942 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
1944 /* Select the NAND device */
1945 this->select_chip(mtd, chipnr);
1947 /* Check the WP bit */
1948 /* Check, if it is write protected */
1949 if (nand_check_wp(mtd)) {
1950 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
1951 instr->state = MTD_ERASE_FAILED;
1955 /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
1956 if (this->options & BBT_AUTO_REFRESH) {
1957 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
1959 bbt_masked_page = 0xffffffff; /* should not match anything */
1962 /* Loop through the pages */
1965 instr->state = MTD_ERASING;
1968 /* Check if we have a bad block, we do not erase bad blocks ! */
1969 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
1970 printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
1971 instr->state = MTD_ERASE_FAILED;
1975 /* Invalidate the page cache, if we erase the block which contains
1976 the current cached page */
1977 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
1980 this->erase_cmd(mtd, page & this->pagemask);
1982 status = this->waitfunc(mtd, this, FL_ERASING);
1984 /* See if operation failed and additional status checks are available */
1985 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
1986 status = this->errstat(mtd, this, FL_ERASING, status, page);
1989 /* See if block erase succeeded */
1990 if (status & NAND_STATUS_FAIL) {
1991 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
1992 instr->state = MTD_ERASE_FAILED;
1993 instr->fail_addr = (page << this->page_shift);
1997 /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
1998 if (this->options & BBT_AUTO_REFRESH) {
1999 if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
2000 (page != this->bbt_td->pages[chipnr])) {
2001 rewrite_bbt[chipnr] = (page << this->page_shift);
2005 /* Increment page address and decrement length */
2006 len -= (1 << this->phys_erase_shift);
2007 page += pages_per_block;
2009 /* Check, if we cross a chip boundary */
2010 if (len && !(page & this->pagemask)) {
2012 this->select_chip(mtd, -1);
2013 this->select_chip(mtd, chipnr);
2015 /* if BBT requires refresh and BBT-PERCHIP,
2016 * set the BBT page mask to see if this BBT should be rewritten */
2017 if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
2018 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2023 instr->state = MTD_ERASE_DONE;
2027 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2028 /* Do call back function */
2030 mtd_erase_callback(instr);
2032 /* Deselect and wake up anyone waiting on the device */
2033 nand_release_device(mtd);
2035 /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
2036 if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
2037 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
2038 if (rewrite_bbt[chipnr]) {
2039 /* update the BBT for chip */
2040 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2041 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2042 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2047 /* Return more or less happy */
2052 * nand_sync - [MTD Interface] sync
2053 * @mtd: MTD device structure
2055 * Sync is actually a wait for chip ready function
2057 static void nand_sync(struct mtd_info *mtd)
2059 struct nand_chip *this = mtd->priv;
2061 DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2063 /* Grab the lock and see if the device is available */
2064 nand_get_device(this, mtd, FL_SYNCING);
2065 /* Release it and go back */
2066 nand_release_device(mtd);
2070 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2071 * @mtd: MTD device structure
2072 * @ofs: offset relative to mtd start
2074 static int nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2076 /* Check for invalid offset */
2077 if (ofs > mtd->size)
2080 return nand_block_checkbad(mtd, ofs, 1, 0);
2084 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2085 * @mtd: MTD device structure
2086 * @ofs: offset relative to mtd start
2088 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2090 struct nand_chip *this = mtd->priv;
2093 if ((ret = nand_block_isbad(mtd, ofs))) {
2094 /* If it was bad already, return success and do nothing. */
2100 return this->block_markbad(mtd, ofs);
2104 * nand_suspend - [MTD Interface] Suspend the NAND flash
2105 * @mtd: MTD device structure
2107 static int nand_suspend(struct mtd_info *mtd)
2109 struct nand_chip *this = mtd->priv;
2111 return nand_get_device(this, mtd, FL_PM_SUSPENDED);
2115 * nand_resume - [MTD Interface] Resume the NAND flash
2116 * @mtd: MTD device structure
2118 static void nand_resume(struct mtd_info *mtd)
2120 struct nand_chip *this = mtd->priv;
2122 if (this->state == FL_PM_SUSPENDED)
2123 nand_release_device(mtd);
2125 printk(KERN_ERR "nand_resume() called for a chip which is not "
2126 "in suspended state\n");
2130 * Free allocated data structures
2132 static void nand_free_kmem(struct nand_chip *this)
2134 /* Buffer allocated by nand_scan ? */
2135 if (this->options & NAND_OOBBUF_ALLOC)
2136 kfree(this->oob_buf);
2137 /* Buffer allocated by nand_scan ? */
2138 if (this->options & NAND_DATABUF_ALLOC)
2139 kfree(this->data_buf);
2140 /* Controller allocated by nand_scan ? */
2141 if (this->options & NAND_CONTROLLER_ALLOC)
2142 kfree(this->controller);
2146 * Allocate buffers and data structures
2148 static int nand_allocate_kmem(struct mtd_info *mtd, struct nand_chip *this)
2152 if (!this->oob_buf) {
2153 len = mtd->oobsize <<
2154 (this->phys_erase_shift - this->page_shift);
2155 this->oob_buf = kmalloc(len, GFP_KERNEL);
2158 this->options |= NAND_OOBBUF_ALLOC;
2161 if (!this->data_buf) {
2162 len = mtd->writesize + mtd->oobsize;
2163 this->data_buf = kmalloc(len, GFP_KERNEL);
2164 if (!this->data_buf)
2166 this->options |= NAND_DATABUF_ALLOC;
2169 if (!this->controller) {
2170 this->controller = kzalloc(sizeof(struct nand_hw_control),
2172 if (!this->controller)
2174 this->options |= NAND_CONTROLLER_ALLOC;
2179 printk(KERN_ERR "nand_scan(): Cannot allocate buffers\n");
2180 nand_free_kmem(this);
2185 * Set default functions
2187 static void nand_set_defaults(struct nand_chip *this, int busw)
2189 /* check for proper chip_delay setup, set 20us if not */
2190 if (!this->chip_delay)
2191 this->chip_delay = 20;
2193 /* check, if a user supplied command function given */
2194 if (this->cmdfunc == NULL)
2195 this->cmdfunc = nand_command;
2197 /* check, if a user supplied wait function given */
2198 if (this->waitfunc == NULL)
2199 this->waitfunc = nand_wait;
2201 if (!this->select_chip)
2202 this->select_chip = nand_select_chip;
2203 if (!this->write_byte)
2204 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2205 if (!this->read_byte)
2206 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2207 if (!this->write_word)
2208 this->write_word = nand_write_word;
2209 if (!this->read_word)
2210 this->read_word = nand_read_word;
2211 if (!this->block_bad)
2212 this->block_bad = nand_block_bad;
2213 if (!this->block_markbad)
2214 this->block_markbad = nand_default_block_markbad;
2215 if (!this->write_buf)
2216 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2217 if (!this->read_buf)
2218 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2219 if (!this->verify_buf)
2220 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2221 if (!this->scan_bbt)
2222 this->scan_bbt = nand_default_bbt;
2226 * Get the flash and manufacturer id and lookup if the typ is supported
2228 static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
2229 struct nand_chip *this,
2230 int busw, int *maf_id)
2232 struct nand_flash_dev *type = NULL;
2233 int i, dev_id, maf_idx;
2235 /* Select the device */
2236 this->select_chip(mtd, 0);
2238 /* Send the command for reading device ID */
2239 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2241 /* Read manufacturer and device IDs */
2242 *maf_id = this->read_byte(mtd);
2243 dev_id = this->read_byte(mtd);
2245 /* Lookup the flash id */
2246 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2247 if (dev_id == nand_flash_ids[i].id) {
2248 type = &nand_flash_ids[i];
2254 return ERR_PTR(-ENODEV);
2256 this->chipsize = nand_flash_ids[i].chipsize << 20;
2258 /* Newer devices have all the information in additional id bytes */
2259 if (!nand_flash_ids[i].pagesize) {
2261 /* The 3rd id byte contains non relevant data ATM */
2262 extid = this->read_byte(mtd);
2263 /* The 4th id byte is the important one */
2264 extid = this->read_byte(mtd);
2266 mtd->writesize = 1024 << (extid & 0x3);
2269 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->writesize >> 9);
2271 /* Calc blocksize. Blocksize is multiples of 64KiB */
2272 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2274 /* Get buswidth information */
2275 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2279 * Old devices have this data hardcoded in the device id table
2281 mtd->erasesize = nand_flash_ids[i].erasesize;
2282 mtd->writesize = nand_flash_ids[i].pagesize;
2283 mtd->oobsize = mtd->writesize / 32;
2284 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2287 /* Try to identify manufacturer */
2288 for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_id++) {
2289 if (nand_manuf_ids[maf_idx].id == *maf_id)
2294 * Check, if buswidth is correct. Hardware drivers should set
2297 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2298 printk(KERN_INFO "NAND device: Manufacturer ID:"
2299 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
2300 dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
2301 printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
2302 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2304 return ERR_PTR(-EINVAL);
2307 /* Calculate the address shift from the page size */
2308 this->page_shift = ffs(mtd->writesize) - 1;
2309 /* Convert chipsize to number of pages per chip -1. */
2310 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2312 this->bbt_erase_shift = this->phys_erase_shift =
2313 ffs(mtd->erasesize) - 1;
2314 this->chip_shift = ffs(this->chipsize) - 1;
2316 /* Set the bad block position */
2317 this->badblockpos = mtd->writesize > 512 ?
2318 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2320 /* Get chip options, preserve non chip based options */
2321 this->options &= ~NAND_CHIPOPTIONS_MSK;
2322 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2325 * Set this as a default. Board drivers can override it, if necessary
2327 this->options |= NAND_NO_AUTOINCR;
2329 /* Check if this is a not a samsung device. Do not clear the
2330 * options for chips which are not having an extended id.
2332 if (*maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2333 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2335 /* Check for AND chips with 4 page planes */
2336 if (this->options & NAND_4PAGE_ARRAY)
2337 this->erase_cmd = multi_erase_cmd;
2339 this->erase_cmd = single_erase_cmd;
2341 /* Do not replace user supplied command function ! */
2342 if (mtd->writesize > 512 && this->cmdfunc == nand_command)
2343 this->cmdfunc = nand_command_lp;
2345 printk(KERN_INFO "NAND device: Manufacturer ID:"
2346 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, dev_id,
2347 nand_manuf_ids[maf_idx].name, type->name);
2352 /* module_text_address() isn't exported, and it's mostly a pointless
2353 test if this is a module _anyway_ -- they'd have to try _really_ hard
2354 to call us from in-kernel code if the core NAND support is modular. */
2356 #define caller_is_module() (1)
2358 #define caller_is_module() \
2359 module_text_address((unsigned long)__builtin_return_address(0))
2363 * nand_scan - [NAND Interface] Scan for the NAND device
2364 * @mtd: MTD device structure
2365 * @maxchips: Number of chips to scan for
2367 * This fills out all the uninitialized function pointers
2368 * with the defaults.
2369 * The flash ID is read and the mtd/chip structures are
2370 * filled with the appropriate values. Buffers are allocated if
2371 * they are not provided by the board driver
2372 * The mtd->owner field must be set to the module of the caller
2375 int nand_scan(struct mtd_info *mtd, int maxchips)
2377 int i, busw, nand_maf_id;
2378 struct nand_chip *this = mtd->priv;
2379 struct nand_flash_dev *type;
2381 /* Many callers got this wrong, so check for it for a while... */
2382 if (!mtd->owner && caller_is_module()) {
2383 printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
2387 /* Get buswidth to select the correct functions */
2388 busw = this->options & NAND_BUSWIDTH_16;
2389 /* Set the default functions */
2390 nand_set_defaults(this, busw);
2392 /* Read the flash type */
2393 type = nand_get_flash_type(mtd, this, busw, &nand_maf_id);
2396 printk(KERN_WARNING "No NAND device found!!!\n");
2397 this->select_chip(mtd, -1);
2398 return PTR_ERR(type);
2401 /* Check for a chip array */
2402 for (i = 1; i < maxchips; i++) {
2403 this->select_chip(mtd, i);
2404 /* Send the command for reading device ID */
2405 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2406 /* Read manufacturer and device IDs */
2407 if (nand_maf_id != this->read_byte(mtd) ||
2408 type->id != this->read_byte(mtd))
2412 printk(KERN_INFO "%d NAND chips detected\n", i);
2414 /* Store the number of chips and calc total size for mtd */
2416 mtd->size = i * this->chipsize;
2418 /* Allocate buffers and data structures */
2419 if (nand_allocate_kmem(mtd, this))
2422 /* Preset the internal oob buffer */
2423 memset(this->oob_buf, 0xff,
2424 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2427 * If no default placement scheme is given, select an appropriate one
2429 if (!this->autooob) {
2430 switch (mtd->oobsize) {
2432 this->autooob = &nand_oob_8;
2435 this->autooob = &nand_oob_16;
2438 this->autooob = &nand_oob_64;
2441 printk(KERN_WARNING "No oob scheme defined for "
2442 "oobsize %d\n", mtd->oobsize);
2448 * The number of bytes available for the filesystem to place fs
2449 * dependend oob data
2452 for (i = 0; this->autooob->oobfree[i][1]; i++)
2453 mtd->oobavail += this->autooob->oobfree[i][1];
2456 * check ECC mode, default to software if 3byte/512byte hardware ECC is
2457 * selected and we have 256 byte pagesize fallback to software ECC
2459 switch (this->ecc.mode) {
2461 case NAND_ECC_HW_SYNDROME:
2462 if (!this->ecc.calculate || !this->ecc.correct ||
2464 printk(KERN_WARNING "No ECC functions supplied, "
2465 "Hardware ECC not possible\n");
2468 if (mtd->writesize >= this->ecc.size)
2470 printk(KERN_WARNING "%d byte HW ECC not possible on "
2471 "%d byte page size, fallback to SW ECC\n",
2472 this->ecc.size, mtd->writesize);
2473 this->ecc.mode = NAND_ECC_SOFT;
2476 this->ecc.calculate = nand_calculate_ecc;
2477 this->ecc.correct = nand_correct_data;
2478 this->ecc.size = 256;
2479 this->ecc.bytes = 3;
2483 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
2484 "This is not recommended !!\n");
2485 this->ecc.size = mtd->writesize;
2486 this->ecc.bytes = 0;
2489 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
2495 * Set the number of read / write steps for one page depending on ECC
2498 this->ecc.steps = mtd->writesize / this->ecc.size;
2499 if(this->ecc.steps * this->ecc.size != mtd->writesize) {
2500 printk(KERN_WARNING "Invalid ecc parameters\n");
2504 /* Initialize state, waitqueue and spinlock */
2505 this->state = FL_READY;
2506 init_waitqueue_head(&this->controller->wq);
2507 spin_lock_init(&this->controller->lock);
2509 /* De-select the device */
2510 this->select_chip(mtd, -1);
2512 /* Invalidate the pagebuffer reference */
2515 /* Fill in remaining MTD driver data */
2516 mtd->type = MTD_NANDFLASH;
2517 mtd->flags = MTD_CAP_NANDFLASH;
2518 mtd->ecctype = MTD_ECC_SW;
2519 mtd->erase = nand_erase;
2521 mtd->unpoint = NULL;
2522 mtd->read = nand_read;
2523 mtd->write = nand_write;
2524 mtd->read_oob = nand_read_oob;
2525 mtd->write_oob = nand_write_oob;
2526 mtd->sync = nand_sync;
2529 mtd->suspend = nand_suspend;
2530 mtd->resume = nand_resume;
2531 mtd->block_isbad = nand_block_isbad;
2532 mtd->block_markbad = nand_block_markbad;
2534 /* and make the autooob the default one */
2535 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2537 /* Check, if we should skip the bad block table scan */
2538 if (this->options & NAND_SKIP_BBTSCAN)
2541 /* Build bad block table */
2542 return this->scan_bbt(mtd);
2546 * nand_release - [NAND Interface] Free resources held by the NAND device
2547 * @mtd: MTD device structure
2549 void nand_release(struct mtd_info *mtd)
2551 struct nand_chip *this = mtd->priv;
2553 #ifdef CONFIG_MTD_PARTITIONS
2554 /* Deregister partitions */
2555 del_mtd_partitions(mtd);
2557 /* Deregister the device */
2558 del_mtd_device(mtd);
2560 /* Free bad block table memory */
2563 nand_free_kmem(this);
2566 EXPORT_SYMBOL_GPL(nand_scan);
2567 EXPORT_SYMBOL_GPL(nand_release);
2569 static int __init nand_base_init(void)
2571 led_trigger_register_simple("nand-disk", &nand_led_trigger);
2575 static void __exit nand_base_exit(void)
2577 led_trigger_unregister_simple(nand_led_trigger);
2580 module_init(nand_base_init);
2581 module_exit(nand_base_exit);
2583 MODULE_LICENSE("GPL");
2584 MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2585 MODULE_DESCRIPTION("Generic NAND flash driver code");