karo: fdt: convert tx6qdl_fixup_flexcan() to global function karo_fdt_fixup_flexcan()

[karo-tx-uboot.git] / common / cmd_nand.c

diff --git a/common/cmd_nand.c b/common/cmd_nand.c
index f20223cffc4061add0426afa96102535300b7854..be14b5f6caeb2192f6309a0f43949a5b39f70016 100644 (file)
--- a/common/cmd_nand.c
+++ b/common/cmd_nand.c
@@ -62,8 +62,8 @@ static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
        ops.oobbuf = oobbuf;
        ops.len = nand->writesize;
        ops.ooblen = nand->oobsize;
-       ops.mode = MTD_OOB_RAW;
-       i = nand->read_oob(nand, addr, &ops);
+       ops.mode = MTD_OPS_RAW;
+       i = mtd_read_oob(nand, addr, &ops);
        if (i < 0) {
                printf("Error (%d) reading page %08lx\n", i, off);
                free(datbuf);
@@ -404,13 +404,13 @@ static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
                        .oobbuf = ((u8 *)addr) + nand->writesize,
                        .len = nand->writesize,
                        .ooblen = nand->oobsize,
-                       .mode = MTD_OOB_RAW
+                       .mode = MTD_OPS_RAW
                };
 
                if (read)
-                       ret = nand->read_oob(nand, off, &ops);
+                       ret = mtd_read_oob(nand, off, &ops);
                else
-                       ret = nand->write_oob(nand, off, &ops);
+                       ret = mtd_write_oob(nand, off, &ops);
 
                if (ret) {
                        printf("%s: error at offset %llx, ret %d\n",
@@ -426,7 +426,7 @@ static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
 }
 
 /* Adjust a chip/partition size down for bad blocks so we don't
- * read/write/erase past the end of a chip/partition by accident.
+ * read/write past the end of a chip/partition by accident.
  */
 static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev)
 {
@@ -477,7 +477,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        /* Only "dump" is repeatable. */
        if (repeat && strcmp(cmd, "dump"))
-               return 0;
+               return CMD_RET_FAILURE;
 
        if (strcmp(cmd, "info") == 0) {
 
@@ -486,7 +486,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        if (nand_info[i].name)
                                nand_print_and_set_info(i);
                }
-               return 0;
+               return CMD_RET_SUCCESS;
        }
 
        if (strcmp(cmd, "device") == 0) {
@@ -496,19 +496,20 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                                puts("no devices available\n");
                        else
                                nand_print_and_set_info(dev);
-                       return 0;
+                       return CMD_RET_SUCCESS;
                }
 
                dev = (int)simple_strtoul(argv[2], NULL, 10);
                set_dev(dev);
 
-               return 0;
+               return CMD_RET_SUCCESS;
        }
 
 #ifdef CONFIG_ENV_OFFSET_OOB
        /* this command operates only on the first nand device */
        if (strcmp(cmd, "env.oob") == 0)
-               return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
+               return do_nand_env_oob(cmdtp, argc - 1, argv + 1) ?
+                       CMD_RET_FAILURE : CMD_RET_SUCCESS;;
 #endif
 
        /* The following commands operate on the current device, unless
@@ -520,7 +521,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
            !nand_info[dev].name) {
                puts("\nno devices available\n");
-               return 1;
+               return CMD_RET_FAILURE;
        }
        nand = &nand_info[dev];
 
@@ -529,7 +530,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                for (off = 0; off < nand->size; off += nand->erasesize)
                        if (nand_block_isbad(nand, off))
                                printf("  %08llx\n", (unsigned long long)off);
-               return 0;
+               return CMD_RET_SUCCESS;
        }
 
        /*
@@ -546,7 +547,6 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                int scrub = !strncmp(cmd, "scrub", 5);
                int spread = 0;
                int args = 2;
-               int adjust_size = 0;
                const char *scrub_warn =
                        "Warning: "
                        "scrub option will erase all factory set bad blocks!\n"
@@ -563,10 +563,8 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                                spread = 1;
                        } else if (!strcmp(&cmd[5], ".part")) {
                                args = 1;
-                               adjust_size = 1;
                        } else if (!strcmp(&cmd[5], ".chip")) {
                                args = 0;
-                               adjust_size = 1;
                        } else {
                                goto usage;
                        }
@@ -584,11 +582,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                /* skip first two or three arguments, look for offset and size */
                if (arg_off_size(argc - o, argv + o, &dev, &off, &size,
                                 &maxsize) != 0)
