[mirror_ubuntu-bionic-kernel.git] / drivers / acpi / glue.c

/*
 * Link physical devices with ACPI devices support
 *
 * Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
 * Copyright (c) 2005 Intel Corp.
 *
 * This file is released under the GPLv2.
 */
#include <linux/export.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/rwsem.h>
#include <linux/acpi.h>

#include "internal.h"

#define ACPI_GLUE_DEBUG	0
#if ACPI_GLUE_DEBUG
#define DBG(x...) printk(PREFIX x)
#else
#define DBG(x...) do { } while(0)
#endif
static LIST_HEAD(bus_type_list);
static DECLARE_RWSEM(bus_type_sem);

#define PHYSICAL_NODE_STRING "physical_node"

int register_acpi_bus_type(struct acpi_bus_type *type)
{
	if (acpi_disabled)
		return -ENODEV;
	if (type && type->bus && type->find_device) {
		down_write(&bus_type_sem);
		list_add_tail(&type->list, &bus_type_list);
		up_write(&bus_type_sem);
		printk(KERN_INFO PREFIX "bus type %s registered\n",
		       type->bus->name);
		return 0;
	}
	return -ENODEV;
}
EXPORT_SYMBOL_GPL(register_acpi_bus_type);

int unregister_acpi_bus_type(struct acpi_bus_type *type)
{
	if (acpi_disabled)
		return 0;
	if (type) {
		down_write(&bus_type_sem);
		list_del_init(&type->list);
		up_write(&bus_type_sem);
		printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
		       type->bus->name);
		return 0;
	}
	return -ENODEV;
}
EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);

static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
{
	struct acpi_bus_type *tmp, *ret = NULL;

	down_read(&bus_type_sem);
	list_for_each_entry(tmp, &bus_type_list, list) {
		if (tmp->bus == type) {
			ret = tmp;
			break;
		}
	}
	up_read(&bus_type_sem);
	return ret;
}

static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
{
	struct acpi_bus_type *tmp;
	int ret = -ENODEV;

	down_read(&bus_type_sem);
	list_for_each_entry(tmp, &bus_type_list, list) {
		if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
			ret = 0;
			break;
		}
	}
	up_read(&bus_type_sem);
	return ret;
}

/* Get device's handler per its address under its parent */
struct acpi_find_child {
	acpi_handle handle;
	u64 address;
};

static acpi_status
do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	acpi_status status;
	struct acpi_device_info *info;
	struct acpi_find_child *find = context;

	status = acpi_get_object_info(handle, &info);
	if (ACPI_SUCCESS(status)) {
		if ((info->address == find->address)
			&& (info->valid & ACPI_VALID_ADR))
			find->handle = handle;
		kfree(info);
	}
	return AE_OK;
}

acpi_handle acpi_get_child(acpi_handle parent, u64 address)
{
	struct acpi_find_child find = { NULL, address };

	if (!parent)
		return NULL;
	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
			    1, do_acpi_find_child, NULL, &find, NULL);
	return find.handle;
}

EXPORT_SYMBOL(acpi_get_child);

