blob: e24ed7f9c4a9afa50d29f914e689ab1518d95dc8 [file] [log] [blame]
wdenkdc7c9a12003-03-26 06:55:25 +00001/*
2 * Driver for NAND support, Rick Bronson
3 * borrowed heavily from:
4 * (c) 1999 Machine Vision Holdings, Inc.
5 * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
wdenk384cc682005-04-03 22:35:21 +00006 *
Ben Gardinerc9f73512010-07-05 13:27:07 -04007 * Ported 'dynenv' to 'nand env.oob' command
8 * (C) 2010 Nanometrics, Inc.
9 * 'dynenv' -- Dynamic environment offset in NAND OOB
10 * (C) Copyright 2006-2007 OpenMoko, Inc.
wdenk384cc682005-04-03 22:35:21 +000011 * Added 16-bit nand support
12 * (C) 2004 Texas Instruments
Scott Woodea533c22010-08-02 13:04:24 -050013 *
Scott Wood418396e2012-03-02 14:01:57 -060014 * Copyright 2010, 2012 Freescale Semiconductor
Scott Woodea533c22010-08-02 13:04:24 -050015 * The portions of this file whose copyright is held by Freescale and which
16 * are not considered a derived work of GPL v2-only code may be distributed
17 * and/or modified under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of the
19 * License, or (at your option) any later version.
wdenkdc7c9a12003-03-26 06:55:25 +000020 */
21
22#include <common.h>
William Juulcfa460a2007-10-31 13:53:06 +010023#include <linux/mtd/mtd.h>
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010024#include <command.h>
25#include <watchdog.h>
26#include <malloc.h>
27#include <asm/byteorder.h>
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010028#include <jffs2/jffs2.h>
29#include <nand.h>
30
Ladislav Michl0c8a8492009-04-21 02:26:31 +020031#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese856f0542006-10-28 15:55:52 +020032
Wolfgang Denk445093d2009-11-17 21:27:39 +010033/* partition handling routines */
Stefan Roese856f0542006-10-28 15:55:52 +020034int mtdparts_init(void);
35int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
36int find_dev_and_part(const char *id, struct mtd_device **dev,
Wolfgang Denk4b070802008-08-14 14:41:06 +020037 u8 *part_num, struct part_info **part);
Stefan Roese856f0542006-10-28 15:55:52 +020038#endif
39
Scott Wood8c5659a2010-08-25 15:24:01 -050040static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010041{
42 int i;
William Juul9ad754f2007-12-14 16:33:45 +010043 u_char *datbuf, *oobbuf, *p;
Scott Wood8c5659a2010-08-25 15:24:01 -050044 static loff_t last;
45
46 if (repeat)
47 off = last + nand->writesize;
48
49 last = off;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010050
Thierry Reding62fd66f2012-07-30 20:21:55 +000051 datbuf = memalign(ARCH_DMA_MINALIGN, nand->writesize);
52 oobbuf = memalign(ARCH_DMA_MINALIGN, nand->oobsize);
William Juul9ad754f2007-12-14 16:33:45 +010053 if (!datbuf || !oobbuf) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010054 puts("No memory for page buffer\n");
55 return 1;
56 }
William Juulcfa460a2007-10-31 13:53:06 +010057 off &= ~(nand->writesize - 1);
William Juulcfa460a2007-10-31 13:53:06 +010058 loff_t addr = (loff_t) off;
William Juul9ad754f2007-12-14 16:33:45 +010059 struct mtd_oob_ops ops;
60 memset(&ops, 0, sizeof(ops));
61 ops.datbuf = datbuf;
Tom Rinicfdae122012-02-23 15:47:46 -070062 ops.oobbuf = oobbuf;
William Juul9ad754f2007-12-14 16:33:45 +010063 ops.len = nand->writesize;
64 ops.ooblen = nand->oobsize;
65 ops.mode = MTD_OOB_RAW;
66 i = nand->read_oob(nand, addr, &ops);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010067 if (i < 0) {
Stefan Roesee8706902008-07-10 10:10:54 +020068 printf("Error (%d) reading page %08lx\n", i, off);
William Juul9ad754f2007-12-14 16:33:45 +010069 free(datbuf);
70 free(oobbuf);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010071 return 1;
72 }
Stefan Roesee8706902008-07-10 10:10:54 +020073 printf("Page %08lx dump:\n", off);
William Juul9ad754f2007-12-14 16:33:45 +010074 i = nand->writesize >> 4;
75 p = datbuf;
Wolfgang Denk4b070802008-08-14 14:41:06 +020076
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010077 while (i--) {
William Juul9ad754f2007-12-14 16:33:45 +010078 if (!only_oob)
79 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
80 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
81 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
Scott Wooddfbf6172008-06-12 13:20:16 -050082 p[8], p[9], p[10], p[11], p[12], p[13], p[14],
83 p[15]);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010084 p += 16;
85 }
86 puts("OOB:\n");
87 i = nand->oobsize >> 3;
Tom Rinicfdae122012-02-23 15:47:46 -070088 p = oobbuf;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010089 while (i--) {
William Juulcfa460a2007-10-31 13:53:06 +010090 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
91 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010092 p += 8;
93 }
William Juul9ad754f2007-12-14 16:33:45 +010094 free(datbuf);
95 free(oobbuf);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010096
97 return 0;
98}
99
100/* ------------------------------------------------------------------------- */
101
Scott Woodea533c22010-08-02 13:04:24 -0500102static int set_dev(int dev)
103{
104 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
105 !nand_info[dev].name) {
106 puts("No such device\n");
107 return -1;
108 }
109
110 if (nand_curr_device == dev)
111 return 0;
112
113 printf("Device %d: %s", dev, nand_info[dev].name);
114 puts("... is now current device\n");
115 nand_curr_device = dev;
116
117#ifdef CONFIG_SYS_NAND_SELECT_DEVICE
118 board_nand_select_device(nand_info[dev].priv, dev);
119#endif
120
121 return 0;
122}
123
124static inline int str2off(const char *p, loff_t *num)
125{
126 char *endptr;
127
128 *num = simple_strtoull(p, &endptr, 16);
129 return *p != '\0' && *endptr == '\0';
130}
131
132static inline int str2long(const char *p, ulong *num)
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100133{
Stefan Roese856f0542006-10-28 15:55:52 +0200134 char *endptr;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100135
Stefan Roese856f0542006-10-28 15:55:52 +0200136 *num = simple_strtoul(p, &endptr, 16);
Scott Woodea533c22010-08-02 13:04:24 -0500137 return *p != '\0' && *endptr == '\0';
Stefan Roese856f0542006-10-28 15:55:52 +0200138}
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100139
Scott Woodea533c22010-08-02 13:04:24 -0500140static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size)
Stefan Roese856f0542006-10-28 15:55:52 +0200141{
Scott Woodea533c22010-08-02 13:04:24 -0500142#ifdef CONFIG_CMD_MTDPARTS
Stefan Roese856f0542006-10-28 15:55:52 +0200143 struct mtd_device *dev;
144 struct part_info *part;
145 u8 pnum;
Scott Woodea533c22010-08-02 13:04:24 -0500146 int ret;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100147
Scott Woodea533c22010-08-02 13:04:24 -0500148 ret = mtdparts_init();
149 if (ret)
150 return ret;
151
152 ret = find_dev_and_part(partname, &dev, &pnum, &part);
153 if (ret)
154 return ret;
155
156 if (dev->id->type != MTD_DEV_TYPE_NAND) {
157 puts("not a NAND device\n");
158 return -1;
Stefan Roese856f0542006-10-28 15:55:52 +0200159 }
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100160
Scott Woodea533c22010-08-02 13:04:24 -0500161 *off = part->offset;
162 *size = part->size;
163 *idx = dev->id->num;
164
165 ret = set_dev(*idx);
166 if (ret)
167 return ret;
168
169 return 0;
170#else
171 puts("offset is not a number\n");
172 return -1;
173#endif
174}
175
176static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *maxsize)
177{
178 if (!str2off(arg, off))
179 return get_part(arg, idx, off, maxsize);
180
181 if (*off >= nand_info[*idx].size) {
182 puts("Offset exceeds device limit\n");
183 return -1;
184 }
185
186 *maxsize = nand_info[*idx].size - *off;
187 return 0;
188}
189
190static int arg_off_size(int argc, char *const argv[], int *idx,
191 loff_t *off, loff_t *size)
192{
193 int ret;
Marek Vasutf624dd12012-04-29 00:28:39 +0200194 loff_t maxsize = 0;
Scott Woodea533c22010-08-02 13:04:24 -0500195
196 if (argc == 0) {
Stefan Roese856f0542006-10-28 15:55:52 +0200197 *off = 0;
Scott Woodea533c22010-08-02 13:04:24 -0500198 *size = nand_info[*idx].size;
199 goto print;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100200 }
201
Scott Woodea533c22010-08-02 13:04:24 -0500202 ret = arg_off(argv[0], idx, off, &maxsize);
203 if (ret)
204 return ret;
205
206 if (argc == 1) {
207 *size = maxsize;
208 goto print;
Stefan Roese856f0542006-10-28 15:55:52 +0200209 }
210
Scott Woodea533c22010-08-02 13:04:24 -0500211 if (!str2off(argv[1], size)) {
212 printf("'%s' is not a number\n", argv[1]);
213 return -1;
214 }
215
216 if (*size > maxsize) {
217 puts("Size exceeds partition or device limit\n");
218 return -1;
219 }
220
221print:
222 printf("device %d ", *idx);
223 if (*size == nand_info[*idx].size)
Stefan Roese856f0542006-10-28 15:55:52 +0200224 puts("whole chip\n");
225 else
Scott Woodea533c22010-08-02 13:04:24 -0500226 printf("offset 0x%llx, size 0x%llx\n",
227 (unsigned long long)*off, (unsigned long long)*size);
Stefan Roese856f0542006-10-28 15:55:52 +0200228 return 0;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100229}
230
Nishanth Menon50657c22008-12-13 09:43:06 -0600231#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
232static void print_status(ulong start, ulong end, ulong erasesize, int status)
233{
Joe Hershbergere70bfa22012-08-22 16:49:45 -0500234 /*
235 * Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is
236 * not the same as others. Instead of bit 1 being lock, it is
237 * #lock_tight. To make the driver support either format, ignore bit 1
238 * and use only bit 0 and bit 2.
239 */
Nishanth Menon50657c22008-12-13 09:43:06 -0600240 printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
241 start,
242 end - 1,
243 (end - start) / erasesize,
244 ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
Joe Hershbergere70bfa22012-08-22 16:49:45 -0500245 (!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""),
Nishanth Menon50657c22008-12-13 09:43:06 -0600246 ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
247}
248
249static void do_nand_status(nand_info_t *nand)
250{
251 ulong block_start = 0;
252 ulong off;
253 int last_status = -1;
254
255 struct nand_chip *nand_chip = nand->priv;
256 /* check the WP bit */
257 nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
258 printf("device is %swrite protected\n",
259 (nand_chip->read_byte(nand) & 0x80 ?
260 "NOT " : ""));
261
262 for (off = 0; off < nand->size; off += nand->erasesize) {
263 int s = nand_get_lock_status(nand, off);
264
265 /* print message only if status has changed */
266 if (s != last_status && off != 0) {
267 print_status(block_start, off, nand->erasesize,
268 last_status);
269 block_start = off;
270 }
271 last_status = s;
272 }
273 /* Print the last block info */
274 print_status(block_start, off, nand->erasesize, last_status);
275}
276#endif
277
Ben Gardinerc9f73512010-07-05 13:27:07 -0400278#ifdef CONFIG_ENV_OFFSET_OOB
279unsigned long nand_env_oob_offset;
280
Scott Woodea533c22010-08-02 13:04:24 -0500281int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
Ben Gardinerc9f73512010-07-05 13:27:07 -0400282{
283 int ret;
284 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
Scott Woodea533c22010-08-02 13:04:24 -0500285 nand_info_t *nand = &nand_info[0];
Ben Gardinerc9f73512010-07-05 13:27:07 -0400286 char *cmd = argv[1];
287
Scott Woodea533c22010-08-02 13:04:24 -0500288 if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) {
289 puts("no devices available\n");
290 return 1;
291 }
292
293 set_dev(0);
294
Ben Gardinerc9f73512010-07-05 13:27:07 -0400295 if (!strcmp(cmd, "get")) {
296 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
Scott Wood53504a22010-07-12 18:17:40 -0500297 if (ret)
Ben Gardinerc9f73512010-07-05 13:27:07 -0400298 return 1;
Scott Wood53504a22010-07-12 18:17:40 -0500299
300 printf("0x%08lx\n", nand_env_oob_offset);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400301 } else if (!strcmp(cmd, "set")) {
Scott Woodea533c22010-08-02 13:04:24 -0500302 loff_t addr;
303 loff_t maxsize;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400304 struct mtd_oob_ops ops;
Scott Woodea533c22010-08-02 13:04:24 -0500305 int idx = 0;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400306
307 if (argc < 3)
308 goto usage;
309
Scott Woodea533c22010-08-02 13:04:24 -0500310 if (arg_off(argv[2], &idx, &addr, &maxsize)) {
311 puts("Offset or partition name expected\n");
312 return 1;
313 }
314
315 if (idx != 0) {
316 puts("Partition not on first NAND device\n");
Ben Gardinerc9f73512010-07-05 13:27:07 -0400317 return 1;
318 }
319
320 if (nand->oobavail < ENV_OFFSET_SIZE) {
Scott Wood53504a22010-07-12 18:17:40 -0500321 printf("Insufficient available OOB bytes:\n"
322 "%d OOB bytes available but %d required for "
323 "env.oob support\n",
324 nand->oobavail, ENV_OFFSET_SIZE);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400325 return 1;
326 }
327
328 if ((addr & (nand->erasesize - 1)) != 0) {
329 printf("Environment offset must be block-aligned\n");
330 return 1;
331 }
332
333 ops.datbuf = NULL;
334 ops.mode = MTD_OOB_AUTO;
335 ops.ooboffs = 0;
336 ops.ooblen = ENV_OFFSET_SIZE;
337 ops.oobbuf = (void *) oob_buf;
338
339 oob_buf[0] = ENV_OOB_MARKER;
340 oob_buf[1] = addr / nand->erasesize;
341
342 ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops);
Scott Wood53504a22010-07-12 18:17:40 -0500343 if (ret) {
Ben Gardinerc9f73512010-07-05 13:27:07 -0400344 printf("Error writing OOB block 0\n");
345 return ret;
346 }
Scott Wood53504a22010-07-12 18:17:40 -0500347
348 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
349 if (ret) {
350 printf("Error reading env offset in OOB\n");
351 return ret;
352 }
353
354 if (addr != nand_env_oob_offset) {
355 printf("Verification of env offset in OOB failed: "
Scott Woodea533c22010-08-02 13:04:24 -0500356 "0x%08llx expected but got 0x%08lx\n",
357 (unsigned long long)addr, nand_env_oob_offset);
Scott Wood53504a22010-07-12 18:17:40 -0500358 return 1;
359 }
Ben Gardinerc9f73512010-07-05 13:27:07 -0400360 } else {
361 goto usage;
362 }
363
364 return ret;
365
366usage:
Simon Glass4c12eeb2011-12-10 08:44:01 +0000367 return CMD_RET_USAGE;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400368}
369
370#endif
371
Marek Vasutce80ddc2011-09-22 03:57:26 +0200372static void nand_print_and_set_info(int idx)
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100373{
374 nand_info_t *nand = &nand_info[idx];
375 struct nand_chip *chip = nand->priv;
Marek Vasutce80ddc2011-09-22 03:57:26 +0200376 const int bufsz = 32;
377 char buf[bufsz];
378
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100379 printf("Device %d: ", idx);
380 if (chip->numchips > 1)
381 printf("%dx ", chip->numchips);
382 printf("%s, sector size %u KiB\n",
383 nand->name, nand->erasesize >> 10);
Marek Vasutce80ddc2011-09-22 03:57:26 +0200384 printf(" Page size %8d b\n", nand->writesize);
385 printf(" OOB size %8d b\n", nand->oobsize);
386 printf(" Erase size %8d b\n", nand->erasesize);
387
388 /* Set geometry info */
389 sprintf(buf, "%x", nand->writesize);
390 setenv("nand_writesize", buf);
391
392 sprintf(buf, "%x", nand->oobsize);
393 setenv("nand_oobsize", buf);
394
395 sprintf(buf, "%x", nand->erasesize);
396 setenv("nand_erasesize", buf);
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100397}
398
Scott Wood418396e2012-03-02 14:01:57 -0600399static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
400 int read)
401{
402 int ret = 0;
Scott Wood418396e2012-03-02 14:01:57 -0600403
404 while (count--) {
405 /* Raw access */
406 mtd_oob_ops_t ops = {
407 .datbuf = (u8 *)addr,
408 .oobbuf = ((u8 *)addr) + nand->writesize,
409 .len = nand->writesize,
410 .ooblen = nand->oobsize,
411 .mode = MTD_OOB_RAW
412 };
413
Scott Wood418396e2012-03-02 14:01:57 -0600414 if (read)
415 ret = nand->read_oob(nand, off, &ops);
416 else
417 ret = nand->write_oob(nand, off, &ops);
418
419 if (ret) {
420 printf("%s: error at offset %llx, ret %d\n",
421 __func__, (long long)off, ret);
422 break;
423 }
424
425 addr += nand->writesize + nand->oobsize;
426 off += nand->writesize;
427 }
428
429 return ret;
430}
431
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200432int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100433{
Scott Woodea533c22010-08-02 13:04:24 -0500434 int i, ret = 0;
435 ulong addr;
436 loff_t off, size;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100437 char *cmd, *s;
438 nand_info_t *nand;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200439#ifdef CONFIG_SYS_NAND_QUIET
440 int quiet = CONFIG_SYS_NAND_QUIET;
Matthias Fuchsc750d2e2007-09-12 12:36:53 +0200441#else
Stefan Roese2255b2d2006-10-10 12:36:02 +0200442 int quiet = 0;
Matthias Fuchsc750d2e2007-09-12 12:36:53 +0200443#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200444 const char *quiet_str = getenv("quiet");
Scott Woodea533c22010-08-02 13:04:24 -0500445 int dev = nand_curr_device;
Scott Wood8c5659a2010-08-25 15:24:01 -0500446 int repeat = flag & CMD_FLAG_REPEAT;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100447
448 /* at least two arguments please */
449 if (argc < 2)
450 goto usage;
451
Stefan Roese2255b2d2006-10-10 12:36:02 +0200452 if (quiet_str)
453 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
454
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100455 cmd = argv[1];
456
Scott Wood8c5659a2010-08-25 15:24:01 -0500457 /* Only "dump" is repeatable. */
458 if (repeat && strcmp(cmd, "dump"))
459 return 0;
460
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100461 if (strcmp(cmd, "info") == 0) {
462
463 putc('\n');
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200464 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100465 if (nand_info[i].name)
Marek Vasutce80ddc2011-09-22 03:57:26 +0200466 nand_print_and_set_info(i);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100467 }
468 return 0;
469 }
470
471 if (strcmp(cmd, "device") == 0) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100472 if (argc < 3) {
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100473 putc('\n');
Scott Woodea533c22010-08-02 13:04:24 -0500474 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100475 puts("no devices available\n");
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100476 else
Marek Vasutce80ddc2011-09-22 03:57:26 +0200477 nand_print_and_set_info(dev);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100478 return 0;
479 }
Stefan Roese43a2b0e2006-10-20 14:28:52 +0200480
Scott Woodea533c22010-08-02 13:04:24 -0500481 dev = (int)simple_strtoul(argv[2], NULL, 10);
482 set_dev(dev);
Stefan Roese43a2b0e2006-10-20 14:28:52 +0200483
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100484 return 0;
485 }
486
Ben Gardinerc9f73512010-07-05 13:27:07 -0400487#ifdef CONFIG_ENV_OFFSET_OOB
488 /* this command operates only on the first nand device */
Scott Woodea533c22010-08-02 13:04:24 -0500489 if (strcmp(cmd, "env.oob") == 0)
490 return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400491#endif
492
Scott Woodea533c22010-08-02 13:04:24 -0500493 /* The following commands operate on the current device, unless
494 * overridden by a partition specifier. Note that if somehow the
495 * current device is invalid, it will have to be changed to a valid
496 * one before these commands can run, even if a partition specifier
497 * for another device is to be used.
498 */
499 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
500 !nand_info[dev].name) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100501 puts("\nno devices available\n");
502 return 1;
503 }
Scott Woodea533c22010-08-02 13:04:24 -0500504 nand = &nand_info[dev];
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100505
506 if (strcmp(cmd, "bad") == 0) {
Scott Woodea533c22010-08-02 13:04:24 -0500507 printf("\nDevice %d bad blocks:\n", dev);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100508 for (off = 0; off < nand->size; off += nand->erasesize)
509 if (nand_block_isbad(nand, off))
Scott Woodea533c22010-08-02 13:04:24 -0500510 printf(" %08llx\n", (unsigned long long)off);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100511 return 0;
512 }
513
Stefan Roese856f0542006-10-28 15:55:52 +0200514 /*
515 * Syntax is:
516 * 0 1 2 3 4
517 * nand erase [clean] [off size]
518 */
Scott Wood30486322010-08-25 14:43:29 -0500519 if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
Stefan Roese2255b2d2006-10-10 12:36:02 +0200520 nand_erase_options_t opts;
Stefan Roese856f0542006-10-28 15:55:52 +0200521 /* "clean" at index 2 means request to write cleanmarker */
William Juul3043c042007-11-14 14:28:11 +0100522 int clean = argc > 2 && !strcmp("clean", argv[2]);
Marek Vasut60899812011-09-14 00:20:35 +0200523 int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
524 int o = (clean || scrub_yes) ? 3 : 2;
Scott Wood30486322010-08-25 14:43:29 -0500525 int scrub = !strncmp(cmd, "scrub", 5);
Scott Wood30486322010-08-25 14:43:29 -0500526 int spread = 0;
527 int args = 2;
Marek Vasut60899812011-09-14 00:20:35 +0200528 const char *scrub_warn =
529 "Warning: "
530 "scrub option will erase all factory set bad blocks!\n"
531 " "
532 "There is no reliable way to recover them.\n"
533 " "
534 "Use this command only for testing purposes if you\n"
535 " "
536 "are sure of what you are doing!\n"
537 "\nReally scrub this NAND flash? <y/N>\n";
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100538
Scott Wood30486322010-08-25 14:43:29 -0500539 if (cmd[5] != 0) {
540 if (!strcmp(&cmd[5], ".spread")) {
541 spread = 1;
542 } else if (!strcmp(&cmd[5], ".part")) {
Scott Wood30486322010-08-25 14:43:29 -0500543 args = 1;
544 } else if (!strcmp(&cmd[5], ".chip")) {
Scott Wood30486322010-08-25 14:43:29 -0500545 args = 0;
546 } else {
547 goto usage;
548 }
549 }
550
551 /*
552 * Don't allow missing arguments to cause full chip/partition
553 * erases -- easy to do accidentally, e.g. with a misspelled
554 * variable name.
555 */
556 if (argc != o + args)
557 goto usage;
558
559 printf("\nNAND %s: ", cmd);
Stefan Roese856f0542006-10-28 15:55:52 +0200560 /* skip first two or three arguments, look for offset and size */
Scott Woodea533c22010-08-02 13:04:24 -0500561 if (arg_off_size(argc - o, argv + o, &dev, &off, &size) != 0)
Stefan Roese856f0542006-10-28 15:55:52 +0200562 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200563
Scott Woodea533c22010-08-02 13:04:24 -0500564 nand = &nand_info[dev];
565
Stefan Roese2255b2d2006-10-10 12:36:02 +0200566 memset(&opts, 0, sizeof(opts));
567 opts.offset = off;
568 opts.length = size;
569 opts.jffs2 = clean;
570 opts.quiet = quiet;
Scott Wood30486322010-08-25 14:43:29 -0500571 opts.spread = spread;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200572
573 if (scrub) {
Marek Vasut60899812011-09-14 00:20:35 +0200574 if (!scrub_yes)
575 puts(scrub_warn);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200576
Marek Vasut60899812011-09-14 00:20:35 +0200577 if (scrub_yes)
578 opts.scrub = 1;
579 else if (getc() == 'y') {
Florian Fainelli6b94b492010-03-20 19:02:58 +0100580 puts("y");
581 if (getc() == '\r')
582 opts.scrub = 1;
583 else {
584 puts("scrub aborted\n");
585 return -1;
586 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200587 } else {
Stefan Roese856f0542006-10-28 15:55:52 +0200588 puts("scrub aborted\n");
Stefan Roese2255b2d2006-10-10 12:36:02 +0200589 return -1;
590 }
591 }
592 ret = nand_erase_opts(nand, &opts);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100593 printf("%s\n", ret ? "ERROR" : "OK");
594
595 return ret == 0 ? 0 : 1;
596 }
597
598 if (strncmp(cmd, "dump", 4) == 0) {
599 if (argc < 3)
600 goto usage;
601
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100602 off = (int)simple_strtoul(argv[2], NULL, 16);
Scott Wood8c5659a2010-08-25 15:24:01 -0500603 ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100604
605 return ret == 0 ? 1 : 0;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100606 }
607
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100608 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
Scott Woodea533c22010-08-02 13:04:24 -0500609 size_t rwsize;
Scott Wood418396e2012-03-02 14:01:57 -0600610 ulong pagecount = 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200611 int read;
Scott Wood418396e2012-03-02 14:01:57 -0600612 int raw;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200613
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100614 if (argc < 4)
615 goto usage;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200616
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100617 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
618
Stefan Roese2255b2d2006-10-10 12:36:02 +0200619 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
Stefan Roese856f0542006-10-28 15:55:52 +0200620 printf("\nNAND %s: ", read ? "read" : "write");
William Juul4cbb6512007-11-08 10:39:53 +0100621
Scott Woodea533c22010-08-02 13:04:24 -0500622 nand = &nand_info[dev];
Scott Woodea533c22010-08-02 13:04:24 -0500623
Stefan Roese2255b2d2006-10-10 12:36:02 +0200624 s = strchr(cmd, '.');
Scott Wood418396e2012-03-02 14:01:57 -0600625
Steve Sakoman8d75c892012-06-07 10:19:18 -0700626 if (s && !strcmp(s, ".raw")) {
Scott Wood418396e2012-03-02 14:01:57 -0600627 raw = 1;
628
629 if (arg_off(argv[3], &dev, &off, &size))
630 return 1;
631
632 if (argc > 4 && !str2long(argv[4], &pagecount)) {
633 printf("'%s' is not a number\n", argv[4]);
634 return 1;
635 }
636
637 if (pagecount * nand->writesize > size) {
638 puts("Size exceeds partition or device limit\n");
639 return -1;
640 }
641
642 rwsize = pagecount * (nand->writesize + nand->oobsize);
643 } else {
644 if (arg_off_size(argc - 3, argv + 3, &dev,
645 &off, &size) != 0)
646 return 1;
647
648 rwsize = size;
649 }
650
Scott Wood984e03c2008-06-12 13:13:23 -0500651 if (!s || !strcmp(s, ".jffs2") ||
652 !strcmp(s, ".e") || !strcmp(s, ".i")) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500653 if (read)
Scott Woodea533c22010-08-02 13:04:24 -0500654 ret = nand_read_skip_bad(nand, off, &rwsize,
Wolfgang Denk4b070802008-08-14 14:41:06 +0200655 (u_char *)addr);
Scott Wooddfbf6172008-06-12 13:20:16 -0500656 else
Scott Woodea533c22010-08-02 13:04:24 -0500657 ret = nand_write_skip_bad(nand, off, &rwsize,
Lei Wen47fc18f2011-01-06 11:11:58 +0800658 (u_char *)addr, 0);
Ben Gardinerc9494862011-06-14 16:35:07 -0400659#ifdef CONFIG_CMD_NAND_TRIMFFS
660 } else if (!strcmp(s, ".trimffs")) {
661 if (read) {
662 printf("Unknown nand command suffix '%s'\n", s);
663 return 1;
664 }
665 ret = nand_write_skip_bad(nand, off, &rwsize,
666 (u_char *)addr,
667 WITH_DROP_FFS);
668#endif
Lei Wen47fc18f2011-01-06 11:11:58 +0800669#ifdef CONFIG_CMD_NAND_YAFFS
670 } else if (!strcmp(s, ".yaffs")) {
671 if (read) {
672 printf("Unknown nand command suffix '%s'.\n", s);
673 return 1;
674 }
Ben Gardinera6c9aa12011-05-24 10:18:35 -0400675 ret = nand_write_skip_bad(nand, off, &rwsize,
Scott Wood418396e2012-03-02 14:01:57 -0600676 (u_char *)addr,
677 WITH_INLINE_OOB);
Lei Wen47fc18f2011-01-06 11:11:58 +0800678#endif
Mike Frysingerdfc99e12009-04-12 22:29:20 -0400679 } else if (!strcmp(s, ".oob")) {
William Juulcfa460a2007-10-31 13:53:06 +0100680 /* out-of-band data */
681 mtd_oob_ops_t ops = {
682 .oobbuf = (u8 *)addr,
Scott Woodea533c22010-08-02 13:04:24 -0500683 .ooblen = rwsize,
William Juulcfa460a2007-10-31 13:53:06 +0100684 .mode = MTD_OOB_RAW
685 };
686
Harald Welte62d4f432007-12-19 14:12:53 +0100687 if (read)
William Juulcfa460a2007-10-31 13:53:06 +0100688 ret = nand->read_oob(nand, off, &ops);
Harald Welte62d4f432007-12-19 14:12:53 +0100689 else
William Juulcfa460a2007-10-31 13:53:06 +0100690 ret = nand->write_oob(nand, off, &ops);
Scott Wood418396e2012-03-02 14:01:57 -0600691 } else if (raw) {
692 ret = raw_access(nand, addr, off, pagecount, read);
Stefan Roese856f0542006-10-28 15:55:52 +0200693 } else {
Scott Wood984e03c2008-06-12 13:13:23 -0500694 printf("Unknown nand command suffix '%s'.\n", s);
695 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200696 }
697
Scott Woodea533c22010-08-02 13:04:24 -0500698 printf(" %zu bytes %s: %s\n", rwsize,
Stefan Roese2255b2d2006-10-10 12:36:02 +0200699 read ? "read" : "written", ret ? "ERROR" : "OK");
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100700
701 return ret == 0 ? 0 : 1;
702 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200703
Stefan Roese2255b2d2006-10-10 12:36:02 +0200704 if (strcmp(cmd, "markbad") == 0) {
Wolfgang Denk8360b662009-05-24 17:34:33 +0200705 argc -= 2;
706 argv += 2;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200707
Wolfgang Denk8360b662009-05-24 17:34:33 +0200708 if (argc <= 0)
709 goto usage;
710
711 while (argc > 0) {
712 addr = simple_strtoul(*argv, NULL, 16);
713
714 if (nand->block_markbad(nand, addr)) {
715 printf("block 0x%08lx NOT marked "
716 "as bad! ERROR %d\n",
717 addr, ret);
718 ret = 1;
719 } else {
720 printf("block 0x%08lx successfully "
721 "marked as bad\n",
722 addr);
723 }
724 --argc;
725 ++argv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200726 }
Wolfgang Denk8360b662009-05-24 17:34:33 +0200727 return ret;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200728 }
Scott Wooddfbf6172008-06-12 13:20:16 -0500729
Stefan Roese2255b2d2006-10-10 12:36:02 +0200730 if (strcmp(cmd, "biterr") == 0) {
731 /* todo */
732 return 1;
733 }
734
Nishanth Menon50657c22008-12-13 09:43:06 -0600735#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Stefan Roese2255b2d2006-10-10 12:36:02 +0200736 if (strcmp(cmd, "lock") == 0) {
Nishanth Menon50657c22008-12-13 09:43:06 -0600737 int tight = 0;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200738 int status = 0;
739 if (argc == 3) {
740 if (!strcmp("tight", argv[2]))
741 tight = 1;
742 if (!strcmp("status", argv[2]))
743 status = 1;
744 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200745 if (status) {
Nishanth Menon50657c22008-12-13 09:43:06 -0600746 do_nand_status(nand);
William Juulcfa460a2007-10-31 13:53:06 +0100747 } else {
William Juul5e1dae52007-11-09 13:32:30 +0100748 if (!nand_lock(nand, tight)) {
749 puts("NAND flash successfully locked\n");
750 } else {
751 puts("Error locking NAND flash\n");
752 return 1;
753 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200754 }
755 return 0;
756 }
757
Joe Hershbergereee623a2012-08-22 16:49:42 -0500758 if (strncmp(cmd, "unlock", 5) == 0) {
759 int allexcept = 0;
760
761 s = strchr(cmd, '.');
762
763 if (s && !strcmp(s, ".allexcept"))
764 allexcept = 1;
765
Scott Wood16e00992010-10-13 11:04:30 -0500766 if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size) < 0)
Stefan Roese856f0542006-10-28 15:55:52 +0200767 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200768
Joe Hershbergereee623a2012-08-22 16:49:42 -0500769 if (!nand_unlock(&nand_info[dev], off, size, allexcept)) {
William Juul5e1dae52007-11-09 13:32:30 +0100770 puts("NAND flash successfully unlocked\n");
771 } else {
772 puts("Error unlocking NAND flash, "
William Juul3043c042007-11-14 14:28:11 +0100773 "write and erase will probably fail\n");
William Juul5e1dae52007-11-09 13:32:30 +0100774 return 1;
775 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200776 return 0;
777 }
Nishanth Menon50657c22008-12-13 09:43:06 -0600778#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200779
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100780usage:
Simon Glass4c12eeb2011-12-10 08:44:01 +0000781 return CMD_RET_USAGE;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100782}
783
Frans Meulenbroeks388a29d2010-07-31 15:01:53 +0200784U_BOOT_CMD(
785 nand, CONFIG_SYS_MAXARGS, 1, do_nand,
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200786 "NAND sub-system",
787 "info - show available NAND devices\n"
788 "nand device [dev] - show or set current device\n"
789 "nand read - addr off|partition size\n"
790 "nand write - addr off|partition size\n"
791 " read/write 'size' bytes starting at offset 'off'\n"
792 " to/from memory address 'addr', skipping bad blocks.\n"
Scott Wood418396e2012-03-02 14:01:57 -0600793 "nand read.raw - addr off|partition [count]\n"
794 "nand write.raw - addr off|partition [count]\n"
795 " Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
Ben Gardinerc9494862011-06-14 16:35:07 -0400796#ifdef CONFIG_CMD_NAND_TRIMFFS
797 "nand write.trimffs - addr off|partition size\n"
798 " write 'size' bytes starting at offset 'off' from memory address\n"
799 " 'addr', skipping bad blocks and dropping any pages at the end\n"
800 " of eraseblocks that contain only 0xFF\n"
801#endif
Lei Wen47fc18f2011-01-06 11:11:58 +0800802#ifdef CONFIG_CMD_NAND_YAFFS
803 "nand write.yaffs - addr off|partition size\n"
804 " write 'size' bytes starting at offset 'off' with yaffs format\n"
805 " from memory address 'addr', skipping bad blocks.\n"
806#endif
Daniel Hobieb3abce2011-05-19 19:28:54 +0200807 "nand erase[.spread] [clean] off size - erase 'size' bytes "
Scott Wood30486322010-08-25 14:43:29 -0500808 "from offset 'off'\n"
809 " With '.spread', erase enough for given file size, otherwise,\n"
810 " 'size' includes skipped bad blocks.\n"
811 "nand erase.part [clean] partition - erase entire mtd partition'\n"
812 "nand erase.chip [clean] - erase entire chip'\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200813 "nand bad - show bad blocks\n"
814 "nand dump[.oob] off - dump page\n"
Marek Vasut60899812011-09-14 00:20:35 +0200815 "nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
Scott Wood30486322010-08-25 14:43:29 -0500816 " really clean NAND erasing bad blocks (UNSAFE)\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200817 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
818 "nand biterr off - make a bit error at offset (UNSAFE)"
Nishanth Menon50657c22008-12-13 09:43:06 -0600819#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200820 "\n"
821 "nand lock [tight] [status]\n"
822 " bring nand to lock state or display locked pages\n"
Joe Hershbergereee623a2012-08-22 16:49:42 -0500823 "nand unlock[.allexcept] [offset] [size] - unlock section"
Nishanth Menon50657c22008-12-13 09:43:06 -0600824#endif
Ben Gardinerc9f73512010-07-05 13:27:07 -0400825#ifdef CONFIG_ENV_OFFSET_OOB
826 "\n"
827 "nand env.oob - environment offset in OOB of block 0 of"
828 " first device.\n"
829 "nand env.oob set off|partition - set enviromnent offset\n"
830 "nand env.oob get - get environment offset"
831#endif
Nishanth Menon50657c22008-12-13 09:43:06 -0600832);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100833
Stefan Roese856f0542006-10-28 15:55:52 +0200834static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
Wolfgang Denk4b070802008-08-14 14:41:06 +0200835 ulong offset, ulong addr, char *cmd)
Stefan Roese856f0542006-10-28 15:55:52 +0200836{
837 int r;
Mike Frysinger67d668b2011-06-05 13:43:02 +0000838 char *s;
Wolfgang Denk4ca79f42008-04-28 12:08:18 +0200839 size_t cnt;
Stefan Roese856f0542006-10-28 15:55:52 +0200840 image_header_t *hdr;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100841#if defined(CONFIG_FIT)
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200842 const void *fit_hdr = NULL;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100843#endif
Thomas Knobloch10e03892007-07-06 14:58:39 +0200844
845 s = strchr(cmd, '.');
846 if (s != NULL &&
Scott Wood65d8bc92009-03-17 12:06:04 -0500847 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
Scott Wood984e03c2008-06-12 13:13:23 -0500848 printf("Unknown nand load suffix '%s'\n", s);
Simon Glass770605e2012-02-13 13:51:18 +0000849 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Scott Wood984e03c2008-06-12 13:13:23 -0500850 return 1;
851 }
Stefan Roese856f0542006-10-28 15:55:52 +0200852
853 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
854
William Juulcfa460a2007-10-31 13:53:06 +0100855 cnt = nand->writesize;
Ladislav Michl09875052009-03-13 14:38:19 +0100856 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Stefan Roese856f0542006-10-28 15:55:52 +0200857 if (r) {
858 puts("** Read error\n");
Simon Glass770605e2012-02-13 13:51:18 +0000859 bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200860 return 1;
861 }
Simon Glass770605e2012-02-13 13:51:18 +0000862 bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200863
Marian Balakowicz9a4daad2008-02-29 14:58:34 +0100864 switch (genimg_get_format ((void *)addr)) {
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100865 case IMAGE_FORMAT_LEGACY:
866 hdr = (image_header_t *)addr;
Stefan Roese856f0542006-10-28 15:55:52 +0200867
Simon Glass770605e2012-02-13 13:51:18 +0000868 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100869 image_print_contents (hdr);
870
871 cnt = image_get_image_size (hdr);
872 break;
873#if defined(CONFIG_FIT)
874 case IMAGE_FORMAT_FIT:
Marian Balakowicz09475f72008-03-12 10:33:01 +0100875 fit_hdr = (const void *)addr;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100876 puts ("Fit image detected...\n");
877
878 cnt = fit_get_size (fit_hdr);
879 break;
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100880#endif
881 default:
Simon Glass770605e2012-02-13 13:51:18 +0000882 bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100883 puts ("** Unknown image type\n");
Stefan Roese856f0542006-10-28 15:55:52 +0200884 return 1;
885 }
Simon Glass770605e2012-02-13 13:51:18 +0000886 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Stefan Roese856f0542006-10-28 15:55:52 +0200887
Ladislav Michl09875052009-03-13 14:38:19 +0100888 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Stefan Roese856f0542006-10-28 15:55:52 +0200889 if (r) {
890 puts("** Read error\n");
Simon Glass770605e2012-02-13 13:51:18 +0000891 bootstage_error(BOOTSTAGE_ID_NAND_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200892 return 1;
893 }
Simon Glass770605e2012-02-13 13:51:18 +0000894 bootstage_mark(BOOTSTAGE_ID_NAND_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200895
Marian Balakowicz09475f72008-03-12 10:33:01 +0100896#if defined(CONFIG_FIT)
897 /* This cannot be done earlier, we need complete FIT image in RAM first */
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200898 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
899 if (!fit_check_format (fit_hdr)) {
Simon Glass770605e2012-02-13 13:51:18 +0000900 bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200901 puts ("** Bad FIT image format\n");
902 return 1;
903 }
Simon Glass770605e2012-02-13 13:51:18 +0000904 bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200905 fit_print_contents (fit_hdr);
906 }
Marian Balakowicz09475f72008-03-12 10:33:01 +0100907#endif
908
Stefan Roese856f0542006-10-28 15:55:52 +0200909 /* Loading ok, update default load address */
910
911 load_addr = addr;
912
Mike Frysinger67d668b2011-06-05 13:43:02 +0000913 return bootm_maybe_autostart(cmdtp, cmd);
Stefan Roese856f0542006-10-28 15:55:52 +0200914}
915
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200916int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100917{
918 char *boot_device = NULL;
Stefan Roese856f0542006-10-28 15:55:52 +0200919 int idx;
920 ulong addr, offset = 0;
Ladislav Michl0c8a8492009-04-21 02:26:31 +0200921#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese856f0542006-10-28 15:55:52 +0200922 struct mtd_device *dev;
923 struct part_info *part;
924 u8 pnum;
925
926 if (argc >= 2) {
927 char *p = (argc == 2) ? argv[1] : argv[2];
928 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
929 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
930 if (dev->id->type != MTD_DEV_TYPE_NAND) {
931 puts("Not a NAND device\n");
932 return 1;
933 }
934 if (argc > 3)
935 goto usage;
936 if (argc == 3)
Thomas Knobloch10e03892007-07-06 14:58:39 +0200937 addr = simple_strtoul(argv[1], NULL, 16);
Stefan Roese856f0542006-10-28 15:55:52 +0200938 else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200939 addr = CONFIG_SYS_LOAD_ADDR;
Stefan Roese856f0542006-10-28 15:55:52 +0200940 return nand_load_image(cmdtp, &nand_info[dev->id->num],
Wolfgang Denk4b070802008-08-14 14:41:06 +0200941 part->offset, addr, argv[0]);
Stefan Roese856f0542006-10-28 15:55:52 +0200942 }
943 }
944#endif
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100945
Simon Glass770605e2012-02-13 13:51:18 +0000946 bootstage_mark(BOOTSTAGE_ID_NAND_PART);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100947 switch (argc) {
948 case 1:
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200949 addr = CONFIG_SYS_LOAD_ADDR;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100950 boot_device = getenv("bootdevice");
951 break;
952 case 2:
953 addr = simple_strtoul(argv[1], NULL, 16);
954 boot_device = getenv("bootdevice");
955 break;
956 case 3:
957 addr = simple_strtoul(argv[1], NULL, 16);
958 boot_device = argv[2];
959 break;
960 case 4:
961 addr = simple_strtoul(argv[1], NULL, 16);
962 boot_device = argv[2];
963 offset = simple_strtoul(argv[3], NULL, 16);
964 break;
965 default:
Ladislav Michl0c8a8492009-04-21 02:26:31 +0200966#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese856f0542006-10-28 15:55:52 +0200967usage:
968#endif
Simon Glass770605e2012-02-13 13:51:18 +0000969 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Simon Glass4c12eeb2011-12-10 08:44:01 +0000970 return CMD_RET_USAGE;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100971 }
Simon Glass770605e2012-02-13 13:51:18 +0000972 bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100973
974 if (!boot_device) {
975 puts("\n** No boot device **\n");
Simon Glass770605e2012-02-13 13:51:18 +0000976 bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100977 return 1;
978 }
Simon Glass770605e2012-02-13 13:51:18 +0000979 bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100980
Stefan Roese856f0542006-10-28 15:55:52 +0200981 idx = simple_strtoul(boot_device, NULL, 16);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100982
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200983 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
Stefan Roese856f0542006-10-28 15:55:52 +0200984 printf("\n** Device %d not available\n", idx);
Simon Glass770605e2012-02-13 13:51:18 +0000985 bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100986 return 1;
987 }
Simon Glass770605e2012-02-13 13:51:18 +0000988 bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100989
Stefan Roese856f0542006-10-28 15:55:52 +0200990 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100991}
992
993U_BOOT_CMD(nboot, 4, 1, do_nandboot,
Peter Tyser2fb26042009-01-27 18:03:12 -0600994 "boot from NAND device",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200995 "[partition] | [[[loadAddr] dev] offset]"
996);