[linux-block.git] / drivers / acpi / acpi_platform.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * ACPI support for platform bus type.
 *
 * Copyright (C) 2012, Intel Corporation
 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
 *          Mathias Nyman <mathias.nyman@linux.intel.com>
 *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 */

#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/pci.h>
#include <linux/platform_device.h>

#include "internal.h"

static const struct acpi_device_id forbidden_id_list[] = {
	{"PNP0000",  0},	/* PIC */
	{"PNP0100",  0},	/* Timer */
	{"PNP0200",  0},	/* AT DMA Controller */
	{"ACPI0009", 0},	/* IOxAPIC */
	{"ACPI000A", 0},	/* IOAPIC */
	{"SMB0001",  0},	/* ACPI SMBUS virtual device */
	{"", 0},
};

static struct platform_device *acpi_platform_device_find_by_companion(struct acpi_device *adev)
{
	struct device *dev;

	dev = bus_find_device_by_acpi_dev(&platform_bus_type, adev);
	return dev ? to_platform_device(dev) : NULL;
}

static int acpi_platform_device_remove_notify(struct notifier_block *nb,
					      unsigned long value, void *arg)
{
	struct acpi_device *adev = arg;
	struct platform_device *pdev;

	switch (value) {
	case ACPI_RECONFIG_DEVICE_ADD:
		/* Nothing to do here */
		break;
	case ACPI_RECONFIG_DEVICE_REMOVE:
		if (!acpi_device_enumerated(adev))
			break;

		pdev = acpi_platform_device_find_by_companion(adev);
		if (!pdev)
			break;

		platform_device_unregister(pdev);
		put_device(&pdev->dev);
		break;
	}

	return NOTIFY_OK;
}

static struct notifier_block acpi_platform_notifier = {
	.notifier_call = acpi_platform_device_remove_notify,
};

static void acpi_platform_fill_resource(struct acpi_device *adev,
	const struct resource *src, struct resource *dest)
{
	struct device *parent;

	*dest = *src;

	/*
	 * If the device has parent we need to take its resources into
	 * account as well because this device might consume part of those.
	 */
	parent = acpi_get_first_physical_node(adev->parent);
	if (parent && dev_is_pci(parent))
		dest->parent = pci_find_resource(to_pci_dev(parent), dest);
}

/**
 * acpi_create_platform_device - Create platform device for ACPI device node
 * @adev: ACPI device node to create a platform device for.
 * @properties: Optional collection of build-in properties.
 *
 * Check if the given @adev can be represented as a platform device and, if
 * that's the case, create and register a platform device, populate its common
 * resources and returns a pointer to it.  Otherwise, return %NULL.
 *
 * Name of the platform device will be the same as @adev's.
 */
struct platform_device *acpi_create_platform_device(struct acpi_device *adev,
					struct property_entry *properties)
{
	struct platform_device *pdev = NULL;
	struct platform_device_info pdevinfo;
	struct resource_entry *rentry;
	struct list_head resource_list;
	struct resource *resources = NULL;
	int count;

	/* If the ACPI node already has a physical device attached, skip it. */
	if (adev->physical_node_count)
		return NULL;

	if (!acpi_match_device_ids(adev, forbidden_id_list))
		return ERR_PTR(-EINVAL);

	INIT_LIST_HEAD(&resource_list);
	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	if (count < 0) {
		return NULL;
	} else if (count > 0) {
		resources = kcalloc(count, sizeof(struct resource),
				    GFP_KERNEL);
		if (!resources) {
			dev_err(&adev->dev, "No memory for resources\n");
			acpi_dev_free_resource_list(&resource_list);
			return ERR_PTR(-ENOMEM);
		}
		count = 0;
		list_for_each_entry(rentry, &resource_list, node)
			acpi_platform_fill_resource(adev, rentry->res,
						    &resources[count++]);

		acpi_dev_free_resource_list(&resource_list);
	}

	memset(&pdevinfo, 0, sizeof(pdevinfo));
	/*
	 * If the ACPI node has a parent and that parent has a physical device
	 * attached to it, that physical device should be the parent of the
	 * platform device we are about to create.
	 */
	pdevinfo.parent = adev->parent ?
		acpi_get_first_physical_node(adev->parent) : NULL;
	pdevinfo.name = dev_name(&adev->dev);
	pdevinfo.id = -1;
	pdevinfo.res = resources;
	pdevinfo.num_res = count;
	pdevinfo.fwnode = acpi_fwnode_handle(adev);
	pdevinfo.properties = properties;

