ARM: rockchip: add smp functionality

Some SoCs need parts of their sram for special purposes. So while being part of the peripheral, it should not be part of the genpool controlling the sram.

Therefore add an option mmio-sram-reserved to keep arbitrary portions of the sram from general usage.

Suggested-by Rob Herring <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

Tested-by Ulrich Prinz <[email protected]>

---
 Documentation/devicetree/bindings/misc/sram.txt |    8 ++++++++
 1 file changed, 8 insertions(+)

Documentation/devicetree/bindings/misc/sram.txt +8 -1

index 4d0a00e..09ee7a3 100644
@@ -8,9 +8,17 @@ Required properties:
 
 - reg : SRAM iomem address range
 
+Optional properties:
+
+- mmio-sram-reserved: ordered list of reserved chunks inside the sram that
+  should not be used by the operating system.
+  Format is <base size>, <base size>, ...; with base being relative to the
+  reg property base.
+
 Example:
 
 sram: sram at 5c000000 {
        compatible = "mmio-sram";
        reg = <0x5c000000 0x40000>; /* 256 KiB SRAM at address 0x5c000000 */
+       mmio-sram-reserved = <0x0 0x100>; /* reserve 0x5c000000-0x5c000100 */
 };
--

1.7.10.4

This implements support for the mmio-sram-reserved option to keep the genpool from using these areas.

Suggested-by Rob Herring <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

Tested-by Ulrich Prinz <[email protected]>

---
 drivers/misc/sram.c |  118 +++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 110 insertions(+), 8 deletions(-)

drivers/misc/sram.c +12 -4

index afe66571..7fb60f3 100644
@@ -36,13 +36,23 @@ struct sram_dev {
 	struct clk *clk;
 };
 
+struct sram_reserve {
+	unsigned long start;
+	unsigned long size;
+};
+
 static int sram_probe(struct platform_device *pdev)
 {
 	void __iomem *virt_base;
 	struct sram_dev *sram;
 	struct resource *res;
-	unsigned long size;
-	int ret;
+	unsigned long size, cur_start, cur_size;
+	const __be32 *reserved_list = NULL;
+	int reserved_size = 0;
+	struct sram_reserve *rblocks;
+	unsigned int nblocks;
+	int ret = 0;
+	int i;
 
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	virt_base = devm_ioremap_resource(&pdev->dev, res);

@@ -65,19 +75,111 @@ static int sram_probe(struct platform_device *pdev)
 	if (!sram->pool)
 		return -ENOMEM;
 
-	ret = gen_pool_add_virt(sram->pool, (unsigned long)virt_base,
-				res->start, size, -1);

drivers/misc/sram.c +13 -0

+			if (!reserved_size || reserved_size % 2) {
+				dev_warn(&pdev->dev, "wrong number of arguments in mmio-sram-reserved\n");
+				reserved_list = NULL;
+				reserved_size = 0;
+			}
+		}
+	}
+
+	/*
+	 * We need an additional block to mark the end of the memory region
+	 * after the reserved blocks from the dt are processed.
+	 */
+	nblocks = reserved_size / 2 + 1;

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper function that also centralises strict sanity checking and DTB format details.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---
Hi Mark,
did you mean it like this? I've tested it with the sram-reserve change and it made the part of the determining the number elements a lot nicer :-)

 drivers/of/base.c  |   32 ++++++++++++++++++++++++++++++++
 include/linux/of.h |    8 ++++++++
 2 files changed, 40 insertions(+)

drivers/of/base.c +4 -0

