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/slab.h>
21 #include <linux/pci.h>
23 #include <asm/errno.h>
25 #include <asm/of_device.h>
26 #include <asm/of_platform.h>
27 #include <asm/topology.h>
28 #include <asm/pci-bridge.h>
29 #include <asm/ppc-pci.h>
30 #include <asm/atomic.h>
33 * The list of OF IDs below is used for matching bus types in the
34 * system whose devices are to be exposed as of_platform_devices.
36 * This is the default list valid for most platforms. This file provides
37 * functions who can take an explicit list if necessary though
39 * The search is always performed recursively looking for children of
40 * the provided device_node and recursively if such a children matches
41 * a bus type in the list
44 static struct of_device_id of_default_bus_ids
[] = {
46 { .compatible
= "soc", },
47 { .type
= "spider", },
56 static atomic_t bus_no_reg_magic
;
60 * OF platform device type definition & base infrastructure
64 static int of_platform_bus_match(struct device
*dev
, struct device_driver
*drv
)
66 struct of_device
* of_dev
= to_of_device(dev
);
67 struct of_platform_driver
* of_drv
= to_of_platform_driver(drv
);
68 const struct of_device_id
* matches
= of_drv
->match_table
;
73 return of_match_device(matches
, of_dev
) != NULL
;
76 static int of_platform_device_probe(struct device
*dev
)
79 struct of_platform_driver
*drv
;
80 struct of_device
*of_dev
;
81 const struct of_device_id
*match
;
83 drv
= to_of_platform_driver(dev
->driver
);
84 of_dev
= to_of_device(dev
);
91 match
= of_match_device(drv
->match_table
, of_dev
);
93 error
= drv
->probe(of_dev
, match
);
100 static int of_platform_device_remove(struct device
*dev
)
102 struct of_device
* of_dev
= to_of_device(dev
);
103 struct of_platform_driver
* drv
= to_of_platform_driver(dev
->driver
);
105 if (dev
->driver
&& drv
->remove
)
110 static int of_platform_device_suspend(struct device
*dev
, pm_message_t state
)
112 struct of_device
* of_dev
= to_of_device(dev
);
113 struct of_platform_driver
* drv
= to_of_platform_driver(dev
->driver
);
116 if (dev
->driver
&& drv
->suspend
)
117 error
= drv
->suspend(of_dev
, state
);
121 static int of_platform_device_resume(struct device
* dev
)
123 struct of_device
* of_dev
= to_of_device(dev
);
124 struct of_platform_driver
* drv
= to_of_platform_driver(dev
->driver
);
127 if (dev
->driver
&& drv
->resume
)
128 error
= drv
->resume(of_dev
);
132 struct bus_type of_platform_bus_type
= {
133 .name
= "of_platform",
134 .match
= of_platform_bus_match
,
135 .uevent
= of_device_uevent
,
136 .probe
= of_platform_device_probe
,
137 .remove
= of_platform_device_remove
,
138 .suspend
= of_platform_device_suspend
,
139 .resume
= of_platform_device_resume
,
141 EXPORT_SYMBOL(of_platform_bus_type
);
143 static int __init
of_bus_driver_init(void)
145 return bus_register(&of_platform_bus_type
);
148 postcore_initcall(of_bus_driver_init
);
150 int of_register_platform_driver(struct of_platform_driver
*drv
)
152 /* initialize common driver fields */
153 drv
->driver
.name
= drv
->name
;
154 drv
->driver
.bus
= &of_platform_bus_type
;
156 /* register with core */
157 return driver_register(&drv
->driver
);
159 EXPORT_SYMBOL(of_register_platform_driver
);
161 void of_unregister_platform_driver(struct of_platform_driver
*drv
)
163 driver_unregister(&drv
->driver
);
165 EXPORT_SYMBOL(of_unregister_platform_driver
);
167 static void of_platform_make_bus_id(struct of_device
*dev
)
169 struct device_node
*node
= dev
->node
;
170 char *name
= dev
->dev
.bus_id
;
176 * If it's a DCR based device, use 'd' for native DCRs
177 * and 'D' for MMIO DCRs.
179 #ifdef CONFIG_PPC_DCR
180 reg
= of_get_property(node
, "dcr-reg", NULL
);
182 #ifdef CONFIG_PPC_DCR_NATIVE
183 snprintf(name
, BUS_ID_SIZE
, "d%x.%s",
185 #else /* CONFIG_PPC_DCR_NATIVE */
186 addr
= of_translate_dcr_address(node
, *reg
, NULL
);
187 if (addr
!= OF_BAD_ADDR
) {
188 snprintf(name
, BUS_ID_SIZE
,
189 "D%llx.%s", (unsigned long long)addr
,
193 #endif /* !CONFIG_PPC_DCR_NATIVE */
195 #endif /* CONFIG_PPC_DCR */
198 * For MMIO, get the physical address
200 reg
= of_get_property(node
, "reg", NULL
);
202 addr
= of_translate_address(node
, reg
);
203 if (addr
!= OF_BAD_ADDR
) {
204 snprintf(name
, BUS_ID_SIZE
,
205 "%llx.%s", (unsigned long long)addr
,
212 * No BusID, use the node name and add a globally incremented
213 * counter (and pray...)
215 magic
= atomic_add_return(1, &bus_no_reg_magic
);
216 snprintf(name
, BUS_ID_SIZE
, "%s.%d", node
->name
, magic
- 1);
219 struct of_device
* of_platform_device_create(struct device_node
*np
,
221 struct device
*parent
)
223 struct of_device
*dev
;
225 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
229 dev
->node
= of_node_get(np
);
230 dev
->dma_mask
= 0xffffffffUL
;
231 dev
->dev
.dma_mask
= &dev
->dma_mask
;
232 dev
->dev
.parent
= parent
;
233 dev
->dev
.bus
= &of_platform_bus_type
;
234 dev
->dev
.release
= of_release_dev
;
235 dev
->dev
.archdata
.of_node
= np
;
236 dev
->dev
.archdata
.numa_node
= of_node_to_nid(np
);
238 /* We do not fill the DMA ops for platform devices by default.
239 * This is currently the responsibility of the platform code
240 * to do such, possibly using a device notifier
244 strlcpy(dev
->dev
.bus_id
, bus_id
, BUS_ID_SIZE
);
246 of_platform_make_bus_id(dev
);
248 if (of_device_register(dev
) != 0) {
255 EXPORT_SYMBOL(of_platform_device_create
);
260 * of_platform_bus_create - Create an OF device for a bus node and all its
261 * children. Optionally recursively instanciate matching busses.
262 * @bus: device node of the bus to instanciate
263 * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
264 * disallow recursive creation of child busses
266 static int of_platform_bus_create(struct device_node
*bus
,
267 struct of_device_id
*matches
,
268 struct device
*parent
)
270 struct device_node
*child
;
271 struct of_device
*dev
;
274 for (child
= NULL
; (child
= of_get_next_child(bus
, child
)); ) {
275 pr_debug(" create child: %s\n", child
->full_name
);
276 dev
= of_platform_device_create(child
, NULL
, parent
);
279 else if (!of_match_node(matches
, child
))
282 pr_debug(" and sub busses\n");
283 rc
= of_platform_bus_create(child
, matches
, &dev
->dev
);
293 * of_platform_bus_probe - Probe the device-tree for platform busses
294 * @root: parent of the first level to probe or NULL for the root of the tree
295 * @matches: match table, NULL to use the default
296 * @parent: parent to hook devices from, NULL for toplevel
298 * Note that children of the provided root are not instanciated as devices
299 * unless the specified root itself matches the bus list and is not NULL.
302 int of_platform_bus_probe(struct device_node
*root
,
303 struct of_device_id
*matches
,
304 struct device
*parent
)
306 struct device_node
*child
;
307 struct of_device
*dev
;
311 matches
= of_default_bus_ids
;
312 if (matches
== OF_NO_DEEP_PROBE
)
315 root
= of_find_node_by_path("/");
319 pr_debug("of_platform_bus_probe()\n");
320 pr_debug(" starting at: %s\n", root
->full_name
);
322 /* Do a self check of bus type, if there's a match, create
325 if (of_match_node(matches
, root
)) {
326 pr_debug(" root match, create all sub devices\n");
327 dev
= of_platform_device_create(root
, NULL
, parent
);
332 pr_debug(" create all sub busses\n");
333 rc
= of_platform_bus_create(root
, matches
, &dev
->dev
);
336 for (child
= NULL
; (child
= of_get_next_child(root
, child
)); ) {
337 if (!of_match_node(matches
, child
))
340 pr_debug(" match: %s\n", child
->full_name
);
341 dev
= of_platform_device_create(child
, NULL
, parent
);
345 rc
= of_platform_bus_create(child
, matches
, &dev
->dev
);
355 EXPORT_SYMBOL(of_platform_bus_probe
);
357 static int of_dev_node_match(struct device
*dev
, void *data
)
359 return to_of_device(dev
)->node
== data
;
362 struct of_device
*of_find_device_by_node(struct device_node
*np
)
366 dev
= bus_find_device(&of_platform_bus_type
,
367 NULL
, np
, of_dev_node_match
);
369 return to_of_device(dev
);
372 EXPORT_SYMBOL(of_find_device_by_node
);
374 static int of_dev_phandle_match(struct device
*dev
, void *data
)
377 return to_of_device(dev
)->node
->linux_phandle
== *ph
;
380 struct of_device
*of_find_device_by_phandle(phandle ph
)
384 dev
= bus_find_device(&of_platform_bus_type
,
385 NULL
, &ph
, of_dev_phandle_match
);
387 return to_of_device(dev
);
390 EXPORT_SYMBOL(of_find_device_by_phandle
);
393 #ifdef CONFIG_PPC_OF_PLATFORM_PCI
395 /* The probing of PCI controllers from of_platform is currently
396 * 64 bits only, mostly due to gratuitous differences between
397 * the 32 and 64 bits PCI code on PowerPC and the 32 bits one
398 * lacking some bits needed here.
401 static int __devinit
of_pci_phb_probe(struct of_device
*dev
,
402 const struct of_device_id
*match
)
404 struct pci_controller
*phb
;
406 /* Check if we can do that ... */
407 if (ppc_md
.pci_setup_phb
== NULL
)
410 printk(KERN_INFO
"Setting up PCI bus %s\n", dev
->node
->full_name
);
412 /* Alloc and setup PHB data structure */
413 phb
= pcibios_alloc_controller(dev
->node
);
417 /* Setup parent in sysfs */
418 phb
->parent
= &dev
->dev
;
420 /* Setup the PHB using arch provided callback */
421 if (ppc_md
.pci_setup_phb(phb
)) {
422 pcibios_free_controller(phb
);
426 /* Process "ranges" property */
427 pci_process_bridge_OF_ranges(phb
, dev
->node
, 0);
429 /* Init pci_dn data structures */
430 pci_devs_phb_init_dynamic(phb
);
432 /* Register devices with EEH */
434 if (dev
->node
->child
)
435 eeh_add_device_tree_early(dev
->node
);
436 #endif /* CONFIG_EEH */
441 /* Claim resources. This might need some rework as well depending
442 * wether we are doing probe-only or not, like assigning unassigned
445 pcibios_claim_one_bus(phb
->bus
);
447 /* Finish EEH setup */
449 eeh_add_device_tree_late(phb
->bus
);
452 /* Add probed PCI devices to the device model */
453 pci_bus_add_devices(phb
->bus
);
458 static struct of_device_id of_pci_phb_ids
[] = {
462 { .type
= "pciex", },
467 static struct of_platform_driver of_pci_phb_driver
= {
469 .match_table
= of_pci_phb_ids
,
470 .probe
= of_pci_phb_probe
,
473 static __init
int of_pci_phb_init(void)
475 return of_register_platform_driver(&of_pci_phb_driver
);
478 device_initcall(of_pci_phb_init
);
480 #endif /* CONFIG_PPC_OF_PLATFORM_PCI */