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

Pull device tree changes from Grant Likely:
 "All around device tree changes destined for v3.8.  Aside from the
  documentation updates the highlights in this branch include:

   - Kbuild changes for using CPP with .dts files
   - locking fix from preempt_rt patchset
   - include DT alias names in device uevent
   - Selftest bugfixes and improvements
   - New function for counting phandles stanzas in a property
   - constify argument to of_node_full_name()
   - Various bug fixes

  This tree did also contain a commit to use platform_device_add instead
  of open-coding the device add code, but it caused problems with amba
  devices and needed to be reverted."

* tag 'dt-for-linus' of git://git.secretlab.ca/git/linux: (23 commits)
  Revert "of: use platform_device_add"
  kbuild: limit dtc+cpp include path
  gpio: Make of_count_named_gpios() use new of_count_phandle_with_args()
  of: Create function for counting number of phandles in a property
  of/base: Clean up exit paths for of_parse_phandle_with_args()
  of/selftest: Use selftest() macro throughout
  of/selftest: Fix GPIOs selftest to cover the 7th case
  of: fix recursive locking in of_get_next_available_child()
  documentation/devicetree: Fix a typo in exynos-dw-mshc.txt
  OF: convert devtree lock from rw_lock to raw spinlock
  of/exynos_g2d: Add Bindings for exynos G2D driver
  kbuild: create a rule to run the pre-processor on *.dts files
  input: Extend matrix-keypad device tree binding
  devicetree: Move NS2 LEDs binding into LEDs directory
  of: use platform_device_add
  powerpc/5200: Fix size to request_mem_region() call
  documentation/devicetree: Fix typos
  of: add 'const' to of_node_full_name parameter
  of: Output devicetree alias names in uevent
  DT: add vendor prefixes for Renesas and Toshiba
  ...

12 files changed, 304 insertions, 174 deletions

diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c
index 25b1dbe8921d..a71a54a3e3f7 100644
--- a/drivers/gpio/gpiolib-of.c
+++ b/drivers/gpio/gpiolib-of.c
@@ -89,41 +89,6 @@ int of_get_named_gpio_flags(struct device_node *np, const char *propname,
 EXPORT_SYMBOL(of_get_named_gpio_flags);
 
 /**
- * of_gpio_named_count - Count GPIOs for a device
- * @np:         device node to count GPIOs for
- * @propname:   property name containing gpio specifier(s)
- *
- * The function returns the count of GPIOs specified for a node.
- *
- * Note that the empty GPIO specifiers counts too. For example,
- *
- * gpios = <0
- *          &pio1 1 2
- *          0
- *          &pio2 3 4>;
- *
- * defines four GPIOs (so this function will return 4), two of which
- * are not specified.
- */
-unsigned int of_gpio_named_count(struct device_node *np, const char* propname)
-{
-        unsigned int cnt = 0;
-
-        do {
-                int ret;
-
-                ret = of_parse_phandle_with_args(np, propname, "#gpio-cells",
-                                                 cnt, NULL);
-                /* A hole in the gpios = <> counts anyway. */
-                if (ret < 0 && ret != -EEXIST)
-                        break;
-        } while (++cnt);
-
-        return cnt;
-}
-EXPORT_SYMBOL(of_gpio_named_count);
-
-/**
  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
  * @gc:         pointer to the gpio_chip structure
  * @np:         device node of the GPIO chip
diff --git a/drivers/hwmon/gpio-fan.c b/drivers/hwmon/gpio-fan.c
index 4e04c1228e51..39781945a5d2 100644
--- a/drivers/hwmon/gpio-fan.c
+++ b/drivers/hwmon/gpio-fan.c
@@ -422,7 +422,7 @@ static int gpio_fan_get_of_pdata(struct device *dev,
 
         /* Fill GPIO pin array */
         pdata->num_ctrl = of_gpio_count(node);
-        if (!pdata->num_ctrl) {
+        if (pdata->num_ctrl <= 0) {
                 dev_err(dev, "gpios DT property empty / missing");
                 return -ENODEV;
         }
@@ -477,7 +477,7 @@ static int gpio_fan_get_of_pdata(struct device *dev,
         pdata->speed = speed;
 
         /* Alarm GPIO if one exists */
-        if (of_gpio_named_count(node, "alarm-gpios")) {
+        if (of_gpio_named_count(node, "alarm-gpios") > 0) {
                 struct gpio_fan_alarm *alarm;
                 int val;
                 enum of_gpio_flags flags;
diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
index f4ff0dda7597..71d77192ac1e 100644
--- a/drivers/input/keyboard/matrix_keypad.c
+++ b/drivers/input/keyboard/matrix_keypad.c
@@ -403,7 +403,7 @@ matrix_keypad_parse_dt(struct device *dev)
         struct matrix_keypad_platform_data *pdata;
         struct device_node *np = dev->of_node;
         unsigned int *gpios;
-        int i;
+        int i, nrow, ncol;
 
         if (!np) {
                 dev_err(dev, "device lacks DT data\n");
@@ -416,9 +416,9 @@ matrix_keypad_parse_dt(struct device *dev)
                 return ERR_PTR(-ENOMEM);
         }
 
-        pdata->num_row_gpios = of_gpio_named_count(np, "row-gpios");
-        pdata->num_col_gpios = of_gpio_named_count(np, "col-gpios");
-        if (!pdata->num_row_gpios || !pdata->num_col_gpios) {
+        pdata->num_row_gpios = nrow = of_gpio_named_count(np, "row-gpios");
+        pdata->num_col_gpios = ncol = of_gpio_named_count(np, "col-gpios");
+        if (nrow <= 0 || ncol <= 0) {
                 dev_err(dev, "number of keypad rows/columns not specified\n");
                 return ERR_PTR(-EINVAL);
         }
diff --git a/drivers/net/phy/mdio-mux-gpio.c b/drivers/net/phy/mdio-mux-gpio.c
index 0c9accb1c14f..e91d7d736ae2 100644
--- a/drivers/net/phy/mdio-mux-gpio.c
+++ b/drivers/net/phy/mdio-mux-gpio.c
@@ -53,7 +53,7 @@ static int mdio_mux_gpio_probe(struct platform_device *pdev)
 {
         enum of_gpio_flags f;
         struct mdio_mux_gpio_state *s;
-        unsigned int num_gpios;
+        int num_gpios;
         unsigned int n;
         int r;
 
@@ -61,7 +61,7 @@ static int mdio_mux_gpio_probe(struct platform_device *pdev)
                 return -ENODEV;
 
         num_gpios = of_gpio_count(pdev->dev.of_node);
-        if (num_gpios == 0 || num_gpios > MDIO_MUX_GPIO_MAX_BITS)
+        if (num_gpios <= 0 || num_gpios > MDIO_MUX_GPIO_MAX_BITS)
                 return -ENODEV;
 
         s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 2390ddb22d60..321d3ef05006 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -24,38 +24,21 @@
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
 
-/**
- * struct alias_prop - Alias property in 'aliases' node
- * @link:       List node to link the structure in aliases_lookup list
- * @alias:      Alias property name
- * @np:         Pointer to device_node that the alias stands for
- * @id:         Index value from end of alias name
- * @stem:       Alias string without the index
- *
- * The structure represents one alias property of 'aliases' node as
- * an entry in aliases_lookup list.
- */
-struct alias_prop {
-        struct list_head link;
-        const char *alias;
-        struct device_node *np;
-        int id;
-        char stem[0];
-};
+#include "of_private.h"
 
-static LIST_HEAD(aliases_lookup);
+LIST_HEAD(aliases_lookup);
 
 struct device_node *of_allnodes;
 EXPORT_SYMBOL(of_allnodes);
 struct device_node *of_chosen;
 struct device_node *of_aliases;
 
-static DEFINE_MUTEX(of_aliases_mutex);
+DEFINE_MUTEX(of_aliases_mutex);
 
 /* use when traversing tree through the allnext, child, sibling,
  * or parent members of struct device_node.
  */
-DEFINE_RWLOCK(devtree_lock);
+DEFINE_RAW_SPINLOCK(devtree_lock);
 
 int of_n_addr_cells(struct device_node *np)
 {
@@ -164,16 +147,14 @@ void of_node_put(struct device_node *node)
 EXPORT_SYMBOL(of_node_put);
 #endif /* CONFIG_OF_DYNAMIC */
 
-struct property *of_find_property(const struct device_node *np,
-                                  const char *name,
-                                  int *lenp)
+static struct property *__of_find_property(const struct device_node *np,
+                                           const char *name, int *lenp)
 {
         struct property *pp;
 
         if (!np)
                 return NULL;
 
-        read_lock(&devtree_lock);
         for (pp = np->properties; pp; pp = pp->next) {
                 if (of_prop_cmp(pp->name, name) == 0) {
                         if (lenp)
@@ -181,7 +162,20 @@ struct property *of_find_property(const struct device_node *np,
                         break;
                 }
         }
-        read_unlock(&devtree_lock);
+
+        return pp;
+}
+
+struct property *of_find_property(const struct device_node *np,
+                                  const char *name,
+                                  int *lenp)
+{
+        struct property *pp;
+        unsigned long flags;
+
+        raw_spin_lock_irqsave(&devtree_lock, flags);
+        pp = __of_find_property(np, name, lenp);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
         return pp;
 }
@@ -199,13 +193,13 @@ struct device_node *of_find_all_nodes(struct device_node *prev)
 {
         struct device_node *np;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock(&devtree_lock);
         np = prev ? prev->allnext : of_allnodes;
         for (; np != NULL; np = np->allnext)
                 if (of_node_get(np))
                         break;
         of_node_put(prev);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock(&devtree_lock);
         return np;
 }
 EXPORT_SYMBOL(of_find_all_nodes);
@@ -214,8 +208,20 @@ EXPORT_SYMBOL(of_find_all_nodes);
  * Find a property with a given name for a given node
  * and return the value.
  */
+static const void *__of_get_property(const struct device_node *np,
+                                     const char *name, int *lenp)
+{
+        struct property *pp = __of_find_property(np, name, lenp);
+
+        return pp ? pp->value : NULL;
+}
+
+/*
+ * Find a property with a given name for a given node
+ * and return the value.
+ */
 const void *of_get_property(const struct device_node *np, const char *name,
-                         int *lenp)
+                            int *lenp)
 {
         struct property *pp = of_find_property(np, name, lenp);
 
@@ -226,13 +232,13 @@ EXPORT_SYMBOL(of_get_property);
 /** Checks if the given "compat" string matches one of the strings in
  * the device's "compatible" property
  */
-int of_device_is_compatible(const struct device_node *device,
-                const char *compat)
+static int __of_device_is_compatible(const struct device_node *device,
+                                     const char *compat)
 {
         const char* cp;
         int cplen, l;
 
-        cp = of_get_property(device, "compatible", &cplen);
+        cp = __of_get_property(device, "compatible", &cplen);
         if (cp == NULL)
                 return 0;
         while (cplen > 0) {
@@ -245,6 +251,21 @@ int of_device_is_compatible(const struct device_node *device,
 
         return 0;
 }
+
+/** Checks if the given "compat" string matches one of the strings in
+ * the device's "compatible" property
+ */
+int of_device_is_compatible(const struct device_node *device,
+                const char *compat)
+{
+        unsigned long flags;
+        int res;
+
+        raw_spin_lock_irqsave(&devtree_lock, flags);
+        res = __of_device_is_compatible(device, compat);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
+        return res;
+}
 EXPORT_SYMBOL(of_device_is_compatible);
 
 /**
@@ -269,19 +290,19 @@ int of_machine_is_compatible(const char *compat)
 EXPORT_SYMBOL(of_machine_is_compatible);
 
 /**
- *  of_device_is_available - check if a device is available for use
+ *  __of_device_is_available - check if a device is available for use
  *
- *  @device: Node to check for availability
+ *  @device: Node to check for availability, with locks already held
  *
  *  Returns 1 if the status property is absent or set to "okay" or "ok",
  *  0 otherwise
  */
-int of_device_is_available(const struct device_node *device)
+static int __of_device_is_available(const struct device_node *device)
 {
         const char *status;
         int statlen;
 
-        status = of_get_property(device, "status", &statlen);
+        status = __of_get_property(device, "status", &statlen);
         if (status == NULL)
                 return 1;
 
@@ -292,6 +313,26 @@ int of_device_is_available(const struct device_node *device)
 
         return 0;
 }
+
+/**
+ *  of_device_is_available - check if a device is available for use
+ *
+ *  @device: Node to check for availability
+ *
+ *  Returns 1 if the status property is absent or set to "okay" or "ok",
+ *  0 otherwise
+ */
+int of_device_is_available(const struct device_node *device)
+{
+        unsigned long flags;
+        int res;
+
+        raw_spin_lock_irqsave(&devtree_lock, flags);
+        res = __of_device_is_available(device);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
+        return res;
+
+}
 EXPORT_SYMBOL(of_device_is_available);
 
 /**
@@ -304,13 +345,14 @@ EXPORT_SYMBOL(of_device_is_available);
 struct device_node *of_get_parent(const struct device_node *node)
 {
         struct device_node *np;
+        unsigned long flags;
 
         if (!node)
                 return NULL;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = of_node_get(node->parent);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_get_parent);
@@ -329,14 +371,15 @@ EXPORT_SYMBOL(of_get_parent);
 struct device_node *of_get_next_parent(struct device_node *node)
 {
         struct device_node *parent;
+        unsigned long flags;
 
         if (!node)
                 return NULL;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         parent = of_node_get(node->parent);
         of_node_put(node);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return parent;
 }
 
@@ -352,14 +395,15 @@ struct device_node *of_get_next_child(const struct device_node *node,
         struct device_node *prev)
 {
         struct device_node *next;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         next = prev ? prev->sibling : node->child;
         for (; next; next = next->sibling)
                 if (of_node_get(next))
                         break;
         of_node_put(prev);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return next;
 }
 EXPORT_SYMBOL(of_get_next_child);
@@ -377,16 +421,16 @@ struct device_node *of_get_next_available_child(const struct device_node *node,
 {
         struct device_node *next;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock(&devtree_lock);
         next = prev ? prev->sibling : node->child;
         for (; next; next = next->sibling) {
-                if (!of_device_is_available(next))
+                if (!__of_device_is_available(next))
                         continue;
                 if (of_node_get(next))
                         break;
         }
         of_node_put(prev);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock(&devtree_lock);
         return next;
 }
 EXPORT_SYMBOL(of_get_next_available_child);
@@ -424,14 +468,15 @@ EXPORT_SYMBOL(of_get_child_by_name);
 struct device_node *of_find_node_by_path(const char *path)
 {
         struct device_node *np = of_allnodes;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         for (; np; np = np->allnext) {
                 if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
                     && of_node_get(np))
                         break;
         }
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_node_by_path);
@@ -451,15 +496,16 @@ struct device_node *of_find_node_by_name(struct device_node *from,
         const char *name)
 {
         struct device_node *np;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = from ? from->allnext : of_allnodes;
         for (; np; np = np->allnext)
                 if (np->name && (of_node_cmp(np->name, name) == 0)
                     && of_node_get(np))
                         break;
         of_node_put(from);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_node_by_name);
@@ -480,15 +526,16 @@ struct device_node *of_find_node_by_type(struct device_node *from,
         const char *type)
 {
         struct device_node *np;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = from ? from->allnext : of_allnodes;
         for (; np; np = np->allnext)
                 if (np->type && (of_node_cmp(np->type, type) == 0)
                     && of_node_get(np))
                         break;
         of_node_put(from);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_node_by_type);
@@ -511,18 +558,20 @@ struct device_node *of_find_compatible_node(struct device_node *from,
         const char *type, const char *compatible)
 {
         struct device_node *np;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = from ? from->allnext : of_allnodes;
         for (; np; np = np->allnext) {
                 if (type
                     && !(np->type && (of_node_cmp(np->type, type) == 0)))
                         continue;
-                if (of_device_is_compatible(np, compatible) && of_node_get(np))
+                if (__of_device_is_compatible(np, compatible) &&
+                    of_node_get(np))
                         break;
         }
         of_node_put(from);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_compatible_node);
@@ -544,8 +593,9 @@ struct device_node *of_find_node_with_property(struct device_node *from,
 {
         struct device_node *np;
         struct property *pp;
+        unsigned long flags;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = from ? from->allnext : of_allnodes;
         for (; np; np = np->allnext) {
                 for (pp = np->properties; pp; pp = pp->next) {
@@ -557,20 +607,14 @@ struct device_node *of_find_node_with_property(struct device_node *from,
         }
 out:
         of_node_put(from);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_node_with_property);
 
-/**
- * of_match_node - Tell if an device_node has a matching of_match structure
- *      @matches:       array of of device match structures to search in
- *      @node:          the of device structure to match against
- *
- *      Low level utility function used by device matching.
- */
-const struct of_device_id *of_match_node(const struct of_device_id *matches,
-                                         const struct device_node *node)
+static
+const struct of_device_id *__of_match_node(const struct of_device_id *matches,
+                                           const struct device_node *node)
 {
         if (!matches)
                 return NULL;
@@ -584,14 +628,33 @@ const struct of_device_id *of_match_node(const struct of_device_id *matches,
                         match &= node->type
                                 && !strcmp(matches->type, node->type);
                 if (matches->compatible[0])
-                        match &= of_device_is_compatible(node,
-                                                matches->compatible);
+                        match &= __of_device_is_compatible(node,
+                                                           matches->compatible);
                 if (match)
                         return matches;
                 matches++;
         }
         return NULL;
 }
+
+/**
+ * of_match_node - Tell if an device_node has a matching of_match structure
+ *      @matches:       array of of device match structures to search in
+ *      @node:          the of device structure to match against
+ *
+ *      Low level utility function used by device matching.
+ */
+const struct of_device_id *of_match_node(const struct of_device_id *matches,
+                                         const struct device_node *node)
+{
+        const struct of_device_id *match;
+        unsigned long flags;
+
+        raw_spin_lock_irqsave(&devtree_lock, flags);
+        match = __of_match_node(matches, node);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
+        return match;
+}
 EXPORT_SYMBOL(of_match_node);
 
 /**
@@ -612,21 +675,24 @@ struct device_node *of_find_matching_node_and_match(struct device_node *from,
                                         const struct of_device_id **match)
 {
         struct device_node *np;
+        const struct of_device_id *m;
+        unsigned long flags;
 
         if (match)
                 *match = NULL;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np = from ? from->allnext : of_allnodes;
         for (; np; np = np->allnext) {
-                if (of_match_node(matches, np) && of_node_get(np)) {
+                m = __of_match_node(matches, np);
+                if (m && of_node_get(np)) {
                         if (match)
-                                *match = matches;
+                                *match = m;
                         break;
                 }
         }
         of_node_put(from);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
         return np;
 }
 EXPORT_SYMBOL(of_find_matching_node_and_match);
@@ -669,12 +735,12 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 {
         struct device_node *np;
 
-        read_lock(&devtree_lock);
+        raw_spin_lock(&devtree_lock);
         for (np = of_allnodes; np; np = np->allnext)
                 if (np->phandle == handle)
                         break;
         of_node_get(np);
-        read_unlock(&devtree_lock);
+        raw_spin_unlock(&devtree_lock);
         return np;
 }
 EXPORT_SYMBOL(of_find_node_by_phandle);
@@ -1025,12 +1091,13 @@ EXPORT_SYMBOL(of_parse_phandle);
  * 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)
+static 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)
 {
         const __be32 *list, *list_end;
-        int size, cur_index = 0;
+        int rc = 0, size, cur_index = 0;
         uint32_t count = 0;
         struct device_node *node = NULL;
         phandle phandle;
@@ -1043,6 +1110,7 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
 
         /* Loop over the phandles until all the requested entry is found */
         while (list < list_end) {
+                rc = -EINVAL;
                 count = 0;
 
                 /*
@@ -1059,13 +1127,13 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
                         if (!node) {
                                 pr_err("%s: could not find phandle\n",
                                          np->full_name);
-                                break;
+                                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);
-                                break;
+                                goto err;
                         }
 
                         /*
@@ -1075,7 +1143,7 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
                         if (list + count > list_end) {
                                 pr_err("%s: arguments longer than property\n",
                                          np->full_name);
-                                break;
+                                goto err;
                         }
                 }
 
@@ -1085,9 +1153,10 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
                  * index matches, then fill the out_args structure and return,
                  * or return -ENOENT for an empty entry.
                  */
+                rc = -ENOENT;
                 if (cur_index == index) {
                         if (!phandle)
-                                return -ENOENT;
+                                goto err;
 
                         if (out_args) {
                                 int i;
@@ -1098,6 +1167,10 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
                                 for (i = 0; i < count; i++)
                                         out_args->args[i] = be32_to_cpup(list++);
                         }
+
+                        /* Found it! return success */
+                        if (node)
+                                of_node_put(node);
                         return 0;
                 }
 
@@ -1107,13 +1180,51 @@ int of_parse_phandle_with_args(const struct device_node *np, const char *list_na
                 cur_index++;
         }
 
-        /* Loop exited without finding a valid entry; return an error */
+        /*
+         * Unlock node before returning result; will be one of:
+         * -ENOENT : index is for empty phandle
+         * -EINVAL : parsing error on data
+         * [1..n]  : Number of phandle (count mode; when index = -1)
+         */
+        rc = index < 0 ? cur_index : -ENOENT;
+ err:
         if (node)
                 of_node_put(node);
-        return -EINVAL;
+        return rc;
+}
+
+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);
 }
 EXPORT_SYMBOL(of_parse_phandle_with_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
+ * @cells_name: property name that specifies phandles' arguments count
+ *
+ * Returns the number of phandle + argument tuples within a property. It
+ * is a typical pattern to encode a list of phandle and variable
+ * arguments into a single property. The number of arguments is encoded
+ * by a property in the phandle-target node. For example, a gpios
+ * property would contain a list of GPIO specifies consisting of a
+ * phandle and 1 or more arguments. The number of arguments are
+ * determined by the #gpio-cells property in the node pointed to by the
+ * phandle.
+ */
+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);
+}
+EXPORT_SYMBOL(of_count_phandle_with_args);
+
 #if defined(CONFIG_OF_DYNAMIC)
 static int of_property_notify(int action, struct device_node *np,
                               struct property *prop)
@@ -1146,18 +1257,18 @@ int of_add_property(struct device_node *np, struct property *prop)
                 return rc;
 
         prop->next = NULL;
-        write_lock_irqsave(&devtree_lock, flags);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         next = &np->properties;
         while (*next) {
                 if (strcmp(prop->name, (*next)->name) == 0) {
                         /* duplicate ! don't insert it */
-                        write_unlock_irqrestore(&devtree_lock, flags);
+                        raw_spin_unlock_irqrestore(&devtree_lock, flags);
                         return -1;
                 }
                 next = &(*next)->next;
         }
         *next = prop;
-        write_unlock_irqrestore(&devtree_lock, flags);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
 #ifdef CONFIG_PROC_DEVICETREE
         /* try to add to proc as well if it was initialized */
@@ -1187,7 +1298,7 @@ int of_remove_property(struct device_node *np, struct property *prop)
         if (rc)
                 return rc;
 
-        write_lock_irqsave(&devtree_lock, flags);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         next = &np->properties;
         while (*next) {
                 if (*next == prop) {
@@ -1200,7 +1311,7 @@ int of_remove_property(struct device_node *np, struct property *prop)
                 }
                 next = &(*next)->next;
         }
-        write_unlock_irqrestore(&devtree_lock, flags);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
         if (!found)
                 return -ENODEV;
@@ -1240,7 +1351,7 @@ int of_update_property(struct device_node *np, struct property *newprop)
         if (!oldprop)
                 return of_add_property(np, newprop);
 
-        write_lock_irqsave(&devtree_lock, flags);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         next = &np->properties;
         while (*next) {
                 if (*next == oldprop) {
@@ -1254,7 +1365,7 @@ int of_update_property(struct device_node *np, struct property *newprop)
                 }
                 next = &(*next)->next;
         }
-        write_unlock_irqrestore(&devtree_lock, flags);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
         if (!found)
                 return -ENODEV;
@@ -1327,12 +1438,12 @@ int of_attach_node(struct device_node *np)
         if (rc)
                 return rc;
 
-        write_lock_irqsave(&devtree_lock, flags);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
         np->sibling = np->parent->child;
         np->allnext = of_allnodes;
         np->parent->child = np;
         of_allnodes = np;
-        write_unlock_irqrestore(&devtree_lock, flags);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
         of_add_proc_dt_entry(np);
         return 0;
@@ -1375,17 +1486,17 @@ int of_detach_node(struct device_node *np)
         if (rc)
                 return rc;
 
-        write_lock_irqsave(&devtree_lock, flags);
+        raw_spin_lock_irqsave(&devtree_lock, flags);
 
         if (of_node_check_flag(np, OF_DETACHED)) {
                 /* someone already detached it */
-                write_unlock_irqrestore(&devtree_lock, flags);
+                raw_spin_unlock_irqrestore(&devtree_lock, flags);
                 return rc;
         }
 
         parent = np->parent;
         if (!parent) {
-                write_unlock_irqrestore(&devtree_lock, flags);
+                raw_spin_unlock_irqrestore(&devtree_lock, flags);
                 return rc;
         }
 
@@ -1412,7 +1523,7 @@ int of_detach_node(struct device_node *np)
         }
 
         of_node_set_flag(np, OF_DETACHED);
-        write_unlock_irqrestore(&devtree_lock, flags);
+        raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
         of_remove_proc_dt_entry(np);
         return rc;
diff --git a/drivers/of/device.c b/drivers/of/device.c
index 4c74e4fc5a51..f685e55e0717 100644
--- a/drivers/of/device.c
+++ b/drivers/of/device.c
@@ -8,6 +8,7 @@
 #include <linux/slab.h>
 
 #include <asm/errno.h>
+#include "of_private.h"
 
 /**
  * of_match_device - Tell if a struct device matches an of_device_id list
@@ -131,6 +132,7 @@ ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
 void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         const char *compat;
+        struct alias_prop *app;
         int seen = 0, cplen, sl;
 
         if ((!dev) || (!dev->of_node))
@@ -153,6 +155,17 @@ void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
                 seen++;
         }
         add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen);
+
+        seen = 0;
+        mutex_lock(&of_aliases_mutex);
+        list_for_each_entry(app, &aliases_lookup, link) {
+                if (dev->of_node == app->np) {
+                        add_uevent_var(env, "OF_ALIAS_%d=%s", seen,
+                                       app->alias);
+                        seen++;
+                }
+        }
+        mutex_unlock(&of_aliases_mutex);
 }
 
 int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
diff --git a/drivers/of/of_private.h b/drivers/of/of_private.h
new file mode 100644
index 000000000000..ff350c8fa7ac
--- /dev/null
+++ b/drivers/of/of_private.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_OF_PRIVATE_H
+#define _LINUX_OF_PRIVATE_H
+/*
+ * Private symbols used by OF support code
+ *
+ * Paul Mackerras       August 1996.
+ * Copyright (C) 1996-2005 Paul Mackerras.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+/**
+ * struct alias_prop - Alias property in 'aliases' node
+ * @link:       List node to link the structure in aliases_lookup list
+ * @alias:      Alias property name
+ * @np:         Pointer to device_node that the alias stands for
+ * @id:         Index value from end of alias name
+ * @stem:       Alias string without the index
+ *
+ * The structure represents one alias property of 'aliases' node as
+ * an entry in aliases_lookup list.
+ */
+struct alias_prop {
+        struct list_head link;
+        const char *alias;
+        struct device_node *np;
+        int id;
+        char stem[0];
+};
+
+extern struct mutex of_aliases_mutex;
+extern struct list_head aliases_lookup;
+#endif /* _LINUX_OF_PRIVATE_H */
diff --git a/drivers/of/selftest.c b/drivers/of/selftest.c
index f24ffd7088d2..0eb5c38b4e07 100644
--- a/drivers/of/selftest.c
+++ b/drivers/of/selftest.c
@@ -2,7 +2,7 @@
  * Self tests for device tree subsystem
  */
 
-#define pr_fmt(fmt) "### %s(): " fmt, __func__
+#define pr_fmt(fmt) "### dt-test ### " fmt
 
 #include <linux/clk.h>
 #include <linux/err.h>
@@ -16,26 +16,30 @@
 
 static bool selftest_passed = true;
 #define selftest(result, fmt, ...) { \
-        selftest_passed &= (result); \
-        if (!(result)) \
+        if (!(result)) { \
                 pr_err("FAIL %s:%i " fmt, __FILE__, __LINE__, ##__VA_ARGS__); \
+                selftest_passed = false; \
+        } else { \
+                pr_info("pass %s:%i\n", __FILE__, __LINE__); \
+        } \
 }
 
 static void __init of_selftest_parse_phandle_with_args(void)
 {
         struct device_node *np;
         struct of_phandle_args args;
-        int rc, i;
-        bool passed_all = true;
+        int i, rc;
 
-        pr_info("start\n");
         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
         if (!np) {
                 pr_err("missing testcase data\n");
                 return;
         }
 
-        for (i = 0; i < 7; i++) {
+        rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
+        selftest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
+
+        for (i = 0; i < 8; i++) {
                 bool passed = true;
                 rc = of_parse_phandle_with_args(np, "phandle-list",
                                                 "#phandle-cells", i, &args);
@@ -79,45 +83,47 @@ static void __init of_selftest_parse_phandle_with_args(void)
                         passed &= (args.args[0] == (i + 1));
                         break;
                 case 7:
-                        passed &= (rc == -EINVAL);
+                        passed &= (rc == -ENOENT);
                         break;
                 default:
                         passed = false;
                 }
 
-                if (!passed) {
-                        int j;
-                        pr_err("index %i - data error on node %s rc=%i regs=[",
-                                i, args.np->full_name, rc);
-                        for (j = 0; j < args.args_count; j++)
-                                printk(" %i", args.args[j]);
-                        printk(" ]\n");
-
-                        passed_all = false;
-                }
+                selftest(passed, "index %i - data error on node %s rc=%i\n",
+                         i, args.np->full_name, rc);
         }
 
         /* Check for missing list property */
         rc = of_parse_phandle_with_args(np, "phandle-list-missing",
                                         "#phandle-cells", 0, &args);
-        passed_all &= (rc == -EINVAL);
+        selftest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
+        rc = of_count_phandle_with_args(np, "phandle-list-missing",
+                                        "#phandle-cells");
+        selftest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 
         /* Check for missing cells property */
         rc = of_parse_phandle_with_args(np, "phandle-list",
                                         "#phandle-cells-missing", 0, &args);
-        passed_all &= (rc == -EINVAL);
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
+        rc = of_count_phandle_with_args(np, "phandle-list",
+                                        "#phandle-cells-missing");
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 
         /* Check for bad phandle in list */
         rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
                                         "#phandle-cells", 0, &args);
-        passed_all &= (rc == -EINVAL);
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
+        rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
+                                        "#phandle-cells");
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 
         /* Check for incorrectly formed argument list */
         rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
                                         "#phandle-cells", 1, &args);
-        passed_all &= (rc == -EINVAL);
-
-        pr_info("end - %s\n", passed_all ? "PASS" : "FAIL");
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
+        rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
+                                        "#phandle-cells");
+        selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 }
 
 static void __init of_selftest_property_match_string(void)
diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c
index 1a7f6359d998..086a9eef2e05 100644
--- a/drivers/spi/spi-fsl-spi.c
+++ b/drivers/spi/spi-fsl-spi.c
@@ -947,12 +947,12 @@ static int of_fsl_spi_get_chipselects(struct device *dev)
         struct device_node *np = dev->of_node;
         struct fsl_spi_platform_data *pdata = dev->platform_data;
         struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
-        unsigned int ngpios;
+        int ngpios;
         int i = 0;
         int ret;
 
         ngpios = of_gpio_count(np);
-        if (!ngpios) {
+        if (ngpios <= 0) {
                 /*
                  * SPI w/o chip-select line. One SPI device is still permitted
                  * though.
diff --git a/drivers/spi/spi-oc-tiny.c b/drivers/spi/spi-oc-tiny.c
index 432e66ec3088..cb2e284bd814 100644
--- a/drivers/spi/spi-oc-tiny.c
+++ b/drivers/spi/spi-oc-tiny.c
@@ -54,7 +54,7 @@ struct tiny_spi {
         unsigned int txc, rxc;
         const u8 *txp;
         u8 *rxp;
-        unsigned int gpio_cs_count;
+        int gpio_cs_count;
         int *gpio_cs;
 };
 
@@ -74,7 +74,7 @@ static void tiny_spi_chipselect(struct spi_device *spi, int is_active)
 {
         struct tiny_spi *hw = tiny_spi_to_hw(spi);
 
-        if (hw->gpio_cs_count) {
+        if (hw->gpio_cs_count > 0) {
                 gpio_set_value(hw->gpio_cs[spi->chip_select],
                         (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
         }
@@ -254,7 +254,7 @@ static int tiny_spi_of_probe(struct platform_device *pdev)
         if (!np)
                 return 0;
         hw->gpio_cs_count = of_gpio_count(np);
-        if (hw->gpio_cs_count) {
+        if (hw->gpio_cs_count > 0) {
                 hw->gpio_cs = devm_kzalloc(&pdev->dev,
                                 hw->gpio_cs_count * sizeof(unsigned int),
                                 GFP_KERNEL);
@@ -352,7 +352,7 @@ static int tiny_spi_probe(struct platform_device *pdev)
                         goto exit_gpio;
                 gpio_direction_output(hw->gpio_cs[i], 1);
         }
-        hw->bitbang.master->num_chipselect = max(1U, hw->gpio_cs_count);
+        hw->bitbang.master->num_chipselect = max(1, hw->gpio_cs_count);
 
         /* register our spi controller */
         err = spi_bitbang_start(&hw->bitbang);
diff --git a/drivers/spi/spi-ppc4xx.c b/drivers/spi/spi-ppc4xx.c
index 424b333fab18..357f183a4fb7 100644
--- a/drivers/spi/spi-ppc4xx.c
+++ b/drivers/spi/spi-ppc4xx.c
@@ -419,7 +419,7 @@ static int spi_ppc4xx_of_probe(struct platform_device *op)
          * This includes both "null" gpio's and real ones.
          */
         num_gpios = of_gpio_count(np);
-        if (num_gpios) {
+        if (num_gpios > 0) {
                 int i;
 
                 hw->gpios = kzalloc(sizeof(int) * num_gpios, GFP_KERNEL);
@@ -471,7 +471,7 @@ static int spi_ppc4xx_of_probe(struct platform_device *op)
                 SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST;
 
         /* this many pins in all GPIO controllers */
-        bbp->master->num_chipselect = num_gpios;
+        bbp->master->num_chipselect = num_gpios > 0 ? num_gpios : 0;
 
         /* Get the clock for the OPB */
         opbnp = of_find_compatible_node(NULL, NULL, "ibm,opb");
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 4fffb1f39def..6f193b02a9e8 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -1059,15 +1059,14 @@ EXPORT_SYMBOL_GPL(spi_alloc_master);
 #ifdef CONFIG_OF
 static int of_spi_register_master(struct spi_master *master)
 {
-        u16 nb;
-        int i, *cs;
+        int nb, i, *cs;
         struct device_node *np = master->dev.of_node;
 
         if (!np)
                 return 0;
 
         nb = of_gpio_named_count(np, "cs-gpios");
-        master->num_chipselect = max(nb, master->num_chipselect);
+        master->num_chipselect = max(nb, (int)master->num_chipselect);
 
         if (nb < 1)
                 return 0;