Merge tag 'devicetree-for-linus' of git://git.secretlab.ca/git/linux

Pull device tree core updates from Grant Likely:
 "Generally minor changes.  A bunch of bug fixes, particularly for
  initialization and some refactoring.  Most notable change if feeding
  the entire flattened tree into the random pool at boot.  May not be
  significant, but shouldn't hurt either"

Tim Bird questions whether the boot time cost of the random feeding may
be noticeable.  And "add_device_randomness()" is definitely not some
speed deamon of a function.

* tag 'devicetree-for-linus' of git://git.secretlab.ca/git/linux:
  of/platform: add error reporting to of_amba_device_create()
  irq/of: Fix comment typo for irq_of_parse_and_map
  of: Feed entire flattened device tree into the random pool
  of/fdt: Clean up casting in unflattening path
  of/fdt: Remove duplicate memory clearing on FDT unflattening
  gpio: implement gpio-ranges binding document fix
  of: call __of_parse_phandle_with_args from of_parse_phandle
  of: introduce of_parse_phandle_with_fixed_args
  of: move of_parse_phandle()
  of: move documentation of of_parse_phandle_with_args
  of: Fix missing memory initialization on FDT unflattening
  of: consolidate definition of early_init_dt_alloc_memory_arch()
  of: Make of_get_phy_mode() return int i.s.o. const int
  include: dt-binding: input: create a DT header defining key codes.
  of/platform: Staticize of_platform_device_create_pdata()
  of: Specify initrd location using 64-bit
  dt: Typo fix
  OF: make of_property_for_each_{u32|string}() use parameters if OF is not enabled

6 files changed, 211 insertions, 116 deletions

diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c
index ba9876ffb017..0dfaf20e4dad 100644
--- a/drivers/gpio/gpiolib-of.c
+++ b/drivers/gpio/gpiolib-of.c
@@ -195,8 +195,8 @@ static void of_gpiochip_add_pin_range(struct gpio_chip *chip)
                 return;
 
         for (;; index++) {
-                ret = of_parse_phandle_with_args(np, "gpio-ranges",
-                                "#gpio-range-cells", index, &pinspec);
+                ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
+                                index, &pinspec);
                 if (ret)
                         break;
 
diff --git a/drivers/of/base.c b/drivers/of/base.c
index e486e416d5a0..865d3f66c86b 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -1176,65 +1176,10 @@ int of_property_count_strings(struct device_node *np, const char *propname)
 }
 EXPORT_SYMBOL_GPL(of_property_count_strings);
 