index f807d0e..0f40ea5 100644
@@ -920,6 +920,38 @@ int of_property_read_u32_index(const struct device_node *np,
 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
 
 /**
+ * of_property_count_u32_elems - Count the number of u32 values in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.

drivers/of/base.c +8 -0

+               return -EINVAL;
+       }
+
+       return len / elem_size;
+}
+EXPORT_SYMBOL_GPL(of_property_count_u32_elems);
+
+/**
  * of_property_read_u8_array - Find and read an array of u8 from a property.
  *
  * @np:                device node from which the property value is to be read.

include/linux/of.h +8 -1

index 276c546..5794942 100644
@@ -253,6 +253,8 @@ extern struct property *of_find_property(const struct device_node *np,
 extern int of_property_read_u32_index(const struct device_node *np,
                                       const char *propname,
                                       u32 index, u32 *out_value);
+extern int of_property_count_u32_elems(const struct device_node *np,
+                                      const char *propname);
 extern int of_property_read_u8_array(const struct device_node *np,
                        const char *propname, u8 *out_values, size_t sz);
 extern int of_property_read_u16_array(const struct device_node *np,

@@ -432,6 +434,12 @@ static inline int of_property_read_u32_index(const struct device_node *np,
        return -ENOSYS;
 }
 
+static inline int of_property_count_u32_elems(const struct device_node *np,
+                       const char *propname)
+{
+       return -ENOSYS;
+}
+
 static inline int of_property_read_u8_array(const struct device_node *np,
                        const char *propname, u8 *out_values, size_t sz)
 {
--

1.7.10.4

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper function that also centralises strict sanity checking and DTB format details.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---
Hi Mark,
did you mean it like this? I've tested it with the sram-reserve change and it made the part of the determining the number elements a lot nicer :-)

 drivers/of/base.c  |   32 ++++++++++++++++++++++++++++++++
 include/linux/of.h |    8 ++++++++
 2 files changed, 40 insertions(+)

drivers/of/base.c +20 -0

index f807d0e..0f40ea5 100644
@@ -920,6 +920,38 @@ int of_property_read_u32_index(const struct device_node *np,
 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
 
 /**
+ * of_property_count_u32_elems - Count the number of u32 values in a property
+ *
+ * @np:		device node from which the property value is to be read.
+ * @propname:	name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u32 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u32 and -ENODATA if the
+ * property does not have a value.
+ */
+int of_property_count_u32_elems(const struct device_node *np,
+				const char *propname)
+{
+	int elem_size = sizeof(u32);
+	int len;
+	struct property *prop = of_find_property(np, propname, &len);
+
+	if (!prop)
+		return -EINVAL;
+	if (!prop->value)

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---
changes since v1:
address comments from Rob Herring and Mark Rutland:
- provide a helper and a set of wrappers for u8-u64
- get rid of extra len variable, prop->length is enough
- include node name in error message

 drivers/of/base.c  |   98 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/of.h |   32 +++++++++++++++++
 2 files changed, 130 insertions(+)

drivers/of/base.c +0 -0

index f807d0e..b6e6d4a 100644
@@ -862,6 +862,104 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 EXPORT_SYMBOL(of_find_node_by_phandle);

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---
changes since v1:
address comments from Rob Herring and Mark Rutland:
- provide a helper and a set of wrappers for u8-u64
- get rid of extra len variable, prop->length is enough
- include node name in error message

 drivers/of/base.c  |   98 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/of.h |   32 +++++++++++++++++
 2 files changed, 130 insertions(+)

drivers/of/base.c +14 -0

index f807d0e..b6e6d4a 100644
@@ -862,6 +862,104 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 EXPORT_SYMBOL(of_find_node_by_phandle);
 
 /**
+ * of_count_property_elems_of_size - Count the number of elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ * @elem_size: size of the individual element
+ */
+static int of_count_property_elems_of_size(const struct device_node *np,
+                               const char *propname, int elem_size)
+{
+       struct property *prop = of_find_property(np, propname, NULL);
+
+       if (!prop)
+               return -EINVAL;
+       if (!prop->value)

drivers/of/base.c +8 -0

+
+/**
+ * of_property_count_u8_elems - Count the number of u8 elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u8 elements

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

changes since v3:
address more comments from Rob Herring
- export the base function and inline the type-specific wrappers changes since v2:
address more comments from Mark Rutland
- switch to of_property_count_elems_of_size
- use full_name instead of name in error message changes since v1:
address comments from Rob Herring and Mark Rutland:
- provide a helper and a set of wrappers for u8-u64
- get rid of extra len variable, prop->length is enough
- include node name in error message

Mark, does your Reviewed-by holds for this variant too?

 drivers/of/base.c  |   32 ++++++++++++++++++++++
 include/linux/of.h |   76 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+)

drivers/of/base.c +32 -0

index f807d0e..21646c0 100644
@@ -862,6 +862,38 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 EXPORT_SYMBOL(of_find_node_by_phandle);
 
 /**
+ * of_property_count_elems_of_size - Count the number of elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ * @elem_size: size of the individual element
+ *
+ * Search for a property in a device node and count the number of elements of
+ * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
+ * property does not exist or its length does not match a multiple of u16 and
+ * -ENODATA if the property does not have a value.
+ */
+int of_property_count_elems_of_size(const struct device_node *np,
+                               const char *propname, int elem_size)
+{
+       struct property *prop = of_find_property(np, propname, NULL);
+
+       if (!prop)
+               return -EINVAL;
+       if (!prop->value)
+               return -ENODATA;
+
+       if (prop->length % elem_size != 0) {
+               pr_err("size of %s in node %s is not a multiple of %d\n",
+                      propname, np->full_name, elem_size);
+               return -EINVAL;
+       }
+
+       return prop->length / elem_size;
+}
+EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
+
+/**
  * of_find_property_value_of_size
  *
  * @np:                device node from which the property value is to be read.

include/linux/of.h +76 -1

index 276c546..293920d 100644
@@ -250,6 +250,8 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                         const char *name,
                                         int *lenp);
+extern int of_property_count_elems_of_size(const struct device_node *np,
+                               const char *propname, int elem_size);
 extern int of_property_read_u32_index(const struct device_node *np,
                                       const char *propname,
                                       u32 index, u32 *out_value);

@@ -426,6 +428,12 @@ static inline struct device_node *of_find_compatible_node(
        return NULL;
 }
 
+static inline int of_property_count_elems_of_size(const struct device_node *np,
+                       const char *propname, int elem_size)
+{
+       return -ENOSYS;
+}
+
 static inline int of_property_read_u32_index(const struct device_node *np,
                        const char *propname, u32 index, u32 *out_value)
 {

@@ -565,6 +573,74 @@ static inline int of_node_to_nid(struct device_node *device) { return 0; }
 #endif
 
 /**
+ * of_property_count_u8_elems - Count the number of u8 elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u8 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u8 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u8_elems(const struct device_node *np,
+                               const char *propname)
+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u8));
+}
+
+/**
+ * of_property_count_u16_elems - Count the number of u16 elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u16 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u16 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u16_elems(const struct device_node *np,
+                               const char *propname)
+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u16));
+}
+
+/**
+ * of_property_count_u32_elems - Count the number of u32 elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u32 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u32 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u32_elems(const struct device_node *np,
+                               const char *propname)
+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u32));
+}
+
+/**
+ * of_property_count_u64_elems - Count the number of u64 elements in a property
+ *
+ * @np:                device node from which the property value is to be read.
+ * @propname:  name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u64 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u64 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u64_elems(const struct device_node *np,
+                               const char *propname)
+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u64));
+}
+
+/**
  * of_property_read_bool - Findfrom a property
  * @np:                device node from which the property value is to be read.
  * @propname:  name of the property to be searched.
--

1.7.10.4

Quoted 6 lines

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Quoted 3 lines

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

Quoted 190 lines

changes since v3:
address more comments from Rob Herring
- export the base function and inline the type-specific wrappers changes since v2:
address more comments from Mark Rutland
- switch to of_property_count_elems_of_size
- use full_name instead of name in error message changes since v1:
address comments from Rob Herring and Mark Rutland:
- provide a helper and a set of wrappers for u8-u64
- get rid of extra len variable, prop->length is enough
- include node name in error message

Mark, does your Reviewed-by holds for this variant too?

 drivers/of/base.c  |   32 ++++++++++++++++++++++
 include/linux/of.h |   76

++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 108 insertions(+)

drivers/of/base.c +0 -0

index f807d0e..21646c0 100644
@@ -862,6 +862,38 @@ struct device_node *of_find_node_by_phandle(phandle

handle)>
EXPORT_SYMBOL(of_find_node_by_phandle);

/**

+ * of_property_count_elems_of_size - Count the number of elements in a property + *
+ * @np: device node from which the property value is to be
read. + * @propname: name of the property to be searched.
+ * @elem_size: size of the individual element
+ *
+ * Search for a property in a device node and count the number of elements of + * size elem_size in it. Returns number of elements on sucess, -EINVAL if the + * property does not exist or its length does not match a multiple of u16 and + * -ENODATA if the property does not have a value.
+ */

drivers/of/base.c +21 -0

+int of_property_count_elems_of_size(const struct device_node *np,
+                               const char *propname, int elem_size)
+{
+       struct property *prop = of_find_property(np, propname, NULL);
+
+       if (!prop)
+               return -EINVAL;
+       if (!prop->value)
+               return -ENODATA;
+
+       if (prop->length % elem_size != 0) {
+               pr_err("size of %s in node %s is not a multiple of %d\n",
+                      propname, np->full_name, elem_size);
+               return -EINVAL;
+       }
+
+       return prop->length / elem_size;
+}
+EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
+
+/**
 
  * of_find_property_value_of_size
  *
  * @np:                device node from which the property value is to be
  read.> 

include/linux/of.h +2 -0

index 276c546..293920d 100644
@@ -250,6 +250,8 @@ extern struct device_node *of_find_node_with_property(
 
 extern struct property *of_find_property(const struct device_node *np,
 
                                         const char *name,
                                         int *lenp);
 
+extern int of_property_count_elems_of_size(const struct device_node *np,
+                               const char *propname, int elem_size);

extern int of_property_read_u32_index(const struct device_node *np,

const char *propname, u32 index, u32 *out_value);

include/linux/of.h +1 -0

@@ -426,6 +428,12 @@ static inline struct device_node
 *of_find_compatible_node(> 
        return NULL;
 
 }
 
+static inline int of_property_count_elems_of_size(const struct

device_node *np, + const char *propname, int
elem_size)

include/linux/of.h +5 -0

+{
+       return -ENOSYS;
+}
+
 
 static inline int of_property_read_u32_index(const struct device_node
 *np,
 
                        const char *propname, u32 index, u32 *out_value)
 
 {

@@ -565,6 +573,74 @@ static inline int of_node_to_nid(struct device_node
 *device) { return 0; }> 
 #endif
 
 /**
 
+ * of_property_count_u8_elems - Count the number of u8 elements in a

property + *
+ * @np: device node from which the property value is to be
read. + * @propname: name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u8 elements + * in it. Returns number of elements on sucess, -EINVAL if the property does + * not exist or its length does not match a multiple of u8 and -ENODATA if the + * property does not have a value.
+ */
+static inline int of_property_count_u8_elems(const struct device_node *np,

include/linux/of.h +7 -0

+                               const char *propname)
+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u8));
+}
+
+/**
+ * of_property_count_u16_elems - Count the number of u16 elements in a

property + *
+ * @np: device node from which the property value is to be
read. + * @propname: name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u16 elements + * in it. Returns number of elements on sucess, -EINVAL if the property does + * not exist or its length does not match a multiple of u16 and -ENODATA if the + * property does not have a value.
+ */
+static inline int of_property_count_u16_elems(const struct device_node
*np, + const char *propname)

