[deliverable/linux.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)
{
	unsigned long *busnr = data;
	struct acpi_resource_address64 address;

	if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
		return AE_OK;

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

	return AE_OK;
}

static int get_root_bridge_busnr(acpi_handle handle)
{
	acpi_status status;
	unsigned long 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,
				       &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:
	kfree(buffer.pointer);
	return (int)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 */
		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_CTRL_TERMINATE;
	}
	else
		status = AE_OK;
      exit:
	kfree(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;
}
EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_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 = context;

	status = acpi_get_object_info(handle, &buffer);
	if (ACPI_SUCCESS(status)) {
		info = buffer.pointer;
		if (info->address == find->address)
			find->handle = handle;
		kfree(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->archdata.acpi_handle) {
		printk(KERN_WARNING PREFIX
		       "Drivers changed 'acpi_handle' 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->archdata.acpi_handle = handle;

	return 0;
}

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