onenand.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595
  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 == next_ofs) {
  123. next_ofs = to + len;
  124. to += skip_ofs;
  125. } else {
  126. next_ofs = to + len;
  127. skip_ofs = 0;
  128. }
  129. ofs = to;
  130. while (blocks) {
  131. ret = mtd_block_isbad(mtd, ofs);
  132. if (ret) {
  133. printk("Bad blocks %d at 0x%x\n",
  134. (u32)(ofs >> this->erase_shift), (u32)ofs);
  135. skip_ofs += blocksize;
  136. goto next;
  137. }
  138. if (!withoob)
  139. ret = mtd_write(mtd, ofs, blocksize, &_retlen, buf);
  140. else
  141. ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
  142. if (ret) {
  143. printk("Write failed 0x%x, %d", (u32)ofs, ret);
  144. skip_ofs += blocksize;
  145. goto next;
  146. }
  147. buf += blocksize;
  148. blocks--;
  149. *retlen += _retlen;
  150. next:
  151. ofs += blocksize;
  152. }
  153. return 0;
  154. }
  155. static int onenand_block_erase(u32 start, u32 size, int force)
  156. {
  157. struct onenand_chip *this = mtd->priv;
  158. struct erase_info instr = {
  159. .callback = NULL,
  160. };
  161. loff_t ofs;
  162. int ret;
  163. int blocksize = 1 << this->erase_shift;
  164. for (ofs = start; ofs < (start + size); ofs += blocksize) {
  165. ret = mtd_block_isbad(mtd, ofs);
  166. if (ret && !force) {
  167. printf("Skip erase bad block %d at 0x%x\n",
  168. (u32)(ofs >> this->erase_shift), (u32)ofs);
  169. continue;
  170. }
  171. instr.addr = ofs;
  172. instr.len = blocksize;
  173. instr.priv = force;
  174. instr.mtd = mtd;
  175. ret = mtd_erase(mtd, &instr);
  176. if (ret) {
  177. printf("erase failed block %d at 0x%x\n",
  178. (u32)(ofs >> this->erase_shift), (u32)ofs);
  179. continue;
  180. }
  181. }
  182. return 0;
  183. }
  184. static int onenand_block_test(u32 start, u32 size)
  185. {
  186. struct onenand_chip *this = mtd->priv;
  187. struct erase_info instr = {
  188. .callback = NULL,
  189. .priv = 0,
  190. };
  191. int blocks;
  192. loff_t ofs;
  193. int blocksize = 1 << this->erase_shift;
  194. int start_block, end_block;
  195. size_t retlen;
  196. u_char *buf;
  197. u_char *verify_buf;
  198. int ret;
  199. buf = malloc(blocksize);
  200. if (!buf) {
  201. printf("Not enough malloc space available!\n");
  202. return -1;
  203. }
  204. verify_buf = malloc(blocksize);
  205. if (!verify_buf) {
  206. printf("Not enough malloc space available!\n");
  207. return -1;
  208. }
  209. start_block = start >> this->erase_shift;
  210. end_block = (start + size) >> this->erase_shift;
  211. /* Protect boot-loader from badblock testing */
  212. if (start_block < 2)
  213. start_block = 2;
  214. if (end_block > (mtd->size >> this->erase_shift))
  215. end_block = mtd->size >> this->erase_shift;
  216. blocks = start_block;
  217. ofs = start;
  218. while (blocks < end_block) {
  219. printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
  220. ret = mtd_block_isbad(mtd, ofs);
  221. if (ret) {
  222. printf("Skip erase bad block %d at 0x%x\n",
  223. (u32)(ofs >> this->erase_shift), (u32)ofs);
  224. goto next;
  225. }
  226. instr.addr = ofs;
  227. instr.len = blocksize;
  228. ret = mtd_erase(mtd, &instr);
  229. if (ret) {
  230. printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
  231. goto next;
  232. }
  233. ret = mtd_write(mtd, ofs, blocksize, &retlen, buf);
  234. if (ret) {
  235. printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
  236. goto next;
  237. }
  238. ret = mtd_read(mtd, ofs, blocksize, &retlen, verify_buf);
  239. if (ret) {
  240. printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
  241. goto next;
  242. }
  243. if (memcmp(buf, verify_buf, blocksize))
  244. printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
  245. next:
  246. ofs += blocksize;
  247. blocks++;
  248. }
  249. printf("...Done\n");
  250. free(buf);
  251. free(verify_buf);
  252. return 0;
  253. }
  254. static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
  255. {
  256. int i;
  257. u_char *datbuf, *oobbuf, *p;
  258. struct mtd_oob_ops ops;
  259. loff_t addr;
  260. datbuf = malloc(mtd->writesize + mtd->oobsize);
  261. oobbuf = malloc(mtd->oobsize);
  262. if (!datbuf || !oobbuf) {
  263. puts("No memory for page buffer\n");
  264. return 1;
  265. }
  266. off &= ~(mtd->writesize - 1);
  267. addr = (loff_t) off;
  268. memset(&ops, 0, sizeof(ops));
  269. ops.datbuf = datbuf;
  270. ops.oobbuf = oobbuf;
  271. ops.len = mtd->writesize;
  272. ops.ooblen = mtd->oobsize;
  273. ops.retlen = 0;
  274. i = mtd_read_oob(mtd, addr, &ops);
  275. if (i < 0) {
  276. printf("Error (%d) reading page %08lx\n", i, off);
  277. free(datbuf);
  278. free(oobbuf);
  279. return 1;
  280. }
  281. printf("Page %08lx dump:\n", off);
  282. i = mtd->writesize >> 4;
  283. p = datbuf;
  284. while (i--) {
  285. if (!only_oob)
  286. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
  287. " %02x %02x %02x %02x %02x %02x %02x %02x\n",
  288. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
  289. p[8], p[9], p[10], p[11], p[12], p[13], p[14],
  290. p[15]);
  291. p += 16;
  292. }
  293. puts("OOB:\n");
  294. i = mtd->oobsize >> 3;
  295. p = oobbuf;
  296. while (i--) {
  297. printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
  298. p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
  299. p += 8;
  300. }
  301. free(datbuf);
  302. free(oobbuf);
  303. return 0;
  304. }
  305. static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  306. {
  307. printf("%s\n", mtd->name);
  308. return 0;
  309. }
  310. static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  311. {
  312. ulong ofs;
  313. mtd = &onenand_mtd;
  314. /* Currently only one OneNAND device is supported */
  315. printf("\nDevice %d bad blocks:\n", 0);
  316. for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
  317. if (mtd_block_isbad(mtd, ofs))
  318. printf(" %08x\n", (u32)ofs);
  319. }
  320. return 0;
  321. }
  322. static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  323. {
  324. char *s;
  325. int oob = 0;
  326. ulong addr, ofs;
  327. size_t len;
  328. int ret = 0;
  329. size_t retlen = 0;
  330. if (argc < 3)
  331. return CMD_RET_USAGE;
  332. s = strchr(argv[0], '.');
  333. if ((s != NULL) && (!strcmp(s, ".oob")))
  334. oob = 1;
  335. addr = (ulong)simple_strtoul(argv[1], NULL, 16);
  336. printf("\nOneNAND read: ");
  337. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  338. return 1;
  339. ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
  340. printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
  341. return ret == 0 ? 0 : 1;
  342. }
  343. static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  344. {
  345. ulong addr, ofs;
  346. size_t len;
  347. int ret = 0, withoob = 0;
  348. size_t retlen = 0;
  349. if (argc < 3)
  350. return CMD_RET_USAGE;
  351. if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
  352. withoob = 1;
  353. addr = (ulong)simple_strtoul(argv[1], NULL, 16);
  354. printf("\nOneNAND write: ");
  355. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  356. return 1;
  357. ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
  358. printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
  359. return ret == 0 ? 0 : 1;
  360. }
  361. static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  362. {
  363. ulong ofs;
  364. int ret = 0;
  365. size_t len;
  366. int force;
  367. /*
  368. * Syntax is:
  369. * 0 1 2 3 4
  370. * onenand erase [force] [off size]
  371. */
  372. argc--;
  373. argv++;
  374. if (argc)
  375. {
  376. if (!strcmp("force", argv[0]))
  377. {
  378. force = 1;
  379. argc--;
  380. argv++;
  381. }
  382. }
  383. printf("\nOneNAND erase: ");
  384. /* skip first two or three arguments, look for offset and size */
  385. if (arg_off_size_onenand(argc, argv, &ofs, &len) != 0)
  386. return 1;
  387. ret = onenand_block_erase(ofs, len, force);
  388. printf("%s\n", ret ? "ERROR" : "OK");
  389. return ret == 0 ? 0 : 1;
  390. }
  391. static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  392. {
  393. ulong ofs;
  394. int ret = 0;
  395. size_t len;
  396. /*
  397. * Syntax is:
  398. * 0 1 2 3 4
  399. * onenand test [force] [off size]
  400. */
  401. printf("\nOneNAND test: ");
  402. /* skip first two or three arguments, look for offset and size */
  403. if (arg_off_size_onenand(argc - 1, argv + 1, &ofs, &len) != 0)
  404. return 1;
  405. ret = onenand_block_test(ofs, len);
  406. printf("%s\n", ret ? "ERROR" : "OK");
  407. return ret == 0 ? 0 : 1;
  408. }
  409. static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  410. {
  411. ulong ofs;
  412. int ret = 0;
  413. char *s;
  414. if (argc < 2)
  415. return CMD_RET_USAGE;
  416. s = strchr(argv[0], '.');
  417. ofs = (int)simple_strtoul(argv[1], NULL, 16);
  418. if (s != NULL && strcmp(s, ".oob") == 0)
  419. ret = onenand_dump(mtd, ofs, 1);
  420. else
  421. ret = onenand_dump(mtd, ofs, 0);
  422. return ret == 0 ? 1 : 0;
  423. }
  424. static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  425. {
  426. int ret = 0;
  427. ulong addr;
  428. argc -= 2;
  429. argv += 2;
  430. if (argc <= 0)
  431. return CMD_RET_USAGE;
  432. while (argc > 0) {
  433. addr = simple_strtoul(*argv, NULL, 16);
  434. if (mtd_block_markbad(mtd, addr)) {
  435. printf("block 0x%08lx NOT marked "
  436. "as bad! ERROR %d\n",
  437. addr, ret);
  438. ret = 1;
  439. } else {
  440. printf("block 0x%08lx successfully "
  441. "marked as bad\n",
  442. addr);
  443. }
  444. --argc;
  445. ++argv;
  446. }
  447. return ret;
  448. }
  449. static cmd_tbl_t cmd_onenand_sub[] = {
  450. U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
  451. U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
  452. U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
  453. U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
  454. U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
  455. U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
  456. U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
  457. U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
  458. U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
  459. };
  460. #ifdef CONFIG_NEEDS_MANUAL_RELOC
  461. void onenand_reloc(void) {
  462. fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
  463. }
  464. #endif
  465. static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  466. {
  467. cmd_tbl_t *c;
  468. if (argc < 2)
  469. return CMD_RET_USAGE;
  470. mtd = &onenand_mtd;
  471. /* Strip off leading 'onenand' command argument */
  472. argc--;
  473. argv++;
  474. c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
  475. if (c)
  476. return c->cmd(cmdtp, flag, argc, argv);
  477. else
  478. return CMD_RET_USAGE;
  479. }
  480. U_BOOT_CMD(
  481. onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
  482. "OneNAND sub-system",
  483. "info - show available OneNAND devices\n"
  484. "onenand bad - show bad blocks\n"
  485. "onenand read[.oob] addr off size\n"
  486. "onenand write[.yaffs] addr off size\n"
  487. " read/write 'size' bytes starting at offset 'off'\n"
  488. " to/from memory address 'addr', skipping bad blocks.\n"
  489. "onenand erase [force] [off size] - erase 'size' bytes from\n"
  490. "onenand test [off size] - test 'size' bytes from\n"
  491. " offset 'off' (entire device if not specified)\n"
  492. "onenand dump[.oob] off - dump page\n"
  493. "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
  494. );