nand.c 23 KB

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