#include <command.h>
#include <malloc.h>
-#include <linux/mtd/compat.h>
+#include <linux/compat.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/onenand.h>
return (*p != '\0' && *endptr == '\0') ? 1 : 0;
}
-static int arg_off_size(int argc, char *argv[], ulong *off, size_t *size)
+static int arg_off_size(int argc, char * const argv[], ulong *off, size_t *size)
{
if (argc >= 1) {
if (!(str2long(argv[0], off))) {
}
if ((*off + *size) > mtd->size) {
- printf("total chip size (0x%x) exceeded!\n", mtd->size);
+ printf("total chip size (0x%llx) exceeded!\n", mtd->size);
return -1;
}
return 0;
}
+static int onenand_write_oneblock_withoob(loff_t to, const u_char * buf,
+ size_t *retlen)
+{
+ struct mtd_oob_ops ops = {
+ .len = mtd->writesize,
+ .ooblen = mtd->oobsize,
+ .mode = MTD_OOB_AUTO,
+ };
+ int page, ret = 0;
+ for (page = 0; page < (mtd->erasesize / mtd->writesize); page ++) {
+ ops.datbuf = (u_char *)buf;
+ buf += mtd->writesize;
+ ops.oobbuf = (u_char *)buf;
+ buf += mtd->oobsize;
+ ret = mtd->write_oob(mtd, to, &ops);
+ if (ret)
+ break;
+ to += mtd->writesize;
+ }
+
+ *retlen = (ret) ? 0 : mtd->erasesize;
+ return ret;
+}
+
static int onenand_block_write(loff_t to, size_t len,
- size_t *retlen, const u_char * buf)
+ size_t *retlen, const u_char * buf, int withoob)
{
struct onenand_chip *this = mtd->priv;
int blocks = len >> this->erase_shift;
goto next;
}
- ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
+ if (!withoob)
+ ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
+ else
+ ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
if (ret) {
printk("Write failed 0x%x, %d", (u32)ofs, ret);
skip_ofs += blocksize;
addr = (loff_t) off;
memset(&ops, 0, sizeof(ops));
ops.datbuf = datbuf;
- ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
+ ops.oobbuf = oobbuf;
ops.len = mtd->writesize;
ops.ooblen = mtd->oobsize;
ops.retlen = 0;
}
puts("OOB:\n");
i = mtd->oobsize >> 3;
+ p = oobbuf;
+
while (i--) {
printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
return 0;
}
-int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
+static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
- struct onenand_chip *this;
- int blocksize;
- ulong addr, ofs;
- size_t len, retlen = 0;
- int ret;
- char *cmd, *s;
+ printf("%s\n", mtd->name);
+ return 0;
+}
+
+static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong ofs;
mtd = &onenand_mtd;
- this = mtd->priv;
- blocksize = (1 << this->erase_shift);
+ /* Currently only one OneNAND device is supported */
+ printf("\nDevice %d bad blocks:\n", 0);
+ for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
+ if (mtd->block_isbad(mtd, ofs))
+ printf(" %08x\n", (u32)ofs);
+ }
- cmd = argv[1];
+ return 0;
+}
+
+static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ char *s;
+ int oob = 0;
+ ulong addr, ofs;
+ size_t len;
+ int ret = 0;
+ size_t retlen = 0;
- switch (argc) {
- case 0:
- case 1:
- goto usage;
+ if (argc < 3)
+ return CMD_RET_USAGE;
- case 2:
- if (strcmp(cmd, "info") == 0) {
- printf("%s\n", mtd->name);
- return 0;
- }
+ s = strchr(argv[0], '.');
+ if ((s != NULL) && (!strcmp(s, ".oob")))
+ oob = 1;
- if (strcmp(cmd, "bad") == 0) {
- /* Currently only one OneNAND device is supported */
- printf("\nDevice %d bad blocks:\n", 0);
- for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
- if (mtd->block_isbad(mtd, ofs))
- printf(" %08x\n", (u32)ofs);
- }
+ addr = (ulong)simple_strtoul(argv[1], NULL, 16);
- return 0;
- }
+ printf("\nOneNAND read: ");
+ if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
+ return 1;
- default:
- /* At least 4 args */
+ ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
- /*
- * Syntax is:
- * 0 1 2 3 4
- * onenand erase [force] [off size]
- */
- if ((strcmp(cmd, "erase") == 0) || (strcmp(cmd, "test") == 0)) {
- int force = argc > 2 && !strcmp("force", argv[2]);
- int o = force ? 3 : 2;
- int erase;
+ printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
- erase = strcmp(cmd, "erase") == 0; /* 1 = erase, 0 = test */
- printf("\nOneNAND %s: ", erase ? "erase" : "test");
+ return ret == 0 ? 0 : 1;
+}
+
+static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong addr, ofs;
+ size_t len;
+ int ret = 0, withoob = 0;
+ size_t retlen = 0;
- /* skip first two or three arguments, look for offset and size */
- if (arg_off_size(argc - o, argv + o, &ofs, &len) != 0)
- return 1;
+ if (argc < 3)
+ return CMD_RET_USAGE;
+
+ if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
+ withoob = 1;
+
+ addr = (ulong)simple_strtoul(argv[1], NULL, 16);
+
+ printf("\nOneNAND write: ");
+ if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
+ return 1;
- if (erase)
- ret = onenand_block_erase(ofs, len, force);
- else
- ret = onenand_block_test(ofs, len);
+ ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
- printf("%s\n", ret ? "ERROR" : "OK");
+ printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
- return ret == 0 ? 0 : 1;
+ return ret == 0 ? 0 : 1;
+}
+
+static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong ofs;
+ int ret = 0;
+ size_t len;
+ int force;
+
+ /*
+ * Syntax is:
+ * 0 1 2 3 4
+ * onenand erase [force] [off size]
+ */
+ argc--;
+ argv++;
+ if (argc)
+ {
+ if (!strcmp("force", argv[0]))
+ {
+ force = 1;
+ argc--;
+ argv++;
}
+ }
+ printf("\nOneNAND erase: ");
- if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
- int read;
- int oob = 0;
+ /* skip first two or three arguments, look for offset and size */
+ if (arg_off_size(argc, argv, &ofs, &len) != 0)
+ return 1;
- if (argc < 4)
- goto usage;
+ ret = onenand_block_erase(ofs, len, force);
- addr = (ulong)simple_strtoul(argv[2], NULL, 16);
+ printf("%s\n", ret ? "ERROR" : "OK");
- read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
- printf("\nOneNAND %s: ", read ? "read" : "write");
- if (arg_off_size(argc - 3, argv + 3, &ofs, &len) != 0)
- return 1;
+ return ret == 0 ? 0 : 1;
+}
- s = strchr(cmd, '.');
- if ((s != NULL) && (!strcmp(s, ".oob")))
- oob = 1;
+static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong ofs;
+ int ret = 0;
+ size_t len;
- if (read) {
- ret = onenand_block_read(ofs, len, &retlen,
- (u8 *)addr, oob);
- } else {
- ret = onenand_block_write(ofs, len, &retlen,
- (u8 *)addr);
- }
+ /*
+ * Syntax is:
+ * 0 1 2 3 4
+ * onenand test [force] [off size]
+ */
- printf(" %d bytes %s: %s\n", retlen,
- read ? "read" : "written", ret ? "ERROR" : "OK");
+ printf("\nOneNAND test: ");
- return ret == 0 ? 0 : 1;
- }
+ /* skip first two or three arguments, look for offset and size */
+ if (arg_off_size(argc - 1, argv + 1, &ofs, &len) != 0)
+ return 1;
- if (strcmp(cmd, "markbad") == 0) {
- addr = (ulong)simple_strtoul(argv[2], NULL, 16);
-
- int ret = mtd->block_markbad(mtd, addr);
- if (ret == 0) {
- printf("block 0x%08lx successfully marked as bad\n",
- (ulong) addr);
- return 0;
- } else {
- printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
- (ulong) addr, ret);
- }
- return 1;
- }
+ ret = onenand_block_test(ofs, len);
+
+ printf("%s\n", ret ? "ERROR" : "OK");
+
+ return ret == 0 ? 0 : 1;
+}
- if (strncmp(cmd, "dump", 4) == 0) {
- if (argc < 3)
- goto usage;
+static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ ulong ofs;
+ int ret = 0;
+ char *s;
- s = strchr(cmd, '.');
- ofs = (int)simple_strtoul(argv[2], NULL, 16);
+ if (argc < 2)
+ return CMD_RET_USAGE;
- if (s != NULL && strcmp(s, ".oob") == 0)
- ret = onenand_dump(mtd, ofs, 1);
- else
- ret = onenand_dump(mtd, ofs, 0);
+ s = strchr(argv[0], '.');
+ ofs = (int)simple_strtoul(argv[1], NULL, 16);
- return ret == 0 ? 1 : 0;
- }
+ if (s != NULL && strcmp(s, ".oob") == 0)
+ ret = onenand_dump(mtd, ofs, 1);
+ else
+ ret = onenand_dump(mtd, ofs, 0);
- break;
+ return ret == 0 ? 1 : 0;
+}
+
+static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ int ret = 0;
+ ulong addr;
+
+ argc -= 2;
+ argv += 2;
+
+ if (argc <= 0)
+ return CMD_RET_USAGE;
+
+ while (argc > 0) {
+ addr = simple_strtoul(*argv, NULL, 16);
+
+ if (mtd->block_markbad(mtd, addr)) {
+ printf("block 0x%08lx NOT marked "
+ "as bad! ERROR %d\n",
+ addr, ret);
+ ret = 1;
+ } else {
+ printf("block 0x%08lx successfully "
+ "marked as bad\n",
+ addr);
+ }
+ --argc;
+ ++argv;
}
+ return ret;
+}
- return 0;
+static cmd_tbl_t cmd_onenand_sub[] = {
+ U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
+ U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
+ U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
+ U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
+ U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
+ U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
+ U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
+ U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
+ U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
+};
+
+#ifdef CONFIG_NEEDS_MANUAL_RELOC
+void onenand_reloc(void) {
+ fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
+}
+#endif
-usage:
- cmd_usage(cmdtp);
- return 1;
+static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ cmd_tbl_t *c;
+
+ if (argc < 2)
+ return CMD_RET_USAGE;
+
+ mtd = &onenand_mtd;
+
+ /* Strip off leading 'onenand' command argument */
+ argc--;
+ argv++;
+
+ c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
+
+ if (c)
+ return c->cmd(cmdtp, flag, argc, argv);
+ else
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
- onenand, 6, 1, do_onenand,
- "onenand - OneNAND sub-system\n",
+ onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
+ "OneNAND sub-system",
"info - show available OneNAND devices\n"
"onenand bad - show bad blocks\n"
"onenand read[.oob] addr off size\n"
- "onenand write[.oob] addr off size\n"
+ "onenand write[.yaffs] addr off size\n"
" read/write 'size' bytes starting at offset 'off'\n"
" to/from memory address 'addr', skipping bad blocks.\n"
"onenand erase [force] [off size] - erase 'size' bytes from\n"
"onenand test [off size] - test 'size' bytes from\n"
" offset 'off' (entire device if not specified)\n"
"onenand dump[.oob] off - dump page\n"
- "onenand markbad off - mark bad block at offset (UNSAFE)\n"
+ "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
);