8 files changed, 407 insertions, 97 deletions

diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
index d06a6374ed6c..cac63c9f49ae 100644
--- a/drivers/of/Kconfig
+++ b/drivers/of/Kconfig
@@ -71,8 +71,14 @@ config OF_MDIO
 
 config OF_PCI
         def_tristate PCI
-        depends on PCI && (PPC || MICROBLAZE || X86)
+        depends on PCI
         help
           OpenFirmware PCI bus accessors
 
+config OF_PCI_IRQ
+        def_tristate PCI
+        depends on OF_PCI && OF_IRQ
+        help
+          OpenFirmware PCI IRQ routing helpers
+
 endmenu # OF
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
index f7861ed2f287..dccb1176be57 100644
--- a/drivers/of/Makefile
+++ b/drivers/of/Makefile
@@ -10,3 +10,4 @@ obj-$(CONFIG_OF_NET)	+= of_net.o
 obj-$(CONFIG_OF_SPI)    += of_spi.o
 obj-$(CONFIG_OF_MDIO)   += of_mdio.o
 obj-$(CONFIG_OF_PCI)    += of_pci.o
+obj-$(CONFIG_OF_PCI_IRQ)  += of_pci_irq.o
diff --git a/drivers/of/address.c b/drivers/of/address.c
index b4559c58c095..da1f4b9605df 100644
--- a/drivers/of/address.c
+++ b/drivers/of/address.c
@@ -577,6 +577,24 @@ int of_address_to_resource(struct device_node *dev, int index,
 }
 EXPORT_SYMBOL_GPL(of_address_to_resource);
 
+struct device_node *of_find_matching_node_by_address(struct device_node *from,
+                                        const struct of_device_id *matches,
+                                        u64 base_address)
+{
+        struct device_node *dn = of_find_matching_node(from, matches);
+        struct resource res;
+
+        while (dn) {
+                if (of_address_to_resource(dn, 0, &res))
+                        continue;
+                if (res.start == base_address)
+                        return dn;
+                dn = of_find_matching_node(dn, matches);
+        }
+
+        return NULL;
+}
+
 
 /**
  * of_iomap - Maps the memory mapped IO for a given device_node
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 632ebae7f17a..02ed36719def 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -596,6 +596,71 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 EXPORT_SYMBOL(of_find_node_by_phandle);
 
 /**
+ * of_property_read_u32_array - Find and read an array of 32 bit integers
+ * from a property.
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @out_value:  pointer to return value, modified only if return value is 0.
+ *
+ * Search for a property in a device node and read 32-bit value(s) from
+ * it. Returns 0 on success, -EINVAL if the property does not exist,
+ * -ENODATA if property does not have a value, and -EOVERFLOW if the
+ * property data isn't large enough.
+ *
+ * The out_value is modified only if a valid u32 value can be decoded.
+ */
+int of_property_read_u32_array(const struct device_node *np, char *propname,
+                               u32 *out_values, size_t sz)
+{
+        struct property *prop = of_find_property(np, propname, NULL);
+        const __be32 *val;
+
+        if (!prop)
+                return -EINVAL;
+        if (!prop->value)
+                return -ENODATA;
+        if ((sz * sizeof(*out_values)) > prop->length)
+                return -EOVERFLOW;
+
+        val = prop->value;
+        while (sz--)
+                *out_values++ = be32_to_cpup(val++);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_property_read_u32_array);
+
+/**
+ * of_property_read_string - Find and read a string from a property
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @out_string: pointer to null terminated return string, modified only if
+ *              return value is 0.
+ *
+ * Search for a property in a device tree node and retrieve a null
+ * terminated string value (pointer to data, not a copy). Returns 0 on
+ * success, -EINVAL if the property does not exist, -ENODATA if property
+ * does not have a value, and -EILSEQ if the string is not null-terminated
+ * within the length of the property data.
+ *
+ * The out_string pointer is modified only if a valid string can be decoded.
+ */
+int of_property_read_string(struct device_node *np, char *propname,
+                                const char **out_string)
+{
+        struct property *prop = of_find_property(np, propname, NULL);
+        if (!prop)
+                return -EINVAL;
+        if (!prop->value)
+                return -ENODATA;
+        if (strnlen(prop->value, prop->length) >= prop->length)
+                return -EILSEQ;
+        *out_string = prop->value;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_property_read_string);
+
+/**
  * 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
diff --git a/drivers/of/gpio.c b/drivers/of/gpio.c
index 905960338fb2..3007662ac614 100644
--- a/drivers/of/gpio.c
+++ b/drivers/of/gpio.c
@@ -21,8 +21,9 @@
 #include <linux/slab.h>
 
 /**
- * of_get_gpio_flags - Get a GPIO number and flags to use with GPIO API
+ * of_get_named_gpio_flags() - Get a GPIO number and flags to use with GPIO API
  * @np:         device node to get GPIO from
+ * @propname:   property name containing gpio specifier(s)
  * @index:      index of the GPIO
  * @flags:      a flags pointer to fill in
  *
@@ -30,8 +31,8 @@
  * value on the error condition. If @flags is not NULL the function also fills
  * in flags for the GPIO.
  */
