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 * Copyright (C) 2008 Nokia Corporation: drop_ffs() function by
15 * Artem Bityutskiy <dedekind1@gmail.com> from mtd-utils
17 * See file CREDITS for list of people who contributed to this
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License version
22 * 2 as published by the Free Software Foundation.
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
34 * Copyright 2010 Freescale Semiconductor
35 * The portions of this file whose copyright is held by Freescale and which
36 * are not considered a derived work of GPL v2-only code may be distributed
37 * and/or modified under the terms of the GNU General Public License as
38 * published by the Free Software Foundation; either version 2 of the
39 * License, or (at your option) any later version.
48 #include <asm/errno.h>
49 #include <linux/mtd/mtd.h>
51 #include <jffs2/jffs2.h>
53 typedef struct erase_info erase_info_t
;
54 typedef struct mtd_info mtd_info_t
;
56 /* support only for native endian JFFS2 */
57 #define cpu_to_je16(x) (x)
58 #define cpu_to_je32(x) (x)
61 * nand_erase_opts: - erase NAND flash with support for various options
64 * @param meminfo NAND device to erase
65 * @param opts options, @see struct nand_erase_options
66 * @return 0 in case of success
68 * This code is ported from flash_eraseall.c from Linux mtd utils by
69 * Arcom Control System Ltd.
71 int nand_erase_opts(nand_info_t
*meminfo
, const nand_erase_options_t
*opts
)
73 struct jffs2_unknown_node cleanmarker
;
75 unsigned long erase_length
, erased_length
; /* in blocks */
78 int percent_complete
= -1;
79 const char *mtd_device
= meminfo
->name
;
80 struct mtd_oob_ops oob_opts
;
81 struct nand_chip
*chip
= meminfo
->priv
;
83 if ((opts
->offset
& (meminfo
->writesize
- 1)) != 0) {
84 printf("Attempt to erase non page aligned data\n");
88 memset(&erase
, 0, sizeof(erase
));
89 memset(&oob_opts
, 0, sizeof(oob_opts
));
92 erase
.len
= meminfo
->erasesize
;
93 erase
.addr
= opts
->offset
;
94 erase_length
= lldiv(opts
->length
+ meminfo
->erasesize
- 1,
97 cleanmarker
.magic
= cpu_to_je16 (JFFS2_MAGIC_BITMASK
);
98 cleanmarker
.nodetype
= cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER
);
99 cleanmarker
.totlen
= cpu_to_je32(8);
101 /* scrub option allows to erase badblock. To prevent internal
102 * check from erase() method, set block check method to dummy
103 * and disable bad block table while erasing.
106 erase
.scrub
= opts
->scrub
;
108 * We don't need the bad block table anymore...
109 * after scrub, there are no bad blocks left!
117 for (erased_length
= 0;
118 erased_length
< erase_length
;
119 erase
.addr
+= meminfo
->erasesize
) {
123 if (!opts
->scrub
&& bbtest
) {
124 int ret
= meminfo
->block_isbad(meminfo
, erase
.addr
);
127 printf("\rSkipping bad block at "
137 } else if (ret
< 0) {
138 printf("\n%s: MTD get bad block failed: %d\n",
147 result
= meminfo
->erase(meminfo
, &erase
);
149 printf("\n%s: MTD Erase failure: %d\n",
154 /* format for JFFS2 ? */
155 if (opts
->jffs2
&& chip
->ecc
.layout
->oobavail
>= 8) {
156 chip
->ops
.ooblen
= 8;
157 chip
->ops
.datbuf
= NULL
;
158 chip
->ops
.oobbuf
= (uint8_t *)&cleanmarker
;
159 chip
->ops
.ooboffs
= 0;
160 chip
->ops
.mode
= MTD_OOB_AUTO
;
162 result
= meminfo
->write_oob(meminfo
,
166 printf("\n%s: MTD writeoob failure: %d\n",
173 unsigned long long n
= erased_length
* 100ULL;
176 do_div(n
, erase_length
);
179 /* output progress message only at whole percent
180 * steps to reduce the number of messages printed
181 * on (slow) serial consoles
183 if (percent
!= percent_complete
) {
184 percent_complete
= percent
;
186 printf("\rErasing at 0x%llx -- %3d%% complete.",
187 erase
.addr
, percent
);
189 if (opts
->jffs2
&& result
== 0)
190 printf(" Cleanmarker written at 0x%llx.",
199 chip
->scan_bbt(meminfo
);
204 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
206 /******************************************************************************
207 * Support for locking / unlocking operations of some NAND devices
208 *****************************************************************************/
210 #define NAND_CMD_LOCK 0x2a
211 #define NAND_CMD_LOCK_TIGHT 0x2c
212 #define NAND_CMD_UNLOCK1 0x23
213 #define NAND_CMD_UNLOCK2 0x24
214 #define NAND_CMD_LOCK_STATUS 0x7a
217 * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
220 * @param mtd nand mtd instance
221 * @param tight bring device in lock tight mode
223 * @return 0 on success, -1 in case of error
225 * The lock / lock-tight command only applies to the whole chip. To get some
226 * parts of the chip lock and others unlocked use the following sequence:
228 * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
229 * - Call nand_unlock() once for each consecutive area to be unlocked
230 * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
232 * If the device is in lock-tight state software can't change the
233 * current active lock/unlock state of all pages. nand_lock() / nand_unlock()
234 * calls will fail. It is only posible to leave lock-tight state by
235 * an hardware signal (low pulse on _WP pin) or by power down.
237 int nand_lock(struct mtd_info
*mtd
, int tight
)
241 struct nand_chip
*chip
= mtd
->priv
;
243 /* select the NAND device */
244 chip
->select_chip(mtd
, 0);
247 (tight
? NAND_CMD_LOCK_TIGHT
: NAND_CMD_LOCK
),
250 /* call wait ready function */
251 status
= chip
->waitfunc(mtd
, chip
);
253 /* see if device thinks it succeeded */
258 /* de-select the NAND device */
259 chip
->select_chip(mtd
, -1);
264 * nand_get_lock_status: - query current lock state from one page of NAND
267 * @param mtd nand mtd instance
268 * @param offset page address to query (muss be page aligned!)
270 * @return -1 in case of error
272 * bitfield with the following combinations:
273 * NAND_LOCK_STATUS_TIGHT: page in tight state
274 * NAND_LOCK_STATUS_LOCK: page locked
275 * NAND_LOCK_STATUS_UNLOCK: page unlocked
278 int nand_get_lock_status(struct mtd_info
*mtd
, loff_t offset
)
283 struct nand_chip
*chip
= mtd
->priv
;
285 /* select the NAND device */
286 chipnr
= (int)(offset
>> chip
->chip_shift
);
287 chip
->select_chip(mtd
, chipnr
);
290 if ((offset
& (mtd
->writesize
- 1)) != 0) {
291 printf ("nand_get_lock_status: "
292 "Start address must be beginning of "
298 /* check the Lock Status */
299 page
= (int)(offset
>> chip
->page_shift
);
300 chip
->cmdfunc(mtd
, NAND_CMD_LOCK_STATUS
, -1, page
& chip
->pagemask
);
302 ret
= chip
->read_byte(mtd
) & (NAND_LOCK_STATUS_TIGHT
303 | NAND_LOCK_STATUS_LOCK
304 | NAND_LOCK_STATUS_UNLOCK
);
307 /* de-select the NAND device */
308 chip
->select_chip(mtd
, -1);
313 * nand_unlock: - Unlock area of NAND pages
314 * only one consecutive area can be unlocked at one time!
316 * @param mtd nand mtd instance
317 * @param start start byte address
318 * @param length number of bytes to unlock (must be a multiple of
319 * page size nand->writesize)
321 * @return 0 on success, -1 in case of error
323 int nand_unlock(struct mtd_info
*mtd
, ulong start
, ulong length
)
329 struct nand_chip
*chip
= mtd
->priv
;
330 printf ("nand_unlock: start: %08x, length: %d!\n",
331 (int)start
, (int)length
);
333 /* select the NAND device */
334 chipnr
= (int)(start
>> chip
->chip_shift
);
335 chip
->select_chip(mtd
, chipnr
);
337 /* check the WP bit */
338 chip
->cmdfunc(mtd
, NAND_CMD_STATUS
, -1, -1);
339 if (!(chip
->read_byte(mtd
) & NAND_STATUS_WP
)) {
340 printf ("nand_unlock: Device is write protected!\n");
345 if ((start
& (mtd
->erasesize
- 1)) != 0) {
346 printf ("nand_unlock: Start address must be beginning of "
352 if (length
== 0 || (length
& (mtd
->erasesize
- 1)) != 0) {
353 printf ("nand_unlock: Length must be a multiple of nand block "
354 "size %08x!\n", mtd
->erasesize
);
360 * Set length so that the last address is set to the
361 * starting address of the last block
363 length
-= mtd
->erasesize
;
365 /* submit address of first page to unlock */
366 page
= (int)(start
>> chip
->page_shift
);
367 chip
->cmdfunc(mtd
, NAND_CMD_UNLOCK1
, -1, page
& chip
->pagemask
);
369 /* submit ADDRESS of LAST page to unlock */
370 page
+= (int)(length
>> chip
->page_shift
);
371 chip
->cmdfunc(mtd
, NAND_CMD_UNLOCK2
, -1, page
& chip
->pagemask
);
373 /* call wait ready function */
374 status
= chip
->waitfunc(mtd
, chip
);
375 /* see if device thinks it succeeded */
377 /* there was an error */
383 /* de-select the NAND device */
384 chip
->select_chip(mtd
, -1);
392 * Check if there are any bad blocks, and whether length including bad
393 * blocks fits into device
395 * @param nand NAND device
396 * @param offset offset in flash
397 * @param length image length
398 * @return 0 if the image fits and there are no bad blocks
399 * 1 if the image fits, but there are bad blocks
400 * -1 if the image does not fit
402 static int check_skip_len(nand_info_t
*nand
, loff_t offset
, size_t length
)
404 size_t len_excl_bad
= 0;
407 while (len_excl_bad
< length
) {
408 size_t block_len
, block_off
;
411 if (offset
>= nand
->size
)
414 block_start
= offset
& ~(loff_t
)(nand
->erasesize
- 1);
415 block_off
= offset
& (nand
->erasesize
- 1);
416 block_len
= nand
->erasesize
- block_off
;
418 if (!nand_block_isbad(nand
, block_start
))
419 len_excl_bad
+= block_len
;
429 #ifdef CONFIG_CMD_NAND_TRIMFFS
430 static size_t drop_ffs(const nand_info_t
*nand
, const u_char
*buf
,
435 for (i
= l
- 1; i
>= 0; i
--)
439 /* The resulting length must be aligned to the minimum flash I/O size */
441 l
= (l
+ nand
->writesize
- 1) / nand
->writesize
;
442 l
*= nand
->writesize
;
445 * since the input length may be unaligned, prevent access past the end
453 * nand_write_skip_bad:
455 * Write image to NAND flash.
456 * Blocks that are marked bad are skipped and the is written to the next
457 * block instead as long as the image is short enough to fit even after
458 * skipping the bad blocks.
460 * @param nand NAND device
461 * @param offset offset in flash
462 * @param length buffer length
463 * @param buffer buffer to read from
464 * @param flags flags modifying the behaviour of the write to NAND
465 * @return 0 in case of success
467 int nand_write_skip_bad(nand_info_t
*nand
, loff_t offset
, size_t *length
,
468 u_char
*buffer
, int flags
)
470 int rval
= 0, blocksize
;
471 size_t left_to_write
= *length
;
472 u_char
*p_buffer
= buffer
;
475 #ifdef CONFIG_CMD_NAND_YAFFS
476 if (flags
& WITH_YAFFS_OOB
) {
477 if (flags
& ~WITH_YAFFS_OOB
)
481 pages
= nand
->erasesize
/ nand
->writesize
;
482 blocksize
= (pages
* nand
->oobsize
) + nand
->erasesize
;
483 if (*length
% (nand
->writesize
+ nand
->oobsize
)) {
484 printf ("Attempt to write incomplete page"
491 blocksize
= nand
->erasesize
;
495 * nand_write() handles unaligned, partial page writes.
497 * We allow length to be unaligned, for convenience in
498 * using the $filesize variable.
500 * However, starting at an unaligned offset makes the
501 * semantics of bad block skipping ambiguous (really,
502 * you should only start a block skipping access at a
503 * partition boundary). So don't try to handle that.
505 if ((offset
& (nand
->writesize
- 1)) != 0) {
506 printf ("Attempt to write non page aligned data\n");
511 need_skip
= check_skip_len(nand
, offset
, *length
);
513 printf ("Attempt to write outside the flash area\n");
518 if (!need_skip
&& !(flags
& WITH_DROP_FFS
)) {
519 rval
= nand_write (nand
, offset
, length
, buffer
);
524 printf ("NAND write to offset %llx failed %d\n",
529 while (left_to_write
> 0) {
530 size_t block_offset
= offset
& (nand
->erasesize
- 1);
531 size_t write_size
, truncated_write_size
;
535 if (nand_block_isbad (nand
, offset
& ~(nand
->erasesize
- 1))) {
536 printf ("Skip bad block 0x%08llx\n",
537 offset
& ~(nand
->erasesize
- 1));
538 offset
+= nand
->erasesize
- block_offset
;
542 if (left_to_write
< (blocksize
- block_offset
))
543 write_size
= left_to_write
;
545 write_size
= blocksize
- block_offset
;
547 #ifdef CONFIG_CMD_NAND_YAFFS
548 if (flags
& WITH_YAFFS_OOB
) {
550 size_t pagesize
= nand
->writesize
;
551 size_t pagesize_oob
= pagesize
+ nand
->oobsize
;
552 struct mtd_oob_ops ops
;
555 ops
.ooblen
= nand
->oobsize
;
556 ops
.mode
= MTD_OOB_AUTO
;
559 pages
= write_size
/ pagesize_oob
;
560 for (page
= 0; page
< pages
; page
++) {
563 ops
.datbuf
= p_buffer
;
564 ops
.oobbuf
= ops
.datbuf
+ pagesize
;
566 rval
= nand
->write_oob(nand
, offset
, &ops
);
571 p_buffer
+= pagesize_oob
;
577 truncated_write_size
= write_size
;
578 #ifdef CONFIG_CMD_NAND_TRIMFFS
579 if (flags
& WITH_DROP_FFS
)
580 truncated_write_size
= drop_ffs(nand
, p_buffer
,
584 rval
= nand_write(nand
, offset
, &truncated_write_size
,
586 offset
+= write_size
;
587 p_buffer
+= write_size
;
591 printf ("NAND write to offset %llx failed %d\n",
593 *length
-= left_to_write
;
597 left_to_write
-= write_size
;
604 * nand_read_skip_bad:
606 * Read image from NAND flash.
607 * Blocks that are marked bad are skipped and the next block is readen
608 * instead as long as the image is short enough to fit even after skipping the
611 * @param nand NAND device
612 * @param offset offset in flash
613 * @param length buffer length, on return holds remaining bytes to read
614 * @param buffer buffer to write to
615 * @return 0 in case of success
617 int nand_read_skip_bad(nand_info_t
*nand
, loff_t offset
, size_t *length
,
621 size_t left_to_read
= *length
;
622 u_char
*p_buffer
= buffer
;
625 if ((offset
& (nand
->writesize
- 1)) != 0) {
626 printf ("Attempt to read non page aligned data\n");
631 need_skip
= check_skip_len(nand
, offset
, *length
);
633 printf ("Attempt to read outside the flash area\n");
639 rval
= nand_read (nand
, offset
, length
, buffer
);
640 if (!rval
|| rval
== -EUCLEAN
)
644 printf ("NAND read from offset %llx failed %d\n",
649 while (left_to_read
> 0) {
650 size_t block_offset
= offset
& (nand
->erasesize
- 1);
655 if (nand_block_isbad (nand
, offset
& ~(nand
->erasesize
- 1))) {
656 printf ("Skipping bad block 0x%08llx\n",
657 offset
& ~(nand
->erasesize
- 1));
658 offset
+= nand
->erasesize
- block_offset
;
662 if (left_to_read
< (nand
->erasesize
- block_offset
))
663 read_length
= left_to_read
;
665 read_length
= nand
->erasesize
- block_offset
;
667 rval
= nand_read (nand
, offset
, &read_length
, p_buffer
);
668 if (rval
&& rval
!= -EUCLEAN
) {
669 printf ("NAND read from offset %llx failed %d\n",
671 *length
-= left_to_read
;
675 left_to_read
-= read_length
;
676 offset
+= read_length
;
677 p_buffer
+= read_length
;