blob: 12dd26a33fac3458d0fd89bcf2dcc91859f75895 [file] [log] [blame]
Stefan Roese2255b2d2006-10-10 12:36:02 +02001/*
Marcel Ziswiler7817cb22007-12-30 03:30:46 +01002 * drivers/mtd/nand/nand_util.c
Stefan Roese2255b2d2006-10-10 12:36:02 +02003 *
4 * Copyright (C) 2006 by Weiss-Electronic GmbH.
5 * All rights reserved.
6 *
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)
13 *
Ben Gardiner169d54d2011-06-14 16:35:06 -040014 * Copyright (C) 2008 Nokia Corporation: drop_ffs() function by
15 * Artem Bityutskiy <dedekind1@gmail.com> from mtd-utils
16 *
Tom Rini9d33fb42013-10-31 09:24:00 -040017 * Copyright 2010 Freescale Semiconductor
18 *
19 * SPDX-License-Identifier: GPL-2.0
Stefan Roese2255b2d2006-10-10 12:36:02 +020020 */
21
22#include <common.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020023#include <command.h>
24#include <watchdog.h>
25#include <malloc.h>
Dirk Behme3a6d56c2007-08-02 17:42:08 +020026#include <div64.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020027
William Juulcfa460a2007-10-31 13:53:06 +010028#include <asm/errno.h>
29#include <linux/mtd/mtd.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020030#include <nand.h>
31#include <jffs2/jffs2.h>
32
Benoît Thébaudeaubd742802012-11-05 10:15:46 +000033typedef struct erase_info erase_info_t;
34typedef struct mtd_info mtd_info_t;
Stefan Roese2255b2d2006-10-10 12:36:02 +020035
36/* support only for native endian JFFS2 */
37#define cpu_to_je16(x) (x)
38#define cpu_to_je32(x) (x)
39
Stefan Roese2255b2d2006-10-10 12:36:02 +020040/**
41 * nand_erase_opts: - erase NAND flash with support for various options
Benoît Thébaudeaubd742802012-11-05 10:15:46 +000042 * (jffs2 formatting)
Stefan Roese2255b2d2006-10-10 12:36:02 +020043 *
44 * @param meminfo NAND device to erase
45 * @param opts options, @see struct nand_erase_options
46 * @return 0 in case of success
47 *
48 * This code is ported from flash_eraseall.c from Linux mtd utils by
49 * Arcom Control System Ltd.
50 */
51int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts)
52{
53 struct jffs2_unknown_node cleanmarker;
Stefan Roese2255b2d2006-10-10 12:36:02 +020054 erase_info_t erase;
Scott Wood30486322010-08-25 14:43:29 -050055 unsigned long erase_length, erased_length; /* in blocks */
Stefan Roese2255b2d2006-10-10 12:36:02 +020056 int result;
57 int percent_complete = -1;
Stefan Roese2255b2d2006-10-10 12:36:02 +020058 const char *mtd_device = meminfo->name;
William Juulcfa460a2007-10-31 13:53:06 +010059 struct mtd_oob_ops oob_opts;
60 struct nand_chip *chip = meminfo->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +020061
Benoît Thébaudeau8156f7322012-11-05 10:16:15 +000062 if ((opts->offset & (meminfo->erasesize - 1)) != 0) {
63 printf("Attempt to erase non block-aligned data\n");
Scott Wood30486322010-08-25 14:43:29 -050064 return -1;
65 }
66
Stefan Roese2255b2d2006-10-10 12:36:02 +020067 memset(&erase, 0, sizeof(erase));
William Juulcfa460a2007-10-31 13:53:06 +010068 memset(&oob_opts, 0, sizeof(oob_opts));
Stefan Roese2255b2d2006-10-10 12:36:02 +020069
70 erase.mtd = meminfo;
71 erase.len = meminfo->erasesize;
Stefan Roese856f0542006-10-28 15:55:52 +020072 erase.addr = opts->offset;
Scott Wood30486322010-08-25 14:43:29 -050073 erase_length = lldiv(opts->length + meminfo->erasesize - 1,
74 meminfo->erasesize);
Stefan Roese2255b2d2006-10-10 12:36:02 +020075
Benoît Thébaudeaubd742802012-11-05 10:15:46 +000076 cleanmarker.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
77 cleanmarker.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
William Juulcfa460a2007-10-31 13:53:06 +010078 cleanmarker.totlen = cpu_to_je32(8);
Stefan Roese2255b2d2006-10-10 12:36:02 +020079
80 /* scrub option allows to erase badblock. To prevent internal
81 * check from erase() method, set block check method to dummy
82 * and disable bad block table while erasing.
83 */
84 if (opts->scrub) {
Marek Vasut6d414192011-09-12 06:04:06 +020085 erase.scrub = opts->scrub;
86 /*
87 * We don't need the bad block table anymore...
Stefan Roese2255b2d2006-10-10 12:36:02 +020088 * after scrub, there are no bad blocks left!
89 */
Marek Vasut6d414192011-09-12 06:04:06 +020090 if (chip->bbt) {
91 kfree(chip->bbt);
Stefan Roese2255b2d2006-10-10 12:36:02 +020092 }
Marek Vasut6d414192011-09-12 06:04:06 +020093 chip->bbt = NULL;
Masahiro Yamadaab37b762014-12-26 22:20:58 +090094 chip->options &= ~NAND_BBT_SCANNED;
Stefan Roese2255b2d2006-10-10 12:36:02 +020095 }
96
Scott Wood30486322010-08-25 14:43:29 -050097 for (erased_length = 0;
98 erased_length < erase_length;
Stefan Roese2255b2d2006-10-10 12:36:02 +020099 erase.addr += meminfo->erasesize) {
William Juul4cbb6512007-11-08 10:39:53 +0100100
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000101 WATCHDOG_RESET();
Stefan Roese2255b2d2006-10-10 12:36:02 +0200102
Heiko Schochera67cc372013-06-24 18:50:40 +0200103 if (opts->lim && (erase.addr >= (opts->offset + opts->lim))) {
104 puts("Size of erase exceeds limit\n");
105 return -EFBIG;
106 }
Masahiro Yamada47b6dad2013-07-12 10:53:37 +0900107 if (!opts->scrub) {
Sergey Lapindfe64e22013-01-14 03:46:50 +0000108 int ret = mtd_block_isbad(meminfo, erase.addr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200109 if (ret > 0) {
110 if (!opts->quiet)
111 printf("\rSkipping bad block at "
Stefan Roese8d2effe2009-05-11 16:03:55 +0200112 "0x%08llx "
Wolfgang Denk87621bc2006-10-12 11:43:47 +0200113 " \n",
114 erase.addr);
Scott Wood30486322010-08-25 14:43:29 -0500115
116 if (!opts->spread)
117 erased_length++;
118
Stefan Roese2255b2d2006-10-10 12:36:02 +0200119 continue;
120
121 } else if (ret < 0) {
122 printf("\n%s: MTD get bad block failed: %d\n",
123 mtd_device,
124 ret);
125 return -1;
126 }
127 }
128
Scott Wood30486322010-08-25 14:43:29 -0500129 erased_length++;
130
Sergey Lapindfe64e22013-01-14 03:46:50 +0000131 result = mtd_erase(meminfo, &erase);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200132 if (result != 0) {
133 printf("\n%s: MTD Erase failure: %d\n",
134 mtd_device, result);
135 continue;
136 }
137
138 /* format for JFFS2 ? */
Scott Woodbd78bc62008-10-29 14:20:26 -0500139 if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) {
Sergey Lapindfe64e22013-01-14 03:46:50 +0000140 struct mtd_oob_ops ops;
141 ops.ooblen = 8;
142 ops.datbuf = NULL;
143 ops.oobbuf = (uint8_t *)&cleanmarker;
144 ops.ooboffs = 0;
145 ops.mode = MTD_OPS_AUTO_OOB;
William Juul4cbb6512007-11-08 10:39:53 +0100146
Sergey Lapindfe64e22013-01-14 03:46:50 +0000147 result = mtd_write_oob(meminfo,
Wolfgang Denk93e14592013-10-04 17:43:24 +0200148 erase.addr,
149 &ops);
William Juulcfa460a2007-10-31 13:53:06 +0100150 if (result != 0) {
151 printf("\n%s: MTD writeoob failure: %d\n",
Scott Woodbd78bc62008-10-29 14:20:26 -0500152 mtd_device, result);
William Juulcfa460a2007-10-31 13:53:06 +0100153 continue;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200154 }
155 }
156
157 if (!opts->quiet) {
Scott Wood30486322010-08-25 14:43:29 -0500158 unsigned long long n = erased_length * 100ULL;
Matthias Fuchs5bd7fe92007-09-11 17:04:00 +0200159 int percent;
160
161 do_div(n, erase_length);
162 percent = (int)n;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200163
164 /* output progress message only at whole percent
165 * steps to reduce the number of messages printed
166 * on (slow) serial consoles
167 */
168 if (percent != percent_complete) {
169 percent_complete = percent;
170
Stefan Roese8d2effe2009-05-11 16:03:55 +0200171 printf("\rErasing at 0x%llx -- %3d%% complete.",
Scott Woodbd78bc62008-10-29 14:20:26 -0500172 erase.addr, percent);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200173
174 if (opts->jffs2 && result == 0)
Stefan Roese8d2effe2009-05-11 16:03:55 +0200175 printf(" Cleanmarker written at 0x%llx.",
Scott Woodbd78bc62008-10-29 14:20:26 -0500176 erase.addr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200177 }
178 }
179 }
180 if (!opts->quiet)
181 printf("\n");
182
Stefan Roese2255b2d2006-10-10 12:36:02 +0200183 return 0;
184}
185
Nishanth Menon50657c22008-12-13 09:43:06 -0600186#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
187
Heiko Schocherff94bc42014-06-24 10:10:04 +0200188#define NAND_CMD_LOCK_TIGHT 0x2c
189#define NAND_CMD_LOCK_STATUS 0x7a
190
Stefan Roese2255b2d2006-10-10 12:36:02 +0200191/******************************************************************************
192 * Support for locking / unlocking operations of some NAND devices
193 *****************************************************************************/
194
Stefan Roese2255b2d2006-10-10 12:36:02 +0200195/**
196 * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
197 * state
198 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600199 * @param mtd nand mtd instance
Stefan Roese2255b2d2006-10-10 12:36:02 +0200200 * @param tight bring device in lock tight mode
201 *
202 * @return 0 on success, -1 in case of error
203 *
204 * The lock / lock-tight command only applies to the whole chip. To get some
205 * parts of the chip lock and others unlocked use the following sequence:
206 *
207 * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
208 * - Call nand_unlock() once for each consecutive area to be unlocked
209 * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
210 *
211 * If the device is in lock-tight state software can't change the
212 * current active lock/unlock state of all pages. nand_lock() / nand_unlock()
213 * calls will fail. It is only posible to leave lock-tight state by
214 * an hardware signal (low pulse on _WP pin) or by power down.
215 */
Nishanth Menon50657c22008-12-13 09:43:06 -0600216int nand_lock(struct mtd_info *mtd, int tight)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200217{
218 int ret = 0;
219 int status;
Nishanth Menon50657c22008-12-13 09:43:06 -0600220 struct nand_chip *chip = mtd->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200221
222 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600223 chip->select_chip(mtd, 0);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200224
Joe Hershbergerfcecb4a2013-02-08 09:27:19 +0000225 /* check the Lock Tight Status */
226 chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, 0);
227 if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
228 printf("nand_lock: Device is locked tight!\n");
229 ret = -1;
230 goto out;
231 }
232
Nishanth Menon50657c22008-12-13 09:43:06 -0600233 chip->cmdfunc(mtd,
Stefan Roese2255b2d2006-10-10 12:36:02 +0200234 (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),
235 -1, -1);
236
237 /* call wait ready function */
Nishanth Menon50657c22008-12-13 09:43:06 -0600238 status = chip->waitfunc(mtd, chip);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200239
240 /* see if device thinks it succeeded */
241 if (status & 0x01) {
242 ret = -1;
243 }
244
Joe Hershbergerfcecb4a2013-02-08 09:27:19 +0000245 out:
Stefan Roese2255b2d2006-10-10 12:36:02 +0200246 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600247 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200248 return ret;
249}
250
251/**
252 * nand_get_lock_status: - query current lock state from one page of NAND
253 * flash
254 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600255 * @param mtd nand mtd instance
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000256 * @param offset page address to query (must be page-aligned!)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200257 *
258 * @return -1 in case of error
259 * >0 lock status:
260 * bitfield with the following combinations:
261 * NAND_LOCK_STATUS_TIGHT: page in tight state
Stefan Roese2255b2d2006-10-10 12:36:02 +0200262 * NAND_LOCK_STATUS_UNLOCK: page unlocked
263 *
264 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200265int nand_get_lock_status(struct mtd_info *mtd, loff_t offset)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200266{
267 int ret = 0;
268 int chipnr;
269 int page;
Nishanth Menon50657c22008-12-13 09:43:06 -0600270 struct nand_chip *chip = mtd->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200271
272 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600273 chipnr = (int)(offset >> chip->chip_shift);
274 chip->select_chip(mtd, chipnr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200275
276
Nishanth Menon50657c22008-12-13 09:43:06 -0600277 if ((offset & (mtd->writesize - 1)) != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000278 printf("nand_get_lock_status: "
Stefan Roese2255b2d2006-10-10 12:36:02 +0200279 "Start address must be beginning of "
280 "nand page!\n");
281 ret = -1;
282 goto out;
283 }
284
285 /* check the Lock Status */
Nishanth Menon50657c22008-12-13 09:43:06 -0600286 page = (int)(offset >> chip->page_shift);
287 chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200288
Nishanth Menon50657c22008-12-13 09:43:06 -0600289 ret = chip->read_byte(mtd) & (NAND_LOCK_STATUS_TIGHT
Stefan Roese2255b2d2006-10-10 12:36:02 +0200290 | NAND_LOCK_STATUS_UNLOCK);
291
292 out:
293 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600294 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200295 return ret;
296}
297
298/**
299 * nand_unlock: - Unlock area of NAND pages
300 * only one consecutive area can be unlocked at one time!
301 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600302 * @param mtd nand mtd instance
Stefan Roese2255b2d2006-10-10 12:36:02 +0200303 * @param start start byte address
304 * @param length number of bytes to unlock (must be a multiple of
William Juulcfa460a2007-10-31 13:53:06 +0100305 * page size nand->writesize)
Joe Hershbergereee623a2012-08-22 16:49:42 -0500306 * @param allexcept if set, unlock everything not selected
Stefan Roese2255b2d2006-10-10 12:36:02 +0200307 *
308 * @return 0 on success, -1 in case of error
309 */
Joe Hershbergere331ab22012-08-22 16:49:43 -0500310int nand_unlock(struct mtd_info *mtd, loff_t start, size_t length,
311 int allexcept)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200312{
313 int ret = 0;
314 int chipnr;
315 int status;
316 int page;
Nishanth Menon50657c22008-12-13 09:43:06 -0600317 struct nand_chip *chip = mtd->priv;
Joe Hershbergereee623a2012-08-22 16:49:42 -0500318
Tom Rini3ef1ead2013-12-16 09:59:34 -0500319 debug("nand_unlock%s: start: %08llx, length: %zd!\n",
Joe Hershbergereee623a2012-08-22 16:49:42 -0500320 allexcept ? " (allexcept)" : "", start, length);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200321
322 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600323 chipnr = (int)(start >> chip->chip_shift);
324 chip->select_chip(mtd, chipnr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200325
326 /* check the WP bit */
Nishanth Menon50657c22008-12-13 09:43:06 -0600327 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
328 if (!(chip->read_byte(mtd) & NAND_STATUS_WP)) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000329 printf("nand_unlock: Device is write protected!\n");
Stefan Roese2255b2d2006-10-10 12:36:02 +0200330 ret = -1;
331 goto out;
332 }
333
Joe Hershbergerfcecb4a2013-02-08 09:27:19 +0000334 /* check the Lock Tight Status */
335 page = (int)(start >> chip->page_shift);
336 chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
337 if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
338 printf("nand_unlock: Device is locked tight!\n");
339 ret = -1;
340 goto out;
341 }
342
Nishanth Menon50657c22008-12-13 09:43:06 -0600343 if ((start & (mtd->erasesize - 1)) != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000344 printf("nand_unlock: Start address must be beginning of "
Nishanth Menon50657c22008-12-13 09:43:06 -0600345 "nand block!\n");
Stefan Roese2255b2d2006-10-10 12:36:02 +0200346 ret = -1;
347 goto out;
348 }
349
Nishanth Menon50657c22008-12-13 09:43:06 -0600350 if (length == 0 || (length & (mtd->erasesize - 1)) != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000351 printf("nand_unlock: Length must be a multiple of nand block "
Nishanth Menon50657c22008-12-13 09:43:06 -0600352 "size %08x!\n", mtd->erasesize);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200353 ret = -1;
354 goto out;
355 }
356
Nishanth Menon50657c22008-12-13 09:43:06 -0600357 /*
358 * Set length so that the last address is set to the
359 * starting address of the last block
360 */
361 length -= mtd->erasesize;
362
Stefan Roese2255b2d2006-10-10 12:36:02 +0200363 /* submit address of first page to unlock */
Nishanth Menon50657c22008-12-13 09:43:06 -0600364 chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200365
366 /* submit ADDRESS of LAST page to unlock */
Nishanth Menon50657c22008-12-13 09:43:06 -0600367 page += (int)(length >> chip->page_shift);
Joe Hershbergereee623a2012-08-22 16:49:42 -0500368
369 /*
370 * Page addresses for unlocking are supposed to be block-aligned.
371 * At least some NAND chips use the low bit to indicate that the
372 * page range should be inverted.
373 */
374 if (allexcept)
375 page |= 1;
376
Nishanth Menon50657c22008-12-13 09:43:06 -0600377 chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200378
379 /* call wait ready function */
Nishanth Menon50657c22008-12-13 09:43:06 -0600380 status = chip->waitfunc(mtd, chip);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200381 /* see if device thinks it succeeded */
382 if (status & 0x01) {
383 /* there was an error */
384 ret = -1;
385 goto out;
386 }
387
388 out:
389 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600390 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200391 return ret;
392}
William Juulcfa460a2007-10-31 13:53:06 +0100393#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200394
Scott Wooddfbf6172008-06-12 13:20:16 -0500395/**
Scott Woodf9a52542010-07-30 16:11:41 -0500396 * check_skip_len
Scott Wooddfbf6172008-06-12 13:20:16 -0500397 *
Scott Woodf9a52542010-07-30 16:11:41 -0500398 * Check if there are any bad blocks, and whether length including bad
399 * blocks fits into device
Scott Wooddfbf6172008-06-12 13:20:16 -0500400 *
401 * @param nand NAND device
402 * @param offset offset in flash
403 * @param length image length
Tom Rinic39d6a02013-03-14 05:32:50 +0000404 * @param used length of flash needed for the requested length
Scott Woodf9a52542010-07-30 16:11:41 -0500405 * @return 0 if the image fits and there are no bad blocks
406 * 1 if the image fits, but there are bad blocks
407 * -1 if the image does not fit
Scott Wooddfbf6172008-06-12 13:20:16 -0500408 */
Tom Rinic39d6a02013-03-14 05:32:50 +0000409static int check_skip_len(nand_info_t *nand, loff_t offset, size_t length,
410 size_t *used)
Scott Wooddfbf6172008-06-12 13:20:16 -0500411{
Scott Wooddfbf6172008-06-12 13:20:16 -0500412 size_t len_excl_bad = 0;
Scott Woodf9a52542010-07-30 16:11:41 -0500413 int ret = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500414
415 while (len_excl_bad < length) {
Scott Woodf9a52542010-07-30 16:11:41 -0500416 size_t block_len, block_off;
417 loff_t block_start;
Scott Wooddfbf6172008-06-12 13:20:16 -0500418
Daniel Hobi0ec81db2009-12-01 14:05:55 +0100419 if (offset >= nand->size)
Scott Woodf9a52542010-07-30 16:11:41 -0500420 return -1;
421
422 block_start = offset & ~(loff_t)(nand->erasesize - 1);
423 block_off = offset & (nand->erasesize - 1);
424 block_len = nand->erasesize - block_off;
425
426 if (!nand_block_isbad(nand, block_start))
427 len_excl_bad += block_len;
428 else
429 ret = 1;
430
431 offset += block_len;
Tom Rinic39d6a02013-03-14 05:32:50 +0000432 *used += block_len;
Scott Wooddfbf6172008-06-12 13:20:16 -0500433 }
434
Tom Rinic39d6a02013-03-14 05:32:50 +0000435 /* If the length is not a multiple of block_len, adjust. */
436 if (len_excl_bad > length)
437 *used -= (len_excl_bad - length);
438
Scott Woodf9a52542010-07-30 16:11:41 -0500439 return ret;
Scott Wooddfbf6172008-06-12 13:20:16 -0500440}
441
Ben Gardiner169d54d2011-06-14 16:35:06 -0400442#ifdef CONFIG_CMD_NAND_TRIMFFS
443static size_t drop_ffs(const nand_info_t *nand, const u_char *buf,
444 const size_t *len)
445{
htbegin453db362013-03-01 23:00:34 +0000446 size_t l = *len;
447 ssize_t i;
Ben Gardiner169d54d2011-06-14 16:35:06 -0400448
449 for (i = l - 1; i >= 0; i--)
450 if (buf[i] != 0xFF)
451 break;
452
453 /* The resulting length must be aligned to the minimum flash I/O size */
454 l = i + 1;
455 l = (l + nand->writesize - 1) / nand->writesize;
456 l *= nand->writesize;
457
458 /*
459 * since the input length may be unaligned, prevent access past the end
460 * of the buffer
461 */
462 return min(l, *len);
463}
464#endif
465
Scott Wooddfbf6172008-06-12 13:20:16 -0500466/**
Peter Tyser59b5a2a2015-02-03 11:58:12 -0600467 * nand_verify_page_oob:
468 *
469 * Verify a page of NAND flash, including the OOB.
470 * Reads page of NAND and verifies the contents and OOB against the
471 * values in ops.
472 *
473 * @param nand NAND device
474 * @param ops MTD operations, including data to verify
475 * @param ofs offset in flash
476 * @return 0 in case of success
477 */
478int nand_verify_page_oob(nand_info_t *nand, struct mtd_oob_ops *ops, loff_t ofs)
479{
480 int rval;
481 struct mtd_oob_ops vops;
482 size_t verlen = nand->writesize + nand->oobsize;
483
484 memcpy(&vops, ops, sizeof(vops));
485
486 vops.datbuf = malloc(verlen);
487
488 if (!vops.datbuf)
489 return -ENOMEM;
490
491 vops.oobbuf = vops.datbuf + nand->writesize;
492
493 rval = mtd_read_oob(nand, ofs, &vops);
494 if (!rval)
495 rval = memcmp(ops->datbuf, vops.datbuf, vops.len);
496 if (!rval)
497 rval = memcmp(ops->oobbuf, vops.oobbuf, vops.ooblen);
498
499 free(vops.datbuf);
500
501 return rval ? -EIO : 0;
502}
503
504/**
505 * nand_verify:
506 *
507 * Verify a region of NAND flash.
508 * Reads NAND in page-sized chunks and verifies the contents against
509 * the contents of a buffer. The offset into the NAND must be
510 * page-aligned, and the function doesn't handle skipping bad blocks.
511 *
512 * @param nand NAND device
513 * @param ofs offset in flash
514 * @param len buffer length
515 * @param buf buffer to read from
516 * @return 0 in case of success
517 */
518int nand_verify(nand_info_t *nand, loff_t ofs, size_t len, u_char *buf)
519{
520 int rval = 0;
521 size_t verofs;
522 size_t verlen = nand->writesize;
523 uint8_t *verbuf = malloc(verlen);
524
525 if (!verbuf)
526 return -ENOMEM;
527
528 /* Read the NAND back in page-size groups to limit malloc size */
529 for (verofs = ofs; verofs < ofs + len;
530 verofs += verlen, buf += verlen) {
531 verlen = min(nand->writesize, (uint32_t)(ofs + len - verofs));
532 rval = nand_read(nand, verofs, &verlen, verbuf);
533 if (!rval || (rval == -EUCLEAN))
534 rval = memcmp(buf, verbuf, verlen);
535
536 if (rval)
537 break;
538 }
539
540 free(verbuf);
541
542 return rval ? -EIO : 0;
543}
544
545
546
547/**
Scott Wooddfbf6172008-06-12 13:20:16 -0500548 * nand_write_skip_bad:
549 *
550 * Write image to NAND flash.
551 * Blocks that are marked bad are skipped and the is written to the next
552 * block instead as long as the image is short enough to fit even after
Tom Rinic39d6a02013-03-14 05:32:50 +0000553 * skipping the bad blocks. Due to bad blocks we may not be able to
554 * perform the requested write. In the case where the write would
555 * extend beyond the end of the NAND device, both length and actual (if
556 * not NULL) are set to 0. In the case where the write would extend
557 * beyond the limit we are passed, length is set to 0 and actual is set
558 * to the required length.
Scott Wooddfbf6172008-06-12 13:20:16 -0500559 *
560 * @param nand NAND device
561 * @param offset offset in flash
562 * @param length buffer length
Tom Rinic39d6a02013-03-14 05:32:50 +0000563 * @param actual set to size required to write length worth of
564 * buffer or 0 on error, if not NULL
565 * @param lim maximum size that actual may be in order to not
566 * exceed the buffer
Lei Wen47fc18f2011-01-06 11:11:58 +0800567 * @param buffer buffer to read from
Ben Gardinera6c9aa12011-05-24 10:18:35 -0400568 * @param flags flags modifying the behaviour of the write to NAND
Scott Wooddfbf6172008-06-12 13:20:16 -0500569 * @return 0 in case of success
570 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200571int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
Tom Rinic39d6a02013-03-14 05:32:50 +0000572 size_t *actual, loff_t lim, u_char *buffer, int flags)
Scott Wooddfbf6172008-06-12 13:20:16 -0500573{
Lei Wen47fc18f2011-01-06 11:11:58 +0800574 int rval = 0, blocksize;
Scott Wooddfbf6172008-06-12 13:20:16 -0500575 size_t left_to_write = *length;
Tom Rinic39d6a02013-03-14 05:32:50 +0000576 size_t used_for_write = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500577 u_char *p_buffer = buffer;
Scott Woodf9a52542010-07-30 16:11:41 -0500578 int need_skip;
Scott Wooddfbf6172008-06-12 13:20:16 -0500579
Tom Rinic39d6a02013-03-14 05:32:50 +0000580 if (actual)
581 *actual = 0;
582
Peter Tyser004a1fd2015-02-03 11:58:16 -0600583 blocksize = nand->erasesize;
Lei Wen47fc18f2011-01-06 11:11:58 +0800584
Scott Woodf9a52542010-07-30 16:11:41 -0500585 /*
586 * nand_write() handles unaligned, partial page writes.
587 *
588 * We allow length to be unaligned, for convenience in
589 * using the $filesize variable.
590 *
591 * However, starting at an unaligned offset makes the
592 * semantics of bad block skipping ambiguous (really,
593 * you should only start a block skipping access at a
594 * partition boundary). So don't try to handle that.
595 */
596 if ((offset & (nand->writesize - 1)) != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000597 printf("Attempt to write non page-aligned data\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500598 *length = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500599 return -EINVAL;
600 }
601
Tom Rinic39d6a02013-03-14 05:32:50 +0000602 need_skip = check_skip_len(nand, offset, *length, &used_for_write);
603
604 if (actual)
605 *actual = used_for_write;
606
Scott Woodf9a52542010-07-30 16:11:41 -0500607 if (need_skip < 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000608 printf("Attempt to write outside the flash area\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500609 *length = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500610 return -EINVAL;
611 }
612
Tom Rinic39d6a02013-03-14 05:32:50 +0000613 if (used_for_write > lim) {
614 puts("Size of write exceeds partition or device limit\n");
615 *length = 0;
616 return -EFBIG;
617 }
618
Ben Gardiner169d54d2011-06-14 16:35:06 -0400619 if (!need_skip && !(flags & WITH_DROP_FFS)) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000620 rval = nand_write(nand, offset, length, buffer);
Peter Tyser59b5a2a2015-02-03 11:58:12 -0600621
622 if ((flags & WITH_WR_VERIFY) && !rval)
623 rval = nand_verify(nand, offset, *length, buffer);
624
Scott Woodf9a52542010-07-30 16:11:41 -0500625 if (rval == 0)
626 return 0;
Scott Wood2077e342008-11-25 10:47:02 -0600627
Scott Woodf9a52542010-07-30 16:11:41 -0500628 *length = 0;
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000629 printf("NAND write to offset %llx failed %d\n",
Scott Woodf9a52542010-07-30 16:11:41 -0500630 offset, rval);
Scott Wood2077e342008-11-25 10:47:02 -0600631 return rval;
Scott Wooddfbf6172008-06-12 13:20:16 -0500632 }
633
634 while (left_to_write > 0) {
635 size_t block_offset = offset & (nand->erasesize - 1);
Ben Gardiner169d54d2011-06-14 16:35:06 -0400636 size_t write_size, truncated_write_size;
Scott Wooddfbf6172008-06-12 13:20:16 -0500637
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000638 WATCHDOG_RESET();
Giulio Benetti1fc1d9a2009-07-31 17:30:34 -0500639
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000640 if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) {
641 printf("Skip bad block 0x%08llx\n",
Scott Wooddfbf6172008-06-12 13:20:16 -0500642 offset & ~(nand->erasesize - 1));
643 offset += nand->erasesize - block_offset;
644 continue;
645 }
646
Lei Wen47fc18f2011-01-06 11:11:58 +0800647 if (left_to_write < (blocksize - block_offset))
Scott Wooddfbf6172008-06-12 13:20:16 -0500648 write_size = left_to_write;
649 else
Lei Wen47fc18f2011-01-06 11:11:58 +0800650 write_size = blocksize - block_offset;
Scott Wooddfbf6172008-06-12 13:20:16 -0500651
Peter Tyser004a1fd2015-02-03 11:58:16 -0600652 truncated_write_size = write_size;
Ben Gardiner169d54d2011-06-14 16:35:06 -0400653#ifdef CONFIG_CMD_NAND_TRIMFFS
Peter Tyser004a1fd2015-02-03 11:58:16 -0600654 if (flags & WITH_DROP_FFS)
655 truncated_write_size = drop_ffs(nand, p_buffer,
656 &write_size);
Ben Gardiner169d54d2011-06-14 16:35:06 -0400657#endif
658
Peter Tyser004a1fd2015-02-03 11:58:16 -0600659 rval = nand_write(nand, offset, &truncated_write_size,
660 p_buffer);
Peter Tyser59b5a2a2015-02-03 11:58:12 -0600661
Peter Tyser004a1fd2015-02-03 11:58:16 -0600662 if ((flags & WITH_WR_VERIFY) && !rval)
663 rval = nand_verify(nand, offset,
664 truncated_write_size, p_buffer);
Peter Tyser59b5a2a2015-02-03 11:58:12 -0600665
Peter Tyser004a1fd2015-02-03 11:58:16 -0600666 offset += write_size;
667 p_buffer += write_size;
Lei Wen47fc18f2011-01-06 11:11:58 +0800668
Scott Wooddfbf6172008-06-12 13:20:16 -0500669 if (rval != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000670 printf("NAND write to offset %llx failed %d\n",
Wolfgang Denk4b070802008-08-14 14:41:06 +0200671 offset, rval);
Scott Wooddfbf6172008-06-12 13:20:16 -0500672 *length -= left_to_write;
673 return rval;
674 }
675
676 left_to_write -= write_size;
Scott Wooddfbf6172008-06-12 13:20:16 -0500677 }
678
679 return 0;
680}
681
682/**
683 * nand_read_skip_bad:
684 *
685 * Read image from NAND flash.
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000686 * Blocks that are marked bad are skipped and the next block is read
Tom Rinic39d6a02013-03-14 05:32:50 +0000687 * instead as long as the image is short enough to fit even after
688 * skipping the bad blocks. Due to bad blocks we may not be able to
689 * perform the requested read. In the case where the read would extend
690 * beyond the end of the NAND device, both length and actual (if not
691 * NULL) are set to 0. In the case where the read would extend beyond
692 * the limit we are passed, length is set to 0 and actual is set to the
693 * required length.
Scott Wooddfbf6172008-06-12 13:20:16 -0500694 *
695 * @param nand NAND device
696 * @param offset offset in flash
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000697 * @param length buffer length, on return holds number of read bytes
Tom Rinic39d6a02013-03-14 05:32:50 +0000698 * @param actual set to size required to read length worth of buffer or 0
699 * on error, if not NULL
700 * @param lim maximum size that actual may be in order to not exceed the
701 * buffer
Scott Wooddfbf6172008-06-12 13:20:16 -0500702 * @param buffer buffer to write to
703 * @return 0 in case of success
704 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200705int nand_read_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
Tom Rinic39d6a02013-03-14 05:32:50 +0000706 size_t *actual, loff_t lim, u_char *buffer)
Scott Wooddfbf6172008-06-12 13:20:16 -0500707{
708 int rval;
709 size_t left_to_read = *length;
Tom Rinic39d6a02013-03-14 05:32:50 +0000710 size_t used_for_read = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500711 u_char *p_buffer = buffer;
Scott Woodf9a52542010-07-30 16:11:41 -0500712 int need_skip;
Scott Wooddfbf6172008-06-12 13:20:16 -0500713
Scott Woodf9a52542010-07-30 16:11:41 -0500714 if ((offset & (nand->writesize - 1)) != 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000715 printf("Attempt to read non page-aligned data\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500716 *length = 0;
Tom Rinic39d6a02013-03-14 05:32:50 +0000717 if (actual)
718 *actual = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500719 return -EINVAL;
720 }
721
Tom Rinic39d6a02013-03-14 05:32:50 +0000722 need_skip = check_skip_len(nand, offset, *length, &used_for_read);
723
724 if (actual)
725 *actual = used_for_read;
726
Scott Woodf9a52542010-07-30 16:11:41 -0500727 if (need_skip < 0) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000728 printf("Attempt to read outside the flash area\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500729 *length = 0;
730 return -EINVAL;
731 }
732
Tom Rinic39d6a02013-03-14 05:32:50 +0000733 if (used_for_read > lim) {
734 puts("Size of read exceeds partition or device limit\n");
735 *length = 0;
736 return -EFBIG;
737 }
738
Scott Woodf9a52542010-07-30 16:11:41 -0500739 if (!need_skip) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000740 rval = nand_read(nand, offset, length, buffer);
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300741 if (!rval || rval == -EUCLEAN)
742 return 0;
Scott Woodf9a52542010-07-30 16:11:41 -0500743
744 *length = 0;
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000745 printf("NAND read from offset %llx failed %d\n",
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300746 offset, rval);
Scott Wood2077e342008-11-25 10:47:02 -0600747 return rval;
Scott Wooddfbf6172008-06-12 13:20:16 -0500748 }
749
750 while (left_to_read > 0) {
751 size_t block_offset = offset & (nand->erasesize - 1);
752 size_t read_length;
753
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000754 WATCHDOG_RESET();
Giulio Benetti1fc1d9a2009-07-31 17:30:34 -0500755
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000756 if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) {
757 printf("Skipping bad block 0x%08llx\n",
Scott Wooddfbf6172008-06-12 13:20:16 -0500758 offset & ~(nand->erasesize - 1));
759 offset += nand->erasesize - block_offset;
760 continue;
761 }
762
763 if (left_to_read < (nand->erasesize - block_offset))
764 read_length = left_to_read;
765 else
766 read_length = nand->erasesize - block_offset;
767
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000768 rval = nand_read(nand, offset, &read_length, p_buffer);
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300769 if (rval && rval != -EUCLEAN) {
Benoît Thébaudeaubd742802012-11-05 10:15:46 +0000770 printf("NAND read from offset %llx failed %d\n",
Wolfgang Denk4b070802008-08-14 14:41:06 +0200771 offset, rval);
Scott Wooddfbf6172008-06-12 13:20:16 -0500772 *length -= left_to_read;
773 return rval;
774 }
775
776 left_to_read -= read_length;
777 offset += read_length;
778 p_buffer += read_length;
779 }
780
781 return 0;
782}
Benoît Thébaudeau3287f6d2012-11-16 20:20:54 +0100783
784#ifdef CONFIG_CMD_NAND_TORTURE
785
786/**
787 * check_pattern:
788 *
789 * Check if buffer contains only a certain byte pattern.
790 *
791 * @param buf buffer to check
792 * @param patt the pattern to check
793 * @param size buffer size in bytes
794 * @return 1 if there are only patt bytes in buf
795 * 0 if something else was found
796 */
797static int check_pattern(const u_char *buf, u_char patt, int size)
798{
799 int i;
800
801 for (i = 0; i < size; i++)
802 if (buf[i] != patt)
803 return 0;
804 return 1;
805}
806
807/**
808 * nand_torture:
809 *
810 * Torture a block of NAND flash.
811 * This is useful to determine if a block that caused a write error is still
812 * good or should be marked as bad.
813 *
814 * @param nand NAND device
815 * @param offset offset in flash
816 * @return 0 if the block is still good
817 */
818int nand_torture(nand_info_t *nand, loff_t offset)
819{
820 u_char patterns[] = {0xa5, 0x5a, 0x00};
821 struct erase_info instr = {
822 .mtd = nand,
823 .addr = offset,
824 .len = nand->erasesize,
825 };
826 size_t retlen;
827 int err, ret = -1, i, patt_count;
828 u_char *buf;
829
830 if ((offset & (nand->erasesize - 1)) != 0) {
831 puts("Attempt to torture a block at a non block-aligned offset\n");
832 return -EINVAL;
833 }
834
835 if (offset + nand->erasesize > nand->size) {
836 puts("Attempt to torture a block outside the flash area\n");
837 return -EINVAL;
838 }
839
840 patt_count = ARRAY_SIZE(patterns);
841
842 buf = malloc(nand->erasesize);
843 if (buf == NULL) {
844 puts("Out of memory for erase block buffer\n");
845 return -ENOMEM;
846 }
847
848 for (i = 0; i < patt_count; i++) {
849 err = nand->erase(nand, &instr);
850 if (err) {
851 printf("%s: erase() failed for block at 0x%llx: %d\n",
852 nand->name, instr.addr, err);
853 goto out;
854 }
855
856 /* Make sure the block contains only 0xff bytes */
857 err = nand->read(nand, offset, nand->erasesize, &retlen, buf);
858 if ((err && err != -EUCLEAN) || retlen != nand->erasesize) {
859 printf("%s: read() failed for block at 0x%llx: %d\n",
860 nand->name, instr.addr, err);
861 goto out;
862 }
863
864 err = check_pattern(buf, 0xff, nand->erasesize);
865 if (!err) {
866 printf("Erased block at 0x%llx, but a non-0xff byte was found\n",
867 offset);
868 ret = -EIO;
869 goto out;
870 }
871
872 /* Write a pattern and check it */
873 memset(buf, patterns[i], nand->erasesize);
874 err = nand->write(nand, offset, nand->erasesize, &retlen, buf);
875 if (err || retlen != nand->erasesize) {
876 printf("%s: write() failed for block at 0x%llx: %d\n",
877 nand->name, instr.addr, err);
878 goto out;
879 }
880
881 err = nand->read(nand, offset, nand->erasesize, &retlen, buf);
882 if ((err && err != -EUCLEAN) || retlen != nand->erasesize) {
883 printf("%s: read() failed for block at 0x%llx: %d\n",
884 nand->name, instr.addr, err);
885 goto out;
886 }
887
888 err = check_pattern(buf, patterns[i], nand->erasesize);
889 if (!err) {
890 printf("Pattern 0x%.2x checking failed for block at "
891 "0x%llx\n", patterns[i], offset);
892 ret = -EIO;
893 goto out;
894 }
895 }
896
897 ret = 0;
898
899out:
900 free(buf);
901 return ret;
902}
903
904#endif