Linux Audio

Check our new training course

Loading...
v3.1
  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 */
 
  9#include <linux/init.h>
 10#include <linux/list.h>
 11#include <linux/device.h>
 12#include <linux/slab.h>
 13#include <linux/rwsem.h>
 14#include <linux/acpi.h>
 15
 16#include "internal.h"
 17
 18#define ACPI_GLUE_DEBUG	0
 19#if ACPI_GLUE_DEBUG
 20#define DBG(x...) printk(PREFIX x)
 21#else
 22#define DBG(x...) do { } while(0)
 23#endif
 24static LIST_HEAD(bus_type_list);
 25static DECLARE_RWSEM(bus_type_sem);
 26
 27int register_acpi_bus_type(struct acpi_bus_type *type)
 28{
 29	if (acpi_disabled)
 30		return -ENODEV;
 31	if (type && type->bus && type->find_device) {
 32		down_write(&bus_type_sem);
 33		list_add_tail(&type->list, &bus_type_list);
 34		up_write(&bus_type_sem);
 35		printk(KERN_INFO PREFIX "bus type %s registered\n",
 36		       type->bus->name);
 37		return 0;
 38	}
 39	return -ENODEV;
 40}
 41
 42int unregister_acpi_bus_type(struct acpi_bus_type *type)
 43{
 44	if (acpi_disabled)
 45		return 0;
 46	if (type) {
 47		down_write(&bus_type_sem);
 48		list_del_init(&type->list);
 49		up_write(&bus_type_sem);
 50		printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
 51		       type->bus->name);
 52		return 0;
 53	}
 54	return -ENODEV;
 55}
 56
 57static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
 58{
 59	struct acpi_bus_type *tmp, *ret = NULL;
 60
 61	down_read(&bus_type_sem);
 62	list_for_each_entry(tmp, &bus_type_list, list) {
 63		if (tmp->bus == type) {
 64			ret = tmp;
 65			break;
 66		}
 67	}
 68	up_read(&bus_type_sem);
 69	return ret;
 70}
 
 71
 72static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
 73{
 74	struct acpi_bus_type *tmp;
 75	int ret = -ENODEV;
 76
 77	down_read(&bus_type_sem);
 78	list_for_each_entry(tmp, &bus_type_list, list) {
 79		if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
 80			ret = 0;
 81			break;
 82		}
 83	}
 84	up_read(&bus_type_sem);
 85	return ret;
 86}
 
 87
 88/* Get device's handler per its address under its parent */
 89struct acpi_find_child {
 90	acpi_handle handle;
 91	u64 address;
 92};
 93
 94static acpi_status
 95do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
 96{
 97	acpi_status status;
 98	struct acpi_device_info *info;
 99	struct acpi_find_child *find = context;
100
101	status = acpi_get_object_info(handle, &info);
102	if (ACPI_SUCCESS(status)) {
103		if ((info->address == find->address)
104			&& (info->valid & ACPI_VALID_ADR))
105			find->handle = handle;
106		kfree(info);
107	}
108	return AE_OK;
109}
110
111acpi_handle acpi_get_child(acpi_handle parent, u64 address)
112{
113	struct acpi_find_child find = { NULL, address };
114
115	if (!parent)
116		return NULL;
117	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
118			    1, do_acpi_find_child, NULL, &find, NULL);
119	return find.handle;
120}
121
122EXPORT_SYMBOL(acpi_get_child);
123
124/* Link ACPI devices with physical devices */
125static void acpi_glue_data_handler(acpi_handle handle,
126				   void *context)
127{
128	/* we provide an empty handler */
129}
130
131/* Note: a success call will increase reference count by one */
132struct device *acpi_get_physical_device(acpi_handle handle)
133{
134	acpi_status status;
135	struct device *dev;
136
137	status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
138	if (ACPI_SUCCESS(status))
139		return get_device(dev);
140	return NULL;
141}
142
143EXPORT_SYMBOL(acpi_get_physical_device);
144
145static int acpi_bind_one(struct device *dev, acpi_handle handle)
146{
147	struct acpi_device *acpi_dev;
148	acpi_status status;
149
150	if (dev->archdata.acpi_handle) {
151		dev_warn(dev, "Drivers changed 'acpi_handle'\n");
152		return -EINVAL;
153	}
154	get_device(dev);
155	status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
156	if (ACPI_FAILURE(status)) {
157		put_device(dev);
158		return -EINVAL;
159	}
160	dev->archdata.acpi_handle = handle;
161
162	status = acpi_bus_get_device(handle, &acpi_dev);
163	if (!ACPI_FAILURE(status)) {
164		int ret;
165
166		ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
167				"firmware_node");
168		ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
169				"physical_node");
170		if (acpi_dev->wakeup.flags.valid)
171			device_set_wakeup_capable(dev, true);
172	}
173
174	return 0;
175}
176
177static int acpi_unbind_one(struct device *dev)
178{
179	if (!dev->archdata.acpi_handle)
180		return 0;
181	if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) {
182		struct acpi_device *acpi_dev;
183
184		/* acpi_get_physical_device increase refcnt by one */
185		put_device(dev);
186
187		if (!acpi_bus_get_device(dev->archdata.acpi_handle,
188					&acpi_dev)) {
189			sysfs_remove_link(&dev->kobj, "firmware_node");
190			sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node");
191		}
192
193		acpi_detach_data(dev->archdata.acpi_handle,
194				 acpi_glue_data_handler);
195		dev->archdata.acpi_handle = NULL;
196		/* acpi_bind_one increase refcnt by one */
197		put_device(dev);
198	} else {
199		dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
200	}
201	return 0;
202}
203
204static int acpi_platform_notify(struct device *dev)
205{
206	struct acpi_bus_type *type;
207	acpi_handle handle;
208	int ret = -EINVAL;
209
210	if (!dev->bus || !dev->parent) {
211		/* bridge devices genernally haven't bus or parent */
212		ret = acpi_find_bridge_device(dev, &handle);
213		goto end;
214	}
215	type = acpi_get_bus_type(dev->bus);
216	if (!type) {
217		DBG("No ACPI bus support for %s\n", dev_name(dev));
218		ret = -EINVAL;
219		goto end;
220	}
221	if ((ret = type->find_device(dev, &handle)) != 0)
222		DBG("Can't get handler for %s\n", dev_name(dev));
223      end:
224	if (!ret)
225		acpi_bind_one(dev, handle);
226
227#if ACPI_GLUE_DEBUG
228	if (!ret) {
229		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
230
231		acpi_get_name(dev->archdata.acpi_handle,
232			      ACPI_FULL_PATHNAME, &buffer);
233		DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
234		kfree(buffer.pointer);
235	} else
236		DBG("Device %s -> No ACPI support\n", dev_name(dev));
237#endif
238
239	return ret;
240}
241
242static int acpi_platform_notify_remove(struct device *dev)
243{
244	acpi_unbind_one(dev);
245	return 0;
246}
247
248int __init init_acpi_device_notify(void)
249{
250	if (platform_notify || platform_notify_remove) {
251		printk(KERN_ERR PREFIX "Can't use platform_notify\n");
252		return 0;
253	}
254	platform_notify = acpi_platform_notify;
255	platform_notify_remove = acpi_platform_notify_remove;
256	return 0;
257}
v3.5.6
  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 */
  9#include <linux/export.h>
 10#include <linux/init.h>
 11#include <linux/list.h>
 12#include <linux/device.h>
 13#include <linux/slab.h>
 14#include <linux/rwsem.h>
 15#include <linux/acpi.h>
 16
 17#include "internal.h"
 18
 19#define ACPI_GLUE_DEBUG	0
 20#if ACPI_GLUE_DEBUG
 21#define DBG(x...) printk(PREFIX x)
 22#else
 23#define DBG(x...) do { } while(0)
 24#endif
 25static LIST_HEAD(bus_type_list);
 26static DECLARE_RWSEM(bus_type_sem);
 27
 28int register_acpi_bus_type(struct acpi_bus_type *type)
 29{
 30	if (acpi_disabled)
 31		return -ENODEV;
 32	if (type && type->bus && type->find_device) {
 33		down_write(&bus_type_sem);
 34		list_add_tail(&type->list, &bus_type_list);
 35		up_write(&bus_type_sem);
 36		printk(KERN_INFO PREFIX "bus type %s registered\n",
 37		       type->bus->name);
 38		return 0;
 39	}
 40	return -ENODEV;
 41}
 42
 43int unregister_acpi_bus_type(struct acpi_bus_type *type)
 44{
 45	if (acpi_disabled)
 46		return 0;
 47	if (type) {
 48		down_write(&bus_type_sem);
 49		list_del_init(&type->list);
 50		up_write(&bus_type_sem);
 51		printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
 52		       type->bus->name);
 53		return 0;
 54	}
 55	return -ENODEV;
 56}
 57
 58static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
 59{
 60	struct acpi_bus_type *tmp, *ret = NULL;
 61
 62	down_read(&bus_type_sem);
 63	list_for_each_entry(tmp, &bus_type_list, list) {
 64		if (tmp->bus == type) {
 65			ret = tmp;
 66			break;
 67		}
 68	}
 69	up_read(&bus_type_sem);
 70	return ret;
 71}
 72EXPORT_SYMBOL_GPL(register_acpi_bus_type);
 73
 74static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
 75{
 76	struct acpi_bus_type *tmp;
 77	int ret = -ENODEV;
 78
 79	down_read(&bus_type_sem);
 80	list_for_each_entry(tmp, &bus_type_list, list) {
 81		if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
 82			ret = 0;
 83			break;
 84		}
 85	}
 86	up_read(&bus_type_sem);
 87	return ret;
 88}
 89EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
 90
 91/* Get device's handler per its address under its parent */
 92struct acpi_find_child {
 93	acpi_handle handle;
 94	u64 address;
 95};
 96
 97static acpi_status
 98do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
 99{
100	acpi_status status;
101	struct acpi_device_info *info;
102	struct acpi_find_child *find = context;
103
104	status = acpi_get_object_info(handle, &info);
105	if (ACPI_SUCCESS(status)) {
106		if ((info->address == find->address)
107			&& (info->valid & ACPI_VALID_ADR))
108			find->handle = handle;
109		kfree(info);
110	}
111	return AE_OK;
112}
113
114acpi_handle acpi_get_child(acpi_handle parent, u64 address)
115{
116	struct acpi_find_child find = { NULL, address };
117
118	if (!parent)
119		return NULL;
120	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
121			    1, do_acpi_find_child, NULL, &find, NULL);
122	return find.handle;
123}
124
125EXPORT_SYMBOL(acpi_get_child);
126
127/* Link ACPI devices with physical devices */
128static void acpi_glue_data_handler(acpi_handle handle,
129				   void *context)
130{
131	/* we provide an empty handler */
132}
133
134/* Note: a success call will increase reference count by one */
135struct device *acpi_get_physical_device(acpi_handle handle)
136{
137	acpi_status status;
138	struct device *dev;
139
140	status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
141	if (ACPI_SUCCESS(status))
142		return get_device(dev);
143	return NULL;
144}
145
146EXPORT_SYMBOL(acpi_get_physical_device);
147
148static int acpi_bind_one(struct device *dev, acpi_handle handle)
149{
150	struct acpi_device *acpi_dev;
151	acpi_status status;
152
153	if (dev->archdata.acpi_handle) {
154		dev_warn(dev, "Drivers changed 'acpi_handle'\n");
155		return -EINVAL;
156	}
157	get_device(dev);
158	status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
159	if (ACPI_FAILURE(status)) {
160		put_device(dev);
161		return -EINVAL;
162	}
163	dev->archdata.acpi_handle = handle;
164
165	status = acpi_bus_get_device(handle, &acpi_dev);
166	if (!ACPI_FAILURE(status)) {
167		int ret;
168
169		ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
170				"firmware_node");
171		ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
172				"physical_node");
173		if (acpi_dev->wakeup.flags.valid)
174			device_set_wakeup_capable(dev, true);
175	}
176
177	return 0;
178}
179
180static int acpi_unbind_one(struct device *dev)
181{
182	if (!dev->archdata.acpi_handle)
183		return 0;
184	if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) {
185		struct acpi_device *acpi_dev;
186
187		/* acpi_get_physical_device increase refcnt by one */
188		put_device(dev);
189
190		if (!acpi_bus_get_device(dev->archdata.acpi_handle,
191					&acpi_dev)) {
192			sysfs_remove_link(&dev->kobj, "firmware_node");
193			sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node");
194		}
195
196		acpi_detach_data(dev->archdata.acpi_handle,
197				 acpi_glue_data_handler);
198		dev->archdata.acpi_handle = NULL;
199		/* acpi_bind_one increase refcnt by one */
200		put_device(dev);
201	} else {
202		dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
203	}
204	return 0;
205}
206
207static int acpi_platform_notify(struct device *dev)
208{
209	struct acpi_bus_type *type;
210	acpi_handle handle;
211	int ret = -EINVAL;
212
213	if (!dev->bus || !dev->parent) {
214		/* bridge devices genernally haven't bus or parent */
215		ret = acpi_find_bridge_device(dev, &handle);
216		goto end;
217	}
218	type = acpi_get_bus_type(dev->bus);
219	if (!type) {
220		DBG("No ACPI bus support for %s\n", dev_name(dev));
221		ret = -EINVAL;
222		goto end;
223	}
224	if ((ret = type->find_device(dev, &handle)) != 0)
225		DBG("Can't get handler for %s\n", dev_name(dev));
226      end:
227	if (!ret)
228		acpi_bind_one(dev, handle);
229
230#if ACPI_GLUE_DEBUG
231	if (!ret) {
232		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
233
234		acpi_get_name(dev->archdata.acpi_handle,
235			      ACPI_FULL_PATHNAME, &buffer);
236		DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
237		kfree(buffer.pointer);
238	} else
239		DBG("Device %s -> No ACPI support\n", dev_name(dev));
240#endif
241
242	return ret;
243}
244
245static int acpi_platform_notify_remove(struct device *dev)
246{
247	acpi_unbind_one(dev);
248	return 0;
249}
250
251int __init init_acpi_device_notify(void)
252{
253	if (platform_notify || platform_notify_remove) {
254		printk(KERN_ERR PREFIX "Can't use platform_notify\n");
255		return 0;
256	}
257	platform_notify = acpi_platform_notify;
258	platform_notify_remove = acpi_platform_notify_remove;
259	return 0;
260}