cmd_nand.c 18 KB

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