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>
7 * 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.
11 * Added 16-bit nand support
12 * (C) 2004 Texas Instruments
14 * Copyright 2010, 2012 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.
23 #include <linux/mtd/mtd.h>
28 #include <asm/byteorder.h>
29 #include <jffs2/jffs2.h>
32 #if defined(CONFIG_CMD_MTDPARTS)
34 /* partition handling routines */
35 int mtdparts_init(void);
36 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
37 int find_dev_and_part(const char *id, struct mtd_device **dev,
38 u8 *part_num, struct part_info **part);
41 static int nand_dump(struct mtd_info *mtd, ulong off, int only_oob,
45 u_char *datbuf, *oobbuf, *p;
50 off = last + mtd->writesize;
54 datbuf = memalign(ARCH_DMA_MINALIGN, mtd->writesize);
56 puts("No memory for page buffer\n");
60 oobbuf = memalign(ARCH_DMA_MINALIGN, mtd->oobsize);
62 puts("No memory for page buffer\n");
66 off &= ~(mtd->writesize - 1);
67 loff_t addr = (loff_t) off;
68 struct mtd_oob_ops ops;
69 memset(&ops, 0, sizeof(ops));
72 ops.len = mtd->writesize;
73 ops.ooblen = mtd->oobsize;
74 ops.mode = MTD_OPS_RAW;
75 i = mtd_read_oob(mtd, addr, &ops);
77 printf("Error (%d) reading page %08lx\n", i, off);
81 printf("Page %08lx dump:\n", off);
84 i = mtd->writesize >> 4;
88 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
89 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
90 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
91 p[8], p[9], p[10], p[11], p[12], p[13], p[14],
98 i = mtd->oobsize >> 3;
101 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
102 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
114 /* ------------------------------------------------------------------------- */
116 static int set_dev(int dev)
118 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
119 !nand_info[dev]->name) {
120 puts("No such device\n");
124 if (nand_curr_device == dev)
127 printf("Device %d: %s", dev, nand_info[dev]->name);
128 puts("... is now current device\n");
129 nand_curr_device = dev;
131 #ifdef CONFIG_SYS_NAND_SELECT_DEVICE
132 board_nand_select_device(nand_info[dev]->priv, dev);
138 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
139 static void print_status(ulong start, ulong end, ulong erasesize, int status)
142 * Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is
143 * not the same as others. Instead of bit 1 being lock, it is
144 * #lock_tight. To make the driver support either format, ignore bit 1
145 * and use only bit 0 and bit 2.
147 printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
150 (end - start) / erasesize,
151 ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
152 (!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""),
153 ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
156 static void do_nand_status(struct mtd_info *mtd)
158 ulong block_start = 0;
160 int last_status = -1;
162 struct nand_chip *nand_chip = mtd_to_nand(mtd);
163 /* check the WP bit */
164 nand_chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
165 printf("device is %swrite protected\n",
166 (nand_chip->read_byte(mtd) & 0x80 ?
169 for (off = 0; off < mtd->size; off += mtd->erasesize) {
170 int s = nand_get_lock_status(mtd, off);
172 /* print message only if status has changed */
173 if (s != last_status && off != 0) {
174 print_status(block_start, off, mtd->erasesize,
180 /* Print the last block info */
181 print_status(block_start, off, mtd->erasesize, last_status);
185 #ifdef CONFIG_ENV_OFFSET_OOB
186 unsigned long nand_env_oob_offset;
188 int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
191 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
192 struct mtd_info *mtd = nand_info[0];
195 if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !mtd->name) {
196 puts("no devices available\n");
202 if (!strcmp(cmd, "get")) {
203 ret = get_nand_env_oob(mtd, &nand_env_oob_offset);
207 printf("0x%08lx\n", nand_env_oob_offset);
208 } else if (!strcmp(cmd, "set")) {
211 struct mtd_oob_ops ops;
217 /* We don't care about size, or maxsize. */
218 if (mtd_arg_off(argv[2], &idx, &addr, &maxsize, &maxsize,
219 MTD_DEV_TYPE_NAND, nand_info[idx]->size)) {
220 puts("Offset or partition name expected\n");
224 puts("Offset or partition name expected\n");
229 puts("Partition not on first NAND device\n");
233 if (mtd->oobavail < ENV_OFFSET_SIZE) {
234 printf("Insufficient available OOB bytes:\n"
235 "%d OOB bytes available but %d required for "
237 mtd->oobavail, ENV_OFFSET_SIZE);
241 if ((addr & (mtd->erasesize - 1)) != 0) {
242 printf("Environment offset must be block-aligned\n");
247 ops.mode = MTD_OOB_AUTO;
249 ops.ooblen = ENV_OFFSET_SIZE;
250 ops.oobbuf = (void *) oob_buf;
252 oob_buf[0] = ENV_OOB_MARKER;
253 oob_buf[1] = addr / mtd->erasesize;
255 ret = mtd->write_oob(mtd, ENV_OFFSET_SIZE, &ops);
257 printf("Error writing OOB block 0\n");
261 ret = get_nand_env_oob(mtd, &nand_env_oob_offset);
263 printf("Error reading env offset in OOB\n");
267 if (addr != nand_env_oob_offset) {
268 printf("Verification of env offset in OOB failed: "
269 "0x%08llx expected but got 0x%08lx\n",
270 (unsigned long long)addr, nand_env_oob_offset);
280 return CMD_RET_USAGE;
285 static void nand_print_and_set_info(int idx)
287 struct mtd_info *mtd = nand_info[idx];
288 struct nand_chip *chip = mtd_to_nand(mtd);
290 printf("Device %d: ", idx);
291 if (chip->numchips > 1)
292 printf("%dx ", chip->numchips);
293 printf("%s, sector size %u KiB\n",
294 mtd->name, mtd->erasesize >> 10);
295 printf(" Page size %8d b\n", mtd->writesize);
296 printf(" OOB size %8d b\n", mtd->oobsize);
297 printf(" Erase size %8d b\n", mtd->erasesize);
298 printf(" subpagesize %8d b\n", chip->subpagesize);
299 printf(" options 0x%8x\n", chip->options);
300 printf(" bbt options 0x%8x\n", chip->bbt_options);
302 /* Set geometry info */
303 setenv_hex("nand_writesize", mtd->writesize);
304 setenv_hex("nand_oobsize", mtd->oobsize);
305 setenv_hex("nand_erasesize", mtd->erasesize);
308 static int raw_access(struct mtd_info *mtd, ulong addr, loff_t off,
309 ulong count, int read)
315 mtd_oob_ops_t ops = {
316 .datbuf = (u8 *)addr,
317 .oobbuf = ((u8 *)addr) + mtd->writesize,
318 .len = mtd->writesize,
319 .ooblen = mtd->oobsize,
324 ret = mtd_read_oob(mtd, off, &ops);
326 ret = mtd_write_oob(mtd, off, &ops);
328 ret = nand_verify_page_oob(mtd, &ops, off);
332 printf("%s: error at offset %llx, ret %d\n",
333 __func__, (long long)off, ret);
337 addr += mtd->writesize + mtd->oobsize;
338 off += mtd->writesize;
344 /* Adjust a chip/partition size down for bad blocks so we don't
345 * read/write past the end of a chip/partition by accident.
347 static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev)
349 /* We grab the nand info object here fresh because this is usually
350 * called after arg_off_size() which can change the value of dev.
352 struct mtd_info *mtd = nand_info[dev];
353 loff_t maxoffset = offset + *size;
356 /* count badblocks in NAND from offset to offset + size */
357 for (; offset < maxoffset; offset += mtd->erasesize) {
358 if (nand_block_isbad(mtd, offset))
361 /* adjust size if any bad blocks found */
363 *size -= badblocks * mtd->erasesize;
364 printf("size adjusted to 0x%llx (%d bad blocks)\n",
365 (unsigned long long)*size, badblocks);
369 static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
373 loff_t off, size, maxsize;
375 struct mtd_info *mtd;
376 #ifdef CONFIG_SYS_NAND_QUIET
377 int quiet = CONFIG_SYS_NAND_QUIET;
381 const char *quiet_str = getenv("quiet");
382 int dev = nand_curr_device;
383 int repeat = flag & CMD_FLAG_REPEAT;
385 /* at least two arguments please */
390 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
394 /* Only "dump" is repeatable. */
395 if (repeat && strcmp(cmd, "dump"))
398 if (strcmp(cmd, "info") == 0) {
401 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
402 if (nand_info[i]->name)
403 nand_print_and_set_info(i);
408 if (strcmp(cmd, "device") == 0) {
411 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
412 puts("no devices available\n");
414 nand_print_and_set_info(dev);
418 dev = (int)simple_strtoul(argv[2], NULL, 10);
424 #ifdef CONFIG_ENV_OFFSET_OOB
425 /* this command operates only on the first nand device */
426 if (strcmp(cmd, "env.oob") == 0)
427 return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
430 /* The following commands operate on the current device, unless
431 * overridden by a partition specifier. Note that if somehow the
432 * current device is invalid, it will have to be changed to a valid
433 * one before these commands can run, even if a partition specifier
434 * for another device is to be used.
436 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
437 !nand_info[dev]->name) {
438 puts("\nno devices available\n");
441 mtd = nand_info[dev];
443 if (strcmp(cmd, "bad") == 0) {
444 printf("\nDevice %d bad blocks:\n", dev);
445 for (off = 0; off < mtd->size; off += mtd->erasesize)
446 if (nand_block_isbad(mtd, off))
447 printf(" %08llx\n", (unsigned long long)off);
454 * nand erase [clean] [off size]
456 if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
457 nand_erase_options_t opts;
458 /* "clean" at index 2 means request to write cleanmarker */
459 int clean = argc > 2 && !strcmp("clean", argv[2]);
460 int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
461 int o = (clean || scrub_yes) ? 3 : 2;
462 int scrub = !strncmp(cmd, "scrub", 5);
465 const char *scrub_warn =
467 "scrub option will erase all factory set bad blocks!\n"
469 "There is no reliable way to recover them.\n"
471 "Use this command only for testing purposes if you\n"
473 "are sure of what you are doing!\n"
474 "\nReally scrub this NAND flash? <y/N>\n";
477 if (!strcmp(&cmd[5], ".spread")) {
479 } else if (!strcmp(&cmd[5], ".part")) {
481 } else if (!strcmp(&cmd[5], ".chip")) {
489 * Don't allow missing arguments to cause full chip/partition
490 * erases -- easy to do accidentally, e.g. with a misspelled
493 if (argc != o + args)
496 printf("\nNAND %s: ", cmd);
497 /* skip first two or three arguments, look for offset and size */
498 if (mtd_arg_off_size(argc - o, argv + o, &dev, &off, &size,
499 &maxsize, MTD_DEV_TYPE_NAND,
500 nand_info[dev]->size) != 0)
506 mtd = nand_info[dev];
508 memset(&opts, 0, sizeof(opts));
513 opts.spread = spread;
520 if (confirm_yesno()) {
523 puts("scrub aborted\n");
528 ret = nand_erase_opts(mtd, &opts);
529 printf("%s\n", ret ? "ERROR" : "OK");
531 return ret == 0 ? 0 : 1;
534 if (strncmp(cmd, "dump", 4) == 0) {
538 off = (int)simple_strtoul(argv[2], NULL, 16);
539 ret = nand_dump(mtd, off, !strcmp(&cmd[4], ".oob"), repeat);
541 return ret == 0 ? 1 : 0;
544 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
553 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
555 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
556 printf("\nNAND %s: ", read ? "read" : "write");
558 s = strchr(cmd, '.');
560 if (s && !strcmp(s, ".raw")) {
563 if (mtd_arg_off(argv[3], &dev, &off, &size, &maxsize,
565 nand_info[dev]->size))
571 mtd = nand_info[dev];
573 if (argc > 4 && !str2long(argv[4], &pagecount)) {
574 printf("'%s' is not a number\n", argv[4]);
578 if (pagecount * mtd->writesize > size) {
579 puts("Size exceeds partition or device limit\n");
583 rwsize = pagecount * (mtd->writesize + mtd->oobsize);
585 if (mtd_arg_off_size(argc - 3, argv + 3, &dev, &off,
588 nand_info[dev]->size) != 0)
594 /* size is unspecified */
596 adjust_size_for_badblocks(&size, off, dev);
600 mtd = nand_info[dev];
602 if (!s || !strcmp(s, ".jffs2") ||
603 !strcmp(s, ".e") || !strcmp(s, ".i")) {
605 ret = nand_read_skip_bad(mtd, off, &rwsize,
609 ret = nand_write_skip_bad(mtd, off, &rwsize,
613 #ifdef CONFIG_CMD_NAND_TRIMFFS
614 } else if (!strcmp(s, ".trimffs")) {
616 printf("Unknown nand command suffix '%s'\n", s);
619 ret = nand_write_skip_bad(mtd, off, &rwsize, NULL,
620 maxsize, (u_char *)addr,
621 WITH_DROP_FFS | WITH_WR_VERIFY);
623 } else if (!strcmp(s, ".oob")) {
624 /* out-of-band data */
625 mtd_oob_ops_t ops = {
626 .oobbuf = (u8 *)addr,
632 ret = mtd_read_oob(mtd, off, &ops);
634 ret = mtd_write_oob(mtd, off, &ops);
636 ret = raw_access(mtd, addr, off, pagecount, read);
638 printf("Unknown nand command suffix '%s'.\n", s);
642 printf(" %zu bytes %s: %s\n", rwsize,
643 read ? "read" : "written", ret ? "ERROR" : "OK");
645 return ret == 0 ? 0 : 1;
648 #ifdef CONFIG_CMD_NAND_TORTURE
649 if (strcmp(cmd, "torture") == 0) {
651 unsigned int failed = 0, passed = 0;
656 if (!str2off(argv[2], &off)) {
657 puts("Offset is not a valid number\n");
661 size = mtd->erasesize;
663 if (!str2off(argv[3], &size)) {
664 puts("Size is not a valid number\n");
670 if (endoff > mtd->size) {
671 puts("Arguments beyond end of NAND\n");
675 off = round_down(off, mtd->erasesize);
676 endoff = round_up(endoff, mtd->erasesize);
678 printf("\nNAND torture: device %d offset 0x%llx size 0x%llx (block size 0x%x)\n",
679 dev, off, size, mtd->erasesize);
680 while (off < endoff) {
681 ret = nand_torture(mtd, off);
684 printf(" block at 0x%llx failed\n", off);
688 off += mtd->erasesize;
690 printf(" Passed: %u, failed: %u\n", passed, failed);
695 if (strcmp(cmd, "markbad") == 0) {
703 addr = simple_strtoul(*argv, NULL, 16);
705 if (mtd_block_markbad(mtd, addr)) {
706 printf("block 0x%08lx NOT marked "
707 "as bad! ERROR %d\n",
711 printf("block 0x%08lx successfully "
721 if (strcmp(cmd, "biterr") == 0) {
726 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
727 if (strcmp(cmd, "lock") == 0) {
731 if (!strcmp("tight", argv[2]))
733 if (!strcmp("status", argv[2]))
739 if (!nand_lock(mtd, tight)) {
740 puts("NAND flash successfully locked\n");
742 puts("Error locking NAND flash\n");
749 if (strncmp(cmd, "unlock", 5) == 0) {
752 s = strchr(cmd, '.');
754 if (s && !strcmp(s, ".allexcept"))
757 if (mtd_arg_off_size(argc - 2, argv + 2, &dev, &off, &size,
758 &maxsize, MTD_DEV_TYPE_NAND,
759 nand_info[dev]->size) < 0)
765 if (!nand_unlock(nand_info[dev], off, size, allexcept)) {
766 puts("NAND flash successfully unlocked\n");
768 puts("Error unlocking NAND flash, "
769 "write and erase will probably fail\n");
777 return CMD_RET_USAGE;
780 #ifdef CONFIG_SYS_LONGHELP
781 static char nand_help_text[] =
782 "info - show available NAND devices\n"
783 "nand device [dev] - show or set current device\n"
784 "nand read - addr off|partition size\n"
785 "nand write - addr off|partition size\n"
786 " read/write 'size' bytes starting at offset 'off'\n"
787 " to/from memory address 'addr', skipping bad blocks.\n"
788 "nand read.raw - addr off|partition [count]\n"
789 "nand write.raw - addr off|partition [count]\n"
790 " Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
791 #ifdef CONFIG_CMD_NAND_TRIMFFS
792 "nand write.trimffs - addr off|partition size\n"
793 " write 'size' bytes starting at offset 'off' from memory address\n"
794 " 'addr', skipping bad blocks and dropping any pages at the end\n"
795 " of eraseblocks that contain only 0xFF\n"
797 "nand erase[.spread] [clean] off size - erase 'size' bytes "
798 "from offset 'off'\n"
799 " With '.spread', erase enough for given file size, otherwise,\n"
800 " 'size' includes skipped bad blocks.\n"
801 "nand erase.part [clean] partition - erase entire mtd partition'\n"
802 "nand erase.chip [clean] - erase entire chip'\n"
803 "nand bad - show bad blocks\n"
804 "nand dump[.oob] off - dump page\n"
805 #ifdef CONFIG_CMD_NAND_TORTURE
806 "nand torture off - torture one block at offset\n"
807 "nand torture off [size] - torture blocks from off to off+size\n"
809 "nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
810 " really clean NAND erasing bad blocks (UNSAFE)\n"
811 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
812 "nand biterr off - make a bit error at offset (UNSAFE)"
813 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
815 "nand lock [tight] [status]\n"
816 " bring nand to lock state or display locked pages\n"
817 "nand unlock[.allexcept] [offset] [size] - unlock section"
819 #ifdef CONFIG_ENV_OFFSET_OOB
821 "nand env.oob - environment offset in OOB of block 0 of"
823 "nand env.oob set off|partition - set enviromnent offset\n"
824 "nand env.oob get - get environment offset"
830 nand, CONFIG_SYS_MAXARGS, 1, do_nand,
831 "NAND sub-system", nand_help_text
834 static int nand_load_image(cmd_tbl_t *cmdtp, struct mtd_info *mtd,
835 ulong offset, ulong addr, char *cmd)
840 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
843 #if defined(CONFIG_FIT)
844 const void *fit_hdr = NULL;
847 s = strchr(cmd, '.');
849 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
850 printf("Unknown nand load suffix '%s'\n", s);
851 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
855 printf("\nLoading from %s, offset 0x%lx\n", mtd->name, offset);
857 cnt = mtd->writesize;
858 r = nand_read_skip_bad(mtd, offset, &cnt, NULL, mtd->size,
861 puts("** Read error\n");
862 bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
865 bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
867 switch (genimg_get_format ((void *)addr)) {
868 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
869 case IMAGE_FORMAT_LEGACY:
870 hdr = (image_header_t *)addr;
872 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
873 image_print_contents (hdr);
875 cnt = image_get_image_size (hdr);
878 #if defined(CONFIG_FIT)
879 case IMAGE_FORMAT_FIT:
880 fit_hdr = (const void *)addr;
881 puts ("Fit image detected...\n");
883 cnt = fit_get_size (fit_hdr);
887 bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
888 puts ("** Unknown image type\n");
891 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
893 r = nand_read_skip_bad(mtd, offset, &cnt, NULL, mtd->size,
896 puts("** Read error\n");
897 bootstage_error(BOOTSTAGE_ID_NAND_READ);
900 bootstage_mark(BOOTSTAGE_ID_NAND_READ);
902 #if defined(CONFIG_FIT)
903 /* This cannot be done earlier, we need complete FIT image in RAM first */
904 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
905 if (!fit_check_format (fit_hdr)) {
906 bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
907 puts ("** Bad FIT image format\n");
910 bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
911 fit_print_contents (fit_hdr);
915 /* Loading ok, update default load address */
919 return bootm_maybe_autostart(cmdtp, cmd);
922 static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
925 char *boot_device = NULL;
927 ulong addr, offset = 0;
928 #if defined(CONFIG_CMD_MTDPARTS)
929 struct mtd_device *dev;
930 struct part_info *part;
934 char *p = (argc == 2) ? argv[1] : argv[2];
935 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
936 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
937 if (dev->id->type != MTD_DEV_TYPE_NAND) {
938 puts("Not a NAND device\n");
944 addr = simple_strtoul(argv[1], NULL, 16);
946 addr = CONFIG_SYS_LOAD_ADDR;
947 return nand_load_image(cmdtp, nand_info[dev->id->num],
948 part->offset, addr, argv[0]);
953 bootstage_mark(BOOTSTAGE_ID_NAND_PART);
956 addr = CONFIG_SYS_LOAD_ADDR;
957 boot_device = getenv("bootdevice");
960 addr = simple_strtoul(argv[1], NULL, 16);
961 boot_device = getenv("bootdevice");
964 addr = simple_strtoul(argv[1], NULL, 16);
965 boot_device = argv[2];
968 addr = simple_strtoul(argv[1], NULL, 16);
969 boot_device = argv[2];
970 offset = simple_strtoul(argv[3], NULL, 16);
973 #if defined(CONFIG_CMD_MTDPARTS)
976 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
977 return CMD_RET_USAGE;
979 bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
982 puts("\n** No boot device **\n");
983 bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
986 bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
988 idx = simple_strtoul(boot_device, NULL, 16);
990 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx]->name) {
991 printf("\n** Device %d not available\n", idx);
992 bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
995 bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
997 return nand_load_image(cmdtp, nand_info[idx], offset, addr, argv[0]);
1000 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
1001 "boot from NAND device",
1002 "[partition] | [[[loadAddr] dev] offset]"