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>
27 #include <asm/byteorder.h>
28 #include <jffs2/jffs2.h>
31 #if defined(CONFIG_CMD_MTDPARTS)
33 /* partition handling routines */
34 int mtdparts_init(void);
35 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
36 int find_dev_and_part(const char *id, struct mtd_device **dev,
37 u8 *part_num, struct part_info **part);
40 static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
43 u_char *datbuf, *oobbuf, *p;
48 off = last + nand->writesize;
52 datbuf = memalign(ARCH_DMA_MINALIGN, nand->writesize);
54 puts("No memory for page buffer\n");
58 oobbuf = memalign(ARCH_DMA_MINALIGN, nand->oobsize);
60 puts("No memory for page buffer\n");
64 off &= ~(nand->writesize - 1);
65 loff_t addr = (loff_t) off;
66 struct mtd_oob_ops ops;
67 memset(&ops, 0, sizeof(ops));
70 ops.len = nand->writesize;
71 ops.ooblen = nand->oobsize;
72 ops.mode = MTD_OPS_RAW;
73 i = mtd_read_oob(nand, addr, &ops);
75 printf("Error (%d) reading page %08lx\n", i, off);
79 printf("Page %08lx dump:\n", off);
82 i = nand->writesize >> 4;
86 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
87 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
88 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
89 p[8], p[9], p[10], p[11], p[12], p[13], p[14],
96 i = nand->oobsize >> 3;
99 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
100 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
112 /* ------------------------------------------------------------------------- */
114 static int set_dev(int dev)
116 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
117 !nand_info[dev].name) {
118 puts("No such device\n");
122 if (nand_curr_device == dev)
125 printf("Device %d: %s", dev, nand_info[dev].name);
126 puts("... is now current device\n");
127 nand_curr_device = dev;
129 #ifdef CONFIG_SYS_NAND_SELECT_DEVICE
130 board_nand_select_device(nand_info[dev].priv, dev);
136 static inline int str2off(const char *p, loff_t *num)
140 *num = simple_strtoull(p, &endptr, 16);
141 return *p != '\0' && *endptr == '\0';
144 static inline int str2long(const char *p, ulong *num)
148 *num = simple_strtoul(p, &endptr, 16);
149 return *p != '\0' && *endptr == '\0';
152 static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size,
155 #ifdef CONFIG_CMD_MTDPARTS
156 struct mtd_device *dev;
157 struct part_info *part;
161 ret = mtdparts_init();
165 ret = find_dev_and_part(partname, &dev, &pnum, &part);
169 if (dev->id->type != MTD_DEV_TYPE_NAND) {
170 puts("not a NAND device\n");
176 *maxsize = part->size;
185 puts("offset is not a number\n");
190 static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
193 if (!str2off(arg, off))
194 return get_part(arg, idx, off, size, maxsize);
196 if (*off >= nand_info[*idx].size) {
197 puts("Offset exceeds device limit\n");
201 *maxsize = nand_info[*idx].size - *off;
206 static int arg_off_size(int argc, char *const argv[], int *idx,
207 loff_t *off, loff_t *size, loff_t *maxsize)
213 *size = nand_info[*idx].size;
218 ret = arg_off(argv[0], idx, off, size, maxsize);
225 if (!str2off(argv[1], size)) {
226 printf("'%s' is not a number\n", argv[1]);
230 if (*size > *maxsize) {
231 puts("Size exceeds partition or device limit\n");
236 printf("device %d ", *idx);
237 if (*size == nand_info[*idx].size)
238 puts("whole chip\n");
240 printf("offset 0x%llx, size 0x%llx\n",
241 (unsigned long long)*off, (unsigned long long)*size);
245 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
246 static void print_status(ulong start, ulong end, ulong erasesize, int status)
249 * Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is
250 * not the same as others. Instead of bit 1 being lock, it is
251 * #lock_tight. To make the driver support either format, ignore bit 1
252 * and use only bit 0 and bit 2.
254 printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
257 (end - start) / erasesize,
258 ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
259 (!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""),
260 ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
263 static void do_nand_status(nand_info_t *nand)
265 ulong block_start = 0;
267 int last_status = -1;
269 struct nand_chip *nand_chip = nand->priv;
270 /* check the WP bit */
271 nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
272 printf("device is %swrite protected\n",
273 (nand_chip->read_byte(nand) & 0x80 ?
276 for (off = 0; off < nand->size; off += nand->erasesize) {
277 int s = nand_get_lock_status(nand, off);
279 /* print message only if status has changed */
280 if (s != last_status && off != 0) {
281 print_status(block_start, off, nand->erasesize,
287 /* Print the last block info */
288 print_status(block_start, off, nand->erasesize, last_status);
292 #ifdef CONFIG_ENV_OFFSET_OOB
293 unsigned long nand_env_oob_offset;
295 int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
298 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
299 nand_info_t *nand = &nand_info[0];
302 if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) {
303 puts("no devices available\n");
309 if (!strcmp(cmd, "get")) {
310 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
314 printf("0x%08lx\n", nand_env_oob_offset);
315 } else if (!strcmp(cmd, "set")) {
318 struct mtd_oob_ops ops;
324 /* We don't care about size, or maxsize. */
325 if (arg_off(argv[2], &idx, &addr, &maxsize, &maxsize)) {
326 puts("Offset or partition name expected\n");
331 puts("Partition not on first NAND device\n");
335 if (nand->oobavail < ENV_OFFSET_SIZE) {
336 printf("Insufficient available OOB bytes:\n"
337 "%d OOB bytes available but %d required for "
339 nand->oobavail, ENV_OFFSET_SIZE);
343 if ((addr & (nand->erasesize - 1)) != 0) {
344 printf("Environment offset must be block-aligned\n");
349 ops.mode = MTD_OOB_AUTO;
351 ops.ooblen = ENV_OFFSET_SIZE;
352 ops.oobbuf = (void *) oob_buf;
354 oob_buf[0] = ENV_OOB_MARKER;
355 oob_buf[1] = addr / nand->erasesize;
357 ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops);
359 printf("Error writing OOB block 0\n");
363 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
365 printf("Error reading env offset in OOB\n");
369 if (addr != nand_env_oob_offset) {
370 printf("Verification of env offset in OOB failed: "
371 "0x%08llx expected but got 0x%08lx\n",
372 (unsigned long long)addr, nand_env_oob_offset);
382 return CMD_RET_USAGE;
387 static void nand_print_and_set_info(int idx)
389 nand_info_t *nand = &nand_info[idx];
390 struct nand_chip *chip = nand->priv;
392 printf("Device %d: ", idx);
393 if (chip->numchips > 1)
394 printf("%dx ", chip->numchips);
395 printf("%s, sector size %u KiB\n",
396 nand->name, nand->erasesize >> 10);
397 printf(" Page size %8d b\n", nand->writesize);
398 printf(" OOB size %8d b\n", nand->oobsize);
399 printf(" Erase size %8d b\n", nand->erasesize);
400 printf(" subpagesize %8d b\n", chip->subpagesize);
401 printf(" options 0x%8x\n", chip->options);
402 printf(" bbt options 0x%8x\n", chip->bbt_options);
404 /* Set geometry info */
405 setenv_hex("nand_writesize", nand->writesize);
406 setenv_hex("nand_oobsize", nand->oobsize);
407 setenv_hex("nand_erasesize", nand->erasesize);
410 static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
417 mtd_oob_ops_t ops = {
418 .datbuf = (u8 *)addr,
419 .oobbuf = ((u8 *)addr) + nand->writesize,
420 .len = nand->writesize,
421 .ooblen = nand->oobsize,
426 ret = mtd_read_oob(nand, off, &ops);
428 ret = mtd_write_oob(nand, off, &ops);
430 ret = nand_verify_page_oob(nand, &ops, off);
434 printf("%s: error at offset %llx, ret %d\n",
435 __func__, (long long)off, ret);
439 addr += nand->writesize + nand->oobsize;
440 off += nand->writesize;
446 /* Adjust a chip/partition size down for bad blocks so we don't
447 * read/write past the end of a chip/partition by accident.
449 static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev)
451 /* We grab the nand info object here fresh because this is usually
452 * called after arg_off_size() which can change the value of dev.
454 nand_info_t *nand = &nand_info[dev];
455 loff_t maxoffset = offset + *size;
458 /* count badblocks in NAND from offset to offset + size */
459 for (; offset < maxoffset; offset += nand->erasesize) {
460 if (nand_block_isbad(nand, offset))
463 /* adjust size if any bad blocks found */
465 *size -= badblocks * nand->erasesize;
466 printf("size adjusted to 0x%llx (%d bad blocks)\n",
467 (unsigned long long)*size, badblocks);
471 static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
475 loff_t off, size, maxsize;
478 #ifdef CONFIG_SYS_NAND_QUIET
479 int quiet = CONFIG_SYS_NAND_QUIET;
483 const char *quiet_str = getenv("quiet");
484 int dev = nand_curr_device;
485 int repeat = flag & CMD_FLAG_REPEAT;
487 /* at least two arguments please */
492 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
496 /* Only "dump" is repeatable. */
497 if (repeat && strcmp(cmd, "dump"))
498 return CMD_RET_FAILURE;
500 if (strcmp(cmd, "info") == 0) {
503 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
504 if (nand_info[i].name)
505 nand_print_and_set_info(i);
507 return CMD_RET_SUCCESS;
510 if (strcmp(cmd, "device") == 0) {
513 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
514 puts("no devices available\n");
516 nand_print_and_set_info(dev);
517 return CMD_RET_SUCCESS;
520 dev = (int)simple_strtoul(argv[2], NULL, 10);
523 return CMD_RET_SUCCESS;
526 #ifdef CONFIG_ENV_OFFSET_OOB
527 /* this command operates only on the first nand device */
528 if (strcmp(cmd, "env.oob") == 0)
529 return do_nand_env_oob(cmdtp, argc - 1, argv + 1) ?
530 CMD_RET_FAILURE : CMD_RET_SUCCESS;;
533 /* The following commands operate on the current device, unless
534 * overridden by a partition specifier. Note that if somehow the
535 * current device is invalid, it will have to be changed to a valid
536 * one before these commands can run, even if a partition specifier
537 * for another device is to be used.
539 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
540 !nand_info[dev].name) {
541 puts("\nno devices available\n");
542 return CMD_RET_FAILURE;
544 nand = &nand_info[dev];
546 if (strcmp(cmd, "bad") == 0) {
547 printf("\nDevice %d bad blocks:\n", dev);
548 for (off = 0; off < nand->size; off += nand->erasesize)
549 if (nand_block_isbad(nand, off))
550 printf(" %08llx\n", (unsigned long long)off);
551 return CMD_RET_SUCCESS;
557 * nand erase [clean] [off size]
559 if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
560 nand_erase_options_t opts;
561 /* "clean" at index 2 means request to write cleanmarker */
562 int clean = argc > 2 && !strcmp("clean", argv[2]);
563 int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
564 int o = (clean || scrub_yes) ? 3 : 2;
565 int scrub = !strncmp(cmd, "scrub", 5);
568 const char *scrub_warn =
570 "scrub option will erase all factory set bad blocks!\n"
572 "There is no reliable way to recover them.\n"
574 "Use this command only for testing purposes if you\n"
576 "are sure of what you are doing!\n"
577 "\nReally scrub this NAND flash? <y/N>\n";
580 if (!strcmp(&cmd[5], ".spread")) {
582 } else if (!strcmp(&cmd[5], ".part")) {
584 } else if (!strcmp(&cmd[5], ".chip")) {
592 * Don't allow missing arguments to cause full chip/partition
593 * erases -- easy to do accidentally, e.g. with a misspelled
596 if (argc != o + args)
599 printf("\nNAND %s: ", cmd);
600 /* skip first two or three arguments, look for offset and size */
601 if (arg_off_size(argc - o, argv + o, &dev, &off, &size,
603 return CMD_RET_FAILURE;
605 nand = &nand_info[dev];
607 memset(&opts, 0, sizeof(opts));
612 opts.spread = spread;
619 if (confirm_yesno()) {
622 puts("scrub aborted\n");
623 return CMD_RET_FAILURE;
627 ret = nand_erase_opts(nand, &opts);
628 printf("%s\n", ret ? "ERROR" : "OK");
630 return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
633 if (strncmp(cmd, "dump", 4) == 0) {
637 off = (int)simple_strtoul(argv[2], NULL, 16);
638 ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
640 return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
643 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
652 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
654 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
655 printf("\nNAND %s: ", read ? "read" : "write");
657 s = strchr(cmd, '.');
659 if (s && !strcmp(s, ".raw")) {
662 if (arg_off(argv[3], &dev, &off, &size, &maxsize))
665 nand = &nand_info[dev];
667 if (argc > 4 && !str2long(argv[4], &pagecount)) {
668 printf("'%s' is not a number\n", argv[4]);
672 if (pagecount * nand->writesize > size) {
673 puts("Size exceeds partition or device limit\n");
677 rwsize = pagecount * (nand->writesize + nand->oobsize);
679 if (arg_off_size(argc - 3, argv + 3, &dev,
680 &off, &size, &maxsize) != 0)
683 /* size is unspecified */
685 adjust_size_for_badblocks(&size, off, dev);
689 nand = &nand_info[dev];
691 if (!s || !strcmp(s, ".jffs2") ||
692 !strcmp(s, ".e") || !strcmp(s, ".i")) {
694 ret = nand_read_skip_bad(nand, off, &rwsize,
698 ret = nand_write_skip_bad(nand, off, &rwsize,
702 #ifdef CONFIG_CMD_NAND_TRIMFFS
703 } else if (!strcmp(s, ".trimffs")) {
705 printf("Unknown nand command suffix '%s'\n", s);
706 return CMD_RET_FAILURE;
708 ret = nand_write_skip_bad(nand, off, &rwsize, NULL,
709 maxsize, (u_char *)addr,
710 WITH_DROP_FFS | WITH_WR_VERIFY);
712 } else if (!strcmp(s, ".oob")) {
713 /* out-of-band data */
714 mtd_oob_ops_t ops = {
715 .oobbuf = (u8 *)addr,
721 ret = mtd_read_oob(nand, off, &ops);
723 ret = mtd_write_oob(nand, off, &ops);
725 ret = raw_access(nand, addr, off, pagecount, read);
727 printf("Unknown nand command suffix '%s'.\n", s);
728 return CMD_RET_FAILURE;
731 printf(" %zu bytes %s: %s\n", rwsize,
732 read ? "read" : "written", ret ? "ERROR" : "OK");
734 return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
737 #ifdef CONFIG_CMD_NAND_TORTURE
738 if (strcmp(cmd, "torture") == 0) {
742 if (!str2off(argv[2], &off)) {
743 puts("Offset is not a valid number\n");
747 printf("\nNAND torture: device %d offset 0x%llx size 0x%x\n",
748 dev, off, nand->erasesize);
749 ret = nand_torture(nand, off);
750 printf(" %s\n", ret ? "Failed" : "Passed");
752 return ret == 0 ? 0 : 1;
756 if (strcmp(cmd, "markbad") == 0) {
764 addr = simple_strtoul(*argv, NULL, 16);
766 if (mtd_block_markbad(nand, addr)) {
767 printf("block 0x%08lx NOT marked "
768 "as bad! ERROR %d\n",
772 printf("block 0x%08lx successfully "
779 return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
782 if (strcmp(cmd, "biterr") == 0) {
784 return CMD_RET_FAILURE;
787 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
788 if (strcmp(cmd, "lock") == 0) {
792 if (!strcmp("tight", argv[2]))
794 if (!strcmp("status", argv[2]))
798 do_nand_status(nand);
800 if (!nand_lock(nand, tight)) {
801 puts("NAND flash successfully locked\n");
803 puts("Error locking NAND flash\n");
804 return CMD_RET_FAILURE;
807 return CMD_RET_SUCCESS;
810 if (strncmp(cmd, "unlock", 5) == 0) {
813 s = strchr(cmd, '.');
815 if (s && !strcmp(s, ".allexcept"))
818 if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size,
820 return CMD_RET_FAILURE;
822 if (!nand_unlock(&nand_info[dev], off, size, allexcept)) {
823 puts("NAND flash successfully unlocked\n");
825 puts("Error unlocking NAND flash, "
826 "write and erase will probably fail\n");
827 return CMD_RET_FAILURE;
829 return CMD_RET_SUCCESS;
834 return CMD_RET_USAGE;
837 #ifdef CONFIG_SYS_LONGHELP
838 static char nand_help_text[] =
839 "info - show available NAND devices\n"
840 "nand device [dev] - show or set current device\n"
841 "nand read - addr off|partition size\n"
842 "nand write - addr off|partition size\n"
843 " read/write 'size' bytes starting at offset 'off'\n"
844 " to/from memory address 'addr', skipping bad blocks.\n"
845 "nand read.raw - addr off|partition [count]\n"
846 "nand write.raw - addr off|partition [count]\n"
847 " Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
848 #ifdef CONFIG_CMD_NAND_TRIMFFS
849 "nand write.trimffs - addr off|partition size\n"
850 " write 'size' bytes starting at offset 'off' from memory address\n"
851 " 'addr', skipping bad blocks and dropping any pages at the end\n"
852 " of eraseblocks that contain only 0xFF\n"
854 "nand erase[.spread] [clean] off size - erase 'size' bytes "
855 "from offset 'off'\n"
856 " With '.spread', erase enough for given file size, otherwise,\n"
857 " 'size' includes skipped bad blocks.\n"
858 "nand erase.part [clean] partition - erase entire mtd partition'\n"
859 "nand erase.chip [clean] - erase entire chip'\n"
860 "nand bad - show bad blocks\n"
861 "nand dump[.oob] off - dump page\n"
862 #ifdef CONFIG_CMD_NAND_TORTURE
863 "nand torture off - torture block at offset\n"
865 "nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
866 " really clean NAND erasing bad blocks (UNSAFE)\n"
867 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
868 "nand biterr off - make a bit error at offset (UNSAFE)"
869 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
871 "nand lock [tight] [status]\n"
872 " bring nand to lock state or display locked pages\n"
873 "nand unlock[.allexcept] [offset] [size] - unlock section"
875 #ifdef CONFIG_ENV_OFFSET_OOB
877 "nand env.oob - environment offset in OOB of block 0 of"
879 "nand env.oob set off|partition - set enviromnent offset\n"
880 "nand env.oob get - get environment offset"
886 nand, CONFIG_SYS_MAXARGS, 1, do_nand,
887 "NAND sub-system", nand_help_text
890 static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
891 ulong offset, ulong addr, char *cmd)
896 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
899 #if defined(CONFIG_FIT)
900 const void *fit_hdr = NULL;
903 s = strchr(cmd, '.');
905 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
906 printf("Unknown nand load suffix '%s'\n", s);
907 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
911 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
913 cnt = nand->writesize;
914 r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size,
917 puts("** Read error\n");
918 bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
921 bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
923 switch (genimg_get_format ((void *)addr)) {
924 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
925 case IMAGE_FORMAT_LEGACY:
926 hdr = (image_header_t *)addr;
928 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
929 image_print_contents (hdr);
931 cnt = image_get_image_size (hdr);
934 #if defined(CONFIG_FIT)
935 case IMAGE_FORMAT_FIT:
936 fit_hdr = (const void *)addr;
937 puts ("Fit image detected...\n");
939 cnt = fit_get_size (fit_hdr);
943 bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
944 puts ("** Unknown image type\n");
947 bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
949 r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size,
952 puts("** Read error\n");
953 bootstage_error(BOOTSTAGE_ID_NAND_READ);
956 bootstage_mark(BOOTSTAGE_ID_NAND_READ);
958 #if defined(CONFIG_FIT)
959 /* This cannot be done earlier, we need complete FIT image in RAM first */
960 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
961 if (!fit_check_format (fit_hdr)) {
962 bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
963 puts ("** Bad FIT image format\n");
966 bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
967 fit_print_contents (fit_hdr);
971 /* Loading ok, update default load address */
975 return bootm_maybe_autostart(cmdtp, cmd);
978 static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
981 char *boot_device = NULL;
983 ulong addr, offset = 0;
984 #if defined(CONFIG_CMD_MTDPARTS)
985 struct mtd_device *dev;
986 struct part_info *part;
990 char *p = (argc == 2) ? argv[1] : argv[2];
991 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
992 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
993 if (dev->id->type != MTD_DEV_TYPE_NAND) {
994 puts("Not a NAND device\n");
1000 addr = simple_strtoul(argv[1], NULL, 16);
1002 addr = CONFIG_SYS_LOAD_ADDR;
1003 return nand_load_image(cmdtp, &nand_info[dev->id->num],
1004 part->offset, addr, argv[0]);
1009 bootstage_mark(BOOTSTAGE_ID_NAND_PART);
1012 addr = CONFIG_SYS_LOAD_ADDR;
1013 boot_device = getenv("bootdevice");
1016 addr = simple_strtoul(argv[1], NULL, 16);
1017 boot_device = getenv("bootdevice");
1020 addr = simple_strtoul(argv[1], NULL, 16);
1021 boot_device = argv[2];
1024 addr = simple_strtoul(argv[1], NULL, 16);
1025 boot_device = argv[2];
1026 offset = simple_strtoul(argv[3], NULL, 16);
1029 #if defined(CONFIG_CMD_MTDPARTS)
1032 bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
1033 return CMD_RET_USAGE;
1035 bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
1038 puts("\n** No boot device **\n");
1039 bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
1042 bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
1044 idx = simple_strtoul(boot_device, NULL, 16);
1046 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
1047 printf("\n** Device %d not available\n", idx);
1048 bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
1051 bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
1053 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
1056 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
1057 "boot from NAND device",
1058 "[partition] | [[[loadAddr] dev] offset]"