[linux.git] / drivers / mfd / mfd-core.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * drivers/mfd/mfd-core.c
 *
 * core MFD support
 * Copyright (c) 2006 Ian Molton
 * Copyright (c) 2007,2008 Dmitry Baryshkov
 */

#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/acpi.h>
#include <linux/list.h>
#include <linux/property.h>
#include <linux/mfd/core.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/irqdomain.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/regulator/consumer.h>

static LIST_HEAD(mfd_of_node_list);

struct mfd_of_node_entry {
	struct list_head list;
	struct device *dev;
	struct device_node *np;
};

static struct device_type mfd_dev_type = {
	.name	= "mfd_device",
};

#if IS_ENABLED(CONFIG_ACPI)
struct match_ids_walk_data {
	struct acpi_device_id *ids;
	struct acpi_device *adev;
};

static int match_device_ids(struct acpi_device *adev, void *data)
{
	struct match_ids_walk_data *wd = data;

	if (!acpi_match_device_ids(adev, wd->ids)) {
		wd->adev = adev;
		return 1;
	}

	return 0;
}

static void mfd_acpi_add_device(const struct mfd_cell *cell,
				struct platform_device *pdev)
{
	const struct mfd_cell_acpi_match *match = cell->acpi_match;
	struct acpi_device *adev = NULL;
	struct acpi_device *parent;

	parent = ACPI_COMPANION(pdev->dev.parent);
	if (!parent)
		return;

	/*
	 * MFD child device gets its ACPI handle either from the ACPI device
	 * directly under the parent that matches the either _HID or _CID, or
	 * _ADR or it will use the parent handle if is no ID is given.
	 *
	 * Note that use of _ADR is a grey area in the ACPI specification,
	 * though at least Intel Galileo Gen 2 is using it to distinguish
	 * the children devices.
	 */
	if (match) {
		if (match->pnpid) {
			struct acpi_device_id ids[2] = {};
			struct match_ids_walk_data wd = {
				.adev = NULL,
				.ids = ids,
			};

			strscpy(ids[0].id, match->pnpid, sizeof(ids[0].id));
			acpi_dev_for_each_child(parent, match_device_ids, &wd);
			adev = wd.adev;
		} else {
			adev = acpi_find_child_device(parent, match->adr, false);
		}
	}

	ACPI_COMPANION_SET(&pdev->dev, adev ?: parent);
}
#else
static inline void mfd_acpi_add_device(const struct mfd_cell *cell,
				       struct platform_device *pdev)
{
}
#endif

static int mfd_match_of_node_to_dev(struct platform_device *pdev,
				    struct device_node *np,
				    const struct mfd_cell *cell)
{
#if IS_ENABLED(CONFIG_OF)
	struct mfd_of_node_entry *of_entry;
	u64 of_node_addr;

	/* Skip if OF node has previously been allocated to a device */
	list_for_each_entry(of_entry, &mfd_of_node_list, list)
		if (of_entry->np == np)
			return -EAGAIN;

	if (!cell->use_of_reg)
		/* No of_reg defined - allocate first free compatible match */
		goto allocate_of_node;

	/* We only care about each node's first defined address */
	if (of_property_read_reg(np, 0, &of_node_addr, NULL))
		/* OF node does not contatin a 'reg' property to match to */
		return -EAGAIN;

	if (cell->of_reg != of_node_addr)
		/* No match */
		return -EAGAIN;

allocate_of_node:
	of_entry = kzalloc(sizeof(*of_entry), GFP_KERNEL);
	if (!of_entry)
		return -ENOMEM;

	of_entry->dev = &pdev->dev;
	of_entry->np = np;
	list_add_tail(&of_entry->list, &mfd_of_node_list);

	pdev->dev.of_node = np;
	pdev->dev.fwnode = &np->fwnode;
#endif
	return 0;
}

