13f23de10SStephen Rothwell /* 23f23de10SStephen Rothwell * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. 33f23de10SStephen Rothwell * <benh@kernel.crashing.org> 43f23de10SStephen Rothwell * and Arnd Bergmann, IBM Corp. 53f23de10SStephen Rothwell * Merged from powerpc/kernel/of_platform.c and 63f23de10SStephen Rothwell * sparc{,64}/kernel/of_device.c by Stephen Rothwell 73f23de10SStephen Rothwell * 83f23de10SStephen Rothwell * This program is free software; you can redistribute it and/or 93f23de10SStephen Rothwell * modify it under the terms of the GNU General Public License 103f23de10SStephen Rothwell * as published by the Free Software Foundation; either version 113f23de10SStephen Rothwell * 2 of the License, or (at your option) any later version. 123f23de10SStephen Rothwell * 133f23de10SStephen Rothwell */ 143f23de10SStephen Rothwell #include <linux/errno.h> 155c457083SStephen Rothwell #include <linux/module.h> 165de1540bSGrant Likely #include <linux/amba/bus.h> 173f23de10SStephen Rothwell #include <linux/device.h> 185fd200f3SGrant Likely #include <linux/dma-mapping.h> 1950ef5284SGrant Likely #include <linux/slab.h> 209e3288dcSGrant Likely #include <linux/of_address.h> 213f23de10SStephen Rothwell #include <linux/of_device.h> 229e3288dcSGrant Likely #include <linux/of_irq.h> 233f23de10SStephen Rothwell #include <linux/of_platform.h> 24eca39301SGrant Likely #include <linux/platform_device.h> 25eca39301SGrant Likely 26cbb49c26SGrant Likely const struct of_device_id of_default_bus_match_table[] = { 27cbb49c26SGrant Likely { .compatible = "simple-bus", }, 28cbb49c26SGrant Likely #ifdef CONFIG_ARM_AMBA 29cbb49c26SGrant Likely { .compatible = "arm,amba-bus", }, 30cbb49c26SGrant Likely #endif /* CONFIG_ARM_AMBA */ 31cbb49c26SGrant Likely {} /* Empty terminated list */ 32cbb49c26SGrant Likely }; 33cbb49c26SGrant Likely 34c6085584SJonas Bonn static int of_dev_node_match(struct device *dev, void *data) 35c6085584SJonas Bonn { 36c6085584SJonas Bonn return dev->of_node == data; 37c6085584SJonas Bonn } 38c6085584SJonas Bonn 39c6085584SJonas Bonn /** 40c6085584SJonas Bonn * of_find_device_by_node - Find the platform_device associated with a node 41c6085584SJonas Bonn * @np: Pointer to device tree node 42c6085584SJonas Bonn * 43c6085584SJonas Bonn * Returns platform_device pointer, or NULL if not found 44c6085584SJonas Bonn */ 45c6085584SJonas Bonn struct platform_device *of_find_device_by_node(struct device_node *np) 46c6085584SJonas Bonn { 47c6085584SJonas Bonn struct device *dev; 48c6085584SJonas Bonn 49c6085584SJonas Bonn dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match); 50c6085584SJonas Bonn return dev ? to_platform_device(dev) : NULL; 51c6085584SJonas Bonn } 52c6085584SJonas Bonn EXPORT_SYMBOL(of_find_device_by_node); 53c6085584SJonas Bonn 54596c955cSGrant Likely #if defined(CONFIG_PPC_DCR) 55596c955cSGrant Likely #include <asm/dcr.h> 56596c955cSGrant Likely #endif 57596c955cSGrant Likely 585fd200f3SGrant Likely #if !defined(CONFIG_SPARC) 595fd200f3SGrant Likely /* 605fd200f3SGrant Likely * The following routines scan a subtree and registers a device for 615fd200f3SGrant Likely * each applicable node. 625fd200f3SGrant Likely * 635fd200f3SGrant Likely * Note: sparc doesn't use these routines because it has a different 645fd200f3SGrant Likely * mechanism for creating devices from device tree nodes. 655fd200f3SGrant Likely */ 665fd200f3SGrant Likely 675fd200f3SGrant Likely /** 6894c09319SGrant Likely * of_device_make_bus_id - Use the device node data to assign a unique name 6994c09319SGrant Likely * @dev: pointer to device structure that is linked to a device tree node 7094c09319SGrant Likely * 7194c09319SGrant Likely * This routine will first try using either the dcr-reg or the reg property 7294c09319SGrant Likely * value to derive a unique name. As a last resort it will use the node 7394c09319SGrant Likely * name followed by a unique number. 7494c09319SGrant Likely */ 75c6601225SGrant Likely void of_device_make_bus_id(struct device *dev) 7694c09319SGrant Likely { 7794c09319SGrant Likely static atomic_t bus_no_reg_magic; 7894c09319SGrant Likely struct device_node *node = dev->of_node; 7994c09319SGrant Likely const u32 *reg; 8094c09319SGrant Likely u64 addr; 8194c09319SGrant Likely int magic; 8294c09319SGrant Likely 8394c09319SGrant Likely #ifdef CONFIG_PPC_DCR 8494c09319SGrant Likely /* 8594c09319SGrant Likely * If it's a DCR based device, use 'd' for native DCRs 8694c09319SGrant Likely * and 'D' for MMIO DCRs. 8794c09319SGrant Likely */ 8894c09319SGrant Likely reg = of_get_property(node, "dcr-reg", NULL); 8994c09319SGrant Likely if (reg) { 9094c09319SGrant Likely #ifdef CONFIG_PPC_DCR_NATIVE 9194c09319SGrant Likely dev_set_name(dev, "d%x.%s", *reg, node->name); 9294c09319SGrant Likely #else /* CONFIG_PPC_DCR_NATIVE */ 9394c09319SGrant Likely u64 addr = of_translate_dcr_address(node, *reg, NULL); 9494c09319SGrant Likely if (addr != OF_BAD_ADDR) { 9594c09319SGrant Likely dev_set_name(dev, "D%llx.%s", 9694c09319SGrant Likely (unsigned long long)addr, node->name); 9794c09319SGrant Likely return; 9894c09319SGrant Likely } 9994c09319SGrant Likely #endif /* !CONFIG_PPC_DCR_NATIVE */ 10094c09319SGrant Likely } 10194c09319SGrant Likely #endif /* CONFIG_PPC_DCR */ 10294c09319SGrant Likely 10394c09319SGrant Likely /* 10494c09319SGrant Likely * For MMIO, get the physical address 10594c09319SGrant Likely */ 10694c09319SGrant Likely reg = of_get_property(node, "reg", NULL); 10794c09319SGrant Likely if (reg) { 10894c09319SGrant Likely addr = of_translate_address(node, reg); 10994c09319SGrant Likely if (addr != OF_BAD_ADDR) { 11094c09319SGrant Likely dev_set_name(dev, "%llx.%s", 11194c09319SGrant Likely (unsigned long long)addr, node->name); 11294c09319SGrant Likely return; 11394c09319SGrant Likely } 11494c09319SGrant Likely } 11594c09319SGrant Likely 11694c09319SGrant Likely /* 11794c09319SGrant Likely * No BusID, use the node name and add a globally incremented 11894c09319SGrant Likely * counter (and pray...) 11994c09319SGrant Likely */ 12094c09319SGrant Likely magic = atomic_add_return(1, &bus_no_reg_magic); 12194c09319SGrant Likely dev_set_name(dev, "%s.%d", node->name, magic - 1); 12294c09319SGrant Likely } 12394c09319SGrant Likely 12494c09319SGrant Likely /** 12594c09319SGrant Likely * of_device_alloc - Allocate and initialize an of_device 12694c09319SGrant Likely * @np: device node to assign to device 12794c09319SGrant Likely * @bus_id: Name to assign to the device. May be null to use default name. 12894c09319SGrant Likely * @parent: Parent device. 12994c09319SGrant Likely */ 13094a0cb1fSGrant Likely struct platform_device *of_device_alloc(struct device_node *np, 13194c09319SGrant Likely const char *bus_id, 13294c09319SGrant Likely struct device *parent) 13394c09319SGrant Likely { 13494a0cb1fSGrant Likely struct platform_device *dev; 13552f6537cSAndres Salomon int rc, i, num_reg = 0, num_irq; 136ac80a51eSGrant Likely struct resource *res, temp_res; 13794c09319SGrant Likely 1387096d042SGrant Likely dev = platform_device_alloc("", -1); 1397096d042SGrant Likely if (!dev) 1407096d042SGrant Likely return NULL; 1417096d042SGrant Likely 1427096d042SGrant Likely /* count the io and irq resources */ 143ac80a51eSGrant Likely while (of_address_to_resource(np, num_reg, &temp_res) == 0) 144ac80a51eSGrant Likely num_reg++; 14552f6537cSAndres Salomon num_irq = of_irq_count(np); 146ac80a51eSGrant Likely 147ac80a51eSGrant Likely /* Populate the resource table */ 148ac80a51eSGrant Likely if (num_irq || num_reg) { 1497096d042SGrant Likely res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); 1507096d042SGrant Likely if (!res) { 1517096d042SGrant Likely platform_device_put(dev); 1527096d042SGrant Likely return NULL; 1537096d042SGrant Likely } 1547096d042SGrant Likely 155ac80a51eSGrant Likely dev->num_resources = num_reg + num_irq; 156ac80a51eSGrant Likely dev->resource = res; 157ac80a51eSGrant Likely for (i = 0; i < num_reg; i++, res++) { 158ac80a51eSGrant Likely rc = of_address_to_resource(np, i, res); 159ac80a51eSGrant Likely WARN_ON(rc); 160ac80a51eSGrant Likely } 16152f6537cSAndres Salomon WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq); 162ac80a51eSGrant Likely } 16394c09319SGrant Likely 16494c09319SGrant Likely dev->dev.of_node = of_node_get(np); 1659e3288dcSGrant Likely #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 16694c09319SGrant Likely dev->dev.dma_mask = &dev->archdata.dma_mask; 1679e3288dcSGrant Likely #endif 16894c09319SGrant Likely dev->dev.parent = parent; 16994c09319SGrant Likely 17094c09319SGrant Likely if (bus_id) 17194c09319SGrant Likely dev_set_name(&dev->dev, "%s", bus_id); 17294c09319SGrant Likely else 17394c09319SGrant Likely of_device_make_bus_id(&dev->dev); 17494c09319SGrant Likely 17594c09319SGrant Likely return dev; 17694c09319SGrant Likely } 17794c09319SGrant Likely EXPORT_SYMBOL(of_device_alloc); 17894c09319SGrant Likely 17994c09319SGrant Likely /** 180*15c3597dSGrant Likely * of_platform_device_create_pdata - Alloc, initialize and register an of_device 1815fd200f3SGrant Likely * @np: pointer to node to create device for 1825fd200f3SGrant Likely * @bus_id: name to assign device 183*15c3597dSGrant Likely * @platform_data: pointer to populate platform_data pointer with 1845fd200f3SGrant Likely * @parent: Linux device model parent device. 185cd1e6504SGrant Likely * 186cd1e6504SGrant Likely * Returns pointer to created platform device, or NULL if a device was not 187cd1e6504SGrant Likely * registered. Unavailable devices will not get registered. 1885fd200f3SGrant Likely */ 189*15c3597dSGrant Likely struct platform_device *of_platform_device_create_pdata( 190*15c3597dSGrant Likely struct device_node *np, 1915fd200f3SGrant Likely const char *bus_id, 192*15c3597dSGrant Likely void *platform_data, 1935fd200f3SGrant Likely struct device *parent) 1945fd200f3SGrant Likely { 19594a0cb1fSGrant Likely struct platform_device *dev; 1965fd200f3SGrant Likely 197cd1e6504SGrant Likely if (!of_device_is_available(np)) 198cd1e6504SGrant Likely return NULL; 199cd1e6504SGrant Likely 2005fd200f3SGrant Likely dev = of_device_alloc(np, bus_id, parent); 2015fd200f3SGrant Likely if (!dev) 2025fd200f3SGrant Likely return NULL; 2035fd200f3SGrant Likely 2049e3288dcSGrant Likely #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 2055fd200f3SGrant Likely dev->archdata.dma_mask = 0xffffffffUL; 2069e3288dcSGrant Likely #endif 2075fd200f3SGrant Likely dev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 208eca39301SGrant Likely dev->dev.bus = &platform_bus_type; 209*15c3597dSGrant Likely dev->dev.platform_data = platform_data; 2105fd200f3SGrant Likely 2115fd200f3SGrant Likely /* We do not fill the DMA ops for platform devices by default. 2125fd200f3SGrant Likely * This is currently the responsibility of the platform code 2135fd200f3SGrant Likely * to do such, possibly using a device notifier 2145fd200f3SGrant Likely */ 2155fd200f3SGrant Likely 2167096d042SGrant Likely if (of_device_add(dev) != 0) { 2177096d042SGrant Likely platform_device_put(dev); 2185fd200f3SGrant Likely return NULL; 2195fd200f3SGrant Likely } 2205fd200f3SGrant Likely 2215fd200f3SGrant Likely return dev; 2225fd200f3SGrant Likely } 223*15c3597dSGrant Likely 224*15c3597dSGrant Likely /** 225*15c3597dSGrant Likely * of_platform_device_create - Alloc, initialize and register an of_device 226*15c3597dSGrant Likely * @np: pointer to node to create device for 227*15c3597dSGrant Likely * @bus_id: name to assign device 228*15c3597dSGrant Likely * @parent: Linux device model parent device. 229*15c3597dSGrant Likely * 230*15c3597dSGrant Likely * Returns pointer to created platform device, or NULL if a device was not 231*15c3597dSGrant Likely * registered. Unavailable devices will not get registered. 232*15c3597dSGrant Likely */ 233*15c3597dSGrant Likely struct platform_device *of_platform_device_create(struct device_node *np, 234*15c3597dSGrant Likely const char *bus_id, 235*15c3597dSGrant Likely struct device *parent) 236*15c3597dSGrant Likely { 237*15c3597dSGrant Likely return of_platform_device_create_pdata(np, bus_id, NULL, parent); 238*15c3597dSGrant Likely } 2395fd200f3SGrant Likely EXPORT_SYMBOL(of_platform_device_create); 2405fd200f3SGrant Likely 2415de1540bSGrant Likely #ifdef CONFIG_ARM_AMBA 2425de1540bSGrant Likely static struct amba_device *of_amba_device_create(struct device_node *node, 2435de1540bSGrant Likely const char *bus_id, 2445de1540bSGrant Likely void *platform_data, 2455de1540bSGrant Likely struct device *parent) 2465de1540bSGrant Likely { 2475de1540bSGrant Likely struct amba_device *dev; 2485de1540bSGrant Likely const void *prop; 2495de1540bSGrant Likely int i, ret; 2505de1540bSGrant Likely 2515de1540bSGrant Likely pr_debug("Creating amba device %s\n", node->full_name); 2525de1540bSGrant Likely 2535de1540bSGrant Likely if (!of_device_is_available(node)) 2545de1540bSGrant Likely return NULL; 2555de1540bSGrant Likely 2565de1540bSGrant Likely dev = kzalloc(sizeof(*dev), GFP_KERNEL); 2575de1540bSGrant Likely if (!dev) 2585de1540bSGrant Likely return NULL; 2595de1540bSGrant Likely 2605de1540bSGrant Likely /* setup generic device info */ 2615de1540bSGrant Likely dev->dev.coherent_dma_mask = ~0; 2625de1540bSGrant Likely dev->dev.of_node = of_node_get(node); 2635de1540bSGrant Likely dev->dev.parent = parent; 2645de1540bSGrant Likely dev->dev.platform_data = platform_data; 2655de1540bSGrant Likely if (bus_id) 2665de1540bSGrant Likely dev_set_name(&dev->dev, "%s", bus_id); 2675de1540bSGrant Likely else 2685de1540bSGrant Likely of_device_make_bus_id(&dev->dev); 2695de1540bSGrant Likely 2705de1540bSGrant Likely /* setup amba-specific device info */ 2715de1540bSGrant Likely dev->dma_mask = ~0; 2725de1540bSGrant Likely 2735de1540bSGrant Likely /* Allow the HW Peripheral ID to be overridden */ 2745de1540bSGrant Likely prop = of_get_property(node, "arm,primecell-periphid", NULL); 2755de1540bSGrant Likely if (prop) 2765de1540bSGrant Likely dev->periphid = of_read_ulong(prop, 1); 2775de1540bSGrant Likely 2785de1540bSGrant Likely /* Decode the IRQs and address ranges */ 2795de1540bSGrant Likely for (i = 0; i < AMBA_NR_IRQS; i++) 2805de1540bSGrant Likely dev->irq[i] = irq_of_parse_and_map(node, i); 2815de1540bSGrant Likely 2825de1540bSGrant Likely ret = of_address_to_resource(node, 0, &dev->res); 2835de1540bSGrant Likely if (ret) 2845de1540bSGrant Likely goto err_free; 2855de1540bSGrant Likely 2865de1540bSGrant Likely ret = amba_device_register(dev, &iomem_resource); 2875de1540bSGrant Likely if (ret) 2885de1540bSGrant Likely goto err_free; 2895de1540bSGrant Likely 2905de1540bSGrant Likely return dev; 2915de1540bSGrant Likely 2925de1540bSGrant Likely err_free: 2935de1540bSGrant Likely kfree(dev); 2945de1540bSGrant Likely return NULL; 2955de1540bSGrant Likely } 2965de1540bSGrant Likely #else /* CONFIG_ARM_AMBA */ 2975de1540bSGrant Likely static struct amba_device *of_amba_device_create(struct device_node *node, 2985de1540bSGrant Likely const char *bus_id, 2995de1540bSGrant Likely void *platform_data, 3005de1540bSGrant Likely struct device *parent) 3015de1540bSGrant Likely { 3025de1540bSGrant Likely return NULL; 3035de1540bSGrant Likely } 3045de1540bSGrant Likely #endif /* CONFIG_ARM_AMBA */ 3055de1540bSGrant Likely 3065fd200f3SGrant Likely /** 307*15c3597dSGrant Likely * of_devname_lookup() - Given a device node, lookup the preferred Linux name 308*15c3597dSGrant Likely */ 309*15c3597dSGrant Likely static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup, 310*15c3597dSGrant Likely struct device_node *np) 311*15c3597dSGrant Likely { 312*15c3597dSGrant Likely struct resource res; 313*15c3597dSGrant Likely if (lookup) { 314*15c3597dSGrant Likely for(; lookup->name != NULL; lookup++) { 315*15c3597dSGrant Likely if (!of_device_is_compatible(np, lookup->compatible)) 316*15c3597dSGrant Likely continue; 317*15c3597dSGrant Likely if (of_address_to_resource(np, 0, &res)) 318*15c3597dSGrant Likely continue; 319*15c3597dSGrant Likely if (res.start != lookup->phys_addr) 320*15c3597dSGrant Likely continue; 321*15c3597dSGrant Likely pr_debug("%s: devname=%s\n", np->full_name, lookup->name); 322*15c3597dSGrant Likely return lookup; 323*15c3597dSGrant Likely } 324*15c3597dSGrant Likely } 325*15c3597dSGrant Likely return NULL; 326*15c3597dSGrant Likely } 327*15c3597dSGrant Likely 328*15c3597dSGrant Likely /** 32938e9e21dSGrant Likely * of_platform_bus_create() - Create a device for a node and its children. 3305fd200f3SGrant Likely * @bus: device node of the bus to instantiate 3311eed4c07SGrant Likely * @matches: match table for bus nodes 33238e9e21dSGrant Likely * disallow recursive creation of child buses 33338e9e21dSGrant Likely * @parent: parent for new device, or NULL for top level. 33438e9e21dSGrant Likely * 33538e9e21dSGrant Likely * Creates a platform_device for the provided device_node, and optionally 33638e9e21dSGrant Likely * recursively create devices for all the child nodes. 3375fd200f3SGrant Likely */ 33838e9e21dSGrant Likely static int of_platform_bus_create(struct device_node *bus, 3395fd200f3SGrant Likely const struct of_device_id *matches, 340*15c3597dSGrant Likely const struct of_dev_auxdata *lookup, 34129d4f8a4SGrant Likely struct device *parent, bool strict) 3425fd200f3SGrant Likely { 343*15c3597dSGrant Likely const struct of_dev_auxdata *auxdata; 3445fd200f3SGrant Likely struct device_node *child; 34594a0cb1fSGrant Likely struct platform_device *dev; 346*15c3597dSGrant Likely const char *bus_id = NULL; 347*15c3597dSGrant Likely void *platform_data = NULL; 3485fd200f3SGrant Likely int rc = 0; 3495fd200f3SGrant Likely 35029d4f8a4SGrant Likely /* Make sure it has a compatible property */ 35129d4f8a4SGrant Likely if (strict && (!of_get_property(bus, "compatible", NULL))) { 35229d4f8a4SGrant Likely pr_debug("%s() - skipping %s, no compatible prop\n", 35329d4f8a4SGrant Likely __func__, bus->full_name); 35429d4f8a4SGrant Likely return 0; 35529d4f8a4SGrant Likely } 35629d4f8a4SGrant Likely 357*15c3597dSGrant Likely auxdata = of_dev_lookup(lookup, bus); 358*15c3597dSGrant Likely if (auxdata) { 359*15c3597dSGrant Likely bus_id = auxdata->name; 360*15c3597dSGrant Likely platform_data = auxdata->platform_data; 361*15c3597dSGrant Likely } 362*15c3597dSGrant Likely 3635de1540bSGrant Likely if (of_device_is_compatible(bus, "arm,primecell")) { 364*15c3597dSGrant Likely of_amba_device_create(bus, bus_id, platform_data, parent); 3655de1540bSGrant Likely return 0; 3665de1540bSGrant Likely } 3675de1540bSGrant Likely 368*15c3597dSGrant Likely dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent); 36938e9e21dSGrant Likely if (!dev || !of_match_node(matches, bus)) 37038e9e21dSGrant Likely return 0; 37138e9e21dSGrant Likely 3725fd200f3SGrant Likely for_each_child_of_node(bus, child) { 3735fd200f3SGrant Likely pr_debug(" create child: %s\n", child->full_name); 374*15c3597dSGrant Likely rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict); 3755fd200f3SGrant Likely if (rc) { 3765fd200f3SGrant Likely of_node_put(child); 3775fd200f3SGrant Likely break; 3785fd200f3SGrant Likely } 3795fd200f3SGrant Likely } 3805fd200f3SGrant Likely return rc; 3815fd200f3SGrant Likely } 3825fd200f3SGrant Likely 3835fd200f3SGrant Likely /** 38438e9e21dSGrant Likely * of_platform_bus_probe() - Probe the device-tree for platform buses 3855fd200f3SGrant Likely * @root: parent of the first level to probe or NULL for the root of the tree 3861eed4c07SGrant Likely * @matches: match table for bus nodes 3875fd200f3SGrant Likely * @parent: parent to hook devices from, NULL for toplevel 3885fd200f3SGrant Likely * 3895fd200f3SGrant Likely * Note that children of the provided root are not instantiated as devices 3905fd200f3SGrant Likely * unless the specified root itself matches the bus list and is not NULL. 3915fd200f3SGrant Likely */ 3925fd200f3SGrant Likely int of_platform_bus_probe(struct device_node *root, 3935fd200f3SGrant Likely const struct of_device_id *matches, 3945fd200f3SGrant Likely struct device *parent) 3955fd200f3SGrant Likely { 3965fd200f3SGrant Likely struct device_node *child; 3975fd200f3SGrant Likely int rc = 0; 3985fd200f3SGrant Likely 3991eed4c07SGrant Likely root = root ? of_node_get(root) : of_find_node_by_path("/"); 4001eed4c07SGrant Likely if (!root) 40160d59913SGrant Likely return -EINVAL; 4025fd200f3SGrant Likely 4035fd200f3SGrant Likely pr_debug("of_platform_bus_probe()\n"); 4045fd200f3SGrant Likely pr_debug(" starting at: %s\n", root->full_name); 4055fd200f3SGrant Likely 4061eed4c07SGrant Likely /* Do a self check of bus type, if there's a match, create children */ 4075fd200f3SGrant Likely if (of_match_node(matches, root)) { 408*15c3597dSGrant Likely rc = of_platform_bus_create(root, matches, NULL, parent, false); 40938e9e21dSGrant Likely } else for_each_child_of_node(root, child) { 4105fd200f3SGrant Likely if (!of_match_node(matches, child)) 4115fd200f3SGrant Likely continue; 412*15c3597dSGrant Likely rc = of_platform_bus_create(child, matches, NULL, parent, false); 41338e9e21dSGrant Likely if (rc) 4145fd200f3SGrant Likely break; 4155fd200f3SGrant Likely } 41638e9e21dSGrant Likely 4175fd200f3SGrant Likely of_node_put(root); 4185fd200f3SGrant Likely return rc; 4195fd200f3SGrant Likely } 4205fd200f3SGrant Likely EXPORT_SYMBOL(of_platform_bus_probe); 42129d4f8a4SGrant Likely 42229d4f8a4SGrant Likely /** 42329d4f8a4SGrant Likely * of_platform_populate() - Populate platform_devices from device tree data 42429d4f8a4SGrant Likely * @root: parent of the first level to probe or NULL for the root of the tree 42529d4f8a4SGrant Likely * @matches: match table, NULL to use the default 42629d4f8a4SGrant Likely * @parent: parent to hook devices from, NULL for toplevel 42729d4f8a4SGrant Likely * 42829d4f8a4SGrant Likely * Similar to of_platform_bus_probe(), this function walks the device tree 42929d4f8a4SGrant Likely * and creates devices from nodes. It differs in that it follows the modern 43029d4f8a4SGrant Likely * convention of requiring all device nodes to have a 'compatible' property, 43129d4f8a4SGrant Likely * and it is suitable for creating devices which are children of the root 43229d4f8a4SGrant Likely * node (of_platform_bus_probe will only create children of the root which 43329d4f8a4SGrant Likely * are selected by the @matches argument). 43429d4f8a4SGrant Likely * 43529d4f8a4SGrant Likely * New board support should be using this function instead of 43629d4f8a4SGrant Likely * of_platform_bus_probe(). 43729d4f8a4SGrant Likely * 43829d4f8a4SGrant Likely * Returns 0 on success, < 0 on failure. 43929d4f8a4SGrant Likely */ 44029d4f8a4SGrant Likely int of_platform_populate(struct device_node *root, 44129d4f8a4SGrant Likely const struct of_device_id *matches, 442*15c3597dSGrant Likely const struct of_dev_auxdata *lookup, 44329d4f8a4SGrant Likely struct device *parent) 44429d4f8a4SGrant Likely { 44529d4f8a4SGrant Likely struct device_node *child; 44629d4f8a4SGrant Likely int rc = 0; 44729d4f8a4SGrant Likely 44829d4f8a4SGrant Likely root = root ? of_node_get(root) : of_find_node_by_path("/"); 44929d4f8a4SGrant Likely if (!root) 45029d4f8a4SGrant Likely return -EINVAL; 45129d4f8a4SGrant Likely 45229d4f8a4SGrant Likely for_each_child_of_node(root, child) { 453*15c3597dSGrant Likely rc = of_platform_bus_create(child, matches, lookup, parent, true); 45429d4f8a4SGrant Likely if (rc) 45529d4f8a4SGrant Likely break; 45629d4f8a4SGrant Likely } 45729d4f8a4SGrant Likely 45829d4f8a4SGrant Likely of_node_put(root); 45929d4f8a4SGrant Likely return rc; 46029d4f8a4SGrant Likely } 4615fd200f3SGrant Likely #endif /* !CONFIG_SPARC */ 462