-/**
- * of_parse_phandle - Resolve a phandle property to a device_node pointer
- * @np: Pointer to device node holding phandle property
- * @phandle_name: Name of property holding a phandle value
- * @index: For properties holding a table of phandles, this is the index into
- *         the table
- *
- * Returns the device_node pointer with refcount incremented.  Use
- * of_node_put() on it when done.
- */
-struct device_node *of_parse_phandle(const struct device_node *np,
-                                     const char *phandle_name, int index)
-{
-        const __be32 *phandle;
-        int size;
-
-        phandle = of_get_property(np, phandle_name, &size);
-        if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
-                return NULL;
-
-        return of_find_node_by_phandle(be32_to_cpup(phandle + index));
-}
-EXPORT_SYMBOL(of_parse_phandle);
-
-/**
- * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
- * @np:         pointer to a device tree node containing a list
- * @list_name:  property name that contains a list
- * @cells_name: property name that specifies phandles' arguments count
- * @index:      index of a phandle to parse out
- * @out_args:   optional pointer to output arguments structure (will be filled)
- *
- * This function is useful to parse lists of phandles and their arguments.
- * Returns 0 on success and fills out_args, on error returns appropriate
- * errno value.
- *
- * Caller is responsible to call of_node_put() on the returned out_args->node
- * pointer.
- *
- * Example:
- *
- * phandle1: node1 {
- *      #list-cells = <2>;
- * }
- *
- * phandle2: node2 {
- *      #list-cells = <1>;
- * }
- *
- * node3 {
- *      list = <&phandle1 1 2 &phandle2 3>;
- * }
- *
- * To get a device_node of the `node2' node you may call this:
- * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
- */
 static int __of_parse_phandle_with_args(const struct device_node *np,
                                         const char *list_name,
-                                        const char *cells_name, int index,
+                                        const char *cells_name,
+                                        int cell_count, int index,
                                         struct of_phandle_args *out_args)
 {
         const __be32 *list, *list_end;
@@ -1262,19 +1207,32 @@ static int __of_parse_phandle_with_args(const struct device_node *np,
                 if (phandle) {
                         /*
                          * Find the provider node and parse the #*-cells
-                         * property to determine the argument length
+                         * property to determine the argument length.
+                         *
+                         * This is not needed if the cell count is hard-coded
+                         * (i.e. cells_name not set, but cell_count is set),
+                         * except when we're going to return the found node
+                         * below.
                          */
-                        node = of_find_node_by_phandle(phandle);
-                        if (!node) {
-                                pr_err("%s: could not find phandle\n",
-                                         np->full_name);
-                                goto err;
+                        if (cells_name || cur_index == index) {
+                                node = of_find_node_by_phandle(phandle);
+                                if (!node) {
+                                        pr_err("%s: could not find phandle\n",
+                                                np->full_name);
+                                        goto err;
+                                }
                         }
-                        if (of_property_read_u32(node, cells_name, &count)) {
-                                pr_err("%s: could not get %s for %s\n",
-                                         np->full_name, cells_name,
-                                         node->full_name);
-                                goto err;
+
+                        if (cells_name) {
+                                if (of_property_read_u32(node, cells_name,
+                                                         &count)) {
+                                        pr_err("%s: could not get %s for %s\n",
+                                                np->full_name, cells_name,
+                                                node->full_name);
+                                        goto err;
+                                }
+                        } else {
+                                count = cell_count;
                         }
 
                         /*
@@ -1334,17 +1292,117 @@ static int __of_parse_phandle_with_args(const struct device_node *np,
         return rc;
 }
 
+/**
+ * of_parse_phandle - Resolve a phandle property to a device_node pointer
+ * @np: Pointer to device node holding phandle property
+ * @phandle_name: Name of property holding a phandle value
+ * @index: For properties holding a table of phandles, this is the index into
+ *         the table
+ *
+ * Returns the device_node pointer with refcount incremented.  Use
+ * of_node_put() on it when done.
+ */
+struct device_node *of_parse_phandle(const struct device_node *np,
+                                     const char *phandle_name, int index)
+{
+        struct of_phandle_args args;
+
+        if (index < 0)
+                return NULL;
+
+        if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
+                                         index, &args))
+                return NULL;
+
+        return args.np;
+}
+EXPORT_SYMBOL(of_parse_phandle);
+
+/**
+ * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
+ * @np:         pointer to a device tree node containing a list
+ * @list_name:  property name that contains a list
+ * @cells_name: property name that specifies phandles' arguments count
+ * @index:      index of a phandle to parse out
+ * @out_args:   optional pointer to output arguments structure (will be filled)
+ *
+ * This function is useful to parse lists of phandles and their arguments.
+ * Returns 0 on success and fills out_args, on error returns appropriate
+ * errno value.
+ *
+ * Caller is responsible to call of_node_put() on the returned out_args->node
+ * pointer.
+ *
+ * Example:
+ *
+ * phandle1: node1 {
+ *      #list-cells = <2>;
+ * }
+ *
+ * phandle2: node2 {
+ *      #list-cells = <1>;
+ * }
+ *
+ * node3 {
+ *      list = <&phandle1 1 2 &phandle2 3>;
+ * }
+ *
+ * To get a device_node of the `node2' node you may call this:
+ * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
+ */
 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
                                 const char *cells_name, int index,
                                 struct of_phandle_args *out_args)
 {
         if (index < 0)
                 return -EINVAL;
-        return __of_parse_phandle_with_args(np, list_name, cells_name, index, out_args);
+        return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
+                                            index, out_args);
 }
 EXPORT_SYMBOL(of_parse_phandle_with_args);
 
 /**
+ * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
+ * @np:         pointer to a device tree node containing a list
+ * @list_name:  property name that contains a list
+ * @cell_count: number of argument cells following the phandle
+ * @index:      index of a phandle to parse out
+ * @out_args:   optional pointer to output arguments structure (will be filled)
+ *
+ * This function is useful to parse lists of phandles and their arguments.
+ * Returns 0 on success and fills out_args, on error returns appropriate
+ * errno value.
+ *
+ * Caller is responsible to call of_node_put() on the returned out_args->node
+ * pointer.
+ *
+ * Example:
+ *
+ * phandle1: node1 {
+ * }
+ *
+ * phandle2: node2 {
+ * }
+ *
+ * node3 {
+ *      list = <&phandle1 0 2 &phandle2 2 3>;
+ * }
+ *
+ * To get a device_node of the `node2' node you may call this:
+ * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
+ */
+int of_parse_phandle_with_fixed_args(const struct device_node *np,
+                                const char *list_name, int cell_count,
+                                int index, struct of_phandle_args *out_args)
+{
+        if (index < 0)
+                return -EINVAL;
+        return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
+                                           index, out_args);
+}
+EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
+
+/**
  * of_count_phandle_with_args() - Find the number of phandles references in a property
  * @np:         pointer to a device tree node containing a list
  * @list_name:  property name that contains a list
@@ -1362,7 +1420,8 @@ EXPORT_SYMBOL(of_parse_phandle_with_args);
 int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
                                 const char *cells_name)
 {
-        return __of_parse_phandle_with_args(np, list_name, cells_name, -1, NULL);
+        return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1,
+                                            NULL);
 }
 EXPORT_SYMBOL(of_count_phandle_with_args);
 
@@ -1734,6 +1793,7 @@ void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
                 ap = dt_alloc(sizeof(*ap) + len + 1, 4);
                 if (!ap)
                         continue;
+                memset(ap, 0, sizeof(*ap) + len + 1);
                 ap->alias = start;
                 of_alias_add(ap, np, id, start, len);
         }
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index 4fb06f3e7b3c..229dd9d69e18 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -11,12 +11,14 @@
 
 #include <linux/kernel.h>
 #include <linux/initrd.h>
+#include <linux/memblock.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_fdt.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
+#include <linux/random.h>
 
 #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
 #ifdef CONFIG_PPC
@@ -125,13 +127,13 @@ int of_fdt_match(struct boot_param_header *blob, unsigned long node,
         return score;
 }
 
-static void *unflatten_dt_alloc(unsigned long *mem, unsigned long size,
+static void *unflatten_dt_alloc(void **mem, unsigned long size,
                                        unsigned long align)
 {
         void *res;
 
-        *mem = ALIGN(*mem, align);
-        res = (void *)*mem;
+        *mem = PTR_ALIGN(*mem, align);
+        res = *mem;
         *mem += size;
 
         return res;
@@ -146,9 +148,9 @@ static void *unflatten_dt_alloc(unsigned long *mem, unsigned long size,
  * @allnextpp: pointer to ->allnext from last allocated device_node
  * @fpsize: Size of the node path up at the current depth.
  */
