cmd_nand.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677
  1. /*
  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>
  6. *
  7. * Added 16-bit nand support
  8. * (C) 2004 Texas Instruments
  9. */
  10. #include <common.h>
  11. #include <linux/mtd/mtd.h>
  12. #include <command.h>
  13. #include <watchdog.h>
  14. #include <malloc.h>
  15. #include <asm/byteorder.h>
  16. #include <jffs2/jffs2.h>
  17. #include <nand.h>
  18. #if defined(CONFIG_CMD_MTDPARTS)
  19. /* parition handling routines */
  20. int mtdparts_init(void);
  21. int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
  22. int find_dev_and_part(const char *id, struct mtd_device **dev,
  23. u8 *part_num, struct part_info **part);
  24. #endif
  25. static int nand_dump(nand_info_t *nand, ulong off, int only_oob)
  26. {
  27. int i;
  28. u_char *datbuf, *oobbuf, *p;
  29. datbuf = malloc(nand->writesize + nand->oobsize);
  30. oobbuf = malloc(nand->oobsize);
  31. if (!datbuf || !oobbuf) {
  32. puts("No memory for page buffer\n");
  33. return 1;
  34. }
  35. off &= ~(nand->writesize - 1);
  36. loff_t addr = (loff_t) off;
  37. struct mtd_oob_ops ops;
  38. memset(&ops, 0, sizeof(ops));
  39. ops.datbuf = datbuf;
  40. ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
  41. ops.len = nand->writesize;
  42. ops.ooblen = nand->oobsize;
  43. ops.mode = MTD_OOB_RAW;
  44. i = nand->read_oob(nand, addr, &ops);
  45. if (i < 0) {
  46. printf("Error (%d) reading page %08lx\n", i, off);
  47. free(datbuf);
  48. free(oobbuf);
  49. return 1;
  50. }
  51. printf("Page %08lx dump:\n", off);
  52. i = nand->writesize >> 4;
  53. p = datbuf;
  54. while (i--) {
  55. if (!only_oob)
  56. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
  57. " %02x %02x %02x %02x %02x %02x %02x %02x\n",
  58. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
  59. p[8], p[9], p[10], p[11], p[12], p[13], p[14],
  60. p[15]);
  61. p += 16;
  62. }
  63. puts("OOB:\n");
  64. i = nand->oobsize >> 3;
  65. while (i--) {
  66. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
  67. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
  68. p += 8;
  69. }
  70. free(datbuf);
  71. free(oobbuf);
  72. return 0;
  73. }
  74. /* ------------------------------------------------------------------------- */
  75. static inline int str2long(char *p, ulong *num)
  76. {
  77. char *endptr;
  78. *num = simple_strtoul(p, &endptr, 16);
  79. return (*p != '\0' && *endptr == '\0') ? 1 : 0;
  80. }
  81. static int
  82. arg_off_size(int argc, char *argv[], nand_info_t *nand, ulong *off, size_t *size)
  83. {
  84. int idx = nand_curr_device;
  85. #if defined(CONFIG_CMD_MTDPARTS)
  86. struct mtd_device *dev;
  87. struct part_info *part;
  88. u8 pnum;
  89. if (argc >= 1 && !(str2long(argv[0], off))) {
  90. if ((mtdparts_init() == 0) &&
  91. (find_dev_and_part(argv[0], &dev, &pnum, &part) == 0)) {
  92. if (dev->id->type != MTD_DEV_TYPE_NAND) {
  93. puts("not a NAND device\n");
  94. return -1;
  95. }
  96. *off = part->offset;
  97. if (argc >= 2) {
  98. if (!(str2long(argv[1], (ulong *)size))) {
  99. printf("'%s' is not a number\n", argv[1]);
  100. return -1;
  101. }
  102. if (*size > part->size)
  103. *size = part->size;
  104. } else {
  105. *size = part->size;
  106. }
  107. idx = dev->id->num;
  108. *nand = nand_info[idx];
  109. goto out;
  110. }
  111. }
  112. #endif
  113. if (argc >= 1) {
  114. if (!(str2long(argv[0], off))) {
  115. printf("'%s' is not a number\n", argv[0]);
  116. return -1;
  117. }
  118. } else {
  119. *off = 0;
  120. }
  121. if (argc >= 2) {
  122. if (!(str2long(argv[1], (ulong *)size))) {
  123. printf("'%s' is not a number\n", argv[1]);
  124. return -1;
  125. }
  126. } else {
  127. *size = nand->size - *off;
  128. }
  129. #if defined(CONFIG_CMD_MTDPARTS)
  130. out:
  131. #endif
  132. printf("device %d ", idx);
  133. if (*size == nand->size)
  134. puts("whole chip\n");
  135. else
  136. printf("offset 0x%lx, size 0x%zx\n", *off, *size);
  137. return 0;
  138. }
  139. #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
  140. static void print_status(ulong start, ulong end, ulong erasesize, int status)
  141. {
  142. printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
  143. start,
  144. end - 1,
  145. (end - start) / erasesize,
  146. ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
  147. ((status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
  148. ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
  149. }
  150. static void do_nand_status(nand_info_t *nand)
  151. {
  152. ulong block_start = 0;
  153. ulong off;
  154. int last_status = -1;
  155. struct nand_chip *nand_chip = nand->priv;
  156. /* check the WP bit */
  157. nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
  158. printf("device is %swrite protected\n",
  159. (nand_chip->read_byte(nand) & 0x80 ?
  160. "NOT " : ""));
  161. for (off = 0; off < nand->size; off += nand->erasesize) {
  162. int s = nand_get_lock_status(nand, off);
  163. /* print message only if status has changed */
  164. if (s != last_status && off != 0) {
  165. print_status(block_start, off, nand->erasesize,
  166. last_status);
  167. block_start = off;
  168. }
  169. last_status = s;
  170. }
  171. /* Print the last block info */
  172. print_status(block_start, off, nand->erasesize, last_status);
  173. }
  174. #endif
  175. static void nand_print_info(int idx)
  176. {
  177. nand_info_t *nand = &nand_info[idx];
  178. struct nand_chip *chip = nand->priv;
  179. printf("Device %d: ", idx);
  180. if (chip->numchips > 1)
  181. printf("%dx ", chip->numchips);
  182. printf("%s, sector size %u KiB\n",
  183. nand->name, nand->erasesize >> 10);
  184. }
  185. int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
  186. {
  187. int i, dev, ret = 0;
  188. ulong addr, off;
  189. size_t size;
  190. char *cmd, *s;
  191. nand_info_t *nand;
  192. #ifdef CONFIG_SYS_NAND_QUIET
  193. int quiet = CONFIG_SYS_NAND_QUIET;
  194. #else
  195. int quiet = 0;
  196. #endif
  197. const char *quiet_str = getenv("quiet");
  198. /* at least two arguments please */
  199. if (argc < 2)
  200. goto usage;
  201. if (quiet_str)
  202. quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
  203. cmd = argv[1];
  204. if (strcmp(cmd, "info") == 0) {
  205. putc('\n');
  206. for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
  207. if (nand_info[i].name)
  208. nand_print_info(i);
  209. }
  210. return 0;
  211. }
  212. if (strcmp(cmd, "device") == 0) {
  213. if (argc < 3) {
  214. putc('\n');
  215. if ((nand_curr_device < 0) ||
  216. (nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE))
  217. puts("no devices available\n");
  218. else
  219. nand_print_info(nand_curr_device);
  220. return 0;
  221. }
  222. dev = (int)simple_strtoul(argv[2], NULL, 10);
  223. if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[dev].name) {
  224. puts("No such device\n");
  225. return 1;
  226. }
  227. printf("Device %d: %s", dev, nand_info[dev].name);
  228. puts("... is now current device\n");
  229. nand_curr_device = dev;
  230. #ifdef CONFIG_SYS_NAND_SELECT_DEVICE
  231. /*
  232. * Select the chip in the board/cpu specific driver
  233. */
  234. board_nand_select_device(nand_info[dev].priv, dev);
  235. #endif
  236. return 0;
  237. }
  238. if (strcmp(cmd, "bad") != 0 && strcmp(cmd, "erase") != 0 &&
  239. strncmp(cmd, "dump", 4) != 0 &&
  240. strncmp(cmd, "read", 4) != 0 && strncmp(cmd, "write", 5) != 0 &&
  241. strcmp(cmd, "scrub") != 0 && strcmp(cmd, "markbad") != 0 &&
  242. strcmp(cmd, "biterr") != 0 &&
  243. strcmp(cmd, "lock") != 0 && strcmp(cmd, "unlock") != 0 )
  244. goto usage;
  245. /* the following commands operate on the current device */
  246. if (nand_curr_device < 0 || nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
  247. !nand_info[nand_curr_device].name) {
  248. puts("\nno devices available\n");
  249. return 1;
  250. }
  251. nand = &nand_info[nand_curr_device];
  252. if (strcmp(cmd, "bad") == 0) {
  253. printf("\nDevice %d bad blocks:\n", nand_curr_device);
  254. for (off = 0; off < nand->size; off += nand->erasesize)
  255. if (nand_block_isbad(nand, off))
  256. printf(" %08lx\n", off);
  257. return 0;
  258. }
  259. /*
  260. * Syntax is:
  261. * 0 1 2 3 4
  262. * nand erase [clean] [off size]
  263. */
  264. if (strcmp(cmd, "erase") == 0 || strcmp(cmd, "scrub") == 0) {
  265. nand_erase_options_t opts;
  266. /* "clean" at index 2 means request to write cleanmarker */
  267. int clean = argc > 2 && !strcmp("clean", argv[2]);
  268. int o = clean ? 3 : 2;
  269. int scrub = !strcmp(cmd, "scrub");
  270. printf("\nNAND %s: ", scrub ? "scrub" : "erase");
  271. /* skip first two or three arguments, look for offset and size */
  272. if (arg_off_size(argc - o, argv + o, nand, &off, &size) != 0)
  273. return 1;
  274. memset(&opts, 0, sizeof(opts));
  275. opts.offset = off;
  276. opts.length = size;
  277. opts.jffs2 = clean;
  278. opts.quiet = quiet;
  279. if (scrub) {
  280. puts("Warning: "
  281. "scrub option will erase all factory set "
  282. "bad blocks!\n"
  283. " "
  284. "There is no reliable way to recover them.\n"
  285. " "
  286. "Use this command only for testing purposes "
  287. "if you\n"
  288. " "
  289. "are sure of what you are doing!\n"
  290. "\nReally scrub this NAND flash? <y/N>\n");
  291. if (getc() == 'y' && getc() == '\r') {
  292. opts.scrub = 1;
  293. } else {
  294. puts("scrub aborted\n");
  295. return -1;
  296. }
  297. }
  298. ret = nand_erase_opts(nand, &opts);
  299. printf("%s\n", ret ? "ERROR" : "OK");
  300. return ret == 0 ? 0 : 1;
  301. }
  302. if (strncmp(cmd, "dump", 4) == 0) {
  303. if (argc < 3)
  304. goto usage;
  305. s = strchr(cmd, '.');
  306. off = (int)simple_strtoul(argv[2], NULL, 16);
  307. if (s != NULL && strcmp(s, ".oob") == 0)
  308. ret = nand_dump(nand, off, 1);
  309. else
  310. ret = nand_dump(nand, off, 0);
  311. return ret == 0 ? 1 : 0;
  312. }
  313. if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
  314. int read;
  315. if (argc < 4)
  316. goto usage;
  317. addr = (ulong)simple_strtoul(argv[2], NULL, 16);
  318. read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
  319. printf("\nNAND %s: ", read ? "read" : "write");
  320. if (arg_off_size(argc - 3, argv + 3, nand, &off, &size) != 0)
  321. return 1;
  322. s = strchr(cmd, '.');
  323. if (!s || !strcmp(s, ".jffs2") ||
  324. !strcmp(s, ".e") || !strcmp(s, ".i")) {
  325. if (read)
  326. ret = nand_read_skip_bad(nand, off, &size,
  327. (u_char *)addr);
  328. else
  329. ret = nand_write_skip_bad(nand, off, &size,
  330. (u_char *)addr);
  331. } else if (!strcmp(s, ".oob")) {
  332. /* out-of-band data */
  333. mtd_oob_ops_t ops = {
  334. .oobbuf = (u8 *)addr,
  335. .ooblen = size,
  336. .mode = MTD_OOB_RAW
  337. };
  338. if (read)
  339. ret = nand->read_oob(nand, off, &ops);
  340. else
  341. ret = nand->write_oob(nand, off, &ops);
  342. } else {
  343. printf("Unknown nand command suffix '%s'.\n", s);
  344. return 1;
  345. }
  346. printf(" %zu bytes %s: %s\n", size,
  347. read ? "read" : "written", ret ? "ERROR" : "OK");
  348. return ret == 0 ? 0 : 1;
  349. }
  350. if (strcmp(cmd, "markbad") == 0) {
  351. argc -= 2;
  352. argv += 2;
  353. if (argc <= 0)
  354. goto usage;
  355. while (argc > 0) {
  356. addr = simple_strtoul(*argv, NULL, 16);
  357. if (nand->block_markbad(nand, addr)) {
  358. printf("block 0x%08lx NOT marked "
  359. "as bad! ERROR %d\n",
  360. addr, ret);
  361. ret = 1;
  362. } else {
  363. printf("block 0x%08lx successfully "
  364. "marked as bad\n",
  365. addr);
  366. }
  367. --argc;
  368. ++argv;
  369. }
  370. return ret;
  371. }
  372. if (strcmp(cmd, "biterr") == 0) {
  373. /* todo */
  374. return 1;
  375. }
  376. #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
  377. if (strcmp(cmd, "lock") == 0) {
  378. int tight = 0;
  379. int status = 0;
  380. if (argc == 3) {
  381. if (!strcmp("tight", argv[2]))
  382. tight = 1;
  383. if (!strcmp("status", argv[2]))
  384. status = 1;
  385. }
  386. if (status) {
  387. do_nand_status(nand);
  388. } else {
  389. if (!nand_lock(nand, tight)) {
  390. puts("NAND flash successfully locked\n");
  391. } else {
  392. puts("Error locking NAND flash\n");
  393. return 1;
  394. }
  395. }
  396. return 0;
  397. }
  398. if (strcmp(cmd, "unlock") == 0) {
  399. if (arg_off_size(argc - 2, argv + 2, nand, &off, &size) < 0)
  400. return 1;
  401. if (!nand_unlock(nand, off, size)) {
  402. puts("NAND flash successfully unlocked\n");
  403. } else {
  404. puts("Error unlocking NAND flash, "
  405. "write and erase will probably fail\n");
  406. return 1;
  407. }
  408. return 0;
  409. }
  410. #endif
  411. usage:
  412. cmd_usage(cmdtp);
  413. return 1;
  414. }
  415. U_BOOT_CMD(nand, CONFIG_SYS_MAXARGS, 1, do_nand,
  416. "NAND sub-system",
  417. "info - show available NAND devices\n"
  418. "nand device [dev] - show or set current device\n"
  419. "nand read - addr off|partition size\n"
  420. "nand write - addr off|partition size\n"
  421. " read/write 'size' bytes starting at offset 'off'\n"
  422. " to/from memory address 'addr', skipping bad blocks.\n"
  423. "nand erase [clean] [off size] - erase 'size' bytes from\n"
  424. " offset 'off' (entire device if not specified)\n"
  425. "nand bad - show bad blocks\n"
  426. "nand dump[.oob] off - dump page\n"
  427. "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
  428. "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
  429. "nand biterr off - make a bit error at offset (UNSAFE)"
  430. #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
  431. "\n"
  432. "nand lock [tight] [status]\n"
  433. " bring nand to lock state or display locked pages\n"
  434. "nand unlock [offset] [size] - unlock section"
  435. #endif
  436. );
  437. static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
  438. ulong offset, ulong addr, char *cmd)
  439. {
  440. int r;
  441. char *ep, *s;
  442. size_t cnt;
  443. image_header_t *hdr;
  444. #if defined(CONFIG_FIT)
  445. const void *fit_hdr = NULL;
  446. #endif
  447. s = strchr(cmd, '.');
  448. if (s != NULL &&
  449. (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
  450. printf("Unknown nand load suffix '%s'\n", s);
  451. show_boot_progress(-53);
  452. return 1;
  453. }
  454. printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
  455. cnt = nand->writesize;
  456. r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
  457. if (r) {
  458. puts("** Read error\n");
  459. show_boot_progress (-56);
  460. return 1;
  461. }
  462. show_boot_progress (56);
  463. switch (genimg_get_format ((void *)addr)) {
  464. case IMAGE_FORMAT_LEGACY:
  465. hdr = (image_header_t *)addr;
  466. show_boot_progress (57);
  467. image_print_contents (hdr);
  468. cnt = image_get_image_size (hdr);
  469. break;
  470. #if defined(CONFIG_FIT)
  471. case IMAGE_FORMAT_FIT:
  472. fit_hdr = (const void *)addr;
  473. puts ("Fit image detected...\n");
  474. cnt = fit_get_size (fit_hdr);
  475. break;
  476. #endif
  477. default:
  478. show_boot_progress (-57);
  479. puts ("** Unknown image type\n");
  480. return 1;
  481. }
  482. show_boot_progress (57);
  483. r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
  484. if (r) {
  485. puts("** Read error\n");
  486. show_boot_progress (-58);
  487. return 1;
  488. }
  489. show_boot_progress (58);
  490. #if defined(CONFIG_FIT)
  491. /* This cannot be done earlier, we need complete FIT image in RAM first */
  492. if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
  493. if (!fit_check_format (fit_hdr)) {
  494. show_boot_progress (-150);
  495. puts ("** Bad FIT image format\n");
  496. return 1;
  497. }
  498. show_boot_progress (151);
  499. fit_print_contents (fit_hdr);
  500. }
  501. #endif
  502. /* Loading ok, update default load address */
  503. load_addr = addr;
  504. /* Check if we should attempt an auto-start */
  505. if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
  506. char *local_args[2];
  507. extern int do_bootm(cmd_tbl_t *, int, int, char *[]);
  508. local_args[0] = cmd;
  509. local_args[1] = NULL;
  510. printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
  511. do_bootm(cmdtp, 0, 1, local_args);
  512. return 1;
  513. }
  514. return 0;
  515. }
  516. int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
  517. {
  518. char *boot_device = NULL;
  519. int idx;
  520. ulong addr, offset = 0;
  521. #if defined(CONFIG_CMD_MTDPARTS)
  522. struct mtd_device *dev;
  523. struct part_info *part;
  524. u8 pnum;
  525. if (argc >= 2) {
  526. char *p = (argc == 2) ? argv[1] : argv[2];
  527. if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
  528. (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
  529. if (dev->id->type != MTD_DEV_TYPE_NAND) {
  530. puts("Not a NAND device\n");
  531. return 1;
  532. }
  533. if (argc > 3)
  534. goto usage;
  535. if (argc == 3)
  536. addr = simple_strtoul(argv[1], NULL, 16);
  537. else
  538. addr = CONFIG_SYS_LOAD_ADDR;
  539. return nand_load_image(cmdtp, &nand_info[dev->id->num],
  540. part->offset, addr, argv[0]);
  541. }
  542. }
  543. #endif
  544. show_boot_progress(52);
  545. switch (argc) {
  546. case 1:
  547. addr = CONFIG_SYS_LOAD_ADDR;
  548. boot_device = getenv("bootdevice");
  549. break;
  550. case 2:
  551. addr = simple_strtoul(argv[1], NULL, 16);
  552. boot_device = getenv("bootdevice");
  553. break;
  554. case 3:
  555. addr = simple_strtoul(argv[1], NULL, 16);
  556. boot_device = argv[2];
  557. break;
  558. case 4:
  559. addr = simple_strtoul(argv[1], NULL, 16);
  560. boot_device = argv[2];
  561. offset = simple_strtoul(argv[3], NULL, 16);
  562. break;
  563. default:
  564. #if defined(CONFIG_CMD_MTDPARTS)
  565. usage:
  566. #endif
  567. cmd_usage(cmdtp);
  568. show_boot_progress(-53);
  569. return 1;
  570. }
  571. show_boot_progress(53);
  572. if (!boot_device) {
  573. puts("\n** No boot device **\n");
  574. show_boot_progress(-54);
  575. return 1;
  576. }
  577. show_boot_progress(54);
  578. idx = simple_strtoul(boot_device, NULL, 16);
  579. if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
  580. printf("\n** Device %d not available\n", idx);
  581. show_boot_progress(-55);
  582. return 1;
  583. }
  584. show_boot_progress(55);
  585. return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
  586. }
  587. U_BOOT_CMD(nboot, 4, 1, do_nandboot,
  588. "boot from NAND device",
  589. "[partition] | [[[loadAddr] dev] offset]"
  590. );