static int mfd_add_device(struct device *parent, int id,
			  const struct mfd_cell *cell,
			  struct resource *mem_base,
			  int irq_base, struct irq_domain *domain)
{
	struct resource *res;
	struct platform_device *pdev;
	struct device_node *np = NULL;
	struct mfd_of_node_entry *of_entry, *tmp;
	bool disabled = false;
	int ret = -ENOMEM;
	int platform_id;
	int r;

	if (id == PLATFORM_DEVID_AUTO)
		platform_id = id;
	else
		platform_id = id + cell->id;

	pdev = platform_device_alloc(cell->name, platform_id);
	if (!pdev)
		goto fail_alloc;

	pdev->mfd_cell = kmemdup(cell, sizeof(*cell), GFP_KERNEL);
	if (!pdev->mfd_cell)
		goto fail_device;

	res = kcalloc(cell->num_resources, sizeof(*res), GFP_KERNEL);
	if (!res)
		goto fail_device;

	pdev->dev.parent = parent;
	pdev->dev.type = &mfd_dev_type;
	pdev->dev.dma_mask = parent->dma_mask;
	pdev->dev.dma_parms = parent->dma_parms;
	pdev->dev.coherent_dma_mask = parent->coherent_dma_mask;

	ret = regulator_bulk_register_supply_alias(
			&pdev->dev, cell->parent_supplies,
			parent, cell->parent_supplies,
			cell->num_parent_supplies);
	if (ret < 0)
		goto fail_res;

	if (IS_ENABLED(CONFIG_OF) && parent->of_node && cell->of_compatible) {
		for_each_child_of_node(parent->of_node, np) {
			if (of_device_is_compatible(np, cell->of_compatible)) {
				/* Skip 'disabled' devices */
				if (!of_device_is_available(np)) {
					disabled = true;
					continue;
				}

				ret = mfd_match_of_node_to_dev(pdev, np, cell);
				if (ret == -EAGAIN)
					continue;
				of_node_put(np);
				if (ret)
					goto fail_alias;

				goto match;
			}
		}

		if (disabled) {
			/* Ignore 'disabled' devices error free */
			ret = 0;
			goto fail_alias;
		}

match:
		if (!pdev->dev.of_node)
			pr_warn("%s: Failed to locate of_node [id: %d]\n",
				cell->name, platform_id);
	}

	mfd_acpi_add_device(cell, pdev);

	if (cell->pdata_size) {
		ret = platform_device_add_data(pdev,
					cell->platform_data, cell->pdata_size);
		if (ret)
			goto fail_of_entry;
	}

	if (cell->swnode) {
		ret = device_add_software_node(&pdev->dev, cell->swnode);
		if (ret)
			goto fail_of_entry;
	}

	for (r = 0; r < cell->num_resources; r++) {
		res[r].name = cell->resources[r].name;
		res[r].flags = cell->resources[r].flags;

		/* Find out base to use */
		if ((cell->resources[r].flags & IORESOURCE_MEM) && mem_base) {
			res[r].parent = mem_base;
			res[r].start = mem_base->start +
				cell->resources[r].start;
			res[r].end = mem_base->start +
				cell->resources[r].end;
		} else if (cell->resources[r].flags & IORESOURCE_IRQ) {
			if (domain) {
				/* Unable to create mappings for IRQ ranges. */
				WARN_ON(cell->resources[r].start !=
					cell->resources[r].end);
				res[r].start = res[r].end = irq_create_mapping(
					domain, cell->resources[r].start);
			} else {
				res[r].start = irq_base +
					cell->resources[r].start;
				res[r].end   = irq_base +
					cell->resources[r].end;
			}
		} else {
			res[r].parent = cell->resources[r].parent;
			res[r].start = cell->resources[r].start;
			res[r].end   = cell->resources[r].end;
		}

		if (!cell->ignore_resource_conflicts) {
			if (has_acpi_companion(&pdev->dev)) {
				ret = acpi_check_resource_conflict(&res[r]);
				if (ret)
					goto fail_res_conflict;
			}
		}
	}

	ret = platform_device_add_resources(pdev, res, cell->num_resources);
	if (ret)
		goto fail_res_conflict;

	ret = platform_device_add(pdev);
	if (ret)
		goto fail_res_conflict;

	if (cell->pm_runtime_no_callbacks)
		pm_runtime_no_callbacks(&pdev->dev);

	kfree(res);

	return 0;

fail_res_conflict:
	if (cell->swnode)
		device_remove_software_node(&pdev->dev);
fail_of_entry:
	list_for_each_entry_safe(of_entry, tmp, &mfd_of_node_list, list)
		if (of_entry->dev == &pdev->dev) {
			list_del(&of_entry->list);
			kfree(of_entry);
		}
fail_alias:
	regulator_bulk_unregister_supply_alias(&pdev->dev,
					       cell->parent_supplies,
					       cell->num_parent_supplies);
fail_res:
	kfree(res);
fail_device:
	platform_device_put(pdev);
fail_alloc:
	return ret;
}

