[linux-2.6-block.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/init.h>
#include <linux/list.h>
#include <linux/device.h>
#include <linux/rwsem.h>
#include <linux/acpi.h>

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

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(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(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 PCI root bridge's handle from its segment and bus number */
struct acpi_find_pci_root {
	unsigned int seg;
	unsigned int bus;
	acpi_handle handle;
};

static acpi_status
do_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
{
	int *busnr = (int *)data;
	struct acpi_resource_address64 address;

	if (resource->id != ACPI_RSTYPE_ADDRESS16 &&
	    resource->id != ACPI_RSTYPE_ADDRESS32 &&
	    resource->id != ACPI_RSTYPE_ADDRESS64)
		return AE_OK;

	acpi_resource_to_address64(resource, &address);
	if ((address.address_length > 0) &&
	    (address.resource_type == ACPI_BUS_NUMBER_RANGE))
		*busnr = address.min_address_range;

	return AE_OK;
}

static int get_root_bridge_busnr(acpi_handle handle)
{
	acpi_status status;
	int bus, bbn;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);

	status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL,
				       (unsigned long *)&bbn);
	if (status == AE_NOT_FOUND) {
		/* Assume bus = 0 */
		printk(KERN_INFO PREFIX
		       "Assume root bridge [%s] bus is 0\n",
		       (char *)buffer.pointer);
		status = AE_OK;
		bbn = 0;
	}
	if (ACPI_FAILURE(status)) {
		bbn = -ENODEV;
		goto exit;
	}
	if (bbn > 0)
		goto exit;

	/* _BBN in some systems return 0 for all root bridges */
	bus = -1;
	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
				     do_root_bridge_busnr_callback, &bus);
	/* If _CRS failed, we just use _BBN */
	if (ACPI_FAILURE(status) || (bus == -1))
		goto exit;
	/* We select _CRS */
	if (bbn != bus) {
		printk(KERN_INFO PREFIX
		       "_BBN and _CRS returns different value for %s. Select _CRS\n",
		       (char *)buffer.pointer);
		bbn = bus;
	}
      exit:
	acpi_os_free(buffer.pointer);
	return bbn;
}

static acpi_status
find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv)
{
	struct acpi_find_pci_root *find = (struct acpi_find_pci_root *)context;
	unsigned long seg, bus;
	acpi_status status;
	int tmp;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);

	status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &seg);
	if (status == AE_NOT_FOUND) {
		/* Assume seg = 0 */
		printk(KERN_INFO PREFIX
		       "Assume root bridge [%s] segment is 0\n",
		       (char *)buffer.pointer);
		status = AE_OK;
		seg = 0;
	}
	if (ACPI_FAILURE(status)) {
		status = AE_CTRL_DEPTH;
		goto exit;
	}

	tmp = get_root_bridge_busnr(handle);
	if (tmp < 0) {
		printk(KERN_ERR PREFIX
		       "Find root bridge failed for %s\n",
		       (char *)buffer.pointer);
		status = AE_CTRL_DEPTH;
		goto exit;
	}
	bus = tmp;

	if (seg == find->seg && bus == find->bus)
		find->handle = handle;
	status = AE_OK;
      exit:
	acpi_os_free(buffer.pointer);
	return status;
}

acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
{
	struct acpi_find_pci_root find = { seg, bus, NULL };

	acpi_get_devices(PCI_ROOT_HID_STRING, find_pci_rootbridge, &find, NULL);
	return find.handle;
}

/* Get device's handler per its address under its parent */
struct acpi_find_child {
	acpi_handle handle;
	acpi_integer 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_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	struct acpi_find_child *find = (struct acpi_find_child *)context;

	status = acpi_get_object_info(handle, &buffer);
	if (ACPI_SUCCESS(status)) {
		info = buffer.pointer;
		if (info->address == find->address)
			find->handle = handle;
		acpi_os_free(buffer.pointer);
	}
	return AE_OK;
}

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

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

EXPORT_SYMBOL(acpi_get_child);

/* Link ACPI devices with physical devices */
static void acpi_glue_data_handler(acpi_handle handle,
				   u32 function, void *context)
{
	/* we provide an empty handler */
}

/* Note: a success call will increase reference count by one */
struct device *acpi_get_physical_device(acpi_handle handle)
{
	acpi_status status;
	struct device *dev;

	status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
	if (ACPI_SUCCESS(status))
		return get_device(dev);
	return NULL;
}