-static unsigned long unflatten_dt_node(struct boot_param_header *blob,
-                                unsigned long mem,
-                                unsigned long *p,
+static void * unflatten_dt_node(struct boot_param_header *blob,
+                                void *mem,
+                                void **p,
                                 struct device_node *dad,
                                 struct device_node ***allnextpp,
                                 unsigned long fpsize)
@@ -161,15 +163,15 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
         int has_name = 0;
         int new_format = 0;
 
-        tag = be32_to_cpup((__be32 *)(*p));
+        tag = be32_to_cpup(*p);
         if (tag != OF_DT_BEGIN_NODE) {
                 pr_err("Weird tag at start of node: %x\n", tag);
                 return mem;
         }
         *p += 4;
-        pathp = (char *)*p;
+        pathp = *p;
         l = allocl = strlen(pathp) + 1;
-        *p = ALIGN(*p + l, 4);
+        *p = PTR_ALIGN(*p + l, 4);
 
         /* version 0x10 has a more compact unit name here instead of the full
          * path. we accumulate the full path size using "fpsize", we'll rebuild
@@ -201,7 +203,6 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
                                 __alignof__(struct device_node));
         if (allnextpp) {
                 char *fn;
-                memset(np, 0, sizeof(*np));
                 np->full_name = fn = ((char *)np) + sizeof(*np);
                 if (new_format) {
                         /* rebuild full path for new format */
@@ -239,7 +240,7 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
                 u32 sz, noff;
                 char *pname;
 
-                tag = be32_to_cpup((__be32 *)(*p));
+                tag = be32_to_cpup(*p);
                 if (tag == OF_DT_NOP) {
                         *p += 4;
                         continue;
@@ -247,11 +248,11 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
                 if (tag != OF_DT_PROP)
                         break;
                 *p += 4;
-                sz = be32_to_cpup((__be32 *)(*p));
-                noff = be32_to_cpup((__be32 *)((*p) + 4));
+                sz = be32_to_cpup(*p);
+                noff = be32_to_cpup(*p + 4);
                 *p += 8;
                 if (be32_to_cpu(blob->version) < 0x10)
-                        *p = ALIGN(*p, sz >= 8 ? 8 : 4);
+                        *p = PTR_ALIGN(*p, sz >= 8 ? 8 : 4);
 
                 pname = of_fdt_get_string(blob, noff);
                 if (pname == NULL) {
@@ -281,11 +282,11 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
                                 np->phandle = be32_to_cpup((__be32 *)*p);
                         pp->name = pname;
                         pp->length = sz;
-                        pp->value = (void *)*p;
+                        pp->value = *p;
                         *prev_pp = pp;
                         prev_pp = &pp->next;
                 }
-                *p = ALIGN((*p) + sz, 4);
+                *p = PTR_ALIGN((*p) + sz, 4);
         }
         /* with version 0x10 we may not have the name property, recreate
          * it here from the unit name if absent
@@ -334,7 +335,7 @@ static unsigned long unflatten_dt_node(struct boot_param_header *blob,
                 else
                         mem = unflatten_dt_node(blob, mem, p, np, allnextpp,
                                                 fpsize);
-                tag = be32_to_cpup((__be32 *)(*p));
+                tag = be32_to_cpup(*p);
         }
         if (tag != OF_DT_END_NODE) {
                 pr_err("Weird tag at end of node: %x\n", tag);
@@ -360,7 +361,8 @@ static void __unflatten_device_tree(struct boot_param_header *blob,
                              struct device_node **mynodes,
                              void * (*dt_alloc)(u64 size, u64 align))
 {
-        unsigned long start, mem, size;
+        unsigned long size;
+        void *start, *mem;
         struct device_node **allnextp = mynodes;
 
         pr_debug(" -> unflatten_device_tree()\n");
@@ -381,32 +383,28 @@ static void __unflatten_device_tree(struct boot_param_header *blob,
         }
 
         /* First pass, scan for size */
-        start = ((unsigned long)blob) +
-                be32_to_cpu(blob->off_dt_struct);
-        size = unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
-        size = (size | 3) + 1;
+        start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
+        size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
+        size = ALIGN(size, 4);
 
         pr_debug("  size is %lx, allocating...\n", size);
 
         /* Allocate memory for the expanded device tree */
-        mem = (unsigned long)
-                dt_alloc(size + 4, __alignof__(struct device_node));
+        mem = dt_alloc(size + 4, __alignof__(struct device_node));
+        memset(mem, 0, size);
 
-        memset((void *)mem, 0, size);
+        *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
 
-        ((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);
-
-        pr_debug("  unflattening %lx...\n", mem);
+        pr_debug("  unflattening %p...\n", mem);
 
         /* Second pass, do actual unflattening */
-        start = ((unsigned long)blob) +
-                be32_to_cpu(blob->off_dt_struct);
+        start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
         unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);
-        if (be32_to_cpup((__be32 *)start) != OF_DT_END)
-                pr_warning("Weird tag at end of tree: %08x\n", *((u32 *)start));
-        if (be32_to_cpu(((__be32 *)mem)[size / 4]) != 0xdeadbeef)
+        if (be32_to_cpup(start) != OF_DT_END)
+                pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));
+        if (be32_to_cpup(mem + size) != 0xdeadbeef)
                 pr_warning("End of tree marker overwritten: %08x\n",
-                           be32_to_cpu(((__be32 *)mem)[size / 4]));
+                           be32_to_cpup(mem + size));
         *allnextp = NULL;
 
         pr_debug(" <- unflatten_device_tree()\n");
