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
;
156 if (erase_length
< meminfo
->erasesize
) {
157 printf("Warning: Erase size 0x%08x smaller than one " \
158 "erase block 0x%08x\n",erase_length
, meminfo
->erasesize
);
159 printf(" Erasing 0x%08x instead\n", meminfo
->erasesize
);
160 erase_length
= meminfo
->erasesize
;
164 erase
.addr
< opts
->offset
+ erase_length
;
165 erase
.addr
+= meminfo
->erasesize
) {
169 if (!opts
->scrub
&& bbtest
) {
170 int ret
= meminfo
->block_isbad(meminfo
, erase
.addr
);
173 printf("\rSkipping bad block at "
179 } else if (ret
< 0) {
180 printf("\n%s: MTD get bad block failed: %d\n",
187 result
= meminfo
->erase(meminfo
, &erase
);
189 printf("\n%s: MTD Erase failure: %d\n",
194 /* format for JFFS2 ? */
197 /* write cleanmarker */
200 result
= meminfo
->write_oob(meminfo
,
207 printf("\n%s: MTD writeoob failure: %d\n",
212 printf("\n%s: this erase routine only supports"
219 unsigned long long n
=(unsigned long long)
220 (erase
.addr
+ meminfo
->erasesize
- opts
->offset
)
224 do_div(n
, erase_length
);
227 /* output progress message only at whole percent
228 * steps to reduce the number of messages printed
229 * on (slow) serial consoles
231 if (percent
!= percent_complete
) {
232 percent_complete
= percent
;
234 printf("\rErasing at 0x%x -- %3d%% complete.",
235 erase
.addr
, percent
);
237 if (opts
->jffs2
&& result
== 0)
238 printf(" Cleanmarker written at 0x%x.",
246 if (nand_block_bad_old
) {
247 struct nand_chip
*priv_nand
= meminfo
->priv
;
249 priv_nand
->block_bad
= nand_block_bad_old
;
250 priv_nand
->scan_bbt(meminfo
);
256 #define MAX_PAGE_SIZE 2048
257 #define MAX_OOB_SIZE 64
260 * buffer array used for writing data
262 static unsigned char data_buf
[MAX_PAGE_SIZE
];
263 static unsigned char oob_buf
[MAX_OOB_SIZE
];
265 /* OOB layouts to pass into the kernel as default */
266 static struct nand_oobinfo none_oobinfo
= {
267 .useecc
= MTD_NANDECC_OFF
,
270 static struct nand_oobinfo jffs2_oobinfo
= {
271 .useecc
= MTD_NANDECC_PLACE
,
273 .eccpos
= { 0, 1, 2, 3, 6, 7 }
276 static struct nand_oobinfo yaffs_oobinfo
= {
277 .useecc
= MTD_NANDECC_PLACE
,
279 .eccpos
= { 8, 9, 10, 13, 14, 15}
282 static struct nand_oobinfo autoplace_oobinfo
= {
283 .useecc
= MTD_NANDECC_AUTOPLACE
287 * nand_write_opts: - write image to NAND flash with support for various options
289 * @param meminfo NAND device to erase
290 * @param opts write options (@see nand_write_options)
291 * @return 0 in case of success
293 * This code is ported from nandwrite.c from Linux mtd utils by
294 * Steven J. Hill and Thomas Gleixner.
296 int nand_write_opts(nand_info_t
*meminfo
, const nand_write_options_t
*opts
)
304 int oobinfochanged
= 0;
305 int percent_complete
= -1;
306 struct nand_oobinfo old_oobinfo
;
307 ulong mtdoffset
= opts
->offset
;
308 ulong erasesize_blockalign
;
309 u_char
*buffer
= opts
->buffer
;
313 if (opts
->pad
&& opts
->writeoob
) {
314 printf("Can't pad when oob data is present.\n");
318 /* set erasesize to specified number of blocks - to match
319 * jffs2 (virtual) block size */
320 if (opts
->blockalign
== 0) {
321 erasesize_blockalign
= meminfo
->erasesize
;
323 erasesize_blockalign
= meminfo
->erasesize
* opts
->blockalign
;
326 /* make sure device page sizes are valid */
327 if (!(meminfo
->oobsize
== 16 && meminfo
->oobblock
== 512)
328 && !(meminfo
->oobsize
== 8 && meminfo
->oobblock
== 256)
329 && !(meminfo
->oobsize
== 64 && meminfo
->oobblock
== 2048)) {
330 printf("Unknown flash (not normal NAND)\n");
334 /* read the current oob info */
335 memcpy(&old_oobinfo
, &meminfo
->oobinfo
, sizeof(old_oobinfo
));
337 /* write without ecc? */
339 memcpy(&meminfo
->oobinfo
, &none_oobinfo
,
340 sizeof(meminfo
->oobinfo
));
345 if (opts
->autoplace
&& (old_oobinfo
.useecc
!= MTD_NANDECC_AUTOPLACE
)) {
347 memcpy(&meminfo
->oobinfo
, &autoplace_oobinfo
,
348 sizeof(meminfo
->oobinfo
));
352 /* force OOB layout for jffs2 or yaffs? */
353 if (opts
->forcejffs2
|| opts
->forceyaffs
) {
354 struct nand_oobinfo
*oobsel
=
355 opts
->forcejffs2
? &jffs2_oobinfo
: &yaffs_oobinfo
;
357 if (meminfo
->oobsize
== 8) {
358 if (opts
->forceyaffs
) {
359 printf("YAFSS cannot operate on "
360 "256 Byte page size\n");
363 /* Adjust number of ecc bytes */
364 jffs2_oobinfo
.eccbytes
= 3;
367 memcpy(&meminfo
->oobinfo
, oobsel
, sizeof(meminfo
->oobinfo
));
370 /* get image length */
371 imglen
= opts
->length
;
372 pagelen
= meminfo
->oobblock
373 + ((opts
->writeoob
!= 0) ? meminfo
->oobsize
: 0);
375 /* check, if file is pagealigned */
376 if ((!opts
->pad
) && ((imglen
% pagelen
) != 0)) {
377 printf("Input block length is not page aligned\n");
381 /* check, if length fits into device */
382 if (((imglen
/ pagelen
) * meminfo
->oobblock
)
383 > (meminfo
->size
- opts
->offset
)) {
384 printf("Image %d bytes, NAND page %d bytes, "
385 "OOB area %u bytes, device size %u bytes\n",
386 imglen
, pagelen
, meminfo
->oobblock
, meminfo
->size
);
387 printf("Input block does not fit into device\n");
394 /* get data from input and write to the device */
395 while (imglen
&& (mtdoffset
< meminfo
->size
)) {
400 * new eraseblock, check for bad block(s). Stay in the
401 * loop to be sure if the offset changes because of
402 * a bad block, that the next block that will be
403 * written to is also checked. Thus avoiding errors if
404 * the block(s) after the skipped block(s) is also bad
405 * (number of blocks depending on the blockalign
407 while (blockstart
!= (mtdoffset
& (~erasesize_blockalign
+1))) {
408 blockstart
= mtdoffset
& (~erasesize_blockalign
+1);
412 /* check all the blocks in an erase block for
415 int ret
= meminfo
->block_isbad(meminfo
, offs
);
418 printf("Bad block check failed\n");
424 printf("\rBad block at 0x%lx "
425 "in erase block from "
426 "0x%x will be skipped\n",
432 mtdoffset
= blockstart
433 + erasesize_blockalign
;
435 offs
+= erasesize_blockalign
437 } while (offs
< blockstart
+ erasesize_blockalign
);
440 readlen
= meminfo
->oobblock
;
441 if (opts
->pad
&& (imglen
< readlen
)) {
443 memset(data_buf
+ readlen
, 0xff,
444 meminfo
->oobblock
- readlen
);
447 /* read page data from input memory buffer */
448 memcpy(data_buf
, buffer
, readlen
);
451 if (opts
->writeoob
) {
452 /* read OOB data from input memory block, exit
454 memcpy(oob_buf
, buffer
, meminfo
->oobsize
);
455 buffer
+= meminfo
->oobsize
;
457 /* write OOB data first, as ecc will be placed
459 result
= meminfo
->write_oob(meminfo
,
467 printf("\nMTD writeoob failure: %d\n",
471 imglen
-= meminfo
->oobsize
;
474 /* write out the page data */
475 result
= meminfo
->write(meminfo
,
479 (unsigned char *) &data_buf
);
482 printf("writing NAND page at offset 0x%lx failed\n",
489 unsigned long long n
= (unsigned long long)
490 (opts
->length
-imglen
) * 100;
493 do_div(n
, opts
->length
);
496 /* output progress message only at whole percent
497 * steps to reduce the number of messages printed
498 * on (slow) serial consoles
500 if (percent
!= percent_complete
) {
501 printf("\rWriting data at 0x%x "
502 "-- %3d%% complete.",
504 percent_complete
= percent
;
508 mtdoffset
+= meminfo
->oobblock
;
515 if (oobinfochanged
) {
516 memcpy(&meminfo
->oobinfo
, &old_oobinfo
,
517 sizeof(meminfo
->oobinfo
));
521 printf("Data did not fit into device, due to bad blocks\n");
530 * nand_read_opts: - read image from NAND flash with support for various options
532 * @param meminfo NAND device to erase
533 * @param opts read options (@see struct nand_read_options)
534 * @return 0 in case of success
537 int nand_read_opts(nand_info_t
*meminfo
, const nand_read_options_t
*opts
)
539 int imglen
= opts
->length
;
543 int percent_complete
= -1;
546 ulong mtdoffset
= opts
->offset
;
547 u_char
*buffer
= opts
->buffer
;
550 /* make sure device page sizes are valid */
551 if (!(meminfo
->oobsize
== 16 && meminfo
->oobblock
== 512)
552 && !(meminfo
->oobsize
== 8 && meminfo
->oobblock
== 256)
553 && !(meminfo
->oobsize
== 64 && meminfo
->oobblock
== 2048)) {
554 printf("Unknown flash (not normal NAND)\n");
558 pagelen
= meminfo
->oobblock
559 + ((opts
->readoob
!= 0) ? meminfo
->oobsize
: 0);
561 /* check, if length is not larger than device */
562 if (((imglen
/ pagelen
) * meminfo
->oobblock
)
563 > (meminfo
->size
- opts
->offset
)) {
564 printf("Image %d bytes, NAND page %d bytes, "
565 "OOB area %u bytes, device size %u bytes\n",
566 imglen
, pagelen
, meminfo
->oobblock
, meminfo
->size
);
567 printf("Input block is larger than device\n");
574 /* get data from input and write to the device */
575 while (imglen
&& (mtdoffset
< meminfo
->size
)) {
580 * new eraseblock, check for bad block(s). Stay in the
581 * loop to be sure if the offset changes because of
582 * a bad block, that the next block that will be
583 * written to is also checked. Thus avoiding errors if
584 * the block(s) after the skipped block(s) is also bad
585 * (number of blocks depending on the blockalign
587 while (blockstart
!= (mtdoffset
& (~meminfo
->erasesize
+1))) {
588 blockstart
= mtdoffset
& (~meminfo
->erasesize
+1);
592 /* check all the blocks in an erase block for
595 int ret
= meminfo
->block_isbad(meminfo
, offs
);
598 printf("Bad block check failed\n");
604 printf("\rBad block at 0x%lx "
605 "in erase block from "
606 "0x%x will be skipped\n",
612 mtdoffset
= blockstart
613 + meminfo
->erasesize
;
615 offs
+= meminfo
->erasesize
;
617 } while (offs
< blockstart
+ meminfo
->erasesize
);
621 /* read page data to memory buffer */
622 result
= meminfo
->read(meminfo
,
626 (unsigned char *) &data_buf
);
629 printf("reading NAND page at offset 0x%lx failed\n",
634 if (imglen
< readlen
) {
638 memcpy(buffer
, data_buf
, readlen
);
643 result
= meminfo
->read_oob(meminfo
,
651 printf("\nMTD readoob failure: %d\n",
657 if (imglen
< readlen
) {
661 memcpy(buffer
, oob_buf
, readlen
);
668 unsigned long long n
= (unsigned long long)
669 (opts
->length
-imglen
) * 100;
672 do_div(n
, opts
->length
);
675 /* output progress message only at whole percent
676 * steps to reduce the number of messages printed
677 * on (slow) serial consoles
679 if (percent
!= percent_complete
) {
681 printf("\rReading data from 0x%x "
682 "-- %3d%% complete.",
684 percent_complete
= percent
;
688 mtdoffset
+= meminfo
->oobblock
;
695 printf("Could not read entire image due to bad blocks\n");
703 /******************************************************************************
704 * Support for locking / unlocking operations of some NAND devices
705 *****************************************************************************/
707 #define NAND_CMD_LOCK 0x2a
708 #define NAND_CMD_LOCK_TIGHT 0x2c
709 #define NAND_CMD_UNLOCK1 0x23
710 #define NAND_CMD_UNLOCK2 0x24
711 #define NAND_CMD_LOCK_STATUS 0x7a
714 * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
717 * @param meminfo nand mtd instance
718 * @param tight bring device in lock tight mode
720 * @return 0 on success, -1 in case of error
722 * The lock / lock-tight command only applies to the whole chip. To get some
723 * parts of the chip lock and others unlocked use the following sequence:
725 * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
726 * - Call nand_unlock() once for each consecutive area to be unlocked
727 * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
729 * If the device is in lock-tight state software can't change the
730 * current active lock/unlock state of all pages. nand_lock() / nand_unlock()
731 * calls will fail. It is only posible to leave lock-tight state by
732 * an hardware signal (low pulse on _WP pin) or by power down.
734 int nand_lock(nand_info_t
*meminfo
, int tight
)
738 struct nand_chip
*this = meminfo
->priv
;
740 /* select the NAND device */
741 this->select_chip(meminfo
, 0);
743 this->cmdfunc(meminfo
,
744 (tight
? NAND_CMD_LOCK_TIGHT
: NAND_CMD_LOCK
),
747 /* call wait ready function */
748 status
= this->waitfunc(meminfo
, this, FL_WRITING
);
750 /* see if device thinks it succeeded */
755 /* de-select the NAND device */
756 this->select_chip(meminfo
, -1);
761 * nand_get_lock_status: - query current lock state from one page of NAND
764 * @param meminfo nand mtd instance
765 * @param offset page address to query (muss be page aligned!)
767 * @return -1 in case of error
769 * bitfield with the following combinations:
770 * NAND_LOCK_STATUS_TIGHT: page in tight state
771 * NAND_LOCK_STATUS_LOCK: page locked
772 * NAND_LOCK_STATUS_UNLOCK: page unlocked
775 int nand_get_lock_status(nand_info_t
*meminfo
, ulong offset
)
780 struct nand_chip
*this = meminfo
->priv
;
782 /* select the NAND device */
783 chipnr
= (int)(offset
>> this->chip_shift
);
784 this->select_chip(meminfo
, chipnr
);
787 if ((offset
& (meminfo
->oobblock
- 1)) != 0) {
788 printf ("nand_get_lock_status: "
789 "Start address must be beginning of "
795 /* check the Lock Status */
796 page
= (int)(offset
>> this->page_shift
);
797 this->cmdfunc(meminfo
, NAND_CMD_LOCK_STATUS
, -1, page
& this->pagemask
);
799 ret
= this->read_byte(meminfo
) & (NAND_LOCK_STATUS_TIGHT
800 | NAND_LOCK_STATUS_LOCK
801 | NAND_LOCK_STATUS_UNLOCK
);
804 /* de-select the NAND device */
805 this->select_chip(meminfo
, -1);
810 * nand_unlock: - Unlock area of NAND pages
811 * only one consecutive area can be unlocked at one time!
813 * @param meminfo nand mtd instance
814 * @param start start byte address
815 * @param length number of bytes to unlock (must be a multiple of
816 * page size nand->oobblock)
818 * @return 0 on success, -1 in case of error
820 int nand_unlock(nand_info_t
*meminfo
, ulong start
, ulong length
)
826 struct nand_chip
*this = meminfo
->priv
;
827 printf ("nand_unlock: start: %08x, length: %d!\n",
828 (int)start
, (int)length
);
830 /* select the NAND device */
831 chipnr
= (int)(start
>> this->chip_shift
);
832 this->select_chip(meminfo
, chipnr
);
834 /* check the WP bit */
835 this->cmdfunc(meminfo
, NAND_CMD_STATUS
, -1, -1);
836 if ((this->read_byte(meminfo
) & 0x80) == 0) {
837 printf ("nand_unlock: Device is write protected!\n");
842 if ((start
& (meminfo
->oobblock
- 1)) != 0) {
843 printf ("nand_unlock: Start address must be beginning of "
849 if (length
== 0 || (length
& (meminfo
->oobblock
- 1)) != 0) {
850 printf ("nand_unlock: Length must be a multiple of nand page "
856 /* submit address of first page to unlock */
857 page
= (int)(start
>> this->page_shift
);
858 this->cmdfunc(meminfo
, NAND_CMD_UNLOCK1
, -1, page
& this->pagemask
);
860 /* submit ADDRESS of LAST page to unlock */
861 page
+= (int)(length
>> this->page_shift
) - 1;
862 this->cmdfunc(meminfo
, NAND_CMD_UNLOCK2
, -1, page
& this->pagemask
);
864 /* call wait ready function */
865 status
= this->waitfunc(meminfo
, this, FL_WRITING
);
866 /* see if device thinks it succeeded */
868 /* there was an error */
874 /* de-select the NAND device */
875 this->select_chip(meminfo
, -1);