cmd_nand.c 22 KB

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