static int acpi_bind_one(struct device *dev, acpi_handle handle)
{
	struct acpi_device *acpi_dev;
	acpi_status status;
	struct acpi_device_physical_node *physical_node, *pn;
	char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
	int retval = -EINVAL;

	if (dev->acpi_handle) {
		if (handle) {
			dev_warn(dev, "ACPI handle is already set\n");
			return -EINVAL;
		} else {
			handle = dev->acpi_handle;
		}
	}
	if (!handle)
		return -EINVAL;

	get_device(dev);
	status = acpi_bus_get_device(handle, &acpi_dev);
	if (ACPI_FAILURE(status))
		goto err;

	physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
	if (!physical_node) {
		retval = -ENOMEM;
		goto err;
	}

	mutex_lock(&acpi_dev->physical_node_lock);

	/* Sanity check. */
	list_for_each_entry(pn, &acpi_dev->physical_node_list, node)
		if (pn->dev == dev) {
			dev_warn(dev, "Already associated with ACPI node\n");
			goto err_free;
		}

	/* allocate physical node id according to physical_node_id_bitmap */
	physical_node->node_id =
		find_first_zero_bit(acpi_dev->physical_node_id_bitmap,
		ACPI_MAX_PHYSICAL_NODE);
	if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) {
		retval = -ENOSPC;
		goto err_free;
	}

	set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap);
	physical_node->dev = dev;
	list_add_tail(&physical_node->node, &acpi_dev->physical_node_list);
	acpi_dev->physical_node_count++;

	mutex_unlock(&acpi_dev->physical_node_lock);

	if (!dev->acpi_handle)
		dev->acpi_handle = handle;

	if (!physical_node->node_id)
		strcpy(physical_node_name, PHYSICAL_NODE_STRING);
	else
		sprintf(physical_node_name,
			"physical_node%d", physical_node->node_id);
	retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
			physical_node_name);
	retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
		"firmware_node");

	if (acpi_dev->wakeup.flags.valid)
		device_set_wakeup_capable(dev, true);

	return 0;

 err:
	dev->acpi_handle = NULL;
	put_device(dev);
	return retval;

 err_free:
	mutex_unlock(&acpi_dev->physical_node_lock);
	kfree(physical_node);
	goto err;
}

static int acpi_unbind_one(struct device *dev)
{
	struct acpi_device_physical_node *entry;
	struct acpi_device *acpi_dev;
	acpi_status status;
	struct list_head *node, *next;

	if (!dev->acpi_handle)
		return 0;

	status = acpi_bus_get_device(dev->acpi_handle, &acpi_dev);
	if (ACPI_FAILURE(status))
		goto err;

	mutex_lock(&acpi_dev->physical_node_lock);
	list_for_each_safe(node, next, &acpi_dev->physical_node_list) {
		char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];

		entry = list_entry(node, struct acpi_device_physical_node,
			node);
		if (entry->dev != dev)
			continue;

		list_del(node);
		clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap);

		acpi_dev->physical_node_count--;

		if (!entry->node_id)
			strcpy(physical_node_name, PHYSICAL_NODE_STRING);
		else
			sprintf(physical_node_name,
				"physical_node%d", entry->node_id);

		sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name);
		sysfs_remove_link(&dev->kobj, "firmware_node");
		dev->acpi_handle = NULL;
		/* acpi_bind_one increase refcnt by one */
		put_device(dev);
		kfree(entry);
	}
	mutex_unlock(&acpi_dev->physical_node_lock);

	return 0;

err:
	dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
	return -EINVAL;
}

static int acpi_platform_notify(struct device *dev)
{
	struct acpi_bus_type *type;
	acpi_handle handle;
	int ret = -EINVAL;

	ret = acpi_bind_one(dev, NULL);
	if (!ret)
		goto out;

	if (!dev->bus || !dev->parent) {
		/* bridge devices genernally haven't bus or parent */
		ret = acpi_find_bridge_device(dev, &handle);
		goto end;
	}
	type = acpi_get_bus_type(dev->bus);
	if (!type) {
		DBG("No ACPI bus support for %s\n", dev_name(dev));
		ret = -EINVAL;
		goto end;
	}
	if ((ret = type->find_device(dev, &handle)) != 0)
		DBG("Can't get handler for %s\n", dev_name(dev));
 end:
	if (!ret)
		acpi_bind_one(dev, handle);

 out:
#if ACPI_GLUE_DEBUG
	if (!ret) {
		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

		acpi_get_name(dev->acpi_handle, ACPI_FULL_PATHNAME, &buffer);
		DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
		kfree(buffer.pointer);
	} else
		DBG("Device %s -> No ACPI support\n", dev_name(dev));
#endif

	return ret;
}

static int acpi_platform_notify_remove(struct device *dev)
{
	acpi_unbind_one(dev);
	return 0;
}

int __init init_acpi_device_notify(void)
{
	if (platform_notify || platform_notify_remove) {
		printk(KERN_ERR PREFIX "Can't use platform_notify\n");
		return 0;
	}
	platform_notify = acpi_platform_notify;
	platform_notify_remove = acpi_platform_notify_remove;
	return 0;
}
Commit	Line	Data
4e10d12a DSL	1	/*
	2	* Link physical devices with ACPI devices support
	3	*
	4	* Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
	5	* Copyright (c) 2005 Intel Corp.
	6	*
	7	* This file is released under the GPLv2.
	8	*/