/**
 * mfd_add_devices - register child devices
 *
 * @parent:	Pointer to parent device.
 * @id:		Can be PLATFORM_DEVID_AUTO to let the Platform API take care
 *		of device numbering, or will be added to a device's cell_id.
 * @cells:	Array of (struct mfd_cell)s describing child devices.
 * @n_devs:	Number of child devices to register.
 * @mem_base:	Parent register range resource for child devices.
 * @irq_base:	Base of the range of virtual interrupt numbers allocated for
 *		this MFD device. Unused if @domain is specified.
 * @domain:	Interrupt domain to create mappings for hardware interrupts.
 */
int mfd_add_devices(struct device *parent, int id,
		    const struct mfd_cell *cells, int n_devs,
		    struct resource *mem_base,
		    int irq_base, struct irq_domain *domain)
{
	int i;
	int ret;

	for (i = 0; i < n_devs; i++) {
		ret = mfd_add_device(parent, id, cells + i, mem_base,
				     irq_base, domain);
		if (ret)
			goto fail;
	}

	return 0;

fail:
	if (i)
		mfd_remove_devices(parent);

	return ret;
}
EXPORT_SYMBOL(mfd_add_devices);

static int mfd_remove_devices_fn(struct device *dev, void *data)
{
	struct platform_device *pdev;
	const struct mfd_cell *cell;
	struct mfd_of_node_entry *of_entry, *tmp;
	int *level = data;

	if (dev->type != &mfd_dev_type)
		return 0;

	pdev = to_platform_device(dev);
	cell = mfd_get_cell(pdev);

	if (level && cell->level > *level)
		return 0;

	if (cell->swnode)
		device_remove_software_node(&pdev->dev);

	list_for_each_entry_safe(of_entry, tmp, &mfd_of_node_list, list)
		if (of_entry->dev == &pdev->dev) {
			list_del(&of_entry->list);
			kfree(of_entry);
		}

	regulator_bulk_unregister_supply_alias(dev, cell->parent_supplies,
					       cell->num_parent_supplies);

	platform_device_unregister(pdev);
	return 0;
}

void mfd_remove_devices_late(struct device *parent)
{
	int level = MFD_DEP_LEVEL_HIGH;

	device_for_each_child_reverse(parent, &level, mfd_remove_devices_fn);
}
EXPORT_SYMBOL(mfd_remove_devices_late);

void mfd_remove_devices(struct device *parent)
{
	int level = MFD_DEP_LEVEL_NORMAL;

	device_for_each_child_reverse(parent, &level, mfd_remove_devices_fn);
}
EXPORT_SYMBOL(mfd_remove_devices);

static void devm_mfd_dev_release(struct device *dev, void *res)
{
	mfd_remove_devices(dev);
}

/**
 * devm_mfd_add_devices - Resource managed version of mfd_add_devices()
 *
 * Returns 0 on success or an appropriate negative error number on failure.
 * All child-devices of the MFD will automatically be removed when it gets
 * unbinded.
 *
 * @dev:	Pointer to parent device.
 * @id:		Can be PLATFORM_DEVID_AUTO to let the Platform API take care
 *		of device numbering, or will be added to a device's cell_id.
 * @cells:	Array of (struct mfd_cell)s describing child devices.
 * @n_devs:	Number of child devices to register.
 * @mem_base:	Parent register range resource for child devices.
 * @irq_base:	Base of the range of virtual interrupt numbers allocated for
 *		this MFD device. Unused if @domain is specified.
 * @domain:	Interrupt domain to create mappings for hardware interrupts.
 */