	if (acpi_dma_supported(adev))
		pdevinfo.dma_mask = DMA_BIT_MASK(32);
	else
		pdevinfo.dma_mask = 0;

	pdev = platform_device_register_full(&pdevinfo);
	if (IS_ERR(pdev))
		dev_err(&adev->dev, "platform device creation failed: %ld\n",
			PTR_ERR(pdev));
	else {
		set_dev_node(&pdev->dev, acpi_get_node(adev->handle));
		dev_dbg(&adev->dev, "created platform device %s\n",
			dev_name(&pdev->dev));
	}

	kfree(resources);

	return pdev;
}
EXPORT_SYMBOL_GPL(acpi_create_platform_device);

void __init acpi_platform_init(void)
{
	acpi_reconfig_notifier_register(&acpi_platform_notifier);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
91e56878 MW	2	/*
	3	* ACPI support for platform bus type.
	4	*
	5	* Copyright (C) 2012, Intel Corporation
	6	* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
	7	* Mathias Nyman <mathias.nyman@linux.intel.com>
	8	* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
91e56878 MW	9	*/
	10
	11	#include <linux/acpi.h>
	12	#include <linux/device.h>
e375325c	13	#include <linux/err.h>
91e56878 MW	14	#include <linux/kernel.h>
91e56878 MW	15	#include <linux/module.h>
8a2f38dd	16	#include <linux/dma-mapping.h>
a252d881	17	#include <linux/pci.h>
91e56878 MW	18	#include <linux/platform_device.h>
91e56878 MW	19
5923f986 AS	20	#include "internal.h"
5923f986 AS	21
48459340	22	static const struct acpi_device_id forbidden_id_list[] = {
08f63d97 JR	23	{"PNP0000", 0}, /* PIC */
	24	{"PNP0100", 0}, /* Timer */
	25	{"PNP0200", 0}, /* AT DMA Controller */
	26	{"ACPI0009", 0}, /* IOxAPIC */
	27	{"ACPI000A", 0}, /* IOAPIC */
2bbb5fa3	28	{"SMB0001", 0}, /* ACPI SMBUS virtual device */
48459340	29	{"", 0},
141a297b RW	30	};
141a297b RW	31
cb0701ac AS	32	static struct platform_device acpi_platform_device_find_by_companion(struct acpi_device adev)
	33	{
	34	struct device *dev;
	35
	36	dev = bus_find_device_by_acpi_dev(&platform_bus_type, adev);
	37	return dev ? to_platform_device(dev) : NULL;
	38	}
	39
	40	static int acpi_platform_device_remove_notify(struct notifier_block *nb,
	41	unsigned long value, void *arg)
	42	{
	43	struct acpi_device *adev = arg;
	44	struct platform_device *pdev;
	45
	46	switch (value) {
	47	case ACPI_RECONFIG_DEVICE_ADD:
	48	/* Nothing to do here */
	49	break;
	50	case ACPI_RECONFIG_DEVICE_REMOVE:
	51	if (!acpi_device_enumerated(adev))
	52	break;
	53
	54	pdev = acpi_platform_device_find_by_companion(adev);
	55	if (!pdev)
	56	break;
	57
	58	platform_device_unregister(pdev);
	59	put_device(&pdev->dev);
	60	break;
	61	}
	62
	63	return NOTIFY_OK;
	64	}
	65
	66	static struct notifier_block acpi_platform_notifier = {
	67	.notifier_call = acpi_platform_device_remove_notify,
	68	};
	69
a252d881 MW	70	static void acpi_platform_fill_resource(struct acpi_device *adev,
	71	const struct resource src, struct resource dest)
	72	{
	73	struct device *parent;
	74
	75	dest = src;
	76
	77	/*
	78	* If the device has parent we need to take its resources into
	79	* account as well because this device might consume part of those.
	80	*/
	81	parent = acpi_get_first_physical_node(adev->parent);
	82	if (parent && dev_is_pci(parent))
	83	dest->parent = pci_find_resource(to_pci_dev(parent), dest);
	84	}
	85
91e56878 MW	86	/**
	87	* acpi_create_platform_device - Create platform device for ACPI device node
	88	* @adev: ACPI device node to create a platform device for.
1571875b	89	* @properties: Optional collection of build-in properties.
91e56878 MW	90	*
	91	* Check if the given @adev can be represented as a platform device and, if
	92	* that's the case, create and register a platform device, populate its common
	93	* resources and returns a pointer to it. Otherwise, return %NULL.
	94	*
7eaa2800	95	* Name of the platform device will be the same as @adev's.
91e56878	96	*/
1571875b HK	97	struct platform_device acpi_create_platform_device(struct acpi_device adev,
1571875b HK	98	struct property_entry *properties)
91e56878 MW	99	{
91e56878 MW	100	struct platform_device *pdev = NULL;
863f9f30	101	struct platform_device_info pdevinfo;
90e97820	102	struct resource_entry *rentry;
8e345c99	103	struct list_head resource_list;
62eb4b07	104	struct resource *resources = NULL;
8e345c99	105	int count;
91e56878 MW	106
	107	/* If the ACPI node already has a physical device attached, skip it. */
	108	if (adev->physical_node_count)
8ce62f85	109	return NULL;
91e56878	110
48459340 ZR	111	if (!acpi_match_device_ids(adev, forbidden_id_list))
	112	return ERR_PTR(-EINVAL);
	113
8e345c99 RW	114	INIT_LIST_HEAD(&resource_list);
8e345c99 RW	115	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
d2fe7251	116	if (count < 0) {
8ce62f85	117	return NULL;
d2fe7251	118	} else if (count > 0) {
6396bb22	119	resources = kcalloc(count, sizeof(struct resource),
d2fe7251 RW	120	GFP_KERNEL);
	121	if (!resources) {
	122	dev_err(&adev->dev, "No memory for resources\n");
	123	acpi_dev_free_resource_list(&resource_list);
8ce62f85	124	return ERR_PTR(-ENOMEM);
d2fe7251 RW	125	}
	126	count = 0;
	127	list_for_each_entry(rentry, &resource_list, node)
a252d881 MW	128	acpi_platform_fill_resource(adev, rentry->res,
a252d881 MW	129	&resources[count++]);
91e56878	130
8e345c99	131	acpi_dev_free_resource_list(&resource_list);
91e56878	132	}
91e56878	133
863f9f30	134	memset(&pdevinfo, 0, sizeof(pdevinfo));
91e56878 MW	135	/*
	136	* If the ACPI node has a parent and that parent has a physical device
	137	* attached to it, that physical device should be the parent of the
	138	* platform device we are about to create.
	139	*/
3b95bd16 AM	140	pdevinfo.parent = adev->parent ?
3b95bd16 AM	141	acpi_get_first_physical_node(adev->parent) : NULL;
863f9f30 RW	142	pdevinfo.name = dev_name(&adev->dev);
	143	pdevinfo.id = -1;
	144	pdevinfo.res = resources;
	145	pdevinfo.num_res = count;
ce793486	146	pdevinfo.fwnode = acpi_fwnode_handle(adev);
1571875b	147	pdevinfo.properties = properties;
1831eff8 SS	148
	149	if (acpi_dma_supported(adev))
	150	pdevinfo.dma_mask = DMA_BIT_MASK(32);
	151	else
	152	pdevinfo.dma_mask = 0;
	153
863f9f30	154	pdev = platform_device_register_full(&pdevinfo);
8ce62f85	155	if (IS_ERR(pdev))
91e56878 MW	156	dev_err(&adev->dev, "platform device creation failed: %ld\n",
91e56878 MW	157	PTR_ERR(pdev));
79f97c30 SD	158	else {
79f97c30 SD	159	set_dev_node(&pdev->dev, acpi_get_node(adev->handle));
91e56878 MW	160	dev_dbg(&adev->dev, "created platform device %s\n",
91e56878 MW	161	dev_name(&pdev->dev));
79f97c30	162	}
91e56878	163
8e345c99	164	kfree(resources);
79f97c30	165
8ce62f85 RW	166	return pdev;
8ce62f85 RW	167	}
083bf668	168	EXPORT_SYMBOL_GPL(acpi_create_platform_device);
cb0701ac AS	169
	170	void __init acpi_platform_init(void)
	171	{
	172	acpi_reconfig_notifier_register(&acpi_platform_notifier);
	173	}