@@ -628,7 +626,8 @@ int __init of_scan_flat_dt_by_path(const char *path,
  */
 void __init early_init_dt_check_for_initrd(unsigned long node)
 {
-        unsigned long start, end, len;
+        u64 start, end;
+        unsigned long len;
         __be32 *prop;
 
         pr_debug("Looking for initrd properties... ");
@@ -636,15 +635,16 @@ void __init early_init_dt_check_for_initrd(unsigned long node)
         prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
         if (!prop)
                 return;
-        start = of_read_ulong(prop, len/4);
+        start = of_read_number(prop, len/4);
 
         prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
         if (!prop)
                 return;
-        end = of_read_ulong(prop, len/4);
+        end = of_read_number(prop, len/4);
 
         early_init_dt_setup_initrd_arch(start, end);
-        pr_debug("initrd_start=0x%lx  initrd_end=0x%lx\n", start, end);
+        pr_debug("initrd_start=0x%llx  initrd_end=0x%llx\n",
+                 (unsigned long long)start, (unsigned long long)end);
 }
 #else
 inline void early_init_dt_check_for_initrd(unsigned long node)
@@ -774,6 +774,17 @@ int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
         return 1;
 }
 
+#ifdef CONFIG_HAVE_MEMBLOCK
+/*
+ * called from unflatten_device_tree() to bootstrap devicetree itself
+ * Architectures can override this definition if memblock isn't used
+ */
+void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
+{
+        return __va(memblock_alloc(size, align));
+}
+#endif
+
 /**
  * unflatten_device_tree - create tree of device_nodes from flat blob
  *
@@ -792,3 +803,14 @@ void __init unflatten_device_tree(void)
 }
 
 #endif /* CONFIG_OF_EARLY_FLATTREE */