include/linux/of.h +6 -0

+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u16));
+}
+
+/**
+ * of_property_count_u32_elems - Count the number of u32 elements in a

property + *
+ * @np: device node from which the property value is to be
read. + * @propname: name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u32 elements + * in it. Returns number of elements on sucess, -EINVAL if the property does + * not exist or its length does not match a multiple of u32 and -ENODATA if the + * property does not have a value.
+ */
+static inline int of_property_count_u32_elems(const struct device_node
*np, + const char *propname)

include/linux/of.h +6 -0

+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u32));
+}
+
+/**
+ * of_property_count_u64_elems - Count the number of u64 elements in a

property + *
+ * @np: device node from which the property value is to be
read. + * @propname: name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u64 elements + * in it. Returns number of elements on sucess, -EINVAL if the property does + * not exist or its length does not match a multiple of u64 and -ENODATA if the + * property does not have a value.
+ */
+static inline int of_property_count_u64_elems(const struct device_node
*np, + const char *propname)

include/linux/of.h +5 -1

+{
+       return of_property_count_elems_of_size(np, propname, sizeof(u64));
+}
+
+/**
 
  * of_property_read_bool - Findfrom a property
  * @np:                device node from which the property value is to be
  read. * @propname:  name of the property to be searched.
 
--

1.7.10.4

Quoted 6 lines · Heiko St??bner

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Quoted 3 lines

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

On Sat, 18 Jan 2014 09:07:30 -0600, Rob Herring <[email protected]>

Quoted 7 lines · Heiko St??bner

Quoted 6 lines

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Quoted 5 lines

Quoted 3 lines

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

I'll take that as an acked-by. Merged, thanks.

Hi Grant,

Quoted 1 line · On Tuesday, 4. February 2014 17:30:34 Grant Likely wrote:

On Sat, 18 Jan 2014 09:07:30 -0600, Rob Herring <[email protected]>

Quoted 13 lines · wrote:

Quoted 12 lines · Heiko St????bner

Quoted 9 lines

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions for u8, u16, u32 and u64.

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

Quoted 1 line

I'll take that as an acked-by. Merged, thanks.

before you taking this patch, I was planning on simply sending this as part of my rockchip-smp series - as I'm currently the only user of it :-) .

This going through your tree is most likely the better way, but now I need it to somehow make its way into arm-soc too ... I guess some sort of stable branch arm-soc could pull?

Quoted 7 lines

Hi Grant,

Quoted 1 line · On Tuesday, 4. February 2014 17:30:34 Grant Likely wrote:

On Sat, 18 Jan 2014 09:07:30 -0600, Rob Herring <[email protected]>

Quoted 1 line · wrote:

Quoted 1 line

On Sat, Jan 18, 2014 at 6:02 AM, Heiko St????bner <[email protected]>

Quoted 20 lines

Quoted 8 lines

Quoted 8 lines

Quoted 8 lines

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations
add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions
for u8, u16, u32 and u64.

Quoted 7 lines

Quoted 5 lines

Quoted 3 lines

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

I'll take that as an acked-by. Merged, thanks.

before you taking this patch, I was planning on simply sending this as part of my rockchip-smp series - as I'm currently the only user of it :-) .

Quoted 3 lines

This going through your tree is most likely the better way, but now I need it to somehow make its way into arm-soc too ... I guess some sort of stable branch arm-soc could pull?

Nah, I'll drop it from my tree. Add my acked-by and merge it via arm-soc.

Am Mittwoch, 5. Februar 2014, 12:06:52 schrieb Grant Likely:

Quoted 8 lines · Heiko St????bner

Quoted 7 lines

Hi Grant,

Quoted 1 line · On Tuesday, 4. February 2014 17:30:34 Grant Likely wrote:

On Sat, 18 Jan 2014 09:07:30 -0600, Rob Herring <[email protected]>

Quoted 1 line · wrote:

Quoted 1 line

On Sat, Jan 18, 2014 at 6:02 AM, Heiko St????????bner <[email protected]>

Quoted 24 lines · wrote:

Quoted 23 lines

Quoted 8 lines

Quoted 8 lines

Quoted 8 lines

The need to know the number of array elements in a property is a common pattern. To prevent duplication of open-coded implementations
add a helper static function that also centralises strict sanity checking and DTB format details, as well as a set of wrapper functions
for u8, u16, u32 and u64.

Quoted 7 lines

Quoted 5 lines

Quoted 3 lines

Suggested-by Mark Rutland <[email protected]>

Signed-off-by Heiko Stuebner <[email protected]>

---

Looks good. Do you plan to convert some users to use this?

I'll take that as an acked-by. Merged, thanks.

before you taking this patch, I was planning on simply sending this as part of my rockchip-smp series - as I'm currently the only user of it :-) .

This going through your tree is most likely the better way, but now I need it to somehow make its way into arm-soc too ... I guess some sort of stable branch arm-soc could pull?

Quoted 2 lines

Nah, I'll drop it from my tree. Add my acked-by and merge it via arm-soc.

As I said on IRC, now it seems like you can keep this patch in your tree :-)

If we're really going with reserved-memory like you suggested in the rockchip- smp series it removes the need to count u32-elements in a property for me, as the reserved blocks move into individual subnodes.