2 * drivers/mtd/nand/nand_util.c
4 * Copyright (C) 2006 by Weiss-Electronic GmbH.
7 * @author: Guido Classen <clagix@gmail.com>
8 * @descr: NAND Flash support
9 * @references: borrowed heavily from Linux mtd-utils code:
10 * flash_eraseall.c by Arcom Control System Ltd
11 * nandwrite.c by Steven J. Hill (sjhill@realitydiluted.com)
12 * and Thomas Gleixner (tglx@linutronix.de)
14 * See file CREDITS for list of people who contributed to this
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License version
19 * 2 as published by the Free Software Foundation.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
35 #if defined(CONFIG_CMD_NAND) && !defined(CFG_NAND_LEGACY)
43 #include <jffs2/jffs2.h>
45 typedef struct erase_info erase_info_t
;
46 typedef struct mtd_info mtd_info_t
;
48 /* support only for native endian JFFS2 */
49 #define cpu_to_je16(x) (x)
50 #define cpu_to_je32(x) (x)
52 /*****************************************************************************/
53 static int nand_block_bad_scrub(struct mtd_info
*mtd
, loff_t ofs
, int getchip
)
59 * nand_erase_opts: - erase NAND flash with support for various options
62 * @param meminfo NAND device to erase
63 * @param opts options, @see struct nand_erase_options
64 * @return 0 in case of success
66 * This code is ported from flash_eraseall.c from Linux mtd utils by
67 * Arcom Control System Ltd.
69 int nand_erase_opts(nand_info_t
*meminfo
, const nand_erase_options_t
*opts
)
71 struct jffs2_unknown_node cleanmarker
;
79 int percent_complete
= -1;
80 int (*nand_block_bad_old
)(struct mtd_info
*, loff_t
, int) = NULL
;
81 const char *mtd_device
= meminfo
->name
;
83 memset(&erase
, 0, sizeof(erase
));
86 erase
.len
= meminfo
->erasesize
;
87 erase
.addr
= opts
->offset
;
88 erase_length
= opts
->length
;
90 isNAND
= meminfo
->type
== MTD_NANDFLASH
? 1 : 0;
93 cleanmarker
.magic
= cpu_to_je16 (JFFS2_MAGIC_BITMASK
);
94 cleanmarker
.nodetype
= cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER
);
96 struct nand_oobinfo
*oobinfo
= &meminfo
->oobinfo
;
98 /* check for autoplacement */
99 if (oobinfo
->useecc
== MTD_NANDECC_AUTOPLACE
) {
100 /* get the position of the free bytes */
101 if (!oobinfo
->oobfree
[0][1]) {
102 printf(" Eeep. Autoplacement selected "
103 "and no empty space in oob\n");
106 clmpos
= oobinfo
->oobfree
[0][0];
107 clmlen
= oobinfo
->oobfree
[0][1];
112 switch (meminfo
->oobsize
) {
128 cleanmarker
.totlen
= cpu_to_je32(8);
131 cpu_to_je32(sizeof(struct jffs2_unknown_node
));
133 cleanmarker
.hdr_crc
= cpu_to_je32(
134 crc32_no_comp(0, (unsigned char *) &cleanmarker
,
135 sizeof(struct jffs2_unknown_node
) - 4));
138 /* scrub option allows to erase badblock. To prevent internal
139 * check from erase() method, set block check method to dummy
140 * and disable bad block table while erasing.
143 struct nand_chip
*priv_nand
= meminfo
->priv
;
145 nand_block_bad_old
= priv_nand
->block_bad
;
146 priv_nand
->block_bad
= nand_block_bad_scrub
;
147 /* we don't need the bad block table anymore...
148 * after scrub, there are no bad blocks left!
150 if (priv_nand
->bbt
) {
151 kfree(priv_nand
->bbt
);
153 priv_nand
->bbt
= NULL
;
157 erase
.addr
< opts
->offset
+ erase_length
;
158 erase
.addr
+= meminfo
->erasesize
) {
162 if (!opts
->scrub
&& bbtest
) {
163 int ret
= meminfo
->block_isbad(meminfo
, erase
.addr
);
166 printf("\rSkipping bad block at "
172 } else if (ret
< 0) {
173 printf("\n%s: MTD get bad block failed: %d\n",
180 result
= meminfo
->erase(meminfo
, &erase
);
182 printf("\n%s: MTD Erase failure: %d\n",
187 /* format for JFFS2 ? */
190 /* write cleanmarker */
193 result
= meminfo
->write_oob(meminfo
,
200 printf("\n%s: MTD writeoob failure: %d\n",
205 printf("\n%s: this erase routine only supports"
212 unsigned long long n
=(unsigned long long)
213 (erase
.addr
+ meminfo
->erasesize
- opts
->offset
)
217 do_div(n
, erase_length
);
220 /* output progress message only at whole percent
221 * steps to reduce the number of messages printed
222 * on (slow) serial consoles
224 if (percent
!= percent_complete
) {
225 percent_complete
= percent
;
227 printf("\rErasing at 0x%x -- %3d%% complete.",
228 erase
.addr
, percent
);
230 if (opts
->jffs2
&& result
== 0)
231 printf(" Cleanmarker written at 0x%x.",
239 if (nand_block_bad_old
) {
240 struct nand_chip
*priv_nand
= meminfo
->priv
;
242 priv_nand
->block_bad
= nand_block_bad_old
;
243 priv_nand
->scan_bbt(meminfo
);
249 #define MAX_PAGE_SIZE 2048
250 #define MAX_OOB_SIZE 64
253 * buffer array used for writing data
255 static unsigned char data_buf
[MAX_PAGE_SIZE
];
256 static unsigned char oob_buf
[MAX_OOB_SIZE
];
258 /* OOB layouts to pass into the kernel as default */
259 static struct nand_oobinfo none_oobinfo
= {
260 .useecc
= MTD_NANDECC_OFF
,
263 static struct nand_oobinfo jffs2_oobinfo
= {
264 .useecc
= MTD_NANDECC_PLACE
,
266 .eccpos
= { 0, 1, 2, 3, 6, 7 }
269 static struct nand_oobinfo yaffs_oobinfo
= {
270 .useecc
= MTD_NANDECC_PLACE
,
272 .eccpos
= { 8, 9, 10, 13, 14, 15}
275 static struct nand_oobinfo autoplace_oobinfo
= {
276 .useecc
= MTD_NANDECC_AUTOPLACE
280 * nand_write_opts: - write image to NAND flash with support for various options
282 * @param meminfo NAND device to erase
283 * @param opts write options (@see nand_write_options)
284 * @return 0 in case of success
286 * This code is ported from nandwrite.c from Linux mtd utils by
287 * Steven J. Hill and Thomas Gleixner.
289 int nand_write_opts(nand_info_t
*meminfo
, const nand_write_options_t
*opts
)
297 int oobinfochanged
= 0;
298 int percent_complete
= -1;
299 struct nand_oobinfo old_oobinfo
;
300 ulong mtdoffset
= opts
->offset
;
301 ulong erasesize_blockalign
;
302 u_char
*buffer
= opts
->buffer
;
306 if (opts
->pad
&& opts
->writeoob
) {
307 printf("Can't pad when oob data is present.\n");
311 /* set erasesize to specified number of blocks - to match
312 * jffs2 (virtual) block size */
313 if (opts
->blockalign
== 0) {
314 erasesize_blockalign
= meminfo
->erasesize
;
316 erasesize_blockalign
= meminfo
->erasesize
* opts
->blockalign
;
319 /* make sure device page sizes are valid */
320 if (!(meminfo
->oobsize
== 16 && meminfo
->oobblock
== 512)
321 && !(meminfo
->oobsize
== 8 && meminfo
->oobblock
== 256)
322 && !(meminfo
->oobsize
== 64 && meminfo
->oobblock
== 2048)) {
323 printf("Unknown flash (not normal NAND)\n");
327 /* read the current oob info */
328 memcpy(&old_oobinfo
, &meminfo
->oobinfo
, sizeof(old_oobinfo
));
330 /* write without ecc? */
332 memcpy(&meminfo
->oobinfo
, &none_oobinfo
,
333 sizeof(meminfo
->oobinfo
));
338 if (opts
->autoplace
&& (old_oobinfo
.useecc
!= MTD_NANDECC_AUTOPLACE
)) {
340 memcpy(&meminfo
->oobinfo
, &autoplace_oobinfo
,
341 sizeof(meminfo
->oobinfo
));
345 /* force OOB layout for jffs2 or yaffs? */
346 if (opts
->forcejffs2
|| opts
->forceyaffs
) {
347 struct nand_oobinfo
*oobsel
=
348 opts
->forcejffs2
? &jffs2_oobinfo
: &yaffs_oobinfo
;
350 if (meminfo
->oobsize
== 8) {
351 if (opts
->forceyaffs
) {
352 printf("YAFSS cannot operate on "
353 "256 Byte page size\n");
356 /* Adjust number of ecc bytes */
357 jffs2_oobinfo
.eccbytes
= 3;
360 memcpy(&meminfo
->oobinfo
, oobsel
, sizeof(meminfo
->oobinfo
));
363 /* get image length */
364 imglen
= opts
->length
;
365 pagelen
= meminfo
->oobblock
366 + ((opts
->writeoob
!= 0) ? meminfo
->oobsize
: 0);
368 /* check, if file is pagealigned */
369 if ((!opts
->pad
) && ((imglen
% pagelen
) != 0)) {
370 printf("Input block length is not page aligned\n");
374 /* check, if length fits into device */
375 if (((imglen
/ pagelen
) * meminfo
->oobblock
)
376 > (meminfo
->size
- opts
->offset
)) {
377 printf("Image %d bytes, NAND page %d bytes, "
378 "OOB area %u bytes, device size %u bytes\n",
379 imglen
, pagelen
, meminfo
->oobblock
, meminfo
->size
);
380 printf("Input block does not fit into device\n");
387 /* get data from input and write to the device */
388 while (imglen
&& (mtdoffset
< meminfo
->size
)) {
393 * new eraseblock, check for bad block(s). Stay in the
394 * loop to be sure if the offset changes because of
395 * a bad block, that the next block that will be
396 * written to is also checked. Thus avoiding errors if
397 * the block(s) after the skipped block(s) is also bad
398 * (number of blocks depending on the blockalign
400 while (blockstart
!= (mtdoffset
& (~erasesize_blockalign
+1))) {
401 blockstart
= mtdoffset
& (~erasesize_blockalign
+1);
405 /* check all the blocks in an erase block for
408 int ret
= meminfo
->block_isbad(meminfo
, offs
);
411 printf("Bad block check failed\n");
417 printf("\rBad block at 0x%lx "
418 "in erase block from "
419 "0x%x will be skipped\n",
425 mtdoffset
= blockstart
426 + erasesize_blockalign
;
428 offs
+= erasesize_blockalign
430 } while (offs
< blockstart
+ erasesize_blockalign
);
433 readlen
= meminfo
->oobblock
;
434 if (opts
->pad
&& (imglen
< readlen
)) {
436 memset(data_buf
+ readlen
, 0xff,
437 meminfo
->oobblock
- readlen
);
440 /* read page data from input memory buffer */
441 memcpy(data_buf
, buffer
, readlen
);
444 if (opts
->writeoob
) {
445 /* read OOB data from input memory block, exit
447 memcpy(oob_buf
, buffer
, meminfo
->oobsize
);
448 buffer
+= meminfo
->oobsize
;
450 /* write OOB data first, as ecc will be placed
452 result
= meminfo
->write_oob(meminfo
,
460 printf("\nMTD writeoob failure: %d\n",
464 imglen
-= meminfo
->oobsize
;
467 /* write out the page data */
468 result
= meminfo
->write(meminfo
,
472 (unsigned char *) &data_buf
);
475 printf("writing NAND page at offset 0x%lx failed\n",
482 unsigned long long n
= (unsigned long long)
483 (opts
->length
-imglen
) * 100;
486 do_div(n
, opts
->length
);
489 /* output progress message only at whole percent
490 * steps to reduce the number of messages printed
491 * on (slow) serial consoles
493 if (percent
!= percent_complete
) {
494 printf("\rWriting data at 0x%x "
495 "-- %3d%% complete.",
497 percent_complete
= percent
;
501 mtdoffset
+= meminfo
->oobblock
;
508 if (oobinfochanged
) {
509 memcpy(&meminfo
->oobinfo
, &old_oobinfo
,
510 sizeof(meminfo
->oobinfo
));
514 printf("Data did not fit into device, due to bad blocks\n");
523 * nand_read_opts: - read image from NAND flash with support for various options
525 * @param meminfo NAND device to erase
526 * @param opts read options (@see struct nand_read_options)
527 * @return 0 in case of success
530 int nand_read_opts(nand_info_t
*meminfo
, const nand_read_options_t
*opts
)
532 int imglen
= opts
->length
;
536 int percent_complete
= -1;
539 ulong mtdoffset
= opts
->offset
;
540 u_char
*buffer
= opts
->buffer
;
543 /* make sure device page sizes are valid */
544 if (!(meminfo
->oobsize
== 16 && meminfo
->oobblock
== 512)
545 && !(meminfo
->oobsize
== 8 && meminfo
->oobblock
== 256)
546 && !(meminfo
->oobsize
== 64 && meminfo
->oobblock
== 2048)) {
547 printf("Unknown flash (not normal NAND)\n");
551 pagelen
= meminfo
->oobblock
552 + ((opts
->readoob
!= 0) ? meminfo
->oobsize
: 0);
554 /* check, if length is not larger than device */
555 if (((imglen
/ pagelen
) * meminfo
->oobblock
)
556 > (meminfo
->size
- opts
->offset
)) {
557 printf("Image %d bytes, NAND page %d bytes, "
558 "OOB area %u bytes, device size %u bytes\n",
559 imglen
, pagelen
, meminfo
->oobblock
, meminfo
->size
);
560 printf("Input block is larger than device\n");
567 /* get data from input and write to the device */
568 while (imglen
&& (mtdoffset
< meminfo
->size
)) {
573 * new eraseblock, check for bad block(s). Stay in the
574 * loop to be sure if the offset changes because of
575 * a bad block, that the next block that will be
576 * written to is also checked. Thus avoiding errors if
577 * the block(s) after the skipped block(s) is also bad
578 * (number of blocks depending on the blockalign
580 while (blockstart
!= (mtdoffset
& (~meminfo
->erasesize
+1))) {
581 blockstart
= mtdoffset
& (~meminfo
->erasesize
+1);
585 /* check all the blocks in an erase block for
588 int ret
= meminfo
->block_isbad(meminfo
, offs
);
591 printf("Bad block check failed\n");
597 printf("\rBad block at 0x%lx "
598 "in erase block from "
599 "0x%x will be skipped\n",
605 mtdoffset
= blockstart
606 + meminfo
->erasesize
;
608 offs
+= meminfo
->erasesize
;
610 } while (offs
< blockstart
+ meminfo
->erasesize
);
614 /* read page data to memory buffer */
615 result
= meminfo
->read(meminfo
,
619 (unsigned char *) &data_buf
);
622 printf("reading NAND page at offset 0x%lx failed\n",
627 if (imglen
< readlen
) {
631 memcpy(buffer
, data_buf
, readlen
);
636 result
= meminfo
->read_oob(meminfo
,
644 printf("\nMTD readoob failure: %d\n",
650 if (imglen
< readlen
) {
654 memcpy(buffer
, oob_buf
, readlen
);
661 unsigned long long n
= (unsigned long long)
662 (opts
->length
-imglen
) * 100;
665 do_div(n
, opts
->length
);
668 /* output progress message only at whole percent
669 * steps to reduce the number of messages printed
670 * on (slow) serial consoles
672 if (percent
!= percent_complete
) {
674 printf("\rReading data from 0x%x "
675 "-- %3d%% complete.",
677 percent_complete
= percent
;
681 mtdoffset
+= meminfo
->oobblock
;
688 printf("Could not read entire image due to bad blocks\n");
696 /******************************************************************************
697 * Support for locking / unlocking operations of some NAND devices
698 *****************************************************************************/
700 #define NAND_CMD_LOCK 0x2a
701 #define NAND_CMD_LOCK_TIGHT 0x2c
702 #define NAND_CMD_UNLOCK1 0x23
703 #define NAND_CMD_UNLOCK2 0x24
704 #define NAND_CMD_LOCK_STATUS 0x7a
707 * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
710 * @param meminfo nand mtd instance
711 * @param tight bring device in lock tight mode
713 * @return 0 on success, -1 in case of error
715 * The lock / lock-tight command only applies to the whole chip. To get some
716 * parts of the chip lock and others unlocked use the following sequence:
718 * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
719 * - Call nand_unlock() once for each consecutive area to be unlocked
720 * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
722 * If the device is in lock-tight state software can't change the
723 * current active lock/unlock state of all pages. nand_lock() / nand_unlock()
724 * calls will fail. It is only posible to leave lock-tight state by
725 * an hardware signal (low pulse on _WP pin) or by power down.
727 int nand_lock(nand_info_t
*meminfo
, int tight
)
731 struct nand_chip
*this = meminfo
->priv
;
733 /* select the NAND device */
734 this->select_chip(meminfo
, 0);
736 this->cmdfunc(meminfo
,
737 (tight
? NAND_CMD_LOCK_TIGHT
: NAND_CMD_LOCK
),
740 /* call wait ready function */
741 status
= this->waitfunc(meminfo
, this, FL_WRITING
);
743 /* see if device thinks it succeeded */
748 /* de-select the NAND device */
749 this->select_chip(meminfo
, -1);
754 * nand_get_lock_status: - query current lock state from one page of NAND
757 * @param meminfo nand mtd instance
758 * @param offset page address to query (muss be page aligned!)
760 * @return -1 in case of error
762 * bitfield with the following combinations:
763 * NAND_LOCK_STATUS_TIGHT: page in tight state
764 * NAND_LOCK_STATUS_LOCK: page locked
765 * NAND_LOCK_STATUS_UNLOCK: page unlocked
768 int nand_get_lock_status(nand_info_t
*meminfo
, ulong offset
)
773 struct nand_chip
*this = meminfo
->priv
;
775 /* select the NAND device */
776 chipnr
= (int)(offset
>> this->chip_shift
);
777 this->select_chip(meminfo
, chipnr
);
780 if ((offset
& (meminfo
->oobblock
- 1)) != 0) {
781 printf ("nand_get_lock_status: "
782 "Start address must be beginning of "
788 /* check the Lock Status */
789 page
= (int)(offset
>> this->page_shift
);
790 this->cmdfunc(meminfo
, NAND_CMD_LOCK_STATUS
, -1, page
& this->pagemask
);
792 ret
= this->read_byte(meminfo
) & (NAND_LOCK_STATUS_TIGHT
793 | NAND_LOCK_STATUS_LOCK
794 | NAND_LOCK_STATUS_UNLOCK
);
797 /* de-select the NAND device */
798 this->select_chip(meminfo
, -1);
803 * nand_unlock: - Unlock area of NAND pages
804 * only one consecutive area can be unlocked at one time!
806 * @param meminfo nand mtd instance
807 * @param start start byte address
808 * @param length number of bytes to unlock (must be a multiple of
809 * page size nand->oobblock)
811 * @return 0 on success, -1 in case of error
813 int nand_unlock(nand_info_t
*meminfo
, ulong start
, ulong length
)
819 struct nand_chip
*this = meminfo
->priv
;
820 printf ("nand_unlock: start: %08x, length: %d!\n",
821 (int)start
, (int)length
);
823 /* select the NAND device */
824 chipnr
= (int)(start
>> this->chip_shift
);
825 this->select_chip(meminfo
, chipnr
);
827 /* check the WP bit */
828 this->cmdfunc(meminfo
, NAND_CMD_STATUS
, -1, -1);
829 if ((this->read_byte(meminfo
) & 0x80) == 0) {
830 printf ("nand_unlock: Device is write protected!\n");
835 if ((start
& (meminfo
->oobblock
- 1)) != 0) {
836 printf ("nand_unlock: Start address must be beginning of "
842 if (length
== 0 || (length
& (meminfo
->oobblock
- 1)) != 0) {
843 printf ("nand_unlock: Length must be a multiple of nand page "
849 /* submit address of first page to unlock */
850 page
= (int)(start
>> this->page_shift
);
851 this->cmdfunc(meminfo
, NAND_CMD_UNLOCK1
, -1, page
& this->pagemask
);
853 /* submit ADDRESS of LAST page to unlock */
854 page
+= (int)(length
>> this->page_shift
) - 1;
855 this->cmdfunc(meminfo
, NAND_CMD_UNLOCK2
, -1, page
& this->pagemask
);
857 /* call wait ready function */
858 status
= this->waitfunc(meminfo
, this, FL_WRITING
);
859 /* see if device thinks it succeeded */
861 /* there was an error */
867 /* de-select the NAND device */
868 this->select_chip(meminfo
, -1);