EXPORT_SYMBOL(acpi_get_physical_device);

static int acpi_bind_one(struct device *dev, acpi_handle handle)
{
	acpi_status status;

	if (dev->firmware_data) {
		printk(KERN_WARNING PREFIX
		       "Drivers changed 'firmware_data' for %s\n", dev->bus_id);
		return -EINVAL;
	}
	get_device(dev);
	status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
	if (ACPI_FAILURE(status)) {
		put_device(dev);
		return -EINVAL;
	}
	dev->firmware_data = handle;

	return 0;
}

static int acpi_unbind_one(struct device *dev)
{
	if (!dev->firmware_data)
		return 0;
	if (dev == acpi_get_physical_device(dev->firmware_data)) {
		/* acpi_get_physical_device increase refcnt by one */
		put_device(dev);
		acpi_detach_data(dev->firmware_data, acpi_glue_data_handler);
		dev->firmware_data = NULL;
		/* acpi_bind_one increase refcnt by one */
		put_device(dev);
	} else {
		printk(KERN_ERR PREFIX
		       "Oops, 'firmware_data' corrupt for %s\n", dev->bus_id);
	}
	return 0;
}

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

	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->bus_id);
		ret = -EINVAL;
		goto end;
	}
	if ((ret = type->find_device(dev, &handle)) != 0)
		DBG("Can't get handler for %s\n", dev->bus_id);
      end:
	if (!ret)
		acpi_bind_one(dev, handle);

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

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

	return ret;
}

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

static int __init init_acpi_device_notify(void)
{
	if (acpi_disabled)
		return 0;
	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;
}

arch_initcall(init_acpi_device_notify);
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	*/
	9	#include <linux/init.h>
	10	#include <linux/list.h>
	11	#include <linux/device.h>
	12	#include <linux/rwsem.h>
	13	#include <linux/acpi.h>
	14
	15	#define ACPI_GLUE_DEBUG 0
	16	#if ACPI_GLUE_DEBUG
	17	#define DBG(x...) printk(PREFIX x)
	18	#else
	19	#define DBG(x...)
	20	#endif
	21	static LIST_HEAD(bus_type_list);
	22	static DECLARE_RWSEM(bus_type_sem);
	23
	24	int register_acpi_bus_type(struct acpi_bus_type *type)
	25	{
	26	if (acpi_disabled)
	27	return -ENODEV;
	28	if (type && type->bus && type->find_device) {
	29	down_write(&bus_type_sem);
	30	list_add_tail(&type->list, &bus_type_list);
	31	up_write(&bus_type_sem);
ef7b06cd	32	printk(KERN_INFO PREFIX "bus type %s registered\n", type->bus->name);
4e10d12a DSL	33	return 0;
	34	}
	35	return -ENODEV;
	36	}
	37
	38	EXPORT_SYMBOL(register_acpi_bus_type);
	39
	40	int unregister_acpi_bus_type(struct acpi_bus_type *type)
	41	{
	42	if (acpi_disabled)
	43	return 0;
	44	if (type) {
	45	down_write(&bus_type_sem);
	46	list_del_init(&type->list);
	47	up_write(&bus_type_sem);
ef7b06cd	48	printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n", type->bus->name);
4e10d12a DSL	49	return 0;
	50	}
	51	return -ENODEV;
	52	}
	53
	54	EXPORT_SYMBOL(unregister_acpi_bus_type);
	55
	56	static struct acpi_bus_type acpi_get_bus_type(struct bus_type type)
	57	{
	58	struct acpi_bus_type tmp, ret = NULL;
	59
	60	down_read(&bus_type_sem);
	61	list_for_each_entry(tmp, &bus_type_list, list) {
	62	if (tmp->bus == type) {
	63	ret = tmp;
	64	break;
	65	}
	66	}
	67	up_read(&bus_type_sem);
	68	return ret;
	69	}
	70
	71	static int acpi_find_bridge_device(struct device dev, acpi_handle handle)
	72	{
	73	struct acpi_bus_type *tmp;
	74	int ret = -ENODEV;
	75
	76	down_read(&bus_type_sem);
	77	list_for_each_entry(tmp, &bus_type_list, list) {
	78	if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
	79	ret = 0;
	80	break;
	81	}
	82	}
	83	up_read(&bus_type_sem);
	84	return ret;
	85	}
	86
	87	/* Get PCI root bridge's handle from its segment and bus number */
	88	struct acpi_find_pci_root {
	89	unsigned int seg;
	90	unsigned int bus;
	91	acpi_handle handle;
	92	};
	93
	94	static acpi_status
	95	do_root_bridge_busnr_callback(struct acpi_resource resource, void data)
	96	{
	97	int busnr = (int )data;
	98	struct acpi_resource_address64 address;
	99
	100	if (resource->id != ACPI_RSTYPE_ADDRESS16 &&
	101	resource->id != ACPI_RSTYPE_ADDRESS32 &&
	102	resource->id != ACPI_RSTYPE_ADDRESS64)
	103	return AE_OK;
	104
	105	acpi_resource_to_address64(resource, &address);
	106	if ((address.address_length > 0) &&
	107	(address.resource_type == ACPI_BUS_NUMBER_RANGE))
	108	*busnr = address.min_address_range;
	109
	110	return AE_OK;
	111	}
	112
