Branch data Line data Source code
1 : : /*
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
7 : : *
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.
12 : : *
13 : : */
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/platform_device.h>
25 : :
26 : : const struct of_device_id of_default_bus_match_table[] = {
27 : : { .compatible = "simple-bus", },
28 : : #ifdef CONFIG_ARM_AMBA
29 : : { .compatible = "arm,amba-bus", },
30 : : #endif /* CONFIG_ARM_AMBA */
31 : : {} /* Empty terminated list */
32 : : };
33 : :
34 : 0 : static int of_dev_node_match(struct device *dev, void *data)
35 : : {
36 : 0 : return dev->of_node == data;
37 : : }
38 : :
39 : : /**
40 : : * of_find_device_by_node - Find the platform_device associated with a node
41 : : * @np: Pointer to device tree node
42 : : *
43 : : * Returns platform_device pointer, or NULL if not found
44 : : */
45 : 0 : struct platform_device *of_find_device_by_node(struct device_node *np)
46 : : {
47 : : struct device *dev;
48 : :
49 : 0 : dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
50 [ # # ]: 0 : return dev ? to_platform_device(dev) : NULL;
51 : : }
52 : : EXPORT_SYMBOL(of_find_device_by_node);
53 : :
54 : : #if defined(CONFIG_PPC_DCR)
55 : : #include <asm/dcr.h>
56 : : #endif
57 : :
58 : : #ifdef CONFIG_OF_ADDRESS
59 : : /*
60 : : * The following routines scan a subtree and registers a device for
61 : : * each applicable node.
62 : : *
63 : : * Note: sparc doesn't use these routines because it has a different
64 : : * mechanism for creating devices from device tree nodes.
65 : : */
66 : :
67 : : /**
68 : : * of_device_make_bus_id - Use the device node data to assign a unique name
69 : : * @dev: pointer to device structure that is linked to a device tree node
70 : : *
71 : : * This routine will first try using either the dcr-reg or the reg property
72 : : * value to derive a unique name. As a last resort it will use the node
73 : : * name followed by a unique number.
74 : : */
75 : 0 : void of_device_make_bus_id(struct device *dev)
76 : : {
77 : : static atomic_t bus_no_reg_magic;
78 : 0 : struct device_node *node = dev->of_node;
79 : : const __be32 *reg;
80 : : u64 addr;
81 : : const __be32 *addrp;
82 : : int magic;
83 : :
84 : : #ifdef CONFIG_PPC_DCR
85 : : /*
86 : : * If it's a DCR based device, use 'd' for native DCRs
87 : : * and 'D' for MMIO DCRs.
88 : : */
89 : : reg = of_get_property(node, "dcr-reg", NULL);
90 : : if (reg) {
91 : : #ifdef CONFIG_PPC_DCR_NATIVE
92 : : dev_set_name(dev, "d%x.%s", *reg, node->name);
93 : : #else /* CONFIG_PPC_DCR_NATIVE */
94 : : u64 addr = of_translate_dcr_address(node, *reg, NULL);
95 : : if (addr != OF_BAD_ADDR) {
96 : : dev_set_name(dev, "D%llx.%s",
97 : : (unsigned long long)addr, node->name);
98 : : return;
99 : : }
100 : : #endif /* !CONFIG_PPC_DCR_NATIVE */
101 : : }
102 : : #endif /* CONFIG_PPC_DCR */
103 : :
104 : : /*
105 : : * For MMIO, get the physical address
106 : : */
107 : 0 : reg = of_get_property(node, "reg", NULL);
108 [ # # ]: 0 : if (reg) {
109 [ # # ]: 0 : if (of_can_translate_address(node)) {
110 : 0 : addr = of_translate_address(node, reg);
111 : : } else {
112 : 0 : addrp = of_get_address(node, 0, NULL, NULL);
113 [ # # ]: 0 : if (addrp)
114 : : addr = of_read_number(addrp, 1);
115 : : else
116 : : addr = OF_BAD_ADDR;
117 : : }
118 [ # # ]: 0 : if (addr != OF_BAD_ADDR) {
119 : 0 : dev_set_name(dev, "%llx.%s",
120 : : (unsigned long long)addr, node->name);
121 : 0 : return;
122 : : }
123 : : }
124 : :
125 : : /*
126 : : * No BusID, use the node name and add a globally incremented
127 : : * counter (and pray...)
128 : : */
129 : : magic = atomic_add_return(1, &bus_no_reg_magic);
130 : 0 : dev_set_name(dev, "%s.%d", node->name, magic - 1);
131 : : }
132 : :
133 : : /**
134 : : * of_device_alloc - Allocate and initialize an of_device
135 : : * @np: device node to assign to device
136 : : * @bus_id: Name to assign to the device. May be null to use default name.
137 : : * @parent: Parent device.
138 : : */
139 : 0 : struct platform_device *of_device_alloc(struct device_node *np,
140 : : const char *bus_id,
141 : : struct device *parent)
142 : : {
143 : : struct platform_device *dev;
144 : : int rc, i, num_reg = 0, num_irq;
145 : : struct resource *res, temp_res;
146 : :
147 : 0 : dev = platform_device_alloc("", -1);
148 [ # # ]: 0 : if (!dev)
149 : : return NULL;
150 : :
151 : : /* count the io and irq resources */
152 [ # # ]: 0 : if (of_can_translate_address(np))
153 [ # # ]: 0 : while (of_address_to_resource(np, num_reg, &temp_res) == 0)
154 : 0 : num_reg++;
155 : 0 : num_irq = of_irq_count(np);
156 : :
157 : : /* Populate the resource table */
158 [ # # ]: 0 : if (num_irq || num_reg) {
159 : 0 : res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
160 [ # # ]: 0 : if (!res) {
161 : 0 : platform_device_put(dev);
162 : 0 : return NULL;
163 : : }
164 : :
165 : 0 : dev->num_resources = num_reg + num_irq;
166 : 0 : dev->resource = res;
167 [ # # ]: 0 : for (i = 0; i < num_reg; i++, res++) {
168 : 0 : rc = of_address_to_resource(np, i, res);
169 [ # # ]: 0 : WARN_ON(rc);
170 : : }
171 [ # # ]: 0 : WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq);
172 : : }
173 : :
174 : 0 : dev->dev.of_node = of_node_get(np);
175 : : #if defined(CONFIG_MICROBLAZE)
176 : : dev->dev.dma_mask = &dev->archdata.dma_mask;
177 : : #endif
178 : 0 : dev->dev.parent = parent;
179 : :
180 [ # # ]: 0 : if (bus_id)
181 : 0 : dev_set_name(&dev->dev, "%s", bus_id);
182 : : else
183 : 0 : of_device_make_bus_id(&dev->dev);
184 : :
185 : 0 : return dev;
186 : : }
187 : : EXPORT_SYMBOL(of_device_alloc);
188 : :
189 : : /**
190 : : * of_platform_device_create_pdata - Alloc, initialize and register an of_device
191 : : * @np: pointer to node to create device for
192 : : * @bus_id: name to assign device
193 : : * @platform_data: pointer to populate platform_data pointer with
194 : : * @parent: Linux device model parent device.
195 : : *
196 : : * Returns pointer to created platform device, or NULL if a device was not
197 : : * registered. Unavailable devices will not get registered.
198 : : */
199 : 0 : static struct platform_device *of_platform_device_create_pdata(
200 : : struct device_node *np,
201 : : const char *bus_id,
202 : : void *platform_data,
203 : : struct device *parent)
204 : : {
205 : : struct platform_device *dev;
206 : :
207 [ # # ]: 0 : if (!of_device_is_available(np))
208 : : return NULL;
209 : :
210 : 0 : dev = of_device_alloc(np, bus_id, parent);
211 [ # # ]: 0 : if (!dev)
212 : : return NULL;
213 : :
214 : : #if defined(CONFIG_MICROBLAZE)
215 : : dev->archdata.dma_mask = 0xffffffffUL;
216 : : #endif
217 : 0 : dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
218 [ # # ]: 0 : if (!dev->dev.dma_mask)
219 : 0 : dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
220 : 0 : dev->dev.bus = &platform_bus_type;
221 : 0 : dev->dev.platform_data = platform_data;
222 : :
223 : : /* We do not fill the DMA ops for platform devices by default.
224 : : * This is currently the responsibility of the platform code
225 : : * to do such, possibly using a device notifier
226 : : */
227 : :
228 [ # # ]: 0 : if (of_device_add(dev) != 0) {
229 : 0 : platform_device_put(dev);
230 : 0 : return NULL;
231 : : }
232 : :
233 : : return dev;
234 : : }
235 : :
236 : : /**
237 : : * of_platform_device_create - Alloc, initialize and register an of_device
238 : : * @np: pointer to node to create device for
239 : : * @bus_id: name to assign device
240 : : * @parent: Linux device model parent device.
241 : : *
242 : : * Returns pointer to created platform device, or NULL if a device was not
243 : : * registered. Unavailable devices will not get registered.
244 : : */
245 : 0 : struct platform_device *of_platform_device_create(struct device_node *np,
246 : : const char *bus_id,
247 : : struct device *parent)
248 : : {
249 : 0 : return of_platform_device_create_pdata(np, bus_id, NULL, parent);
250 : : }
251 : : EXPORT_SYMBOL(of_platform_device_create);
252 : :
253 : : #ifdef CONFIG_ARM_AMBA
254 : 0 : static struct amba_device *of_amba_device_create(struct device_node *node,
255 : : const char *bus_id,
256 : : void *platform_data,
257 : : struct device *parent)
258 : : {
259 : : struct amba_device *dev;
260 : : const void *prop;
261 : : int i, ret;
262 : :
263 : : pr_debug("Creating amba device %s\n", node->full_name);
264 : :
265 [ # # ]: 0 : if (!of_device_is_available(node))
266 : : return NULL;
267 : :
268 : 0 : dev = amba_device_alloc(NULL, 0, 0);
269 [ # # ]: 0 : if (!dev) {
270 : 0 : pr_err("%s(): amba_device_alloc() failed for %s\n",
271 : : __func__, node->full_name);
272 : 0 : return NULL;
273 : : }
274 : :
275 : : /* setup generic device info */
276 : 0 : dev->dev.coherent_dma_mask = ~0;
277 : 0 : dev->dev.of_node = of_node_get(node);
278 : 0 : dev->dev.parent = parent;
279 : 0 : dev->dev.platform_data = platform_data;
280 [ # # ]: 0 : if (bus_id)
281 : 0 : dev_set_name(&dev->dev, "%s", bus_id);
282 : : else
283 : 0 : of_device_make_bus_id(&dev->dev);
284 : :
285 : : /* Allow the HW Peripheral ID to be overridden */
286 : 0 : prop = of_get_property(node, "arm,primecell-periphid", NULL);
287 [ # # ]: 0 : if (prop)
288 : 0 : dev->periphid = of_read_ulong(prop, 1);
289 : :
290 : : /* Decode the IRQs and address ranges */
291 [ # # ]: 0 : for (i = 0; i < AMBA_NR_IRQS; i++)
292 : 0 : dev->irq[i] = irq_of_parse_and_map(node, i);
293 : :
294 : 0 : ret = of_address_to_resource(node, 0, &dev->res);
295 [ # # ]: 0 : if (ret) {
296 : 0 : pr_err("%s(): of_address_to_resource() failed (%d) for %s\n",
297 : : __func__, ret, node->full_name);
298 : 0 : goto err_free;
299 : : }
300 : :
301 : 0 : ret = amba_device_add(dev, &iomem_resource);
302 [ # # ]: 0 : if (ret) {
303 : 0 : pr_err("%s(): amba_device_add() failed (%d) for %s\n",
304 : : __func__, ret, node->full_name);
305 : 0 : goto err_free;
306 : : }
307 : :
308 : : return dev;
309 : :
310 : : err_free:
311 : 0 : amba_device_put(dev);
312 : 0 : return NULL;
313 : : }
314 : : #else /* CONFIG_ARM_AMBA */
315 : : static struct amba_device *of_amba_device_create(struct device_node *node,
316 : : const char *bus_id,
317 : : void *platform_data,
318 : : struct device *parent)
319 : : {
320 : : return NULL;
321 : : }
322 : : #endif /* CONFIG_ARM_AMBA */
323 : :
324 : : /**
325 : : * of_devname_lookup() - Given a device node, lookup the preferred Linux name
326 : : */
327 : 0 : static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
328 : : struct device_node *np)
329 : : {
330 : : struct resource res;
331 : :
332 [ # # ]: 0 : if (!lookup)
333 : : return NULL;
334 : :
335 [ # # ]: 0 : for(; lookup->compatible != NULL; lookup++) {
336 [ # # ]: 0 : if (!of_device_is_compatible(np, lookup->compatible))
337 : 0 : continue;
338 [ # # ]: 0 : if (!of_address_to_resource(np, 0, &res))
339 [ # # ]: 0 : if (res.start != lookup->phys_addr)
340 : 0 : continue;
341 : : pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
342 : : return lookup;
343 : : }
344 : :
345 : : return NULL;
346 : : }
347 : :
348 : : /**
349 : : * of_platform_bus_create() - Create a device for a node and its children.
350 : : * @bus: device node of the bus to instantiate
351 : : * @matches: match table for bus nodes
352 : : * @lookup: auxdata table for matching id and platform_data with device nodes
353 : : * @parent: parent for new device, or NULL for top level.
354 : : * @strict: require compatible property
355 : : *
356 : : * Creates a platform_device for the provided device_node, and optionally
357 : : * recursively create devices for all the child nodes.
358 : : */
359 : 0 : static int of_platform_bus_create(struct device_node *bus,
360 : : const struct of_device_id *matches,
361 : : const struct of_dev_auxdata *lookup,
362 : : struct device *parent, bool strict)
363 : : {
364 : : const struct of_dev_auxdata *auxdata;
365 : : struct device_node *child;
366 : : struct platform_device *dev;
367 : : const char *bus_id = NULL;
368 : : void *platform_data = NULL;
369 : : int rc = 0;
370 : :
371 : : /* Make sure it has a compatible property */
372 [ # # ][ # # ]: 0 : if (strict && (!of_get_property(bus, "compatible", NULL))) {
373 : : pr_debug("%s() - skipping %s, no compatible prop\n",
374 : : __func__, bus->full_name);
375 : : return 0;
376 : : }
377 : :
378 : 0 : auxdata = of_dev_lookup(lookup, bus);
379 [ # # ]: 0 : if (auxdata) {
380 : 0 : bus_id = auxdata->name;
381 : 0 : platform_data = auxdata->platform_data;
382 : : }
383 : :
384 [ # # ]: 0 : if (of_device_is_compatible(bus, "arm,primecell")) {
385 : : /*
386 : : * Don't return an error here to keep compatibility with older
387 : : * device tree files.
388 : : */
389 : 0 : of_amba_device_create(bus, bus_id, platform_data, parent);
390 : 0 : return 0;
391 : : }
392 : :
393 : 0 : dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
394 [ # # ][ # # ]: 0 : if (!dev || !of_match_node(matches, bus))
395 : : return 0;
396 : :
397 [ # # ]: 0 : for_each_child_of_node(bus, child) {
398 : : pr_debug(" create child: %s\n", child->full_name);
399 : 0 : rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
400 [ # # ]: 0 : if (rc) {
401 : : of_node_put(child);
402 : : break;
403 : : }
404 : : }
405 : 0 : return rc;
406 : : }
407 : :
408 : : /**
409 : : * of_platform_bus_probe() - Probe the device-tree for platform buses
410 : : * @root: parent of the first level to probe or NULL for the root of the tree
411 : : * @matches: match table for bus nodes
412 : : * @parent: parent to hook devices from, NULL for toplevel
413 : : *
414 : : * Note that children of the provided root are not instantiated as devices
415 : : * unless the specified root itself matches the bus list and is not NULL.
416 : : */
417 : 0 : int of_platform_bus_probe(struct device_node *root,
418 : : const struct of_device_id *matches,
419 : : struct device *parent)
420 : : {
421 : : struct device_node *child;
422 : : int rc = 0;
423 : :
424 [ # # ]: 0 : root = root ? of_node_get(root) : of_find_node_by_path("/");
425 [ # # ]: 0 : if (!root)
426 : : return -EINVAL;
427 : :
428 : : pr_debug("of_platform_bus_probe()\n");
429 : : pr_debug(" starting at: %s\n", root->full_name);
430 : :
431 : : /* Do a self check of bus type, if there's a match, create children */
432 [ # # ]: 0 : if (of_match_node(matches, root)) {
433 : 0 : rc = of_platform_bus_create(root, matches, NULL, parent, false);
434 [ # # ]: 0 : } else for_each_child_of_node(root, child) {
435 [ # # ]: 0 : if (!of_match_node(matches, child))
436 : 0 : continue;
437 : 0 : rc = of_platform_bus_create(child, matches, NULL, parent, false);
438 [ # # ]: 0 : if (rc)
439 : : break;
440 : : }
441 : :
442 : : of_node_put(root);
443 : 0 : return rc;
444 : : }
445 : : EXPORT_SYMBOL(of_platform_bus_probe);
446 : :
447 : : /**
448 : : * of_platform_populate() - Populate platform_devices from device tree data
449 : : * @root: parent of the first level to probe or NULL for the root of the tree
450 : : * @matches: match table, NULL to use the default
451 : : * @lookup: auxdata table for matching id and platform_data with device nodes
452 : : * @parent: parent to hook devices from, NULL for toplevel
453 : : *
454 : : * Similar to of_platform_bus_probe(), this function walks the device tree
455 : : * and creates devices from nodes. It differs in that it follows the modern
456 : : * convention of requiring all device nodes to have a 'compatible' property,
457 : : * and it is suitable for creating devices which are children of the root
458 : : * node (of_platform_bus_probe will only create children of the root which
459 : : * are selected by the @matches argument).
460 : : *
461 : : * New board support should be using this function instead of
462 : : * of_platform_bus_probe().
463 : : *
464 : : * Returns 0 on success, < 0 on failure.
465 : : */
466 : 0 : int of_platform_populate(struct device_node *root,
467 : : const struct of_device_id *matches,
468 : : const struct of_dev_auxdata *lookup,
469 : : struct device *parent)
470 : : {
471 : : struct device_node *child;
472 : : int rc = 0;
473 : :
474 [ # # ]: 0 : root = root ? of_node_get(root) : of_find_node_by_path("/");
475 [ # # ]: 0 : if (!root)
476 : : return -EINVAL;
477 : :
478 [ # # ]: 0 : for_each_child_of_node(root, child) {
479 : 0 : rc = of_platform_bus_create(child, matches, lookup, parent, true);
480 [ # # ]: 0 : if (rc)
481 : : break;
482 : : }
483 : :
484 : : of_node_put(root);
485 : 0 : return rc;
486 : : }
487 : : EXPORT_SYMBOL_GPL(of_platform_populate);
488 : : #endif /* CONFIG_OF_ADDRESS */
|
