onenand.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610
  1. /*
  2. * U-Boot command for OneNAND support
  3. *
  4. * Copyright (C) 2005-2008 Samsung Electronics
  5. * Kyungmin Park <kyungmin.park@samsung.com>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 as
  9. * published by the Free Software Foundation.
  10. */
  11. #include <common.h>
  12. #include <command.h>
  13. #include <malloc.h>
  14. #include <linux/compat.h>
  15. #include <linux/mtd/mtd.h>
  16. #include <linux/mtd/onenand.h>
  17. #include <asm/io.h>
  18. static struct mtd_info *mtd;
  19. static loff_t next_ofs;
  20. static loff_t skip_ofs;
  21. static int arg_off_size_onenand(int argc, char *const argv[], ulong *off,
  22. size_t *size)
  23. {
  24. if (argc >= 1) {
  25. if (!(str2long(argv[0], off))) {
  26. printf("'%s' is not a number\n", argv[0]);
  27. return -1;
  28. }
  29. } else {
  30. *off = 0;
  31. }
  32. if (argc >= 2) {
  33. if (!(str2long(argv[1], (ulong *)size))) {
  34. printf("'%s' is not a number\n", argv[1]);
  35. return -1;
  36. }
  37. } else {
  38. *size = mtd->size - *off;
  39. }
  40. if ((*off + *size) > mtd->size) {
  41. printf("total chip size (0x%llx) exceeded!\n", mtd->size);
  42. return -1;
  43. }
  44. if (*size == mtd->size)
  45. puts("whole chip\n");
  46. else
  47. printf("offset 0x%lx, size 0x%x\n", *off, *size);
  48. return 0;
  49. }
  50. static int onenand_block_read(loff_t from, size_t len,
  51. size_t *retlen, u_char *buf, int oob)
  52. {
  53. struct onenand_chip *this = mtd->priv;
  54. int blocks = (int) len >> this->erase_shift;
  55. int blocksize = (1 << this->erase_shift);
  56. loff_t ofs = from;
  57. struct mtd_oob_ops ops = {
  58. .retlen = 0,
  59. };
  60. int ret;
  61. if (oob)
  62. ops.ooblen = blocksize;
  63. else
  64. ops.len = blocksize;
  65. while (blocks) {
  66. ret = mtd_block_isbad(mtd, ofs);
  67. if (ret) {
  68. printk("Bad blocks %d at 0x%x\n",
  69. (u32)(ofs >> this->erase_shift), (u32)ofs);
  70. ofs += blocksize;
  71. continue;
  72. }
  73. if (oob)
  74. ops.oobbuf = buf;
  75. else
  76. ops.datbuf = buf;
  77. ops.retlen = 0;
  78. ret = mtd_read_oob(mtd, ofs, &ops);
  79. if (ret) {
  80. printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
  81. ofs += blocksize;
  82. continue;
  83. }
  84. ofs += blocksize;
  85. buf += blocksize;
  86. blocks--;
  87. *retlen += ops.retlen;
  88. }
  89. return 0;
  90. }
  91. static int onenand_write_oneblock_withoob(loff_t to, const u_char * buf,
  92. size_t *retlen)
  93. {
  94. struct mtd_oob_ops ops = {
  95. .len = mtd->writesize,
  96. .ooblen = mtd->oobsize,
  97. .mode = MTD_OPS_AUTO_OOB,
  98. };
  99. int page, ret = 0;
  100. for (page = 0; page < (mtd->erasesize / mtd->writesize); page ++) {
  101. ops.datbuf = (u_char *)buf;
  102. buf += mtd->writesize;
  103. ops.oobbuf = (u_char *)buf;
  104. buf += mtd->oobsize;
  105. ret = mtd_write_oob(mtd, to, &ops);
  106. if (ret)
  107. break;
  108. to += mtd->writesize;
  109. }
  110. *retlen = (ret) ? 0 : mtd->erasesize;
  111. return ret;
  112. }
  113. static int onenand_block_write(loff_t to, size_t len,
  114. size_t *retlen, const u_char * buf, int withoob)
  115. {
  116. struct onenand_chip *this = mtd->priv;
  117. int blocks = len >> this->erase_shift;
  118. int blocksize = (1 << this->erase_shift);
  119. loff_t ofs;
  120. size_t _retlen = 0;
  121. int ret;
  122. if ((to & (mtd->writesize - 1)) != 0) {
  123. printf("Attempt to write non block-aligned data\n");
  124. *retlen = 0;
  125. return 1;
  126. }
  127. if (to == next_ofs) {
  128. next_ofs = to + len;
  129. to += skip_ofs;
  130. } else {
  131. next_ofs = to + len;
  132. skip_ofs = 0;
  133. }
  134. ofs = to;
  135. while (blocks) {
  136. ret = mtd_block_isbad(mtd, ofs);
  137. if (ret) {
  138. printk("Bad blocks %d at 0x%x\n",
  139. (u32)(ofs >> this->erase_shift), (u32)ofs);
  140. skip_ofs += blocksize;
  141. goto next;
  142. }
  143. if (!withoob)
  144. ret = mtd_write(mtd, ofs, blocksize, &_retlen, buf);
  145. else
  146. ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
  147. if (ret) {
  148. printk("Write failed 0x%x, %d", (u32)ofs, ret);
  149. skip_ofs += blocksize;
  150. goto next;
  151. }
  152. buf += blocksize;
  153. blocks--;
  154. *retlen += _retlen;
  155. next:
  156. ofs += blocksize;
  157. }
  158. return 0;
  159. }
  160. static int onenand_block_erase(u32 start, u32 size, int force)
  161. {
  162. struct onenand_chip *this = mtd->priv;
  163. struct erase_info instr = {
  164. .callback = NULL,
  165. };
  166. loff_t ofs;
  167. int ret;
  168. int blocksize = 1 << this->erase_shift;
  169. for (ofs = start; ofs < (start + size); ofs += blocksize) {
  170. ret = mtd_block_isbad(mtd, ofs);
  171. if (ret && !force) {
  172. printf("Skip erase bad block %d at 0x%x\n",
  173. (u32)(ofs >> this->erase_shift), (u32)ofs);
  174. continue;
  175. }
  176. instr.addr = ofs;
  177. instr.len = blocksize;
  178. instr.priv = force;
  179. instr.mtd = mtd;
  180. ret = mtd_erase(mtd, &instr);
  181. if (ret) {
  182. printf("erase failed block %d at 0x%x\n",
  183. (u32)(ofs >> this->erase_shift), (u32)ofs);
  184. continue;
  185. }
  186. }
  187. return 0;
  188. }
  189. static int onenand_block_test(u32 start, u32 size)
  190. {
  191. struct onenand_chip *this = mtd->priv;
  192. struct erase_info instr = {
  193. .callback = NULL,
  194. .priv = 0,
  195. };
  196. int blocks;
  197. loff_t ofs;
  198. int blocksize = 1 << this->erase_shift;
  199. int start_block, end_block;
  200. size_t retlen;
  201. u_char *buf;
  202. u_char *verify_buf;
  203. int ret;
  204. buf = malloc(blocksize);
  205. if (!buf) {
  206. printf("Not enough malloc space available!\n");
  207. return -1;
  208. }
  209. verify_buf = malloc(blocksize);
  210. if (!verify_buf) {
  211. printf("Not enough malloc space available!\n");
  212. return -1;
  213. }
  214. start_block = start >> this->erase_shift;
  215. end_block = (start + size) >> this->erase_shift;
  216. /* Protect boot-loader from badblock testing */
  217. if (start_block < 2)
  218. start_block = 2;
  219. if (end_block > (mtd->size >> this->erase_shift))
  220. end_block = mtd->size >> this->erase_shift;
  221. blocks = start_block;
  222. ofs = start;
  223. while (blocks < end_block) {
  224. printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
  225. ret = mtd_block_isbad(mtd, ofs);
  226. if (ret) {
  227. printf("Skip erase bad block %d at 0x%x\n",
  228. (u32)(ofs >> this->erase_shift), (u32)ofs);
  229. goto next;
  230. }
  231. instr.addr = ofs;
  232. instr.len = blocksize;
  233. ret = mtd_erase(mtd, &instr);
  234. if (ret) {
  235. printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
  236. goto next;
  237. }
  238. ret = mtd_write(mtd, ofs, blocksize, &retlen, buf);
  239. if (ret) {
  240. printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
  241. goto next;
  242. }
  243. ret = mtd_read(mtd, ofs, blocksize, &retlen, verify_buf);
  244. if (ret) {
  245. printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
  246. goto next;
  247. }
  248. if (memcmp(buf, verify_buf, blocksize))
  249. printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
  250. next:
  251. ofs += blocksize;
  252. blocks++;
  253. }
  254. printf("...Done\n");
  255. free(buf);
  256. free(verify_buf);
  257. return 0;
  258. }
  259. static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
  260. {
  261. int i;
  262. u_char *datbuf, *oobbuf, *p;
  263. struct mtd_oob_ops ops;
  264. loff_t addr;
  265. datbuf = malloc(mtd->writesize + mtd->oobsize);
  266. oobbuf = malloc(mtd->oobsize);
  267. if (!datbuf || !oobbuf) {
  268. puts("No memory for page buffer\n");
  269. return 1;
  270. }
  271. off &= ~(mtd->writesize - 1);
  272. addr = (loff_t) off;
  273. memset(&ops, 0, sizeof(ops));
  274. ops.datbuf = datbuf;
  275. ops.oobbuf = oobbuf;
  276. ops.len = mtd->writesize;
  277. ops.ooblen = mtd->oobsize;
  278. ops.retlen = 0;
  279. i = mtd_read_oob(mtd, addr, &ops);
  280. if (i < 0) {
  281. printf("Error (%d) reading page %08lx\n", i, off);
  282. free(datbuf);
  283. free(oobbuf);
  284. return 1;
  285. }
  286. printf("Page %08lx dump:\n", off);
  287. i = mtd->writesize >> 4;
  288. p = datbuf;
  289. while (i--) {
  290. if (!only_oob)
  291. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
  292. " %02x %02x %02x %02x %02x %02x %02x %02x\n",
  293. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
  294. p[8], p[9], p[10], p[11], p[12], p[13], p[14],
  295. p[15]);
  296. p += 16;
  297. }
  298. puts("OOB:\n");
  299. i = mtd->oobsize >> 3;
  300. p = oobbuf;
  301. while (i--) {
  302. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
  303. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
  304. p += 8;
  305. }
  306. free(datbuf);
  307. free(oobbuf);
  308. return 0;
  309. }
  310. static int do_onenand_info(struct cmd_tbl *cmdtp, int flag, int argc,
  311. char *const argv[])
  312. {
  313. printf("%s\n", mtd->name);
  314. return 0;
  315. }
  316. static int do_onenand_bad(struct cmd_tbl *cmdtp, int flag, int argc,
  317. char *const argv[])
  318. {
  319. ulong ofs;
  320. mtd = &onenand_mtd;
  321. /* Currently only one OneNAND device is supported */
  322. printf("\nDevice %d bad blocks:\n", 0);
  323. for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
  324. if (mtd_block_isbad(mtd, ofs))
  325. printf(" %08x\n", (u32)ofs);
  326. }
  327. return 0;
  328. }
  329. static int do_onenand_read(struct cmd_tbl *cmdtp, int flag, int argc,
  330. char *const argv[])
  331. {
  332. char *s;
  333. int oob = 0;
  334. ulong addr, ofs;
  335. size_t len;
  336. int ret = 0;
  337. size_t retlen = 0;
  338. if (argc < 3)
  339. return CMD_RET_USAGE;
  340. s = strchr(argv[0], '.');
  341. if ((s != NULL) && (!strcmp(s, ".oob")))
  342. oob = 1;
  343. addr = (ulong)hextoul(argv[1], NULL);
  344. printf("\nOneNAND read: ");
  345. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  346. return 1;
  347. ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
  348. printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
  349. return ret == 0 ? 0 : 1;
  350. }
  351. static int do_onenand_write(struct cmd_tbl *cmdtp, int flag, int argc,
  352. char *const argv[])
  353. {
  354. ulong addr, ofs;
  355. size_t len;
  356. int ret = 0, withoob = 0;
  357. size_t retlen = 0;
  358. if (argc < 3)
  359. return CMD_RET_USAGE;
  360. if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
  361. withoob = 1;
  362. addr = (ulong)hextoul(argv[1], NULL);
  363. printf("\nOneNAND write: ");
  364. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  365. return 1;
  366. ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
  367. printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
  368. return ret == 0 ? 0 : 1;
  369. }
  370. static int do_onenand_erase(struct cmd_tbl *cmdtp, int flag, int argc,
  371. char *const argv[])
  372. {
  373. ulong ofs;
  374. int ret = 0;
  375. size_t len;
  376. int force;
  377. /*
  378. * Syntax is:
  379. * 0 1 2 3 4
  380. * onenand erase [force] [off size]
  381. */
  382. argc--;
  383. argv++;
  384. if (argc)
  385. {
  386. if (!strcmp("force", argv[0]))
  387. {
  388. force = 1;
  389. argc--;
  390. argv++;
  391. }
  392. }
  393. printf("\nOneNAND erase: ");
  394. /* skip first two or three arguments, look for offset and size */
  395. if (arg_off_size_onenand(argc, argv, &ofs, &len) != 0)
  396. return 1;
  397. ret = onenand_block_erase(ofs, len, force);
  398. printf("%s\n", ret ? "ERROR" : "OK");
  399. return ret == 0 ? 0 : 1;
  400. }
  401. static int do_onenand_test(struct cmd_tbl *cmdtp, int flag, int argc,
  402. char *const argv[])
  403. {
  404. ulong ofs;
  405. int ret = 0;
  406. size_t len;
  407. /*
  408. * Syntax is:
  409. * 0 1 2 3 4
  410. * onenand test [force] [off size]
  411. */
  412. printf("\nOneNAND test: ");
  413. /* skip first two or three arguments, look for offset and size */
  414. if (arg_off_size_onenand(argc - 1, argv + 1, &ofs, &len) != 0)
  415. return 1;
  416. ret = onenand_block_test(ofs, len);
  417. printf("%s\n", ret ? "ERROR" : "OK");
  418. return ret == 0 ? 0 : 1;
  419. }
  420. static int do_onenand_dump(struct cmd_tbl *cmdtp, int flag, int argc,
  421. char *const argv[])
  422. {
  423. ulong ofs;
  424. int ret = 0;
  425. char *s;
  426. if (argc < 2)
  427. return CMD_RET_USAGE;
  428. s = strchr(argv[0], '.');
  429. ofs = (int)hextoul(argv[1], NULL);
  430. if (s != NULL && strcmp(s, ".oob") == 0)
  431. ret = onenand_dump(mtd, ofs, 1);
  432. else
  433. ret = onenand_dump(mtd, ofs, 0);
  434. return ret == 0 ? 1 : 0;
  435. }
  436. static int do_onenand_markbad(struct cmd_tbl *cmdtp, int flag, int argc,
  437. char *const argv[])
  438. {
  439. int ret = 0;
  440. ulong addr;
  441. argc -= 2;
  442. argv += 2;
  443. if (argc <= 0)
  444. return CMD_RET_USAGE;
  445. while (argc > 0) {
  446. addr = hextoul(*argv, NULL);
  447. if (mtd_block_markbad(mtd, addr)) {
  448. printf("block 0x%08lx NOT marked "
  449. "as bad! ERROR %d\n",
  450. addr, ret);
  451. ret = 1;
  452. } else {
  453. printf("block 0x%08lx successfully "
  454. "marked as bad\n",
  455. addr);
  456. }
  457. --argc;
  458. ++argv;
  459. }
  460. return ret;
  461. }
  462. static struct cmd_tbl cmd_onenand_sub[] = {
  463. U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
  464. U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
  465. U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
  466. U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
  467. U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
  468. U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
  469. U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
  470. U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
  471. U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
  472. };
  473. #ifdef CONFIG_NEEDS_MANUAL_RELOC
  474. void onenand_reloc(void) {
  475. fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
  476. }
  477. #endif
  478. static int do_onenand(struct cmd_tbl *cmdtp, int flag, int argc,
  479. char *const argv[])
  480. {
  481. struct cmd_tbl *c;
  482. if (argc < 2)
  483. return CMD_RET_USAGE;
  484. mtd = &onenand_mtd;
  485. /* Strip off leading 'onenand' command argument */
  486. argc--;
  487. argv++;
  488. c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
  489. if (c)
  490. return c->cmd(cmdtp, flag, argc, argv);
  491. else
  492. return CMD_RET_USAGE;
  493. }
  494. U_BOOT_CMD(
  495. onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
  496. "OneNAND sub-system",
  497. "info - show available OneNAND devices\n"
  498. "onenand bad - show bad blocks\n"
  499. "onenand read[.oob] addr off size\n"
  500. "onenand write[.yaffs] addr off size\n"
  501. " read/write 'size' bytes starting at offset 'off'\n"
  502. " to/from memory address 'addr', skipping bad blocks.\n"
  503. "onenand erase [force] [off size] - erase 'size' bytes from\n"
  504. "onenand test [off size] - test 'size' bytes from\n"
  505. " offset 'off' (entire device if not specified)\n"
  506. "onenand dump[.oob] off - dump page\n"
  507. "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
  508. );