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_ecc(struct mtd_info *mtd, loff_t from, size_t len,
143 size_t *retlen, uint8_t *buf, uint8_t *eccbuf,
144 struct nand_oobinfo *oobsel);
145 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
146 size_t *retlen, uint8_t *buf);
147 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
148 size_t *retlen, const uint8_t *buf);
149 static int nand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
150 size_t *retlen, const uint8_t *buf, uint8_t *eccbuf,
151 struct nand_oobinfo *oobsel);
152 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
153 size_t *retlen, const uint8_t *buf);
154 static int nand_writev(struct mtd_info *mtd, const struct kvec *vecs,
155 unsigned long count, loff_t to, size_t *retlen);
156 static int nand_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs,
157 unsigned long count, loff_t to, size_t *retlen,
158 uint8_t *eccbuf, struct nand_oobinfo *oobsel);
159 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr);
160 static void nand_sync(struct mtd_info *mtd);
162 /* Some internal functions */
163 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this,
164 int page, uint8_t * oob_buf,
165 struct nand_oobinfo *oobsel, int mode);
166 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
167 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this,
168 int page, int numpages, uint8_t *oob_buf,
169 struct nand_oobinfo *oobsel, int chipnr,
172 #define nand_verify_pages(...) (0)
175 static int nand_get_device(struct nand_chip *this, struct mtd_info *mtd,
179 * nand_release_device - [GENERIC] release chip
180 * @mtd: MTD device structure
182 * Deselect, release chip lock and wake up anyone waiting on the device
184 static void nand_release_device(struct mtd_info *mtd)
186 struct nand_chip *this = mtd->priv;
188 /* De-select the NAND device */
189 this->select_chip(mtd, -1);
191 /* Release the controller and the chip */
192 spin_lock(&this->controller->lock);
193 this->controller->active = NULL;
194 this->state = FL_READY;
195 wake_up(&this->controller->wq);
196 spin_unlock(&this->controller->lock);
200 * nand_read_byte - [DEFAULT] read one byte from the chip
201 * @mtd: MTD device structure
203 * Default read function for 8bit buswith
205 static uint8_t nand_read_byte(struct mtd_info *mtd)
207 struct nand_chip *this = mtd->priv;
208 return readb(this->IO_ADDR_R);
212 * nand_write_byte - [DEFAULT] write one byte to the chip
213 * @mtd: MTD device structure
214 * @byte: pointer to data byte to write
216 * Default write function for 8it buswith
218 static void nand_write_byte(struct mtd_info *mtd, uint8_t byte)
220 struct nand_chip *this = mtd->priv;
221 writeb(byte, this->IO_ADDR_W);
225 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
226 * @mtd: MTD device structure
228 * Default read function for 16bit buswith with
229 * endianess conversion
231 static uint8_t nand_read_byte16(struct mtd_info *mtd)
233 struct nand_chip *this = mtd->priv;
234 return (uint8_t) cpu_to_le16(readw(this->IO_ADDR_R));
238 * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
239 * @mtd: MTD device structure
240 * @byte: pointer to data byte to write
242 * Default write function for 16bit buswith with
243 * endianess conversion
245 static void nand_write_byte16(struct mtd_info *mtd, uint8_t byte)
247 struct nand_chip *this = mtd->priv;
248 writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
252 * nand_read_word - [DEFAULT] read one word from the chip
253 * @mtd: MTD device structure
255 * Default read function for 16bit buswith without
256 * endianess conversion
258 static u16 nand_read_word(struct mtd_info *mtd)
260 struct nand_chip *this = mtd->priv;
261 return readw(this->IO_ADDR_R);
265 * nand_write_word - [DEFAULT] write one word to the chip
266 * @mtd: MTD device structure
267 * @word: data word to write
269 * Default write function for 16bit buswith without
270 * endianess conversion
272 static void nand_write_word(struct mtd_info *mtd, u16 word)
274 struct nand_chip *this = mtd->priv;
275 writew(word, this->IO_ADDR_W);
279 * nand_select_chip - [DEFAULT] control CE line
280 * @mtd: MTD device structure
281 * @chip: chipnumber to select, -1 for deselect
283 * Default select function for 1 chip devices.
285 static void nand_select_chip(struct mtd_info *mtd, int chip)
287 struct nand_chip *this = mtd->priv;
290 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
293 this->hwcontrol(mtd, NAND_CTL_SETNCE);
302 * nand_write_buf - [DEFAULT] write buffer to chip
303 * @mtd: MTD device structure
305 * @len: number of bytes to write
307 * Default write function for 8bit buswith
309 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
312 struct nand_chip *this = mtd->priv;
314 for (i = 0; i < len; i++)
315 writeb(buf[i], this->IO_ADDR_W);
319 * nand_read_buf - [DEFAULT] read chip data into buffer
320 * @mtd: MTD device structure
321 * @buf: buffer to store date
322 * @len: number of bytes to read
324 * Default read function for 8bit buswith
326 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
329 struct nand_chip *this = mtd->priv;
331 for (i = 0; i < len; i++)
332 buf[i] = readb(this->IO_ADDR_R);
336 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
337 * @mtd: MTD device structure
338 * @buf: buffer containing the data to compare
339 * @len: number of bytes to compare
341 * Default verify function for 8bit buswith
343 static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
346 struct nand_chip *this = mtd->priv;
348 for (i = 0; i < len; i++)
349 if (buf[i] != readb(this->IO_ADDR_R))
356 * nand_write_buf16 - [DEFAULT] write buffer to chip
357 * @mtd: MTD device structure
359 * @len: number of bytes to write
361 * Default write function for 16bit buswith
363 static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
366 struct nand_chip *this = mtd->priv;
367 u16 *p = (u16 *) buf;
370 for (i = 0; i < len; i++)
371 writew(p[i], this->IO_ADDR_W);
376 * nand_read_buf16 - [DEFAULT] read chip data into buffer
377 * @mtd: MTD device structure
378 * @buf: buffer to store date
379 * @len: number of bytes to read
381 * Default read function for 16bit buswith
383 static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
386 struct nand_chip *this = mtd->priv;
387 u16 *p = (u16 *) buf;
390 for (i = 0; i < len; i++)
391 p[i] = readw(this->IO_ADDR_R);
395 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
396 * @mtd: MTD device structure
397 * @buf: buffer containing the data to compare
398 * @len: number of bytes to compare
400 * Default verify function for 16bit buswith
402 static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
405 struct nand_chip *this = mtd->priv;
406 u16 *p = (u16 *) buf;
409 for (i = 0; i < len; i++)
410 if (p[i] != readw(this->IO_ADDR_R))
417 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
418 * @mtd: MTD device structure
419 * @ofs: offset from device start
420 * @getchip: 0, if the chip is already selected
422 * Check, if the block is bad.
424 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
426 int page, chipnr, res = 0;
427 struct nand_chip *this = mtd->priv;
431 page = (int)(ofs >> this->page_shift);
432 chipnr = (int)(ofs >> this->chip_shift);
434 /* Grab the lock and see if the device is available */
435 nand_get_device(this, mtd, FL_READING);
437 /* Select the NAND device */
438 this->select_chip(mtd, chipnr);
442 if (this->options & NAND_BUSWIDTH_16) {
443 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE,
444 page & this->pagemask);
445 bad = cpu_to_le16(this->read_word(mtd));
446 if (this->badblockpos & 0x1)
448 if ((bad & 0xFF) != 0xff)
451 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos,
452 page & this->pagemask);
453 if (this->read_byte(mtd) != 0xff)
458 /* Deselect and wake up anyone waiting on the device */
459 nand_release_device(mtd);
466 * nand_default_block_markbad - [DEFAULT] mark a block bad
467 * @mtd: MTD device structure
468 * @ofs: offset from device start
470 * This is the default implementation, which can be overridden by
471 * a hardware specific driver.
473 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
475 struct nand_chip *this = mtd->priv;
476 uint8_t buf[2] = { 0, 0 };
480 /* Get block number */
481 block = ((int)ofs) >> this->bbt_erase_shift;
483 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
485 /* Do we have a flash based bad block table ? */
486 if (this->options & NAND_USE_FLASH_BBT)
487 return nand_update_bbt(mtd, ofs);
489 /* We write two bytes, so we dont have to mess with 16 bit access */
490 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
491 return nand_write_oob(mtd, ofs, 2, &retlen, buf);
495 * nand_check_wp - [GENERIC] check if the chip is write protected
496 * @mtd: MTD device structure
497 * Check, if the device is write protected
499 * The function expects, that the device is already selected
501 static int nand_check_wp(struct mtd_info *mtd)
503 struct nand_chip *this = mtd->priv;
504 /* Check the WP bit */
505 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
506 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
510 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
511 * @mtd: MTD device structure
512 * @ofs: offset from device start
513 * @getchip: 0, if the chip is already selected
514 * @allowbbt: 1, if its allowed to access the bbt area
516 * Check, if the block is bad. Either by reading the bad block table or
517 * calling of the scan function.
519 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
522 struct nand_chip *this = mtd->priv;
525 return this->block_bad(mtd, ofs, getchip);
527 /* Return info from the table */
528 return nand_isbad_bbt(mtd, ofs, allowbbt);
531 DEFINE_LED_TRIGGER(nand_led_trigger);
534 * Wait for the ready pin, after a command
535 * The timeout is catched later.
537 static void nand_wait_ready(struct mtd_info *mtd)
539 struct nand_chip *this = mtd->priv;
540 unsigned long timeo = jiffies + 2;
542 led_trigger_event(nand_led_trigger, LED_FULL);
543 /* wait until command is processed or timeout occures */
545 if (this->dev_ready(mtd))
547 touch_softlockup_watchdog();
548 } while (time_before(jiffies, timeo));
549 led_trigger_event(nand_led_trigger, LED_OFF);
553 * nand_command - [DEFAULT] Send command to NAND device
554 * @mtd: MTD device structure
555 * @command: the command to be sent
556 * @column: the column address for this command, -1 if none
557 * @page_addr: the page address for this command, -1 if none
559 * Send command to NAND device. This function is used for small page
560 * devices (256/512 Bytes per page)
562 static void nand_command(struct mtd_info *mtd, unsigned command, int column,
565 register struct nand_chip *this = mtd->priv;
567 /* Begin command latch cycle */
568 this->hwcontrol(mtd, NAND_CTL_SETCLE);
570 * Write out the command to the device.
572 if (command == NAND_CMD_SEQIN) {
575 if (column >= mtd->oobblock) {
577 column -= mtd->oobblock;
578 readcmd = NAND_CMD_READOOB;
579 } else if (column < 256) {
580 /* First 256 bytes --> READ0 */
581 readcmd = NAND_CMD_READ0;
584 readcmd = NAND_CMD_READ1;
586 this->write_byte(mtd, readcmd);
588 this->write_byte(mtd, command);
590 /* Set ALE and clear CLE to start address cycle */
591 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
593 if (column != -1 || page_addr != -1) {
594 this->hwcontrol(mtd, NAND_CTL_SETALE);
596 /* Serially input address */
598 /* Adjust columns for 16 bit buswidth */
599 if (this->options & NAND_BUSWIDTH_16)
601 this->write_byte(mtd, column);
603 if (page_addr != -1) {
604 this->write_byte(mtd, (uint8_t)(page_addr & 0xff));
605 this->write_byte(mtd, (uint8_t)((page_addr >> 8) & 0xff));
606 /* One more address cycle for devices > 32MiB */
607 if (this->chipsize > (32 << 20))
608 this->write_byte(mtd, (uint8_t)((page_addr >> 16) & 0x0f));
610 /* Latch in address */
611 this->hwcontrol(mtd, NAND_CTL_CLRALE);
615 * program and erase have their own busy handlers
616 * status and sequential in needs no delay
620 case NAND_CMD_PAGEPROG:
621 case NAND_CMD_ERASE1:
622 case NAND_CMD_ERASE2:
624 case NAND_CMD_STATUS:
630 udelay(this->chip_delay);
631 this->hwcontrol(mtd, NAND_CTL_SETCLE);
632 this->write_byte(mtd, NAND_CMD_STATUS);
633 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
634 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
637 /* This applies to read commands */
640 * If we don't have access to the busy pin, we apply the given
643 if (!this->dev_ready) {
644 udelay(this->chip_delay);
648 /* Apply this short delay always to ensure that we do wait tWB in
649 * any case on any machine. */
652 nand_wait_ready(mtd);
656 * nand_command_lp - [DEFAULT] Send command to NAND large page device
657 * @mtd: MTD device structure
658 * @command: the command to be sent
659 * @column: the column address for this command, -1 if none
660 * @page_addr: the page address for this command, -1 if none
662 * Send command to NAND device. This is the version for the new large page devices
663 * We dont have the separate regions as we have in the small page devices.
664 * We must emulate NAND_CMD_READOOB to keep the code compatible.
667 static void nand_command_lp(struct mtd_info *mtd, unsigned command, int column, int page_addr)
669 register struct nand_chip *this = mtd->priv;
671 /* Emulate NAND_CMD_READOOB */
672 if (command == NAND_CMD_READOOB) {
673 column += mtd->oobblock;
674 command = NAND_CMD_READ0;
677 /* Begin command latch cycle */
678 this->hwcontrol(mtd, NAND_CTL_SETCLE);
679 /* Write out the command to the device. */
680 this->write_byte(mtd, (command & 0xff));
681 /* End command latch cycle */
682 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
684 if (column != -1 || page_addr != -1) {
685 this->hwcontrol(mtd, NAND_CTL_SETALE);
687 /* Serially input address */
689 /* Adjust columns for 16 bit buswidth */
690 if (this->options & NAND_BUSWIDTH_16)
692 this->write_byte(mtd, column & 0xff);
693 this->write_byte(mtd, column >> 8);
695 if (page_addr != -1) {
696 this->write_byte(mtd, (uint8_t)(page_addr & 0xff));
697 this->write_byte(mtd, (uint8_t)((page_addr >> 8) & 0xff));
698 /* One more address cycle for devices > 128MiB */
699 if (this->chipsize > (128 << 20))
700 this->write_byte(mtd, (uint8_t)((page_addr >> 16) & 0xff));
702 /* Latch in address */
703 this->hwcontrol(mtd, NAND_CTL_CLRALE);
707 * program and erase have their own busy handlers
708 * status, sequential in, and deplete1 need no delay
712 case NAND_CMD_CACHEDPROG:
713 case NAND_CMD_PAGEPROG:
714 case NAND_CMD_ERASE1:
715 case NAND_CMD_ERASE2:
717 case NAND_CMD_STATUS:
718 case NAND_CMD_DEPLETE1:
722 * read error status commands require only a short delay
724 case NAND_CMD_STATUS_ERROR:
725 case NAND_CMD_STATUS_ERROR0:
726 case NAND_CMD_STATUS_ERROR1:
727 case NAND_CMD_STATUS_ERROR2:
728 case NAND_CMD_STATUS_ERROR3:
729 udelay(this->chip_delay);
735 udelay(this->chip_delay);
736 this->hwcontrol(mtd, NAND_CTL_SETCLE);
737 this->write_byte(mtd, NAND_CMD_STATUS);
738 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
739 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
743 /* Begin command latch cycle */
744 this->hwcontrol(mtd, NAND_CTL_SETCLE);
745 /* Write out the start read command */
746 this->write_byte(mtd, NAND_CMD_READSTART);
747 /* End command latch cycle */
748 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
749 /* Fall through into ready check */
751 /* This applies to read commands */
754 * If we don't have access to the busy pin, we apply the given
757 if (!this->dev_ready) {
758 udelay(this->chip_delay);
763 /* Apply this short delay always to ensure that we do wait tWB in
764 * any case on any machine. */
767 nand_wait_ready(mtd);
771 * nand_get_device - [GENERIC] Get chip for selected access
772 * @this: the nand chip descriptor
773 * @mtd: MTD device structure
774 * @new_state: the state which is requested
776 * Get the device and lock it for exclusive access
779 nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state)
781 spinlock_t *lock = &this->controller->lock;
782 wait_queue_head_t *wq = &this->controller->wq;
783 DECLARE_WAITQUEUE(wait, current);
787 /* Hardware controller shared among independend devices */
788 /* Hardware controller shared among independend devices */
789 if (!this->controller->active)
790 this->controller->active = this;
792 if (this->controller->active == this && this->state == FL_READY) {
793 this->state = new_state;
797 if (new_state == FL_PM_SUSPENDED) {
799 return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
801 set_current_state(TASK_UNINTERRUPTIBLE);
802 add_wait_queue(wq, &wait);
805 remove_wait_queue(wq, &wait);
810 * nand_wait - [DEFAULT] wait until the command is done
811 * @mtd: MTD device structure
812 * @this: NAND chip structure
813 * @state: state to select the max. timeout value
815 * Wait for command done. This applies to erase and program only
816 * Erase can take up to 400ms and program up to 20ms according to
817 * general NAND and SmartMedia specs
820 static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
823 unsigned long timeo = jiffies;
826 if (state == FL_ERASING)
827 timeo += (HZ * 400) / 1000;
829 timeo += (HZ * 20) / 1000;
831 led_trigger_event(nand_led_trigger, LED_FULL);
833 /* Apply this short delay always to ensure that we do wait tWB in
834 * any case on any machine. */
837 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
838 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
840 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
842 while (time_before(jiffies, timeo)) {
843 /* Check, if we were interrupted */
844 if (this->state != state)
847 if (this->dev_ready) {
848 if (this->dev_ready(mtd))
851 if (this->read_byte(mtd) & NAND_STATUS_READY)
856 led_trigger_event(nand_led_trigger, LED_OFF);
858 status = (int)this->read_byte(mtd);
863 * nand_write_page - [GENERIC] write one page
864 * @mtd: MTD device structure
865 * @this: NAND chip structure
866 * @page: startpage inside the chip, must be called with (page & this->pagemask)
867 * @oob_buf: out of band data buffer
868 * @oobsel: out of band selecttion structre
869 * @cached: 1 = enable cached programming if supported by chip
871 * Nand_page_program function is used for write and writev !
872 * This function will always program a full page of data
873 * If you call it with a non page aligned buffer, you're lost :)
875 * Cached programming is not supported yet.
877 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page,
878 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int cached)
881 uint8_t ecc_code[32];
882 int eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
883 int *oob_config = oobsel->eccpos;
884 int datidx = 0, eccidx = 0, eccsteps = this->ecc.steps;
887 /* FIXME: Enable cached programming */
890 /* Send command to begin auto page programming */
891 this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
893 /* Write out complete page of data, take care of eccmode */
895 /* No ecc, write all */
897 printk(KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
898 this->write_buf(mtd, this->data_poi, mtd->oobblock);
901 /* Software ecc 3/256, write all */
903 for (; eccsteps; eccsteps--) {
904 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
905 for (i = 0; i < 3; i++, eccidx++)
906 oob_buf[oob_config[eccidx]] = ecc_code[i];
907 datidx += this->ecc.size;
909 this->write_buf(mtd, this->data_poi, mtd->oobblock);
912 eccbytes = this->ecc.bytes;
913 for (; eccsteps; eccsteps--) {
914 /* enable hardware ecc logic for write */
915 this->ecc.hwctl(mtd, NAND_ECC_WRITE);
916 this->write_buf(mtd, &this->data_poi[datidx], this->ecc.size);
917 this->ecc.calculate(mtd, &this->data_poi[datidx], ecc_code);
918 for (i = 0; i < eccbytes; i++, eccidx++)
919 oob_buf[oob_config[eccidx]] = ecc_code[i];
920 /* If the hardware ecc provides syndromes then
921 * the ecc code must be written immidiately after
922 * the data bytes (words) */
923 if (this->options & NAND_HWECC_SYNDROME)
924 this->write_buf(mtd, ecc_code, eccbytes);
925 datidx += this->ecc.size;
930 /* Write out OOB data */
931 if (this->options & NAND_HWECC_SYNDROME)
932 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
934 this->write_buf(mtd, oob_buf, mtd->oobsize);
936 /* Send command to actually program the data */
937 this->cmdfunc(mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
940 /* call wait ready function */
941 status = this->waitfunc(mtd, this, FL_WRITING);
943 /* See if operation failed and additional status checks are available */
944 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
945 status = this->errstat(mtd, this, FL_WRITING, status, page);
948 /* See if device thinks it succeeded */
949 if (status & NAND_STATUS_FAIL) {
950 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
954 /* FIXME: Implement cached programming ! */
955 /* wait until cache is ready */
956 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
961 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
963 * nand_verify_pages - [GENERIC] verify the chip contents after a write
964 * @mtd: MTD device structure
965 * @this: NAND chip structure
966 * @page: startpage inside the chip, must be called with (page & this->pagemask)
967 * @numpages: number of pages to verify
968 * @oob_buf: out of band data buffer
969 * @oobsel: out of band selecttion structre
970 * @chipnr: number of the current chip
971 * @oobmode: 1 = full buffer verify, 0 = ecc only
973 * The NAND device assumes that it is always writing to a cleanly erased page.
974 * Hence, it performs its internal write verification only on bits that
975 * transitioned from 1 to 0. The device does NOT verify the whole page on a
976 * byte by byte basis. It is possible that the page was not completely erased
977 * or the page is becoming unusable due to wear. The read with ECC would catch
978 * the error later when the ECC page check fails, but we would rather catch
979 * it early in the page write stage. Better to write no data than invalid data.
981 static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
982 uint8_t *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
984 int i, j, datidx = 0, oobofs = 0, res = -EIO;
985 int eccsteps = this->eccsteps;
989 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
991 /* Send command to read back the first page */
992 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
995 for (j = 0; j < eccsteps; j++) {
996 /* Loop through and verify the data */
997 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
998 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1001 datidx += mtd->eccsize;
1002 /* Have we a hw generator layout ? */
1005 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
1006 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1009 oobofs += hweccbytes;
1012 /* check, if we must compare all data or if we just have to
1013 * compare the ecc bytes
1016 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
1017 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1021 /* Read always, else autoincrement fails */
1022 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
1024 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
1025 int ecccnt = oobsel->eccbytes;
1027 for (i = 0; i < ecccnt; i++) {
1028 int idx = oobsel->eccpos[i];
1029 if (oobdata[idx] != oob_buf[oobofs + idx]) {
1030 DEBUG(MTD_DEBUG_LEVEL0, "%s: Failed ECC write verify, page 0x%08x, %6i bytes were succesful\n",
1031 __FUNCTION__, page, i);
1037 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1041 /* Apply delay or wait for ready/busy pin
1042 * Do this before the AUTOINCR check, so no problems
1043 * arise if a chip which does auto increment
1044 * is marked as NOAUTOINCR by the board driver.
1045 * Do this also before returning, so the chip is
1046 * ready for the next command.
1048 if (!this->dev_ready)
1049 udelay(this->chip_delay);
1051 nand_wait_ready(mtd);
1053 /* All done, return happy */
1057 /* Check, if the chip supports auto page increment */
1058 if (!NAND_CANAUTOINCR(this))
1059 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1062 * Terminate the read command. We come here in case of an error
1063 * So we must issue a reset command.
1066 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1072 * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
1073 * @mtd: MTD device structure
1074 * @from: offset to read from
1075 * @len: number of bytes to read
1076 * @retlen: pointer to variable to store the number of read bytes
1077 * @buf: the databuffer to put data
1079 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1082 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1084 return nand_do_read_ecc(mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1088 * nand_read_ecc - [MTD Interface] MTD compability function for nand_do_read_ecc
1089 * @mtd: MTD device structure
1090 * @from: offset to read from
1091 * @len: number of bytes to read
1092 * @retlen: pointer to variable to store the number of read bytes
1093 * @buf: the databuffer to put data
1094 * @oob_buf: filesystem supplied oob data buffer
1095 * @oobsel: oob selection structure
1097 * This function simply calls nand_do_read_ecc with flags = 0xff
1099 static int nand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1100 size_t *retlen, uint8_t *buf, uint8_t *oob_buf, struct nand_oobinfo *oobsel)
1102 /* use userspace supplied oobinfo, if zero */
1104 oobsel = &mtd->oobinfo;
1105 return nand_do_read_ecc(mtd, from, len, retlen, buf, oob_buf, oobsel, 0xff);
1109 * nand_do_read_ecc - [MTD Interface] Read data with ECC
1110 * @mtd: MTD device structure
1111 * @from: offset to read from
1112 * @len: number of bytes to read
1113 * @retlen: pointer to variable to store the number of read bytes
1114 * @buf: the databuffer to put data
1115 * @oob_buf: filesystem supplied oob data buffer (can be NULL)
1116 * @oobsel: oob selection structure
1117 * @flags: flag to indicate if nand_get_device/nand_release_device should be preformed
1118 * and how many corrected error bits are acceptable:
1119 * bits 0..7 - number of tolerable errors
1120 * bit 8 - 0 == do not get/release chip, 1 == get/release chip
1122 * NAND read with ECC
1124 int nand_do_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1125 size_t *retlen, uint8_t *buf, uint8_t *oob_buf, struct nand_oobinfo *oobsel, int flags)
1128 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1129 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1130 struct nand_chip *this = mtd->priv;
1131 uint8_t *data_poi, *oob_data = oob_buf;
1132 uint8_t ecc_calc[32];
1133 uint8_t ecc_code[32];
1134 int eccmode, eccsteps;
1135 int *oob_config, datidx;
1136 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1141 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1143 /* Do not allow reads past end of device */
1144 if ((from + len) > mtd->size) {
1145 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1150 /* Grab the lock and see if the device is available */
1151 if (flags & NAND_GET_DEVICE)
1152 nand_get_device(this, mtd, FL_READING);
1154 /* Autoplace of oob data ? Use the default placement scheme */
1155 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1156 oobsel = this->autooob;
1158 eccmode = oobsel->useecc ? this->ecc.mode : NAND_ECC_NONE;
1159 oob_config = oobsel->eccpos;
1161 /* Select the NAND device */
1162 chipnr = (int)(from >> this->chip_shift);
1163 this->select_chip(mtd, chipnr);
1165 /* First we calculate the starting page */
1166 realpage = (int)(from >> this->page_shift);
1167 page = realpage & this->pagemask;
1169 /* Get raw starting column */
1170 col = from & (mtd->oobblock - 1);
1172 end = mtd->oobblock;
1173 ecc = this->ecc.size;
1174 eccbytes = this->ecc.bytes;
1176 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1179 oobreadlen = mtd->oobsize;
1180 if (this->options & NAND_HWECC_SYNDROME)
1181 oobreadlen -= oobsel->eccbytes;
1183 /* Loop until all data read */
1184 while (read < len) {
1186 int aligned = (!col && (len - read) >= end);
1188 * If the read is not page aligned, we have to read into data buffer
1189 * due to ecc, else we read into return buffer direct
1192 data_poi = &buf[read];
1194 data_poi = this->data_buf;
1196 /* Check, if we have this page in the buffer
1198 * FIXME: Make it work when we must provide oob data too,
1199 * check the usage of data_buf oob field
1201 if (realpage == this->pagebuf && !oob_buf) {
1202 /* aligned read ? */
1204 memcpy(data_poi, this->data_buf, end);
1208 /* Check, if we must send the read command */
1210 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1214 /* get oob area, if we have no oob buffer from fs-driver */
1215 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1216 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1217 oob_data = &this->data_buf[end];
1219 eccsteps = this->ecc.steps;
1222 case NAND_ECC_NONE:{
1223 /* No ECC, Read in a page */
1224 static unsigned long lastwhinge = 0;
1225 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1227 "Reading data from NAND FLASH without ECC is not recommended\n");
1228 lastwhinge = jiffies;
1230 this->read_buf(mtd, data_poi, end);
1234 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1235 this->read_buf(mtd, data_poi, end);
1236 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += 3, datidx += ecc)
1237 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1241 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += eccbytes, datidx += ecc) {
1242 this->ecc.hwctl(mtd, NAND_ECC_READ);
1243 this->read_buf(mtd, &data_poi[datidx], ecc);
1245 /* HW ecc with syndrome calculation must read the
1246 * syndrome from flash immidiately after the data */
1248 /* Some hw ecc generators need to know when the
1249 * syndrome is read from flash */
1250 this->ecc.hwctl(mtd, NAND_ECC_READSYN);
1251 this->read_buf(mtd, &oob_data[i], eccbytes);
1252 /* We calc error correction directly, it checks the hw
1253 * generator for an error, reads back the syndrome and
1254 * does the error correction on the fly */
1255 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1256 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1257 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1258 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1262 this->ecc.calculate(mtd, &data_poi[datidx], &ecc_calc[i]);
1269 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1271 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1275 /* Pick the ECC bytes out of the oob data */
1276 for (j = 0; j < oobsel->eccbytes; j++)
1277 ecc_code[j] = oob_data[oob_config[j]];
1279 /* correct data, if necessary */
1280 for (i = 0, j = 0, datidx = 0; i < this->ecc.steps; i++, datidx += ecc) {
1281 ecc_status = this->ecc.correct(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1283 /* Get next chunk of ecc bytes */
1286 /* Check, if we have a fs supplied oob-buffer,
1287 * This is the legacy mode. Used by YAFFS1
1288 * Should go away some day
1290 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
1291 int *p = (int *)(&oob_data[mtd->oobsize]);
1295 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1296 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1302 /* check, if we have a fs supplied oob-buffer */
1304 /* without autoplace. Legacy mode used by YAFFS1 */
1305 switch (oobsel->useecc) {
1306 case MTD_NANDECC_AUTOPLACE:
1307 case MTD_NANDECC_AUTOPL_USR:
1308 /* Walk through the autoplace chunks */
1309 for (i = 0; oobsel->oobfree[i][1]; i++) {
1310 int from = oobsel->oobfree[i][0];
1311 int num = oobsel->oobfree[i][1];
1312 memcpy(&oob_buf[oob], &oob_data[from], num);
1316 case MTD_NANDECC_PLACE:
1317 /* YAFFS1 legacy mode */
1318 oob_data += this->ecc.steps * sizeof(int);
1320 oob_data += mtd->oobsize;
1324 /* Partial page read, transfer data into fs buffer */
1326 for (j = col; j < end && read < len; j++)
1327 buf[read++] = data_poi[j];
1328 this->pagebuf = realpage;
1330 read += mtd->oobblock;
1332 /* Apply delay or wait for ready/busy pin
1333 * Do this before the AUTOINCR check, so no problems
1334 * arise if a chip which does auto increment
1335 * is marked as NOAUTOINCR by the board driver.
1337 if (!this->dev_ready)
1338 udelay(this->chip_delay);
1340 nand_wait_ready(mtd);
1345 /* For subsequent reads align to page boundary. */
1347 /* Increment page address */
1350 page = realpage & this->pagemask;
1351 /* Check, if we cross a chip boundary */
1354 this->select_chip(mtd, -1);
1355 this->select_chip(mtd, chipnr);
1357 /* Check, if the chip supports auto page increment
1358 * or if we have hit a block boundary.
1360 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1364 /* Deselect and wake up anyone waiting on the device */
1365 if (flags & NAND_GET_DEVICE)
1366 nand_release_device(mtd);
1369 * Return success, if no ECC failures, else -EBADMSG
1370 * fs driver will take care of that, because
1371 * retlen == desired len and result == -EBADMSG
1374 return ecc_failed ? -EBADMSG : 0;
1378 * nand_read_oob - [MTD Interface] NAND read out-of-band
1379 * @mtd: MTD device structure
1380 * @from: offset to read from
1381 * @len: number of bytes to read
1382 * @retlen: pointer to variable to store the number of read bytes
1383 * @buf: the databuffer to put data
1385 * NAND read out-of-band data from the spare area
1387 static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, uint8_t *buf)
1389 int i, col, page, chipnr;
1390 struct nand_chip *this = mtd->priv;
1391 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1393 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1395 /* Shift to get page */
1396 page = (int)(from >> this->page_shift);
1397 chipnr = (int)(from >> this->chip_shift);
1399 /* Mask to get column */
1400 col = from & (mtd->oobsize - 1);
1402 /* Initialize return length value */
1405 /* Do not allow reads past end of device */
1406 if ((from + len) > mtd->size) {
1407 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1412 /* Grab the lock and see if the device is available */
1413 nand_get_device(this, mtd, FL_READING);
1415 /* Select the NAND device */
1416 this->select_chip(mtd, chipnr);
1418 /* Send the read command */
1419 this->cmdfunc(mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1421 * Read the data, if we read more than one page
1422 * oob data, let the device transfer the data !
1426 int thislen = mtd->oobsize - col;
1427 thislen = min_t(int, thislen, len);
1428 this->read_buf(mtd, &buf[i], thislen);
1436 /* Check, if we cross a chip boundary */
1437 if (!(page & this->pagemask)) {
1439 this->select_chip(mtd, -1);
1440 this->select_chip(mtd, chipnr);
1443 /* Apply delay or wait for ready/busy pin
1444 * Do this before the AUTOINCR check, so no problems
1445 * arise if a chip which does auto increment
1446 * is marked as NOAUTOINCR by the board driver.
1448 if (!this->dev_ready)
1449 udelay(this->chip_delay);
1451 nand_wait_ready(mtd);
1453 /* Check, if the chip supports auto page increment
1454 * or if we have hit a block boundary.
1456 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1457 /* For subsequent page reads set offset to 0 */
1458 this->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1463 /* Deselect and wake up anyone waiting on the device */
1464 nand_release_device(mtd);
1472 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1473 * @mtd: MTD device structure
1474 * @buf: temporary buffer
1475 * @from: offset to read from
1476 * @len: number of bytes to read
1477 * @ooblen: number of oob data bytes to read
1479 * Read raw data including oob into buffer
1481 int nand_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1483 struct nand_chip *this = mtd->priv;
1484 int page = (int)(from >> this->page_shift);
1485 int chip = (int)(from >> this->chip_shift);
1488 int pagesize = mtd->oobblock + mtd->oobsize;
1489 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1491 /* Do not allow reads past end of device */
1492 if ((from + len) > mtd->size) {
1493 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1497 /* Grab the lock and see if the device is available */
1498 nand_get_device(this, mtd, FL_READING);
1500 this->select_chip(mtd, chip);
1502 /* Add requested oob length */
1507 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1510 this->read_buf(mtd, &buf[cnt], pagesize);
1516 if (!this->dev_ready)
1517 udelay(this->chip_delay);
1519 nand_wait_ready(mtd);
1521 /* Check, if the chip supports auto page increment */
1522 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1526 /* Deselect and wake up anyone waiting on the device */
1527 nand_release_device(mtd);
1532 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1533 * @mtd: MTD device structure
1534 * @fsbuf: buffer given by fs driver
1535 * @oobsel: out of band selection structre
1536 * @autoplace: 1 = place given buffer into the oob bytes
1537 * @numpages: number of pages to prepare
1540 * 1. Filesystem buffer available and autoplacement is off,
1541 * return filesystem buffer
1542 * 2. No filesystem buffer or autoplace is off, return internal
1544 * 3. Filesystem buffer is given and autoplace selected
1545 * put data from fs buffer into internal buffer and
1546 * retrun internal buffer
1548 * Note: The internal buffer is filled with 0xff. This must
1549 * be done only once, when no autoplacement happens
1550 * Autoplacement sets the buffer dirty flag, which
1551 * forces the 0xff fill before using the buffer again.
1554 static uint8_t *nand_prepare_oobbuf(struct mtd_info *mtd, uint8_t *fsbuf, struct nand_oobinfo *oobsel,
1555 int autoplace, int numpages)
1557 struct nand_chip *this = mtd->priv;
1560 /* Zero copy fs supplied buffer */
1561 if (fsbuf && !autoplace)
1564 /* Check, if the buffer must be filled with ff again */
1565 if (this->oobdirty) {
1566 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1570 /* If we have no autoplacement or no fs buffer use the internal one */
1571 if (!autoplace || !fsbuf)
1572 return this->oob_buf;
1574 /* Walk through the pages and place the data */
1577 while (numpages--) {
1578 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1579 int to = ofs + oobsel->oobfree[i][0];
1580 int num = oobsel->oobfree[i][1];
1581 memcpy(&this->oob_buf[to], fsbuf, num);
1585 ofs += mtd->oobavail;
1587 return this->oob_buf;
1590 #define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
1593 * nand_write - [MTD Interface] compability function for nand_write_ecc
1594 * @mtd: MTD device structure
1595 * @to: offset to write to
1596 * @len: number of bytes to write
1597 * @retlen: pointer to variable to store the number of written bytes
1598 * @buf: the data to write
1600 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1603 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const uint8_t *buf)
1605 return (nand_write_ecc(mtd, to, len, retlen, buf, NULL, NULL));
1609 * nand_write_ecc - [MTD Interface] NAND write with ECC
1610 * @mtd: MTD device structure
1611 * @to: offset to write to
1612 * @len: number of bytes to write
1613 * @retlen: pointer to variable to store the number of written bytes
1614 * @buf: the data to write
1615 * @eccbuf: filesystem supplied oob data buffer
1616 * @oobsel: oob selection structure
1618 * NAND write with ECC
1620 static int nand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
1621 size_t *retlen, const uint8_t *buf, uint8_t *eccbuf,
1622 struct nand_oobinfo *oobsel)
1624 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1625 int autoplace = 0, numpages, totalpages;
1626 struct nand_chip *this = mtd->priv;
1627 uint8_t *oobbuf, *bufstart;
1628 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1630 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1632 /* Initialize retlen, in case of early exit */
1635 /* Do not allow write past end of device */
1636 if ((to + len) > mtd->size) {
1637 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
1641 /* reject writes, which are not page aligned */
1642 if (NOTALIGNED(to) || NOTALIGNED(len)) {
1643 printk(KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1647 /* Grab the lock and see if the device is available */
1648 nand_get_device(this, mtd, FL_WRITING);
1650 /* Calculate chipnr */
1651 chipnr = (int)(to >> this->chip_shift);
1652 /* Select the NAND device */
1653 this->select_chip(mtd, chipnr);
1655 /* Check, if it is write protected */
1656 if (nand_check_wp(mtd))
1659 /* if oobsel is NULL, use chip defaults */
1661 oobsel = &mtd->oobinfo;
1663 /* Autoplace of oob data ? Use the default placement scheme */
1664 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1665 oobsel = this->autooob;
1668 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1671 /* Setup variables and oob buffer */
1672 totalpages = len >> this->page_shift;
1673 page = (int)(to >> this->page_shift);
1674 /* Invalidate the page cache, if we write to the cached page */
1675 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1678 /* Set it relative to chip */
1679 page &= this->pagemask;
1681 /* Calc number of pages we can write in one go */
1682 numpages = min(ppblock - (startpage & (ppblock - 1)), totalpages);
1683 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1684 bufstart = (uint8_t *) buf;
1686 /* Loop until all data is written */
1687 while (written < len) {
1689 this->data_poi = (uint8_t *) &buf[written];
1690 /* Write one page. If this is the last page to write
1691 * or the last page in this block, then use the
1692 * real pageprogram command, else select cached programming
1693 * if supported by the chip.
1695 ret = nand_write_page(mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1697 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1701 oob += mtd->oobsize;
1702 /* Update written bytes count */
1703 written += mtd->oobblock;
1707 /* Increment page address */
1710 /* Have we hit a block boundary ? Then we have to verify and
1711 * if verify is ok, we have to setup the oob buffer for
1714 if (!(page & (ppblock - 1))) {
1716 this->data_poi = bufstart;
1717 ret = nand_verify_pages(mtd, this, startpage, page - startpage,
1718 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1720 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1725 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1727 eccbuf += (page - startpage) * ofs;
1728 totalpages -= page - startpage;
1729 numpages = min(totalpages, ppblock);
1730 page &= this->pagemask;
1732 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1734 /* Check, if we cross a chip boundary */
1737 this->select_chip(mtd, -1);
1738 this->select_chip(mtd, chipnr);
1742 /* Verify the remaining pages */
1744 this->data_poi = bufstart;
1745 ret = nand_verify_pages(mtd, this, startpage, totalpages, oobbuf, oobsel, chipnr, (eccbuf != NULL));
1749 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1752 /* Deselect and wake up anyone waiting on the device */
1753 nand_release_device(mtd);
1759 * nand_write_oob - [MTD Interface] NAND write out-of-band
1760 * @mtd: MTD device structure
1761 * @to: offset to write to
1762 * @len: number of bytes to write
1763 * @retlen: pointer to variable to store the number of written bytes
1764 * @buf: the data to write
1766 * NAND write out-of-band
1768 static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const uint8_t *buf)
1770 int column, page, status, ret = -EIO, chipnr;
1771 struct nand_chip *this = mtd->priv;
1773 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1775 /* Shift to get page */
1776 page = (int)(to >> this->page_shift);
1777 chipnr = (int)(to >> this->chip_shift);
1779 /* Mask to get column */
1780 column = to & (mtd->oobsize - 1);
1782 /* Initialize return length value */
1785 /* Do not allow write past end of page */
1786 if ((column + len) > mtd->oobsize) {
1787 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1791 /* Grab the lock and see if the device is available */
1792 nand_get_device(this, mtd, FL_WRITING);
1794 /* Select the NAND device */
1795 this->select_chip(mtd, chipnr);
1797 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1798 in one of my DiskOnChip 2000 test units) will clear the whole
1799 data page too if we don't do this. I have no clue why, but
1800 I seem to have 'fixed' it in the doc2000 driver in
1801 August 1999. dwmw2. */
1802 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1804 /* Check, if it is write protected */
1805 if (nand_check_wp(mtd))
1808 /* Invalidate the page cache, if we write to the cached page */
1809 if (page == this->pagebuf)
1812 if (NAND_MUST_PAD(this)) {
1813 /* Write out desired data */
1814 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1815 /* prepad 0xff for partial programming */
1816 this->write_buf(mtd, ffchars, column);
1818 this->write_buf(mtd, buf, len);
1819 /* postpad 0xff for partial programming */
1820 this->write_buf(mtd, ffchars, mtd->oobsize - (len + column));
1822 /* Write out desired data */
1823 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1825 this->write_buf(mtd, buf, len);
1827 /* Send command to program the OOB data */
1828 this->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1830 status = this->waitfunc(mtd, this, FL_WRITING);
1832 /* See if device thinks it succeeded */
1833 if (status & NAND_STATUS_FAIL) {
1834 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1841 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1842 /* Send command to read back the data */
1843 this->cmdfunc(mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1845 if (this->verify_buf(mtd, buf, len)) {
1846 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1853 /* Deselect and wake up anyone waiting on the device */
1854 nand_release_device(mtd);
1860 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1861 * @mtd: MTD device structure
1862 * @vecs: the iovectors to write
1863 * @count: number of vectors
1864 * @to: offset to write to
1865 * @retlen: pointer to variable to store the number of written bytes
1867 * NAND write with kvec. This just calls the ecc function
1869 static int nand_writev(struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1870 loff_t to, size_t *retlen)
1872 return (nand_writev_ecc(mtd, vecs, count, to, retlen, NULL, NULL));
1876 * nand_writev_ecc - [MTD Interface] write with iovec with ecc
1877 * @mtd: MTD device structure
1878 * @vecs: the iovectors to write
1879 * @count: number of vectors
1880 * @to: offset to write to
1881 * @retlen: pointer to variable to store the number of written bytes
1882 * @eccbuf: filesystem supplied oob data buffer
1883 * @oobsel: oob selection structure
1885 * NAND write with iovec with ecc
1887 static int nand_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1888 loff_t to, size_t *retlen, uint8_t *eccbuf, struct nand_oobinfo *oobsel)
1890 int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1891 int oob, numpages, autoplace = 0, startpage;
1892 struct nand_chip *this = mtd->priv;
1893 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1894 uint8_t *oobbuf, *bufstart;
1896 /* Preset written len for early exit */
1899 /* Calculate total length of data */
1901 for (i = 0; i < count; i++)
1902 total_len += (int)vecs[i].iov_len;
1904 DEBUG(MTD_DEBUG_LEVEL3, "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int)to, (unsigned int)total_len, count);
1906 /* Do not allow write past end of page */
1907 if ((to + total_len) > mtd->size) {
1908 DEBUG(MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1912 /* reject writes, which are not page aligned */
1913 if (NOTALIGNED(to) || NOTALIGNED(total_len)) {
1914 printk(KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1918 /* Grab the lock and see if the device is available */
1919 nand_get_device(this, mtd, FL_WRITING);
1921 /* Get the current chip-nr */
1922 chipnr = (int)(to >> this->chip_shift);
1923 /* Select the NAND device */
1924 this->select_chip(mtd, chipnr);
1926 /* Check, if it is write protected */
1927 if (nand_check_wp(mtd))
1930 /* if oobsel is NULL, use chip defaults */
1932 oobsel = &mtd->oobinfo;
1934 /* Autoplace of oob data ? Use the default placement scheme */
1935 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1936 oobsel = this->autooob;
1939 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1942 /* Setup start page */
1943 page = (int)(to >> this->page_shift);
1944 /* Invalidate the page cache, if we write to the cached page */
1945 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
1948 startpage = page & this->pagemask;
1950 /* Loop until all kvec' data has been written */
1953 /* If the given tuple is >= pagesize then
1954 * write it out from the iov
1956 if ((vecs->iov_len - len) >= mtd->oobblock) {
1957 /* Calc number of pages we can write
1958 * out of this iov in one go */
1959 numpages = (vecs->iov_len - len) >> this->page_shift;
1960 /* Do not cross block boundaries */
1961 numpages = min(ppblock - (startpage & (ppblock - 1)), numpages);
1962 oobbuf = nand_prepare_oobbuf(mtd, NULL, oobsel, autoplace, numpages);
1963 bufstart = (uint8_t *) vecs->iov_base;
1965 this->data_poi = bufstart;
1967 for (i = 1; i <= numpages; i++) {
1968 /* Write one page. If this is the last page to write
1969 * then use the real pageprogram command, else select
1970 * cached programming if supported by the chip.
1972 ret = nand_write_page(mtd, this, page & this->pagemask,
1973 &oobbuf[oob], oobsel, i != numpages);
1976 this->data_poi += mtd->oobblock;
1977 len += mtd->oobblock;
1978 oob += mtd->oobsize;
1981 /* Check, if we have to switch to the next tuple */
1982 if (len >= (int)vecs->iov_len) {
1988 /* We must use the internal buffer, read data out of each
1989 * tuple until we have a full page to write
1992 while (cnt < mtd->oobblock) {
1993 if (vecs->iov_base != NULL && vecs->iov_len)
1994 this->data_buf[cnt++] = ((uint8_t *) vecs->iov_base)[len++];
1995 /* Check, if we have to switch to the next tuple */
1996 if (len >= (int)vecs->iov_len) {
2002 this->pagebuf = page;
2003 this->data_poi = this->data_buf;
2004 bufstart = this->data_poi;
2006 oobbuf = nand_prepare_oobbuf(mtd, NULL, oobsel, autoplace, numpages);
2007 ret = nand_write_page(mtd, this, page & this->pagemask, oobbuf, oobsel, 0);
2013 this->data_poi = bufstart;
2014 ret = nand_verify_pages(mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
2018 written += mtd->oobblock * numpages;
2023 startpage = page & this->pagemask;
2024 /* Check, if we cross a chip boundary */
2027 this->select_chip(mtd, -1);
2028 this->select_chip(mtd, chipnr);
2033 /* Deselect and wake up anyone waiting on the device */
2034 nand_release_device(mtd);
2041 * single_erease_cmd - [GENERIC] NAND standard block erase command function
2042 * @mtd: MTD device structure
2043 * @page: the page address of the block which will be erased
2045 * Standard erase command for NAND chips
2047 static void single_erase_cmd(struct mtd_info *mtd, int page)
2049 struct nand_chip *this = mtd->priv;
2050 /* Send commands to erase a block */
2051 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2052 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2056 * multi_erease_cmd - [GENERIC] AND specific block erase command function
2057 * @mtd: MTD device structure
2058 * @page: the page address of the block which will be erased
2060 * AND multi block erase command function
2061 * Erase 4 consecutive blocks
2063 static void multi_erase_cmd(struct mtd_info *mtd, int page)
2065 struct nand_chip *this = mtd->priv;
2066 /* Send commands to erase a block */
2067 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2068 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2069 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2070 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2071 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2075 * nand_erase - [MTD Interface] erase block(s)
2076 * @mtd: MTD device structure
2077 * @instr: erase instruction
2079 * Erase one ore more blocks
2081 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
2083 return nand_erase_nand(mtd, instr, 0);
2086 #define BBT_PAGE_MASK 0xffffff3f
2088 * nand_erase_intern - [NAND Interface] erase block(s)
2089 * @mtd: MTD device structure
2090 * @instr: erase instruction
2091 * @allowbbt: allow erasing the bbt area
2093 * Erase one ore more blocks
2095 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2097 int page, len, status, pages_per_block, ret, chipnr;
2098 struct nand_chip *this = mtd->priv;
2099 int rewrite_bbt[NAND_MAX_CHIPS]={0}; /* flags to indicate the page, if bbt needs to be rewritten. */
2100 unsigned int bbt_masked_page; /* bbt mask to compare to page being erased. */
2101 /* It is used to see if the current page is in the same */
2102 /* 256 block group and the same bank as the bbt. */
2104 DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n", (unsigned int)instr->addr, (unsigned int)instr->len);
2106 /* Start address must align on block boundary */
2107 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2108 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2112 /* Length must align on block boundary */
2113 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2114 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2118 /* Do not allow erase past end of device */
2119 if ((instr->len + instr->addr) > mtd->size) {
2120 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2124 instr->fail_addr = 0xffffffff;
2126 /* Grab the lock and see if the device is available */
2127 nand_get_device(this, mtd, FL_ERASING);
2129 /* Shift to get first page */
2130 page = (int)(instr->addr >> this->page_shift);
2131 chipnr = (int)(instr->addr >> this->chip_shift);
2133 /* Calculate pages in each block */
2134 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
2136 /* Select the NAND device */
2137 this->select_chip(mtd, chipnr);
2139 /* Check the WP bit */
2140 /* Check, if it is write protected */
2141 if (nand_check_wp(mtd)) {
2142 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2143 instr->state = MTD_ERASE_FAILED;
2147 /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
2148 if (this->options & BBT_AUTO_REFRESH) {
2149 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2151 bbt_masked_page = 0xffffffff; /* should not match anything */
2154 /* Loop through the pages */
2157 instr->state = MTD_ERASING;
2160 /* Check if we have a bad block, we do not erase bad blocks ! */
2161 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2162 printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2163 instr->state = MTD_ERASE_FAILED;
2167 /* Invalidate the page cache, if we erase the block which contains
2168 the current cached page */
2169 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2172 this->erase_cmd(mtd, page & this->pagemask);
2174 status = this->waitfunc(mtd, this, FL_ERASING);
2176 /* See if operation failed and additional status checks are available */
2177 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
2178 status = this->errstat(mtd, this, FL_ERASING, status, page);
2181 /* See if block erase succeeded */
2182 if (status & NAND_STATUS_FAIL) {
2183 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2184 instr->state = MTD_ERASE_FAILED;
2185 instr->fail_addr = (page << this->page_shift);
2189 /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
2190 if (this->options & BBT_AUTO_REFRESH) {
2191 if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
2192 (page != this->bbt_td->pages[chipnr])) {
2193 rewrite_bbt[chipnr] = (page << this->page_shift);
2197 /* Increment page address and decrement length */
2198 len -= (1 << this->phys_erase_shift);
2199 page += pages_per_block;
2201 /* Check, if we cross a chip boundary */
2202 if (len && !(page & this->pagemask)) {
2204 this->select_chip(mtd, -1);
2205 this->select_chip(mtd, chipnr);
2207 /* if BBT requires refresh and BBT-PERCHIP,
2208 * set the BBT page mask to see if this BBT should be rewritten */
2209 if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
2210 bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
2215 instr->state = MTD_ERASE_DONE;
2219 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2220 /* Do call back function */
2222 mtd_erase_callback(instr);
2224 /* Deselect and wake up anyone waiting on the device */
2225 nand_release_device(mtd);
2227 /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
2228 if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
2229 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
2230 if (rewrite_bbt[chipnr]) {
2231 /* update the BBT for chip */
2232 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2233 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2234 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2239 /* Return more or less happy */
2244 * nand_sync - [MTD Interface] sync
2245 * @mtd: MTD device structure
2247 * Sync is actually a wait for chip ready function
2249 static void nand_sync(struct mtd_info *mtd)
2251 struct nand_chip *this = mtd->priv;
2253 DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2255 /* Grab the lock and see if the device is available */
2256 nand_get_device(this, mtd, FL_SYNCING);
2257 /* Release it and go back */
2258 nand_release_device(mtd);
2262 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2263 * @mtd: MTD device structure
2264 * @ofs: offset relative to mtd start
2266 static int nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2268 /* Check for invalid offset */
2269 if (ofs > mtd->size)
2272 return nand_block_checkbad(mtd, ofs, 1, 0);
2276 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2277 * @mtd: MTD device structure
2278 * @ofs: offset relative to mtd start
2280 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2282 struct nand_chip *this = mtd->priv;
2285 if ((ret = nand_block_isbad(mtd, ofs))) {
2286 /* If it was bad already, return success and do nothing. */
2292 return this->block_markbad(mtd, ofs);
2296 * nand_suspend - [MTD Interface] Suspend the NAND flash
2297 * @mtd: MTD device structure
2299 static int nand_suspend(struct mtd_info *mtd)
2301 struct nand_chip *this = mtd->priv;
2303 return nand_get_device(this, mtd, FL_PM_SUSPENDED);
2307 * nand_resume - [MTD Interface] Resume the NAND flash
2308 * @mtd: MTD device structure
2310 static void nand_resume(struct mtd_info *mtd)
2312 struct nand_chip *this = mtd->priv;
2314 if (this->state == FL_PM_SUSPENDED)
2315 nand_release_device(mtd);
2317 printk(KERN_ERR "nand_resume() called for a chip which is not "
2318 "in suspended state\n");
2322 * Free allocated data structures
2324 static void nand_free_kmem(struct nand_chip *this)
2326 /* Buffer allocated by nand_scan ? */
2327 if (this->options & NAND_OOBBUF_ALLOC)
2328 kfree(this->oob_buf);
2329 /* Buffer allocated by nand_scan ? */
2330 if (this->options & NAND_DATABUF_ALLOC)
2331 kfree(this->data_buf);
2332 /* Controller allocated by nand_scan ? */
2333 if (this->options & NAND_CONTROLLER_ALLOC)
2334 kfree(this->controller);
2338 * Allocate buffers and data structures
2340 static int nand_allocate_kmem(struct mtd_info *mtd, struct nand_chip *this)
2344 if (!this->oob_buf) {
2345 len = mtd->oobsize <<
2346 (this->phys_erase_shift - this->page_shift);
2347 this->oob_buf = kmalloc(len, GFP_KERNEL);
2350 this->options |= NAND_OOBBUF_ALLOC;
2353 if (!this->data_buf) {
2354 len = mtd->oobblock + mtd->oobsize;
2355 this->data_buf = kmalloc(len, GFP_KERNEL);
2356 if (!this->data_buf)
2358 this->options |= NAND_DATABUF_ALLOC;
2361 if (!this->controller) {
2362 this->controller = kzalloc(sizeof(struct nand_hw_control),
2364 if (!this->controller)
2366 this->options |= NAND_CONTROLLER_ALLOC;
2371 printk(KERN_ERR "nand_scan(): Cannot allocate buffers\n");
2372 nand_free_kmem(this);
2377 * Set default functions
2379 static void nand_set_defaults(struct nand_chip *this, int busw)
2381 /* check for proper chip_delay setup, set 20us if not */
2382 if (!this->chip_delay)
2383 this->chip_delay = 20;
2385 /* check, if a user supplied command function given */
2386 if (this->cmdfunc == NULL)
2387 this->cmdfunc = nand_command;
2389 /* check, if a user supplied wait function given */
2390 if (this->waitfunc == NULL)
2391 this->waitfunc = nand_wait;
2393 if (!this->select_chip)
2394 this->select_chip = nand_select_chip;
2395 if (!this->write_byte)
2396 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2397 if (!this->read_byte)
2398 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2399 if (!this->write_word)
2400 this->write_word = nand_write_word;
2401 if (!this->read_word)
2402 this->read_word = nand_read_word;
2403 if (!this->block_bad)
2404 this->block_bad = nand_block_bad;
2405 if (!this->block_markbad)
2406 this->block_markbad = nand_default_block_markbad;
2407 if (!this->write_buf)
2408 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2409 if (!this->read_buf)
2410 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2411 if (!this->verify_buf)
2412 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2413 if (!this->scan_bbt)
2414 this->scan_bbt = nand_default_bbt;
2418 * Get the flash and manufacturer id and lookup if the typ is supported
2420 static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
2421 struct nand_chip *this,
2422 int busw, int *maf_id)
2424 struct nand_flash_dev *type = NULL;
2425 int i, dev_id, maf_idx;
2427 /* Select the device */
2428 this->select_chip(mtd, 0);
2430 /* Send the command for reading device ID */
2431 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2433 /* Read manufacturer and device IDs */
2434 *maf_id = this->read_byte(mtd);
2435 dev_id = this->read_byte(mtd);
2437 /* Lookup the flash id */
2438 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
2439 if (dev_id == nand_flash_ids[i].id) {
2440 type = &nand_flash_ids[i];
2446 return ERR_PTR(-ENODEV);
2448 this->chipsize = nand_flash_ids[i].chipsize << 20;
2450 /* Newer devices have all the information in additional id bytes */
2451 if (!nand_flash_ids[i].pagesize) {
2453 /* The 3rd id byte contains non relevant data ATM */
2454 extid = this->read_byte(mtd);
2455 /* The 4th id byte is the important one */
2456 extid = this->read_byte(mtd);
2458 mtd->oobblock = 1024 << (extid & 0x3);
2461 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->oobblock >> 9);
2463 /* Calc blocksize. Blocksize is multiples of 64KiB */
2464 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2466 /* Get buswidth information */
2467 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
2471 * Old devices have this data hardcoded in the device id table
2473 mtd->erasesize = nand_flash_ids[i].erasesize;
2474 mtd->oobblock = nand_flash_ids[i].pagesize;
2475 mtd->oobsize = mtd->oobblock / 32;
2476 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2479 /* Try to identify manufacturer */
2480 for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_id++) {
2481 if (nand_manuf_ids[maf_idx].id == *maf_id)
2486 * Check, if buswidth is correct. Hardware drivers should set
2489 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2490 printk(KERN_INFO "NAND device: Manufacturer ID:"
2491 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
2492 dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
2493 printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
2494 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2496 return ERR_PTR(-EINVAL);
2499 /* Calculate the address shift from the page size */
2500 this->page_shift = ffs(mtd->oobblock) - 1;
2501 /* Convert chipsize to number of pages per chip -1. */
2502 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2504 this->bbt_erase_shift = this->phys_erase_shift =
2505 ffs(mtd->erasesize) - 1;
2506 this->chip_shift = ffs(this->chipsize) - 1;
2508 /* Set the bad block position */
2509 this->badblockpos = mtd->oobblock > 512 ?
2510 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2512 /* Get chip options, preserve non chip based options */
2513 this->options &= ~NAND_CHIPOPTIONS_MSK;
2514 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2517 * Set this as a default. Board drivers can override it, if necessary
2519 this->options |= NAND_NO_AUTOINCR;
2521 /* Check if this is a not a samsung device. Do not clear the
2522 * options for chips which are not having an extended id.
2524 if (*maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2525 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
2527 /* Check for AND chips with 4 page planes */
2528 if (this->options & NAND_4PAGE_ARRAY)
2529 this->erase_cmd = multi_erase_cmd;
2531 this->erase_cmd = single_erase_cmd;
2533 /* Do not replace user supplied command function ! */
2534 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2535 this->cmdfunc = nand_command_lp;
2537 printk(KERN_INFO "NAND device: Manufacturer ID:"
2538 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, dev_id,
2539 nand_manuf_ids[maf_idx].name, type->name);
2544 /* module_text_address() isn't exported, and it's mostly a pointless
2545 test if this is a module _anyway_ -- they'd have to try _really_ hard
2546 to call us from in-kernel code if the core NAND support is modular. */
2548 #define caller_is_module() (1)
2550 #define caller_is_module() \
2551 module_text_address((unsigned long)__builtin_return_address(0))
2555 * nand_scan - [NAND Interface] Scan for the NAND device
2556 * @mtd: MTD device structure
2557 * @maxchips: Number of chips to scan for
2559 * This fills out all the uninitialized function pointers
2560 * with the defaults.
2561 * The flash ID is read and the mtd/chip structures are
2562 * filled with the appropriate values. Buffers are allocated if
2563 * they are not provided by the board driver
2564 * The mtd->owner field must be set to the module of the caller
2567 int nand_scan(struct mtd_info *mtd, int maxchips)
2569 int i, busw, nand_maf_id;
2570 struct nand_chip *this = mtd->priv;
2571 struct nand_flash_dev *type;
2573 /* Many callers got this wrong, so check for it for a while... */
2574 if (!mtd->owner && caller_is_module()) {
2575 printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
2579 /* Get buswidth to select the correct functions */
2580 busw = this->options & NAND_BUSWIDTH_16;
2581 /* Set the default functions */
2582 nand_set_defaults(this, busw);
2584 /* Read the flash type */
2585 type = nand_get_flash_type(mtd, this, busw, &nand_maf_id);
2588 printk(KERN_WARNING "No NAND device found!!!\n");
2589 this->select_chip(mtd, -1);
2590 return PTR_ERR(type);
2593 /* Check for a chip array */
2594 for (i = 1; i < maxchips; i++) {
2595 this->select_chip(mtd, i);
2596 /* Send the command for reading device ID */
2597 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2598 /* Read manufacturer and device IDs */
2599 if (nand_maf_id != this->read_byte(mtd) ||
2600 type->id != this->read_byte(mtd))
2604 printk(KERN_INFO "%d NAND chips detected\n", i);
2606 /* Store the number of chips and calc total size for mtd */
2608 mtd->size = i * this->chipsize;
2610 /* Allocate buffers and data structures */
2611 if (nand_allocate_kmem(mtd, this))
2614 /* Preset the internal oob buffer */
2615 memset(this->oob_buf, 0xff,
2616 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2619 * If no default placement scheme is given, select an appropriate one
2621 if (!this->autooob) {
2622 switch (mtd->oobsize) {
2624 this->autooob = &nand_oob_8;
2627 this->autooob = &nand_oob_16;
2630 this->autooob = &nand_oob_64;
2633 printk(KERN_WARNING "No oob scheme defined for "
2634 "oobsize %d\n", mtd->oobsize);
2640 * The number of bytes available for the filesystem to place fs
2641 * dependend oob data
2644 for (i = 0; this->autooob->oobfree[i][1]; i++)
2645 mtd->oobavail += this->autooob->oobfree[i][1];
2648 * check ECC mode, default to software if 3byte/512byte hardware ECC is
2649 * selected and we have 256 byte pagesize fallback to software ECC
2651 switch (this->ecc.mode) {
2653 case NAND_ECC_HW_SYNDROME:
2654 if (!this->ecc.calculate || !this->ecc.correct ||
2656 printk(KERN_WARNING "No ECC functions supplied, "
2657 "Hardware ECC not possible\n");
2660 if (mtd->oobblock >= this->ecc.size)
2662 printk(KERN_WARNING "%d byte HW ECC not possible on "
2663 "%d byte page size, fallback to SW ECC\n",
2664 this->ecc.size, mtd->oobblock);
2665 this->ecc.mode = NAND_ECC_SOFT;
2668 this->ecc.calculate = nand_calculate_ecc;
2669 this->ecc.correct = nand_correct_data;
2670 this->ecc.size = 256;
2671 this->ecc.bytes = 3;
2675 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
2676 "This is not recommended !!\n");
2677 this->ecc.size = mtd->oobblock;
2678 this->ecc.bytes = 0;
2681 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
2687 * Set the number of read / write steps for one page depending on ECC
2690 this->ecc.steps = mtd->oobblock / this->ecc.size;
2691 if(this->ecc.steps * this->ecc.size != mtd->oobblock) {
2692 printk(KERN_WARNING "Invalid ecc parameters\n");
2696 /* Initialize state, waitqueue and spinlock */
2697 this->state = FL_READY;
2698 init_waitqueue_head(&this->controller->wq);
2699 spin_lock_init(&this->controller->lock);
2701 /* De-select the device */
2702 this->select_chip(mtd, -1);
2704 /* Invalidate the pagebuffer reference */
2707 /* Fill in remaining MTD driver data */
2708 mtd->type = MTD_NANDFLASH;
2709 mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
2710 mtd->ecctype = MTD_ECC_SW;
2711 mtd->erase = nand_erase;
2713 mtd->unpoint = NULL;
2714 mtd->read = nand_read;
2715 mtd->write = nand_write;
2716 mtd->read_ecc = nand_read_ecc;
2717 mtd->write_ecc = nand_write_ecc;
2718 mtd->read_oob = nand_read_oob;
2719 mtd->write_oob = nand_write_oob;
2721 mtd->writev = nand_writev;
2722 mtd->writev_ecc = nand_writev_ecc;
2723 mtd->sync = nand_sync;
2726 mtd->suspend = nand_suspend;
2727 mtd->resume = nand_resume;
2728 mtd->block_isbad = nand_block_isbad;
2729 mtd->block_markbad = nand_block_markbad;
2731 /* and make the autooob the default one */
2732 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2734 /* Check, if we should skip the bad block table scan */
2735 if (this->options & NAND_SKIP_BBTSCAN)
2738 /* Build bad block table */
2739 return this->scan_bbt(mtd);
2743 * nand_release - [NAND Interface] Free resources held by the NAND device
2744 * @mtd: MTD device structure
2746 void nand_release(struct mtd_info *mtd)
2748 struct nand_chip *this = mtd->priv;
2750 #ifdef CONFIG_MTD_PARTITIONS
2751 /* Deregister partitions */
2752 del_mtd_partitions(mtd);
2754 /* Deregister the device */
2755 del_mtd_device(mtd);
2757 /* Free bad block table memory */
2760 nand_free_kmem(this);
2763 EXPORT_SYMBOL_GPL(nand_scan);
2764 EXPORT_SYMBOL_GPL(nand_release);
2766 static int __init nand_base_init(void)
2768 led_trigger_register_simple("nand-disk", &nand_led_trigger);
2772 static void __exit nand_base_exit(void)
2774 led_trigger_unregister_simple(nand_led_trigger);
2777 module_init(nand_base_init);
2778 module_exit(nand_base_exit);
2780 MODULE_LICENSE("GPL");
2781 MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2782 MODULE_DESCRIPTION("Generic NAND flash driver code");