+
+/* Feed entire flattened device tree into the random pool */
+static int __init add_fdt_randomness(void)
+{
+        if (initial_boot_params)
+                add_device_randomness(initial_boot_params,
+                                be32_to_cpu(initial_boot_params->totalsize));
+
+        return 0;
+}
+core_initcall(add_fdt_randomness);
diff --git a/drivers/of/irq.c b/drivers/of/irq.c
index 1264923ade0f..1752988d6aa8 100644
--- a/drivers/of/irq.c
+++ b/drivers/of/irq.c
@@ -28,7 +28,7 @@
 
 /**
  * irq_of_parse_and_map - Parse and map an interrupt into linux virq space
- * @device: Device node of the device whose interrupt is to be mapped
+ * @dev: Device node of the device whose interrupt is to be mapped
  * @index: Index of the interrupt to map
  *
  * This function is a wrapper that chains of_irq_map_one() and
diff --git a/drivers/of/of_net.c b/drivers/of/of_net.c
index ea174c8ee34b..8f9be2e09937 100644
--- a/drivers/of/of_net.c
+++ b/drivers/of/of_net.c
@@ -39,7 +39,7 @@ static const char *phy_modes[] = {
  * The function gets phy interface string from property 'phy-mode',
  * and return its index in phy_modes table, or errno in error case.
  */
-const int of_get_phy_mode(struct device_node *np)
+int of_get_phy_mode(struct device_node *np)
 {
         const char *pm;
         int err, i;
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index eeca8a596973..9b439ac63d8e 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -197,7 +197,7 @@ EXPORT_SYMBOL(of_device_alloc);
  * Returns pointer to created platform device, or NULL if a device was not
  * registered.  Unavailable devices will not get registered.
  */
-struct platform_device *of_platform_device_create_pdata(
+static struct platform_device *of_platform_device_create_pdata(
                                         struct device_node *np,
                                         const char *bus_id,
                                         void *platform_data,
@@ -268,8 +268,11 @@ static struct amba_device *of_amba_device_create(struct device_node *node,
                 return NULL;
 
         dev = amba_device_alloc(NULL, 0, 0);
-        if (!dev)
+        if (!dev) {
+                pr_err("%s(): amba_device_alloc() failed for %s\n",
+                       __func__, node->full_name);
                 return NULL;
+        }
 
         /* setup generic device info */
         dev->dev.coherent_dma_mask = ~0;
@@ -294,12 +297,18 @@ static struct amba_device *of_amba_device_create(struct device_node *node,
                 dev->irq[i] = irq_of_parse_and_map(node, i);
 
         ret = of_address_to_resource(node, 0, &dev->res);
-        if (ret)
+        if (ret) {
+                pr_err("%s(): of_address_to_resource() failed (%d) for %s\n",
+                       __func__, ret, node->full_name);
                 goto err_free;
+        }
 
         ret = amba_device_add(dev, &iomem_resource);
-        if (ret)
+        if (ret) {
+                pr_err("%s(): amba_device_add() failed (%d) for %s\n",
+                       __func__, ret, node->full_name);
                 goto err_free;
+        }
 
         return dev;
 
@@ -378,6 +387,10 @@ static int of_platform_bus_create(struct device_node *bus,
         }
 
         if (of_device_is_compatible(bus, "arm,primecell")) {
+                /*
+                 * Don't return an error here to keep compatibility with older
+                 * device tree files.
+                 */
                 of_amba_device_create(bus, bus_id, platform_data, parent);
                 return 0;
         }