214f2c90	9	#include <linux/export.h>
4e10d12a DSL	10	#include <linux/init.h>
	11	#include <linux/list.h>
	12	#include <linux/device.h>
5a0e3ad6	13	#include <linux/slab.h>
4e10d12a DSL	14	#include <linux/rwsem.h>
	15	#include <linux/acpi.h>
	16
a192a958 LB	17	#include "internal.h"
a192a958 LB	18
4e10d12a DSL	19	#define ACPI_GLUE_DEBUG 0
	20	#if ACPI_GLUE_DEBUG
	21	#define DBG(x...) printk(PREFIX x)
	22	#else
4ebf83c8	23	#define DBG(x...) do { } while(0)
4e10d12a DSL	24	#endif
	25	static LIST_HEAD(bus_type_list);
	26	static DECLARE_RWSEM(bus_type_sem);
	27
1033f904 LT	28	#define PHYSICAL_NODE_STRING "physical_node"
1033f904 LT	29
4e10d12a DSL	30	int register_acpi_bus_type(struct acpi_bus_type *type)
	31	{
	32	if (acpi_disabled)
	33	return -ENODEV;
	34	if (type && type->bus && type->find_device) {
	35	down_write(&bus_type_sem);
	36	list_add_tail(&type->list, &bus_type_list);
	37	up_write(&bus_type_sem);
4be44fcd LB	38	printk(KERN_INFO PREFIX "bus type %s registered\n",
4be44fcd LB	39	type->bus->name);
4e10d12a DSL	40	return 0;
	41	}
	42	return -ENODEV;
	43	}
91e4d5a1	44	EXPORT_SYMBOL_GPL(register_acpi_bus_type);
4e10d12a	45
4e10d12a DSL	46	int unregister_acpi_bus_type(struct acpi_bus_type *type)
	47	{
	48	if (acpi_disabled)
	49	return 0;
	50	if (type) {
	51	down_write(&bus_type_sem);
	52	list_del_init(&type->list);
	53	up_write(&bus_type_sem);
4be44fcd LB	54	printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
4be44fcd LB	55	type->bus->name);
4e10d12a DSL	56	return 0;
	57	}
	58	return -ENODEV;
	59	}
91e4d5a1	60	EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
4e10d12a	61
4e10d12a DSL	62	static struct acpi_bus_type acpi_get_bus_type(struct bus_type type)
	63	{
	64	struct acpi_bus_type tmp, ret = NULL;
	65
	66	down_read(&bus_type_sem);
	67	list_for_each_entry(tmp, &bus_type_list, list) {
	68	if (tmp->bus == type) {
	69	ret = tmp;
	70	break;
	71	}
	72	}
	73	up_read(&bus_type_sem);
	74	return ret;
	75	}
	76
	77	static int acpi_find_bridge_device(struct device dev, acpi_handle handle)
	78	{
	79	struct acpi_bus_type *tmp;
	80	int ret = -ENODEV;
	81
	82	down_read(&bus_type_sem);
	83	list_for_each_entry(tmp, &bus_type_list, list) {
	84	if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
	85	ret = 0;
	86	break;
	87	}
	88	}
	89	up_read(&bus_type_sem);
	90	return ret;
	91	}
	92
4e10d12a DSL	93	/* Get device's handler per its address under its parent */
	94	struct acpi_find_child {
	95	acpi_handle handle;
439913ff	96	u64 address;
4e10d12a DSL	97	};
	98
	99	static acpi_status
	100	do_acpi_find_child(acpi_handle handle, u32 lvl, void context, void *rv)
	101	{
	102	acpi_status status;
	103	struct acpi_device_info *info;
50dd0969	104	struct acpi_find_child *find = context;
4e10d12a	105
15b8dd53	106	status = acpi_get_object_info(handle, &info);
4e10d12a	107	if (ACPI_SUCCESS(status)) {
108029ff ZY	108	if ((info->address == find->address)
108029ff ZY	109	&& (info->valid & ACPI_VALID_ADR))
4e10d12a	110	find->handle = handle;
15b8dd53	111	kfree(info);
4e10d12a DSL	112	}
	113	return AE_OK;
	114	}
	115
