blob: bae630dfb68ff1b3847a11d9b2f028751f105640 [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 *
14 * Copyright 2010 Freescale Semiconductor
15 * 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
Tom Rinicfdae122012-02-23 15:47:46 -070051 datbuf = malloc(nand->writesize);
William Juul9ad754f2007-12-14 16:33:45 +010052 oobbuf = malloc(nand->oobsize);
53 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;
194 loff_t maxsize;
195
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{
234 printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
235 start,
236 end - 1,
237 (end - start) / erasesize,
238 ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
239 ((status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
240 ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
241}
242
243static void do_nand_status(nand_info_t *nand)
244{
245 ulong block_start = 0;
246 ulong off;
247 int last_status = -1;
248
249 struct nand_chip *nand_chip = nand->priv;
250 /* check the WP bit */
251 nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
252 printf("device is %swrite protected\n",
253 (nand_chip->read_byte(nand) & 0x80 ?
254 "NOT " : ""));
255
256 for (off = 0; off < nand->size; off += nand->erasesize) {
257 int s = nand_get_lock_status(nand, off);
258
259 /* print message only if status has changed */
260 if (s != last_status && off != 0) {
261 print_status(block_start, off, nand->erasesize,
262 last_status);
263 block_start = off;
264 }
265 last_status = s;
266 }
267 /* Print the last block info */
268 print_status(block_start, off, nand->erasesize, last_status);
269}
270#endif
271
Ben Gardinerc9f73512010-07-05 13:27:07 -0400272#ifdef CONFIG_ENV_OFFSET_OOB
273unsigned long nand_env_oob_offset;
274
Scott Woodea533c22010-08-02 13:04:24 -0500275int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
Ben Gardinerc9f73512010-07-05 13:27:07 -0400276{
277 int ret;
278 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
Scott Woodea533c22010-08-02 13:04:24 -0500279 nand_info_t *nand = &nand_info[0];
Ben Gardinerc9f73512010-07-05 13:27:07 -0400280 char *cmd = argv[1];
281
Scott Woodea533c22010-08-02 13:04:24 -0500282 if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) {
283 puts("no devices available\n");
284 return 1;
285 }
286
287 set_dev(0);
288
Ben Gardinerc9f73512010-07-05 13:27:07 -0400289 if (!strcmp(cmd, "get")) {
290 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
Scott Wood53504a22010-07-12 18:17:40 -0500291 if (ret)
Ben Gardinerc9f73512010-07-05 13:27:07 -0400292 return 1;
Scott Wood53504a22010-07-12 18:17:40 -0500293
294 printf("0x%08lx\n", nand_env_oob_offset);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400295 } else if (!strcmp(cmd, "set")) {
Scott Woodea533c22010-08-02 13:04:24 -0500296 loff_t addr;
297 loff_t maxsize;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400298 struct mtd_oob_ops ops;
Scott Woodea533c22010-08-02 13:04:24 -0500299 int idx = 0;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400300
301 if (argc < 3)
302 goto usage;
303
Scott Woodea533c22010-08-02 13:04:24 -0500304 if (arg_off(argv[2], &idx, &addr, &maxsize)) {
305 puts("Offset or partition name expected\n");
306 return 1;
307 }
308
309 if (idx != 0) {
310 puts("Partition not on first NAND device\n");
Ben Gardinerc9f73512010-07-05 13:27:07 -0400311 return 1;
312 }
313
314 if (nand->oobavail < ENV_OFFSET_SIZE) {
Scott Wood53504a22010-07-12 18:17:40 -0500315 printf("Insufficient available OOB bytes:\n"
316 "%d OOB bytes available but %d required for "
317 "env.oob support\n",
318 nand->oobavail, ENV_OFFSET_SIZE);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400319 return 1;
320 }
321
322 if ((addr & (nand->erasesize - 1)) != 0) {
323 printf("Environment offset must be block-aligned\n");
324 return 1;
325 }
326
327 ops.datbuf = NULL;
328 ops.mode = MTD_OOB_AUTO;
329 ops.ooboffs = 0;
330 ops.ooblen = ENV_OFFSET_SIZE;
331 ops.oobbuf = (void *) oob_buf;
332
333 oob_buf[0] = ENV_OOB_MARKER;
334 oob_buf[1] = addr / nand->erasesize;
335
336 ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops);
Scott Wood53504a22010-07-12 18:17:40 -0500337 if (ret) {
Ben Gardinerc9f73512010-07-05 13:27:07 -0400338 printf("Error writing OOB block 0\n");
339 return ret;
340 }
Scott Wood53504a22010-07-12 18:17:40 -0500341
342 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
343 if (ret) {
344 printf("Error reading env offset in OOB\n");
345 return ret;
346 }
347
348 if (addr != nand_env_oob_offset) {
349 printf("Verification of env offset in OOB failed: "
Scott Woodea533c22010-08-02 13:04:24 -0500350 "0x%08llx expected but got 0x%08lx\n",
351 (unsigned long long)addr, nand_env_oob_offset);
Scott Wood53504a22010-07-12 18:17:40 -0500352 return 1;
353 }
Ben Gardinerc9f73512010-07-05 13:27:07 -0400354 } else {
355 goto usage;
356 }
357
358 return ret;
359
360usage:
Simon Glass4c12eeb2011-12-10 08:44:01 +0000361 return CMD_RET_USAGE;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400362}
363
364#endif
365
Marek Vasutce80ddc2011-09-22 03:57:26 +0200366static void nand_print_and_set_info(int idx)
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100367{
368 nand_info_t *nand = &nand_info[idx];
369 struct nand_chip *chip = nand->priv;
Marek Vasutce80ddc2011-09-22 03:57:26 +0200370 const int bufsz = 32;
371 char buf[bufsz];
372
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100373 printf("Device %d: ", idx);
374 if (chip->numchips > 1)
375 printf("%dx ", chip->numchips);
376 printf("%s, sector size %u KiB\n",
377 nand->name, nand->erasesize >> 10);
Marek Vasutce80ddc2011-09-22 03:57:26 +0200378 printf(" Page size %8d b\n", nand->writesize);
379 printf(" OOB size %8d b\n", nand->oobsize);
380 printf(" Erase size %8d b\n", nand->erasesize);
381
382 /* Set geometry info */
383 sprintf(buf, "%x", nand->writesize);
384 setenv("nand_writesize", buf);
385
386 sprintf(buf, "%x", nand->oobsize);
387 setenv("nand_oobsize", buf);
388
389 sprintf(buf, "%x", nand->erasesize);
390 setenv("nand_erasesize", buf);
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100391}
392
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200393int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100394{
Scott Woodea533c22010-08-02 13:04:24 -0500395 int i, ret = 0;
396 ulong addr;
397 loff_t off, size;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100398 char *cmd, *s;
399 nand_info_t *nand;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200400#ifdef CONFIG_SYS_NAND_QUIET
401 int quiet = CONFIG_SYS_NAND_QUIET;
Matthias Fuchsc750d2e2007-09-12 12:36:53 +0200402#else
Stefan Roese2255b2d2006-10-10 12:36:02 +0200403 int quiet = 0;
Matthias Fuchsc750d2e2007-09-12 12:36:53 +0200404#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200405 const char *quiet_str = getenv("quiet");
Scott Woodea533c22010-08-02 13:04:24 -0500406 int dev = nand_curr_device;
Scott Wood8c5659a2010-08-25 15:24:01 -0500407 int repeat = flag & CMD_FLAG_REPEAT;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100408
409 /* at least two arguments please */
410 if (argc < 2)
411 goto usage;
412
Stefan Roese2255b2d2006-10-10 12:36:02 +0200413 if (quiet_str)
414 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
415
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100416 cmd = argv[1];
417
Scott Wood8c5659a2010-08-25 15:24:01 -0500418 /* Only "dump" is repeatable. */
419 if (repeat && strcmp(cmd, "dump"))
420 return 0;
421
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100422 if (strcmp(cmd, "info") == 0) {
423
424 putc('\n');
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200425 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100426 if (nand_info[i].name)
Marek Vasutce80ddc2011-09-22 03:57:26 +0200427 nand_print_and_set_info(i);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100428 }
429 return 0;
430 }
431
432 if (strcmp(cmd, "device") == 0) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100433 if (argc < 3) {
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100434 putc('\n');
Scott Woodea533c22010-08-02 13:04:24 -0500435 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
Wolfgang Grandegger672ed2a2009-02-11 18:38:20 +0100436 puts("no devices available\n");
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100437 else
Marek Vasutce80ddc2011-09-22 03:57:26 +0200438 nand_print_and_set_info(dev);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100439 return 0;
440 }
Stefan Roese43a2b0e2006-10-20 14:28:52 +0200441
Scott Woodea533c22010-08-02 13:04:24 -0500442 dev = (int)simple_strtoul(argv[2], NULL, 10);
443 set_dev(dev);
Stefan Roese43a2b0e2006-10-20 14:28:52 +0200444
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100445 return 0;
446 }
447
Ben Gardinerc9f73512010-07-05 13:27:07 -0400448#ifdef CONFIG_ENV_OFFSET_OOB
449 /* this command operates only on the first nand device */
Scott Woodea533c22010-08-02 13:04:24 -0500450 if (strcmp(cmd, "env.oob") == 0)
451 return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
Ben Gardinerc9f73512010-07-05 13:27:07 -0400452#endif
453
Scott Woodea533c22010-08-02 13:04:24 -0500454 /* The following commands operate on the current device, unless
455 * overridden by a partition specifier. Note that if somehow the
456 * current device is invalid, it will have to be changed to a valid
457 * one before these commands can run, even if a partition specifier
458 * for another device is to be used.
459 */
460 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
461 !nand_info[dev].name) {
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100462 puts("\nno devices available\n");
463 return 1;
464 }
Scott Woodea533c22010-08-02 13:04:24 -0500465 nand = &nand_info[dev];
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100466
467 if (strcmp(cmd, "bad") == 0) {
Scott Woodea533c22010-08-02 13:04:24 -0500468 printf("\nDevice %d bad blocks:\n", dev);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100469 for (off = 0; off < nand->size; off += nand->erasesize)
470 if (nand_block_isbad(nand, off))
Scott Woodea533c22010-08-02 13:04:24 -0500471 printf(" %08llx\n", (unsigned long long)off);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100472 return 0;
473 }
474
Stefan Roese856f0542006-10-28 15:55:52 +0200475 /*
476 * Syntax is:
477 * 0 1 2 3 4
478 * nand erase [clean] [off size]
479 */
Scott Wood30486322010-08-25 14:43:29 -0500480 if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
Stefan Roese2255b2d2006-10-10 12:36:02 +0200481 nand_erase_options_t opts;
Stefan Roese856f0542006-10-28 15:55:52 +0200482 /* "clean" at index 2 means request to write cleanmarker */
William Juul3043c042007-11-14 14:28:11 +0100483 int clean = argc > 2 && !strcmp("clean", argv[2]);
Marek Vasut60899812011-09-14 00:20:35 +0200484 int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
485 int o = (clean || scrub_yes) ? 3 : 2;
Scott Wood30486322010-08-25 14:43:29 -0500486 int scrub = !strncmp(cmd, "scrub", 5);
Scott Wood30486322010-08-25 14:43:29 -0500487 int spread = 0;
488 int args = 2;
Marek Vasut60899812011-09-14 00:20:35 +0200489 const char *scrub_warn =
490 "Warning: "
491 "scrub option will erase all factory set bad blocks!\n"
492 " "
493 "There is no reliable way to recover them.\n"
494 " "
495 "Use this command only for testing purposes if you\n"
496 " "
497 "are sure of what you are doing!\n"
498 "\nReally scrub this NAND flash? <y/N>\n";
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100499
Scott Wood30486322010-08-25 14:43:29 -0500500 if (cmd[5] != 0) {
501 if (!strcmp(&cmd[5], ".spread")) {
502 spread = 1;
503 } else if (!strcmp(&cmd[5], ".part")) {
Scott Wood30486322010-08-25 14:43:29 -0500504 args = 1;
505 } else if (!strcmp(&cmd[5], ".chip")) {
Scott Wood30486322010-08-25 14:43:29 -0500506 args = 0;
507 } else {
508 goto usage;
509 }
510 }
511
512 /*
513 * Don't allow missing arguments to cause full chip/partition
514 * erases -- easy to do accidentally, e.g. with a misspelled
515 * variable name.
516 */
517 if (argc != o + args)
518 goto usage;
519
520 printf("\nNAND %s: ", cmd);
Stefan Roese856f0542006-10-28 15:55:52 +0200521 /* skip first two or three arguments, look for offset and size */
Scott Woodea533c22010-08-02 13:04:24 -0500522 if (arg_off_size(argc - o, argv + o, &dev, &off, &size) != 0)
Stefan Roese856f0542006-10-28 15:55:52 +0200523 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200524
Scott Woodea533c22010-08-02 13:04:24 -0500525 nand = &nand_info[dev];
526
Stefan Roese2255b2d2006-10-10 12:36:02 +0200527 memset(&opts, 0, sizeof(opts));
528 opts.offset = off;
529 opts.length = size;
530 opts.jffs2 = clean;
531 opts.quiet = quiet;
Scott Wood30486322010-08-25 14:43:29 -0500532 opts.spread = spread;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200533
534 if (scrub) {
Marek Vasut60899812011-09-14 00:20:35 +0200535 if (!scrub_yes)
536 puts(scrub_warn);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200537
Marek Vasut60899812011-09-14 00:20:35 +0200538 if (scrub_yes)
539 opts.scrub = 1;
540 else if (getc() == 'y') {
Florian Fainelli6b94b492010-03-20 19:02:58 +0100541 puts("y");
542 if (getc() == '\r')
543 opts.scrub = 1;
544 else {
545 puts("scrub aborted\n");
546 return -1;
547 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200548 } else {
Stefan Roese856f0542006-10-28 15:55:52 +0200549 puts("scrub aborted\n");
Stefan Roese2255b2d2006-10-10 12:36:02 +0200550 return -1;
551 }
552 }
553 ret = nand_erase_opts(nand, &opts);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100554 printf("%s\n", ret ? "ERROR" : "OK");
555
556 return ret == 0 ? 0 : 1;
557 }
558
559 if (strncmp(cmd, "dump", 4) == 0) {
560 if (argc < 3)
561 goto usage;
562
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100563 off = (int)simple_strtoul(argv[2], NULL, 16);
Scott Wood8c5659a2010-08-25 15:24:01 -0500564 ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100565
566 return ret == 0 ? 1 : 0;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100567 }
568
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100569 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
Scott Woodea533c22010-08-02 13:04:24 -0500570 size_t rwsize;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200571 int read;
572
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100573 if (argc < 4)
574 goto usage;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200575
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100576 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
577
Stefan Roese2255b2d2006-10-10 12:36:02 +0200578 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
Stefan Roese856f0542006-10-28 15:55:52 +0200579 printf("\nNAND %s: ", read ? "read" : "write");
Scott Woodea533c22010-08-02 13:04:24 -0500580 if (arg_off_size(argc - 3, argv + 3, &dev, &off, &size) != 0)
Stefan Roese856f0542006-10-28 15:55:52 +0200581 return 1;
William Juul4cbb6512007-11-08 10:39:53 +0100582
Scott Woodea533c22010-08-02 13:04:24 -0500583 nand = &nand_info[dev];
584 rwsize = size;
585
Stefan Roese2255b2d2006-10-10 12:36:02 +0200586 s = strchr(cmd, '.');
Scott Wood984e03c2008-06-12 13:13:23 -0500587 if (!s || !strcmp(s, ".jffs2") ||
588 !strcmp(s, ".e") || !strcmp(s, ".i")) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500589 if (read)
Scott Woodea533c22010-08-02 13:04:24 -0500590 ret = nand_read_skip_bad(nand, off, &rwsize,
Wolfgang Denk4b070802008-08-14 14:41:06 +0200591 (u_char *)addr);
Scott Wooddfbf6172008-06-12 13:20:16 -0500592 else
Scott Woodea533c22010-08-02 13:04:24 -0500593 ret = nand_write_skip_bad(nand, off, &rwsize,
Lei Wen47fc18f2011-01-06 11:11:58 +0800594 (u_char *)addr, 0);
Ben Gardinerc9494862011-06-14 16:35:07 -0400595#ifdef CONFIG_CMD_NAND_TRIMFFS
596 } else if (!strcmp(s, ".trimffs")) {
597 if (read) {
598 printf("Unknown nand command suffix '%s'\n", s);
599 return 1;
600 }
601 ret = nand_write_skip_bad(nand, off, &rwsize,
602 (u_char *)addr,
603 WITH_DROP_FFS);
604#endif
Lei Wen47fc18f2011-01-06 11:11:58 +0800605#ifdef CONFIG_CMD_NAND_YAFFS
606 } else if (!strcmp(s, ".yaffs")) {
607 if (read) {
608 printf("Unknown nand command suffix '%s'.\n", s);
609 return 1;
610 }
Ben Gardinera6c9aa12011-05-24 10:18:35 -0400611 ret = nand_write_skip_bad(nand, off, &rwsize,
612 (u_char *)addr, WITH_YAFFS_OOB);
Lei Wen47fc18f2011-01-06 11:11:58 +0800613#endif
Mike Frysingerdfc99e12009-04-12 22:29:20 -0400614 } else if (!strcmp(s, ".oob")) {
William Juulcfa460a2007-10-31 13:53:06 +0100615 /* out-of-band data */
616 mtd_oob_ops_t ops = {
617 .oobbuf = (u8 *)addr,
Scott Woodea533c22010-08-02 13:04:24 -0500618 .ooblen = rwsize,
William Juulcfa460a2007-10-31 13:53:06 +0100619 .mode = MTD_OOB_RAW
620 };
621
Harald Welte62d4f432007-12-19 14:12:53 +0100622 if (read)
William Juulcfa460a2007-10-31 13:53:06 +0100623 ret = nand->read_oob(nand, off, &ops);
Harald Welte62d4f432007-12-19 14:12:53 +0100624 else
William Juulcfa460a2007-10-31 13:53:06 +0100625 ret = nand->write_oob(nand, off, &ops);
Marek Vasutfb3659a2011-09-23 15:43:10 +0200626 } else if (!strcmp(s, ".raw")) {
627 /* Raw access */
628 mtd_oob_ops_t ops = {
629 .datbuf = (u8 *)addr,
630 .oobbuf = ((u8 *)addr) + nand->writesize,
631 .len = nand->writesize,
632 .ooblen = nand->oobsize,
633 .mode = MTD_OOB_RAW
634 };
635
636 rwsize = nand->writesize + nand->oobsize;
637
638 if (read)
639 ret = nand->read_oob(nand, off, &ops);
640 else
641 ret = nand->write_oob(nand, off, &ops);
Stefan Roese856f0542006-10-28 15:55:52 +0200642 } else {
Scott Wood984e03c2008-06-12 13:13:23 -0500643 printf("Unknown nand command suffix '%s'.\n", s);
644 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200645 }
646
Scott Woodea533c22010-08-02 13:04:24 -0500647 printf(" %zu bytes %s: %s\n", rwsize,
Stefan Roese2255b2d2006-10-10 12:36:02 +0200648 read ? "read" : "written", ret ? "ERROR" : "OK");
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100649
650 return ret == 0 ? 0 : 1;
651 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200652
Stefan Roese2255b2d2006-10-10 12:36:02 +0200653 if (strcmp(cmd, "markbad") == 0) {
Wolfgang Denk8360b662009-05-24 17:34:33 +0200654 argc -= 2;
655 argv += 2;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200656
Wolfgang Denk8360b662009-05-24 17:34:33 +0200657 if (argc <= 0)
658 goto usage;
659
660 while (argc > 0) {
661 addr = simple_strtoul(*argv, NULL, 16);
662
663 if (nand->block_markbad(nand, addr)) {
664 printf("block 0x%08lx NOT marked "
665 "as bad! ERROR %d\n",
666 addr, ret);
667 ret = 1;
668 } else {
669 printf("block 0x%08lx successfully "
670 "marked as bad\n",
671 addr);
672 }
673 --argc;
674 ++argv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200675 }
Wolfgang Denk8360b662009-05-24 17:34:33 +0200676 return ret;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200677 }
Scott Wooddfbf6172008-06-12 13:20:16 -0500678
Stefan Roese2255b2d2006-10-10 12:36:02 +0200679 if (strcmp(cmd, "biterr") == 0) {
680 /* todo */
681 return 1;
682 }
683
Nishanth Menon50657c22008-12-13 09:43:06 -0600684#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Stefan Roese2255b2d2006-10-10 12:36:02 +0200685 if (strcmp(cmd, "lock") == 0) {
Nishanth Menon50657c22008-12-13 09:43:06 -0600686 int tight = 0;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200687 int status = 0;
688 if (argc == 3) {
689 if (!strcmp("tight", argv[2]))
690 tight = 1;
691 if (!strcmp("status", argv[2]))
692 status = 1;
693 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200694 if (status) {
Nishanth Menon50657c22008-12-13 09:43:06 -0600695 do_nand_status(nand);
William Juulcfa460a2007-10-31 13:53:06 +0100696 } else {
William Juul5e1dae52007-11-09 13:32:30 +0100697 if (!nand_lock(nand, tight)) {
698 puts("NAND flash successfully locked\n");
699 } else {
700 puts("Error locking NAND flash\n");
701 return 1;
702 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200703 }
704 return 0;
705 }
706
707 if (strcmp(cmd, "unlock") == 0) {
Scott Wood16e00992010-10-13 11:04:30 -0500708 if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size) < 0)
Stefan Roese856f0542006-10-28 15:55:52 +0200709 return 1;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200710
Scott Woodea533c22010-08-02 13:04:24 -0500711 if (!nand_unlock(&nand_info[dev], off, size)) {
William Juul5e1dae52007-11-09 13:32:30 +0100712 puts("NAND flash successfully unlocked\n");
713 } else {
714 puts("Error unlocking NAND flash, "
William Juul3043c042007-11-14 14:28:11 +0100715 "write and erase will probably fail\n");
William Juul5e1dae52007-11-09 13:32:30 +0100716 return 1;
717 }
Stefan Roese2255b2d2006-10-10 12:36:02 +0200718 return 0;
719 }
Nishanth Menon50657c22008-12-13 09:43:06 -0600720#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200721
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100722usage:
Simon Glass4c12eeb2011-12-10 08:44:01 +0000723 return CMD_RET_USAGE;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100724}
725
Frans Meulenbroeks388a29d2010-07-31 15:01:53 +0200726U_BOOT_CMD(
727 nand, CONFIG_SYS_MAXARGS, 1, do_nand,
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200728 "NAND sub-system",
729 "info - show available NAND devices\n"
730 "nand device [dev] - show or set current device\n"
731 "nand read - addr off|partition size\n"
732 "nand write - addr off|partition size\n"
733 " read/write 'size' bytes starting at offset 'off'\n"
734 " to/from memory address 'addr', skipping bad blocks.\n"
Marek Vasutfb3659a2011-09-23 15:43:10 +0200735 "nand read.raw - addr off|partition\n"
736 "nand write.raw - addr off|partition\n"
737 " Use read.raw/write.raw to avoid ECC and access the page as-is.\n"
Ben Gardinerc9494862011-06-14 16:35:07 -0400738#ifdef CONFIG_CMD_NAND_TRIMFFS
739 "nand write.trimffs - addr off|partition size\n"
740 " write 'size' bytes starting at offset 'off' from memory address\n"
741 " 'addr', skipping bad blocks and dropping any pages at the end\n"
742 " of eraseblocks that contain only 0xFF\n"
743#endif
Lei Wen47fc18f2011-01-06 11:11:58 +0800744#ifdef CONFIG_CMD_NAND_YAFFS
745 "nand write.yaffs - addr off|partition size\n"
746 " write 'size' bytes starting at offset 'off' with yaffs format\n"
747 " from memory address 'addr', skipping bad blocks.\n"
748#endif
Daniel Hobieb3abce2011-05-19 19:28:54 +0200749 "nand erase[.spread] [clean] off size - erase 'size' bytes "
Scott Wood30486322010-08-25 14:43:29 -0500750 "from offset 'off'\n"
751 " With '.spread', erase enough for given file size, otherwise,\n"
752 " 'size' includes skipped bad blocks.\n"
753 "nand erase.part [clean] partition - erase entire mtd partition'\n"
754 "nand erase.chip [clean] - erase entire chip'\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200755 "nand bad - show bad blocks\n"
756 "nand dump[.oob] off - dump page\n"
Marek Vasut60899812011-09-14 00:20:35 +0200757 "nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
Scott Wood30486322010-08-25 14:43:29 -0500758 " really clean NAND erasing bad blocks (UNSAFE)\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200759 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
760 "nand biterr off - make a bit error at offset (UNSAFE)"
Nishanth Menon50657c22008-12-13 09:43:06 -0600761#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200762 "\n"
763 "nand lock [tight] [status]\n"
764 " bring nand to lock state or display locked pages\n"
765 "nand unlock [offset] [size] - unlock section"
Nishanth Menon50657c22008-12-13 09:43:06 -0600766#endif
Ben Gardinerc9f73512010-07-05 13:27:07 -0400767#ifdef CONFIG_ENV_OFFSET_OOB
768 "\n"
769 "nand env.oob - environment offset in OOB of block 0 of"
770 " first device.\n"
771 "nand env.oob set off|partition - set enviromnent offset\n"
772 "nand env.oob get - get environment offset"
773#endif
Nishanth Menon50657c22008-12-13 09:43:06 -0600774);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100775
Stefan Roese856f0542006-10-28 15:55:52 +0200776static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
Wolfgang Denk4b070802008-08-14 14:41:06 +0200777 ulong offset, ulong addr, char *cmd)
Stefan Roese856f0542006-10-28 15:55:52 +0200778{
779 int r;
Mike Frysinger67d668b2011-06-05 13:43:02 +0000780 char *s;
Wolfgang Denk4ca79f42008-04-28 12:08:18 +0200781 size_t cnt;
Stefan Roese856f0542006-10-28 15:55:52 +0200782 image_header_t *hdr;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100783#if defined(CONFIG_FIT)
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200784 const void *fit_hdr = NULL;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100785#endif
Thomas Knobloch10e03892007-07-06 14:58:39 +0200786
787 s = strchr(cmd, '.');
788 if (s != NULL &&
Scott Wood65d8bc92009-03-17 12:06:04 -0500789 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
Scott Wood984e03c2008-06-12 13:13:23 -0500790 printf("Unknown nand load suffix '%s'\n", s);
Simon Glass770605e2012-02-13 13:51:18 +0000791 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Scott Wood984e03c2008-06-12 13:13:23 -0500792 return 1;
793 }
Stefan Roese856f0542006-10-28 15:55:52 +0200794
795 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
796
William Juulcfa460a2007-10-31 13:53:06 +0100797 cnt = nand->writesize;
Ladislav Michl09875052009-03-13 14:38:19 +0100798 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Stefan Roese856f0542006-10-28 15:55:52 +0200799 if (r) {
800 puts("** Read error\n");
Simon Glass770605e2012-02-13 13:51:18 +0000801 bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200802 return 1;
803 }
Simon Glass770605e2012-02-13 13:51:18 +0000804 bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200805
Marian Balakowicz9a4daad2008-02-29 14:58:34 +0100806 switch (genimg_get_format ((void *)addr)) {
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100807 case IMAGE_FORMAT_LEGACY:
808 hdr = (image_header_t *)addr;
Stefan Roese856f0542006-10-28 15:55:52 +0200809
Simon Glass770605e2012-02-13 13:51:18 +0000810 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100811 image_print_contents (hdr);
812
813 cnt = image_get_image_size (hdr);
814 break;
815#if defined(CONFIG_FIT)
816 case IMAGE_FORMAT_FIT:
Marian Balakowicz09475f72008-03-12 10:33:01 +0100817 fit_hdr = (const void *)addr;
Marian Balakowicz09475f72008-03-12 10:33:01 +0100818 puts ("Fit image detected...\n");
819
820 cnt = fit_get_size (fit_hdr);
821 break;
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100822#endif
823 default:
Simon Glass770605e2012-02-13 13:51:18 +0000824 bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczd5934ad2008-02-04 08:28:09 +0100825 puts ("** Unknown image type\n");
Stefan Roese856f0542006-10-28 15:55:52 +0200826 return 1;
827 }
Simon Glass770605e2012-02-13 13:51:18 +0000828 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Stefan Roese856f0542006-10-28 15:55:52 +0200829
Ladislav Michl09875052009-03-13 14:38:19 +0100830 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Stefan Roese856f0542006-10-28 15:55:52 +0200831 if (r) {
832 puts("** Read error\n");
Simon Glass770605e2012-02-13 13:51:18 +0000833 bootstage_error(BOOTSTAGE_ID_NAND_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200834 return 1;
835 }
Simon Glass770605e2012-02-13 13:51:18 +0000836 bootstage_mark(BOOTSTAGE_ID_NAND_READ);
Stefan Roese856f0542006-10-28 15:55:52 +0200837
Marian Balakowicz09475f72008-03-12 10:33:01 +0100838#if defined(CONFIG_FIT)
839 /* This cannot be done earlier, we need complete FIT image in RAM first */
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200840 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
841 if (!fit_check_format (fit_hdr)) {
Simon Glass770605e2012-02-13 13:51:18 +0000842 bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200843 puts ("** Bad FIT image format\n");
844 return 1;
845 }
Simon Glass770605e2012-02-13 13:51:18 +0000846 bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
Marian Balakowicz3bab76a2008-06-06 23:07:40 +0200847 fit_print_contents (fit_hdr);
848 }
Marian Balakowicz09475f72008-03-12 10:33:01 +0100849#endif
850
Stefan Roese856f0542006-10-28 15:55:52 +0200851 /* Loading ok, update default load address */
852
853 load_addr = addr;
854
Mike Frysinger67d668b2011-06-05 13:43:02 +0000855 return bootm_maybe_autostart(cmdtp, cmd);
Stefan Roese856f0542006-10-28 15:55:52 +0200856}
857
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200858int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100859{
860 char *boot_device = NULL;
Stefan Roese856f0542006-10-28 15:55:52 +0200861 int idx;
862 ulong addr, offset = 0;
Ladislav Michl0c8a8492009-04-21 02:26:31 +0200863#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese856f0542006-10-28 15:55:52 +0200864 struct mtd_device *dev;
865 struct part_info *part;
866 u8 pnum;
867
868 if (argc >= 2) {
869 char *p = (argc == 2) ? argv[1] : argv[2];
870 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
871 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
872 if (dev->id->type != MTD_DEV_TYPE_NAND) {
873 puts("Not a NAND device\n");
874 return 1;
875 }
876 if (argc > 3)
877 goto usage;
878 if (argc == 3)
Thomas Knobloch10e03892007-07-06 14:58:39 +0200879 addr = simple_strtoul(argv[1], NULL, 16);
Stefan Roese856f0542006-10-28 15:55:52 +0200880 else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200881 addr = CONFIG_SYS_LOAD_ADDR;
Stefan Roese856f0542006-10-28 15:55:52 +0200882 return nand_load_image(cmdtp, &nand_info[dev->id->num],
Wolfgang Denk4b070802008-08-14 14:41:06 +0200883 part->offset, addr, argv[0]);
Stefan Roese856f0542006-10-28 15:55:52 +0200884 }
885 }
886#endif
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100887
Simon Glass770605e2012-02-13 13:51:18 +0000888 bootstage_mark(BOOTSTAGE_ID_NAND_PART);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100889 switch (argc) {
890 case 1:
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200891 addr = CONFIG_SYS_LOAD_ADDR;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100892 boot_device = getenv("bootdevice");
893 break;
894 case 2:
895 addr = simple_strtoul(argv[1], NULL, 16);
896 boot_device = getenv("bootdevice");
897 break;
898 case 3:
899 addr = simple_strtoul(argv[1], NULL, 16);
900 boot_device = argv[2];
901 break;
902 case 4:
903 addr = simple_strtoul(argv[1], NULL, 16);
904 boot_device = argv[2];
905 offset = simple_strtoul(argv[3], NULL, 16);
906 break;
907 default:
Ladislav Michl0c8a8492009-04-21 02:26:31 +0200908#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese856f0542006-10-28 15:55:52 +0200909usage:
910#endif
Simon Glass770605e2012-02-13 13:51:18 +0000911 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Simon Glass4c12eeb2011-12-10 08:44:01 +0000912 return CMD_RET_USAGE;
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100913 }
Simon Glass770605e2012-02-13 13:51:18 +0000914 bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100915
916 if (!boot_device) {
917 puts("\n** No boot device **\n");
Simon Glass770605e2012-02-13 13:51:18 +0000918 bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100919 return 1;
920 }
Simon Glass770605e2012-02-13 13:51:18 +0000921 bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100922
Stefan Roese856f0542006-10-28 15:55:52 +0200923 idx = simple_strtoul(boot_device, NULL, 16);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100924
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200925 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
Stefan Roese856f0542006-10-28 15:55:52 +0200926 printf("\n** Device %d not available\n", idx);
Simon Glass770605e2012-02-13 13:51:18 +0000927 bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100928 return 1;
929 }
Simon Glass770605e2012-02-13 13:51:18 +0000930 bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100931
Stefan Roese856f0542006-10-28 15:55:52 +0200932 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100933}
934
935U_BOOT_CMD(nboot, 4, 1, do_nandboot,
Peter Tyser2fb26042009-01-27 18:03:12 -0600936 "boot from NAND device",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200937 "[partition] | [[[loadAddr] dev] offset]"
938);