Merge branch 'rmobile-mx' of git://git.denx.de/u-boot-sh

[people/ms/u-boot.git] / common / fb_nand.c

diff --git a/common/fb_nand.c b/common/fb_nand.c
index bdfad17258dfe170b28bced609d5ee3c02b58323..aa28046cbd83050b94f76306f6f448e97e5101fc 100644 (file)
--- a/common/fb_nand.c
+++ b/common/fb_nand.c
@@ -15,8 +15,6 @@
 #include <jffs2/jffs2.h>
 #include <nand.h>
 
-static char *response_str;
-
 struct fb_nand_sparse {
        struct mtd_info         *mtd;
        struct part_info        *part;
@@ -32,7 +30,7 @@ __weak int board_fastboot_write_partition_setup(char *name)
        return 0;
 }
 
-static int fb_nand_lookup(const char *partname, char *response,
+static int fb_nand_lookup(const char *partname,
                          struct mtd_info **mtd,
                          struct part_info **part)
 {
@@ -42,26 +40,26 @@ static int fb_nand_lookup(const char *partname, char *response,
 
        ret = mtdparts_init();
        if (ret) {
-               error("Cannot initialize MTD partitions\n");
-               fastboot_fail(response_str, "cannot init mtdparts");
+               pr_err("Cannot initialize MTD partitions\n");
+               fastboot_fail("cannot init mtdparts");
                return ret;
        }
 
        ret = find_dev_and_part(partname, &dev, &pnum, part);
        if (ret) {
-               error("cannot find partition: '%s'", partname);
-               fastboot_fail(response_str, "cannot find partition");
+               pr_err("cannot find partition: '%s'", partname);
+               fastboot_fail("cannot find partition");
                return ret;
        }
 
        if (dev->id->type != MTD_DEV_TYPE_NAND) {
-               error("partition '%s' is not stored on a NAND device",
+               pr_err("partition '%s' is not stored on a NAND device",
                      partname);
-               fastboot_fail(response_str, "not a NAND device");
+               fastboot_fail("not a NAND device");
                return -EINVAL;
        }
 
-       *mtd = nand_info[dev->id->num];
+       *mtd = get_nand_dev_by_index(dev->id->num);
 
        return 0;
 }
@@ -128,20 +126,36 @@ static lbaint_t fb_nand_sparse_write(struct sparse_storage *info,
        return written / info->blksz;
 }
 
+static lbaint_t fb_nand_sparse_reserve(struct sparse_storage *info,
+               lbaint_t blk, lbaint_t blkcnt)
+{
+       int bad_blocks = 0;
+
+/*
+ * TODO - implement a function to determine the total number
+ * of blocks which must be used in order to reserve the specified
+ * number ("blkcnt") of "good-blocks", starting at "blk"...
+ * ( possibly something like the "check_skip_len()" function )
+ */
+
+       /*
+        * the return value must be 'blkcnt' ("good-blocks") plus the
+        * number of "bad-blocks" encountered within this space...
+        */
+       return blkcnt + bad_blocks;
+}
+
 void fb_nand_flash_write(const char *cmd, void *download_buffer,
-                        unsigned int download_bytes, char *response)
+                        unsigned int download_bytes)
 {
        struct part_info *part;
        struct mtd_info *mtd = NULL;
        int ret;
 
-       /* initialize the response buffer */
-       response_str = response;
-
-       ret = fb_nand_lookup(cmd, response, &mtd, &part);
+       ret = fb_nand_lookup(cmd, &mtd, &part);
        if (ret) {
-               error("invalid NAND device");
-               fastboot_fail(response_str, "invalid NAND device");
+               pr_err("invalid NAND device");
+               fastboot_fail("invalid NAND device");
                return;
        }
 
@@ -160,13 +174,14 @@ void fb_nand_flash_write(const char *cmd, void *download_buffer,
                sparse.start = part->offset / sparse.blksz;
                sparse.size = part->size / sparse.blksz;
                sparse.write = fb_nand_sparse_write;
+               sparse.reserve = fb_nand_sparse_reserve;
 
                printf("Flashing sparse image at offset " LBAFU "\n",
                       sparse.start);
 
                sparse.priv = &sparse_priv;
                write_sparse_image(&sparse, cmd, download_buffer,
-                                  download_bytes, response_str);
+                                  download_bytes);
        } else {
                printf("Flashing raw image at offset 0x%llx\n",
                       part->offset);
@@ -179,26 +194,23 @@ void fb_nand_flash_write(const char *cmd, void *download_buffer,
        }
 
        if (ret) {
-               fastboot_fail(response_str, "error writing the image");
+               fastboot_fail("error writing the image");
                return;
        }
 
-       fastboot_okay(response_str, "");
+       fastboot_okay("");
 }
 
-void fb_nand_erase(const char *cmd, char *response)
+void fb_nand_erase(const char *cmd)
 {
        struct part_info *part;
        struct mtd_info *mtd = NULL;
        int ret;
 
-       /* initialize the response buffer */
-       response_str = response;
-
-       ret = fb_nand_lookup(cmd, response, &mtd, &part);
+       ret = fb_nand_lookup(cmd, &mtd, &part);
        if (ret) {
-               error("invalid NAND device");
-               fastboot_fail(response_str, "invalid NAND device");
+               pr_err("invalid NAND device");
+               fastboot_fail("invalid NAND device");
                return;
        }
 
@@ -208,10 +220,10 @@ void fb_nand_erase(const char *cmd, char *response)
 
        ret = _fb_nand_erase(mtd, part);
        if (ret) {
-               error("failed erasing from device %s", mtd->name);
-               fastboot_fail(response_str, "failed erasing from device");
+               pr_err("failed erasing from device %s", mtd->name);
+               fastboot_fail("failed erasing from device");
                return;
        }
 
-       fastboot_okay(response_str, "");
+       fastboot_okay("");
 }