int devm_mfd_add_devices(struct device *dev, int id,
			 const struct mfd_cell *cells, int n_devs,
			 struct resource *mem_base,
			 int irq_base, struct irq_domain *domain)
{
	struct device **ptr;
	int ret;

	ptr = devres_alloc(devm_mfd_dev_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	ret = mfd_add_devices(dev, id, cells, n_devs, mem_base,
			      irq_base, domain);
	if (ret < 0) {
		devres_free(ptr);
		return ret;
	}

	*ptr = dev;
	devres_add(dev, ptr);

	return ret;
}
EXPORT_SYMBOL(devm_mfd_add_devices);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ian Molton, Dmitry Baryshkov");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
aa613de6 DB	2	/*
	3	* drivers/mfd/mfd-core.c
	4	*
	5	* core MFD support
	6	* Copyright (c) 2006 Ian Molton
	7	* Copyright (c) 2007,2008 Dmitry Baryshkov
aa613de6 DB	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/platform_device.h>
91fedede	12	#include <linux/acpi.h>
466a62d7	13	#include <linux/list.h>
4d215cab	14	#include <linux/property.h>
aa613de6	15	#include <linux/mfd/core.h>
4c90aa94	16	#include <linux/pm_runtime.h>
5a0e3ad6	17	#include <linux/slab.h>
4e36dd33	18	#include <linux/module.h>
c94bb233 LJ	19	#include <linux/irqdomain.h>
c94bb233 LJ	20	#include <linux/of.h>
466a62d7	21	#include <linux/of_address.h>
7fcd4274	22	#include <linux/regulator/consumer.h>
aa613de6	23
466a62d7 LJ	24	static LIST_HEAD(mfd_of_node_list);
	25
	26	struct mfd_of_node_entry {
	27	struct list_head list;
	28	struct device *dev;
	29	struct device_node *np;
	30	};
	31
b9fbb62e CK	32	static struct device_type mfd_dev_type = {
	33	.name = "mfd_device",
	34	};
	35
6ab34301	36	#if IS_ENABLED(CONFIG_ACPI)
0c9b9c2a RW	37	struct match_ids_walk_data {
	38	struct acpi_device_id *ids;
	39	struct acpi_device *adev;
	40	};
	41
	42	static int match_device_ids(struct acpi_device adev, void data)
	43	{
	44	struct match_ids_walk_data *wd = data;
	45
	46	if (!acpi_match_device_ids(adev, wd->ids)) {
	47	wd->adev = adev;
	48	return 1;
	49	}
	50
	51	return 0;
	52	}
	53
6ab34301 MW	54	static void mfd_acpi_add_device(const struct mfd_cell *cell,
	55	struct platform_device *pdev)
	56	{
98a3be44	57	const struct mfd_cell_acpi_match *match = cell->acpi_match;
40cb71f3	58	struct acpi_device *adev = NULL;
0c9b9c2a	59	struct acpi_device *parent;
6ab34301	60
98a3be44 AS	61	parent = ACPI_COMPANION(pdev->dev.parent);
98a3be44 AS	62	if (!parent)
6ab34301 MW	63	return;
	64
	65	/*
98a3be44 AS	66	* MFD child device gets its ACPI handle either from the ACPI device
	67	* directly under the parent that matches the either _HID or _CID, or
	68	* _ADR or it will use the parent handle if is no ID is given.
	69	*
	70	* Note that use of _ADR is a grey area in the ACPI specification,
40cb71f3 AS	71	* though at least Intel Galileo Gen 2 is using it to distinguish
40cb71f3 AS	72	* the children devices.
6ab34301	73	*/
98a3be44 AS	74	if (match) {
	75	if (match->pnpid) {
	76	struct acpi_device_id ids[2] = {};
0c9b9c2a RW	77	struct match_ids_walk_data wd = {
	78	.adev = NULL,
	79	.ids = ids,
	80	};
98a3be44	81
6a32d399	82	strscpy(ids[0].id, match->pnpid, sizeof(ids[0].id));
0c9b9c2a RW	83	acpi_dev_for_each_child(parent, match_device_ids, &wd);
0c9b9c2a RW	84	adev = wd.adev;
98a3be44	85	} else {
40cb71f3	86	adev = acpi_find_child_device(parent, match->adr, false);
98a3be44	87	}
6ab34301 MW	88	}
6ab34301 MW	89
40cb71f3	90	ACPI_COMPANION_SET(&pdev->dev, adev ?: parent);
6ab34301 MW	91	}
	92	#else
	93	static inline void mfd_acpi_add_device(const struct mfd_cell *cell,
	94	struct platform_device *pdev)
	95	{
	96	}
	97	#endif
	98