-                       return 1;
-
-               /* size is unspecified */
-               if (adjust_size && !scrub)
-                       adjust_size_for_badblocks(&size, off, dev);
+                       return CMD_RET_FAILURE;
 
                nand = &nand_info[dev];
 
@@ -611,17 +605,17 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                                        opts.scrub = 1;
                                else {
                                        puts("scrub aborted\n");
-                                       return -1;
+                                       return CMD_RET_FAILURE;
                                }
                        } else {
                                puts("scrub aborted\n");
-                               return -1;
+                               return CMD_RET_FAILURE;
                        }
                }
                ret = nand_erase_opts(nand, &opts);
                printf("%s\n", ret ? "ERROR" : "OK");
 
-               return ret == 0 ? 0 : 1;
+               return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
        }
 
        if (strncmp(cmd, "dump", 4) == 0) {
@@ -631,7 +625,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                off = (int)simple_strtoul(argv[2], NULL, 16);
                ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
 
-               return ret == 0 ? 1 : 0;
+               return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
        }
 
        if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
@@ -694,7 +688,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                } else if (!strcmp(s, ".trimffs")) {
                        if (read) {
                                printf("Unknown nand command suffix '%s'\n", s);
-                               return 1;
+                               return CMD_RET_FAILURE;
                        }
                        ret = nand_write_skip_bad(nand, off, &rwsize, NULL,
                                                maxsize, (u_char *)addr,
@@ -704,7 +698,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                } else if (!strcmp(s, ".yaffs")) {
                        if (read) {
                                printf("Unknown nand command suffix '%s'.\n", s);
-                               return 1;
+                               return CMD_RET_FAILURE;
                        }
                        ret = nand_write_skip_bad(nand, off, &rwsize, NULL,
                                                maxsize, (u_char *)addr,
@@ -715,24 +709,24 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        mtd_oob_ops_t ops = {
                                .oobbuf = (u8 *)addr,
                                .ooblen = rwsize,
-                               .mode = MTD_OOB_RAW
+                               .mode = MTD_OPS_RAW
                        };
 
                        if (read)
-                               ret = nand->read_oob(nand, off, &ops);
+                               ret = mtd_read_oob(nand, off, &ops);
                        else
-                               ret = nand->write_oob(nand, off, &ops);
+                               ret = mtd_write_oob(nand, off, &ops);
                } else if (raw) {
                        ret = raw_access(nand, addr, off, pagecount, read);
                } else {
                        printf("Unknown nand command suffix '%s'.\n", s);
-                       return 1;
+                       return CMD_RET_FAILURE;
                }
 
                printf(" %zu bytes %s: %s\n", rwsize,
                       read ? "read" : "written", ret ? "ERROR" : "OK");
 
-               return ret == 0 ? 0 : 1;
+               return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
        }
 
 #ifdef CONFIG_CMD_NAND_TORTURE
@@ -764,7 +758,7 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                while (argc > 0) {
                        addr = simple_strtoul(*argv, NULL, 16);
 
-                       if (nand->block_markbad(nand, addr)) {
+                       if (mtd_block_markbad(nand, addr)) {
                                printf("block 0x%08lx NOT marked "
                                        "as bad! ERROR %d\n",
                                        addr, ret);
@@ -777,12 +771,12 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        --argc;
                        ++argv;
                }
-               return ret;
+               return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
        }
 
        if (strcmp(cmd, "biterr") == 0) {
                /* todo */
-               return 1;
+               return CMD_RET_FAILURE;
        }
 
 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
@@ -802,10 +796,10 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                                puts("NAND flash successfully locked\n");
                        } else {
                                puts("Error locking NAND flash\n");
-                               return 1;
+                               return CMD_RET_FAILURE;
                        }
                }
-               return 0;
+               return CMD_RET_SUCCESS;
        }
 
        if (strncmp(cmd, "unlock", 5) == 0) {
@@ -818,16 +812,16 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
                if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size,
                                 &maxsize) < 0)
-                       return 1;
+                       return CMD_RET_FAILURE;
 
                if (!nand_unlock(&nand_info[dev], off, size, allexcept)) {
                        puts("NAND flash successfully unlocked\n");
                } else {
                        puts("Error unlocking NAND flash, "
                             "write and erase will probably fail\n");
-                       return 1;
+                       return CMD_RET_FAILURE;
                }
-               return 0;
+               return CMD_RET_SUCCESS;
        }
 #endif