439913ff	116	acpi_handle acpi_get_child(acpi_handle parent, u64 address)
4e10d12a DSL	117	{
	118	struct acpi_find_child find = { NULL, address };
	119
	120	if (!parent)
	121	return NULL;
	122	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
2263576c	123	1, do_acpi_find_child, NULL, &find, NULL);
4e10d12a DSL	124	return find.handle;
	125	}
	126
	127	EXPORT_SYMBOL(acpi_get_child);
	128
4e10d12a DSL	129	static int acpi_bind_one(struct device *dev, acpi_handle handle)
4e10d12a DSL	130	{
1071695f	131	struct acpi_device *acpi_dev;
4e10d12a	132	acpi_status status;
f3fd0c8a	133	struct acpi_device_physical_node physical_node, pn;
1033f904 LT	134	char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
1033f904 LT	135	int retval = -EINVAL;
4e10d12a	136
06f64c8f	137	if (dev->acpi_handle) {
f3fd0c8a RW	138	if (handle) {
	139	dev_warn(dev, "ACPI handle is already set\n");
	140	return -EINVAL;
	141	} else {
	142	handle = dev->acpi_handle;
	143	}
4e10d12a	144	}
f3fd0c8a RW	145	if (!handle)
f3fd0c8a RW	146	return -EINVAL;
1033f904	147
4e10d12a	148	get_device(dev);
1033f904 LT	149	status = acpi_bus_get_device(handle, &acpi_dev);
	150	if (ACPI_FAILURE(status))
	151	goto err;
	152
f3fd0c8a	153	physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
1033f904 LT	154	if (!physical_node) {
	155	retval = -ENOMEM;
	156	goto err;
4e10d12a	157	}
4e10d12a	158
1033f904	159	mutex_lock(&acpi_dev->physical_node_lock);
f3fd0c8a RW	160
	161	/* Sanity check. */
	162	list_for_each_entry(pn, &acpi_dev->physical_node_list, node)
	163	if (pn->dev == dev) {
	164	dev_warn(dev, "Already associated with ACPI node\n");
	165	goto err_free;
	166	}
	167
1033f904 LT	168	/* allocate physical node id according to physical_node_id_bitmap */
	169	physical_node->node_id =
	170	find_first_zero_bit(acpi_dev->physical_node_id_bitmap,
	171	ACPI_MAX_PHYSICAL_NODE);
	172	if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) {
	173	retval = -ENOSPC;
f3fd0c8a	174	goto err_free;
1071695f DB	175	}
1071695f DB	176
1033f904 LT	177	set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap);
	178	physical_node->dev = dev;
	179	list_add_tail(&physical_node->node, &acpi_dev->physical_node_list);
	180	acpi_dev->physical_node_count++;
f3fd0c8a	181
1033f904 LT	182	mutex_unlock(&acpi_dev->physical_node_lock);
1033f904 LT	183
f3fd0c8a RW	184	if (!dev->acpi_handle)
f3fd0c8a RW	185	dev->acpi_handle = handle;
1033f904 LT	186
	187	if (!physical_node->node_id)
	188	strcpy(physical_node_name, PHYSICAL_NODE_STRING);
	189	else
	190	sprintf(physical_node_name,
	191	"physical_node%d", physical_node->node_id);
	192	retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
	193	physical_node_name);
	194	retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
	195	"firmware_node");
	196
	197	if (acpi_dev->wakeup.flags.valid)
	198	device_set_wakeup_capable(dev, true);
	199
4e10d12a	200	return 0;
1033f904 LT	201
1033f904 LT	202	err:
f3fd0c8a	203	dev->acpi_handle = NULL;
1033f904 LT	204	put_device(dev);
1033f904 LT	205	return retval;
f3fd0c8a RW	206
	207	err_free:
	208	mutex_unlock(&acpi_dev->physical_node_lock);
	209	kfree(physical_node);
	210	goto err;