466a62d7 LJ	99	static int mfd_match_of_node_to_dev(struct platform_device *pdev,
	100	struct device_node *np,
	101	const struct mfd_cell *cell)
	102	{
	103	#if IS_ENABLED(CONFIG_OF)
	104	struct mfd_of_node_entry *of_entry;
466a62d7 LJ	105	u64 of_node_addr;
466a62d7 LJ	106
466a62d7 LJ	107	/* Skip if OF node has previously been allocated to a device */
	108	list_for_each_entry(of_entry, &mfd_of_node_list, list)
	109	if (of_entry->np == np)
	110	return -EAGAIN;
	111
	112	if (!cell->use_of_reg)
	113	/* No of_reg defined - allocate first free compatible match */
	114	goto allocate_of_node;
	115
	116	/* We only care about each node's first defined address */
c7fe3bbf	117	if (of_property_read_reg(np, 0, &of_node_addr, NULL))
466a62d7 LJ	118	/* OF node does not contatin a 'reg' property to match to */
	119	return -EAGAIN;
	120
466a62d7 LJ	121	if (cell->of_reg != of_node_addr)
	122	/* No match */
	123	return -EAGAIN;
	124
	125	allocate_of_node:
	126	of_entry = kzalloc(sizeof(*of_entry), GFP_KERNEL);
	127	if (!of_entry)
	128	return -ENOMEM;
	129
	130	of_entry->dev = &pdev->dev;
	131	of_entry->np = np;
	132	list_add_tail(&of_entry->list, &mfd_of_node_list);
	133
	134	pdev->dev.of_node = np;
	135	pdev->dev.fwnode = &np->fwnode;
	136	#endif
	137	return 0;
	138	}
	139
