blob: 1568594ca4109c0944292fb2ea7762fa343e7e76 [file] [log] [blame]
wdenkc8434db2003-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>
wdenk6d3c6d12005-04-03 22:35:21 +00006 *
Ben Gardiner5fc8b7f2010-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.
wdenk6d3c6d12005-04-03 22:35:21 +000011 * Added 16-bit nand support
12 * (C) 2004 Texas Instruments
Scott Woode5836dc2010-08-02 13:04:24 -050013 *
Scott Wood733fb022012-03-02 14:01:57 -060014 * Copyright 2010, 2012 Freescale Semiconductor
Scott Woode5836dc2010-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.
wdenkc8434db2003-03-26 06:55:25 +000020 */
21
22#include <common.h>
William Juul52c07962007-10-31 13:53:06 +010023#include <linux/mtd/mtd.h>
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010024#include <command.h>
25#include <watchdog.h>
26#include <malloc.h>
27#include <asm/byteorder.h>
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010028#include <jffs2/jffs2.h>
29#include <nand.h>
30
Ladislav Michl9d0928d2009-04-21 02:26:31 +020031#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese198b23e2006-10-28 15:55:52 +020032
Wolfgang Denk161bfc52009-11-17 21:27:39 +010033/* partition handling routines */
Stefan Roese198b23e2006-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 Denk74e0dde2008-08-14 14:41:06 +020037 u8 *part_num, struct part_info **part);
Stefan Roese198b23e2006-10-28 15:55:52 +020038#endif
39
Scott Wood67d5a2a2010-08-25 15:24:01 -050040static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010041{
42 int i;
William Juule7ebe6e2007-12-14 16:33:45 +010043 u_char *datbuf, *oobbuf, *p;
Scott Wood67d5a2a2010-08-25 15:24:01 -050044 static loff_t last;
45
46 if (repeat)
47 off = last + nand->writesize;
48
49 last = off;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010050
Thierry Reding7d6784f2012-07-30 20:21:55 +000051 datbuf = memalign(ARCH_DMA_MINALIGN, nand->writesize);
52 oobbuf = memalign(ARCH_DMA_MINALIGN, nand->oobsize);
William Juule7ebe6e2007-12-14 16:33:45 +010053 if (!datbuf || !oobbuf) {
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010054 puts("No memory for page buffer\n");
55 return 1;
56 }
William Juul52c07962007-10-31 13:53:06 +010057 off &= ~(nand->writesize - 1);
William Juul52c07962007-10-31 13:53:06 +010058 loff_t addr = (loff_t) off;
William Juule7ebe6e2007-12-14 16:33:45 +010059 struct mtd_oob_ops ops;
60 memset(&ops, 0, sizeof(ops));
61 ops.datbuf = datbuf;
Tom Rini2d2e9752012-02-23 15:47:46 -070062 ops.oobbuf = oobbuf;
William Juule7ebe6e2007-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 Sieka582f1a32006-03-05 18:57:33 +010067 if (i < 0) {
Stefan Roese3167d072008-07-10 10:10:54 +020068 printf("Error (%d) reading page %08lx\n", i, off);
William Juule7ebe6e2007-12-14 16:33:45 +010069 free(datbuf);
70 free(oobbuf);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010071 return 1;
72 }
Stefan Roese3167d072008-07-10 10:10:54 +020073 printf("Page %08lx dump:\n", off);
William Juule7ebe6e2007-12-14 16:33:45 +010074 i = nand->writesize >> 4;
75 p = datbuf;
Wolfgang Denk74e0dde2008-08-14 14:41:06 +020076
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010077 while (i--) {
William Juule7ebe6e2007-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 Woodcc5f3392008-06-12 13:20:16 -050082 p[8], p[9], p[10], p[11], p[12], p[13], p[14],
83 p[15]);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010084 p += 16;
85 }
86 puts("OOB:\n");
87 i = nand->oobsize >> 3;
Tom Rini2d2e9752012-02-23 15:47:46 -070088 p = oobbuf;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010089 while (i--) {
William Juul52c07962007-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 Sieka582f1a32006-03-05 18:57:33 +010092 p += 8;
93 }
William Juule7ebe6e2007-12-14 16:33:45 +010094 free(datbuf);
95 free(oobbuf);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010096
97 return 0;
98}
99
100/* ------------------------------------------------------------------------- */
101
Scott Woode5836dc2010-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 Sieka582f1a32006-03-05 18:57:33 +0100133{
Stefan Roese198b23e2006-10-28 15:55:52 +0200134 char *endptr;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100135
Stefan Roese198b23e2006-10-28 15:55:52 +0200136 *num = simple_strtoul(p, &endptr, 16);
Scott Woode5836dc2010-08-02 13:04:24 -0500137 return *p != '\0' && *endptr == '\0';
Stefan Roese198b23e2006-10-28 15:55:52 +0200138}
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100139
Scott Woode5836dc2010-08-02 13:04:24 -0500140static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size)
Stefan Roese198b23e2006-10-28 15:55:52 +0200141{
Scott Woode5836dc2010-08-02 13:04:24 -0500142#ifdef CONFIG_CMD_MTDPARTS
Stefan Roese198b23e2006-10-28 15:55:52 +0200143 struct mtd_device *dev;
144 struct part_info *part;
145 u8 pnum;
Scott Woode5836dc2010-08-02 13:04:24 -0500146 int ret;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100147
Scott Woode5836dc2010-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 Roese198b23e2006-10-28 15:55:52 +0200159 }
Scott Woode5836dc2010-08-02 13:04:24 -0500160
161 *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;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100173#endif
Scott Woode5836dc2010-08-02 13:04:24 -0500174}
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100175
Scott Woode5836dc2010-08-02 13:04:24 -0500176static 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 Vasutdea93b82012-04-29 00:28:39 +0200194 loff_t maxsize = 0;
Scott Woode5836dc2010-08-02 13:04:24 -0500195
196 if (argc == 0) {
Stefan Roese198b23e2006-10-28 15:55:52 +0200197 *off = 0;
Scott Woode5836dc2010-08-02 13:04:24 -0500198 *size = nand_info[*idx].size;
199 goto print;
Stefan Roese198b23e2006-10-28 15:55:52 +0200200 }
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100201
Scott Woode5836dc2010-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;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100209 }
210
Scott Woode5836dc2010-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 Roese198b23e2006-10-28 15:55:52 +0200224 puts("whole chip\n");
225 else
Scott Woode5836dc2010-08-02 13:04:24 -0500226 printf("offset 0x%llx, size 0x%llx\n",
227 (unsigned long long)*off, (unsigned long long)*size);
Stefan Roese198b23e2006-10-28 15:55:52 +0200228 return 0;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100229}
230
Nishanth Menonb20f8402008-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 Hershberger53768562012-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 Menonb20f8402008-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 Hershberger53768562012-08-22 16:49:45 -0500245 (!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""),
Nishanth Menonb20f8402008-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 Gardiner5fc8b7f2010-07-05 13:27:07 -0400278#ifdef CONFIG_ENV_OFFSET_OOB
279unsigned long nand_env_oob_offset;
280
Scott Woode5836dc2010-08-02 13:04:24 -0500281int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400282{
283 int ret;
284 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
Scott Woode5836dc2010-08-02 13:04:24 -0500285 nand_info_t *nand = &nand_info[0];
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400286 char *cmd = argv[1];
287
Scott Woode5836dc2010-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 Gardiner5fc8b7f2010-07-05 13:27:07 -0400295 if (!strcmp(cmd, "get")) {
296 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
Scott Wood0268da02010-07-12 18:17:40 -0500297 if (ret)
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400298 return 1;
Scott Wood0268da02010-07-12 18:17:40 -0500299
300 printf("0x%08lx\n", nand_env_oob_offset);
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400301 } else if (!strcmp(cmd, "set")) {
Scott Woode5836dc2010-08-02 13:04:24 -0500302 loff_t addr;
303 loff_t maxsize;
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400304 struct mtd_oob_ops ops;
Scott Woode5836dc2010-08-02 13:04:24 -0500305 int idx = 0;
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400306
307 if (argc < 3)
308 goto usage;
309
Scott Woode5836dc2010-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 Gardiner5fc8b7f2010-07-05 13:27:07 -0400317 return 1;
318 }
319
320 if (nand->oobavail < ENV_OFFSET_SIZE) {
Scott Wood0268da02010-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 Gardiner5fc8b7f2010-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 Wood0268da02010-07-12 18:17:40 -0500343 if (ret) {
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400344 printf("Error writing OOB block 0\n");
345 return ret;
346 }
Scott Wood0268da02010-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 Woode5836dc2010-08-02 13:04:24 -0500356 "0x%08llx expected but got 0x%08lx\n",
357 (unsigned long long)addr, nand_env_oob_offset);
Scott Wood0268da02010-07-12 18:17:40 -0500358 return 1;
359 }
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400360 } else {
361 goto usage;
362 }
363
364 return ret;
365
366usage:
Simon Glassa06dfc72011-12-10 08:44:01 +0000367 return CMD_RET_USAGE;
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400368}
369
370#endif
371
Marek Vasut185ce252011-09-22 03:57:26 +0200372static void nand_print_and_set_info(int idx)
Wolfgang Grandeggerb325d7e2009-02-11 18:38:20 +0100373{
374 nand_info_t *nand = &nand_info[idx];
375 struct nand_chip *chip = nand->priv;
Kim Phillipsdc00a682012-10-29 13:34:31 +0000376 char buf[32];
Marek Vasut185ce252011-09-22 03:57:26 +0200377
Wolfgang Grandeggerb325d7e2009-02-11 18:38:20 +0100378 printf("Device %d: ", idx);
379 if (chip->numchips > 1)
380 printf("%dx ", chip->numchips);
381 printf("%s, sector size %u KiB\n",
382 nand->name, nand->erasesize >> 10);
Marek Vasut185ce252011-09-22 03:57:26 +0200383 printf(" Page size %8d b\n", nand->writesize);
384 printf(" OOB size %8d b\n", nand->oobsize);
385 printf(" Erase size %8d b\n", nand->erasesize);
386
387 /* Set geometry info */
388 sprintf(buf, "%x", nand->writesize);
389 setenv("nand_writesize", buf);
390
391 sprintf(buf, "%x", nand->oobsize);
392 setenv("nand_oobsize", buf);
393
394 sprintf(buf, "%x", nand->erasesize);
395 setenv("nand_erasesize", buf);
Wolfgang Grandeggerb325d7e2009-02-11 18:38:20 +0100396}
397
Scott Wood733fb022012-03-02 14:01:57 -0600398static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
399 int read)
400{
401 int ret = 0;
Scott Wood733fb022012-03-02 14:01:57 -0600402
403 while (count--) {
404 /* Raw access */
405 mtd_oob_ops_t ops = {
406 .datbuf = (u8 *)addr,
407 .oobbuf = ((u8 *)addr) + nand->writesize,
408 .len = nand->writesize,
409 .ooblen = nand->oobsize,
410 .mode = MTD_OOB_RAW
411 };
412
Scott Wood733fb022012-03-02 14:01:57 -0600413 if (read)
414 ret = nand->read_oob(nand, off, &ops);
415 else
416 ret = nand->write_oob(nand, off, &ops);
417
418 if (ret) {
419 printf("%s: error at offset %llx, ret %d\n",
420 __func__, (long long)off, ret);
421 break;
422 }
423
424 addr += nand->writesize + nand->oobsize;
425 off += nand->writesize;
426 }
427
428 return ret;
429}
430
Kim Phillipsdc00a682012-10-29 13:34:31 +0000431static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100432{
Scott Woode5836dc2010-08-02 13:04:24 -0500433 int i, ret = 0;
434 ulong addr;
435 loff_t off, size;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100436 char *cmd, *s;
437 nand_info_t *nand;
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200438#ifdef CONFIG_SYS_NAND_QUIET
439 int quiet = CONFIG_SYS_NAND_QUIET;
Matthias Fuchsd42fff22007-09-12 12:36:53 +0200440#else
Stefan Roesed351b2b2006-10-10 12:36:02 +0200441 int quiet = 0;
Matthias Fuchsd42fff22007-09-12 12:36:53 +0200442#endif
Stefan Roesed351b2b2006-10-10 12:36:02 +0200443 const char *quiet_str = getenv("quiet");
Scott Woode5836dc2010-08-02 13:04:24 -0500444 int dev = nand_curr_device;
Scott Wood67d5a2a2010-08-25 15:24:01 -0500445 int repeat = flag & CMD_FLAG_REPEAT;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100446
447 /* at least two arguments please */
448 if (argc < 2)
449 goto usage;
450
Stefan Roesed351b2b2006-10-10 12:36:02 +0200451 if (quiet_str)
452 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
453
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100454 cmd = argv[1];
455
Scott Wood67d5a2a2010-08-25 15:24:01 -0500456 /* Only "dump" is repeatable. */
457 if (repeat && strcmp(cmd, "dump"))
458 return 0;
459
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100460 if (strcmp(cmd, "info") == 0) {
461
462 putc('\n');
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200463 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100464 if (nand_info[i].name)
Marek Vasut185ce252011-09-22 03:57:26 +0200465 nand_print_and_set_info(i);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100466 }
467 return 0;
468 }
469
470 if (strcmp(cmd, "device") == 0) {
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100471 if (argc < 3) {
Wolfgang Grandeggerb325d7e2009-02-11 18:38:20 +0100472 putc('\n');
Scott Woode5836dc2010-08-02 13:04:24 -0500473 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
Wolfgang Grandeggerb325d7e2009-02-11 18:38:20 +0100474 puts("no devices available\n");
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100475 else
Marek Vasut185ce252011-09-22 03:57:26 +0200476 nand_print_and_set_info(dev);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100477 return 0;
478 }
Stefan Roese3cdd3fd2006-10-20 14:28:52 +0200479
Scott Woode5836dc2010-08-02 13:04:24 -0500480 dev = (int)simple_strtoul(argv[2], NULL, 10);
481 set_dev(dev);
Stefan Roese3cdd3fd2006-10-20 14:28:52 +0200482
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100483 return 0;
484 }
485
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400486#ifdef CONFIG_ENV_OFFSET_OOB
487 /* this command operates only on the first nand device */
Scott Woode5836dc2010-08-02 13:04:24 -0500488 if (strcmp(cmd, "env.oob") == 0)
489 return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400490#endif
491
Scott Woode5836dc2010-08-02 13:04:24 -0500492 /* The following commands operate on the current device, unless
493 * overridden by a partition specifier. Note that if somehow the
494 * current device is invalid, it will have to be changed to a valid
495 * one before these commands can run, even if a partition specifier
496 * for another device is to be used.
497 */
498 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
499 !nand_info[dev].name) {
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100500 puts("\nno devices available\n");
501 return 1;
502 }
Scott Woode5836dc2010-08-02 13:04:24 -0500503 nand = &nand_info[dev];
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100504
505 if (strcmp(cmd, "bad") == 0) {
Scott Woode5836dc2010-08-02 13:04:24 -0500506 printf("\nDevice %d bad blocks:\n", dev);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100507 for (off = 0; off < nand->size; off += nand->erasesize)
508 if (nand_block_isbad(nand, off))
Scott Woode5836dc2010-08-02 13:04:24 -0500509 printf(" %08llx\n", (unsigned long long)off);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100510 return 0;
511 }
512
Stefan Roese198b23e2006-10-28 15:55:52 +0200513 /*
514 * Syntax is:
515 * 0 1 2 3 4
516 * nand erase [clean] [off size]
517 */
Scott Wood1b5cd512010-08-25 14:43:29 -0500518 if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
Stefan Roesed351b2b2006-10-10 12:36:02 +0200519 nand_erase_options_t opts;
Stefan Roese198b23e2006-10-28 15:55:52 +0200520 /* "clean" at index 2 means request to write cleanmarker */
William Juulbfb83322007-11-14 14:28:11 +0100521 int clean = argc > 2 && !strcmp("clean", argv[2]);
Marek Vasuta9869812011-09-14 00:20:35 +0200522 int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
523 int o = (clean || scrub_yes) ? 3 : 2;
Scott Wood1b5cd512010-08-25 14:43:29 -0500524 int scrub = !strncmp(cmd, "scrub", 5);
Scott Wood1b5cd512010-08-25 14:43:29 -0500525 int spread = 0;
526 int args = 2;
Marek Vasuta9869812011-09-14 00:20:35 +0200527 const char *scrub_warn =
528 "Warning: "
529 "scrub option will erase all factory set bad blocks!\n"
530 " "
531 "There is no reliable way to recover them.\n"
532 " "
533 "Use this command only for testing purposes if you\n"
534 " "
535 "are sure of what you are doing!\n"
536 "\nReally scrub this NAND flash? <y/N>\n";
Stefan Roesed351b2b2006-10-10 12:36:02 +0200537
Scott Wood1b5cd512010-08-25 14:43:29 -0500538 if (cmd[5] != 0) {
539 if (!strcmp(&cmd[5], ".spread")) {
540 spread = 1;
541 } else if (!strcmp(&cmd[5], ".part")) {
Scott Wood1b5cd512010-08-25 14:43:29 -0500542 args = 1;
543 } else if (!strcmp(&cmd[5], ".chip")) {
Scott Wood1b5cd512010-08-25 14:43:29 -0500544 args = 0;
545 } else {
546 goto usage;
547 }
548 }
549
550 /*
551 * Don't allow missing arguments to cause full chip/partition
552 * erases -- easy to do accidentally, e.g. with a misspelled
553 * variable name.
554 */
555 if (argc != o + args)
556 goto usage;
557
558 printf("\nNAND %s: ", cmd);
Stefan Roese198b23e2006-10-28 15:55:52 +0200559 /* skip first two or three arguments, look for offset and size */
Scott Woode5836dc2010-08-02 13:04:24 -0500560 if (arg_off_size(argc - o, argv + o, &dev, &off, &size) != 0)
Stefan Roese198b23e2006-10-28 15:55:52 +0200561 return 1;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200562
Scott Woode5836dc2010-08-02 13:04:24 -0500563 nand = &nand_info[dev];
564
Stefan Roesed351b2b2006-10-10 12:36:02 +0200565 memset(&opts, 0, sizeof(opts));
566 opts.offset = off;
567 opts.length = size;
568 opts.jffs2 = clean;
569 opts.quiet = quiet;
Scott Wood1b5cd512010-08-25 14:43:29 -0500570 opts.spread = spread;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200571
572 if (scrub) {
Marek Vasuta9869812011-09-14 00:20:35 +0200573 if (!scrub_yes)
574 puts(scrub_warn);
Stefan Roesed351b2b2006-10-10 12:36:02 +0200575
Marek Vasuta9869812011-09-14 00:20:35 +0200576 if (scrub_yes)
577 opts.scrub = 1;
578 else if (getc() == 'y') {
Florian Fainelliadb8eb92010-03-20 19:02:58 +0100579 puts("y");
580 if (getc() == '\r')
581 opts.scrub = 1;
582 else {
583 puts("scrub aborted\n");
584 return -1;
585 }
Stefan Roesed351b2b2006-10-10 12:36:02 +0200586 } else {
Stefan Roese198b23e2006-10-28 15:55:52 +0200587 puts("scrub aborted\n");
Stefan Roesed351b2b2006-10-10 12:36:02 +0200588 return -1;
589 }
590 }
591 ret = nand_erase_opts(nand, &opts);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100592 printf("%s\n", ret ? "ERROR" : "OK");
593
594 return ret == 0 ? 0 : 1;
595 }
596
597 if (strncmp(cmd, "dump", 4) == 0) {
598 if (argc < 3)
599 goto usage;
600
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100601 off = (int)simple_strtoul(argv[2], NULL, 16);
Scott Wood67d5a2a2010-08-25 15:24:01 -0500602 ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100603
604 return ret == 0 ? 1 : 0;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100605 }
606
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100607 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
Scott Woode5836dc2010-08-02 13:04:24 -0500608 size_t rwsize;
Scott Wood733fb022012-03-02 14:01:57 -0600609 ulong pagecount = 1;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200610 int read;
Scott Wood733fb022012-03-02 14:01:57 -0600611 int raw;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200612
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100613 if (argc < 4)
614 goto usage;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200615
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100616 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
617
Stefan Roesed351b2b2006-10-10 12:36:02 +0200618 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
Stefan Roese198b23e2006-10-28 15:55:52 +0200619 printf("\nNAND %s: ", read ? "read" : "write");
William Juulb76ec382007-11-08 10:39:53 +0100620
Scott Woode5836dc2010-08-02 13:04:24 -0500621 nand = &nand_info[dev];
Scott Woode5836dc2010-08-02 13:04:24 -0500622
Stefan Roesed351b2b2006-10-10 12:36:02 +0200623 s = strchr(cmd, '.');
Scott Wood733fb022012-03-02 14:01:57 -0600624
Steve Sakoman736d3252012-06-07 10:19:18 -0700625 if (s && !strcmp(s, ".raw")) {
Scott Wood733fb022012-03-02 14:01:57 -0600626 raw = 1;
627
628 if (arg_off(argv[3], &dev, &off, &size))
629 return 1;
630
631 if (argc > 4 && !str2long(argv[4], &pagecount)) {
632 printf("'%s' is not a number\n", argv[4]);
633 return 1;
634 }
635
636 if (pagecount * nand->writesize > size) {
637 puts("Size exceeds partition or device limit\n");
638 return -1;
639 }
640
641 rwsize = pagecount * (nand->writesize + nand->oobsize);
642 } else {
643 if (arg_off_size(argc - 3, argv + 3, &dev,
644 &off, &size) != 0)
645 return 1;
646
647 rwsize = size;
648 }
649
Scott Wood12b1c952008-06-12 13:13:23 -0500650 if (!s || !strcmp(s, ".jffs2") ||
651 !strcmp(s, ".e") || !strcmp(s, ".i")) {
Scott Woodcc5f3392008-06-12 13:20:16 -0500652 if (read)
Scott Woode5836dc2010-08-02 13:04:24 -0500653 ret = nand_read_skip_bad(nand, off, &rwsize,
Wolfgang Denk74e0dde2008-08-14 14:41:06 +0200654 (u_char *)addr);
Scott Woodcc5f3392008-06-12 13:20:16 -0500655 else
Scott Woode5836dc2010-08-02 13:04:24 -0500656 ret = nand_write_skip_bad(nand, off, &rwsize,
Lei Wen4b5deaa2011-01-06 11:11:58 +0800657 (u_char *)addr, 0);
Ben Gardinerbc04b4d2011-06-14 16:35:07 -0400658#ifdef CONFIG_CMD_NAND_TRIMFFS
659 } else if (!strcmp(s, ".trimffs")) {
660 if (read) {
661 printf("Unknown nand command suffix '%s'\n", s);
662 return 1;
663 }
664 ret = nand_write_skip_bad(nand, off, &rwsize,
665 (u_char *)addr,
666 WITH_DROP_FFS);
667#endif
Lei Wen4b5deaa2011-01-06 11:11:58 +0800668#ifdef CONFIG_CMD_NAND_YAFFS
669 } else if (!strcmp(s, ".yaffs")) {
670 if (read) {
671 printf("Unknown nand command suffix '%s'.\n", s);
672 return 1;
673 }
Ben Gardiner1caafbb2011-05-24 10:18:35 -0400674 ret = nand_write_skip_bad(nand, off, &rwsize,
Scott Wood733fb022012-03-02 14:01:57 -0600675 (u_char *)addr,
676 WITH_INLINE_OOB);
Lei Wen4b5deaa2011-01-06 11:11:58 +0800677#endif
Mike Frysinger9a2cbb92009-04-12 22:29:20 -0400678 } else if (!strcmp(s, ".oob")) {
William Juul52c07962007-10-31 13:53:06 +0100679 /* out-of-band data */
680 mtd_oob_ops_t ops = {
681 .oobbuf = (u8 *)addr,
Scott Woode5836dc2010-08-02 13:04:24 -0500682 .ooblen = rwsize,
William Juul52c07962007-10-31 13:53:06 +0100683 .mode = MTD_OOB_RAW
684 };
685
Harald Welte5a395102007-12-19 14:12:53 +0100686 if (read)
William Juul52c07962007-10-31 13:53:06 +0100687 ret = nand->read_oob(nand, off, &ops);
Harald Welte5a395102007-12-19 14:12:53 +0100688 else
William Juul52c07962007-10-31 13:53:06 +0100689 ret = nand->write_oob(nand, off, &ops);
Scott Wood733fb022012-03-02 14:01:57 -0600690 } else if (raw) {
691 ret = raw_access(nand, addr, off, pagecount, read);
Stefan Roese198b23e2006-10-28 15:55:52 +0200692 } else {
Scott Wood12b1c952008-06-12 13:13:23 -0500693 printf("Unknown nand command suffix '%s'.\n", s);
694 return 1;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200695 }
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100696
Scott Woode5836dc2010-08-02 13:04:24 -0500697 printf(" %zu bytes %s: %s\n", rwsize,
Stefan Roesed351b2b2006-10-10 12:36:02 +0200698 read ? "read" : "written", ret ? "ERROR" : "OK");
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100699
700 return ret == 0 ? 0 : 1;
701 }
Stefan Roesed351b2b2006-10-10 12:36:02 +0200702
Benoît Thébaudeau5661f702012-11-16 20:20:54 +0100703#ifdef CONFIG_CMD_NAND_TORTURE
704 if (strcmp(cmd, "torture") == 0) {
705 if (argc < 3)
706 goto usage;
707
708 if (!str2off(argv[2], &off)) {
709 puts("Offset is not a valid number\n");
710 return 1;
711 }
712
713 printf("\nNAND torture: device %d offset 0x%llx size 0x%x\n",
714 dev, off, nand->erasesize);
715 ret = nand_torture(nand, off);
716 printf(" %s\n", ret ? "Failed" : "Passed");
717
718 return ret == 0 ? 0 : 1;
719 }
720#endif
721
Stefan Roesed351b2b2006-10-10 12:36:02 +0200722 if (strcmp(cmd, "markbad") == 0) {
Wolfgang Denk7a15ca12009-05-24 17:34:33 +0200723 argc -= 2;
724 argv += 2;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200725
Wolfgang Denk7a15ca12009-05-24 17:34:33 +0200726 if (argc <= 0)
727 goto usage;
728
729 while (argc > 0) {
730 addr = simple_strtoul(*argv, NULL, 16);
731
732 if (nand->block_markbad(nand, addr)) {
733 printf("block 0x%08lx NOT marked "
734 "as bad! ERROR %d\n",
735 addr, ret);
736 ret = 1;
737 } else {
738 printf("block 0x%08lx successfully "
739 "marked as bad\n",
740 addr);
741 }
742 --argc;
743 ++argv;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200744 }
Wolfgang Denk7a15ca12009-05-24 17:34:33 +0200745 return ret;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200746 }
Scott Woodcc5f3392008-06-12 13:20:16 -0500747
Stefan Roesed351b2b2006-10-10 12:36:02 +0200748 if (strcmp(cmd, "biterr") == 0) {
749 /* todo */
750 return 1;
751 }
752
Nishanth Menonb20f8402008-12-13 09:43:06 -0600753#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Stefan Roesed351b2b2006-10-10 12:36:02 +0200754 if (strcmp(cmd, "lock") == 0) {
Nishanth Menonb20f8402008-12-13 09:43:06 -0600755 int tight = 0;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200756 int status = 0;
757 if (argc == 3) {
758 if (!strcmp("tight", argv[2]))
759 tight = 1;
760 if (!strcmp("status", argv[2]))
761 status = 1;
762 }
Stefan Roesed351b2b2006-10-10 12:36:02 +0200763 if (status) {
Nishanth Menonb20f8402008-12-13 09:43:06 -0600764 do_nand_status(nand);
William Juul52c07962007-10-31 13:53:06 +0100765 } else {
William Juul9e9c2c12007-11-09 13:32:30 +0100766 if (!nand_lock(nand, tight)) {
767 puts("NAND flash successfully locked\n");
768 } else {
769 puts("Error locking NAND flash\n");
770 return 1;
771 }
Stefan Roesed351b2b2006-10-10 12:36:02 +0200772 }
773 return 0;
774 }
775
Joe Hershbergercccf5952012-08-22 16:49:42 -0500776 if (strncmp(cmd, "unlock", 5) == 0) {
777 int allexcept = 0;
778
779 s = strchr(cmd, '.');
780
781 if (s && !strcmp(s, ".allexcept"))
782 allexcept = 1;
783
Scott Wood6587e3e2010-10-13 11:04:30 -0500784 if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size) < 0)
Stefan Roese198b23e2006-10-28 15:55:52 +0200785 return 1;
Stefan Roesed351b2b2006-10-10 12:36:02 +0200786
Joe Hershbergercccf5952012-08-22 16:49:42 -0500787 if (!nand_unlock(&nand_info[dev], off, size, allexcept)) {
William Juul9e9c2c12007-11-09 13:32:30 +0100788 puts("NAND flash successfully unlocked\n");
789 } else {
790 puts("Error unlocking NAND flash, "
William Juulbfb83322007-11-14 14:28:11 +0100791 "write and erase will probably fail\n");
William Juul9e9c2c12007-11-09 13:32:30 +0100792 return 1;
793 }
Stefan Roesed351b2b2006-10-10 12:36:02 +0200794 return 0;
795 }
Nishanth Menonb20f8402008-12-13 09:43:06 -0600796#endif
Stefan Roesed351b2b2006-10-10 12:36:02 +0200797
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100798usage:
Simon Glassa06dfc72011-12-10 08:44:01 +0000799 return CMD_RET_USAGE;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100800}
801
Kim Phillipsdc00a682012-10-29 13:34:31 +0000802#ifdef CONFIG_SYS_LONGHELP
803static char nand_help_text[] =
Wolfgang Denkc54781c2009-05-24 17:06:54 +0200804 "info - show available NAND devices\n"
805 "nand device [dev] - show or set current device\n"
806 "nand read - addr off|partition size\n"
807 "nand write - addr off|partition size\n"
808 " read/write 'size' bytes starting at offset 'off'\n"
809 " to/from memory address 'addr', skipping bad blocks.\n"
Scott Wood733fb022012-03-02 14:01:57 -0600810 "nand read.raw - addr off|partition [count]\n"
811 "nand write.raw - addr off|partition [count]\n"
812 " Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
Ben Gardinerbc04b4d2011-06-14 16:35:07 -0400813#ifdef CONFIG_CMD_NAND_TRIMFFS
814 "nand write.trimffs - addr off|partition size\n"
815 " write 'size' bytes starting at offset 'off' from memory address\n"
816 " 'addr', skipping bad blocks and dropping any pages at the end\n"
817 " of eraseblocks that contain only 0xFF\n"
818#endif
Lei Wen4b5deaa2011-01-06 11:11:58 +0800819#ifdef CONFIG_CMD_NAND_YAFFS
820 "nand write.yaffs - addr off|partition size\n"
821 " write 'size' bytes starting at offset 'off' with yaffs format\n"
822 " from memory address 'addr', skipping bad blocks.\n"
823#endif
Daniel Hobid99968f2011-05-19 19:28:54 +0200824 "nand erase[.spread] [clean] off size - erase 'size' bytes "
Scott Wood1b5cd512010-08-25 14:43:29 -0500825 "from offset 'off'\n"
826 " With '.spread', erase enough for given file size, otherwise,\n"
827 " 'size' includes skipped bad blocks.\n"
828 "nand erase.part [clean] partition - erase entire mtd partition'\n"
829 "nand erase.chip [clean] - erase entire chip'\n"
Wolfgang Denkc54781c2009-05-24 17:06:54 +0200830 "nand bad - show bad blocks\n"
831 "nand dump[.oob] off - dump page\n"
Benoît Thébaudeau5661f702012-11-16 20:20:54 +0100832#ifdef CONFIG_CMD_NAND_TORTURE
833 "nand torture off - torture block at offset\n"
834#endif
Marek Vasuta9869812011-09-14 00:20:35 +0200835 "nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
Scott Wood1b5cd512010-08-25 14:43:29 -0500836 " really clean NAND erasing bad blocks (UNSAFE)\n"
Wolfgang Denkc54781c2009-05-24 17:06:54 +0200837 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
838 "nand biterr off - make a bit error at offset (UNSAFE)"
Nishanth Menonb20f8402008-12-13 09:43:06 -0600839#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
Wolfgang Denkc54781c2009-05-24 17:06:54 +0200840 "\n"
841 "nand lock [tight] [status]\n"
842 " bring nand to lock state or display locked pages\n"
Joe Hershbergercccf5952012-08-22 16:49:42 -0500843 "nand unlock[.allexcept] [offset] [size] - unlock section"
Nishanth Menonb20f8402008-12-13 09:43:06 -0600844#endif
Ben Gardiner5fc8b7f2010-07-05 13:27:07 -0400845#ifdef CONFIG_ENV_OFFSET_OOB
846 "\n"
847 "nand env.oob - environment offset in OOB of block 0 of"
848 " first device.\n"
849 "nand env.oob set off|partition - set enviromnent offset\n"
850 "nand env.oob get - get environment offset"
851#endif
Kim Phillipsdc00a682012-10-29 13:34:31 +0000852 "";
853#endif
854
855U_BOOT_CMD(
856 nand, CONFIG_SYS_MAXARGS, 1, do_nand,
857 "NAND sub-system", nand_help_text
Nishanth Menonb20f8402008-12-13 09:43:06 -0600858);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100859
Stefan Roese198b23e2006-10-28 15:55:52 +0200860static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
Wolfgang Denk74e0dde2008-08-14 14:41:06 +0200861 ulong offset, ulong addr, char *cmd)
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100862{
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100863 int r;
Mike Frysinger194c2e82011-06-05 13:43:02 +0000864 char *s;
Wolfgang Denk9a11ccd2008-04-28 12:08:18 +0200865 size_t cnt;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100866 image_header_t *hdr;
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100867#if defined(CONFIG_FIT)
Marian Balakowiczcefb4022008-06-06 23:07:40 +0200868 const void *fit_hdr = NULL;
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100869#endif
Thomas Knobloche84b7772007-07-06 14:58:39 +0200870
871 s = strchr(cmd, '.');
872 if (s != NULL &&
Scott Woodd1c1f9c2009-03-17 12:06:04 -0500873 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
Scott Wood12b1c952008-06-12 13:13:23 -0500874 printf("Unknown nand load suffix '%s'\n", s);
Simon Glass0169e6b2012-02-13 13:51:18 +0000875 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Scott Wood12b1c952008-06-12 13:13:23 -0500876 return 1;
877 }
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100878
Stefan Roese198b23e2006-10-28 15:55:52 +0200879 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100880
William Juul52c07962007-10-31 13:53:06 +0100881 cnt = nand->writesize;
Ladislav Michlaaee2a32009-03-13 14:38:19 +0100882 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100883 if (r) {
Stefan Roese198b23e2006-10-28 15:55:52 +0200884 puts("** Read error\n");
Simon Glass0169e6b2012-02-13 13:51:18 +0000885 bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100886 return 1;
887 }
Simon Glass0169e6b2012-02-13 13:51:18 +0000888 bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100889
Marian Balakowiczd7c88a42008-02-29 14:58:34 +0100890 switch (genimg_get_format ((void *)addr)) {
Marian Balakowiczdbdd16a2008-02-04 08:28:09 +0100891 case IMAGE_FORMAT_LEGACY:
892 hdr = (image_header_t *)addr;
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100893
Simon Glass0169e6b2012-02-13 13:51:18 +0000894 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczdbdd16a2008-02-04 08:28:09 +0100895 image_print_contents (hdr);
896
897 cnt = image_get_image_size (hdr);
898 break;
899#if defined(CONFIG_FIT)
900 case IMAGE_FORMAT_FIT:
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100901 fit_hdr = (const void *)addr;
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100902 puts ("Fit image detected...\n");
903
904 cnt = fit_get_size (fit_hdr);
905 break;
Marian Balakowiczdbdd16a2008-02-04 08:28:09 +0100906#endif
907 default:
Simon Glass0169e6b2012-02-13 13:51:18 +0000908 bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
Marian Balakowiczdbdd16a2008-02-04 08:28:09 +0100909 puts ("** Unknown image type\n");
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100910 return 1;
911 }
Simon Glass0169e6b2012-02-13 13:51:18 +0000912 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100913
Ladislav Michlaaee2a32009-03-13 14:38:19 +0100914 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100915 if (r) {
Stefan Roese198b23e2006-10-28 15:55:52 +0200916 puts("** Read error\n");
Simon Glass0169e6b2012-02-13 13:51:18 +0000917 bootstage_error(BOOTSTAGE_ID_NAND_READ);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100918 return 1;
919 }
Simon Glass0169e6b2012-02-13 13:51:18 +0000920 bootstage_mark(BOOTSTAGE_ID_NAND_READ);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100921
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100922#if defined(CONFIG_FIT)
923 /* This cannot be done earlier, we need complete FIT image in RAM first */
Marian Balakowiczcefb4022008-06-06 23:07:40 +0200924 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
925 if (!fit_check_format (fit_hdr)) {
Simon Glass0169e6b2012-02-13 13:51:18 +0000926 bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
Marian Balakowiczcefb4022008-06-06 23:07:40 +0200927 puts ("** Bad FIT image format\n");
928 return 1;
929 }
Simon Glass0169e6b2012-02-13 13:51:18 +0000930 bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
Marian Balakowiczcefb4022008-06-06 23:07:40 +0200931 fit_print_contents (fit_hdr);
932 }
Marian Balakowicze6bdd342008-03-12 10:33:01 +0100933#endif
934
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100935 /* Loading ok, update default load address */
936
937 load_addr = addr;
938
Mike Frysinger194c2e82011-06-05 13:43:02 +0000939 return bootm_maybe_autostart(cmdtp, cmd);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100940}
941
Kim Phillipsdc00a682012-10-29 13:34:31 +0000942static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
943 char * const argv[])
Stefan Roese198b23e2006-10-28 15:55:52 +0200944{
945 char *boot_device = NULL;
946 int idx;
947 ulong addr, offset = 0;
Ladislav Michl9d0928d2009-04-21 02:26:31 +0200948#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese198b23e2006-10-28 15:55:52 +0200949 struct mtd_device *dev;
950 struct part_info *part;
951 u8 pnum;
952
953 if (argc >= 2) {
954 char *p = (argc == 2) ? argv[1] : argv[2];
955 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
956 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
957 if (dev->id->type != MTD_DEV_TYPE_NAND) {
958 puts("Not a NAND device\n");
959 return 1;
960 }
961 if (argc > 3)
962 goto usage;
963 if (argc == 3)
Thomas Knobloche84b7772007-07-06 14:58:39 +0200964 addr = simple_strtoul(argv[1], NULL, 16);
Stefan Roese198b23e2006-10-28 15:55:52 +0200965 else
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200966 addr = CONFIG_SYS_LOAD_ADDR;
Stefan Roese198b23e2006-10-28 15:55:52 +0200967 return nand_load_image(cmdtp, &nand_info[dev->id->num],
Wolfgang Denk74e0dde2008-08-14 14:41:06 +0200968 part->offset, addr, argv[0]);
Stefan Roese198b23e2006-10-28 15:55:52 +0200969 }
970 }
971#endif
972
Simon Glass0169e6b2012-02-13 13:51:18 +0000973 bootstage_mark(BOOTSTAGE_ID_NAND_PART);
Stefan Roese198b23e2006-10-28 15:55:52 +0200974 switch (argc) {
975 case 1:
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +0200976 addr = CONFIG_SYS_LOAD_ADDR;
Stefan Roese198b23e2006-10-28 15:55:52 +0200977 boot_device = getenv("bootdevice");
978 break;
979 case 2:
980 addr = simple_strtoul(argv[1], NULL, 16);
981 boot_device = getenv("bootdevice");
982 break;
983 case 3:
984 addr = simple_strtoul(argv[1], NULL, 16);
985 boot_device = argv[2];
986 break;
987 case 4:
988 addr = simple_strtoul(argv[1], NULL, 16);
989 boot_device = argv[2];
990 offset = simple_strtoul(argv[3], NULL, 16);
991 break;
992 default:
Ladislav Michl9d0928d2009-04-21 02:26:31 +0200993#if defined(CONFIG_CMD_MTDPARTS)
Stefan Roese198b23e2006-10-28 15:55:52 +0200994usage:
995#endif
Simon Glass0169e6b2012-02-13 13:51:18 +0000996 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
Simon Glassa06dfc72011-12-10 08:44:01 +0000997 return CMD_RET_USAGE;
Stefan Roese198b23e2006-10-28 15:55:52 +0200998 }
Simon Glass0169e6b2012-02-13 13:51:18 +0000999 bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
Stefan Roese198b23e2006-10-28 15:55:52 +02001000
1001 if (!boot_device) {
1002 puts("\n** No boot device **\n");
Simon Glass0169e6b2012-02-13 13:51:18 +00001003 bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Stefan Roese198b23e2006-10-28 15:55:52 +02001004 return 1;
1005 }
Simon Glass0169e6b2012-02-13 13:51:18 +00001006 bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +01001007
Stefan Roese198b23e2006-10-28 15:55:52 +02001008 idx = simple_strtoul(boot_device, NULL, 16);
1009
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +02001010 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
Stefan Roese198b23e2006-10-28 15:55:52 +02001011 printf("\n** Device %d not available\n", idx);
Simon Glass0169e6b2012-02-13 13:51:18 +00001012 bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
Stefan Roese198b23e2006-10-28 15:55:52 +02001013 return 1;
1014 }
Simon Glass0169e6b2012-02-13 13:51:18 +00001015 bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
Stefan Roese198b23e2006-10-28 15:55:52 +02001016
1017 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
1018}
1019
1020U_BOOT_CMD(nboot, 4, 1, do_nandboot,
Peter Tyserdfb72b82009-01-27 18:03:12 -06001021 "boot from NAND device",
Wolfgang Denkc54781c2009-05-24 17:06:54 +02001022 "[partition] | [[[loadAddr] dev] offset]"
1023);