dm: core: Update ofnode to read binman-style flash entry

At present ofnode_read_fmap_entry() reads a flash map entry in a format
which is not supported by binman. To allow use to use binman-format
descriptions, update this function.

Also add a simple test.

Signed-off-by: Simon Glass <sjg@chromium.org>

diff --git a/arch/sandbox/dts/sandbox.dts b/arch/sandbox/dts/sandbox.dts
index 48db7818d706a523f067aec072dd5f6020ac5da4..fb866e88079385ae7fbfbdb79c6bfd7af98dcffb 100644 (file)
--- a/arch/sandbox/dts/sandbox.dts
+++ b/arch/sandbox/dts/sandbox.dts
@@ -18,7 +18,7 @@
                stdout-path = "/serial";
        };
 
-       cros_ec: cros-ec@0 {
+       cros_ec: cros-ec {
                reg = <0 0>;
                compatible = "google,cros-ec-sandbox";
 
@@ -26,23 +26,23 @@
                 * This describes the flash memory within the EC. Note
                 * that the STM32L flash erases to 0, not 0xff.
                 */
-               #address-cells = <1>;
-               #size-cells = <1>;
-               flash@8000000 {
-                       reg = <0x08000000 0x20000>;
+               flash {
+                       image-pos = <0x08000000>;
+                       size = <0x20000>;
                        erase-value = <0>;
-                       #address-cells = <1>;
-                       #size-cells = <1>;
 
                        /* Information for sandbox */
                        ro {
-                               reg = <0 0xf000>;
+                               image-pos = <0>;
+                               size = <0xf000>;
                        };
                        wp-ro {
-                               reg = <0xf000 0x1000>;
+                               image-pos = <0xf000>;
+                               size = <0x1000>;
                        };
                        rw {
-                               reg = <0x10000 0x10000>;
+                               image-pos = <0x10000>;
+                               size = <0x10000>;
                        };
                };
        };

diff --git a/arch/sandbox/dts/sandbox64.dts b/arch/sandbox/dts/sandbox64.dts
index 0e32fdad9d81bdaff6365f4ac05c25c2d9506e0f..2c6d35138155db3fad0b05cfaa91ab7adc85389e 100644 (file)
--- a/arch/sandbox/dts/sandbox64.dts
+++ b/arch/sandbox/dts/sandbox64.dts
@@ -17,7 +17,7 @@
                stdout-path = "/serial";
        };
 
-       cros_ec: cros-ec@0 {
+       cros_ec: cros-ec {
                reg = <0 0 0 0>;
                compatible = "google,cros-ec-sandbox";
 
@@ -25,23 +25,23 @@
                 * This describes the flash memory within the EC. Note
                 * that the STM32L flash erases to 0, not 0xff.
                 */
-               #address-cells = <1>;
-               #size-cells = <1>;
-               flash@8000000 {
-                       reg = <0x08000000 0x20000>;
+               flash {
+                       image-pos = <0x08000000>;
+                       size = <0x20000>;
                        erase-value = <0>;
-                       #address-cells = <1>;
-                       #size-cells = <1>;
 
                        /* Information for sandbox */
                        ro {
-                               reg = <0 0xf000>;
+                               image-pos = <0>;
+                               size = <0xf000>;
                        };
                        wp-ro {
-                               reg = <0xf000 0x1000>;
+                               image-pos = <0xf000>;
+                               size = <0x1000>;
                        };
                        rw {
-                               reg = <0x10000 0x10000>;
+                               image-pos = <0x10000>;
+                               size = <0x10000>;
                        };
                };
        };

diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index ad94901fa18304a281d216094e4f0799f02ea9ea..05bccd7694ea5d1d249a6732d01d0ac99d0feb1f 100644 (file)
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -40,6 +40,35 @@
                osd0 = "/osd";
        };
 
+       cros_ec: cros-ec {
+               reg = <0 0>;
+               compatible = "google,cros-ec-sandbox";
+
+               /*
+                * This describes the flash memory within the EC. Note
+                * that the STM32L flash erases to 0, not 0xff.
+                */
+               flash {
+                       image-pos = <0x08000000>;
+                       size = <0x20000>;
+                       erase-value = <0>;
+
+                       /* Information for sandbox */
+                       ro {
+                               image-pos = <0>;
+                               size = <0xf000>;
+                       };
+                       wp-ro {
+                               image-pos = <0xf000>;
+                               size = <0x1000>;
+                       };
+                       rw {
+                               image-pos = <0x10000>;
+                               size = <0x10000>;
+                       };
+               };
+       };
+
        a-test {
                reg = <0 1>;
                compatible = "denx,u-boot-fdt-test";

diff --git a/drivers/core/of_extra.c b/drivers/core/of_extra.c
index aa48917dddf40b13aa0949851018e45a1930fba7..f1f393c3598c7e3579648bda3d949b6e031e1ce5 100644 (file)
--- a/drivers/core/of_extra.c
+++ b/drivers/core/of_extra.c
@@ -13,19 +13,30 @@
 int ofnode_read_fmap_entry(ofnode node, struct fmap_entry *entry)
 {
        const char *prop;
-       u32 reg[2];
 
-       if (ofnode_read_u32_array(node, "reg", reg, 2)) {
-               debug("Node '%s' has bad/missing 'reg' property\n",
+       if (ofnode_read_u32(node, "image-pos", &entry->offset)) {
+               debug("Node '%s' has bad/missing 'image-pos' property\n",
                      ofnode_get_name(node));
-               return -log_ret(ENOENT);
+               return log_ret(-ENOENT);
+       }
+       if (ofnode_read_u32(node, "size", &entry->length)) {
+               debug("Node '%s' has bad/missing 'size' property\n",
+                     ofnode_get_name(node));
+               return log_ret(-ENOENT);
        }
-       entry->offset = reg[0];
-       entry->length = reg[1];
        entry->used = ofnode_read_s32_default(node, "used", entry->length);
        prop = ofnode_read_string(node, "compress");
-       entry->compress_algo = prop && !strcmp(prop, "lzo") ?
-               FMAP_COMPRESS_LZO : FMAP_COMPRESS_NONE;
+       if (prop) {
+               if (!strcmp(prop, "lz4"))
+                       entry->compress_algo = FMAP_COMPRESS_LZ4;
+               else
+                       return log_msg_ret("Unknown compression algo",
+                                          -EINVAL);
+       } else {
+               entry->compress_algo = FMAP_COMPRESS_NONE;
+       }
+       entry->unc_length = ofnode_read_s32_default(node, "uncomp-size",
+                                                   entry->length);
        prop = ofnode_read_string(node, "hash");
        if (prop)
                entry->hash_size = strlen(prop);

diff --git a/drivers/misc/cros_ec.c b/drivers/misc/cros_ec.c
index 6f299d407a4c12bcd8136f0f29d73c67043b0153..c5ac03d027dad2c5cefd2da29d95031d1d038695 100644 (file)
--- a/drivers/misc/cros_ec.c
+++ b/drivers/misc/cros_ec.c
@@ -263,8 +263,8 @@ static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
  * @return number of bytes in response, or -ve on error
  */
 static int ec_command_inptr(struct cros_ec_dev *dev, uint8_t cmd,
-               int cmd_version, const void *dout, int dout_len, uint8_t **dinp,
-               int din_len)
+                           int cmd_version, const void *dout, int dout_len,
+                           uint8_t **dinp, int din_len)
 {
        uint8_t *din = NULL;
        int len;
@@ -409,7 +409,7 @@ int cros_ec_read_build_info(struct cros_ec_dev *dev, char **strp)
 }
 
 int cros_ec_read_current_image(struct cros_ec_dev *dev,
-               enum ec_current_image *image)
+                              enum ec_current_image *image)
 {
        struct ec_response_get_version *r;
 
@@ -422,7 +422,7 @@ int cros_ec_read_current_image(struct cros_ec_dev *dev,
 }
 
 static int cros_ec_wait_on_hash_done(struct cros_ec_dev *dev,
-                                 struct ec_response_vboot_hash *hash)
+                                    struct ec_response_vboot_hash *hash)
 {
        struct ec_params_vboot_hash p;
        ulong start;
@@ -446,7 +446,7 @@ static int cros_ec_wait_on_hash_done(struct cros_ec_dev *dev,
 
 
 int cros_ec_read_hash(struct cros_ec_dev *dev,
-               struct ec_response_vboot_hash *hash)
+                     struct ec_response_vboot_hash *hash)
 {
        struct ec_params_vboot_hash p;
        int rv;
@@ -515,7 +515,7 @@ static int cros_ec_invalidate_hash(struct cros_ec_dev *dev)
 }
 
 int cros_ec_reboot(struct cros_ec_dev *dev, enum ec_reboot_cmd cmd,
-               uint8_t flags)
+                  uint8_t flags)
 {
        struct ec_params_reboot_ec p;
 
@@ -601,8 +601,8 @@ int cros_ec_clear_host_events(struct cros_ec_dev *dev, uint32_t events)
 }
 
 int cros_ec_flash_protect(struct cros_ec_dev *dev,
-                      uint32_t set_mask, uint32_t set_flags,
-                      struct ec_response_flash_protect *resp)
+                         uint32_t set_mask, uint32_t set_flags,
+                         struct ec_response_flash_protect *resp)
 {
        struct ec_params_flash_protect params;
 
@@ -742,7 +742,8 @@ int cros_ec_flash_erase(struct cros_ec_dev *dev, uint32_t offset, uint32_t size)
  * @return 0 if ok, -1 on error
  */
 static int cros_ec_flash_write_block(struct cros_ec_dev *dev,
-               const uint8_t *data, uint32_t offset, uint32_t size)
+                                    const uint8_t *data, uint32_t offset,
+                                    uint32_t size)
 {
        struct ec_params_flash_write *p;
        int ret;
@@ -802,7 +803,7 @@ static int cros_ec_data_is_erased(const uint32_t *data, int size)
  * @param info Pointer to output flash info struct
  */
 int cros_ec_read_flashinfo(struct cros_ec_dev *dev,
-                         struct ec_response_flash_info *info)
+                          struct ec_response_flash_info *info)
 {
        int ret;
 
@@ -815,7 +816,7 @@ int cros_ec_read_flashinfo(struct cros_ec_dev *dev,
 }
 
 int cros_ec_flash_write(struct cros_ec_dev *dev, const uint8_t *data,
-                    uint32_t offset, uint32_t size)
+                       uint32_t offset, uint32_t size)
 {
        uint32_t burst = cros_ec_flash_write_burst_size(dev);
        uint32_t end, off;
@@ -832,7 +833,7 @@ int cros_ec_flash_write(struct cros_ec_dev *dev, const uint8_t *data,
                /* If the data is empty, there is no point in programming it */
                todo = min(end - off, burst);
                if (dev->optimise_flash_write &&
-                               cros_ec_data_is_erased((uint32_t *)data, todo))
+                   cros_ec_data_is_erased((uint32_t *)data, todo))
                        continue;
 
                ret = cros_ec_flash_write_block(dev, data, off, todo);
@@ -859,7 +860,7 @@ int cros_ec_flash_write(struct cros_ec_dev *dev, const uint8_t *data,
  * @return 0 if ok, -1 on error
  */
 static int cros_ec_flash_read_block(struct cros_ec_dev *dev, uint8_t *data,
-                                uint32_t offset, uint32_t size)
+                                   uint32_t offset, uint32_t size)
 {
        struct ec_params_flash_read p;
 
@@ -871,7 +872,7 @@ static int cros_ec_flash_read_block(struct cros_ec_dev *dev, uint8_t *data,
 }
 
 int cros_ec_flash_read(struct cros_ec_dev *dev, uint8_t *data, uint32_t offset,
-                   uint32_t size)
+                      uint32_t size)
 {
        uint32_t burst = cros_ec_flash_write_burst_size(dev);
        uint32_t end, off;
@@ -888,8 +889,8 @@ int cros_ec_flash_read(struct cros_ec_dev *dev, uint8_t *data, uint32_t offset,
        return 0;
 }
 
-int cros_ec_flash_update_rw(struct cros_ec_dev *dev,
-                        const uint8_t *image, int image_size)
+int cros_ec_flash_update_rw(struct cros_ec_dev *dev, const uint8_t *image,
+                           int image_size)
 {
        uint32_t rw_offset, rw_size;
        int ret;

diff --git a/include/dm/of_extra.h b/include/dm/of_extra.h
index 97988b666324d42afd3c634fc8b030dc31baa479..ca15df21b067b03006c8ef5da9b351d427ae1f4b 100644 (file)
--- a/include/dm/of_extra.h
+++ b/include/dm/of_extra.h
@@ -11,7 +11,7 @@
 
 enum fmap_compress_t {
        FMAP_COMPRESS_NONE,
-       FMAP_COMPRESS_LZO,
+       FMAP_COMPRESS_LZ4,
 };
 
 enum fmap_hash_t {
@@ -26,6 +26,7 @@ struct fmap_entry {
        uint32_t length;
        uint32_t used;                  /* Number of bytes used in region */
        enum fmap_compress_t compress_algo;     /* Compression type */
+       uint32_t unc_length;                    /* Uncompressed length */
        enum fmap_hash_t hash_algo;             /* Hash algorithm */
        const uint8_t *hash;                    /* Hash value */
        int hash_size;                          /* Hash size */

diff --git a/test/dm/ofnode.c b/test/dm/ofnode.c
index 907d1ddbdb6f1f48f428d68ee121b8eb9c79f09d..745de50c7bae19b91ee5b8563001170d72f827f7 100644 (file)
--- a/test/dm/ofnode.c
+++ b/test/dm/ofnode.c
@@ -2,6 +2,7 @@
 
 #include <common.h>
 #include <dm.h>
+#include <dm/of_extra.h>
 #include <dm/test.h>
 #include <test/ut.h>
 
@@ -42,3 +43,18 @@ static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
        return 0;
 }
 DM_TEST(dm_test_ofnode_by_prop_value, DM_TESTF_SCAN_FDT);
+
+static int dm_test_ofnode_fmap(struct unit_test_state *uts)
+{
+       struct fmap_entry entry;
+       ofnode node;
+
+       node = ofnode_path("/cros-ec/flash");
+       ut_assert(ofnode_valid(node));
+       ut_assertok(ofnode_read_fmap_entry(node, &entry));
+       ut_asserteq(0x08000000, entry.offset);
+       ut_asserteq(0x20000, entry.length);
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_fmap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);