2017-12-27 21:55:14 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2007-05-02 20:38:57 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
|
|
|
|
* <benh@kernel.crashing.org>
|
|
|
|
* and Arnd Bergmann, IBM Corp.
|
|
|
|
* Merged from powerpc/kernel/of_platform.c and
|
|
|
|
* sparc{,64}/kernel/of_device.c by Stephen Rothwell
|
|
|
|
*/
|
2016-06-15 16:32:18 +03:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) "OF: " fmt
|
|
|
|
|
2007-05-02 20:38:57 +04:00
|
|
|
#include <linux/errno.h>
|
2007-10-18 08:17:42 +04:00
|
|
|
#include <linux/module.h>
|
2011-06-21 20:59:34 +04:00
|
|
|
#include <linux/amba/bus.h>
|
2007-05-02 20:38:57 +04:00
|
|
|
#include <linux/device.h>
|
2010-06-08 17:48:13 +04:00
|
|
|
#include <linux/dma-mapping.h>
|
2010-06-08 17:48:20 +04:00
|
|
|
#include <linux/slab.h>
|
2010-06-08 17:48:26 +04:00
|
|
|
#include <linux/of_address.h>
|
2007-05-02 20:38:57 +04:00
|
|
|
#include <linux/of_device.h>
|
2017-04-10 14:21:01 +03:00
|
|
|
#include <linux/of_iommu.h>
|
2010-06-08 17:48:26 +04:00
|
|
|
#include <linux/of_irq.h>
|
2007-05-02 20:38:57 +04:00
|
|
|
#include <linux/of_platform.h>
|
2010-06-08 17:48:21 +04:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
|
2011-06-21 20:59:34 +04:00
|
|
|
const struct of_device_id of_default_bus_match_table[] = {
|
|
|
|
{ .compatible = "simple-bus", },
|
2015-03-03 11:52:20 +03:00
|
|
|
{ .compatible = "simple-mfd", },
|
2016-09-20 00:21:24 +03:00
|
|
|
{ .compatible = "isa", },
|
2011-06-21 20:59:34 +04:00
|
|
|
#ifdef CONFIG_ARM_AMBA
|
|
|
|
{ .compatible = "arm,amba-bus", },
|
|
|
|
#endif /* CONFIG_ARM_AMBA */
|
|
|
|
{} /* Empty terminated list */
|
|
|
|
};
|
|
|
|
|
2018-04-17 09:27:34 +03:00
|
|
|
static const struct of_device_id of_skipped_node_table[] = {
|
|
|
|
{ .compatible = "operating-points-v2", },
|
|
|
|
{} /* Empty terminated list */
|
|
|
|
};
|
|
|
|
|
2010-07-23 21:19:35 +04:00
|
|
|
/**
|
|
|
|
* of_find_device_by_node - Find the platform_device associated with a node
|
|
|
|
* @np: Pointer to device tree node
|
|
|
|
*
|
2016-11-01 13:53:22 +03:00
|
|
|
* Takes a reference to the embedded struct device which needs to be dropped
|
|
|
|
* after use.
|
|
|
|
*
|
2010-07-23 21:19:35 +04:00
|
|
|
* Returns platform_device pointer, or NULL if not found
|
|
|
|
*/
|
|
|
|
struct platform_device *of_find_device_by_node(struct device_node *np)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
2019-07-24 01:18:33 +03:00
|
|
|
dev = bus_find_device_by_of_node(&platform_bus_type, np);
|
2010-07-23 21:19:35 +04:00
|
|
|
return dev ? to_platform_device(dev) : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_device_by_node);
|
|
|
|
|
2012-02-25 01:58:34 +04:00
|
|
|
#ifdef CONFIG_OF_ADDRESS
|
2010-06-08 17:48:13 +04:00
|
|
|
/*
|
|
|
|
* The following routines scan a subtree and registers a device for
|
|
|
|
* each applicable node.
|
|
|
|
*
|
|
|
|
* Note: sparc doesn't use these routines because it has a different
|
|
|
|
* mechanism for creating devices from device tree nodes.
|
|
|
|
*/
|
|
|
|
|
2010-06-08 17:48:14 +04:00
|
|
|
/**
|
|
|
|
* of_device_make_bus_id - Use the device node data to assign a unique name
|
|
|
|
* @dev: pointer to device structure that is linked to a device tree node
|
|
|
|
*
|
2014-05-21 10:40:31 +04:00
|
|
|
* This routine will first try using the translated bus address to
|
|
|
|
* derive a unique name. If it cannot, then it will prepend names from
|
|
|
|
* parent nodes until a unique name can be derived.
|
2010-06-08 17:48:14 +04:00
|
|
|
*/
|
2016-10-17 22:17:43 +03:00
|
|
|
static void of_device_make_bus_id(struct device *dev)
|
2010-06-08 17:48:14 +04:00
|
|
|
{
|
|
|
|
struct device_node *node = dev->of_node;
|
2012-10-09 04:42:11 +04:00
|
|
|
const __be32 *reg;
|
2010-06-08 17:48:14 +04:00
|
|
|
u64 addr;
|
|
|
|
|
2014-05-21 10:40:31 +04:00
|
|
|
/* Construct the name, using parent nodes if necessary to ensure uniqueness */
|
|
|
|
while (node->parent) {
|
|
|
|
/*
|
|
|
|
* If the address can be translated, then that is as much
|
|
|
|
* uniqueness as we need. Make it the first component and return
|
|
|
|
*/
|
|
|
|
reg = of_get_property(node, "reg", NULL);
|
|
|
|
if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) {
|
2018-08-28 04:00:19 +03:00
|
|
|
dev_set_name(dev, dev_name(dev) ? "%llx.%pOFn:%s" : "%llx.%pOFn",
|
2019-06-24 15:46:20 +03:00
|
|
|
addr, node, dev_name(dev));
|
2010-06-08 17:48:14 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-21 10:40:31 +04:00
|
|
|
/* format arguments only used if dev_name() resolves to NULL */
|
|
|
|
dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s",
|
2017-06-02 02:00:00 +03:00
|
|
|
kbasename(node->full_name), dev_name(dev));
|
2014-05-21 10:40:31 +04:00
|
|
|
node = node->parent;
|
|
|
|
}
|
2010-06-08 17:48:14 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_device_alloc - Allocate and initialize an of_device
|
|
|
|
* @np: device node to assign to device
|
|
|
|
* @bus_id: Name to assign to the device. May be null to use default name.
|
|
|
|
* @parent: Parent device.
|
|
|
|
*/
|
2010-07-22 23:59:23 +04:00
|
|
|
struct platform_device *of_device_alloc(struct device_node *np,
|
2010-06-08 17:48:14 +04:00
|
|
|
const char *bus_id,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
2010-07-22 23:59:23 +04:00
|
|
|
struct platform_device *dev;
|
2010-10-11 07:35:05 +04:00
|
|
|
int rc, i, num_reg = 0, num_irq;
|
2010-06-08 17:48:15 +04:00
|
|
|
struct resource *res, temp_res;
|
|
|
|
|
2017-08-25 18:33:13 +03:00
|
|
|
dev = platform_device_alloc("", PLATFORM_DEVID_NONE);
|
2010-10-20 21:45:13 +04:00
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* count the io and irq resources */
|
2014-05-08 00:23:56 +04:00
|
|
|
while (of_address_to_resource(np, num_reg, &temp_res) == 0)
|
|
|
|
num_reg++;
|
2010-10-11 07:35:05 +04:00
|
|
|
num_irq = of_irq_count(np);
|
2010-06-08 17:48:15 +04:00
|
|
|
|
|
|
|
/* Populate the resource table */
|
|
|
|
if (num_irq || num_reg) {
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 00:03:40 +03:00
|
|
|
res = kcalloc(num_irq + num_reg, sizeof(*res), GFP_KERNEL);
|
2010-10-20 21:45:13 +04:00
|
|
|
if (!res) {
|
|
|
|
platform_device_put(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-08 17:48:15 +04:00
|
|
|
dev->num_resources = num_reg + num_irq;
|
|
|
|
dev->resource = res;
|
|
|
|
for (i = 0; i < num_reg; i++, res++) {
|
|
|
|
rc = of_address_to_resource(np, i, res);
|
|
|
|
WARN_ON(rc);
|
|
|
|
}
|
2014-04-24 02:57:41 +04:00
|
|
|
if (of_irq_to_resource_table(np, res, num_irq) != num_irq)
|
2018-08-28 04:00:19 +03:00
|
|
|
pr_debug("not all legacy IRQ resources mapped for %pOFn\n",
|
|
|
|
np);
|
2010-06-08 17:48:15 +04:00
|
|
|
}
|
2010-06-08 17:48:14 +04:00
|
|
|
|
|
|
|
dev->dev.of_node = of_node_get(np);
|
2016-09-14 18:01:24 +03:00
|
|
|
dev->dev.fwnode = &np->fwnode;
|
2014-11-04 13:26:26 +03:00
|
|
|
dev->dev.parent = parent ? : &platform_bus;
|
2010-06-08 17:48:14 +04:00
|
|
|
|
|
|
|
if (bus_id)
|
|
|
|
dev_set_name(&dev->dev, "%s", bus_id);
|
|
|
|
else
|
|
|
|
of_device_make_bus_id(&dev->dev);
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_device_alloc);
|
|
|
|
|
2010-06-08 17:48:13 +04:00
|
|
|
/**
|
2011-06-21 20:59:35 +04:00
|
|
|
* of_platform_device_create_pdata - Alloc, initialize and register an of_device
|
2010-06-08 17:48:13 +04:00
|
|
|
* @np: pointer to node to create device for
|
|
|
|
* @bus_id: name to assign device
|
2011-06-21 20:59:35 +04:00
|
|
|
* @platform_data: pointer to populate platform_data pointer with
|
2010-06-08 17:48:13 +04:00
|
|
|
* @parent: Linux device model parent device.
|
2011-01-04 01:51:11 +03:00
|
|
|
*
|
|
|
|
* Returns pointer to created platform device, or NULL if a device was not
|
|
|
|
* registered. Unavailable devices will not get registered.
|
2010-06-08 17:48:13 +04:00
|
|
|
*/
|
2013-07-01 23:26:52 +04:00
|
|
|
static struct platform_device *of_platform_device_create_pdata(
|
2011-06-21 20:59:35 +04:00
|
|
|
struct device_node *np,
|
|
|
|
const char *bus_id,
|
|
|
|
void *platform_data,
|
|
|
|
struct device *parent)
|
2010-06-08 17:48:13 +04:00
|
|
|
{
|
2010-07-22 23:59:23 +04:00
|
|
|
struct platform_device *dev;
|
2010-06-08 17:48:13 +04:00
|
|
|
|
2014-05-15 19:55:24 +04:00
|
|
|
if (!of_device_is_available(np) ||
|
|
|
|
of_node_test_and_set_flag(np, OF_POPULATED))
|
2011-01-04 01:51:11 +03:00
|
|
|
return NULL;
|
|
|
|
|
2010-06-08 17:48:13 +04:00
|
|
|
dev = of_device_alloc(np, bus_id, parent);
|
|
|
|
if (!dev)
|
2014-05-15 19:55:24 +04:00
|
|
|
goto err_clear_flag;
|
2010-06-08 17:48:13 +04:00
|
|
|
|
2018-07-27 17:14:15 +03:00
|
|
|
dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
if (!dev->dev.dma_mask)
|
|
|
|
dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
|
2010-06-08 17:48:21 +04:00
|
|
|
dev->dev.bus = &platform_bus_type;
|
2011-06-21 20:59:35 +04:00
|
|
|
dev->dev.platform_data = platform_data;
|
2015-07-28 16:46:15 +03:00
|
|
|
of_msi_configure(&dev->dev, dev->dev.of_node);
|
2010-06-08 17:48:13 +04:00
|
|
|
|
2010-10-20 21:45:13 +04:00
|
|
|
if (of_device_add(dev) != 0) {
|
|
|
|
platform_device_put(dev);
|
2014-05-15 19:55:24 +04:00
|
|
|
goto err_clear_flag;
|
2010-06-08 17:48:13 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return dev;
|
2014-05-15 19:55:24 +04:00
|
|
|
|
|
|
|
err_clear_flag:
|
|
|
|
of_node_clear_flag(np, OF_POPULATED);
|
|
|
|
return NULL;
|
2010-06-08 17:48:13 +04:00
|
|
|
}
|
2011-06-21 20:59:35 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_platform_device_create - Alloc, initialize and register an of_device
|
|
|
|
* @np: pointer to node to create device for
|
|
|
|
* @bus_id: name to assign device
|
|
|
|
* @parent: Linux device model parent device.
|
|
|
|
*
|
|
|
|
* Returns pointer to created platform device, or NULL if a device was not
|
|
|
|
* registered. Unavailable devices will not get registered.
|
|
|
|
*/
|
|
|
|
struct platform_device *of_platform_device_create(struct device_node *np,
|
|
|
|
const char *bus_id,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
return of_platform_device_create_pdata(np, bus_id, NULL, parent);
|
|
|
|
}
|
2010-06-08 17:48:13 +04:00
|
|
|
EXPORT_SYMBOL(of_platform_device_create);
|
|
|
|
|
2011-06-21 20:59:34 +04:00
|
|
|
#ifdef CONFIG_ARM_AMBA
|
|
|
|
static struct amba_device *of_amba_device_create(struct device_node *node,
|
|
|
|
const char *bus_id,
|
|
|
|
void *platform_data,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
struct amba_device *dev;
|
|
|
|
const void *prop;
|
|
|
|
int i, ret;
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug("Creating amba device %pOF\n", node);
|
2011-06-21 20:59:34 +04:00
|
|
|
|
2014-05-15 19:55:24 +04:00
|
|
|
if (!of_device_is_available(node) ||
|
|
|
|
of_node_test_and_set_flag(node, OF_POPULATED))
|
2011-06-21 20:59:34 +04:00
|
|
|
return NULL;
|
|
|
|
|
2011-12-18 15:45:17 +04:00
|
|
|
dev = amba_device_alloc(NULL, 0, 0);
|
2016-06-15 16:32:18 +03:00
|
|
|
if (!dev)
|
2014-05-15 19:55:24 +04:00
|
|
|
goto err_clear_flag;
|
2011-06-21 20:59:34 +04:00
|
|
|
|
2018-08-31 17:13:07 +03:00
|
|
|
/* AMBA devices only support a single DMA mask */
|
|
|
|
dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
|
|
|
|
|
2011-06-21 20:59:34 +04:00
|
|
|
/* setup generic device info */
|
|
|
|
dev->dev.of_node = of_node_get(node);
|
2016-09-14 18:01:24 +03:00
|
|
|
dev->dev.fwnode = &node->fwnode;
|
2014-11-04 13:26:26 +03:00
|
|
|
dev->dev.parent = parent ? : &platform_bus;
|
2011-06-21 20:59:34 +04:00
|
|
|
dev->dev.platform_data = platform_data;
|
|
|
|
if (bus_id)
|
|
|
|
dev_set_name(&dev->dev, "%s", bus_id);
|
|
|
|
else
|
|
|
|
of_device_make_bus_id(&dev->dev);
|
|
|
|
|
|
|
|
/* Allow the HW Peripheral ID to be overridden */
|
|
|
|
prop = of_get_property(node, "arm,primecell-periphid", NULL);
|
|
|
|
if (prop)
|
|
|
|
dev->periphid = of_read_ulong(prop, 1);
|
|
|
|
|
|
|
|
/* Decode the IRQs and address ranges */
|
|
|
|
for (i = 0; i < AMBA_NR_IRQS; i++)
|
|
|
|
dev->irq[i] = irq_of_parse_and_map(node, i);
|
|
|
|
|
|
|
|
ret = of_address_to_resource(node, 0, &dev->res);
|
2013-08-30 15:17:29 +04:00
|
|
|
if (ret) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_err("amba: of_address_to_resource() failed (%d) for %pOF\n",
|
|
|
|
ret, node);
|
2011-06-21 20:59:34 +04:00
|
|
|
goto err_free;
|
2013-08-30 15:17:29 +04:00
|
|
|
}
|
2011-06-21 20:59:34 +04:00
|
|
|
|
2011-12-18 15:45:17 +04:00
|
|
|
ret = amba_device_add(dev, &iomem_resource);
|
2013-08-30 15:17:29 +04:00
|
|
|
if (ret) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_err("amba_device_add() failed (%d) for %pOF\n",
|
|
|
|
ret, node);
|
2011-06-21 20:59:34 +04:00
|
|
|
goto err_free;
|
2013-08-30 15:17:29 +04:00
|
|
|
}
|
2011-06-21 20:59:34 +04:00
|
|
|
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
err_free:
|
2011-12-18 15:45:17 +04:00
|
|
|
amba_device_put(dev);
|
2014-05-15 19:55:24 +04:00
|
|
|
err_clear_flag:
|
|
|
|
of_node_clear_flag(node, OF_POPULATED);
|
2011-06-21 20:59:34 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#else /* CONFIG_ARM_AMBA */
|
|
|
|
static struct amba_device *of_amba_device_create(struct device_node *node,
|
|
|
|
const char *bus_id,
|
|
|
|
void *platform_data,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_ARM_AMBA */
|
|
|
|
|
2011-06-21 20:59:35 +04:00
|
|
|
/**
|
2020-05-24 18:26:14 +03:00
|
|
|
* of_dev_lookup() - Given a device node, lookup the preferred Linux name
|
2011-06-21 20:59:35 +04:00
|
|
|
*/
|
|
|
|
static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
|
|
|
|
struct device_node *np)
|
|
|
|
{
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
const struct of_dev_auxdata *auxdata;
|
2011-06-21 20:59:35 +04:00
|
|
|
struct resource res;
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
int compatible = 0;
|
2011-11-03 09:07:29 +04:00
|
|
|
|
|
|
|
if (!lookup)
|
|
|
|
return NULL;
|
|
|
|
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
auxdata = lookup;
|
|
|
|
for (; auxdata->compatible; auxdata++) {
|
|
|
|
if (!of_device_is_compatible(np, auxdata->compatible))
|
2011-11-03 09:07:29 +04:00
|
|
|
continue;
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
compatible++;
|
2012-07-05 18:15:36 +04:00
|
|
|
if (!of_address_to_resource(np, 0, &res))
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
if (res.start != auxdata->phys_addr)
|
2012-07-05 18:15:36 +04:00
|
|
|
continue;
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug("%pOF: devname=%s\n", np, auxdata->name);
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
return auxdata;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!compatible)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Try compatible match if no phys_addr and name are specified */
|
|
|
|
auxdata = lookup;
|
|
|
|
for (; auxdata->compatible; auxdata++) {
|
|
|
|
if (!of_device_is_compatible(np, auxdata->compatible))
|
|
|
|
continue;
|
|
|
|
if (!auxdata->phys_addr && !auxdata->name) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug("%pOF: compatible match\n", np);
|
of/platform: Allow secondary compatible match in of_dev_lookup
We currently try to match of_dev_auxdata based on compatible,
IO address, and device name. But in some cases we have multiple
instances of drivers that can use the same auxdata.
Let's add an additional secondary lookup for generic compatible
match for auxdata if no device specific match is found. This does
not change the existing matching, and still allows adding device
specific auxdata.
This simplifies things as specifying the IO address and device
name is prone errors as it requires maintaining an in kernel
database for each SoC.
To specify a generic match, all that is needed is to add a
OF_DEV_AUXDATA entry with no device instance specified:
OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
As the auxdata is already initialized only for the booted SoC,
there's not much of a chance of getting things wrong.
Let's also fix two checkpatch warnings while at it to add a
space before parenthesis in the for loop, and remove a comparison
to NULL by using !auxdata->compatible.
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2016-04-15 18:45:32 +03:00
|
|
|
return auxdata;
|
|
|
|
}
|
2011-06-21 20:59:35 +04:00
|
|
|
}
|
2011-11-03 09:07:29 +04:00
|
|
|
|
2011-06-21 20:59:35 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-08 17:48:13 +04:00
|
|
|
/**
|
2011-03-18 19:21:28 +03:00
|
|
|
* of_platform_bus_create() - Create a device for a node and its children.
|
2010-06-08 17:48:13 +04:00
|
|
|
* @bus: device node of the bus to instantiate
|
2011-03-18 19:21:29 +03:00
|
|
|
* @matches: match table for bus nodes
|
2011-11-03 09:07:29 +04:00
|
|
|
* @lookup: auxdata table for matching id and platform_data with device nodes
|
2011-03-18 19:21:28 +03:00
|
|
|
* @parent: parent for new device, or NULL for top level.
|
2011-11-03 09:07:29 +04:00
|
|
|
* @strict: require compatible property
|
2011-03-18 19:21:28 +03:00
|
|
|
*
|
|
|
|
* Creates a platform_device for the provided device_node, and optionally
|
|
|
|
* recursively create devices for all the child nodes.
|
2010-06-08 17:48:13 +04:00
|
|
|
*/
|
2011-03-18 19:21:28 +03:00
|
|
|
static int of_platform_bus_create(struct device_node *bus,
|
2010-06-08 17:48:13 +04:00
|
|
|
const struct of_device_id *matches,
|
2011-06-21 20:59:35 +04:00
|
|
|
const struct of_dev_auxdata *lookup,
|
2011-06-21 20:59:34 +04:00
|
|
|
struct device *parent, bool strict)
|
2010-06-08 17:48:13 +04:00
|
|
|
{
|
2011-06-21 20:59:35 +04:00
|
|
|
const struct of_dev_auxdata *auxdata;
|
2010-06-08 17:48:13 +04:00
|
|
|
struct device_node *child;
|
2010-07-22 23:59:23 +04:00
|
|
|
struct platform_device *dev;
|
2011-06-21 20:59:35 +04:00
|
|
|
const char *bus_id = NULL;
|
|
|
|
void *platform_data = NULL;
|
2010-06-08 17:48:13 +04:00
|
|
|
int rc = 0;
|
|
|
|
|
2011-06-21 20:59:34 +04:00
|
|
|
/* Make sure it has a compatible property */
|
|
|
|
if (strict && (!of_get_property(bus, "compatible", NULL))) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug("%s() - skipping %pOF, no compatible prop\n",
|
|
|
|
__func__, bus);
|
2011-06-21 20:59:34 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-04-17 09:27:34 +03:00
|
|
|
/* Skip nodes for which we don't want to create devices */
|
|
|
|
if (unlikely(of_match_node(of_skipped_node_table, bus))) {
|
|
|
|
pr_debug("%s() - skipping %pOF node\n", __func__, bus);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-01 09:52:54 +03:00
|
|
|
if (of_node_check_flag(bus, OF_POPULATED_BUS)) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug("%s() - skipping %pOF, already populated\n",
|
|
|
|
__func__, bus);
|
2016-06-01 09:52:54 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-21 20:59:35 +04:00
|
|
|
auxdata = of_dev_lookup(lookup, bus);
|
|
|
|
if (auxdata) {
|
|
|
|
bus_id = auxdata->name;
|
|
|
|
platform_data = auxdata->platform_data;
|
|
|
|
}
|
|
|
|
|
2011-06-21 20:59:34 +04:00
|
|
|
if (of_device_is_compatible(bus, "arm,primecell")) {
|
2013-08-30 15:17:29 +04:00
|
|
|
/*
|
|
|
|
* Don't return an error here to keep compatibility with older
|
|
|
|
* device tree files.
|
|
|
|
*/
|
2011-06-21 20:59:35 +04:00
|
|
|
of_amba_device_create(bus, bus_id, platform_data, parent);
|
2011-06-21 20:59:34 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-21 20:59:35 +04:00
|
|
|
dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
|
2011-03-18 19:21:28 +03:00
|
|
|
if (!dev || !of_match_node(matches, bus))
|
|
|
|
return 0;
|
|
|
|
|
2010-06-08 17:48:13 +04:00
|
|
|
for_each_child_of_node(bus, child) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug(" create child: %pOF\n", child);
|
2011-06-21 20:59:35 +04:00
|
|
|
rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
|
2010-06-08 17:48:13 +04:00
|
|
|
if (rc) {
|
|
|
|
of_node_put(child);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-06-24 19:13:47 +04:00
|
|
|
of_node_set_flag(bus, OF_POPULATED_BUS);
|
2010-06-08 17:48:13 +04:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-03-18 19:21:28 +03:00
|
|
|
* of_platform_bus_probe() - Probe the device-tree for platform buses
|
2010-06-08 17:48:13 +04:00
|
|
|
* @root: parent of the first level to probe or NULL for the root of the tree
|
2011-03-18 19:21:29 +03:00
|
|
|
* @matches: match table for bus nodes
|
2010-06-08 17:48:13 +04:00
|
|
|
* @parent: parent to hook devices from, NULL for toplevel
|
|
|
|
*
|
|
|
|
* Note that children of the provided root are not instantiated as devices
|
|
|
|
* unless the specified root itself matches the bus list and is not NULL.
|
|
|
|
*/
|
|
|
|
int of_platform_bus_probe(struct device_node *root,
|
|
|
|
const struct of_device_id *matches,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
int rc = 0;
|
|
|
|
|
2011-03-18 19:21:29 +03:00
|
|
|
root = root ? of_node_get(root) : of_find_node_by_path("/");
|
|
|
|
if (!root)
|
2010-06-08 17:48:25 +04:00
|
|
|
return -EINVAL;
|
2010-06-08 17:48:13 +04:00
|
|
|
|
2016-06-01 09:52:54 +03:00
|
|
|
pr_debug("%s()\n", __func__);
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug(" starting at: %pOF\n", root);
|
2010-06-08 17:48:13 +04:00
|
|
|
|
2011-03-18 19:21:29 +03:00
|
|
|
/* Do a self check of bus type, if there's a match, create children */
|
2010-06-08 17:48:13 +04:00
|
|
|
if (of_match_node(matches, root)) {
|
2011-06-21 20:59:35 +04:00
|
|
|
rc = of_platform_bus_create(root, matches, NULL, parent, false);
|
2011-03-18 19:21:28 +03:00
|
|
|
} else for_each_child_of_node(root, child) {
|
2010-06-08 17:48:13 +04:00
|
|
|
if (!of_match_node(matches, child))
|
|
|
|
continue;
|
2011-06-21 20:59:35 +04:00
|
|
|
rc = of_platform_bus_create(child, matches, NULL, parent, false);
|
2015-10-22 12:02:49 +03:00
|
|
|
if (rc) {
|
|
|
|
of_node_put(child);
|
2010-06-08 17:48:13 +04:00
|
|
|
break;
|
2015-10-22 12:02:49 +03:00
|
|
|
}
|
2010-06-08 17:48:13 +04:00
|
|
|
}
|
2011-03-18 19:21:28 +03:00
|
|
|
|
2010-06-08 17:48:13 +04:00
|
|
|
of_node_put(root);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_platform_bus_probe);
|
2011-06-21 20:59:34 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_platform_populate() - Populate platform_devices from device tree data
|
|
|
|
* @root: parent of the first level to probe or NULL for the root of the tree
|
|
|
|
* @matches: match table, NULL to use the default
|
2012-11-23 20:25:08 +04:00
|
|
|
* @lookup: auxdata table for matching id and platform_data with device nodes
|
2011-06-21 20:59:34 +04:00
|
|
|
* @parent: parent to hook devices from, NULL for toplevel
|
|
|
|
*
|
|
|
|
* Similar to of_platform_bus_probe(), this function walks the device tree
|
|
|
|
* and creates devices from nodes. It differs in that it follows the modern
|
|
|
|
* convention of requiring all device nodes to have a 'compatible' property,
|
|
|
|
* and it is suitable for creating devices which are children of the root
|
|
|
|
* node (of_platform_bus_probe will only create children of the root which
|
|
|
|
* are selected by the @matches argument).
|
|
|
|
*
|
|
|
|
* New board support should be using this function instead of
|
|
|
|
* of_platform_bus_probe().
|
|
|
|
*
|
|
|
|
* Returns 0 on success, < 0 on failure.
|
|
|
|
*/
|
|
|
|
int of_platform_populate(struct device_node *root,
|
|
|
|
const struct of_device_id *matches,
|
2011-06-21 20:59:35 +04:00
|
|
|
const struct of_dev_auxdata *lookup,
|
2011-06-21 20:59:34 +04:00
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
root = root ? of_node_get(root) : of_find_node_by_path("/");
|
|
|
|
if (!root)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-06-01 09:52:54 +03:00
|
|
|
pr_debug("%s()\n", __func__);
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_debug(" starting at: %pOF\n", root);
|
2016-06-01 09:52:54 +03:00
|
|
|
|
2019-09-05 00:11:24 +03:00
|
|
|
device_links_supplier_sync_state_pause();
|
2011-06-21 20:59:34 +04:00
|
|
|
for_each_child_of_node(root, child) {
|
2011-06-21 20:59:35 +04:00
|
|
|
rc = of_platform_bus_create(child, matches, lookup, parent, true);
|
2015-10-22 12:02:49 +03:00
|
|
|
if (rc) {
|
|
|
|
of_node_put(child);
|
2011-06-21 20:59:34 +04:00
|
|
|
break;
|
2015-10-22 12:02:49 +03:00
|
|
|
}
|
2011-06-21 20:59:34 +04:00
|
|
|
}
|
2019-09-05 00:11:24 +03:00
|
|
|
device_links_supplier_sync_state_resume();
|
|
|
|
|
2014-11-20 01:35:39 +03:00
|
|
|
of_node_set_flag(root, OF_POPULATED_BUS);
|
2011-06-21 20:59:34 +04:00
|
|
|
|
|
|
|
of_node_put(root);
|
|
|
|
return rc;
|
|
|
|
}
|
2012-06-08 03:57:36 +04:00
|
|
|
EXPORT_SYMBOL_GPL(of_platform_populate);
|
2014-05-15 19:55:24 +04:00
|
|
|
|
2015-08-02 20:44:43 +03:00
|
|
|
int of_platform_default_populate(struct device_node *root,
|
|
|
|
const struct of_dev_auxdata *lookup,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
return of_platform_populate(root, of_default_bus_match_table, lookup,
|
|
|
|
parent);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_platform_default_populate);
|
|
|
|
|
2016-08-12 08:49:34 +03:00
|
|
|
#ifndef CONFIG_PPC
|
2017-10-11 08:08:53 +03:00
|
|
|
static const struct of_device_id reserved_mem_matches[] = {
|
2017-10-16 21:17:08 +03:00
|
|
|
{ .compatible = "qcom,rmtfs-mem" },
|
2018-04-10 20:57:23 +03:00
|
|
|
{ .compatible = "qcom,cmd-db" },
|
2017-10-11 08:08:53 +03:00
|
|
|
{ .compatible = "ramoops" },
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2016-06-01 09:52:54 +03:00
|
|
|
static int __init of_platform_default_populate_init(void)
|
|
|
|
{
|
2016-07-30 04:11:32 +03:00
|
|
|
struct device_node *node;
|
|
|
|
|
2019-12-09 22:31:19 +03:00
|
|
|
device_links_supplier_sync_state_pause();
|
|
|
|
|
2016-07-30 04:11:32 +03:00
|
|
|
if (!of_have_populated_dt())
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/*
|
2017-10-11 08:08:53 +03:00
|
|
|
* Handle certain compatibles explicitly, since we don't want to create
|
|
|
|
* platform_devices for every node in /reserved-memory with a
|
|
|
|
* "compatible",
|
2016-07-30 04:11:32 +03:00
|
|
|
*/
|
2017-10-11 08:08:53 +03:00
|
|
|
for_each_matching_node(node, reserved_mem_matches)
|
|
|
|
of_platform_device_create(node, NULL, NULL);
|
2016-07-30 04:11:32 +03:00
|
|
|
|
2017-09-28 13:45:59 +03:00
|
|
|
node = of_find_node_by_path("/firmware");
|
2018-01-18 13:43:39 +03:00
|
|
|
if (node) {
|
2017-09-28 13:45:59 +03:00
|
|
|
of_platform_populate(node, NULL, NULL, NULL);
|
2018-01-18 13:43:39 +03:00
|
|
|
of_node_put(node);
|
|
|
|
}
|
2017-09-28 13:45:59 +03:00
|
|
|
|
2016-07-30 04:11:32 +03:00
|
|
|
/* Populate everything else. */
|
|
|
|
of_platform_default_populate(NULL, NULL, NULL);
|
2016-06-01 09:52:54 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
arch_initcall_sync(of_platform_default_populate_init);
|
2019-09-05 00:11:24 +03:00
|
|
|
|
|
|
|
static int __init of_platform_sync_state_init(void)
|
|
|
|
{
|
2019-12-09 22:31:19 +03:00
|
|
|
device_links_supplier_sync_state_resume();
|
2019-09-05 00:11:24 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
late_initcall_sync(of_platform_sync_state_init);
|
2016-08-12 08:49:34 +03:00
|
|
|
#endif
|
2016-06-01 09:52:54 +03:00
|
|
|
|
2017-05-22 14:09:20 +03:00
|
|
|
int of_platform_device_destroy(struct device *dev, void *data)
|
2014-05-15 19:55:24 +04:00
|
|
|
{
|
|
|
|
/* Do not touch devices not populated from the device tree */
|
2014-06-24 19:13:47 +04:00
|
|
|
if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED))
|
2014-05-15 19:55:24 +04:00
|
|
|
return 0;
|
|
|
|
|
2014-06-24 19:13:47 +04:00
|
|
|
/* Recurse for any nodes that were treated as busses */
|
|
|
|
if (of_node_check_flag(dev->of_node, OF_POPULATED_BUS))
|
|
|
|
device_for_each_child(dev, NULL, of_platform_device_destroy);
|
2014-05-15 19:55:24 +04:00
|
|
|
|
2018-06-04 17:14:08 +03:00
|
|
|
of_node_clear_flag(dev->of_node, OF_POPULATED);
|
|
|
|
of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
|
|
|
|
|
2014-05-15 19:55:24 +04:00
|
|
|
if (dev->bus == &platform_bus_type)
|
|
|
|
platform_device_unregister(to_platform_device(dev));
|
|
|
|
#ifdef CONFIG_ARM_AMBA
|
|
|
|
else if (dev->bus == &amba_bustype)
|
|
|
|
amba_device_unregister(to_amba_device(dev));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-05-22 14:09:20 +03:00
|
|
|
EXPORT_SYMBOL_GPL(of_platform_device_destroy);
|
2014-05-15 19:55:24 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* of_platform_depopulate() - Remove devices populated from device tree
|
2014-06-24 19:13:47 +04:00
|
|
|
* @parent: device which children will be removed
|
2014-05-15 19:55:24 +04:00
|
|
|
*
|
|
|
|
* Complementary to of_platform_populate(), this function removes children
|
|
|
|
* of the given device (and, recurrently, their children) that have been
|
|
|
|
* created from their respective device tree nodes (and only those,
|
|
|
|
* leaving others - eg. manually created - unharmed).
|
|
|
|
*/
|
2014-06-24 19:13:47 +04:00
|
|
|
void of_platform_depopulate(struct device *parent)
|
2014-05-15 19:55:24 +04:00
|
|
|
{
|
2014-11-20 01:35:39 +03:00
|
|
|
if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) {
|
2020-08-06 18:36:50 +03:00
|
|
|
device_for_each_child_reverse(parent, NULL, of_platform_device_destroy);
|
2014-11-20 01:35:39 +03:00
|
|
|
of_node_clear_flag(parent->of_node, OF_POPULATED_BUS);
|
|
|
|
}
|
2014-05-15 19:55:24 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_platform_depopulate);
|
|
|
|
|
2017-02-24 19:14:33 +03:00
|
|
|
static void devm_of_platform_populate_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
of_platform_depopulate(*(struct device **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_of_platform_populate() - Populate platform_devices from device tree data
|
|
|
|
* @dev: device that requested to populate from device tree data
|
|
|
|
*
|
|
|
|
* Similar to of_platform_populate(), but will automatically call
|
|
|
|
* of_platform_depopulate() when the device is unbound from the bus.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, < 0 on failure.
|
|
|
|
*/
|
|
|
|
int devm_of_platform_populate(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device **ptr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_of_platform_populate_release,
|
|
|
|
sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
|
|
|
|
if (ret) {
|
|
|
|
devres_free(ptr);
|
|
|
|
} else {
|
|
|
|
*ptr = dev;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_of_platform_populate);
|
|
|
|
|
|
|
|
static int devm_of_platform_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct device **ptr = res;
|
|
|
|
|
|
|
|
if (!ptr) {
|
|
|
|
WARN_ON(!ptr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *ptr == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_of_platform_depopulate() - Remove devices populated from device tree
|
|
|
|
* @dev: device that requested to depopulate from device tree data
|
|
|
|
*
|
|
|
|
* Complementary to devm_of_platform_populate(), this function removes children
|
|
|
|
* of the given device (and, recurrently, their children) that have been
|
|
|
|
* created from their respective device tree nodes (and only those,
|
|
|
|
* leaving others - eg. manually created - unharmed).
|
|
|
|
*/
|
|
|
|
void devm_of_platform_depopulate(struct device *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = devres_release(dev, devm_of_platform_populate_release,
|
|
|
|
devm_of_platform_match, dev);
|
|
|
|
|
|
|
|
WARN_ON(ret);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_of_platform_depopulate);
|
|
|
|
|
2014-10-28 23:36:01 +03:00
|
|
|
#ifdef CONFIG_OF_DYNAMIC
|
|
|
|
static int of_platform_notify(struct notifier_block *nb,
|
|
|
|
unsigned long action, void *arg)
|
|
|
|
{
|
|
|
|
struct of_reconfig_data *rd = arg;
|
|
|
|
struct platform_device *pdev_parent, *pdev;
|
|
|
|
bool children_left;
|
|
|
|
|
|
|
|
switch (of_reconfig_get_state_change(action, rd)) {
|
|
|
|
case OF_RECONFIG_CHANGE_ADD:
|
|
|
|
/* verify that the parent is a bus */
|
|
|
|
if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS))
|
|
|
|
return NOTIFY_OK; /* not for us */
|
|
|
|
|
2014-12-16 20:45:26 +03:00
|
|
|
/* already populated? (driver using of_populate manually) */
|
|
|
|
if (of_node_check_flag(rd->dn, OF_POPULATED))
|
|
|
|
return NOTIFY_OK;
|
|
|
|
|
2014-10-28 23:36:01 +03:00
|
|
|
/* pdev_parent may be NULL when no bus platform device */
|
|
|
|
pdev_parent = of_find_device_by_node(rd->dn->parent);
|
|
|
|
pdev = of_platform_device_create(rd->dn, NULL,
|
|
|
|
pdev_parent ? &pdev_parent->dev : NULL);
|
|
|
|
of_dev_put(pdev_parent);
|
|
|
|
|
|
|
|
if (pdev == NULL) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_err("%s: failed to create for '%pOF'\n",
|
|
|
|
__func__, rd->dn);
|
2014-10-28 23:36:01 +03:00
|
|
|
/* of_platform_device_create tosses the error code */
|
|
|
|
return notifier_from_errno(-EINVAL);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OF_RECONFIG_CHANGE_REMOVE:
|
2014-12-16 20:45:26 +03:00
|
|
|
|
|
|
|
/* already depopulated? */
|
|
|
|
if (!of_node_check_flag(rd->dn, OF_POPULATED))
|
|
|
|
return NOTIFY_OK;
|
|
|
|
|
2014-10-28 23:36:01 +03:00
|
|
|
/* find our device by node */
|
|
|
|
pdev = of_find_device_by_node(rd->dn);
|
|
|
|
if (pdev == NULL)
|
|
|
|
return NOTIFY_OK; /* no? not meant for us */
|
|
|
|
|
|
|
|
/* unregister takes one ref away */
|
|
|
|
of_platform_device_destroy(&pdev->dev, &children_left);
|
|
|
|
|
|
|
|
/* and put the reference of the find */
|
|
|
|
of_dev_put(pdev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block platform_of_notifier = {
|
|
|
|
.notifier_call = of_platform_notify,
|
|
|
|
};
|
|
|
|
|
|
|
|
void of_platform_register_reconfig_notifier(void)
|
|
|
|
{
|
|
|
|
WARN_ON(of_reconfig_notifier_register(&platform_of_notifier));
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OF_DYNAMIC */
|
|
|
|
|
2012-02-25 01:58:34 +04:00
|
|
|
#endif /* CONFIG_OF_ADDRESS */
|