424f525a	140	static int mfd_add_device(struct device *parent, int id,
5a47c0fb	141	const struct mfd_cell *cell,
7f71ac93	142	struct resource *mem_base,
0848c94f	143	int irq_base, struct irq_domain *domain)
aa613de6	144	{
a87903f3	145	struct resource *res;
aa613de6	146	struct platform_device *pdev;
c94bb233	147	struct device_node *np = NULL;
466a62d7	148	struct mfd_of_node_entry of_entry, tmp;
7ba7bdef	149	bool disabled = false;
aa613de6	150	int ret = -ENOMEM;
6e3f62f0	151	int platform_id;
aa613de6 DB	152	int r;
aa613de6 DB	153
a77c50b4	154	if (id == PLATFORM_DEVID_AUTO)
6e3f62f0 JH	155	platform_id = id;
	156	else
	157	platform_id = id + cell->id;
	158
	159	pdev = platform_device_alloc(cell->name, platform_id);
aa613de6 DB	160	if (!pdev)
	161	goto fail_alloc;
	162
b944a688 LJ	163	pdev->mfd_cell = kmemdup(cell, sizeof(*cell), GFP_KERNEL);
	164	if (!pdev->mfd_cell)
	165	goto fail_device;
	166
6396bb22	167	res = kcalloc(cell->num_resources, sizeof(*res), GFP_KERNEL);
a87903f3 IM	168	if (!res)
	169	goto fail_device;
	170
424f525a	171	pdev->dev.parent = parent;
b9fbb62e	172	pdev->dev.type = &mfd_dev_type;
b018e136 BS	173	pdev->dev.dma_mask = parent->dma_mask;
b018e136 BS	174	pdev->dev.dma_parms = parent->dma_parms;
4f08df1b	175	pdev->dev.coherent_dma_mask = parent->coherent_dma_mask;
aa613de6	176
d137be00	177	ret = regulator_bulk_register_supply_alias(
7fcd4274 CK	178	&pdev->dev, cell->parent_supplies,
	179	parent, cell->parent_supplies,
	180	cell->num_parent_supplies);
	181	if (ret < 0)
	182	goto fail_res;
	183
466a62d7	184	if (IS_ENABLED(CONFIG_OF) && parent->of_node && cell->of_compatible) {
c94bb233 LJ	185	for_each_child_of_node(parent->of_node, np) {
c94bb233 LJ	186	if (of_device_is_compatible(np, cell->of_compatible)) {
7ba7bdef	187	/* Skip 'disabled' devices */
22380b65	188	if (!of_device_is_available(np)) {
7ba7bdef HC	189	disabled = true;
7ba7bdef HC	190	continue;
22380b65 LJ	191	}
22380b65 LJ	192
466a62d7 LJ	193	ret = mfd_match_of_node_to_dev(pdev, np, cell);
	194	if (ret == -EAGAIN)
	195	continue;
002be811	196	of_node_put(np);
466a62d7	197	if (ret)
6b5c3506	198	goto fail_alias;
466a62d7	199
7ba7bdef	200	goto match;
c94bb233 LJ	201	}
c94bb233 LJ	202	}
466a62d7	203
7ba7bdef HC	204	if (disabled) {
	205	/* Ignore 'disabled' devices error free */
	206	ret = 0;
	207	goto fail_alias;
	208	}
	209
	210	match:
466a62d7 LJ	211	if (!pdev->dev.of_node)
	212	pr_warn("%s: Failed to locate of_node [id: %d]\n",
	213	cell->name, platform_id);
c94bb233 LJ	214	}
c94bb233 LJ	215
6ab34301 MW	216	mfd_acpi_add_device(cell, pdev);
6ab34301 MW	217
eb895607 SO	218	if (cell->pdata_size) {
	219	ret = platform_device_add_data(pdev,
	220	cell->platform_data, cell->pdata_size);
	221	if (ret)
466a62d7	222	goto fail_of_entry;
eb895607 SO	223	}
eb895607 SO	224
42e59982 HK	225	if (cell->swnode) {
	226	ret = device_add_software_node(&pdev->dev, cell->swnode);
	227	if (ret)
	228	goto fail_of_entry;
	229	}
	230
aa613de6 DB	231	for (r = 0; r < cell->num_resources; r++) {
	232	res[r].name = cell->resources[r].name;
	233	res[r].flags = cell->resources[r].flags;
	234
	235	/* Find out base to use */
f03cfcbc	236	if ((cell->resources[r].flags & IORESOURCE_MEM) && mem_base) {
aa613de6 DB	237	res[r].parent = mem_base;
	238	res[r].start = mem_base->start +
	239	cell->resources[r].start;
	240	res[r].end = mem_base->start +
	241	cell->resources[r].end;
	242	} else if (cell->resources[r].flags & IORESOURCE_IRQ) {
c94bb233 LJ	243	if (domain) {
	244	/* Unable to create mappings for IRQ ranges. */
	245	WARN_ON(cell->resources[r].start !=
	246	cell->resources[r].end);
	247	res[r].start = res[r].end = irq_create_mapping(
	248	domain, cell->resources[r].start);
	249	} else {
	250	res[r].start = irq_base +
	251	cell->resources[r].start;
	252	res[r].end = irq_base +
	253	cell->resources[r].end;
	254	}
aa613de6 DB	255	} else {
	256	res[r].parent = cell->resources[r].parent;
	257	res[r].start = cell->resources[r].start;
	258	res[r].end = cell->resources[r].end;
	259	}
91fedede	260
5f2545fa	261	if (!cell->ignore_resource_conflicts) {
ec40c606 LP	262	if (has_acpi_companion(&pdev->dev)) {
	263	ret = acpi_check_resource_conflict(&res[r]);
	264	if (ret)
5a23e8b0	265	goto fail_res_conflict;
ec40c606	266	}
5f2545fa	267	}
aa613de6 DB	268	}
aa613de6 DB	269
8af5fe3b AL	270	ret = platform_device_add_resources(pdev, res, cell->num_resources);
8af5fe3b AL	271	if (ret)
5a23e8b0	272	goto fail_res_conflict;
aa613de6 DB	273
	274	ret = platform_device_add(pdev);
	275	if (ret)
5a23e8b0	276	goto fail_res_conflict;
a87903f3	277
4c90aa94 MB	278	if (cell->pm_runtime_no_callbacks)
	279	pm_runtime_no_callbacks(&pdev->dev);
	280
a87903f3	281	kfree(res);
aa613de6 DB	282
	283	return 0;
	284
5a23e8b0 AS	285	fail_res_conflict:
	286	if (cell->swnode)
	287	device_remove_software_node(&pdev->dev);
466a62d7 LJ	288	fail_of_entry:
	289	list_for_each_entry_safe(of_entry, tmp, &mfd_of_node_list, list)
	290	if (of_entry->dev == &pdev->dev) {
	291	list_del(&of_entry->list);
	292	kfree(of_entry);
	293	}
7fcd4274	294	fail_alias:
d137be00 CK	295	regulator_bulk_unregister_supply_alias(&pdev->dev,
	296	cell->parent_supplies,
	297	cell->num_parent_supplies);
a87903f3 IM	298	fail_res:
a87903f3 IM	299	kfree(res);
aa613de6 DB	300	fail_device:
	301	platform_device_put(pdev);
	302	fail_alloc:
	303	return ret;
	304	}
	305