4e10d12a DSL	211	}
	212
	213	static int acpi_unbind_one(struct device *dev)
	214	{
1033f904 LT	215	struct acpi_device_physical_node *entry;
	216	struct acpi_device *acpi_dev;
	217	acpi_status status;
	218	struct list_head node, next;
	219
06f64c8f	220	if (!dev->acpi_handle)
4e10d12a	221	return 0;
1071695f	222
06f64c8f	223	status = acpi_bus_get_device(dev->acpi_handle, &acpi_dev);
1033f904 LT	224	if (ACPI_FAILURE(status))
1033f904 LT	225	goto err;
1071695f	226
1033f904 LT	227	mutex_lock(&acpi_dev->physical_node_lock);
	228	list_for_each_safe(node, next, &acpi_dev->physical_node_list) {
	229	char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
	230
	231	entry = list_entry(node, struct acpi_device_physical_node,
	232	node);
	233	if (entry->dev != dev)
	234	continue;
	235
	236	list_del(node);
	237	clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap);
1071695f	238
1033f904 LT	239	acpi_dev->physical_node_count--;
	240
	241	if (!entry->node_id)
	242	strcpy(physical_node_name, PHYSICAL_NODE_STRING);
	243	else
	244	sprintf(physical_node_name,
	245	"physical_node%d", entry->node_id);
	246
	247	sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name);
	248	sysfs_remove_link(&dev->kobj, "firmware_node");
06f64c8f	249	dev->acpi_handle = NULL;
4e10d12a DSL	250	/* acpi_bind_one increase refcnt by one */
4e10d12a DSL	251	put_device(dev);
1033f904	252	kfree(entry);
4e10d12a	253	}
1033f904 LT	254	mutex_unlock(&acpi_dev->physical_node_lock);
1033f904 LT	255
4e10d12a	256	return 0;
1033f904 LT	257
	258	err:
	259	dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
	260	return -EINVAL;
4e10d12a DSL	261	}
	262
	263	static int acpi_platform_notify(struct device *dev)
	264	{
	265	struct acpi_bus_type *type;
	266	acpi_handle handle;
	267	int ret = -EINVAL;
	268
f3fd0c8a RW	269	ret = acpi_bind_one(dev, NULL);
	270	if (!ret)
	271	goto out;
	272
4e10d12a DSL	273	if (!dev->bus \|\| !dev->parent) {
	274	/* bridge devices genernally haven't bus or parent */
	275	ret = acpi_find_bridge_device(dev, &handle);
	276	goto end;
	277	}
	278	type = acpi_get_bus_type(dev->bus);
	279	if (!type) {
db1461ad	280	DBG("No ACPI bus support for %s\n", dev_name(dev));
4e10d12a DSL	281	ret = -EINVAL;
	282	goto end;
	283	}
	284	if ((ret = type->find_device(dev, &handle)) != 0)
db1461ad	285	DBG("Can't get handler for %s\n", dev_name(dev));
f3fd0c8a	286	end:
4e10d12a DSL	287	if (!ret)
	288	acpi_bind_one(dev, handle);
	289
f3fd0c8a	290	out:
4e10d12a DSL	291	#if ACPI_GLUE_DEBUG
	292	if (!ret) {
	293	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	294
06f64c8f	295	acpi_get_name(dev->acpi_handle, ACPI_FULL_PATHNAME, &buffer);
db1461ad	296	DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
02438d87	297	kfree(buffer.pointer);
4e10d12a	298	} else
db1461ad	299	DBG("Device %s -> No ACPI support\n", dev_name(dev));
4e10d12a DSL	300	#endif
	301
	302	return ret;
	303	}
	304
	305	static int acpi_platform_notify_remove(struct device *dev)
	306	{
	307	acpi_unbind_one(dev);
	308	return 0;
	309	}
	310
0e46517d	311	int __init init_acpi_device_notify(void)
4e10d12a	312	{
4e10d12a DSL	313	if (platform_notify \|\| platform_notify_remove) {
	314	printk(KERN_ERR PREFIX "Can't use platform_notify\n");
	315	return 0;
	316	}
	317	platform_notify = acpi_platform_notify;
	318	platform_notify_remove = acpi_platform_notify_remove;
	319	return 0;
	320	}