-int of_get_gpio_flags(struct device_node *np, int index,
-                      enum of_gpio_flags *flags)
+int of_get_named_gpio_flags(struct device_node *np, const char *propname,
+                           int index, enum of_gpio_flags *flags)
 {
         int ret;
         struct device_node *gpio_np;
@@ -40,7 +41,7 @@ int of_get_gpio_flags(struct device_node *np, int index,
         const void *gpio_spec;
         const __be32 *gpio_cells;
 
-        ret = of_parse_phandles_with_args(np, "gpios", "#gpio-cells", index,
+        ret = of_parse_phandles_with_args(np, propname, "#gpio-cells", index,
                                           &gpio_np, &gpio_spec);
         if (ret) {
                 pr_debug("%s: can't parse gpios property\n", __func__);
@@ -79,7 +80,7 @@ err0:
         pr_debug("%s exited with status %d\n", __func__, ret);
         return ret;
 }
-EXPORT_SYMBOL(of_get_gpio_flags);
+EXPORT_SYMBOL(of_get_named_gpio_flags);
 
 /**
  * of_gpio_count - Count GPIOs for a device
diff --git a/drivers/of/of_pci.c b/drivers/of/of_pci.c
index ac1ec54e4fd5..3701b62c1d5e 100644
--- a/drivers/of/of_pci.c
+++ b/drivers/of/of_pci.c
@@ -1,92 +1,41 @@
 #include <linux/kernel.h>
+#include <linux/of.h>
 #include <linux/of_pci.h>
-#include <linux/of_irq.h>
 #include <asm/prom.h>
 
-/**
- * of_irq_map_pci - Resolve the interrupt for a PCI device
- * @pdev:       the device whose interrupt is to be resolved
- * @out_irq:    structure of_irq filled by this function
- *
- * This function resolves the PCI interrupt for a given PCI device. If a
- * device-node exists for a given pci_dev, it will use normal OF tree
- * walking. If not, it will implement standard swizzling and walk up the
- * PCI tree until an device-node is found, at which point it will finish
- * resolving using the OF tree walking.
- */
-int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
+static inline int __of_pci_pci_compare(struct device_node *node,
+                                       unsigned int devfn)
 {
-        struct device_node *dn, *ppnode;
-        struct pci_dev *ppdev;
-        u32 lspec;
-        __be32 lspec_be;
-        __be32 laddr[3];
-        u8 pin;
-        int rc;
+        unsigned int size;
+        const __be32 *reg = of_get_property(node, "reg", &size);
 
-        /* Check if we have a device node, if yes, fallback to standard
-         * device tree parsing
-         */
-        dn = pci_device_to_OF_node(pdev);
-        if (dn) {
-                rc = of_irq_map_one(dn, 0, out_irq);
-                if (!rc)
-                        return rc;
-        }
-
-        /* Ok, we don't, time to have fun. Let's start by building up an
-         * interrupt spec.  we assume #interrupt-cells is 1, which is standard
-         * for PCI. If you do different, then don't use that routine.
-         */
-        rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
-        if (rc != 0)
-                return rc;
-        /* No pin, exit */
-        if (pin == 0)
-                return -ENODEV;
-
-        /* Now we walk up the PCI tree */
-        lspec = pin;
-        for (;;) {
-                /* Get the pci_dev of our parent */
-                ppdev = pdev->bus->self;
-
-                /* Ouch, it's a host bridge... */
-                if (ppdev == NULL) {
-                        ppnode = pci_bus_to_OF_node(pdev->bus);
-
-                        /* No node for host bridge ? give up */
-                        if (ppnode == NULL)
-                                return -EINVAL;
-                } else {
-                        /* We found a P2P bridge, check if it has a node */
-                        ppnode = pci_device_to_OF_node(ppdev);
-                }
-
-                /* Ok, we have found a parent with a device-node, hand over to
-                 * the OF parsing code.
-                 * We build a unit address from the linux device to be used for
-                 * resolution. Note that we use the linux bus number which may
-                 * not match your firmware bus numbering.
-                 * Fortunately, in most cases, interrupt-map-mask doesn't
-                 * include the bus number as part of the matching.
-                 * You should still be careful about that though if you intend
-                 * to rely on this function (you ship  a firmware that doesn't
-                 * create device nodes for all PCI devices).
-                 */
-                if (ppnode)
-                        break;
+        if (!reg || size < 5 * sizeof(__be32))
+                return 0;
+        return ((be32_to_cpup(&reg[0]) >> 8) & 0xff) == devfn;
+}
 
-                /* We can only get here if we hit a P2P bridge with no node,
-                 * let's do standard swizzling and try again
+struct device_node *of_pci_find_child_device(struct device_node *parent,
+                                             unsigned int devfn)
+{
+        struct device_node *node, *node2;
+
+        for_each_child_of_node(parent, node) {
+                if (__of_pci_pci_compare(node, devfn))
+                        return node;
+                /*
+                 * Some OFs create a parent node "multifunc-device" as
+                 * a fake root for all functions of a multi-function
+                 * device we go down them as well.
                  */
-                lspec = pci_swizzle_interrupt_pin(pdev, lspec);
-                pdev = ppdev;
+                if (!strcmp(node->name, "multifunc-device")) {
+                        for_each_child_of_node(node, node2) {
+                                if (__of_pci_pci_compare(node2, devfn)) {
+                                        of_node_put(node);
+                                        return node2;
+                                }
+                        }
+                }
         }
-
-        lspec_be = cpu_to_be32(lspec);
-        laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
-        laddr[1]  = laddr[2] = cpu_to_be32(0);
-        return of_irq_map_raw(ppnode, &lspec_be, 1, laddr, out_irq);
+        return NULL;
 }
-EXPORT_SYMBOL_GPL(of_irq_map_pci);
+EXPORT_SYMBOL_GPL(of_pci_find_child_device);
diff --git a/drivers/of/of_pci_irq.c b/drivers/of/of_pci_irq.c
new file mode 100644
index 000000000000..ac1ec54e4fd5
--- /dev/null
+++ b/drivers/of/of_pci_irq.c
@@ -0,0 +1,92 @@
+#include <linux/kernel.h>
+#include <linux/of_pci.h>
+#include <linux/of_irq.h>
+#include <asm/prom.h>
+
+/**
+ * of_irq_map_pci - Resolve the interrupt for a PCI device
+ * @pdev:       the device whose interrupt is to be resolved
+ * @out_irq:    structure of_irq filled by this function
+ *
+ * This function resolves the PCI interrupt for a given PCI device. If a
+ * device-node exists for a given pci_dev, it will use normal OF tree
+ * walking. If not, it will implement standard swizzling and walk up the
+ * PCI tree until an device-node is found, at which point it will finish
+ * resolving using the OF tree walking.
+ */
+int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
+{
+        struct device_node *dn, *ppnode;
+        struct pci_dev *ppdev;
+        u32 lspec;
+        __be32 lspec_be;
+        __be32 laddr[3];
+        u8 pin;
+        int rc;
+
+        /* Check if we have a device node, if yes, fallback to standard
+         * device tree parsing
+         */
+        dn = pci_device_to_OF_node(pdev);
+        if (dn) {
+                rc = of_irq_map_one(dn, 0, out_irq);
+                if (!rc)
+                        return rc;
+        }
+
+        /* Ok, we don't, time to have fun. Let's start by building up an
+         * interrupt spec.  we assume #interrupt-cells is 1, which is standard
+         * for PCI. If you do different, then don't use that routine.
+         */
+        rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
+        if (rc != 0)
+                return rc;
+        /* No pin, exit */
+        if (pin == 0)
+                return -ENODEV;
+
+        /* Now we walk up the PCI tree */
+        lspec = pin;
+        for (;;) {
+                /* Get the pci_dev of our parent */
+                ppdev = pdev->bus->self;
+
+                /* Ouch, it's a host bridge... */
+                if (ppdev == NULL) {
+                        ppnode = pci_bus_to_OF_node(pdev->bus);
+
+                        /* No node for host bridge ? give up */
+                        if (ppnode == NULL)
+                                return -EINVAL;
+                } else {
+                        /* We found a P2P bridge, check if it has a node */
+                        ppnode = pci_device_to_OF_node(ppdev);
+                }
+
+                /* Ok, we have found a parent with a device-node, hand over to
+                 * the OF parsing code.
+                 * We build a unit address from the linux device to be used for
+                 * resolution. Note that we use the linux bus number which may
+                 * not match your firmware bus numbering.
+                 * Fortunately, in most cases, interrupt-map-mask doesn't
+                 * include the bus number as part of the matching.
+                 * You should still be careful about that though if you intend
+                 * to rely on this function (you ship  a firmware that doesn't
+                 * create device nodes for all PCI devices).
+                 */
+                if (ppnode)
+                        break;
+
+                /* We can only get here if we hit a P2P bridge with no node,
+                 * let's do standard swizzling and try again
+                 */
+                lspec = pci_swizzle_interrupt_pin(pdev, lspec);
+                pdev = ppdev;
+        }
+
+        lspec_be = cpu_to_be32(lspec);
+        laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
+        laddr[1]  = laddr[2] = cpu_to_be32(0);
+        return of_irq_map_raw(ppnode, &lspec_be, 1, laddr, out_irq);
+}
+EXPORT_SYMBOL_GPL(of_irq_map_pci);
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index cfc6a7969401..ed5a6d3c26aa 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -13,6 +13,7 @@
  */
 #include <linux/errno.h>
 #include <linux/module.h>
+#include <linux/amba/bus.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
@@ -22,6 +23,14 @@
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 
+const struct of_device_id of_default_bus_match_table[] = {
+        { .compatible = "simple-bus", },
+#ifdef CONFIG_ARM_AMBA
+        { .compatible = "arm,amba-bus", },
+#endif /* CONFIG_ARM_AMBA */
+        {} /* Empty terminated list */
+};
+
 static int of_dev_node_match(struct device *dev, void *data)
 {
         return dev->of_node == data;
@@ -168,17 +177,20 @@ struct platform_device *of_device_alloc(struct device_node *np,
 EXPORT_SYMBOL(of_device_alloc);
 
 /**
- * of_platform_device_create - Alloc, initialize and register an of_device
+ * of_platform_device_create_pdata - Alloc, initialize and register an of_device
  * @np: pointer to node to create device for
  * @bus_id: name to assign device
+ * @platform_data: pointer to populate platform_data pointer with
  * @parent: Linux device model parent device.
  *
  * 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(struct device_node *np,
-                                            const char *bus_id,
-                                            struct device *parent)
+struct platform_device *of_platform_device_create_pdata(
+                                        struct device_node *np,
+                                        const char *bus_id,
+                                        void *platform_data,
+                                        struct device *parent)
 {
         struct platform_device *dev;
 
@@ -194,6 +206,7 @@ struct platform_device *of_platform_device_create(struct device_node *np,
 #endif
         dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
         dev->dev.bus = &platform_bus_type;
+        dev->dev.platform_data = platform_data;
 
         /* We do not fill the DMA ops for platform devices by default.
          * This is currently the responsibility of the platform code
@@ -207,8 +220,111 @@ struct platform_device *of_platform_device_create(struct device_node *np,
 
         return dev;
 }
+
+/**
+ * of_platform_device_create - Alloc, initialize and register an of_device
+ * @np: pointer to node to create device for
+ * @bus_id: name to assign device
+ * @parent: Linux device model parent device.
+ *
+ * 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(struct device_node *np,
+                                            const char *bus_id,
+                                            struct device *parent)
+{
+        return of_platform_device_create_pdata(np, bus_id, NULL, parent);
+}
 EXPORT_SYMBOL(of_platform_device_create);
 
+#ifdef CONFIG_ARM_AMBA
+static struct amba_device *of_amba_device_create(struct device_node *node,
+                                                 const char *bus_id,
+                                                 void *platform_data,
+                                                 struct device *parent)
+{
+        struct amba_device *dev;
+        const void *prop;
+        int i, ret;
+
+        pr_debug("Creating amba device %s\n", node->full_name);
+
+        if (!of_device_is_available(node))
+                return NULL;
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return NULL;
+
+        /* setup generic device info */
+        dev->dev.coherent_dma_mask = ~0;
+        dev->dev.of_node = of_node_get(node);
+        dev->dev.parent = parent;
+        dev->dev.platform_data = platform_data;
+        if (bus_id)
+                dev_set_name(&dev->dev, "%s", bus_id);
+        else
+                of_device_make_bus_id(&dev->dev);
+
+        /* setup amba-specific device info */
+        dev->dma_mask = ~0;
+
+        /* Allow the HW Peripheral ID to be overridden */
+        prop = of_get_property(node, "arm,primecell-periphid", NULL);
+        if (prop)
+                dev->periphid = of_read_ulong(prop, 1);
+
+        /* Decode the IRQs and address ranges */
+        for (i = 0; i < AMBA_NR_IRQS; i++)
+                dev->irq[i] = irq_of_parse_and_map(node, i);
+
+        ret = of_address_to_resource(node, 0, &dev->res);
+        if (ret)
+                goto err_free;
+
+        ret = amba_device_register(dev, &iomem_resource);
+        if (ret)
+                goto err_free;
+
+        return dev;
+
+err_free:
+        kfree(dev);
+        return NULL;
+}
+#else /* CONFIG_ARM_AMBA */
+static struct amba_device *of_amba_device_create(struct device_node *node,
+                                                 const char *bus_id,
+                                                 void *platform_data,
+                                                 struct device *parent)
+{
+        return NULL;
+}
+#endif /* CONFIG_ARM_AMBA */
+
+/**
+ * of_devname_lookup() - Given a device node, lookup the preferred Linux name
+ */
+static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
+                                 struct device_node *np)
+{
+        struct resource res;
+        if (lookup) {
+                for(; lookup->name != NULL; lookup++) {
+                        if (!of_device_is_compatible(np, lookup->compatible))
+                                continue;
+                        if (of_address_to_resource(np, 0, &res))
+                                continue;
+                        if (res.start != lookup->phys_addr)
+                                continue;
+                        pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
+                        return lookup;
+                }
+        }
+        return NULL;
+}
+
 /**
  * of_platform_bus_create() - Create a device for a node and its children.
  * @bus: device node of the bus to instantiate
@@ -221,19 +337,41 @@ EXPORT_SYMBOL(of_platform_device_create);
  */
 static int of_platform_bus_create(struct device_node *bus,
                                   const struct of_device_id *matches,
-                                  struct device *parent)
+                                  const struct of_dev_auxdata *lookup,
+                                  struct device *parent, bool strict)
 {
+        const struct of_dev_auxdata *auxdata;
         struct device_node *child;
         struct platform_device *dev;
+        const char *bus_id = NULL;
+        void *platform_data = NULL;
         int rc = 0;
 
-        dev = of_platform_device_create(bus, NULL, parent);
+        /* Make sure it has a compatible property */
+        if (strict && (!of_get_property(bus, "compatible", NULL))) {
+                pr_debug("%s() - skipping %s, no compatible prop\n",
+                         __func__, bus->full_name);
+                return 0;
+        }
+
+        auxdata = of_dev_lookup(lookup, bus);
+        if (auxdata) {
+                bus_id = auxdata->name;
+                platform_data = auxdata->platform_data;
+        }
+
+        if (of_device_is_compatible(bus, "arm,primecell")) {
+                of_amba_device_create(bus, bus_id, platform_data, parent);
+                return 0;
+        }
+
+        dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
         if (!dev || !of_match_node(matches, bus))
                 return 0;
 
         for_each_child_of_node(bus, child) {
                 pr_debug("   create child: %s\n", child->full_name);
-                rc = of_platform_bus_create(child, matches, &dev->dev);
+                rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
                 if (rc) {
                         of_node_put(child);
                         break;
@@ -267,11 +405,11 @@ int of_platform_bus_probe(struct device_node *root,
 
         /* Do a self check of bus type, if there's a match, create children */
         if (of_match_node(matches, root)) {
-                rc = of_platform_bus_create(root, matches, parent);
+                rc = of_platform_bus_create(root, matches, NULL, parent, false);
         } else for_each_child_of_node(root, child) {
                 if (!of_match_node(matches, child))
                         continue;
-                rc = of_platform_bus_create(child, matches, parent);
+                rc = of_platform_bus_create(child, matches, NULL, parent, false);
                 if (rc)
                         break;
         }
@@ -280,4 +418,44 @@ int of_platform_bus_probe(struct device_node *root,
         return rc;
 }
 EXPORT_SYMBOL(of_platform_bus_probe);
+
+/**
+ * of_platform_populate() - Populate platform_devices from device tree data
+ * @root: parent of the first level to probe or NULL for the root of the tree
+ * @matches: match table, NULL to use the default
+ * @parent: parent to hook devices from, NULL for toplevel
+ *
+ * Similar to of_platform_bus_probe(), this function walks the device tree
+ * and creates devices from nodes.  It differs in that it follows the modern
+ * convention of requiring all device nodes to have a 'compatible' property,
+ * and it is suitable for creating devices which are children of the root
+ * node (of_platform_bus_probe will only create children of the root which
+ * are selected by the @matches argument).
+ *
+ * New board support should be using this function instead of
+ * of_platform_bus_probe().
+ *
+ * Returns 0 on success, < 0 on failure.
+ */
+int of_platform_populate(struct device_node *root,
+                        const struct of_device_id *matches,
+                        const struct of_dev_auxdata *lookup,
+                        struct device *parent)
+{
+        struct device_node *child;
+        int rc = 0;
+
+        root = root ? of_node_get(root) : of_find_node_by_path("/");
+        if (!root)
+                return -EINVAL;
+
+        for_each_child_of_node(root, child) {
+                rc = of_platform_bus_create(child, matches, lookup, parent, true);
+                if (rc)
+                        break;
+        }
+
+        of_node_put(root);
+        return rc;
+}
 #endif /* !CONFIG_SPARC */