1946f996 BG	306	/**
	307	* mfd_add_devices - register child devices
	308	*
	309	* @parent: Pointer to parent device.
	310	* @id: Can be PLATFORM_DEVID_AUTO to let the Platform API take care
	311	* of device numbering, or will be added to a device's cell_id.
	312	* @cells: Array of (struct mfd_cell)s describing child devices.
	313	* @n_devs: Number of child devices to register.
	314	* @mem_base: Parent register range resource for child devices.
	315	* @irq_base: Base of the range of virtual interrupt numbers allocated for
	316	* this MFD device. Unused if @domain is specified.
	317	* @domain: Interrupt domain to create mappings for hardware interrupts.
	318	*/
424f525a	319	int mfd_add_devices(struct device *parent, int id,
03e361b2	320	const struct mfd_cell *cells, int n_devs,
7f71ac93	321	struct resource *mem_base,
0848c94f	322	int irq_base, struct irq_domain *domain)
aa613de6 DB	323	{
aa613de6 DB	324	int i;
0b208e41	325	int ret;
aa613de6 DB	326
aa613de6 DB	327	for (i = 0; i < n_devs; i++) {
5a47c0fb	328	ret = mfd_add_device(parent, id, cells + i, mem_base,
0848c94f	329	irq_base, domain);
aa613de6	330	if (ret)
0b208e41	331	goto fail;
aa613de6 DB	332	}
aa613de6 DB	333
0b208e41	334	return 0;
aa613de6	335
0b208e41 GU	336	fail:
	337	if (i)
	338	mfd_remove_devices(parent);
5a47c0fb	339
aa613de6 DB	340	return ret;
	341	}
	342	EXPORT_SYMBOL(mfd_add_devices);
	343
