2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
3 * <benh@kernel.crashing.org>
4 * and Arnd Bergmann, IBM Corp.
5 * Merged from powerpc/kernel/of_platform.c and
6 * sparc{,64}/kernel/of_device.c by Stephen Rothwell
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/errno.h>
15 #include <linux/module.h>
16 #include <linux/amba/bus.h>
17 #include <linux/device.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/slab.h>
20 #include <linux/of_address.h>
21 #include <linux/of_device.h>
22 #include <linux/of_irq.h>
23 #include <linux/of_platform.h>
24 #include <linux/of_reserved_mem.h>
25 #include <linux/platform_device.h>
27 const struct of_device_id of_default_bus_match_table
[] = {
28 { .compatible
= "simple-bus", },
29 #ifdef CONFIG_ARM_AMBA
30 { .compatible
= "arm,amba-bus", },
31 #endif /* CONFIG_ARM_AMBA */
32 {} /* Empty terminated list */
35 static int of_dev_node_match(struct device
*dev
, void *data
)
37 return dev
->of_node
== data
;
41 * of_find_device_by_node - Find the platform_device associated with a node
42 * @np: Pointer to device tree node
44 * Returns platform_device pointer, or NULL if not found
46 struct platform_device
*of_find_device_by_node(struct device_node
*np
)
50 dev
= bus_find_device(&platform_bus_type
, NULL
, np
, of_dev_node_match
);
51 return dev
? to_platform_device(dev
) : NULL
;
53 EXPORT_SYMBOL(of_find_device_by_node
);
55 #if defined(CONFIG_PPC_DCR)
59 #ifdef CONFIG_OF_ADDRESS
61 * The following routines scan a subtree and registers a device for
62 * each applicable node.
64 * Note: sparc doesn't use these routines because it has a different
65 * mechanism for creating devices from device tree nodes.
69 * of_device_make_bus_id - Use the device node data to assign a unique name
70 * @dev: pointer to device structure that is linked to a device tree node
72 * This routine will first try using either the dcr-reg or the reg property
73 * value to derive a unique name. As a last resort it will use the node
74 * name followed by a unique number.
76 void of_device_make_bus_id(struct device
*dev
)
78 static atomic_t bus_no_reg_magic
;
79 struct device_node
*node
= dev
->of_node
;
87 * If it's a DCR based device, use 'd' for native DCRs
88 * and 'D' for MMIO DCRs.
90 reg
= of_get_property(node
, "dcr-reg", NULL
);
92 #ifdef CONFIG_PPC_DCR_NATIVE
93 dev_set_name(dev
, "d%x.%s", *reg
, node
->name
);
94 #else /* CONFIG_PPC_DCR_NATIVE */
95 u64 addr
= of_translate_dcr_address(node
, *reg
, NULL
);
96 if (addr
!= OF_BAD_ADDR
) {
97 dev_set_name(dev
, "D%llx.%s",
98 (unsigned long long)addr
, node
->name
);
101 #endif /* !CONFIG_PPC_DCR_NATIVE */
103 #endif /* CONFIG_PPC_DCR */
106 * For MMIO, get the physical address
108 reg
= of_get_property(node
, "reg", NULL
);
110 if (of_can_translate_address(node
)) {
111 addr
= of_translate_address(node
, reg
);
113 addrp
= of_get_address(node
, 0, NULL
, NULL
);
115 addr
= of_read_number(addrp
, 1);
119 if (addr
!= OF_BAD_ADDR
) {
120 dev_set_name(dev
, "%llx.%s",
121 (unsigned long long)addr
, node
->name
);
127 * No BusID, use the node name and add a globally incremented
128 * counter (and pray...)
130 magic
= atomic_add_return(1, &bus_no_reg_magic
);
131 dev_set_name(dev
, "%s.%d", node
->name
, magic
- 1);
135 * of_device_alloc - Allocate and initialize an of_device
136 * @np: device node to assign to device
137 * @bus_id: Name to assign to the device. May be null to use default name.
138 * @parent: Parent device.
140 struct platform_device
*of_device_alloc(struct device_node
*np
,
142 struct device
*parent
)
144 struct platform_device
*dev
;
145 int rc
, i
, num_reg
= 0, num_irq
;
146 struct resource
*res
, temp_res
;
148 dev
= platform_device_alloc("", -1);
152 /* count the io and irq resources */
153 if (of_can_translate_address(np
))
154 while (of_address_to_resource(np
, num_reg
, &temp_res
) == 0)
156 num_irq
= of_irq_count(np
);
158 /* Populate the resource table */
159 if (num_irq
|| num_reg
) {
160 res
= kzalloc(sizeof(*res
) * (num_irq
+ num_reg
), GFP_KERNEL
);
162 platform_device_put(dev
);
166 dev
->num_resources
= num_reg
+ num_irq
;
168 for (i
= 0; i
< num_reg
; i
++, res
++) {
169 rc
= of_address_to_resource(np
, i
, res
);
172 WARN_ON(of_irq_to_resource_table(np
, res
, num_irq
) != num_irq
);
175 dev
->dev
.of_node
= of_node_get(np
);
176 #if defined(CONFIG_MICROBLAZE)
177 dev
->dev
.dma_mask
= &dev
->archdata
.dma_mask
;
179 dev
->dev
.parent
= parent
;
182 dev_set_name(&dev
->dev
, "%s", bus_id
);
184 of_device_make_bus_id(&dev
->dev
);
188 EXPORT_SYMBOL(of_device_alloc
);
191 * of_platform_device_create_pdata - Alloc, initialize and register an of_device
192 * @np: pointer to node to create device for
193 * @bus_id: name to assign device
194 * @platform_data: pointer to populate platform_data pointer with
195 * @parent: Linux device model parent device.
197 * Returns pointer to created platform device, or NULL if a device was not
198 * registered. Unavailable devices will not get registered.
200 static struct platform_device
*of_platform_device_create_pdata(
201 struct device_node
*np
,
204 struct device
*parent
)
206 struct platform_device
*dev
;
208 if (!of_device_is_available(np
))
211 dev
= of_device_alloc(np
, bus_id
, parent
);
215 #if defined(CONFIG_MICROBLAZE)
216 dev
->archdata
.dma_mask
= 0xffffffffUL
;
218 dev
->dev
.coherent_dma_mask
= DMA_BIT_MASK(32);
219 dev
->dev
.bus
= &platform_bus_type
;
220 dev
->dev
.platform_data
= platform_data
;
222 of_reserved_mem_device_init(&dev
->dev
);
224 /* We do not fill the DMA ops for platform devices by default.
225 * This is currently the responsibility of the platform code
226 * to do such, possibly using a device notifier
229 if (of_device_add(dev
) != 0) {
230 platform_device_put(dev
);
231 of_reserved_mem_device_release(&dev
->dev
);
239 * of_platform_device_create - Alloc, initialize and register an of_device
240 * @np: pointer to node to create device for
241 * @bus_id: name to assign device
242 * @parent: Linux device model parent device.
244 * Returns pointer to created platform device, or NULL if a device was not
245 * registered. Unavailable devices will not get registered.
247 struct platform_device
*of_platform_device_create(struct device_node
*np
,
249 struct device
*parent
)
251 return of_platform_device_create_pdata(np
, bus_id
, NULL
, parent
);
253 EXPORT_SYMBOL(of_platform_device_create
);
255 #ifdef CONFIG_ARM_AMBA
256 static struct amba_device
*of_amba_device_create(struct device_node
*node
,
259 struct device
*parent
)
261 struct amba_device
*dev
;
265 pr_debug("Creating amba device %s\n", node
->full_name
);
267 if (!of_device_is_available(node
))
270 dev
= amba_device_alloc(NULL
, 0, 0);
272 pr_err("%s(): amba_device_alloc() failed for %s\n",
273 __func__
, node
->full_name
);
277 /* setup generic device info */
278 dev
->dev
.coherent_dma_mask
= ~0;
279 dev
->dev
.of_node
= of_node_get(node
);
280 dev
->dev
.parent
= parent
;
281 dev
->dev
.platform_data
= platform_data
;
283 dev_set_name(&dev
->dev
, "%s", bus_id
);
285 of_device_make_bus_id(&dev
->dev
);
287 /* setup amba-specific device info */
290 /* Allow the HW Peripheral ID to be overridden */
291 prop
= of_get_property(node
, "arm,primecell-periphid", NULL
);
293 dev
->periphid
= of_read_ulong(prop
, 1);
295 /* Decode the IRQs and address ranges */
296 for (i
= 0; i
< AMBA_NR_IRQS
; i
++)
297 dev
->irq
[i
] = irq_of_parse_and_map(node
, i
);
299 ret
= of_address_to_resource(node
, 0, &dev
->res
);
301 pr_err("%s(): of_address_to_resource() failed (%d) for %s\n",
302 __func__
, ret
, node
->full_name
);
306 ret
= amba_device_add(dev
, &iomem_resource
);
308 pr_err("%s(): amba_device_add() failed (%d) for %s\n",
309 __func__
, ret
, node
->full_name
);
316 amba_device_put(dev
);
319 #else /* CONFIG_ARM_AMBA */
320 static struct amba_device
*of_amba_device_create(struct device_node
*node
,
323 struct device
*parent
)
327 #endif /* CONFIG_ARM_AMBA */
330 * of_devname_lookup() - Given a device node, lookup the preferred Linux name
332 static const struct of_dev_auxdata
*of_dev_lookup(const struct of_dev_auxdata
*lookup
,
333 struct device_node
*np
)
340 for(; lookup
->compatible
!= NULL
; lookup
++) {
341 if (!of_device_is_compatible(np
, lookup
->compatible
))
343 if (!of_address_to_resource(np
, 0, &res
))
344 if (res
.start
!= lookup
->phys_addr
)
346 pr_debug("%s: devname=%s\n", np
->full_name
, lookup
->name
);
354 * of_platform_bus_create() - Create a device for a node and its children.
355 * @bus: device node of the bus to instantiate
356 * @matches: match table for bus nodes
357 * @lookup: auxdata table for matching id and platform_data with device nodes
358 * @parent: parent for new device, or NULL for top level.
359 * @strict: require compatible property
361 * Creates a platform_device for the provided device_node, and optionally
362 * recursively create devices for all the child nodes.
364 static int of_platform_bus_create(struct device_node
*bus
,
365 const struct of_device_id
*matches
,
366 const struct of_dev_auxdata
*lookup
,
367 struct device
*parent
, bool strict
)
369 const struct of_dev_auxdata
*auxdata
;
370 struct device_node
*child
;
371 struct platform_device
*dev
;
372 const char *bus_id
= NULL
;
373 void *platform_data
= NULL
;
376 /* Make sure it has a compatible property */
377 if (strict
&& (!of_get_property(bus
, "compatible", NULL
))) {
378 pr_debug("%s() - skipping %s, no compatible prop\n",
379 __func__
, bus
->full_name
);
383 auxdata
= of_dev_lookup(lookup
, bus
);
385 bus_id
= auxdata
->name
;
386 platform_data
= auxdata
->platform_data
;
389 if (of_device_is_compatible(bus
, "arm,primecell")) {
391 * Don't return an error here to keep compatibility with older
394 of_amba_device_create(bus
, bus_id
, platform_data
, parent
);
398 dev
= of_platform_device_create_pdata(bus
, bus_id
, platform_data
, parent
);
399 if (!dev
|| !of_match_node(matches
, bus
))
402 for_each_child_of_node(bus
, child
) {
403 pr_debug(" create child: %s\n", child
->full_name
);
404 rc
= of_platform_bus_create(child
, matches
, lookup
, &dev
->dev
, strict
);
414 * of_platform_bus_probe() - Probe the device-tree for platform buses
415 * @root: parent of the first level to probe or NULL for the root of the tree
416 * @matches: match table for bus nodes
417 * @parent: parent to hook devices from, NULL for toplevel
419 * Note that children of the provided root are not instantiated as devices
420 * unless the specified root itself matches the bus list and is not NULL.
422 int of_platform_bus_probe(struct device_node
*root
,
423 const struct of_device_id
*matches
,
424 struct device
*parent
)
426 struct device_node
*child
;
429 root
= root
? of_node_get(root
) : of_find_node_by_path("/");
433 pr_debug("of_platform_bus_probe()\n");
434 pr_debug(" starting at: %s\n", root
->full_name
);
436 /* Do a self check of bus type, if there's a match, create children */
437 if (of_match_node(matches
, root
)) {
438 rc
= of_platform_bus_create(root
, matches
, NULL
, parent
, false);
439 } else for_each_child_of_node(root
, child
) {
440 if (!of_match_node(matches
, child
))
442 rc
= of_platform_bus_create(child
, matches
, NULL
, parent
, false);
450 EXPORT_SYMBOL(of_platform_bus_probe
);
453 * of_platform_populate() - Populate platform_devices from device tree data
454 * @root: parent of the first level to probe or NULL for the root of the tree
455 * @matches: match table, NULL to use the default
456 * @lookup: auxdata table for matching id and platform_data with device nodes
457 * @parent: parent to hook devices from, NULL for toplevel
459 * Similar to of_platform_bus_probe(), this function walks the device tree
460 * and creates devices from nodes. It differs in that it follows the modern
461 * convention of requiring all device nodes to have a 'compatible' property,
462 * and it is suitable for creating devices which are children of the root
463 * node (of_platform_bus_probe will only create children of the root which
464 * are selected by the @matches argument).
466 * New board support should be using this function instead of
467 * of_platform_bus_probe().
469 * Returns 0 on success, < 0 on failure.
471 int of_platform_populate(struct device_node
*root
,
472 const struct of_device_id
*matches
,
473 const struct of_dev_auxdata
*lookup
,
474 struct device
*parent
)
476 struct device_node
*child
;
479 root
= root
? of_node_get(root
) : of_find_node_by_path("/");
483 for_each_child_of_node(root
, child
) {
484 rc
= of_platform_bus_create(child
, matches
, lookup
, parent
, true);
492 EXPORT_SYMBOL_GPL(of_platform_populate
);
493 #endif /* CONFIG_OF_ADDRESS */