113	static int get_root_bridge_busnr(acpi_handle handle)
114	{
115	acpi_status status;
116	int bus, bbn;
117	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
118
119	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
120
121	status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL,
122	(unsigned long *)&bbn);
123	if (status == AE_NOT_FOUND) {
124	/* Assume bus = 0 */
125	printk(KERN_INFO PREFIX
126	"Assume root bridge [%s] bus is 0\n",
127	(char *)buffer.pointer);
128	status = AE_OK;
129	bbn = 0;
130	}
131	if (ACPI_FAILURE(status)) {
132	bbn = -ENODEV;
133	goto exit;
134	}
135	if (bbn > 0)
136	goto exit;
137
138	/* _BBN in some systems return 0 for all root bridges */
139	bus = -1;
140	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
141	do_root_bridge_busnr_callback, &bus);
142	/* If _CRS failed, we just use _BBN */
143	if (ACPI_FAILURE(status) \|\| (bus == -1))
144	goto exit;
145	/* We select _CRS */
146	if (bbn != bus) {
147	printk(KERN_INFO PREFIX
148	"_BBN and _CRS returns different value for %s. Select _CRS\n",
149	(char *)buffer.pointer);
150	bbn = bus;
151	}
152	exit:
153	acpi_os_free(buffer.pointer);
154	return bbn;
155	}
156
157	static acpi_status
158	find_pci_rootbridge(acpi_handle handle, u32 lvl, void context, void *rv)
159	{
160	struct acpi_find_pci_root find = (struct acpi_find_pci_root )context;
161	unsigned long seg, bus;
162	acpi_status status;
163	int tmp;
164	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
165
166	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
167
168	status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &seg);
169	if (status == AE_NOT_FOUND) {
170	/* Assume seg = 0 */
171	printk(KERN_INFO PREFIX
172	"Assume root bridge [%s] segment is 0\n",
173	(char *)buffer.pointer);
174	status = AE_OK;
175	seg = 0;
176	}
177	if (ACPI_FAILURE(status)) {
178	status = AE_CTRL_DEPTH;
179	goto exit;
180	}
181
182	tmp = get_root_bridge_busnr(handle);
183	if (tmp < 0) {
184	printk(KERN_ERR PREFIX
185	"Find root bridge failed for %s\n",
186	(char *)buffer.pointer);
187	status = AE_CTRL_DEPTH;
188	goto exit;
189	}
190	bus = tmp;
191
192	if (seg == find->seg && bus == find->bus)
193	find->handle = handle;
194	status = AE_OK;
195	exit:
196	acpi_os_free(buffer.pointer);
197	return status;
198	}
199
200	acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
201	{
202	struct acpi_find_pci_root find = { seg, bus, NULL };
203
204	acpi_get_devices(PCI_ROOT_HID_STRING, find_pci_rootbridge, &find, NULL);
205	return find.handle;
206	}
207
208	/* Get device's handler per its address under its parent */
209	struct acpi_find_child {
210	acpi_handle handle;
211	acpi_integer address;
212	};
213
214	static acpi_status
215	do_acpi_find_child(acpi_handle handle, u32 lvl, void context, void *rv)
216	{
217	acpi_status status;
218	struct acpi_device_info *info;
219	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
220	struct acpi_find_child find = (struct acpi_find_child )context;
221
222	status = acpi_get_object_info(handle, &buffer);
223	if (ACPI_SUCCESS(status)) {
224	info = buffer.pointer;
225	if (info->address == find->address)
226	find->handle = handle;
227	acpi_os_free(buffer.pointer);
228	}
229	return AE_OK;
230	}
231
232	acpi_handle acpi_get_child(acpi_handle parent, acpi_integer address)
233	{
234	struct acpi_find_child find = { NULL, address };
235
236	if (!parent)
237	return NULL;
238	acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
239	1, do_acpi_find_child, &find, NULL);
240	return find.handle;
241	}
242
243	EXPORT_SYMBOL(acpi_get_child);
244
245	/* Link ACPI devices with physical devices */
246	static void acpi_glue_data_handler(acpi_handle handle,
247	u32 function, void *context)
248	{
249	/* we provide an empty handler */
250	}
251
252	/* Note: a success call will increase reference count by one */
253	struct device *acpi_get_physical_device(acpi_handle handle)
254	{
255	acpi_status status;
256	struct device *dev;
257
258	status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
259	if (ACPI_SUCCESS(status))
260	return get_device(dev);
261	return NULL;
262	}
263
264	EXPORT_SYMBOL(acpi_get_physical_device);
265
266	static int acpi_bind_one(struct device *dev, acpi_handle handle)
267	{
268	acpi_status status;
269
270	if (dev->firmware_data) {
271	printk(KERN_WARNING PREFIX
272	"Drivers changed 'firmware_data' for %s\n", dev->bus_id);
273	return -EINVAL;
274	}
275	get_device(dev);
276	status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
277	if (ACPI_FAILURE(status)) {
278	put_device(dev);
279	return -EINVAL;
280	}
281	dev->firmware_data = handle;
282
283	return 0;
284	}
285
286	static int acpi_unbind_one(struct device *dev)
287	{
288	if (!dev->firmware_data)
289	return 0;
290	if (dev == acpi_get_physical_device(dev->firmware_data)) {
291	/* acpi_get_physical_device increase refcnt by one */
292	put_device(dev);
293	acpi_detach_data(dev->firmware_data, acpi_glue_data_handler);
294	dev->firmware_data = NULL;
295	/* acpi_bind_one increase refcnt by one */
296	put_device(dev);
297	} else {
298	printk(KERN_ERR PREFIX
299	"Oops, 'firmware_data' corrupt for %s\n", dev->bus_id);
300	}
301	return 0;
302	}
303
304	static int acpi_platform_notify(struct device *dev)
305	{
306	struct acpi_bus_type *type;
307	acpi_handle handle;
308	int ret = -EINVAL;
309
310	if (!dev->bus \|\| !dev->parent) {
311	/* bridge devices genernally haven't bus or parent */
312	ret = acpi_find_bridge_device(dev, &handle);
313	goto end;
314	}
315	type = acpi_get_bus_type(dev->bus);
316	if (!type) {
ef7b06cd	317	DBG("No ACPI bus support for %s\n", dev->bus_id);
4e10d12a DSL	318	ret = -EINVAL;
	319	goto end;
	320	}
	321	if ((ret = type->find_device(dev, &handle)) != 0)
ef7b06cd	322	DBG("Can't get handler for %s\n", dev->bus_id);
4e10d12a DSL	323	end:
	324	if (!ret)
	325	acpi_bind_one(dev, handle);
	326
	327	#if ACPI_GLUE_DEBUG
	328	if (!ret) {
	329	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	330
	331	acpi_get_name(dev->firmware_data, ACPI_FULL_PATHNAME, &buffer);
	332	DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer);
	333	acpi_os_free(buffer.pointer);
	334	} else
	335	DBG("Device %s -> No ACPI support\n", dev->bus_id);
	336	#endif
	337
	338	return ret;
	339	}
	340
	341	static int acpi_platform_notify_remove(struct device *dev)
	342	{
	343	acpi_unbind_one(dev);
	344	return 0;
	345	}
	346
	347	static int __init init_acpi_device_notify(void)
	348	{
	349	if (acpi_disabled)
	350	return 0;
	351	if (platform_notify \|\| platform_notify_remove) {
	352	printk(KERN_ERR PREFIX "Can't use platform_notify\n");
	353	return 0;
	354	}
	355	platform_notify = acpi_platform_notify;
	356	platform_notify_remove = acpi_platform_notify_remove;
	357	return 0;
	358	}
	359
	360	arch_initcall(init_acpi_device_notify);