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_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
202 * @mtd: MTD device structure
204 * Default read function for 16bit buswith with
205 * endianess conversion
207 static uint8_t nand_read_byte16(struct mtd_info *mtd)
209 struct nand_chip *this = mtd->priv;
210 return (uint8_t) cpu_to_le16(readw(this->IO_ADDR_R));
214 * nand_read_word - [DEFAULT] read one word from the chip
215 * @mtd: MTD device structure
217 * Default read function for 16bit buswith without
218 * endianess conversion
220 static u16 nand_read_word(struct mtd_info *mtd)
222 struct nand_chip *this = mtd->priv;
223 return readw(this->IO_ADDR_R);
227 * nand_select_chip - [DEFAULT] control CE line
228 * @mtd: MTD device structure
229 * @chip: chipnumber to select, -1 for deselect
231 * Default select function for 1 chip devices.
233 static void nand_select_chip(struct mtd_info *mtd, int chip)
235 struct nand_chip *this = mtd->priv;
238 this->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
241 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
250 * nand_write_buf - [DEFAULT] write buffer to chip
251 * @mtd: MTD device structure
253 * @len: number of bytes to write
255 * Default write function for 8bit buswith
257 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
260 struct nand_chip *this = mtd->priv;
262 for (i = 0; i < len; i++)
263 writeb(buf[i], this->IO_ADDR_W);
267 * nand_read_buf - [DEFAULT] read chip data into buffer
268 * @mtd: MTD device structure
269 * @buf: buffer to store date
270 * @len: number of bytes to read
272 * Default read function for 8bit buswith
274 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
277 struct nand_chip *this = mtd->priv;
279 for (i = 0; i < len; i++)
280 buf[i] = readb(this->IO_ADDR_R);
284 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
285 * @mtd: MTD device structure
286 * @buf: buffer containing the data to compare
287 * @len: number of bytes to compare
289 * Default verify function for 8bit buswith
291 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
294 struct nand_chip *this = mtd->priv;
296 for (i = 0; i < len; i++)
297 if (buf[i] != readb(this->IO_ADDR_R))
304 * nand_write_buf16 - [DEFAULT] write buffer to chip
305 * @mtd: MTD device structure
307 * @len: number of bytes to write
309 * Default write function for 16bit buswith
311 static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
314 struct nand_chip *this = mtd->priv;
315 u16 *p = (u16 *) buf;
318 for (i = 0; i < len; i++)
319 writew(p[i], this->IO_ADDR_W);
324 * nand_read_buf16 - [DEFAULT] read chip data into buffer
325 * @mtd: MTD device structure
326 * @buf: buffer to store date
327 * @len: number of bytes to read
329 * Default read function for 16bit buswith
331 static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
334 struct nand_chip *this = mtd->priv;
335 u16 *p = (u16 *) buf;
338 for (i = 0; i < len; i++)
339 p[i] = readw(this->IO_ADDR_R);
343 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
344 * @mtd: MTD device structure
345 * @buf: buffer containing the data to compare
346 * @len: number of bytes to compare
348 * Default verify function for 16bit buswith
350 static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
353 struct nand_chip *this = mtd->priv;
354 u16 *p = (u16 *) buf;
357 for (i = 0; i < len; i++)
358 if (p[i] != readw(this->IO_ADDR_R))
365 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
366 * @mtd: MTD device structure
367 * @ofs: offset from device start
368 * @getchip: 0, if the chip is already selected
370 * Check, if the block is bad.
372 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
374 int page, chipnr, res = 0;
375 struct nand_chip *this = mtd->priv;
379 page = (int)(ofs >> this->page_shift);
380 chipnr = (int)(ofs >> this->chip_shift);
382 /* Grab the lock and see if the device is available */
383 nand_get_device(this, mtd, FL_READING);
385 /* Select the NAND device */
386 this->select_chip(mtd, chipnr);
390 if (this->options & NAND_BUSWIDTH_16) {
391 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE,
392 page & this->pagemask);
393 bad = cpu_to_le16(this->read_word(mtd));
394 if (this->badblockpos & 0x1)
396 if ((bad & 0xFF) != 0xff)
399 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos,
400 page & this->pagemask);
401 if (this->read_byte(mtd) != 0xff)
406 /* Deselect and wake up anyone waiting on the device */
407 nand_release_device(mtd);
414 * nand_default_block_markbad - [DEFAULT] mark a block bad
415 * @mtd: MTD device structure
416 * @ofs: offset from device start
418 * This is the default implementation, which can be overridden by
419 * a hardware specific driver.
421 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
423 struct nand_chip *this = mtd->priv;
424 uint8_t buf[2] = { 0, 0 };
428 /* Get block number */
429 block = ((int)ofs) >> this->bbt_erase_shift;
431 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
433 /* Do we have a flash based bad block table ? */
434 if (this->options & NAND_USE_FLASH_BBT)
435 return nand_update_bbt(mtd, ofs);
437 /* We write two bytes, so we dont have to mess with 16 bit access */
438 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
439 return nand_write_oob(mtd, ofs, 2, &retlen, buf);
443 * nand_check_wp - [GENERIC] check if the chip is write protected
444 * @mtd: MTD device structure
445 * Check, if the device is write protected
447 * The function expects, that the device is already selected
449 static int nand_check_wp(struct mtd_info *mtd)
451 struct nand_chip *this = mtd->priv;
452 /* Check the WP bit */
453 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
454 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
458 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
459 * @mtd: MTD device structure
460 * @ofs: offset from device start
461 * @getchip: 0, if the chip is already selected
462 * @allowbbt: 1, if its allowed to access the bbt area
464 * Check, if the block is bad. Either by reading the bad block table or
465 * calling of the scan function.
467 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
470 struct nand_chip *this = mtd->priv;
473 return this->block_bad(mtd, ofs, getchip);
475 /* Return info from the table */
476 return nand_isbad_bbt(mtd, ofs, allowbbt);
479 DEFINE_LED_TRIGGER(nand_led_trigger);
482 * Wait for the ready pin, after a command
483 * The timeout is catched later.
485 static void nand_wait_ready(struct mtd_info *mtd)
487 struct nand_chip *this = mtd->priv;
488 unsigned long timeo = jiffies + 2;
490 led_trigger_event(nand_led_trigger, LED_FULL);
491 /* wait until command is processed or timeout occures */
493 if (this->dev_ready(mtd))
495 touch_softlockup_watchdog();
496 } while (time_before(jiffies, timeo));
497 led_trigger_event(nand_led_trigger, LED_OFF);
501 * nand_command - [DEFAULT] Send command to NAND device
502 * @mtd: MTD device structure
503 * @command: the command to be sent
504 * @column: the column address for this command, -1 if none
505 * @page_addr: the page address for this command, -1 if none
507 * Send command to NAND device. This function is used for small page
508 * devices (256/512 Bytes per page)
510 static void nand_command(struct mtd_info *mtd, unsigned int command,
511 int column, int page_addr)
513 register struct nand_chip *this = mtd->priv;
514 int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
517 * Write out the command to the device.
519 if (command == NAND_CMD_SEQIN) {
522 if (column >= mtd->writesize) {
524 column -= mtd->writesize;
525 readcmd = NAND_CMD_READOOB;
526 } else if (column < 256) {
527 /* First 256 bytes --> READ0 */
528 readcmd = NAND_CMD_READ0;
531 readcmd = NAND_CMD_READ1;
533 this->cmd_ctrl(mtd, readcmd, ctrl);
534 ctrl &= ~NAND_CTRL_CHANGE;
536 this->cmd_ctrl(mtd, command, ctrl);
539 * Address cycle, when necessary
541 ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
542 /* Serially input address */
544 /* Adjust columns for 16 bit buswidth */
545 if (this->options & NAND_BUSWIDTH_16)
547 this->cmd_ctrl(mtd, column, ctrl);
548 ctrl &= ~NAND_CTRL_CHANGE;
550 if (page_addr != -1) {
551 this->cmd_ctrl(mtd, page_addr, ctrl);
552 ctrl &= ~NAND_CTRL_CHANGE;
553 this->cmd_ctrl(mtd, page_addr >> 8, ctrl);
554 /* One more address cycle for devices > 32MiB */
555 if (this->chipsize > (32 << 20))
556 this->cmd_ctrl(mtd, page_addr >> 16, ctrl);
558 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
561 * program and erase have their own busy handlers
562 * status and sequential in needs no delay
566 case NAND_CMD_PAGEPROG:
567 case NAND_CMD_ERASE1:
568 case NAND_CMD_ERASE2:
570 case NAND_CMD_STATUS:
571 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
577 udelay(this->chip_delay);
578 this->cmd_ctrl(mtd, NAND_CMD_STATUS,
579 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
580 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
581 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
584 /* This applies to read commands */
587 * If we don't have access to the busy pin, we apply the given
590 if (!this->dev_ready) {
591 udelay(this->chip_delay);
595 /* Apply this short delay always to ensure that we do wait tWB in
596 * any case on any machine. */
599 nand_wait_ready(mtd);
603 * nand_command_lp - [DEFAULT] Send command to NAND large page device
604 * @mtd: MTD device structure
605 * @command: the command to be sent
606 * @column: the column address for this command, -1 if none
607 * @page_addr: the page address for this command, -1 if none
609 * Send command to NAND device. This is the version for the new large page
610 * devices We dont have the separate regions as we have in the small page
611 * devices. We must emulate NAND_CMD_READOOB to keep the code compatible.
614 static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
615 int column, int page_addr)
617 register struct nand_chip *this = mtd->priv;
619 /* Emulate NAND_CMD_READOOB */
620 if (command == NAND_CMD_READOOB) {
621 column += mtd->writesize;
622 command = NAND_CMD_READ0;
625 /* Command latch cycle */
626 this->cmd_ctrl(mtd, command & 0xff,
627 NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
629 if (column != -1 || page_addr != -1) {
630 int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
632 /* Serially input address */
634 /* Adjust columns for 16 bit buswidth */
635 if (this->options & NAND_BUSWIDTH_16)
637 this->cmd_ctrl(mtd, column, ctrl);
638 ctrl &= ~NAND_CTRL_CHANGE;
639 this->cmd_ctrl(mtd, column >> 8, ctrl);
641 if (page_addr != -1) {
642 this->cmd_ctrl(mtd, page_addr, ctrl);
643 this->cmd_ctrl(mtd, page_addr >> 8,
644 NAND_NCE | NAND_ALE);
645 /* One more address cycle for devices > 128MiB */
646 if (this->chipsize > (128 << 20))
647 this->cmd_ctrl(mtd, page_addr >> 16,
648 NAND_NCE | NAND_ALE);
651 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
654 * program and erase have their own busy handlers
655 * status, sequential in, and deplete1 need no delay
659 case NAND_CMD_CACHEDPROG:
660 case NAND_CMD_PAGEPROG:
661 case NAND_CMD_ERASE1:
662 case NAND_CMD_ERASE2:
664 case NAND_CMD_STATUS:
665 case NAND_CMD_DEPLETE1:
669 * read error status commands require only a short delay
671 case NAND_CMD_STATUS_ERROR:
672 case NAND_CMD_STATUS_ERROR0:
673 case NAND_CMD_STATUS_ERROR1:
674 case NAND_CMD_STATUS_ERROR2:
675 case NAND_CMD_STATUS_ERROR3:
676 udelay(this->chip_delay);
682 udelay(this->chip_delay);
683 this->cmd_ctrl(mtd, NAND_CMD_STATUS, NAND_NCE | NAND_CLE);
684 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
685 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
689 this->cmd_ctrl(mtd, NAND_CMD_READSTART, NAND_NCE | NAND_CLE);
690 this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE);
692 /* This applies to read commands */
695 * If we don't have access to the busy pin, we apply the given
698 if (!this->dev_ready) {
699 udelay(this->chip_delay);
704 /* Apply this short delay always to ensure that we do wait tWB in
705 * any case on any machine. */
708 nand_wait_ready(mtd);
712 * nand_get_device - [GENERIC] Get chip for selected access
713 * @this: the nand chip descriptor
714 * @mtd: MTD device structure
715 * @new_state: the state which is requested
717 * Get the device and lock it for exclusive access
720 nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state)
722 spinlock_t *lock = &this->controller->lock;
723 wait_queue_head_t *wq = &this->controller->wq;
724 DECLARE_WAITQUEUE(wait, current);
728 /* Hardware controller shared among independend devices */
729 /* Hardware controller shared among independend devices */
730 if (!this->controller->active)
731 this->controller->active = this;
733 if (this->controller->active == this && this->state == FL_READY) {
734 this->state = new_state;
738 if (new_state == FL_PM_SUSPENDED) {
740 return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
742 set_current_state(TASK_UNINTERRUPTIBLE);
743 add_wait_queue(wq, &wait);
746 remove_wait_queue(wq, &wait);
751 * nand_wait - [DEFAULT] wait until the command is done
752 * @mtd: MTD device structure
753 * @this: NAND chip structure
754 * @state: state to select the max. timeout value
756 * Wait for command done. This applies to erase and program only
757 * Erase can take up to 400ms and program up to 20ms according to
758 * general NAND and SmartMedia specs
761 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
764 unsigned long timeo = jiffies;
767 if (state == FL_ERASING)
768 timeo += (HZ * 400) / 1000;
770 timeo += (HZ * 20) / 1000;
772 led_trigger_event(nand_led_trigger, LED_FULL);
774 /* Apply this short delay always to ensure that we do wait tWB in
775 * any case on any machine. */
778 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
779 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
781 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
783 while (time_before(jiffies, timeo)) {
784 /* Check, if we were interrupted */
785 if (this->state != state)
788 if (this->dev_ready) {
789 if (this->dev_ready(mtd))
792 if (this->read_byte(mtd) & NAND_STATUS_READY)
797 led_trigger_event(nand_led_trigger, LED_OFF);
799 status = (int)this->read_byte(mtd);
804 * nand_write_page - [GENERIC] write one page
805 * @mtd: MTD device structure
806 * @this: NAND chip structure
807 * @page: startpage inside the chip, must be called with (page & this->pagemask)
808 * @oob_buf: out of band data buffer
809 * @oobsel: out of band selecttion structre
810 * @cached: 1 = enable cached programming if supported by chip
812 * Nand_page_program function is used for write and writev !
813 * This function will always program a full page of data
814 * If you call it with a non page aligned buffer, you're lost :)
816 * Cached programming is not supported yet.
818 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page,
819 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int cached)
822 uint8_t ecc_code[32];
823 int eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
824 int *oob_config = oobsel->eccpos;
825 int datidx = 0, eccidx = 0, eccsteps = this->ecc.steps;
828 /* FIXME: Enable cached programming */
831 /* Send command to begin auto page programming */
832 this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
834 /* Write out complete page of data, take care of eccmode */
836 /* No ecc, write all */
838 printk(KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
839 this->write_buf(mtd, this->data_poi, mtd->writesize);
842 /* Software ecc 3/256, write all */
844 for (; eccsteps; eccsteps--) {
845 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
846 for (i = 0; i < 3; i++, eccidx++)
847 oob_buf[oob_config[eccidx]] = ecc_code[i];
848 datidx += this->ecc.size;
850 this->write_buf(mtd, this->data_poi, mtd->writesize);
853 eccbytes = this->ecc.bytes;
854 for (; eccsteps; eccsteps--) {
855 /* enable hardware ecc logic for write */
856 this->ecc.hwctl(mtd, NAND_ECC_WRITE);
857 this->write_buf(mtd, &this->data_poi[datidx], this->ecc.size);
858 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
859 for (i = 0; i < eccbytes; i++, eccidx++)
860 oob_buf[oob_config[eccidx]] = ecc_code[i];
861 /* If the hardware ecc provides syndromes then
862 * the ecc code must be written immidiately after
863 * the data bytes (words) */
864 if (this->options & NAND_HWECC_SYNDROME)
865 this->write_buf(mtd, ecc_code, eccbytes);
866 datidx += this->ecc.size;
871 /* Write out OOB data */
872 if (this->options & NAND_HWECC_SYNDROME)
873 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
875 this->write_buf(mtd, oob_buf, mtd->oobsize);
877 /* Send command to actually program the data */
878 this->cmdfunc(mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
881 /* call wait ready function */
882 status = this->waitfunc(mtd, this, FL_WRITING);
884 /* See if operation failed and additional status checks are available */
885 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
886 status = this->errstat(mtd, this, FL_WRITING, status, page);
889 /* See if device thinks it succeeded */
890 if (status & NAND_STATUS_FAIL) {
891 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
895 /* FIXME: Implement cached programming ! */
896 /* wait until cache is ready */
897 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
902 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
904 * nand_verify_pages - [GENERIC] verify the chip contents after a write
905 * @mtd: MTD device structure
906 * @this: NAND chip structure
907 * @page: startpage inside the chip, must be called with (page & this->pagemask)
908 * @numpages: number of pages to verify
909 * @oob_buf: out of band data buffer
910 * @oobsel: out of band selecttion structre
911 * @chipnr: number of the current chip
912 * @oobmode: 1 = full buffer verify, 0 = ecc only
914 * The NAND device assumes that it is always writing to a cleanly erased page.
915 * Hence, it performs its internal write verification only on bits that
916 * transitioned from 1 to 0. The device does NOT verify the whole page on a
917 * byte by byte basis. It is possible that the page was not completely erased
918 * or the page is becoming unusable due to wear. The read with ECC would catch
919 * the error later when the ECC page check fails, but we would rather catch
920 * it early in the page write stage. Better to write no data than invalid data.
922 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
923 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
925 int i, j, datidx = 0, oobofs = 0, res = -EIO;
926 int eccsteps = this->eccsteps;
930 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
932 /* Send command to read back the first page */
933 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
936 for (j = 0; j < eccsteps; j++) {
937 /* Loop through and verify the data */
938 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
939 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
942 datidx += mtd->eccsize;
943 /* Have we a hw generator layout ? */
946 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
947 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
950 oobofs += hweccbytes;
953 /* check, if we must compare all data or if we just have to
954 * compare the ecc bytes
957 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
958 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
962 /* Read always, else autoincrement fails */
963 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
965 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
966 int ecccnt = oobsel->eccbytes;
968 for (i = 0; i < ecccnt; i++) {
969 int idx = oobsel->eccpos[i];
970 if (oobdata[idx] != oob_buf[oobofs + idx]) {
971 DEBUG(MTD_DEBUG_LEVEL0, "%s: Failed ECC write verify, page 0x%08x, %6i bytes were succesful\n",
972 __FUNCTION__, page, i);
978 oobofs += mtd->oobsize - hweccbytes * eccsteps;
982 /* Apply delay or wait for ready/busy pin
983 * Do this before the AUTOINCR check, so no problems
984 * arise if a chip which does auto increment
985 * is marked as NOAUTOINCR by the board driver.
986 * Do this also before returning, so the chip is
987 * ready for the next command.
989 if (!this->dev_ready)
990 udelay(this->chip_delay);
992 nand_wait_ready(mtd);
994 /* All done, return happy */
998 /* Check, if the chip supports auto page increment */
999 if (!NAND_CANAUTOINCR(this))
1000 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1003 * Terminate the read command. We come here in case of an error
1004 * So we must issue a reset command.
1007 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1013 * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
1014 * @mtd: MTD device structure
1015 * @from: offset to read from
1016 * @len: number of bytes to read
1017 * @retlen: pointer to variable to store the number of read bytes
1018 * @buf: the databuffer to put data
1020 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1023 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1025 return nand_do_read_ecc(mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1029 * nand_do_read_ecc - [MTD Interface] Read data with ECC
1030 * @mtd: MTD device structure
1031 * @from: offset to read from
1032 * @len: number of bytes to read
1033 * @retlen: pointer to variable to store the number of read bytes
1034 * @buf: the databuffer to put data
1035 * @oob_buf: filesystem supplied oob data buffer (can be NULL)
1036 * @oobsel: oob selection structure
1037 * @flags: flag to indicate if nand_get_device/nand_release_device should be preformed
1038 * and how many corrected error bits are acceptable:
1039 * bits 0..7 - number of tolerable errors
1040 * bit 8 - 0 == do not get/release chip, 1 == get/release chip
1042 * NAND read with ECC
1044 int nand_do_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1045 size_t *retlen, uint8_t *buf, uint8_t *oob_buf, struct nand_oobinfo *oobsel, int flags)
1048 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1049 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1050 struct nand_chip *this = mtd->priv;
1051 uint8_t *data_poi, *oob_data = oob_buf;
1052 uint8_t ecc_calc[32];
1053 uint8_t ecc_code[32];
1054 int eccmode, eccsteps;
1055 int *oob_config, datidx;
1056 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1061 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1063 /* Do not allow reads past end of device */
1064 if ((from + len) > mtd->size) {
1065 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1070 /* Grab the lock and see if the device is available */
1071 if (flags & NAND_GET_DEVICE)
1072 nand_get_device(this, mtd, FL_READING);
1074 /* Autoplace of oob data ? Use the default placement scheme */
1075 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1076 oobsel = this->autooob;
1078 eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
1079 oob_config = oobsel->eccpos;
1081 /* Select the NAND device */
1082 chipnr = (int)(from >> this->chip_shift);
1083 this->select_chip(mtd, chipnr);
1085 /* First we calculate the starting page */
1086 realpage = (int)(from >> this->page_shift);
1087 page = realpage & this->pagemask;
1089 /* Get raw starting column */
1090 col = from & (mtd->writesize - 1);
1092 end = mtd->writesize;
1093 ecc = this->ecc.size;
1094 eccbytes = this->ecc.bytes;
1096 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1099 oobreadlen = mtd->oobsize;
1100 if (this->options & NAND_HWECC_SYNDROME)
1101 oobreadlen -= oobsel->eccbytes;
1103 /* Loop until all data read */
1104 while (read < len) {
1106 int aligned = (!col && (len - read) >= end);
1108 * If the read is not page aligned, we have to read into data buffer
1109 * due to ecc, else we read into return buffer direct
1112 data_poi = &buf[read];
1114 data_poi = this->data_buf;
1116 /* Check, if we have this page in the buffer
1118 * FIXME: Make it work when we must provide oob data too,
1119 * check the usage of data_buf oob field
1121 if (realpage == this->pagebuf && !oob_buf) {
1122 /* aligned read ? */
1124 memcpy(data_poi, this->data_buf, end);
1128 /* Check, if we must send the read command */
1130 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1134 /* get oob area, if we have no oob buffer from fs-driver */
1135 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1136 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1137 oob_data = &this->data_buf[end];
1139 eccsteps = this->ecc.steps;
1142 case NAND_ECC_NONE:{
1143 /* No ECC, Read in a page */
1144 static unsigned long lastwhinge = 0;
1145 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1147 "Reading data from NAND FLASH without ECC is not recommended\n");
1148 lastwhinge = jiffies;
1150 this->read_buf(mtd, data_poi, end);
1154 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1155 this->read_buf(mtd, data_poi, end);
1156 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += 3, datidx += ecc)
1157 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1161 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += eccbytes, datidx += ecc) {
1162 this->ecc.hwctl(mtd, NAND_ECC_READ);
1163 this->read_buf(mtd, &data_poi[datidx], ecc);
1165 /* HW ecc with syndrome calculation must read the
1166 * syndrome from flash immidiately after the data */
1168 /* Some hw ecc generators need to know when the
1169 * syndrome is read from flash */
1170 this->ecc.hwctl(mtd, NAND_ECC_READSYN);
1171 this->read_buf(mtd, &oob_data[i], eccbytes);
1172 /* We calc error correction directly, it checks the hw
1173 * generator for an error, reads back the syndrome and
1174 * does the error correction on the fly */
1175 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1176 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1177 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1178 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1182 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1189 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1191 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1195 /* Pick the ECC bytes out of the oob data */
1196 for (j = 0; j < oobsel->eccbytes; j++)
1197 ecc_code[j] = oob_data[oob_config[j]];
1199 /* correct data, if necessary */
1200 for (i = 0, j = 0, datidx = 0; i < this->ecc.steps; i++, datidx += ecc) {
1201 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1203 /* Get next chunk of ecc bytes */
1206 /* Check, if we have a fs supplied oob-buffer,
1207 * This is the legacy mode. Used by YAFFS1
1208 * Should go away some day
1210 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1211 int *p = (int *)(&oob_data[mtd->oobsize]);
1215 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1216 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1222 /* check, if we have a fs supplied oob-buffer */
1224 /* without autoplace. Legacy mode used by YAFFS1 */
1225 switch (oobsel->useecc) {
1226 case MTD_NANDECC_AUTOPLACE:
1227 case MTD_NANDECC_AUTOPL_USR:
1228 /* Walk through the autoplace chunks */
1229 for (i = 0; oobsel->oobfree[i][1]; i++) {
1230 int from = oobsel->oobfree[i][0];
1231 int num = oobsel->oobfree[i][1];
1232 memcpy(&oob_buf[oob], &oob_data[from], num);
1236 case MTD_NANDECC_PLACE:
1237 /* YAFFS1 legacy mode */
1238 oob_data += this->ecc.steps * sizeof(int);
1240 oob_data += mtd->oobsize;
1244 /* Partial page read, transfer data into fs buffer */
1246 for (j = col; j < end && read < len; j++)
1247 buf[read++] = data_poi[j];
1248 this->pagebuf = realpage;
1250 read += mtd->writesize;
1252 /* Apply delay or wait for ready/busy pin
1253 * Do this before the AUTOINCR check, so no problems
1254 * arise if a chip which does auto increment
1255 * is marked as NOAUTOINCR by the board driver.
1257 if (!this->dev_ready)
1258 udelay(this->chip_delay);
1260 nand_wait_ready(mtd);
1265 /* For subsequent reads align to page boundary. */
1267 /* Increment page address */
1270 page = realpage & this->pagemask;
1271 /* Check, if we cross a chip boundary */
1274 this->select_chip(mtd, -1);
1275 this->select_chip(mtd, chipnr);
1277 /* Check, if the chip supports auto page increment
1278 * or if we have hit a block boundary.
1280 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1284 /* Deselect and wake up anyone waiting on the device */
1285 if (flags & NAND_GET_DEVICE)
1286 nand_release_device(mtd);
1289 * Return success, if no ECC failures, else -EBADMSG
1290 * fs driver will take care of that, because
1291 * retlen == desired len and result == -EBADMSG
1294 return ecc_failed ? -EBADMSG : 0;
1298 * nand_read_oob - [MTD Interface] NAND read out-of-band
1299 * @mtd: MTD device structure
1300 * @from: offset to read from
1301 * @len: number of bytes to read
1302 * @retlen: pointer to variable to store the number of read bytes
1303 * @buf: the databuffer to put data
1305 * NAND read out-of-band data from the spare area
1307 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1309 int i, col, page, chipnr;
1310 struct nand_chip *this = mtd->priv;
1311 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1313 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1315 /* Shift to get page */
1316 page = (int)(from >> this->page_shift);
1317 chipnr = (int)(from >> this->chip_shift);
1319 /* Mask to get column */
1320 col = from & (mtd->oobsize - 1);
1322 /* Initialize return length value */
1325 /* Do not allow reads past end of device */
1326 if ((from + len) > mtd->size) {
1327 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1332 /* Grab the lock and see if the device is available */
1333 nand_get_device(this, mtd, FL_READING);
1335 /* Select the NAND device */
1336 this->select_chip(mtd, chipnr);
1338 /* Send the read command */
1339 this->cmdfunc(mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1341 * Read the data, if we read more than one page
1342 * oob data, let the device transfer the data !
1346 int thislen = mtd->oobsize - col;
1347 thislen = min_t(int, thislen, len);
1348 this->read_buf(mtd, &buf[i], thislen);
1356 /* Check, if we cross a chip boundary */
1357 if (!(page & this->pagemask)) {
1359 this->select_chip(mtd, -1);
1360 this->select_chip(mtd, chipnr);
1363 /* Apply delay or wait for ready/busy pin
1364 * Do this before the AUTOINCR check, so no problems
1365 * arise if a chip which does auto increment
1366 * is marked as NOAUTOINCR by the board driver.
1368 if (!this->dev_ready)
1369 udelay(this->chip_delay);
1371 nand_wait_ready(mtd);
1373 /* Check, if the chip supports auto page increment
1374 * or if we have hit a block boundary.
1376 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1377 /* For subsequent page reads set offset to 0 */
1378 this->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1383 /* Deselect and wake up anyone waiting on the device */
1384 nand_release_device(mtd);
1392 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1393 * @mtd: MTD device structure
1394 * @buf: temporary buffer
1395 * @from: offset to read from
1396 * @len: number of bytes to read
1397 * @ooblen: number of oob data bytes to read
1399 * Read raw data including oob into buffer
1401 int nand_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1403 struct nand_chip *this = mtd->priv;
1404 int page = (int)(from >> this->page_shift);
1405 int chip = (int)(from >> this->chip_shift);
1408 int pagesize = mtd->writesize + mtd->oobsize;
1409 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1411 /* Do not allow reads past end of device */
1412 if ((from + len) > mtd->size) {
1413 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1417 /* Grab the lock and see if the device is available */
1418 nand_get_device(this, mtd, FL_READING);
1420 this->select_chip(mtd, chip);
1422 /* Add requested oob length */
1427 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1430 this->read_buf(mtd, &buf[cnt], pagesize);
1436 if (!this->dev_ready)
1437 udelay(this->chip_delay);
1439 nand_wait_ready(mtd);
1441 /* Check, if the chip supports auto page increment */
1442 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1446 /* Deselect and wake up anyone waiting on the device */
1447 nand_release_device(mtd);
1452 * nand_write_raw - [GENERIC] Write raw data including oob
1453 * @mtd: MTD device structure
1454 * @buf: source buffer
1455 * @to: offset to write to
1456 * @len: number of bytes to write
1457 * @buf: source buffer
1460 * Write raw data including oob
1462 int nand_write_raw(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1463 uint8_t *buf, uint8_t *oob)
1465 struct nand_chip *this = mtd->priv;
1466 int page = (int)(to >> this->page_shift);
1467 int chip = (int)(to >> this->chip_shift);
1472 /* Do not allow writes past end of device */
1473 if ((to + len) > mtd->size) {
1474 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt write "
1475 "beyond end of device\n");
1479 /* Grab the lock and see if the device is available */
1480 nand_get_device(this, mtd, FL_WRITING);
1482 this->select_chip(mtd, chip);
1483 this->data_poi = buf;
1485 while (len != *retlen) {
1486 ret = nand_write_page(mtd, this, page, oob, &mtd->oobinfo, 0);
1490 *retlen += mtd->writesize;
1491 this->data_poi += mtd->writesize;
1492 oob += mtd->oobsize;
1495 /* Deselect and wake up anyone waiting on the device */
1496 nand_release_device(mtd);
1499 EXPORT_SYMBOL_GPL(nand_write_raw);
1502 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1503 * @mtd: MTD device structure
1504 * @fsbuf: buffer given by fs driver
1505 * @oobsel: out of band selection structre
1506 * @autoplace: 1 = place given buffer into the oob bytes
1507 * @numpages: number of pages to prepare
1510 * 1. Filesystem buffer available and autoplacement is off,
1511 * return filesystem buffer
1512 * 2. No filesystem buffer or autoplace is off, return internal
1514 * 3. Filesystem buffer is given and autoplace selected
1515 * put data from fs buffer into internal buffer and
1516 * retrun internal buffer
1518 * Note: The internal buffer is filled with 0xff. This must
1519 * be done only once, when no autoplacement happens
1520 * Autoplacement sets the buffer dirty flag, which
1521 * forces the 0xff fill before using the buffer again.
1524 static uint8_t *nand_prepare_oobbuf(struct mtd_info *mtd, uint8_t *fsbuf, struct nand_oobinfo *oobsel,
1525 int autoplace, int numpages)
1527 struct nand_chip *this = mtd->priv;
1530 /* Zero copy fs supplied buffer */
1531 if (fsbuf && !autoplace)
1534 /* Check, if the buffer must be filled with ff again */
1535 if (this->oobdirty) {
1536 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1540 /* If we have no autoplacement or no fs buffer use the internal one */
1541 if (!autoplace || !fsbuf)
1542 return this->oob_buf;
1544 /* Walk through the pages and place the data */
1547 while (numpages--) {
1548 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1549 int to = ofs + oobsel->oobfree[i][0];
1550 int num = oobsel->oobfree[i][1];
1551 memcpy(&this->oob_buf[to], fsbuf, num);
1555 ofs += mtd->oobavail;
1557 return this->oob_buf;
1560 #define NOTALIGNED(x) (x & (mtd->writesize-1)) != 0
1563 * nand_write - [MTD Interface] NAND write with ECC
1564 * @mtd: MTD device structure
1565 * @to: offset to write to
1566 * @len: number of bytes to write
1567 * @retlen: pointer to variable to store the number of written bytes
1568 * @buf: the data to write
1570 * NAND write with ECC
1572 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
1573 size_t *retlen, const uint8_t *buf)
1575 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1576 int autoplace = 0, numpages, totalpages;
1577 struct nand_chip *this = mtd->priv;
1578 uint8_t *oobbuf, *bufstart, *eccbuf = NULL;
1579 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1580 struct nand_oobinfo *oobsel = &mtd->oobinfo;
1582 DEBUG(MTD_DEBUG_LEVEL3, "nand_write: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1584 /* Initialize retlen, in case of early exit */
1587 /* Do not allow write past end of device */
1588 if ((to + len) > mtd->size) {
1589 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: Attempt to write past end of page\n");
1593 /* reject writes, which are not page aligned */
1594 if (NOTALIGNED(to) || NOTALIGNED(len)) {
1595 printk(KERN_NOTICE "nand_write: Attempt to write not page aligned data\n");
1599 /* Grab the lock and see if the device is available */
1600 nand_get_device(this, mtd, FL_WRITING);
1602 /* Calculate chipnr */
1603 chipnr = (int)(to >> this->chip_shift);
1604 /* Select the NAND device */
1605 this->select_chip(mtd, chipnr);
1607 /* Check, if it is write protected */
1608 if (nand_check_wp(mtd))
1611 /* Autoplace of oob data ? Use the default placement scheme */
1612 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1613 oobsel = this->autooob;
1616 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1619 /* Setup variables and oob buffer */
1620 totalpages = len >> this->page_shift;
1621 page = (int)(to >> this->page_shift);
1622 /* Invalidate the page cache, if we write to the cached page */
1623 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1626 /* Set it relative to chip */
1627 page &= this->pagemask;
1629 /* Calc number of pages we can write in one go */
1630 numpages = min(ppblock - (startpage & (ppblock - 1)), totalpages);
1631 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1632 bufstart = (uint8_t *) buf;
1634 /* Loop until all data is written */
1635 while (written < len) {
1637 this->data_poi = (uint8_t *) &buf[written];
1638 /* Write one page. If this is the last page to write
1639 * or the last page in this block, then use the
1640 * real pageprogram command, else select cached programming
1641 * if supported by the chip.
1643 ret = nand_write_page(mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1645 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: write_page failed %d\n", ret);
1649 oob += mtd->oobsize;
1650 /* Update written bytes count */
1651 written += mtd->writesize;
1655 /* Increment page address */
1658 /* Have we hit a block boundary ? Then we have to verify and
1659 * if verify is ok, we have to setup the oob buffer for
1662 if (!(page & (ppblock - 1))) {
1664 this->data_poi = bufstart;
1665 ret = nand_verify_pages(mtd, this, startpage, page - startpage,
1666 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1668 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1673 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1675 eccbuf += (page - startpage) * ofs;
1676 totalpages -= page - startpage;
1677 numpages = min(totalpages, ppblock);
1678 page &= this->pagemask;
1680 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1682 /* Check, if we cross a chip boundary */
1685 this->select_chip(mtd, -1);
1686 this->select_chip(mtd, chipnr);
1690 /* Verify the remaining pages */
1692 this->data_poi = bufstart;
1693 ret = nand_verify_pages(mtd, this, startpage, totalpages, oobbuf, oobsel, chipnr, (eccbuf != NULL));
1697 DEBUG(MTD_DEBUG_LEVEL0, "nand_write: verify_pages failed %d\n", ret);
1700 /* Deselect and wake up anyone waiting on the device */
1701 nand_release_device(mtd);
1707 * nand_write_oob - [MTD Interface] NAND write out-of-band
1708 * @mtd: MTD device structure
1709 * @to: offset to write to
1710 * @len: number of bytes to write
1711 * @retlen: pointer to variable to store the number of written bytes
1712 * @buf: the data to write
1714 * NAND write out-of-band
1716 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const uint8_t *buf)
1718 int column, page, status, ret = -EIO, chipnr;
1719 struct nand_chip *this = mtd->priv;
1721 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1723 /* Shift to get page */
1724 page = (int)(to >> this->page_shift);
1725 chipnr = (int)(to >> this->chip_shift);
1727 /* Mask to get column */
1728 column = to & (mtd->oobsize - 1);
1730 /* Initialize return length value */
1733 /* Do not allow write past end of page */
1734 if ((column + len) > mtd->oobsize) {
1735 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1739 /* Grab the lock and see if the device is available */
1740 nand_get_device(this, mtd, FL_WRITING);
1742 /* Select the NAND device */
1743 this->select_chip(mtd, chipnr);
1745 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1746 in one of my DiskOnChip 2000 test units) will clear the whole
1747 data page too if we don't do this. I have no clue why, but
1748 I seem to have 'fixed' it in the doc2000 driver in
1749 August 1999. dwmw2. */
1750 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1752 /* Check, if it is write protected */
1753 if (nand_check_wp(mtd))
1756 /* Invalidate the page cache, if we write to the cached page */
1757 if (page == this->pagebuf)
1760 if (NAND_MUST_PAD(this)) {
1761 /* Write out desired data */
1762 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page & this->pagemask);
1763 /* prepad 0xff for partial programming */
1764 this->write_buf(mtd, ffchars, column);
1766 this->write_buf(mtd, buf, len);
1767 /* postpad 0xff for partial programming */
1768 this->write_buf(mtd, ffchars, mtd->oobsize - (len + column));
1770 /* Write out desired data */
1771 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize + column, page & this->pagemask);
1773 this->write_buf(mtd, buf, len);
1775 /* Send command to program the OOB data */
1776 this->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1778 status = this->waitfunc(mtd, this, FL_WRITING);
1780 /* See if device thinks it succeeded */
1781 if (status & NAND_STATUS_FAIL) {
1782 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1789 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1790 /* Send command to read back the data */
1791 this->cmdfunc(mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1793 if (this->verify_buf(mtd, buf, len)) {
1794 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1801 /* Deselect and wake up anyone waiting on the device */
1802 nand_release_device(mtd);
1808 * single_erease_cmd - [GENERIC] NAND standard block erase command function
1809 * @mtd: MTD device structure
1810 * @page: the page address of the block which will be erased
1812 * Standard erase command for NAND chips
1814 static void single_erase_cmd(struct mtd_info *mtd, int page)
1816 struct nand_chip *this = mtd->priv;
1817 /* Send commands to erase a block */
1818 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1819 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1823 * multi_erease_cmd - [GENERIC] AND specific block erase command function
1824 * @mtd: MTD device structure
1825 * @page: the page address of the block which will be erased
1827 * AND multi block erase command function
1828 * Erase 4 consecutive blocks
1830 static void multi_erase_cmd(struct mtd_info *mtd, int page)
1832 struct nand_chip *this = mtd->priv;
1833 /* Send commands to erase a block */
1834 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1835 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1836 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
1837 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
1838 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
1842 * nand_erase - [MTD Interface] erase block(s)
1843 * @mtd: MTD device structure
1844 * @instr: erase instruction
1846 * Erase one ore more blocks
1848 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
1850 return nand_erase_nand(mtd, instr, 0);
1853 #define BBT_PAGE_MASK 0xffffff3f
1855 * nand_erase_intern - [NAND Interface] erase block(s)
1856 * @mtd: MTD device structure
1857 * @instr: erase instruction
1858 * @allowbbt: allow erasing the bbt area
1860 * Erase one ore more blocks
1862 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
1864 int page, len, status, pages_per_block, ret, chipnr;
1865 struct nand_chip *this = mtd->priv;
1866 int rewrite_bbt[NAND_MAX_CHIPS]={0}; /* flags to indicate the page, if bbt needs to be rewritten. */
1867 unsigned int bbt_masked_page; /* bbt mask to compare to page being erased. */
1868 /* It is used to see if the current page is in the same */
1869 /* 256 block group and the same bank as the bbt. */
1871 DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n", (unsigned int)instr->addr, (unsigned int)instr->len);
1873 /* Start address must align on block boundary */
1874 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
1875 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
1879 /* Length must align on block boundary */
1880 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
1881 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
1885 /* Do not allow erase past end of device */
1886 if ((instr->len + instr->addr) > mtd->size) {
1887 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
1891 instr->fail_addr = 0xffffffff;
1893 /* Grab the lock and see if the device is available */
1894 nand_get_device(this, mtd, FL_ERASING);
1896 /* Shift to get first page */
1897 page = (int)(instr->addr >> this->page_shift);
1898 chipnr = (int)(instr->addr >> this->chip_shift);
1900 /* Calculate pages in each block */
1901 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
1903 /* Select the NAND device */
1904 this->select_chip(mtd, chipnr);
1906 /* Check the WP bit */
1907 /* Check, if it is write protected */
1908 if (nand_check_wp(mtd)) {
1909 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
1910 instr->state = MTD_ERASE_FAILED;
1914 /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
1915 if (this->options & BBT_AUTO_REFRESH) {
1916 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
1918 bbt_masked_page = 0xffffffff; /* should not match anything */
1921 /* Loop through the pages */
1924 instr->state = MTD_ERASING;
1927 /* Check if we have a bad block, we do not erase bad blocks ! */
1928 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
1929 printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
1930 instr->state = MTD_ERASE_FAILED;
1934 /* Invalidate the page cache, if we erase the block which contains
1935 the current cached page */
1936 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
1939 this->erase_cmd(mtd, page & this->pagemask);
1941 status = this->waitfunc(mtd, this, FL_ERASING);
1943 /* See if operation failed and additional status checks are available */
1944 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
1945 status = this->errstat(mtd, this, FL_ERASING, status, page);
1948 /* See if block erase succeeded */
1949 if (status & NAND_STATUS_FAIL) {
1950 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
1951 instr->state = MTD_ERASE_FAILED;
1952 instr->fail_addr = (page << this->page_shift);
1956 /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
1957 if (this->options & BBT_AUTO_REFRESH) {
1958 if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
1959 (page != this->bbt_td->pages[chipnr])) {
1960 rewrite_bbt[chipnr] = (page << this->page_shift);
1964 /* Increment page address and decrement length */
1965 len -= (1 << this->phys_erase_shift);
1966 page += pages_per_block;
1968 /* Check, if we cross a chip boundary */
1969 if (len && !(page & this->pagemask)) {
1971 this->select_chip(mtd, -1);
1972 this->select_chip(mtd, chipnr);
1974 /* if BBT requires refresh and BBT-PERCHIP,
1975 * set the BBT page mask to see if this BBT should be rewritten */
1976 if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
1977 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
1982 instr->state = MTD_ERASE_DONE;
1986 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
1987 /* Do call back function */
1989 mtd_erase_callback(instr);
1991 /* Deselect and wake up anyone waiting on the device */
1992 nand_release_device(mtd);
1994 /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
1995 if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
1996 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
1997 if (rewrite_bbt[chipnr]) {
1998 /* update the BBT for chip */
1999 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2000 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2001 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2006 /* Return more or less happy */
2011 * nand_sync - [MTD Interface] sync
2012 * @mtd: MTD device structure
2014 * Sync is actually a wait for chip ready function
2016 static void nand_sync(struct mtd_info *mtd)
2018 struct nand_chip *this = mtd->priv;
2020 DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2022 /* Grab the lock and see if the device is available */
2023 nand_get_device(this, mtd, FL_SYNCING);
2024 /* Release it and go back */
2025 nand_release_device(mtd);
2029 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2030 * @mtd: MTD device structure
2031 * @ofs: offset relative to mtd start
2033 static int nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2035 /* Check for invalid offset */
2036 if (ofs > mtd->size)
2039 return nand_block_checkbad(mtd, ofs, 1, 0);
2043 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2044 * @mtd: MTD device structure
2045 * @ofs: offset relative to mtd start
2047 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2049 struct nand_chip *this = mtd->priv;
2052 if ((ret = nand_block_isbad(mtd, ofs))) {
2053 /* If it was bad already, return success and do nothing. */
2059 return this->block_markbad(mtd, ofs);
2063 * nand_suspend - [MTD Interface] Suspend the NAND flash
2064 * @mtd: MTD device structure
2066 static int nand_suspend(struct mtd_info *mtd)
2068 struct nand_chip *this = mtd->priv;
2070 return nand_get_device(this, mtd, FL_PM_SUSPENDED);
2074 * nand_resume - [MTD Interface] Resume the NAND flash
2075 * @mtd: MTD device structure
2077 static void nand_resume(struct mtd_info *mtd)
2079 struct nand_chip *this = mtd->priv;
2081 if (this->state == FL_PM_SUSPENDED)
2082 nand_release_device(mtd);
2084 printk(KERN_ERR "nand_resume() called for a chip which is not "
2085 "in suspended state\n");
2089 * Free allocated data structures
2091 static void nand_free_kmem(struct nand_chip *this)
2093 /* Buffer allocated by nand_scan ? */
2094 if (this->options & NAND_OOBBUF_ALLOC)
2095 kfree(this->oob_buf);
2096 /* Buffer allocated by nand_scan ? */
2097 if (this->options & NAND_DATABUF_ALLOC)
2098 kfree(this->data_buf);
2099 /* Controller allocated by nand_scan ? */
2100 if (this->options & NAND_CONTROLLER_ALLOC)
2101 kfree(this->controller);
2105 * Allocate buffers and data structures
2107 static int nand_allocate_kmem(struct mtd_info *mtd, struct nand_chip *this)
2111 if (!this->oob_buf) {
2112 len = mtd->oobsize <<
2113 (this->phys_erase_shift - this->page_shift);
2114 this->oob_buf = kmalloc(len, GFP_KERNEL);
2117 this->options |= NAND_OOBBUF_ALLOC;
2120 if (!this->data_buf) {
2121 len = mtd->writesize + mtd->oobsize;
2122 this->data_buf = kmalloc(len, GFP_KERNEL);
2123 if (!this->data_buf)
2125 this->options |= NAND_DATABUF_ALLOC;
2128 if (!this->controller) {
2129 this->controller = kzalloc(sizeof(struct nand_hw_control),
2131 if (!this->controller)
2133 this->options |= NAND_CONTROLLER_ALLOC;
2138 printk(KERN_ERR "nand_scan(): Cannot allocate buffers\n");
2139 nand_free_kmem(this);
2144 * Set default functions
2146 static void nand_set_defaults(struct nand_chip *this, int busw)
2148 /* check for proper chip_delay setup, set 20us if not */
2149 if (!this->chip_delay)
2150 this->chip_delay = 20;
2152 /* check, if a user supplied command function given */
2153 if (this->cmdfunc == NULL)
2154 this->cmdfunc = nand_command;
2156 /* check, if a user supplied wait function given */
2157 if (this->waitfunc == NULL)
2158 this->waitfunc = nand_wait;
2160 if (!this->select_chip)
2161 this->select_chip = nand_select_chip;
2162 if (!this->read_byte)
2163 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2164 if (!this->read_word)
2165 this->read_word = nand_read_word;
2166 if (!this->block_bad)
2167 this->block_bad = nand_block_bad;
2168 if (!this->block_markbad)
2169 this->block_markbad = nand_default_block_markbad;
2170 if (!this->write_buf)
2171 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2172 if (!this->read_buf)
2173 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2174 if (!this->verify_buf)
2175 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2176 if (!this->scan_bbt)
2177 this->scan_bbt = nand_default_bbt;
2181 * Get the flash and manufacturer id and lookup if the typ is supported
2183 static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
2184 struct nand_chip *this,
2185 int busw, int *maf_id)
2187 struct nand_flash_dev *type = NULL;
2188 int i, dev_id, maf_idx;
2190 /* Select the device */
2191 this->select_chip(mtd, 0);
2193 /* Send the command for reading device ID */
2194 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2196 /* Read manufacturer and device IDs */
2197 *maf_id = this->read_byte(mtd);
2198 dev_id = this->read_byte(mtd);
2200 /* Lookup the flash id */
2201 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2202 if (dev_id == nand_flash_ids[i].id) {
2203 type = &nand_flash_ids[i];
2209 return ERR_PTR(-ENODEV);
2211 this->chipsize = nand_flash_ids[i].chipsize << 20;
2213 /* Newer devices have all the information in additional id bytes */
2214 if (!nand_flash_ids[i].pagesize) {
2216 /* The 3rd id byte contains non relevant data ATM */
2217 extid = this->read_byte(mtd);
2218 /* The 4th id byte is the important one */
2219 extid = this->read_byte(mtd);
2221 mtd->writesize = 1024 << (extid & 0x3);
2224 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->writesize >> 9);
2226 /* Calc blocksize. Blocksize is multiples of 64KiB */
2227 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2229 /* Get buswidth information */
2230 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2234 * Old devices have this data hardcoded in the device id table
2236 mtd->erasesize = nand_flash_ids[i].erasesize;
2237 mtd->writesize = nand_flash_ids[i].pagesize;
2238 mtd->oobsize = mtd->writesize / 32;
2239 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2242 /* Try to identify manufacturer */
2243 for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_id++) {
2244 if (nand_manuf_ids[maf_idx].id == *maf_id)
2249 * Check, if buswidth is correct. Hardware drivers should set
2252 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2253 printk(KERN_INFO "NAND device: Manufacturer ID:"
2254 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
2255 dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
2256 printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
2257 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2259 return ERR_PTR(-EINVAL);
2262 /* Calculate the address shift from the page size */
2263 this->page_shift = ffs(mtd->writesize) - 1;
2264 /* Convert chipsize to number of pages per chip -1. */
2265 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2267 this->bbt_erase_shift = this->phys_erase_shift =
2268 ffs(mtd->erasesize) - 1;
2269 this->chip_shift = ffs(this->chipsize) - 1;
2271 /* Set the bad block position */
2272 this->badblockpos = mtd->writesize > 512 ?
2273 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2275 /* Get chip options, preserve non chip based options */
2276 this->options &= ~NAND_CHIPOPTIONS_MSK;
2277 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2280 * Set this as a default. Board drivers can override it, if necessary
2282 this->options |= NAND_NO_AUTOINCR;
2284 /* Check if this is a not a samsung device. Do not clear the
2285 * options for chips which are not having an extended id.
2287 if (*maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2288 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2290 /* Check for AND chips with 4 page planes */
2291 if (this->options & NAND_4PAGE_ARRAY)
2292 this->erase_cmd = multi_erase_cmd;
2294 this->erase_cmd = single_erase_cmd;
2296 /* Do not replace user supplied command function ! */
2297 if (mtd->writesize > 512 && this->cmdfunc == nand_command)
2298 this->cmdfunc = nand_command_lp;
2300 printk(KERN_INFO "NAND device: Manufacturer ID:"
2301 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, dev_id,
2302 nand_manuf_ids[maf_idx].name, type->name);
2307 /* module_text_address() isn't exported, and it's mostly a pointless
2308 test if this is a module _anyway_ -- they'd have to try _really_ hard
2309 to call us from in-kernel code if the core NAND support is modular. */
2311 #define caller_is_module() (1)
2313 #define caller_is_module() \
2314 module_text_address((unsigned long)__builtin_return_address(0))
2318 * nand_scan - [NAND Interface] Scan for the NAND device
2319 * @mtd: MTD device structure
2320 * @maxchips: Number of chips to scan for
2322 * This fills out all the uninitialized function pointers
2323 * with the defaults.
2324 * The flash ID is read and the mtd/chip structures are
2325 * filled with the appropriate values. Buffers are allocated if
2326 * they are not provided by the board driver
2327 * The mtd->owner field must be set to the module of the caller
2330 int nand_scan(struct mtd_info *mtd, int maxchips)
2332 int i, busw, nand_maf_id;
2333 struct nand_chip *this = mtd->priv;
2334 struct nand_flash_dev *type;
2336 /* Many callers got this wrong, so check for it for a while... */
2337 if (!mtd->owner && caller_is_module()) {
2338 printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
2342 /* Get buswidth to select the correct functions */
2343 busw = this->options & NAND_BUSWIDTH_16;
2344 /* Set the default functions */
2345 nand_set_defaults(this, busw);
2347 /* Read the flash type */
2348 type = nand_get_flash_type(mtd, this, busw, &nand_maf_id);
2351 printk(KERN_WARNING "No NAND device found!!!\n");
2352 this->select_chip(mtd, -1);
2353 return PTR_ERR(type);
2356 /* Check for a chip array */
2357 for (i = 1; i < maxchips; i++) {
2358 this->select_chip(mtd, i);
2359 /* Send the command for reading device ID */
2360 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2361 /* Read manufacturer and device IDs */
2362 if (nand_maf_id != this->read_byte(mtd) ||
2363 type->id != this->read_byte(mtd))
2367 printk(KERN_INFO "%d NAND chips detected\n", i);
2369 /* Store the number of chips and calc total size for mtd */
2371 mtd->size = i * this->chipsize;
2373 /* Allocate buffers and data structures */
2374 if (nand_allocate_kmem(mtd, this))
2377 /* Preset the internal oob buffer */
2378 memset(this->oob_buf, 0xff,
2379 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2382 * If no default placement scheme is given, select an appropriate one
2384 if (!this->autooob) {
2385 switch (mtd->oobsize) {
2387 this->autooob = &nand_oob_8;
2390 this->autooob = &nand_oob_16;
2393 this->autooob = &nand_oob_64;
2396 printk(KERN_WARNING "No oob scheme defined for "
2397 "oobsize %d\n", mtd->oobsize);
2403 * The number of bytes available for the filesystem to place fs
2404 * dependend oob data
2407 for (i = 0; this->autooob->oobfree[i][1]; i++)
2408 mtd->oobavail += this->autooob->oobfree[i][1];
2411 * check ECC mode, default to software if 3byte/512byte hardware ECC is
2412 * selected and we have 256 byte pagesize fallback to software ECC
2414 switch (this->ecc.mode) {
2416 case NAND_ECC_HW_SYNDROME:
2417 if (!this->ecc.calculate || !this->ecc.correct ||
2419 printk(KERN_WARNING "No ECC functions supplied, "
2420 "Hardware ECC not possible\n");
2423 if (mtd->writesize >= this->ecc.size)
2425 printk(KERN_WARNING "%d byte HW ECC not possible on "
2426 "%d byte page size, fallback to SW ECC\n",
2427 this->ecc.size, mtd->writesize);
2428 this->ecc.mode = NAND_ECC_SOFT;
2431 this->ecc.calculate = nand_calculate_ecc;
2432 this->ecc.correct = nand_correct_data;
2433 this->ecc.size = 256;
2434 this->ecc.bytes = 3;
2438 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
2439 "This is not recommended !!\n");
2440 this->ecc.size = mtd->writesize;
2441 this->ecc.bytes = 0;
2444 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
2450 * Set the number of read / write steps for one page depending on ECC
2453 this->ecc.steps = mtd->writesize / this->ecc.size;
2454 if(this->ecc.steps * this->ecc.size != mtd->writesize) {
2455 printk(KERN_WARNING "Invalid ecc parameters\n");
2459 /* Initialize state, waitqueue and spinlock */
2460 this->state = FL_READY;
2461 init_waitqueue_head(&this->controller->wq);
2462 spin_lock_init(&this->controller->lock);
2464 /* De-select the device */
2465 this->select_chip(mtd, -1);
2467 /* Invalidate the pagebuffer reference */
2470 /* Fill in remaining MTD driver data */
2471 mtd->type = MTD_NANDFLASH;
2472 mtd->flags = MTD_CAP_NANDFLASH;
2473 mtd->ecctype = MTD_ECC_SW;
2474 mtd->erase = nand_erase;
2476 mtd->unpoint = NULL;
2477 mtd->read = nand_read;
2478 mtd->write = nand_write;
2479 mtd->read_oob = nand_read_oob;
2480 mtd->write_oob = nand_write_oob;
2481 mtd->sync = nand_sync;
2484 mtd->suspend = nand_suspend;
2485 mtd->resume = nand_resume;
2486 mtd->block_isbad = nand_block_isbad;
2487 mtd->block_markbad = nand_block_markbad;
2489 /* and make the autooob the default one */
2490 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2492 /* Check, if we should skip the bad block table scan */
2493 if (this->options & NAND_SKIP_BBTSCAN)
2496 /* Build bad block table */
2497 return this->scan_bbt(mtd);
2501 * nand_release - [NAND Interface] Free resources held by the NAND device
2502 * @mtd: MTD device structure
2504 void nand_release(struct mtd_info *mtd)
2506 struct nand_chip *this = mtd->priv;
2508 #ifdef CONFIG_MTD_PARTITIONS
2509 /* Deregister partitions */
2510 del_mtd_partitions(mtd);
2512 /* Deregister the device */
2513 del_mtd_device(mtd);
2515 /* Free bad block table memory */
2518 nand_free_kmem(this);
2521 EXPORT_SYMBOL_GPL(nand_scan);
2522 EXPORT_SYMBOL_GPL(nand_release);
2524 static int __init nand_base_init(void)
2526 led_trigger_register_simple("nand-disk", &nand_led_trigger);
2530 static void __exit nand_base_exit(void)
2532 led_trigger_unregister_simple(nand_led_trigger);
2535 module_init(nand_base_init);
2536 module_exit(nand_base_exit);
2538 MODULE_LICENSE("GPL");
2539 MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2540 MODULE_DESCRIPTION("Generic NAND flash driver code");