onenand.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605
  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. loff_t ofs;
  165. int ret;
  166. int blocksize = 1 << this->erase_shift;
  167. for (ofs = start; ofs < (start + size); ofs += blocksize) {
  168. ret = mtd_block_isbad(mtd, ofs);
  169. if (ret && !force) {
  170. printf("Skip erase bad block %d at 0x%x\n",
  171. (u32)(ofs >> this->erase_shift), (u32)ofs);
  172. continue;
  173. }
  174. instr.addr = ofs;
  175. instr.len = blocksize;
  176. instr.priv = force;
  177. instr.mtd = mtd;
  178. ret = mtd_erase(mtd, &instr);
  179. if (ret) {
  180. printf("erase failed block %d at 0x%x\n",
  181. (u32)(ofs >> this->erase_shift), (u32)ofs);
  182. continue;
  183. }
  184. }
  185. return 0;
  186. }
  187. static int onenand_block_test(u32 start, u32 size)
  188. {
  189. struct onenand_chip *this = mtd->priv;
  190. struct erase_info instr = {};
  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(struct cmd_tbl *cmdtp, int flag, int argc,
  306. char *const argv[])
  307. {
  308. printf("%s\n", mtd->name);
  309. return 0;
  310. }
  311. static int do_onenand_bad(struct cmd_tbl *cmdtp, int flag, int argc,
  312. char *const argv[])
  313. {
  314. ulong ofs;
  315. mtd = &onenand_mtd;
  316. /* Currently only one OneNAND device is supported */
  317. printf("\nDevice %d bad blocks:\n", 0);
  318. for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
  319. if (mtd_block_isbad(mtd, ofs))
  320. printf(" %08x\n", (u32)ofs);
  321. }
  322. return 0;
  323. }
  324. static int do_onenand_read(struct cmd_tbl *cmdtp, int flag, int argc,
  325. char *const argv[])
  326. {
  327. char *s;
  328. int oob = 0;
  329. ulong addr, ofs;
  330. size_t len;
  331. int ret = 0;
  332. size_t retlen = 0;
  333. if (argc < 3)
  334. return CMD_RET_USAGE;
  335. s = strchr(argv[0], '.');
  336. if ((s != NULL) && (!strcmp(s, ".oob")))
  337. oob = 1;
  338. addr = (ulong)hextoul(argv[1], NULL);
  339. printf("\nOneNAND read: ");
  340. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  341. return 1;
  342. ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
  343. printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
  344. return ret == 0 ? 0 : 1;
  345. }
  346. static int do_onenand_write(struct cmd_tbl *cmdtp, int flag, int argc,
  347. char *const argv[])
  348. {
  349. ulong addr, ofs;
  350. size_t len;
  351. int ret = 0, withoob = 0;
  352. size_t retlen = 0;
  353. if (argc < 3)
  354. return CMD_RET_USAGE;
  355. if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
  356. withoob = 1;
  357. addr = (ulong)hextoul(argv[1], NULL);
  358. printf("\nOneNAND write: ");
  359. if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
  360. return 1;
  361. ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
  362. printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
  363. return ret == 0 ? 0 : 1;
  364. }
  365. static int do_onenand_erase(struct cmd_tbl *cmdtp, int flag, int argc,
  366. char *const argv[])
  367. {
  368. ulong ofs;
  369. int ret = 0;
  370. size_t len;
  371. int force;
  372. /*
  373. * Syntax is:
  374. * 0 1 2 3 4
  375. * onenand erase [force] [off size]
  376. */
  377. argc--;
  378. argv++;
  379. if (argc)
  380. {
  381. if (!strcmp("force", argv[0]))
  382. {
  383. force = 1;
  384. argc--;
  385. argv++;
  386. }
  387. }
  388. printf("\nOneNAND erase: ");
  389. /* skip first two or three arguments, look for offset and size */
  390. if (arg_off_size_onenand(argc, argv, &ofs, &len) != 0)
  391. return 1;
  392. ret = onenand_block_erase(ofs, len, force);
  393. printf("%s\n", ret ? "ERROR" : "OK");
  394. return ret == 0 ? 0 : 1;
  395. }
  396. static int do_onenand_test(struct cmd_tbl *cmdtp, int flag, int argc,
  397. char *const argv[])
  398. {
  399. ulong ofs;
  400. int ret = 0;
  401. size_t len;
  402. /*
  403. * Syntax is:
  404. * 0 1 2 3 4
  405. * onenand test [force] [off size]
  406. */
  407. printf("\nOneNAND test: ");
  408. /* skip first two or three arguments, look for offset and size */
  409. if (arg_off_size_onenand(argc - 1, argv + 1, &ofs, &len) != 0)
  410. return 1;
  411. ret = onenand_block_test(ofs, len);
  412. printf("%s\n", ret ? "ERROR" : "OK");
  413. return ret == 0 ? 0 : 1;
  414. }
  415. static int do_onenand_dump(struct cmd_tbl *cmdtp, int flag, int argc,
  416. char *const argv[])
  417. {
  418. ulong ofs;
  419. int ret = 0;
  420. char *s;
  421. if (argc < 2)
  422. return CMD_RET_USAGE;
  423. s = strchr(argv[0], '.');
  424. ofs = (int)hextoul(argv[1], NULL);
  425. if (s != NULL && strcmp(s, ".oob") == 0)
  426. ret = onenand_dump(mtd, ofs, 1);
  427. else
  428. ret = onenand_dump(mtd, ofs, 0);
  429. return ret == 0 ? 1 : 0;
  430. }
  431. static int do_onenand_markbad(struct cmd_tbl *cmdtp, int flag, int argc,
  432. char *const argv[])
  433. {
  434. int ret = 0;
  435. ulong addr;
  436. argc -= 2;
  437. argv += 2;
  438. if (argc <= 0)
  439. return CMD_RET_USAGE;
  440. while (argc > 0) {
  441. addr = hextoul(*argv, NULL);
  442. if (mtd_block_markbad(mtd, addr)) {
  443. printf("block 0x%08lx NOT marked "
  444. "as bad! ERROR %d\n",
  445. addr, ret);
  446. ret = 1;
  447. } else {
  448. printf("block 0x%08lx successfully "
  449. "marked as bad\n",
  450. addr);
  451. }
  452. --argc;
  453. ++argv;
  454. }
  455. return ret;
  456. }
  457. static struct cmd_tbl cmd_onenand_sub[] = {
  458. U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
  459. U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
  460. U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
  461. U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
  462. U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
  463. U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
  464. U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
  465. U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
  466. U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
  467. };
  468. #ifdef CONFIG_NEEDS_MANUAL_RELOC
  469. void onenand_reloc(void) {
  470. fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
  471. }
  472. #endif
  473. static int do_onenand(struct cmd_tbl *cmdtp, int flag, int argc,
  474. char *const argv[])
  475. {
  476. struct cmd_tbl *c;
  477. if (argc < 2)
  478. return CMD_RET_USAGE;
  479. mtd = &onenand_mtd;
  480. /* Strip off leading 'onenand' command argument */
  481. argc--;
  482. argv++;
  483. c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
  484. if (c)
  485. return c->cmd(cmdtp, flag, argc, argv);
  486. else
  487. return CMD_RET_USAGE;
  488. }
  489. U_BOOT_CMD(
  490. onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
  491. "OneNAND sub-system",
  492. "info - show available OneNAND devices\n"
  493. "onenand bad - show bad blocks\n"
  494. "onenand read[.oob] addr off size\n"
  495. "onenand write[.yaffs] addr off size\n"
  496. " read/write 'size' bytes starting at offset 'off'\n"
  497. " to/from memory address 'addr', skipping bad blocks.\n"
  498. "onenand erase [force] [off size] - erase 'size' bytes from\n"
  499. "onenand test [off size] - test 'size' bytes from\n"
  500. " offset 'off' (entire device if not specified)\n"
  501. "onenand dump[.oob] off - dump page\n"
  502. "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
  503. );