2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
3 * <benh@kernel.crashing.org>
4 * and Arnd Bergmann, IBM Corp.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
15 #include <linux/string.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/mod_devicetable.h>
20 #include <linux/pci.h>
22 #include <linux/of_device.h>
23 #include <linux/of_platform.h>
25 #include <asm/errno.h>
26 #include <asm/topology.h>
27 #include <asm/pci-bridge.h>
28 #include <asm/ppc-pci.h>
29 #include <asm/atomic.h>
32 * The list of OF IDs below is used for matching bus types in the
33 * system whose devices are to be exposed as of_platform_devices.
35 * This is the default list valid for most platforms. This file provides
36 * functions who can take an explicit list if necessary though
38 * The search is always performed recursively looking for children of
39 * the provided device_node and recursively if such a children matches
40 * a bus type in the list
43 static const struct of_device_id of_default_bus_ids[] = {
45 { .compatible = "soc", },
46 { .type = "spider", },
55 struct bus_type of_platform_bus_type = {
56 .uevent = of_device_uevent,
58 EXPORT_SYMBOL(of_platform_bus_type);
60 static int __init of_bus_driver_init(void)
62 return of_bus_type_init(&of_platform_bus_type, "of_platform");
65 postcore_initcall(of_bus_driver_init);
67 struct of_device* of_platform_device_create(struct device_node *np,
69 struct device *parent)
71 struct of_device *dev;
73 dev = of_device_alloc(np, bus_id, parent);
77 dev->dma_mask = 0xffffffffUL;
78 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
80 dev->dev.bus = &of_platform_bus_type;
82 /* We do not fill the DMA ops for platform devices by default.
83 * This is currently the responsibility of the platform code
84 * to do such, possibly using a device notifier
87 if (of_device_register(dev) != 0) {
94 EXPORT_SYMBOL(of_platform_device_create);
99 * of_platform_bus_create - Create an OF device for a bus node and all its
100 * children. Optionally recursively instanciate matching busses.
101 * @bus: device node of the bus to instanciate
102 * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
103 * disallow recursive creation of child busses
105 static int of_platform_bus_create(const struct device_node *bus,
106 const struct of_device_id *matches,
107 struct device *parent)
109 struct device_node *child;
110 struct of_device *dev;
113 for_each_child_of_node(bus, child) {
114 pr_debug(" create child: %s\n", child->full_name);
115 dev = of_platform_device_create(child, NULL, parent);
118 else if (!of_match_node(matches, child))
121 pr_debug(" and sub busses\n");
122 rc = of_platform_bus_create(child, matches, &dev->dev);
132 * of_platform_bus_probe - Probe the device-tree for platform busses
133 * @root: parent of the first level to probe or NULL for the root of the tree
134 * @matches: match table, NULL to use the default
135 * @parent: parent to hook devices from, NULL for toplevel
137 * Note that children of the provided root are not instanciated as devices
138 * unless the specified root itself matches the bus list and is not NULL.
141 int of_platform_bus_probe(struct device_node *root,
142 const struct of_device_id *matches,
143 struct device *parent)
145 struct device_node *child;
146 struct of_device *dev;
150 matches = of_default_bus_ids;
151 if (matches == OF_NO_DEEP_PROBE)
154 root = of_find_node_by_path("/");
158 pr_debug("of_platform_bus_probe()\n");
159 pr_debug(" starting at: %s\n", root->full_name);
161 /* Do a self check of bus type, if there's a match, create
164 if (of_match_node(matches, root)) {
165 pr_debug(" root match, create all sub devices\n");
166 dev = of_platform_device_create(root, NULL, parent);
171 pr_debug(" create all sub busses\n");
172 rc = of_platform_bus_create(root, matches, &dev->dev);
175 for_each_child_of_node(root, child) {
176 if (!of_match_node(matches, child))
179 pr_debug(" match: %s\n", child->full_name);
180 dev = of_platform_device_create(child, NULL, parent);
184 rc = of_platform_bus_create(child, matches, &dev->dev);
194 EXPORT_SYMBOL(of_platform_bus_probe);
196 static int of_dev_node_match(struct device *dev, void *data)
198 return to_of_device(dev)->node == data;
201 struct of_device *of_find_device_by_node(struct device_node *np)
205 dev = bus_find_device(&of_platform_bus_type,
206 NULL, np, of_dev_node_match);
208 return to_of_device(dev);
211 EXPORT_SYMBOL(of_find_device_by_node);
213 static int of_dev_phandle_match(struct device *dev, void *data)
216 return to_of_device(dev)->node->phandle == *ph;
219 struct of_device *of_find_device_by_phandle(phandle ph)
223 dev = bus_find_device(&of_platform_bus_type,
224 NULL, &ph, of_dev_phandle_match);
226 return to_of_device(dev);
229 EXPORT_SYMBOL(of_find_device_by_phandle);
232 #ifdef CONFIG_PPC_OF_PLATFORM_PCI
234 /* The probing of PCI controllers from of_platform is currently
235 * 64 bits only, mostly due to gratuitous differences between
236 * the 32 and 64 bits PCI code on PowerPC and the 32 bits one
237 * lacking some bits needed here.
240 static int __devinit of_pci_phb_probe(struct of_device *dev,
241 const struct of_device_id *match)
243 struct pci_controller *phb;
245 /* Check if we can do that ... */
246 if (ppc_md.pci_setup_phb == NULL)
249 printk(KERN_INFO "Setting up PCI bus %s\n", dev->node->full_name);
251 /* Alloc and setup PHB data structure */
252 phb = pcibios_alloc_controller(dev->node);
256 /* Setup parent in sysfs */
257 phb->parent = &dev->dev;
259 /* Setup the PHB using arch provided callback */
260 if (ppc_md.pci_setup_phb(phb)) {
261 pcibios_free_controller(phb);
265 /* Process "ranges" property */
266 pci_process_bridge_OF_ranges(phb, dev->node, 0);
268 /* Init pci_dn data structures */
269 pci_devs_phb_init_dynamic(phb);
271 /* Register devices with EEH */
273 if (dev->node->child)
274 eeh_add_device_tree_early(dev->node);
275 #endif /* CONFIG_EEH */
278 pcibios_scan_phb(phb, dev->node);
279 if (phb->bus == NULL)
282 /* Claim resources. This might need some rework as well depending
283 * wether we are doing probe-only or not, like assigning unassigned
286 pcibios_claim_one_bus(phb->bus);
288 /* Finish EEH setup */
290 eeh_add_device_tree_late(phb->bus);
293 /* Add probed PCI devices to the device model */
294 pci_bus_add_devices(phb->bus);
299 static struct of_device_id of_pci_phb_ids[] = {
303 { .type = "pciex", },
308 static struct of_platform_driver of_pci_phb_driver = {
309 .match_table = of_pci_phb_ids,
310 .probe = of_pci_phb_probe,
316 static __init int of_pci_phb_init(void)
318 return of_register_platform_driver(&of_pci_phb_driver);
321 device_initcall(of_pci_phb_init);
323 #endif /* CONFIG_PPC_OF_PLATFORM_PCI */