nand.c 24 KB

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