1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
4 * <benh@kernel.crashing.org>
5 * and Arnd Bergmann, IBM Corp.
6 * Merged from powerpc/kernel/of_platform.c and
7 * sparc{,64}/kernel/of_device.c by Stephen Rothwell
8 */
9
10#define pr_fmt(fmt) "OF: " fmt
11
12#include <linux/errno.h>
13#include <linux/module.h>
14#include <linux/amba/bus.h>
15#include <linux/device.h>
16#include <linux/dma-mapping.h>
17#include <linux/slab.h>
18#include <linux/of_address.h>
19#include <linux/of_device.h>
20#include <linux/of_iommu.h>
21#include <linux/of_irq.h>
22#include <linux/of_platform.h>
23#include <linux/platform_device.h>
24
25const struct of_device_id of_default_bus_match_table[] = {
26 { .compatible = "simple-bus", },
27 { .compatible = "simple-mfd", },
28 { .compatible = "isa", },
29#ifdef CONFIG_ARM_AMBA
30 { .compatible = "arm,amba-bus", },
31#endif /* CONFIG_ARM_AMBA */
32 {} /* Empty terminated list */
33};
34
35static const struct of_device_id of_skipped_node_table[] = {
36 { .compatible = "operating-points-v2", },
37 {} /* Empty terminated list */
38};
39
40static int of_dev_node_match(struct device *dev, void *data)
41{
42 return dev->of_node == data;
43}
44
45/**
46 * of_find_device_by_node - Find the platform_device associated with a node
47 * @np: Pointer to device tree node
48 *
49 * Takes a reference to the embedded struct device which needs to be dropped
50 * after use.
51 *
52 * Returns platform_device pointer, or NULL if not found
53 */
54struct platform_device *of_find_device_by_node(struct device_node *np)
55{
56 struct device *dev;
57
58 dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
59 return dev ? to_platform_device(dev) : NULL;
60}
61EXPORT_SYMBOL(of_find_device_by_node);
62
63#ifdef CONFIG_OF_ADDRESS
64/*
65 * The following routines scan a subtree and registers a device for
66 * each applicable node.
67 *
68 * Note: sparc doesn't use these routines because it has a different
69 * mechanism for creating devices from device tree nodes.
70 */
71
72/**
73 * of_device_make_bus_id - Use the device node data to assign a unique name
74 * @dev: pointer to device structure that is linked to a device tree node
75 *
76 * This routine will first try using the translated bus address to
77 * derive a unique name. If it cannot, then it will prepend names from
78 * parent nodes until a unique name can be derived.
79 */
80static void of_device_make_bus_id(struct device *dev)
81{
82 struct device_node *node = dev->of_node;
83 const __be32 *reg;
84 u64 addr;
85
86 /* Construct the name, using parent nodes if necessary to ensure uniqueness */
87 while (node->parent) {
88 /*
89 * If the address can be translated, then that is as much
90 * uniqueness as we need. Make it the first component and return
91 */
92 reg = of_get_property(node, "reg", NULL);
93 if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) {
94 dev_set_name(dev, dev_name(dev) ? "%llx.%pOFn:%s" : "%llx.%pOFn",
95 (unsigned long long)addr, node,
96 dev_name(dev));
97 return;
98 }
99
100 /* format arguments only used if dev_name() resolves to NULL */
101 dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s",
102 kbasename(node->full_name), dev_name(dev));
103 node = node->parent;
104 }
105}
106
107/**
108 * of_device_alloc - Allocate and initialize an of_device
109 * @np: device node to assign to device
110 * @bus_id: Name to assign to the device. May be null to use default name.
111 * @parent: Parent device.
112 */
113struct platform_device *of_device_alloc(struct device_node *np,
114 const char *bus_id,
115 struct device *parent)
116{
117 struct platform_device *dev;
118 int rc, i, num_reg = 0, num_irq;
119 struct resource *res, temp_res;
120
121 dev = platform_device_alloc("", PLATFORM_DEVID_NONE);
122 if (!dev)
123 return NULL;
124
125 /* count the io and irq resources */
126 while (of_address_to_resource(np, num_reg, &temp_res) == 0)
127 num_reg++;
128 num_irq = of_irq_count(np);
129
130 /* Populate the resource table */
131 if (num_irq || num_reg) {
132 res = kcalloc(num_irq + num_reg, sizeof(*res), GFP_KERNEL);
133 if (!res) {
134 platform_device_put(dev);
135 return NULL;
136 }
137
138 dev->num_resources = num_reg + num_irq;
139 dev->resource = res;
140 for (i = 0; i < num_reg; i++, res++) {
141 rc = of_address_to_resource(np, i, res);
142 WARN_ON(rc);
143 }
144 if (of_irq_to_resource_table(np, res, num_irq) != num_irq)
145 pr_debug("not all legacy IRQ resources mapped for %pOFn\n",
146 np);
147 }
148
149 dev->dev.of_node = of_node_get(np);
150 dev->dev.fwnode = &np->fwnode;
151 dev->dev.parent = parent ? : &platform_bus;
152
153 if (bus_id)
154 dev_set_name(&dev->dev, "%s", bus_id);
155 else
156 of_device_make_bus_id(&dev->dev);
157
158 return dev;
159}
160EXPORT_SYMBOL(of_device_alloc);
161
162/**
163 * of_platform_device_create_pdata - Alloc, initialize and register an of_device
164 * @np: pointer to node to create device for
165 * @bus_id: name to assign device
166 * @platform_data: pointer to populate platform_data pointer with
167 * @parent: Linux device model parent device.
168 *
169 * Returns pointer to created platform device, or NULL if a device was not
170 * registered. Unavailable devices will not get registered.
171 */
172static struct platform_device *of_platform_device_create_pdata(
173 struct device_node *np,
174 const char *bus_id,
175 void *platform_data,
176 struct device *parent)
177{
178 struct platform_device *dev;
179
180 if (!of_device_is_available(np) ||
181 of_node_test_and_set_flag(np, OF_POPULATED))
182 return NULL;
183
184 dev = of_device_alloc(np, bus_id, parent);
185 if (!dev)
186 goto err_clear_flag;
187
188 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
189 if (!dev->dev.dma_mask)
190 dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
191 dev->dev.bus = &platform_bus_type;
192 dev->dev.platform_data = platform_data;
193 of_msi_configure(&dev->dev, dev->dev.of_node);
194
195 if (of_device_add(dev) != 0) {
196 platform_device_put(dev);
197 goto err_clear_flag;
198 }
199
200 return dev;
201
202err_clear_flag:
203 of_node_clear_flag(np, OF_POPULATED);
204 return NULL;
205}
206
207/**
208 * of_platform_device_create - Alloc, initialize and register an of_device
209 * @np: pointer to node to create device for
210 * @bus_id: name to assign device
211 * @parent: Linux device model parent device.
212 *
213 * Returns pointer to created platform device, or NULL if a device was not
214 * registered. Unavailable devices will not get registered.
215 */
216struct platform_device *of_platform_device_create(struct device_node *np,
217 const char *bus_id,
218 struct device *parent)
219{
220 return of_platform_device_create_pdata(np, bus_id, NULL, parent);
221}
222EXPORT_SYMBOL(of_platform_device_create);
223
224#ifdef CONFIG_ARM_AMBA
225static struct amba_device *of_amba_device_create(struct device_node *node,
226 const char *bus_id,
227 void *platform_data,
228 struct device *parent)
229{
230 struct amba_device *dev;
231 const void *prop;
232 int i, ret;
233
234 pr_debug("Creating amba device %pOF\n", node);
235
236 if (!of_device_is_available(node) ||
237 of_node_test_and_set_flag(node, OF_POPULATED))
238 return NULL;
239
240 dev = amba_device_alloc(NULL, 0, 0);
241 if (!dev)
242 goto err_clear_flag;
243
244 /* AMBA devices only support a single DMA mask */
245 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
246 dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
247
248 /* setup generic device info */
249 dev->dev.of_node = of_node_get(node);
250 dev->dev.fwnode = &node->fwnode;
251 dev->dev.parent = parent ? : &platform_bus;
252 dev->dev.platform_data = platform_data;
253 if (bus_id)
254 dev_set_name(&dev->dev, "%s", bus_id);
255 else
256 of_device_make_bus_id(&dev->dev);
257
258 /* Allow the HW Peripheral ID to be overridden */
259 prop = of_get_property(node, "arm,primecell-periphid", NULL);
260 if (prop)
261 dev->periphid = of_read_ulong(prop, 1);
262
263 /* Decode the IRQs and address ranges */
264 for (i = 0; i < AMBA_NR_IRQS; i++)
265 dev->irq[i] = irq_of_parse_and_map(node, i);
266
267 ret = of_address_to_resource(node, 0, &dev->res);
268 if (ret) {
269 pr_err("amba: of_address_to_resource() failed (%d) for %pOF\n",
270 ret, node);
271 goto err_free;
272 }
273
274 ret = amba_device_add(dev, &iomem_resource);
275 if (ret) {
276 pr_err("amba_device_add() failed (%d) for %pOF\n",
277 ret, node);
278 goto err_free;
279 }
280
281 return dev;
282
283err_free:
284 amba_device_put(dev);
285err_clear_flag:
286 of_node_clear_flag(node, OF_POPULATED);
287 return NULL;
288}
289#else /* CONFIG_ARM_AMBA */
290static struct amba_device *of_amba_device_create(struct device_node *node,
291 const char *bus_id,
292 void *platform_data,
293 struct device *parent)
294{
295 return NULL;
296}
297#endif /* CONFIG_ARM_AMBA */
298
299/**
300 * of_devname_lookup() - Given a device node, lookup the preferred Linux name
301 */
302static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
303 struct device_node *np)
304{
305 const struct of_dev_auxdata *auxdata;
306 struct resource res;
307 int compatible = 0;
308
309 if (!lookup)
310 return NULL;
311
312 auxdata = lookup;
313 for (; auxdata->compatible; auxdata++) {
314 if (!of_device_is_compatible(np, auxdata->compatible))
315 continue;
316 compatible++;
317 if (!of_address_to_resource(np, 0, &res))
318 if (res.start != auxdata->phys_addr)
319 continue;
320 pr_debug("%pOF: devname=%s\n", np, auxdata->name);
321 return auxdata;
322 }
323
324 if (!compatible)
325 return NULL;
326
327 /* Try compatible match if no phys_addr and name are specified */
328 auxdata = lookup;
329 for (; auxdata->compatible; auxdata++) {
330 if (!of_device_is_compatible(np, auxdata->compatible))
331 continue;
332 if (!auxdata->phys_addr && !auxdata->name) {
333 pr_debug("%pOF: compatible match\n", np);
334 return auxdata;
335 }
336 }
337
338 return NULL;
339}
340
341/**
342 * of_platform_bus_create() - Create a device for a node and its children.
343 * @bus: device node of the bus to instantiate
344 * @matches: match table for bus nodes
345 * @lookup: auxdata table for matching id and platform_data with device nodes
346 * @parent: parent for new device, or NULL for top level.
347 * @strict: require compatible property
348 *
349 * Creates a platform_device for the provided device_node, and optionally
350 * recursively create devices for all the child nodes.
351 */
352static int of_platform_bus_create(struct device_node *bus,
353 const struct of_device_id *matches,
354 const struct of_dev_auxdata *lookup,
355 struct device *parent, bool strict)
356{
357 const struct of_dev_auxdata *auxdata;
358 struct device_node *child;
359 struct platform_device *dev;
360 const char *bus_id = NULL;
361 void *platform_data = NULL;
362 int rc = 0;
363
364 /* Make sure it has a compatible property */
365 if (strict && (!of_get_property(bus, "compatible", NULL))) {
366 pr_debug("%s() - skipping %pOF, no compatible prop\n",
367 __func__, bus);
368 return 0;
369 }
370
371 /* Skip nodes for which we don't want to create devices */
372 if (unlikely(of_match_node(of_skipped_node_table, bus))) {
373 pr_debug("%s() - skipping %pOF node\n", __func__, bus);
374 return 0;
375 }
376
377 if (of_node_check_flag(bus, OF_POPULATED_BUS)) {
378 pr_debug("%s() - skipping %pOF, already populated\n",
379 __func__, bus);
380 return 0;
381 }
382
383 auxdata = of_dev_lookup(lookup, bus);
384 if (auxdata) {
385 bus_id = auxdata->name;
386 platform_data = auxdata->platform_data;
387 }
388
389 if (of_device_is_compatible(bus, "arm,primecell")) {
390 /*
391 * Don't return an error here to keep compatibility with older
392 * device tree files.
393 */
394 of_amba_device_create(bus, bus_id, platform_data, parent);
395 return 0;
396 }
397
398 dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
399 if (!dev || !of_match_node(matches, bus))
400 return 0;
401
402 for_each_child_of_node(bus, child) {
403 pr_debug(" create child: %pOF\n", child);
404 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
405 if (rc) {
406 of_node_put(child);
407 break;
408 }
409 }
410 of_node_set_flag(bus, OF_POPULATED_BUS);
411 return rc;
412}
413
414/**
415 * of_platform_bus_probe() - Probe the device-tree for platform buses
416 * @root: parent of the first level to probe or NULL for the root of the tree
417 * @matches: match table for bus nodes
418 * @parent: parent to hook devices from, NULL for toplevel
419 *
420 * Note that children of the provided root are not instantiated as devices
421 * unless the specified root itself matches the bus list and is not NULL.
422 */
423int of_platform_bus_probe(struct device_node *root,
424 const struct of_device_id *matches,
425 struct device *parent)
426{
427 struct device_node *child;
428 int rc = 0;
429
430 root = root ? of_node_get(root) : of_find_node_by_path("/");
431 if (!root)
432 return -EINVAL;
433
434 pr_debug("%s()\n", __func__);
435 pr_debug(" starting at: %pOF\n", root);
436
437 /* Do a self check of bus type, if there's a match, create children */
438 if (of_match_node(matches, root)) {
439 rc = of_platform_bus_create(root, matches, NULL, parent, false);
440 } else for_each_child_of_node(root, child) {
441 if (!of_match_node(matches, child))
442 continue;
443 rc = of_platform_bus_create(child, matches, NULL, parent, false);
444 if (rc) {
445 of_node_put(child);
446 break;
447 }
448 }
449
450 of_node_put(root);
451 return rc;
452}
453EXPORT_SYMBOL(of_platform_bus_probe);
454
455/**
456 * of_platform_populate() - Populate platform_devices from device tree data
457 * @root: parent of the first level to probe or NULL for the root of the tree
458 * @matches: match table, NULL to use the default
459 * @lookup: auxdata table for matching id and platform_data with device nodes
460 * @parent: parent to hook devices from, NULL for toplevel
461 *
462 * Similar to of_platform_bus_probe(), this function walks the device tree
463 * and creates devices from nodes. It differs in that it follows the modern
464 * convention of requiring all device nodes to have a 'compatible' property,
465 * and it is suitable for creating devices which are children of the root
466 * node (of_platform_bus_probe will only create children of the root which
467 * are selected by the @matches argument).
468 *
469 * New board support should be using this function instead of
470 * of_platform_bus_probe().
471 *
472 * Returns 0 on success, < 0 on failure.
473 */
474int of_platform_populate(struct device_node *root,
475 const struct of_device_id *matches,
476 const struct of_dev_auxdata *lookup,
477 struct device *parent)
478{
479 struct device_node *child;
480 int rc = 0;
481
482 root = root ? of_node_get(root) : of_find_node_by_path("/");
483 if (!root)
484 return -EINVAL;
485
486 pr_debug("%s()\n", __func__);
487 pr_debug(" starting at: %pOF\n", root);
488
489 for_each_child_of_node(root, child) {
490 rc = of_platform_bus_create(child, matches, lookup, parent, true);
491 if (rc) {
492 of_node_put(child);
493 break;
494 }
495 }
496 of_node_set_flag(root, OF_POPULATED_BUS);
497
498 of_node_put(root);
499 return rc;
500}
501EXPORT_SYMBOL_GPL(of_platform_populate);
502
503int of_platform_default_populate(struct device_node *root,
504 const struct of_dev_auxdata *lookup,
505 struct device *parent)
506{
507 return of_platform_populate(root, of_default_bus_match_table, lookup,
508 parent);
509}
510EXPORT_SYMBOL_GPL(of_platform_default_populate);
511
512#ifndef CONFIG_PPC
513static const struct of_device_id reserved_mem_matches[] = {
514 { .compatible = "qcom,rmtfs-mem" },
515 { .compatible = "qcom,cmd-db" },
516 { .compatible = "ramoops" },
517 {}
518};
519
520static int __init of_platform_default_populate_init(void)
521{
522 struct device_node *node;
523
524 if (!of_have_populated_dt())
525 return -ENODEV;
526
527 /*
528 * Handle certain compatibles explicitly, since we don't want to create
529 * platform_devices for every node in /reserved-memory with a
530 * "compatible",
531 */
532 for_each_matching_node(node, reserved_mem_matches)
533 of_platform_device_create(node, NULL, NULL);
534
535 node = of_find_node_by_path("/firmware");
536 if (node) {
537 of_platform_populate(node, NULL, NULL, NULL);
538 of_node_put(node);
539 }
540
541 /* Populate everything else. */
542 of_platform_default_populate(NULL, NULL, NULL);
543
544 return 0;
545}
546arch_initcall_sync(of_platform_default_populate_init);
547#endif
548
549int of_platform_device_destroy(struct device *dev, void *data)
550{
551 /* Do not touch devices not populated from the device tree */
552 if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED))
553 return 0;
554
555 /* Recurse for any nodes that were treated as busses */
556 if (of_node_check_flag(dev->of_node, OF_POPULATED_BUS))
557 device_for_each_child(dev, NULL, of_platform_device_destroy);
558
559 of_node_clear_flag(dev->of_node, OF_POPULATED);
560 of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
561
562 if (dev->bus == &platform_bus_type)
563 platform_device_unregister(to_platform_device(dev));
564#ifdef CONFIG_ARM_AMBA
565 else if (dev->bus == &amba_bustype)
566 amba_device_unregister(to_amba_device(dev));
567#endif
568
569 return 0;
570}
571EXPORT_SYMBOL_GPL(of_platform_device_destroy);
572
573/**
574 * of_platform_depopulate() - Remove devices populated from device tree
575 * @parent: device which children will be removed
576 *
577 * Complementary to of_platform_populate(), this function removes children
578 * of the given device (and, recurrently, their children) that have been
579 * created from their respective device tree nodes (and only those,
580 * leaving others - eg. manually created - unharmed).
581 */
582void of_platform_depopulate(struct device *parent)
583{
584 if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) {
585 device_for_each_child(parent, NULL, of_platform_device_destroy);
586 of_node_clear_flag(parent->of_node, OF_POPULATED_BUS);
587 }
588}
589EXPORT_SYMBOL_GPL(of_platform_depopulate);
590
591static void devm_of_platform_populate_release(struct device *dev, void *res)
592{
593 of_platform_depopulate(*(struct device **)res);
594}
595
596/**
597 * devm_of_platform_populate() - Populate platform_devices from device tree data
598 * @dev: device that requested to populate from device tree data
599 *
600 * Similar to of_platform_populate(), but will automatically call
601 * of_platform_depopulate() when the device is unbound from the bus.
602 *
603 * Returns 0 on success, < 0 on failure.
604 */
605int devm_of_platform_populate(struct device *dev)
606{
607 struct device **ptr;
608 int ret;
609
610 if (!dev)
611 return -EINVAL;
612
613 ptr = devres_alloc(devm_of_platform_populate_release,
614 sizeof(*ptr), GFP_KERNEL);
615 if (!ptr)
616 return -ENOMEM;
617
618 ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
619 if (ret) {
620 devres_free(ptr);
621 } else {
622 *ptr = dev;
623 devres_add(dev, ptr);
624 }
625
626 return ret;
627}
628EXPORT_SYMBOL_GPL(devm_of_platform_populate);
629
630static int devm_of_platform_match(struct device *dev, void *res, void *data)
631{
632 struct device **ptr = res;
633
634 if (!ptr) {
635 WARN_ON(!ptr);
636 return 0;
637 }
638
639 return *ptr == data;
640}
641
642/**
643 * devm_of_platform_depopulate() - Remove devices populated from device tree
644 * @dev: device that requested to depopulate from device tree data
645 *
646 * Complementary to devm_of_platform_populate(), this function removes children
647 * of the given device (and, recurrently, their children) that have been
648 * created from their respective device tree nodes (and only those,
649 * leaving others - eg. manually created - unharmed).
650 */
651void devm_of_platform_depopulate(struct device *dev)
652{
653 int ret;
654
655 ret = devres_release(dev, devm_of_platform_populate_release,
656 devm_of_platform_match, dev);
657
658 WARN_ON(ret);
659}
660EXPORT_SYMBOL_GPL(devm_of_platform_depopulate);
661
662#ifdef CONFIG_OF_DYNAMIC
663static int of_platform_notify(struct notifier_block *nb,
664 unsigned long action, void *arg)
665{
666 struct of_reconfig_data *rd = arg;
667 struct platform_device *pdev_parent, *pdev;
668 bool children_left;
669
670 switch (of_reconfig_get_state_change(action, rd)) {
671 case OF_RECONFIG_CHANGE_ADD:
672 /* verify that the parent is a bus */
673 if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS))
674 return NOTIFY_OK; /* not for us */
675
676 /* already populated? (driver using of_populate manually) */
677 if (of_node_check_flag(rd->dn, OF_POPULATED))
678 return NOTIFY_OK;
679
680 /* pdev_parent may be NULL when no bus platform device */
681 pdev_parent = of_find_device_by_node(rd->dn->parent);
682 pdev = of_platform_device_create(rd->dn, NULL,
683 pdev_parent ? &pdev_parent->dev : NULL);
684 of_dev_put(pdev_parent);
685
686 if (pdev == NULL) {
687 pr_err("%s: failed to create for '%pOF'\n",
688 __func__, rd->dn);
689 /* of_platform_device_create tosses the error code */
690 return notifier_from_errno(-EINVAL);
691 }
692 break;
693
694 case OF_RECONFIG_CHANGE_REMOVE:
695
696 /* already depopulated? */
697 if (!of_node_check_flag(rd->dn, OF_POPULATED))
698 return NOTIFY_OK;
699
700 /* find our device by node */
701 pdev = of_find_device_by_node(rd->dn);
702 if (pdev == NULL)
703 return NOTIFY_OK; /* no? not meant for us */
704
705 /* unregister takes one ref away */
706 of_platform_device_destroy(&pdev->dev, &children_left);
707
708 /* and put the reference of the find */
709 of_dev_put(pdev);
710 break;
711 }
712
713 return NOTIFY_OK;
714}
715
716static struct notifier_block platform_of_notifier = {
717 .notifier_call = of_platform_notify,
718};
719
720void of_platform_register_reconfig_notifier(void)
721{
722 WARN_ON(of_reconfig_notifier_register(&platform_of_notifier));
723}
724#endif /* CONFIG_OF_DYNAMIC */
725
726#endif /* CONFIG_OF_ADDRESS */
727