nand.c 27 KB

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