5a47c0fb	344	static int mfd_remove_devices_fn(struct device dev, void data)
aa613de6	345	{
b9fbb62e CK	346	struct platform_device *pdev;
b9fbb62e CK	347	const struct mfd_cell *cell;
8e88c61d	348	struct mfd_of_node_entry of_entry, tmp;
114294d2	349	int *level = data;
1e29af62	350
b9fbb62e CK	351	if (dev->type != &mfd_dev_type)
	352	return 0;
	353
	354	pdev = to_platform_device(dev);
	355	cell = mfd_get_cell(pdev);
	356
114294d2 CK	357	if (level && cell->level > *level)
	358	return 0;
	359
5a23e8b0 AS	360	if (cell->swnode)
	361	device_remove_software_node(&pdev->dev);
	362
8e88c61d MO	363	list_for_each_entry_safe(of_entry, tmp, &mfd_of_node_list, list)
	364	if (of_entry->dev == &pdev->dev) {
	365	list_del(&of_entry->list);
	366	kfree(of_entry);
	367	}
	368
d137be00 CK	369	regulator_bulk_unregister_supply_alias(dev, cell->parent_supplies,
	370	cell->num_parent_supplies);
	371
1e29af62	372	platform_device_unregister(pdev);
aa613de6 DB	373	return 0;
	374	}
	375
114294d2 CK	376	void mfd_remove_devices_late(struct device *parent)
	377	{
	378	int level = MFD_DEP_LEVEL_HIGH;
	379
	380	device_for_each_child_reverse(parent, &level, mfd_remove_devices_fn);
	381	}
	382	EXPORT_SYMBOL(mfd_remove_devices_late);
	383
424f525a	384	void mfd_remove_devices(struct device *parent)
aa613de6	385	{
114294d2 CK	386	int level = MFD_DEP_LEVEL_NORMAL;
	387
	388	device_for_each_child_reverse(parent, &level, mfd_remove_devices_fn);
aa613de6 DB	389	}
	390	EXPORT_SYMBOL(mfd_remove_devices);
	391
a8f447be LD	392	static void devm_mfd_dev_release(struct device dev, void res)
	393	{
	394	mfd_remove_devices(dev);
	395	}
	396
	397	/**
	398	* devm_mfd_add_devices - Resource managed version of mfd_add_devices()
	399	*
	400	* Returns 0 on success or an appropriate negative error number on failure.
	401	* All child-devices of the MFD will automatically be removed when it gets
	402	* unbinded.
5a0ffef8 LJ	403	*
	404	* @dev: Pointer to parent device.
	405	* @id: Can be PLATFORM_DEVID_AUTO to let the Platform API take care
	406	* of device numbering, or will be added to a device's cell_id.
	407	* @cells: Array of (struct mfd_cell)s describing child devices.
	408	* @n_devs: Number of child devices to register.
	409	* @mem_base: Parent register range resource for child devices.
	410	* @irq_base: Base of the range of virtual interrupt numbers allocated for
	411	* this MFD device. Unused if @domain is specified.
	412	* @domain: Interrupt domain to create mappings for hardware interrupts.
a8f447be LD	413	*/
	414	int devm_mfd_add_devices(struct device *dev, int id,
	415	const struct mfd_cell *cells, int n_devs,
	416	struct resource *mem_base,
	417	int irq_base, struct irq_domain *domain)
	418	{
	419	struct device **ptr;
	420	int ret;
	421
	422	ptr = devres_alloc(devm_mfd_dev_release, sizeof(*ptr), GFP_KERNEL);
	423	if (!ptr)
	424	return -ENOMEM;
	425
	426	ret = mfd_add_devices(dev, id, cells, n_devs, mem_base,
	427	irq_base, domain);
	428	if (ret < 0) {
	429	devres_free(ptr);
	430	return ret;
	431	}
	432
	433	*ptr = dev;
	434	devres_add(dev, ptr);
	435
	436	return ret;
	437	}
	438	EXPORT_SYMBOL(devm_mfd_add_devices);
	439
aa613de6 DB	440	MODULE_LICENSE("GPL");
aa613de6 DB	441	MODULE_AUTHOR("Ian Molton, Dmitry Baryshkov");