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 * For devices which display every fart in the system on a seperate LED. Is
169 * compiled away when LED support is disabled.
171 DEFINE_LED_TRIGGER(nand_led_trigger);
174 * nand_release_device - [GENERIC] release chip
175 * @mtd: MTD device structure
177 * Deselect, release chip lock and wake up anyone waiting on the device
179 static void nand_release_device(struct mtd_info *mtd)
181 struct nand_chip *this = mtd->priv;
183 /* De-select the NAND device */
184 this->select_chip(mtd, -1);
186 /* Release the controller and the chip */
187 spin_lock(&this->controller->lock);
188 this->controller->active = NULL;
189 this->state = FL_READY;
190 wake_up(&this->controller->wq);
191 spin_unlock(&this->controller->lock);
195 * nand_read_byte - [DEFAULT] read one byte from the chip
196 * @mtd: MTD device structure
198 * Default read function for 8bit buswith
200 static uint8_t nand_read_byte(struct mtd_info *mtd)
202 struct nand_chip *this = mtd->priv;
203 return readb(this->IO_ADDR_R);
207 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
208 * @mtd: MTD device structure
210 * Default read function for 16bit buswith with
211 * endianess conversion
213 static uint8_t nand_read_byte16(struct mtd_info *mtd)
215 struct nand_chip *this = mtd->priv;
216 return (uint8_t) cpu_to_le16(readw(this->IO_ADDR_R));
220 * nand_read_word - [DEFAULT] read one word from the chip
221 * @mtd: MTD device structure
223 * Default read function for 16bit buswith without
224 * endianess conversion
226 static u16 nand_read_word(struct mtd_info *mtd)
228 struct nand_chip *this = mtd->priv;
229 return readw(this->IO_ADDR_R);
233 * nand_select_chip - [DEFAULT] control CE line
234 * @mtd: MTD device structure
235 * @chip: chipnumber to select, -1 for deselect
237 * Default select function for 1 chip devices.
239 static void nand_select_chip(struct mtd_info *mtd, int chip)
241 struct nand_chip *this = mtd->priv;
244 this->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
247 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
256 * nand_write_buf - [DEFAULT] write buffer to chip
257 * @mtd: MTD device structure
259 * @len: number of bytes to write
261 * Default write function for 8bit buswith
263 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
266 struct nand_chip *this = mtd->priv;
268 for (i = 0; i < len; i++)
269 writeb(buf[i], this->IO_ADDR_W);
273 * nand_read_buf - [DEFAULT] read chip data into buffer
274 * @mtd: MTD device structure
275 * @buf: buffer to store date
276 * @len: number of bytes to read
278 * Default read function for 8bit buswith
280 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
283 struct nand_chip *this = mtd->priv;
285 for (i = 0; i < len; i++)
286 buf[i] = readb(this->IO_ADDR_R);
290 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
291 * @mtd: MTD device structure
292 * @buf: buffer containing the data to compare
293 * @len: number of bytes to compare
295 * Default verify function for 8bit buswith
297 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
300 struct nand_chip *this = mtd->priv;
302 for (i = 0; i < len; i++)
303 if (buf[i] != readb(this->IO_ADDR_R))
310 * nand_write_buf16 - [DEFAULT] write buffer to chip
311 * @mtd: MTD device structure
313 * @len: number of bytes to write
315 * Default write function for 16bit buswith
317 static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
320 struct nand_chip *this = mtd->priv;
321 u16 *p = (u16 *) buf;
324 for (i = 0; i < len; i++)
325 writew(p[i], this->IO_ADDR_W);
330 * nand_read_buf16 - [DEFAULT] read chip data into buffer
331 * @mtd: MTD device structure
332 * @buf: buffer to store date
333 * @len: number of bytes to read
335 * Default read function for 16bit buswith
337 static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
340 struct nand_chip *this = mtd->priv;
341 u16 *p = (u16 *) buf;
344 for (i = 0; i < len; i++)
345 p[i] = readw(this->IO_ADDR_R);
349 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
350 * @mtd: MTD device structure
351 * @buf: buffer containing the data to compare
352 * @len: number of bytes to compare
354 * Default verify function for 16bit buswith
356 static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
359 struct nand_chip *this = mtd->priv;
360 u16 *p = (u16 *) buf;
363 for (i = 0; i < len; i++)
364 if (p[i] != readw(this->IO_ADDR_R))
371 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
372 * @mtd: MTD device structure
373 * @ofs: offset from device start
374 * @getchip: 0, if the chip is already selected
376 * Check, if the block is bad.
378 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
380 int page, chipnr, res = 0;
381 struct nand_chip *this = mtd->priv;
385 page = (int)(ofs >> this->page_shift);
386 chipnr = (int)(ofs >> this->chip_shift);
388 /* Grab the lock and see if the device is available */
389 nand_get_device(this, mtd, FL_READING);
391 /* Select the NAND device */
392 this->select_chip(mtd, chipnr);
396 if (this->options & NAND_BUSWIDTH_16) {
397 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE,
398 page & this->pagemask);
399 bad = cpu_to_le16(this->read_word(mtd));
400 if (this->badblockpos & 0x1)
402 if ((bad & 0xFF) != 0xff)
405 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos,
406 page & this->pagemask);
407 if (this->read_byte(mtd) != 0xff)
412 /* Deselect and wake up anyone waiting on the device */
413 nand_release_device(mtd);
420 * nand_default_block_markbad - [DEFAULT] mark a block bad
421 * @mtd: MTD device structure
422 * @ofs: offset from device start
424 * This is the default implementation, which can be overridden by
425 * a hardware specific driver.
427 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
429 struct nand_chip *this = mtd->priv;
430 uint8_t buf[2] = { 0, 0 };
434 /* Get block number */
435 block = ((int)ofs) >> this->bbt_erase_shift;
437 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
439 /* Do we have a flash based bad block table ? */
440 if (this->options & NAND_USE_FLASH_BBT)
441 return nand_update_bbt(mtd, ofs);
443 /* We write two bytes, so we dont have to mess with 16 bit access */
444 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
445 return nand_write_oob(mtd, ofs, 2, &retlen, buf);
449 * nand_check_wp - [GENERIC] check if the chip is write protected
450 * @mtd: MTD device structure
451 * Check, if the device is write protected
453 * The function expects, that the device is already selected
455 static int nand_check_wp(struct mtd_info *mtd)
457 struct nand_chip *this = mtd->priv;
458 /* Check the WP bit */
459 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
460 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
464 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
465 * @mtd: MTD device structure
466 * @ofs: offset from device start
467 * @getchip: 0, if the chip is already selected
468 * @allowbbt: 1, if its allowed to access the bbt area
470 * Check, if the block is bad. Either by reading the bad block table or
471 * calling of the scan function.
473 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
476 struct nand_chip *this = mtd->priv;
479 return this->block_bad(mtd, ofs, getchip);
481 /* Return info from the table */
482 return nand_isbad_bbt(mtd, ofs, allowbbt);
486 * Wait for the ready pin, after a command
487 * The timeout is catched later.
489 static void nand_wait_ready(struct mtd_info *mtd)
491 struct nand_chip *this = mtd->priv;
492 unsigned long timeo = jiffies + 2;
494 led_trigger_event(nand_led_trigger, LED_FULL);
495 /* wait until command is processed or timeout occures */
497 if (this->dev_ready(mtd))
499 touch_softlockup_watchdog();
500 } while (time_before(jiffies, timeo));
501 led_trigger_event(nand_led_trigger, LED_OFF);
505 * nand_command - [DEFAULT] Send command to NAND device
506 * @mtd: MTD device structure
507 * @command: the command to be sent
508 * @column: the column address for this command, -1 if none
509 * @page_addr: the page address for this command, -1 if none
511 * Send command to NAND device. This function is used for small page
512 * devices (256/512 Bytes per page)
514 static void nand_command(struct mtd_info *mtd, unsigned int command,
515 int column, int page_addr)
517 register struct nand_chip *this = mtd->priv;
518 int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
521 * Write out the command to the device.
523 if (command == NAND_CMD_SEQIN) {
526 if (column >= mtd->writesize) {
528 column -= mtd->writesize;
529 readcmd = NAND_CMD_READOOB;
530 } else if (column < 256) {
531 /* First 256 bytes --> READ0 */
532 readcmd = NAND_CMD_READ0;
535 readcmd = NAND_CMD_READ1;
537 this->cmd_ctrl(mtd, readcmd, ctrl);
538 ctrl &= ~NAND_CTRL_CHANGE;
540 this->cmd_ctrl(mtd, command, ctrl);
543 * Address cycle, when necessary
545 ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
546 /* Serially input address */
548 /* Adjust columns for 16 bit buswidth */
549 if (this->options & NAND_BUSWIDTH_16)
551 this->cmd_ctrl(mtd, column, ctrl);
552 ctrl &= ~NAND_CTRL_CHANGE;
554 if (page_addr != -1) {
555 this->cmd_ctrl(mtd, page_addr, ctrl);
556 ctrl &= ~NAND_CTRL_CHANGE;
557 this->cmd_ctrl(mtd, page_addr >> 8, ctrl);
558 /* One more address cycle for devices > 32MiB */
559 if (this->chipsize > (32 << 20))
560 this->cmd_ctrl(mtd, page_addr >> 16, ctrl);
562 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
565 * program and erase have their own busy handlers
566 * status and sequential in needs no delay
570 case NAND_CMD_PAGEPROG:
571 case NAND_CMD_ERASE1:
572 case NAND_CMD_ERASE2:
574 case NAND_CMD_STATUS:
575 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
581 udelay(this->chip_delay);
582 this->cmd_ctrl(mtd, NAND_CMD_STATUS,
583 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
584 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
585 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
588 /* This applies to read commands */
591 * If we don't have access to the busy pin, we apply the given
594 if (!this->dev_ready) {
595 udelay(this->chip_delay);
599 /* Apply this short delay always to ensure that we do wait tWB in
600 * any case on any machine. */
603 nand_wait_ready(mtd);
607 * nand_command_lp - [DEFAULT] Send command to NAND large page device
608 * @mtd: MTD device structure
609 * @command: the command to be sent
610 * @column: the column address for this command, -1 if none
611 * @page_addr: the page address for this command, -1 if none
613 * Send command to NAND device. This is the version for the new large page
614 * devices We dont have the separate regions as we have in the small page
615 * devices. We must emulate NAND_CMD_READOOB to keep the code compatible.
618 static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
619 int column, int page_addr)
621 register struct nand_chip *this = mtd->priv;
623 /* Emulate NAND_CMD_READOOB */
624 if (command == NAND_CMD_READOOB) {
625 column += mtd->writesize;
626 command = NAND_CMD_READ0;
629 /* Command latch cycle */
630 this->cmd_ctrl(mtd, command & 0xff,
631 NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
633 if (column != -1 || page_addr != -1) {
634 int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
636 /* Serially input address */
638 /* Adjust columns for 16 bit buswidth */
639 if (this->options & NAND_BUSWIDTH_16)
641 this->cmd_ctrl(mtd, column, ctrl);
642 ctrl &= ~NAND_CTRL_CHANGE;
643 this->cmd_ctrl(mtd, column >> 8, ctrl);
645 if (page_addr != -1) {
646 this->cmd_ctrl(mtd, page_addr, ctrl);
647 this->cmd_ctrl(mtd, page_addr >> 8,
648 NAND_NCE | NAND_ALE);
649 /* One more address cycle for devices > 128MiB */
650 if (this->chipsize > (128 << 20))
651 this->cmd_ctrl(mtd, page_addr >> 16,
652 NAND_NCE | NAND_ALE);
655 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
658 * program and erase have their own busy handlers
659 * status, sequential in, and deplete1 need no delay
663 case NAND_CMD_CACHEDPROG:
664 case NAND_CMD_PAGEPROG:
665 case NAND_CMD_ERASE1:
666 case NAND_CMD_ERASE2:
668 case NAND_CMD_STATUS:
669 case NAND_CMD_DEPLETE1:
673 * read error status commands require only a short delay
675 case NAND_CMD_STATUS_ERROR:
676 case NAND_CMD_STATUS_ERROR0:
677 case NAND_CMD_STATUS_ERROR1:
678 case NAND_CMD_STATUS_ERROR2:
679 case NAND_CMD_STATUS_ERROR3:
680 udelay(this->chip_delay);
686 udelay(this->chip_delay);
687 this->cmd_ctrl(mtd, NAND_CMD_STATUS, NAND_NCE | NAND_CLE);
688 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
689 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
693 this->cmd_ctrl(mtd, NAND_CMD_READSTART, NAND_NCE | NAND_CLE);
694 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
696 /* This applies to read commands */
699 * If we don't have access to the busy pin, we apply the given
702 if (!this->dev_ready) {
703 udelay(this->chip_delay);
708 /* Apply this short delay always to ensure that we do wait tWB in
709 * any case on any machine. */
712 nand_wait_ready(mtd);
716 * nand_get_device - [GENERIC] Get chip for selected access
717 * @this: the nand chip descriptor
718 * @mtd: MTD device structure
719 * @new_state: the state which is requested
721 * Get the device and lock it for exclusive access
724 nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state)
726 spinlock_t *lock = &this->controller->lock;
727 wait_queue_head_t *wq = &this->controller->wq;
728 DECLARE_WAITQUEUE(wait, current);
732 /* Hardware controller shared among independend devices */
733 /* Hardware controller shared among independend devices */
734 if (!this->controller->active)
735 this->controller->active = this;
737 if (this->controller->active == this && this->state == FL_READY) {
738 this->state = new_state;
742 if (new_state == FL_PM_SUSPENDED) {
744 return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
746 set_current_state(TASK_UNINTERRUPTIBLE);
747 add_wait_queue(wq, &wait);
750 remove_wait_queue(wq, &wait);
755 * nand_wait - [DEFAULT] wait until the command is done
756 * @mtd: MTD device structure
757 * @this: NAND chip structure
758 * @state: state to select the max. timeout value
760 * Wait for command done. This applies to erase and program only
761 * Erase can take up to 400ms and program up to 20ms according to
762 * general NAND and SmartMedia specs
765 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
768 unsigned long timeo = jiffies;
771 if (state == FL_ERASING)
772 timeo += (HZ * 400) / 1000;
774 timeo += (HZ * 20) / 1000;
776 led_trigger_event(nand_led_trigger, LED_FULL);
778 /* Apply this short delay always to ensure that we do wait tWB in
779 * any case on any machine. */
782 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
783 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
785 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
787 while (time_before(jiffies, timeo)) {
788 /* Check, if we were interrupted */
789 if (this->state != state)
792 if (this->dev_ready) {
793 if (this->dev_ready(mtd))
796 if (this->read_byte(mtd) & NAND_STATUS_READY)
801 led_trigger_event(nand_led_trigger, LED_OFF);
803 status = (int)this->read_byte(mtd);
808 * nand_write_page - [GENERIC] write one page
809 * @mtd: MTD device structure
810 * @this: NAND chip structure
811 * @page: startpage inside the chip, must be called with (page & this->pagemask)
812 * @oob_buf: out of band data buffer
813 * @oobsel: out of band selecttion structre
814 * @cached: 1 = enable cached programming if supported by chip
816 * Nand_page_program function is used for write and writev !
817 * This function will always program a full page of data
818 * If you call it with a non page aligned buffer, you're lost :)
820 * Cached programming is not supported yet.
822 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page,
823 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int cached)
826 uint8_t ecc_code[32];
827 int eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
828 int *oob_config = oobsel->eccpos;
829 int datidx = 0, eccidx = 0, eccsteps = this->ecc.steps;
832 /* FIXME: Enable cached programming */
835 /* Send command to begin auto page programming */
836 this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
838 /* Write out complete page of data, take care of eccmode */
840 /* No ecc, write all */
842 printk(KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
843 this->write_buf(mtd, this->data_poi, mtd->writesize);
846 /* Software ecc 3/256, write all */
848 for (; eccsteps; eccsteps--) {
849 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
850 for (i = 0; i < 3; i++, eccidx++)
851 oob_buf[oob_config[eccidx]] = ecc_code[i];
852 datidx += this->ecc.size;
854 this->write_buf(mtd, this->data_poi, mtd->writesize);
857 eccbytes = this->ecc.bytes;
858 for (; eccsteps; eccsteps--) {
859 /* enable hardware ecc logic for write */
860 this->ecc.hwctl(mtd, NAND_ECC_WRITE);
861 this->write_buf(mtd, &this->data_poi[datidx], this->ecc.size);
862 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
863 for (i = 0; i < eccbytes; i++, eccidx++)
864 oob_buf[oob_config[eccidx]] = ecc_code[i];
865 /* If the hardware ecc provides syndromes then
866 * the ecc code must be written immidiately after
867 * the data bytes (words) */
868 if (this->options & NAND_HWECC_SYNDROME)
869 this->write_buf(mtd, ecc_code, eccbytes);
870 datidx += this->ecc.size;
875 /* Write out OOB data */
876 if (this->options & NAND_HWECC_SYNDROME)
877 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
879 this->write_buf(mtd, oob_buf, mtd->oobsize);
881 /* Send command to actually program the data */
882 this->cmdfunc(mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
885 /* call wait ready function */
886 status = this->waitfunc(mtd, this, FL_WRITING);
888 /* See if operation failed and additional status checks are available */
889 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
890 status = this->errstat(mtd, this, FL_WRITING, status, page);
893 /* See if device thinks it succeeded */
894 if (status & NAND_STATUS_FAIL) {
895 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
899 /* FIXME: Implement cached programming ! */
900 /* wait until cache is ready */
901 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
906 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
908 * nand_verify_pages - [GENERIC] verify the chip contents after a write
909 * @mtd: MTD device structure
910 * @this: NAND chip structure
911 * @page: startpage inside the chip, must be called with (page & this->pagemask)
912 * @numpages: number of pages to verify
913 * @oob_buf: out of band data buffer
914 * @oobsel: out of band selecttion structre
915 * @chipnr: number of the current chip
916 * @oobmode: 1 = full buffer verify, 0 = ecc only
918 * The NAND device assumes that it is always writing to a cleanly erased page.
919 * Hence, it performs its internal write verification only on bits that
920 * transitioned from 1 to 0. The device does NOT verify the whole page on a
921 * byte by byte basis. It is possible that the page was not completely erased
922 * or the page is becoming unusable due to wear. The read with ECC would catch
923 * the error later when the ECC page check fails, but we would rather catch
924 * it early in the page write stage. Better to write no data than invalid data.
926 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
927 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
929 int i, j, datidx = 0, oobofs = 0, res = -EIO;
930 int eccsteps = this->eccsteps;
934 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
936 /* Send command to read back the first page */
937 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
940 for (j = 0; j < eccsteps; j++) {
941 /* Loop through and verify the data */
942 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
943 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
946 datidx += mtd->eccsize;
947 /* Have we a hw generator layout ? */
950 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
951 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
954 oobofs += hweccbytes;
957 /* check, if we must compare all data or if we just have to
958 * compare the ecc bytes
961 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
962 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
966 /* Read always, else autoincrement fails */
967 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
969 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
970 int ecccnt = oobsel->eccbytes;
972 for (i = 0; i < ecccnt; i++) {
973 int idx = oobsel->eccpos[i];
974 if (oobdata[idx] != oob_buf[oobofs + idx]) {
975 DEBUG(MTD_DEBUG_LEVEL0, "%s: Failed ECC write verify, page 0x%08x, %6i bytes were succesful\n",
976 __FUNCTION__, page, i);
982 oobofs += mtd->oobsize - hweccbytes * eccsteps;
986 /* Apply delay or wait for ready/busy pin
987 * Do this before the AUTOINCR check, so no problems
988 * arise if a chip which does auto increment
989 * is marked as NOAUTOINCR by the board driver.
990 * Do this also before returning, so the chip is
991 * ready for the next command.
993 if (!this->dev_ready)
994 udelay(this->chip_delay);
996 nand_wait_ready(mtd);
998 /* All done, return happy */
1002 /* Check, if the chip supports auto page increment */
1003 if (!NAND_CANAUTOINCR(this))
1004 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1007 * Terminate the read command. We come here in case of an error
1008 * So we must issue a reset command.
1011 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1017 * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
1018 * @mtd: MTD device structure
1019 * @from: offset to read from
1020 * @len: number of bytes to read
1021 * @retlen: pointer to variable to store the number of read bytes
1022 * @buf: the databuffer to put data
1024 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1027 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1029 return nand_do_read_ecc(mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1033 * nand_do_read_ecc - [MTD Interface] Read data with ECC
1034 * @mtd: MTD device structure
1035 * @from: offset to read from
1036 * @len: number of bytes to read
1037 * @retlen: pointer to variable to store the number of read bytes
1038 * @buf: the databuffer to put data
1039 * @oob_buf: filesystem supplied oob data buffer (can be NULL)
1040 * @oobsel: oob selection structure
1041 * @flags: flag to indicate if nand_get_device/nand_release_device should be preformed
1042 * and how many corrected error bits are acceptable:
1043 * bits 0..7 - number of tolerable errors
1044 * bit 8 - 0 == do not get/release chip, 1 == get/release chip
1046 * NAND read with ECC
1048 int nand_do_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1049 size_t *retlen, uint8_t *buf, uint8_t *oob_buf, struct nand_oobinfo *oobsel, int flags)
1052 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1053 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1054 struct nand_chip *this = mtd->priv;
1055 uint8_t *data_poi, *oob_data = oob_buf;
1056 uint8_t ecc_calc[32];
1057 uint8_t ecc_code[32];
1058 int eccmode, eccsteps;
1059 int *oob_config, datidx;
1060 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1065 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1067 /* Do not allow reads past end of device */
1068 if ((from + len) > mtd->size) {
1069 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1074 /* Grab the lock and see if the device is available */
1075 if (flags & NAND_GET_DEVICE)
1076 nand_get_device(this, mtd, FL_READING);
1078 /* Autoplace of oob data ? Use the default placement scheme */
1079 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1080 oobsel = this->autooob;
1082 eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
1083 oob_config = oobsel->eccpos;
1085 /* Select the NAND device */
1086 chipnr = (int)(from >> this->chip_shift);
1087 this->select_chip(mtd, chipnr);
1089 /* First we calculate the starting page */
1090 realpage = (int)(from >> this->page_shift);
1091 page = realpage & this->pagemask;
1093 /* Get raw starting column */
1094 col = from & (mtd->writesize - 1);
1096 end = mtd->writesize;
1097 ecc = this->ecc.size;
1098 eccbytes = this->ecc.bytes;
1100 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1103 oobreadlen = mtd->oobsize;
1104 if (this->options & NAND_HWECC_SYNDROME)
1105 oobreadlen -= oobsel->eccbytes;
1107 /* Loop until all data read */
1108 while (read < len) {
1110 int aligned = (!col && (len - read) >= end);
1112 * If the read is not page aligned, we have to read into data buffer
1113 * due to ecc, else we read into return buffer direct
1116 data_poi = &buf[read];
1118 data_poi = this->data_buf;
1120 /* Check, if we have this page in the buffer
1122 * FIXME: Make it work when we must provide oob data too,
1123 * check the usage of data_buf oob field
1125 if (realpage == this->pagebuf && !oob_buf) {
1126 /* aligned read ? */
1128 memcpy(data_poi, this->data_buf, end);
1132 /* Check, if we must send the read command */
1134 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1138 /* get oob area, if we have no oob buffer from fs-driver */
1139 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1140 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1141 oob_data = &this->data_buf[end];
1143 eccsteps = this->ecc.steps;
1146 case NAND_ECC_NONE:{
1147 /* No ECC, Read in a page */
1148 static unsigned long lastwhinge = 0;
1149 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1151 "Reading data from NAND FLASH without ECC is not recommended\n");
1152 lastwhinge = jiffies;
1154 this->read_buf(mtd, data_poi, end);
1158 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1159 this->read_buf(mtd, data_poi, end);
1160 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += 3, datidx += ecc)
1161 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1165 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += eccbytes, datidx += ecc) {
1166 this->ecc.hwctl(mtd, NAND_ECC_READ);
1167 this->read_buf(mtd, &data_poi[datidx], ecc);
1169 /* HW ecc with syndrome calculation must read the
1170 * syndrome from flash immidiately after the data */
1172 /* Some hw ecc generators need to know when the
1173 * syndrome is read from flash */
1174 this->ecc.hwctl(mtd, NAND_ECC_READSYN);
1175 this->read_buf(mtd, &oob_data[i], eccbytes);
1176 /* We calc error correction directly, it checks the hw
1177 * generator for an error, reads back the syndrome and
1178 * does the error correction on the fly */
1179 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1180 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1181 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1182 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1186 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1193 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1195 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1199 /* Pick the ECC bytes out of the oob data */
1200 for (j = 0; j < oobsel->eccbytes; j++)
1201 ecc_code[j] = oob_data[oob_config[j]];
1203 /* correct data, if necessary */
1204 for (i = 0, j = 0, datidx = 0; i < this->ecc.steps; i++, datidx += ecc) {
1205 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1207 /* Get next chunk of ecc bytes */
1210 /* Check, if we have a fs supplied oob-buffer,
1211 * This is the legacy mode. Used by YAFFS1
1212 * Should go away some day
1214 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1215 int *p = (int *)(&oob_data[mtd->oobsize]);
1219 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1220 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1226 /* check, if we have a fs supplied oob-buffer */
1228 /* without autoplace. Legacy mode used by YAFFS1 */
1229 switch (oobsel->useecc) {
1230 case MTD_NANDECC_AUTOPLACE:
1231 case MTD_NANDECC_AUTOPL_USR:
1232 /* Walk through the autoplace chunks */
1233 for (i = 0; oobsel->oobfree[i][1]; i++) {
1234 int from = oobsel->oobfree[i][0];
1235 int num = oobsel->oobfree[i][1];
1236 memcpy(&oob_buf[oob], &oob_data[from], num);
1240 case MTD_NANDECC_PLACE:
1241 /* YAFFS1 legacy mode */
1242 oob_data += this->ecc.steps * sizeof(int);
1244 oob_data += mtd->oobsize;
1248 /* Partial page read, transfer data into fs buffer */
1250 for (j = col; j < end && read < len; j++)
1251 buf[read++] = data_poi[j];
1252 this->pagebuf = realpage;
1254 read += mtd->writesize;
1256 /* Apply delay or wait for ready/busy pin
1257 * Do this before the AUTOINCR check, so no problems
1258 * arise if a chip which does auto increment
1259 * is marked as NOAUTOINCR by the board driver.
1261 if (!this->dev_ready)
1262 udelay(this->chip_delay);
1264 nand_wait_ready(mtd);
1269 /* For subsequent reads align to page boundary. */
1271 /* Increment page address */
1274 page = realpage & this->pagemask;
1275 /* Check, if we cross a chip boundary */
1278 this->select_chip(mtd, -1);
1279 this->select_chip(mtd, chipnr);
1281 /* Check, if the chip supports auto page increment
1282 * or if we have hit a block boundary.
1284 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1288 /* Deselect and wake up anyone waiting on the device */
1289 if (flags & NAND_GET_DEVICE)
1290 nand_release_device(mtd);
1293 * Return success, if no ECC failures, else -EBADMSG
1294 * fs driver will take care of that, because
1295 * retlen == desired len and result == -EBADMSG
1298 return ecc_failed ? -EBADMSG : 0;
1302 * nand_read_oob - [MTD Interface] NAND read out-of-band
1303 * @mtd: MTD device structure
1304 * @from: offset to read from
1305 * @len: number of bytes to read
1306 * @retlen: pointer to variable to store the number of read bytes
1307 * @buf: the databuffer to put data
1309 * NAND read out-of-band data from the spare area
1311 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1313 int i, col, page, chipnr;
1314 struct nand_chip *this = mtd->priv;
1315 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1317 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1319 /* Shift to get page */
1320 page = (int)(from >> this->page_shift);
1321 chipnr = (int)(from >> this->chip_shift);
1323 /* Mask to get column */
1324 col = from & (mtd->oobsize - 1);
1326 /* Initialize return length value */
1329 /* Do not allow reads past end of device */
1330 if ((from + len) > mtd->size) {
1331 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1336 /* Grab the lock and see if the device is available */
1337 nand_get_device(this, mtd, FL_READING);
1339 /* Select the NAND device */
1340 this->select_chip(mtd, chipnr);
1342 /* Send the read command */
1343 this->cmdfunc(mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1345 * Read the data, if we read more than one page
1346 * oob data, let the device transfer the data !
1350 int thislen = mtd->oobsize - col;
1351 thislen = min_t(int, thislen, len);
1352 this->read_buf(mtd, &buf[i], thislen);
1360 /* Check, if we cross a chip boundary */
1361 if (!(page & this->pagemask)) {
1363 this->select_chip(mtd, -1);
1364 this->select_chip(mtd, chipnr);
1367 /* Apply delay or wait for ready/busy pin
1368 * Do this before the AUTOINCR check, so no problems
1369 * arise if a chip which does auto increment
1370 * is marked as NOAUTOINCR by the board driver.
1372 if (!this->dev_ready)
1373 udelay(this->chip_delay);
1375 nand_wait_ready(mtd);
1377 /* Check, if the chip supports auto page increment
1378 * or if we have hit a block boundary.
1380 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1381 /* For subsequent page reads set offset to 0 */
1382 this->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1387 /* Deselect and wake up anyone waiting on the device */
1388 nand_release_device(mtd);
1396 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1397 * @mtd: MTD device structure
1398 * @buf: temporary buffer
1399 * @from: offset to read from
1400 * @len: number of bytes to read
1401 * @ooblen: number of oob data bytes to read
1403 * Read raw data including oob into buffer
1405 int nand_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1407 struct nand_chip *this = mtd->priv;
1408 int page = (int)(from >> this->page_shift);
1409 int chip = (int)(from >> this->chip_shift);
1412 int pagesize = mtd->writesize + mtd->oobsize;
1413 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1415 /* Do not allow reads past end of device */
1416 if ((from + len) > mtd->size) {
1417 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1421 /* Grab the lock and see if the device is available */
1422 nand_get_device(this, mtd, FL_READING);
1424 this->select_chip(mtd, chip);
1426 /* Add requested oob length */
1431 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1434 this->read_buf(mtd, &buf[cnt], pagesize);
1440 if (!this->dev_ready)
1441 udelay(this->chip_delay);
1443 nand_wait_ready(mtd);
1445 /* Check, if the chip supports auto page increment */
1446 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1450 /* Deselect and wake up anyone waiting on the device */
1451 nand_release_device(mtd);
1456 * nand_write_raw - [GENERIC] Write raw data including oob
1457 * @mtd: MTD device structure
1458 * @buf: source buffer
1459 * @to: offset to write to
1460 * @len: number of bytes to write
1461 * @buf: source buffer
1464 * Write raw data including oob
1466 int nand_write_raw(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1467 uint8_t *buf, uint8_t *oob)
1469 struct nand_chip *this = mtd->priv;
1470 int page = (int)(to >> this->page_shift);
1471 int chip = (int)(to >> this->chip_shift);
1476 /* Do not allow writes past end of device */
1477 if ((to + len) > mtd->size) {
1478 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt write "
1479 "beyond end of device\n");
1483 /* Grab the lock and see if the device is available */
1484 nand_get_device(this, mtd, FL_WRITING);
1486 this->select_chip(mtd, chip);
1487 this->data_poi = buf;
1489 while (len != *retlen) {
1490 ret = nand_write_page(mtd, this, page, oob, &mtd->oobinfo, 0);
1494 *retlen += mtd->writesize;
1495 this->data_poi += mtd->writesize;
1496 oob += mtd->oobsize;
1499 /* Deselect and wake up anyone waiting on the device */
1500 nand_release_device(mtd);
1503 EXPORT_SYMBOL_GPL(nand_write_raw);
1506 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1507 * @mtd: MTD device structure
1508 * @fsbuf: buffer given by fs driver
1509 * @oobsel: out of band selection structre
1510 * @autoplace: 1 = place given buffer into the oob bytes
1511 * @numpages: number of pages to prepare
1514 * 1. Filesystem buffer available and autoplacement is off,
1515 * return filesystem buffer
1516 * 2. No filesystem buffer or autoplace is off, return internal
1518 * 3. Filesystem buffer is given and autoplace selected
1519 * put data from fs buffer into internal buffer and
1520 * retrun internal buffer
1522 * Note: The internal buffer is filled with 0xff. This must
1523 * be done only once, when no autoplacement happens
1524 * Autoplacement sets the buffer dirty flag, which
1525 * forces the 0xff fill before using the buffer again.
1528 static uint8_t *nand_prepare_oobbuf(struct mtd_info *mtd, uint8_t *fsbuf, struct nand_oobinfo *oobsel,
1529 int autoplace, int numpages)
1531 struct nand_chip *this = mtd->priv;
1534 /* Zero copy fs supplied buffer */
1535 if (fsbuf && !autoplace)
1538 /* Check, if the buffer must be filled with ff again */
1539 if (this->oobdirty) {
1540 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1544 /* If we have no autoplacement or no fs buffer use the internal one */
1545 if (!autoplace || !fsbuf)
1546 return this->oob_buf;
1548 /* Walk through the pages and place the data */
1551 while (numpages--) {
1552 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1553 int to = ofs + oobsel->oobfree[i][0];
1554 int num = oobsel->oobfree[i][1];
1555 memcpy(&this->oob_buf[to], fsbuf, num);
1559 ofs += mtd->oobavail;
1561 return this->oob_buf;
1564 #define NOTALIGNED(x) (x & (mtd->writesize-1)) != 0
1567 * nand_write - [MTD Interface] NAND write with ECC
1568 * @mtd: MTD device structure
1569 * @to: offset to write to
1570 * @len: number of bytes to write
1571 * @retlen: pointer to variable to store the number of written bytes
1572 * @buf: the data to write
1574 * NAND write with ECC
1576 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
1577 size_t *retlen, const uint8_t *buf)
1579 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1580 int autoplace = 0, numpages, totalpages;
1581 struct nand_chip *this = mtd->priv;
1582 uint8_t *oobbuf, *bufstart, *eccbuf = NULL;
1583 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1584 struct nand_oobinfo *oobsel = &mtd->oobinfo;
1586 DEBUG(MTD_DEBUG_LEVEL3, "nand_write: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1588 /* Initialize retlen, in case of early exit */
1591 /* Do not allow write past end of device */
1592 if ((to + len) > mtd->size) {
1593 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: Attempt to write past end of page\n");
1597 /* reject writes, which are not page aligned */
1598 if (NOTALIGNED(to) || NOTALIGNED(len)) {
1599 printk(KERN_NOTICE "nand_write: Attempt to write not page aligned data\n");
1603 /* Grab the lock and see if the device is available */
1604 nand_get_device(this, mtd, FL_WRITING);
1606 /* Calculate chipnr */
1607 chipnr = (int)(to >> this->chip_shift);
1608 /* Select the NAND device */
1609 this->select_chip(mtd, chipnr);
1611 /* Check, if it is write protected */
1612 if (nand_check_wp(mtd))
1615 /* Autoplace of oob data ? Use the default placement scheme */
1616 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1617 oobsel = this->autooob;
1620 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1623 /* Setup variables and oob buffer */
1624 totalpages = len >> this->page_shift;
1625 page = (int)(to >> this->page_shift);
1626 /* Invalidate the page cache, if we write to the cached page */
1627 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1630 /* Set it relative to chip */
1631 page &= this->pagemask;
1633 /* Calc number of pages we can write in one go */
1634 numpages = min(ppblock - (startpage & (ppblock - 1)), totalpages);
1635 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1636 bufstart = (uint8_t *) buf;
1638 /* Loop until all data is written */
1639 while (written < len) {
1641 this->data_poi = (uint8_t *) &buf[written];
1642 /* Write one page. If this is the last page to write
1643 * or the last page in this block, then use the
1644 * real pageprogram command, else select cached programming
1645 * if supported by the chip.
1647 ret = nand_write_page(mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1649 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: write_page failed %d\n", ret);
1653 oob += mtd->oobsize;
1654 /* Update written bytes count */
1655 written += mtd->writesize;
1659 /* Increment page address */
1662 /* Have we hit a block boundary ? Then we have to verify and
1663 * if verify is ok, we have to setup the oob buffer for
1666 if (!(page & (ppblock - 1))) {
1668 this->data_poi = bufstart;
1669 ret = nand_verify_pages(mtd, this, startpage, page - startpage,
1670 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1672 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1677 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1679 eccbuf += (page - startpage) * ofs;
1680 totalpages -= page - startpage;
1681 numpages = min(totalpages, ppblock);
1682 page &= this->pagemask;
1684 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1686 /* Check, if we cross a chip boundary */
1689 this->select_chip(mtd, -1);
1690 this->select_chip(mtd, chipnr);
1694 /* Verify the remaining pages */
1696 this->data_poi = bufstart;
1697 ret = nand_verify_pages(mtd, this, startpage, totalpages, oobbuf, oobsel, chipnr, (eccbuf != NULL));
1701 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1704 /* Deselect and wake up anyone waiting on the device */
1705 nand_release_device(mtd);
1711 * nand_write_oob - [MTD Interface] NAND write out-of-band
1712 * @mtd: MTD device structure
1713 * @to: offset to write to
1714 * @len: number of bytes to write
1715 * @retlen: pointer to variable to store the number of written bytes
1716 * @buf: the data to write
1718 * NAND write out-of-band
1720 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const uint8_t *buf)
1722 int column, page, status, ret = -EIO, chipnr;
1723 struct nand_chip *this = mtd->priv;
1725 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1727 /* Shift to get page */
1728 page = (int)(to >> this->page_shift);
1729 chipnr = (int)(to >> this->chip_shift);
1731 /* Mask to get column */
1732 column = to & (mtd->oobsize - 1);
1734 /* Initialize return length value */
1737 /* Do not allow write past end of page */
1738 if ((column + len) > mtd->oobsize) {
1739 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1743 /* Grab the lock and see if the device is available */
1744 nand_get_device(this, mtd, FL_WRITING);
1746 /* Select the NAND device */
1747 this->select_chip(mtd, chipnr);
1749 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1750 in one of my DiskOnChip 2000 test units) will clear the whole
1751 data page too if we don't do this. I have no clue why, but
1752 I seem to have 'fixed' it in the doc2000 driver in
1753 August 1999. dwmw2. */
1754 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1756 /* Check, if it is write protected */
1757 if (nand_check_wp(mtd))
1760 /* Invalidate the page cache, if we write to the cached page */
1761 if (page == this->pagebuf)
1764 if (NAND_MUST_PAD(this)) {
1765 /* Write out desired data */
1766 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page & this->pagemask);
1767 /* prepad 0xff for partial programming */
1768 this->write_buf(mtd, ffchars, column);
1770 this->write_buf(mtd, buf, len);
1771 /* postpad 0xff for partial programming */
1772 this->write_buf(mtd, ffchars, mtd->oobsize - (len + column));
1774 /* Write out desired data */
1775 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize + column, page & this->pagemask);
1777 this->write_buf(mtd, buf, len);
1779 /* Send command to program the OOB data */
1780 this->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1782 status = this->waitfunc(mtd, this, FL_WRITING);
1784 /* See if device thinks it succeeded */
1785 if (status & NAND_STATUS_FAIL) {
1786 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1793 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1794 /* Send command to read back the data */
1795 this->cmdfunc(mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1797 if (this->verify_buf(mtd, buf, len)) {
1798 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1805 /* Deselect and wake up anyone waiting on the device */
1806 nand_release_device(mtd);
1812 * single_erease_cmd - [GENERIC] NAND standard block erase command function
1813 * @mtd: MTD device structure
1814 * @page: the page address of the block which will be erased
1816 * Standard erase command for NAND chips
1818 static void single_erase_cmd(struct mtd_info *mtd, int page)
1820 struct nand_chip *this = mtd->priv;
1821 /* Send commands to erase a block */
1822 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1823 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1827 * multi_erease_cmd - [GENERIC] AND specific block erase command function
1828 * @mtd: MTD device structure
1829 * @page: the page address of the block which will be erased
1831 * AND multi block erase command function
1832 * Erase 4 consecutive blocks
1834 static void multi_erase_cmd(struct mtd_info *mtd, int page)
1836 struct nand_chip *this = mtd->priv;
1837 /* Send commands to erase a block */
1838 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1839 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1840 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1841 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1842 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1846 * nand_erase - [MTD Interface] erase block(s)
1847 * @mtd: MTD device structure
1848 * @instr: erase instruction
1850 * Erase one ore more blocks
1852 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
1854 return nand_erase_nand(mtd, instr, 0);
1857 #define BBT_PAGE_MASK 0xffffff3f
1859 * nand_erase_intern - [NAND Interface] erase block(s)
1860 * @mtd: MTD device structure
1861 * @instr: erase instruction
1862 * @allowbbt: allow erasing the bbt area
1864 * Erase one ore more blocks
1866 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
1868 int page, len, status, pages_per_block, ret, chipnr;
1869 struct nand_chip *this = mtd->priv;
1870 int rewrite_bbt[NAND_MAX_CHIPS]={0}; /* flags to indicate the page, if bbt needs to be rewritten. */
1871 unsigned int bbt_masked_page; /* bbt mask to compare to page being erased. */
1872 /* It is used to see if the current page is in the same */
1873 /* 256 block group and the same bank as the bbt. */
1875 DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n", (unsigned int)instr->addr, (unsigned int)instr->len);
1877 /* Start address must align on block boundary */
1878 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
1879 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
1883 /* Length must align on block boundary */
1884 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
1885 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
1889 /* Do not allow erase past end of device */
1890 if ((instr->len + instr->addr) > mtd->size) {
1891 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
1895 instr->fail_addr = 0xffffffff;
1897 /* Grab the lock and see if the device is available */
1898 nand_get_device(this, mtd, FL_ERASING);
1900 /* Shift to get first page */
1901 page = (int)(instr->addr >> this->page_shift);
1902 chipnr = (int)(instr->addr >> this->chip_shift);
1904 /* Calculate pages in each block */
1905 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
1907 /* Select the NAND device */
1908 this->select_chip(mtd, chipnr);
1910 /* Check the WP bit */
1911 /* Check, if it is write protected */
1912 if (nand_check_wp(mtd)) {
1913 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
1914 instr->state = MTD_ERASE_FAILED;
1918 /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
1919 if (this->options & BBT_AUTO_REFRESH) {
1920 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
1922 bbt_masked_page = 0xffffffff; /* should not match anything */
1925 /* Loop through the pages */
1928 instr->state = MTD_ERASING;
1931 /* Check if we have a bad block, we do not erase bad blocks ! */
1932 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
1933 printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
1934 instr->state = MTD_ERASE_FAILED;
1938 /* Invalidate the page cache, if we erase the block which contains
1939 the current cached page */
1940 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
1943 this->erase_cmd(mtd, page & this->pagemask);
1945 status = this->waitfunc(mtd, this, FL_ERASING);
1947 /* See if operation failed and additional status checks are available */
1948 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
1949 status = this->errstat(mtd, this, FL_ERASING, status, page);
1952 /* See if block erase succeeded */
1953 if (status & NAND_STATUS_FAIL) {
1954 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
1955 instr->state = MTD_ERASE_FAILED;
1956 instr->fail_addr = (page << this->page_shift);
1960 /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
1961 if (this->options & BBT_AUTO_REFRESH) {
1962 if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
1963 (page != this->bbt_td->pages[chipnr])) {
1964 rewrite_bbt[chipnr] = (page << this->page_shift);
1968 /* Increment page address and decrement length */
1969 len -= (1 << this->phys_erase_shift);
1970 page += pages_per_block;
1972 /* Check, if we cross a chip boundary */
1973 if (len && !(page & this->pagemask)) {
1975 this->select_chip(mtd, -1);
1976 this->select_chip(mtd, chipnr);
1978 /* if BBT requires refresh and BBT-PERCHIP,
1979 * set the BBT page mask to see if this BBT should be rewritten */
1980 if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
1981 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
1986 instr->state = MTD_ERASE_DONE;
1990 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
1991 /* Do call back function */
1993 mtd_erase_callback(instr);
1995 /* Deselect and wake up anyone waiting on the device */
1996 nand_release_device(mtd);
1998 /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
1999 if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
2000 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
2001 if (rewrite_bbt[chipnr]) {
2002 /* update the BBT for chip */
2003 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2004 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2005 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2010 /* Return more or less happy */
2015 * nand_sync - [MTD Interface] sync
2016 * @mtd: MTD device structure
2018 * Sync is actually a wait for chip ready function
2020 static void nand_sync(struct mtd_info *mtd)
2022 struct nand_chip *this = mtd->priv;
2024 DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2026 /* Grab the lock and see if the device is available */
2027 nand_get_device(this, mtd, FL_SYNCING);
2028 /* Release it and go back */
2029 nand_release_device(mtd);
2033 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2034 * @mtd: MTD device structure
2035 * @ofs: offset relative to mtd start
2037 static int nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2039 /* Check for invalid offset */
2040 if (ofs > mtd->size)
2043 return nand_block_checkbad(mtd, ofs, 1, 0);
2047 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2048 * @mtd: MTD device structure
2049 * @ofs: offset relative to mtd start
2051 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2053 struct nand_chip *this = mtd->priv;
2056 if ((ret = nand_block_isbad(mtd, ofs))) {
2057 /* If it was bad already, return success and do nothing. */
2063 return this->block_markbad(mtd, ofs);
2067 * nand_suspend - [MTD Interface] Suspend the NAND flash
2068 * @mtd: MTD device structure
2070 static int nand_suspend(struct mtd_info *mtd)
2072 struct nand_chip *this = mtd->priv;
2074 return nand_get_device(this, mtd, FL_PM_SUSPENDED);
2078 * nand_resume - [MTD Interface] Resume the NAND flash
2079 * @mtd: MTD device structure
2081 static void nand_resume(struct mtd_info *mtd)
2083 struct nand_chip *this = mtd->priv;
2085 if (this->state == FL_PM_SUSPENDED)
2086 nand_release_device(mtd);
2088 printk(KERN_ERR "nand_resume() called for a chip which is not "
2089 "in suspended state\n");
2093 * Free allocated data structures
2095 static void nand_free_kmem(struct nand_chip *this)
2097 /* Buffer allocated by nand_scan ? */
2098 if (this->options & NAND_OOBBUF_ALLOC)
2099 kfree(this->oob_buf);
2100 /* Buffer allocated by nand_scan ? */
2101 if (this->options & NAND_DATABUF_ALLOC)
2102 kfree(this->data_buf);
2103 /* Controller allocated by nand_scan ? */
2104 if (this->options & NAND_CONTROLLER_ALLOC)
2105 kfree(this->controller);
2109 * Allocate buffers and data structures
2111 static int nand_allocate_kmem(struct mtd_info *mtd, struct nand_chip *this)
2115 if (!this->oob_buf) {
2116 len = mtd->oobsize <<
2117 (this->phys_erase_shift - this->page_shift);
2118 this->oob_buf = kmalloc(len, GFP_KERNEL);
2121 this->options |= NAND_OOBBUF_ALLOC;
2124 if (!this->data_buf) {
2125 len = mtd->writesize + mtd->oobsize;
2126 this->data_buf = kmalloc(len, GFP_KERNEL);
2127 if (!this->data_buf)
2129 this->options |= NAND_DATABUF_ALLOC;
2132 if (!this->controller) {
2133 this->controller = kzalloc(sizeof(struct nand_hw_control),
2135 if (!this->controller)
2137 this->options |= NAND_CONTROLLER_ALLOC;
2142 printk(KERN_ERR "nand_scan(): Cannot allocate buffers\n");
2143 nand_free_kmem(this);
2148 * Set default functions
2150 static void nand_set_defaults(struct nand_chip *this, int busw)
2152 /* check for proper chip_delay setup, set 20us if not */
2153 if (!this->chip_delay)
2154 this->chip_delay = 20;
2156 /* check, if a user supplied command function given */
2157 if (this->cmdfunc == NULL)
2158 this->cmdfunc = nand_command;
2160 /* check, if a user supplied wait function given */
2161 if (this->waitfunc == NULL)
2162 this->waitfunc = nand_wait;
2164 if (!this->select_chip)
2165 this->select_chip = nand_select_chip;
2166 if (!this->read_byte)
2167 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2168 if (!this->read_word)
2169 this->read_word = nand_read_word;
2170 if (!this->block_bad)
2171 this->block_bad = nand_block_bad;
2172 if (!this->block_markbad)
2173 this->block_markbad = nand_default_block_markbad;
2174 if (!this->write_buf)
2175 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2176 if (!this->read_buf)
2177 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2178 if (!this->verify_buf)
2179 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2180 if (!this->scan_bbt)
2181 this->scan_bbt = nand_default_bbt;
2185 * Get the flash and manufacturer id and lookup if the typ is supported
2187 static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
2188 struct nand_chip *this,
2189 int busw, int *maf_id)
2191 struct nand_flash_dev *type = NULL;
2192 int i, dev_id, maf_idx;
2194 /* Select the device */
2195 this->select_chip(mtd, 0);
2197 /* Send the command for reading device ID */
2198 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2200 /* Read manufacturer and device IDs */
2201 *maf_id = this->read_byte(mtd);
2202 dev_id = this->read_byte(mtd);
2204 /* Lookup the flash id */
2205 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2206 if (dev_id == nand_flash_ids[i].id) {
2207 type = &nand_flash_ids[i];
2213 return ERR_PTR(-ENODEV);
2215 this->chipsize = nand_flash_ids[i].chipsize << 20;
2217 /* Newer devices have all the information in additional id bytes */
2218 if (!nand_flash_ids[i].pagesize) {
2220 /* The 3rd id byte contains non relevant data ATM */
2221 extid = this->read_byte(mtd);
2222 /* The 4th id byte is the important one */
2223 extid = this->read_byte(mtd);
2225 mtd->writesize = 1024 << (extid & 0x3);
2228 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->writesize >> 9);
2230 /* Calc blocksize. Blocksize is multiples of 64KiB */
2231 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2233 /* Get buswidth information */
2234 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2238 * Old devices have this data hardcoded in the device id table
2240 mtd->erasesize = nand_flash_ids[i].erasesize;
2241 mtd->writesize = nand_flash_ids[i].pagesize;
2242 mtd->oobsize = mtd->writesize / 32;
2243 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2246 /* Try to identify manufacturer */
2247 for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_id++) {
2248 if (nand_manuf_ids[maf_idx].id == *maf_id)
2253 * Check, if buswidth is correct. Hardware drivers should set
2256 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2257 printk(KERN_INFO "NAND device: Manufacturer ID:"
2258 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
2259 dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
2260 printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
2261 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2263 return ERR_PTR(-EINVAL);
2266 /* Calculate the address shift from the page size */
2267 this->page_shift = ffs(mtd->writesize) - 1;
2268 /* Convert chipsize to number of pages per chip -1. */
2269 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2271 this->bbt_erase_shift = this->phys_erase_shift =
2272 ffs(mtd->erasesize) - 1;
2273 this->chip_shift = ffs(this->chipsize) - 1;
2275 /* Set the bad block position */
2276 this->badblockpos = mtd->writesize > 512 ?
2277 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2279 /* Get chip options, preserve non chip based options */
2280 this->options &= ~NAND_CHIPOPTIONS_MSK;
2281 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2284 * Set this as a default. Board drivers can override it, if necessary
2286 this->options |= NAND_NO_AUTOINCR;
2288 /* Check if this is a not a samsung device. Do not clear the
2289 * options for chips which are not having an extended id.
2291 if (*maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2292 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2294 /* Check for AND chips with 4 page planes */
2295 if (this->options & NAND_4PAGE_ARRAY)
2296 this->erase_cmd = multi_erase_cmd;
2298 this->erase_cmd = single_erase_cmd;
2300 /* Do not replace user supplied command function ! */
2301 if (mtd->writesize > 512 && this->cmdfunc == nand_command)
2302 this->cmdfunc = nand_command_lp;
2304 printk(KERN_INFO "NAND device: Manufacturer ID:"
2305 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, dev_id,
2306 nand_manuf_ids[maf_idx].name, type->name);
2311 /* module_text_address() isn't exported, and it's mostly a pointless
2312 test if this is a module _anyway_ -- they'd have to try _really_ hard
2313 to call us from in-kernel code if the core NAND support is modular. */
2315 #define caller_is_module() (1)
2317 #define caller_is_module() \
2318 module_text_address((unsigned long)__builtin_return_address(0))
2322 * nand_scan - [NAND Interface] Scan for the NAND device
2323 * @mtd: MTD device structure
2324 * @maxchips: Number of chips to scan for
2326 * This fills out all the uninitialized function pointers
2327 * with the defaults.
2328 * The flash ID is read and the mtd/chip structures are
2329 * filled with the appropriate values. Buffers are allocated if
2330 * they are not provided by the board driver
2331 * The mtd->owner field must be set to the module of the caller
2334 int nand_scan(struct mtd_info *mtd, int maxchips)
2336 int i, busw, nand_maf_id;
2337 struct nand_chip *this = mtd->priv;
2338 struct nand_flash_dev *type;
2340 /* Many callers got this wrong, so check for it for a while... */
2341 if (!mtd->owner && caller_is_module()) {
2342 printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
2346 /* Get buswidth to select the correct functions */
2347 busw = this->options & NAND_BUSWIDTH_16;
2348 /* Set the default functions */
2349 nand_set_defaults(this, busw);
2351 /* Read the flash type */
2352 type = nand_get_flash_type(mtd, this, busw, &nand_maf_id);
2355 printk(KERN_WARNING "No NAND device found!!!\n");
2356 this->select_chip(mtd, -1);
2357 return PTR_ERR(type);
2360 /* Check for a chip array */
2361 for (i = 1; i < maxchips; i++) {
2362 this->select_chip(mtd, i);
2363 /* Send the command for reading device ID */
2364 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2365 /* Read manufacturer and device IDs */
2366 if (nand_maf_id != this->read_byte(mtd) ||
2367 type->id != this->read_byte(mtd))
2371 printk(KERN_INFO "%d NAND chips detected\n", i);
2373 /* Store the number of chips and calc total size for mtd */
2375 mtd->size = i * this->chipsize;
2377 /* Allocate buffers and data structures */
2378 if (nand_allocate_kmem(mtd, this))
2381 /* Preset the internal oob buffer */
2382 memset(this->oob_buf, 0xff,
2383 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2386 * If no default placement scheme is given, select an appropriate one
2388 if (!this->autooob) {
2389 switch (mtd->oobsize) {
2391 this->autooob = &nand_oob_8;
2394 this->autooob = &nand_oob_16;
2397 this->autooob = &nand_oob_64;
2400 printk(KERN_WARNING "No oob scheme defined for "
2401 "oobsize %d\n", mtd->oobsize);
2407 * The number of bytes available for the filesystem to place fs
2408 * dependend oob data
2411 for (i = 0; this->autooob->oobfree[i][1]; i++)
2412 mtd->oobavail += this->autooob->oobfree[i][1];
2415 * check ECC mode, default to software if 3byte/512byte hardware ECC is
2416 * selected and we have 256 byte pagesize fallback to software ECC
2418 switch (this->ecc.mode) {
2420 case NAND_ECC_HW_SYNDROME:
2421 if (!this->ecc.calculate || !this->ecc.correct ||
2423 printk(KERN_WARNING "No ECC functions supplied, "
2424 "Hardware ECC not possible\n");
2427 if (mtd->writesize >= this->ecc.size)
2429 printk(KERN_WARNING "%d byte HW ECC not possible on "
2430 "%d byte page size, fallback to SW ECC\n",
2431 this->ecc.size, mtd->writesize);
2432 this->ecc.mode = NAND_ECC_SOFT;
2435 this->ecc.calculate = nand_calculate_ecc;
2436 this->ecc.correct = nand_correct_data;
2437 this->ecc.size = 256;
2438 this->ecc.bytes = 3;
2442 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
2443 "This is not recommended !!\n");
2444 this->ecc.size = mtd->writesize;
2445 this->ecc.bytes = 0;
2448 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
2454 * Set the number of read / write steps for one page depending on ECC
2457 this->ecc.steps = mtd->writesize / this->ecc.size;
2458 if(this->ecc.steps * this->ecc.size != mtd->writesize) {
2459 printk(KERN_WARNING "Invalid ecc parameters\n");
2463 /* Initialize state, waitqueue and spinlock */
2464 this->state = FL_READY;
2465 init_waitqueue_head(&this->controller->wq);
2466 spin_lock_init(&this->controller->lock);
2468 /* De-select the device */
2469 this->select_chip(mtd, -1);
2471 /* Invalidate the pagebuffer reference */
2474 /* Fill in remaining MTD driver data */
2475 mtd->type = MTD_NANDFLASH;
2476 mtd->flags = MTD_CAP_NANDFLASH;
2477 mtd->ecctype = MTD_ECC_SW;
2478 mtd->erase = nand_erase;
2480 mtd->unpoint = NULL;
2481 mtd->read = nand_read;
2482 mtd->write = nand_write;
2483 mtd->read_oob = nand_read_oob;
2484 mtd->write_oob = nand_write_oob;
2485 mtd->sync = nand_sync;
2488 mtd->suspend = nand_suspend;
2489 mtd->resume = nand_resume;
2490 mtd->block_isbad = nand_block_isbad;
2491 mtd->block_markbad = nand_block_markbad;
2493 /* and make the autooob the default one */
2494 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2496 /* Check, if we should skip the bad block table scan */
2497 if (this->options & NAND_SKIP_BBTSCAN)
2500 /* Build bad block table */
2501 return this->scan_bbt(mtd);
2505 * nand_release - [NAND Interface] Free resources held by the NAND device
2506 * @mtd: MTD device structure
2508 void nand_release(struct mtd_info *mtd)
2510 struct nand_chip *this = mtd->priv;
2512 #ifdef CONFIG_MTD_PARTITIONS
2513 /* Deregister partitions */
2514 del_mtd_partitions(mtd);
2516 /* Deregister the device */
2517 del_mtd_device(mtd);
2519 /* Free bad block table memory */
2522 nand_free_kmem(this);
2525 EXPORT_SYMBOL_GPL(nand_scan);
2526 EXPORT_SYMBOL_GPL(nand_release);
2528 static int __init nand_base_init(void)
2530 led_trigger_register_simple("nand-disk", &nand_led_trigger);
2534 static void __exit nand_base_exit(void)
2536 led_trigger_unregister_simple(nand_led_trigger);
2539 module_init(nand_base_init);
2540 module_exit(nand_base_exit);
2542 MODULE_LICENSE("GPL");
2543 MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2544 MODULE_DESCRIPTION("Generic NAND flash driver code");