ACPI: delete tracing macros from drivers/acpi/*.c (d550d98d) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/acpi/ac.c

+22 −31

Original line number	Original line	Diff line number	Diff line
	@@ -84,19 +84,18 @@ static int acpi_ac_get_state(struct acpi_ac *ac)
	{		{
	acpi_status status = AE_OK;		acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE("acpi_ac_get_state");

	if (!ac)		if (!ac)
	return_VALUE(-EINVAL);		return -EINVAL;

	status = acpi_evaluate_integer(ac->handle, "_PSR", NULL, &ac->state);		status = acpi_evaluate_integer(ac->handle, "_PSR", NULL, &ac->state);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Error reading AC Adapter state"));		ACPI_EXCEPTION((AE_INFO, status, "Error reading AC Adapter state"));
	ac->state = ACPI_AC_STATUS_UNKNOWN;		ac->state = ACPI_AC_STATUS_UNKNOWN;
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	/* --------------------------------------------------------------------------		/* --------------------------------------------------------------------------
	@@ -109,14 +108,13 @@ static int acpi_ac_seq_show(struct seq_file seq, void offset)
	{		{
	struct acpi_ac ac = (struct acpi_ac )seq->private;		struct acpi_ac ac = (struct acpi_ac )seq->private;

	ACPI_FUNCTION_TRACE("acpi_ac_seq_show");

	if (!ac)		if (!ac)
	return_VALUE(0);		return 0;

	if (acpi_ac_get_state(ac)) {		if (acpi_ac_get_state(ac)) {
	seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");		seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");
	return_VALUE(0);		return 0;
	}		}

	seq_puts(seq, "state: ");		seq_puts(seq, "state: ");
	@@ -132,7 +130,7 @@ static int acpi_ac_seq_show(struct seq_file seq, void offset)
	break;		break;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_ac_open_fs(struct inode inode, struct file file)		static int acpi_ac_open_fs(struct inode inode, struct file file)
	@@ -144,13 +142,12 @@ static int acpi_ac_add_fs(struct acpi_device *device)
	{		{
	struct proc_dir_entry *entry = NULL;		struct proc_dir_entry *entry = NULL;

	ACPI_FUNCTION_TRACE("acpi_ac_add_fs");

	if (!acpi_device_dir(device)) {		if (!acpi_device_dir(device)) {
	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
	acpi_ac_dir);		acpi_ac_dir);
	if (!acpi_device_dir(device))		if (!acpi_device_dir(device))
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_device_dir(device)->owner = THIS_MODULE;		acpi_device_dir(device)->owner = THIS_MODULE;
	}		}

	@@ -158,19 +155,18 @@ static int acpi_ac_add_fs(struct acpi_device *device)
	entry = create_proc_entry(ACPI_AC_FILE_STATE,		entry = create_proc_entry(ACPI_AC_FILE_STATE,
	S_IRUGO, acpi_device_dir(device));		S_IRUGO, acpi_device_dir(device));
	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	else {		else {
	entry->proc_fops = &acpi_ac_fops;		entry->proc_fops = &acpi_ac_fops;
	entry->data = acpi_driver_data(device);		entry->data = acpi_driver_data(device);
	entry->owner = THIS_MODULE;		entry->owner = THIS_MODULE;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_ac_remove_fs(struct acpi_device *device)		static int acpi_ac_remove_fs(struct acpi_device *device)
	{		{
	ACPI_FUNCTION_TRACE("acpi_ac_remove_fs");

	if (acpi_device_dir(device)) {		if (acpi_device_dir(device)) {
	remove_proc_entry(ACPI_AC_FILE_STATE, acpi_device_dir(device));		remove_proc_entry(ACPI_AC_FILE_STATE, acpi_device_dir(device));
	@@ -179,7 +175,7 @@ static int acpi_ac_remove_fs(struct acpi_device *device)
	acpi_device_dir(device) = NULL;		acpi_device_dir(device) = NULL;
	}		}

	return_VALUE(0);		return 0;
	}		}

	/* --------------------------------------------------------------------------		/* --------------------------------------------------------------------------
	@@ -191,13 +187,12 @@ static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
	struct acpi_ac ac = (struct acpi_ac )data;		struct acpi_ac ac = (struct acpi_ac )data;
	struct acpi_device *device = NULL;		struct acpi_device *device = NULL;

	ACPI_FUNCTION_TRACE("acpi_ac_notify");

	if (!ac)		if (!ac)
	return_VOID;		return;

	if (acpi_bus_get_device(ac->handle, &device))		if (acpi_bus_get_device(ac->handle, &device))
	return_VOID;		return;

	switch (event) {		switch (event) {
	case ACPI_AC_NOTIFY_STATUS:		case ACPI_AC_NOTIFY_STATUS:
	@@ -210,7 +205,7 @@ static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
	break;		break;
	}		}

	return_VOID;		return;
	}		}

	static int acpi_ac_add(struct acpi_device *device)		static int acpi_ac_add(struct acpi_device *device)
	@@ -219,14 +214,13 @@ static int acpi_ac_add(struct acpi_device *device)
	acpi_status status = AE_OK;		acpi_status status = AE_OK;
	struct acpi_ac *ac = NULL;		struct acpi_ac *ac = NULL;

	ACPI_FUNCTION_TRACE("acpi_ac_add");

	if (!device)		if (!device)
	return_VALUE(-EINVAL);		return -EINVAL;

	ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL);		ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL);
	if (!ac)		if (!ac)
	return_VALUE(-ENOMEM);		return -ENOMEM;
	memset(ac, 0, sizeof(struct acpi_ac));		memset(ac, 0, sizeof(struct acpi_ac));

	ac->handle = device->handle;		ac->handle = device->handle;
	@@ -260,7 +254,7 @@ static int acpi_ac_add(struct acpi_device *device)
	kfree(ac);		kfree(ac);
	}		}

	return_VALUE(result);		return result;
	}		}

	static int acpi_ac_remove(struct acpi_device *device, int type)		static int acpi_ac_remove(struct acpi_device *device, int type)
	@@ -268,10 +262,9 @@ static int acpi_ac_remove(struct acpi_device *device, int type)
	acpi_status status = AE_OK;		acpi_status status = AE_OK;
	struct acpi_ac *ac = NULL;		struct acpi_ac *ac = NULL;

	ACPI_FUNCTION_TRACE("acpi_ac_remove");

	if (!device \|\| !acpi_driver_data(device))		if (!device \|\| !acpi_driver_data(device))
	return_VALUE(-EINVAL);		return -EINVAL;

	ac = (struct acpi_ac *)acpi_driver_data(device);		ac = (struct acpi_ac *)acpi_driver_data(device);

	@@ -282,38 +275,36 @@ static int acpi_ac_remove(struct acpi_device *device, int type)

	kfree(ac);		kfree(ac);

	return_VALUE(0);		return 0;
	}		}

	static int __init acpi_ac_init(void)		static int __init acpi_ac_init(void)
	{		{
	int result = 0;		int result = 0;

	ACPI_FUNCTION_TRACE("acpi_ac_init");

	acpi_ac_dir = proc_mkdir(ACPI_AC_CLASS, acpi_root_dir);		acpi_ac_dir = proc_mkdir(ACPI_AC_CLASS, acpi_root_dir);
	if (!acpi_ac_dir)		if (!acpi_ac_dir)
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_ac_dir->owner = THIS_MODULE;		acpi_ac_dir->owner = THIS_MODULE;

	result = acpi_bus_register_driver(&acpi_ac_driver);		result = acpi_bus_register_driver(&acpi_ac_driver);
	if (result < 0) {		if (result < 0) {
	remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static void __exit acpi_ac_exit(void)		static void __exit acpi_ac_exit(void)
	{		{
	ACPI_FUNCTION_TRACE("acpi_ac_exit");

	acpi_bus_unregister_driver(&acpi_ac_driver);		acpi_bus_unregister_driver(&acpi_ac_driver);

	remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);

	return_VOID;		return;
	}		}

	module_init(acpi_ac_init);		module_init(acpi_ac_init);

drivers/acpi/acpi_memhotplug.c

+34 −48

Original line number	Original line	Diff line number	Diff line
	@@ -85,12 +85,11 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
	struct acpi_resource *resource = NULL;		struct acpi_resource *resource = NULL;
	struct acpi_resource_address64 address64;		struct acpi_resource_address64 address64;

	ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources");

	/* Get the range from the _CRS */		/* Get the range from the _CRS */
	status = acpi_get_current_resources(mem_device->handle, &buffer);		status = acpi_get_current_resources(mem_device->handle, &buffer);
	if (ACPI_FAILURE(status))		if (ACPI_FAILURE(status))
	return_VALUE(-EINVAL);		return -EINVAL;

	resource = (struct acpi_resource *)buffer.pointer;		resource = (struct acpi_resource *)buffer.pointer;
	status = acpi_resource_to_address64(resource, &address64);		status = acpi_resource_to_address64(resource, &address64);
	@@ -106,7 +105,7 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
	}		}

	acpi_os_free(buffer.pointer);		acpi_os_free(buffer.pointer);
	return_VALUE(0);		return 0;
	}		}

	static int		static int
	@@ -118,7 +117,6 @@ acpi_memory_get_device(acpi_handle handle,
	struct acpi_device *device = NULL;		struct acpi_device *device = NULL;
	struct acpi_device *pdevice = NULL;		struct acpi_device *pdevice = NULL;

	ACPI_FUNCTION_TRACE("acpi_memory_get_device");

	if (!acpi_bus_get_device(handle, &device) && device)		if (!acpi_bus_get_device(handle, &device) && device)
	goto end;		goto end;
	@@ -126,14 +124,14 @@ acpi_memory_get_device(acpi_handle handle,
	status = acpi_get_parent(handle, &phandle);		status = acpi_get_parent(handle, &phandle);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));		ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
	return_VALUE(-EINVAL);		return -EINVAL;
	}		}

	/* Get the parent device */		/* Get the parent device */
	status = acpi_bus_get_device(phandle, &pdevice);		status = acpi_bus_get_device(phandle, &pdevice);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Cannot get acpi bus device"));		ACPI_EXCEPTION((AE_INFO, status, "Cannot get acpi bus device"));
	return_VALUE(-EINVAL);		return -EINVAL;
	}		}

	/*		/*
	@@ -143,29 +141,28 @@ acpi_memory_get_device(acpi_handle handle,
	status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);		status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Cannot add acpi bus"));		ACPI_EXCEPTION((AE_INFO, status, "Cannot add acpi bus"));
	return_VALUE(-EINVAL);		return -EINVAL;
	}		}

	end:		end:
	*mem_device = acpi_driver_data(device);		*mem_device = acpi_driver_data(device);
	if (!(*mem_device)) {		if (!(*mem_device)) {
	printk(KERN_ERR "\n driver data not found");		printk(KERN_ERR "\n driver data not found");
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_memory_check_device(struct acpi_memory_device *mem_device)		static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
	{		{
	unsigned long current_status;		unsigned long current_status;

	ACPI_FUNCTION_TRACE("acpi_memory_check_device");

	/* Get device present/absent information from the _STA */		/* Get device present/absent information from the _STA */
	if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA",		if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA",
	NULL, &current_status)))		NULL, &current_status)))
	return_VALUE(-ENODEV);		return -ENODEV;
	/*		/*
	* Check for device status. Device should be		* Check for device status. Device should be
	* present/enabled/functioning.		* present/enabled/functioning.
	@@ -173,16 +170,15 @@ static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
	if (!((current_status & ACPI_MEMORY_STA_PRESENT)		if (!((current_status & ACPI_MEMORY_STA_PRESENT)
	&& (current_status & ACPI_MEMORY_STA_ENABLED)		&& (current_status & ACPI_MEMORY_STA_ENABLED)
	&& (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))		&& (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))
	return_VALUE(-ENODEV);		return -ENODEV;

	return_VALUE(0);		return 0;
	}		}

	static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)		static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
	{		{
	int result;		int result;

	ACPI_FUNCTION_TRACE("acpi_memory_enable_device");

	/* Get the range from the _CRS */		/* Get the range from the _CRS */
	result = acpi_memory_get_device_resources(mem_device);		result = acpi_memory_get_device_resources(mem_device);
	@@ -213,7 +209,6 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
	union acpi_object arg;		union acpi_object arg;
	unsigned long current_status;		unsigned long current_status;

	ACPI_FUNCTION_TRACE("acpi_memory_powerdown_device");

	/* Issue the _EJ0 command */		/* Issue the _EJ0 command */
	arg_list.count = 1;		arg_list.count = 1;
	@@ -225,20 +220,20 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
	/* Return on _EJ0 failure */		/* Return on _EJ0 failure */
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));		ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	/* Evalute _STA to check if the device is disabled */		/* Evalute _STA to check if the device is disabled */
	status = acpi_evaluate_integer(mem_device->handle, "_STA",		status = acpi_evaluate_integer(mem_device->handle, "_STA",
	NULL, &current_status);		NULL, &current_status);
	if (ACPI_FAILURE(status))		if (ACPI_FAILURE(status))
	return_VALUE(-ENODEV);		return -ENODEV;

	/* Check for device status. Device should be disabled */		/* Check for device status. Device should be disabled */
	if (current_status & ACPI_MEMORY_STA_ENABLED)		if (current_status & ACPI_MEMORY_STA_ENABLED)
	return_VALUE(-EINVAL);		return -EINVAL;

	return_VALUE(0);		return 0;
	}		}

	static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)		static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
	@@ -247,7 +242,6 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
	u64 start = mem_device->start_addr;		u64 start = mem_device->start_addr;
	u64 len = mem_device->length;		u64 len = mem_device->length;

	ACPI_FUNCTION_TRACE("acpi_memory_disable_device");

	/*		/*
	* Ask the VM to offline this memory range.		* Ask the VM to offline this memory range.
	@@ -255,7 +249,7 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
	*/		*/
	result = remove_memory(start, len);		result = remove_memory(start, len);
	if (result)		if (result)
	return_VALUE(result);		return result;

	/* Power-off and eject the device */		/* Power-off and eject the device */
	result = acpi_memory_powerdown_device(mem_device);		result = acpi_memory_powerdown_device(mem_device);
	@@ -274,7 +268,6 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
	struct acpi_memory_device *mem_device;		struct acpi_memory_device *mem_device;
	struct acpi_device *device;		struct acpi_device *device;

	ACPI_FUNCTION_TRACE("acpi_memory_device_notify");

	switch (event) {		switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:		case ACPI_NOTIFY_BUS_CHECK:
	@@ -287,7 +280,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
	"\nReceived DEVICE CHECK notification for device\n"));		"\nReceived DEVICE CHECK notification for device\n"));
	if (acpi_memory_get_device(handle, &mem_device)) {		if (acpi_memory_get_device(handle, &mem_device)) {
	printk(KERN_ERR PREFIX "Cannot find driver data\n");		printk(KERN_ERR PREFIX "Cannot find driver data\n");
	return_VOID;		return;
	}		}

	if (!acpi_memory_check_device(mem_device)) {		if (!acpi_memory_check_device(mem_device)) {
	@@ -329,7 +322,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
	break;		break;
	}		}

	return_VOID;		return;
	}		}

	static int acpi_memory_device_add(struct acpi_device *device)		static int acpi_memory_device_add(struct acpi_device *device)
	@@ -337,14 +330,13 @@ static int acpi_memory_device_add(struct acpi_device *device)
	int result;		int result;
	struct acpi_memory_device *mem_device = NULL;		struct acpi_memory_device *mem_device = NULL;

	ACPI_FUNCTION_TRACE("acpi_memory_device_add");

	if (!device)		if (!device)
	return_VALUE(-EINVAL);		return -EINVAL;

	mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);		mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
	if (!mem_device)		if (!mem_device)
	return_VALUE(-ENOMEM);		return -ENOMEM;
	memset(mem_device, 0, sizeof(struct acpi_memory_device));		memset(mem_device, 0, sizeof(struct acpi_memory_device));

	mem_device->handle = device->handle;		mem_device->handle = device->handle;
	@@ -356,7 +348,7 @@ static int acpi_memory_device_add(struct acpi_device *device)
	result = acpi_memory_get_device_resources(mem_device);		result = acpi_memory_get_device_resources(mem_device);
	if (result) {		if (result) {
	kfree(mem_device);		kfree(mem_device);
	return_VALUE(result);		return result;
	}		}

	/* Set the device state */		/* Set the device state */
	@@ -364,22 +356,21 @@ static int acpi_memory_device_add(struct acpi_device *device)

	printk(KERN_INFO "%s \n", acpi_device_name(device));		printk(KERN_INFO "%s \n", acpi_device_name(device));

	return_VALUE(result);		return result;
	}		}

	static int acpi_memory_device_remove(struct acpi_device *device, int type)		static int acpi_memory_device_remove(struct acpi_device *device, int type)
	{		{
	struct acpi_memory_device *mem_device = NULL;		struct acpi_memory_device *mem_device = NULL;

	ACPI_FUNCTION_TRACE("acpi_memory_device_remove");

	if (!device \|\| !acpi_driver_data(device))		if (!device \|\| !acpi_driver_data(device))
	return_VALUE(-EINVAL);		return -EINVAL;

	mem_device = (struct acpi_memory_device *)acpi_driver_data(device);		mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
	kfree(mem_device);		kfree(mem_device);

	return_VALUE(0);		return 0;
	}		}

	/*		/*
	@@ -392,16 +383,15 @@ static acpi_status is_memory_device(acpi_handle handle)
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	struct acpi_device_info *info;		struct acpi_device_info *info;

	ACPI_FUNCTION_TRACE("is_memory_device");

	status = acpi_get_object_info(handle, &buffer);		status = acpi_get_object_info(handle, &buffer);
	if (ACPI_FAILURE(status))		if (ACPI_FAILURE(status))
	return_ACPI_STATUS(status);		return status;

	info = buffer.pointer;		info = buffer.pointer;
	if (!(info->valid & ACPI_VALID_HID)) {		if (!(info->valid & ACPI_VALID_HID)) {
	acpi_os_free(buffer.pointer);		acpi_os_free(buffer.pointer);
	return_ACPI_STATUS(AE_ERROR);		return AE_ERROR;
	}		}

	hardware_id = info->hardware_id.value;		hardware_id = info->hardware_id.value;
	@@ -410,7 +400,7 @@ static acpi_status is_memory_device(acpi_handle handle)
	status = AE_ERROR;		status = AE_ERROR;

	acpi_os_free(buffer.pointer);		acpi_os_free(buffer.pointer);
	return_ACPI_STATUS(status);		return status;
	}		}

	static acpi_status		static acpi_status
	@@ -419,18 +409,17 @@ acpi_memory_register_notify_handler(acpi_handle handle,
	{		{
	acpi_status status;		acpi_status status;

	ACPI_FUNCTION_TRACE("acpi_memory_register_notify_handler");

	status = is_memory_device(handle);		status = is_memory_device(handle);
	if (ACPI_FAILURE(status)){		if (ACPI_FAILURE(status)){
	ACPI_EXCEPTION((AE_INFO, status, "handle is no memory device"));		ACPI_EXCEPTION((AE_INFO, status, "handle is no memory device"));
	return_ACPI_STATUS(AE_OK); /* continue */		return AE_OK; /* continue */
	}		}

	status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,		status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
	acpi_memory_device_notify, NULL);		acpi_memory_device_notify, NULL);
	/* continue */		/* continue */
	return_ACPI_STATUS(AE_OK);		return AE_OK;
	}		}

	static acpi_status		static acpi_status
	@@ -439,19 +428,18 @@ acpi_memory_deregister_notify_handler(acpi_handle handle,
	{		{
	acpi_status status;		acpi_status status;

	ACPI_FUNCTION_TRACE("acpi_memory_deregister_notify_handler");

	status = is_memory_device(handle);		status = is_memory_device(handle);
	if (ACPI_FAILURE(status)){		if (ACPI_FAILURE(status)){
	ACPI_EXCEPTION((AE_INFO, status, "handle is no memory device"));		ACPI_EXCEPTION((AE_INFO, status, "handle is no memory device"));
	return_ACPI_STATUS(AE_OK); /* continue */		return AE_OK; /* continue */
	}		}

	status = acpi_remove_notify_handler(handle,		status = acpi_remove_notify_handler(handle,
	ACPI_SYSTEM_NOTIFY,		ACPI_SYSTEM_NOTIFY,
	acpi_memory_device_notify);		acpi_memory_device_notify);

	return_ACPI_STATUS(AE_OK); /* continue */		return AE_OK; /* continue */
	}		}

	static int __init acpi_memory_device_init(void)		static int __init acpi_memory_device_init(void)
	@@ -459,12 +447,11 @@ static int __init acpi_memory_device_init(void)
	int result;		int result;
	acpi_status status;		acpi_status status;

	ACPI_FUNCTION_TRACE("acpi_memory_device_init");

	result = acpi_bus_register_driver(&acpi_memory_device_driver);		result = acpi_bus_register_driver(&acpi_memory_device_driver);

	if (result < 0)		if (result < 0)
	return_VALUE(-ENODEV);		return -ENODEV;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
	ACPI_UINT32_MAX,		ACPI_UINT32_MAX,
	@@ -474,17 +461,16 @@ static int __init acpi_memory_device_init(void)
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));		ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
	acpi_bus_unregister_driver(&acpi_memory_device_driver);		acpi_bus_unregister_driver(&acpi_memory_device_driver);
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static void __exit acpi_memory_device_exit(void)		static void __exit acpi_memory_device_exit(void)
	{		{
	acpi_status status;		acpi_status status;

	ACPI_FUNCTION_TRACE("acpi_memory_device_exit");

	/*		/*
	* Adding this to un-install notification handlers for all the device		* Adding this to un-install notification handlers for all the device
	@@ -500,7 +486,7 @@ static void __exit acpi_memory_device_exit(void)

	acpi_bus_unregister_driver(&acpi_memory_device_driver);		acpi_bus_unregister_driver(&acpi_memory_device_driver);

	return_VOID;		return;
	}		}

	module_init(acpi_memory_device_init);		module_init(acpi_memory_device_init);

drivers/acpi/battery.c

+41 −56

Original line number	Original line	Diff line number	Diff line
	@@ -132,17 +132,16 @@ acpi_battery_get_info(struct acpi_battery *battery,
	struct acpi_buffer data = { 0, NULL };		struct acpi_buffer data = { 0, NULL };
	union acpi_object *package = NULL;		union acpi_object *package = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_get_info");

	if (!battery \|\| !bif)		if (!battery \|\| !bif)
	return_VALUE(-EINVAL);		return -EINVAL;

	/* Evalute _BIF */		/* Evalute _BIF */

	status = acpi_evaluate_object(battery->handle, "_BIF", NULL, &buffer);		status = acpi_evaluate_object(battery->handle, "_BIF", NULL, &buffer);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	package = (union acpi_object *)buffer.pointer;		package = (union acpi_object *)buffer.pointer;
	@@ -177,7 +176,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
	if (!result)		if (!result)
	(bif) = (struct acpi_battery_info )data.pointer;		(bif) = (struct acpi_battery_info )data.pointer;

	return_VALUE(result);		return result;
	}		}

	static int		static int
	@@ -193,17 +192,16 @@ acpi_battery_get_status(struct acpi_battery *battery,
	struct acpi_buffer data = { 0, NULL };		struct acpi_buffer data = { 0, NULL };
	union acpi_object *package = NULL;		union acpi_object *package = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_get_status");

	if (!battery \|\| !bst)		if (!battery \|\| !bst)
	return_VALUE(-EINVAL);		return -EINVAL;

	/* Evalute _BST */		/* Evalute _BST */

	status = acpi_evaluate_object(battery->handle, "_BST", NULL, &buffer);		status = acpi_evaluate_object(battery->handle, "_BST", NULL, &buffer);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	package = (union acpi_object *)buffer.pointer;		package = (union acpi_object *)buffer.pointer;
	@@ -238,7 +236,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
	if (!result)		if (!result)
	(bst) = (struct acpi_battery_status )data.pointer;		(bst) = (struct acpi_battery_status )data.pointer;

	return_VALUE(result);		return result;
	}		}

	static int		static int
	@@ -248,25 +246,24 @@ acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };		union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg0 };		struct acpi_object_list arg_list = { 1, &arg0 };

	ACPI_FUNCTION_TRACE("acpi_battery_set_alarm");

	if (!battery)		if (!battery)
	return_VALUE(-EINVAL);		return -EINVAL;

	if (!battery->flags.alarm)		if (!battery->flags.alarm)
	return_VALUE(-ENODEV);		return -ENODEV;

	arg0.integer.value = alarm;		arg0.integer.value = alarm;

	status = acpi_evaluate_object(battery->handle, "_BTP", &arg_list, NULL);		status = acpi_evaluate_object(battery->handle, "_BTP", &arg_list, NULL);
	if (ACPI_FAILURE(status))		if (ACPI_FAILURE(status))
	return_VALUE(-ENODEV);		return -ENODEV;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));

	battery->alarm = alarm;		battery->alarm = alarm;

	return_VALUE(0);		return 0;
	}		}

	static int acpi_battery_check(struct acpi_battery *battery)		static int acpi_battery_check(struct acpi_battery *battery)
	@@ -277,18 +274,17 @@ static int acpi_battery_check(struct acpi_battery *battery)
	struct acpi_device *device = NULL;		struct acpi_device *device = NULL;
	struct acpi_battery_info *bif = NULL;		struct acpi_battery_info *bif = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_check");

	if (!battery)		if (!battery)
	return_VALUE(-EINVAL);		return -EINVAL;

	result = acpi_bus_get_device(battery->handle, &device);		result = acpi_bus_get_device(battery->handle, &device);
	if (result)		if (result)
	return_VALUE(result);		return result;

	result = acpi_bus_get_status(device);		result = acpi_bus_get_status(device);
	if (result)		if (result)
	return_VALUE(result);		return result;

	/* Insertion? */		/* Insertion? */

	@@ -300,7 +296,7 @@ static int acpi_battery_check(struct acpi_battery *battery)

	result = acpi_battery_get_info(battery, &bif);		result = acpi_battery_get_info(battery, &bif);
	if (result)		if (result)
	return_VALUE(result);		return result;

	battery->flags.power_unit = bif->power_unit;		battery->flags.power_unit = bif->power_unit;
	battery->trips.warning = bif->design_capacity_warning;		battery->trips.warning = bif->design_capacity_warning;
	@@ -324,7 +320,7 @@ static int acpi_battery_check(struct acpi_battery *battery)

	battery->flags.present = device->status.battery_present;		battery->flags.present = device->status.battery_present;

	return_VALUE(result);		return result;
	}		}

	/* --------------------------------------------------------------------------		/* --------------------------------------------------------------------------
	@@ -339,7 +335,6 @@ static int acpi_battery_read_info(struct seq_file seq, void offset)
	struct acpi_battery_info *bif = NULL;		struct acpi_battery_info *bif = NULL;
	char *units = "?";		char *units = "?";

	ACPI_FUNCTION_TRACE("acpi_battery_read_info");

	if (!battery)		if (!battery)
	goto end;		goto end;
	@@ -409,7 +404,7 @@ static int acpi_battery_read_info(struct seq_file seq, void offset)
	end:		end:
	kfree(bif);		kfree(bif);

	return_VALUE(0);		return 0;
	}		}

	static int acpi_battery_info_open_fs(struct inode inode, struct file file)		static int acpi_battery_info_open_fs(struct inode inode, struct file file)
	@@ -424,7 +419,6 @@ static int acpi_battery_read_state(struct seq_file seq, void offset)
	struct acpi_battery_status *bst = NULL;		struct acpi_battery_status *bst = NULL;
	char *units = "?";		char *units = "?";

	ACPI_FUNCTION_TRACE("acpi_battery_read_state");

	if (!battery)		if (!battery)
	goto end;		goto end;
	@@ -487,7 +481,7 @@ static int acpi_battery_read_state(struct seq_file seq, void offset)
	end:		end:
	kfree(bst);		kfree(bst);

	return_VALUE(0);		return 0;
	}		}

	static int acpi_battery_state_open_fs(struct inode inode, struct file file)		static int acpi_battery_state_open_fs(struct inode inode, struct file file)
	@@ -500,7 +494,6 @@ static int acpi_battery_read_alarm(struct seq_file seq, void offset)
	struct acpi_battery battery = (struct acpi_battery )seq->private;		struct acpi_battery battery = (struct acpi_battery )seq->private;
	char *units = "?";		char *units = "?";

	ACPI_FUNCTION_TRACE("acpi_battery_read_alarm");

	if (!battery)		if (!battery)
	goto end;		goto end;
	@@ -525,7 +518,7 @@ static int acpi_battery_read_alarm(struct seq_file seq, void offset)
	seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);		seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);

	end:		end:
	return_VALUE(0);		return 0;
	}		}

	static ssize_t		static ssize_t
	@@ -538,25 +531,24 @@ acpi_battery_write_alarm(struct file *file,
	struct seq_file m = (struct seq_file )file->private_data;		struct seq_file m = (struct seq_file )file->private_data;
	struct acpi_battery battery = (struct acpi_battery )m->private;		struct acpi_battery battery = (struct acpi_battery )m->private;

	ACPI_FUNCTION_TRACE("acpi_battery_write_alarm");

	if (!battery \|\| (count > sizeof(alarm_string) - 1))		if (!battery \|\| (count > sizeof(alarm_string) - 1))
	return_VALUE(-EINVAL);		return -EINVAL;

	if (!battery->flags.present)		if (!battery->flags.present)
	return_VALUE(-ENODEV);		return -ENODEV;

	if (copy_from_user(alarm_string, buffer, count))		if (copy_from_user(alarm_string, buffer, count))
	return_VALUE(-EFAULT);		return -EFAULT;

	alarm_string[count] = '\0';		alarm_string[count] = '\0';

	result = acpi_battery_set_alarm(battery,		result = acpi_battery_set_alarm(battery,
	simple_strtoul(alarm_string, NULL, 0));		simple_strtoul(alarm_string, NULL, 0));
	if (result)		if (result)
	return_VALUE(result);		return result;

	return_VALUE(count);		return count;
	}		}

	static int acpi_battery_alarm_open_fs(struct inode inode, struct file file)		static int acpi_battery_alarm_open_fs(struct inode inode, struct file file)
	@@ -593,13 +585,12 @@ static int acpi_battery_add_fs(struct acpi_device *device)
	{		{
	struct proc_dir_entry *entry = NULL;		struct proc_dir_entry *entry = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_add_fs");

	if (!acpi_device_dir(device)) {		if (!acpi_device_dir(device)) {
	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
	acpi_battery_dir);		acpi_battery_dir);
	if (!acpi_device_dir(device))		if (!acpi_device_dir(device))
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_device_dir(device)->owner = THIS_MODULE;		acpi_device_dir(device)->owner = THIS_MODULE;
	}		}

	@@ -607,7 +598,7 @@ static int acpi_battery_add_fs(struct acpi_device *device)
	entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,		entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
	S_IRUGO, acpi_device_dir(device));		S_IRUGO, acpi_device_dir(device));
	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	else {		else {
	entry->proc_fops = &acpi_battery_info_ops;		entry->proc_fops = &acpi_battery_info_ops;
	entry->data = acpi_driver_data(device);		entry->data = acpi_driver_data(device);
	@@ -618,7 +609,7 @@ static int acpi_battery_add_fs(struct acpi_device *device)
	entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,		entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,
	S_IRUGO, acpi_device_dir(device));		S_IRUGO, acpi_device_dir(device));
	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	else {		else {
	entry->proc_fops = &acpi_battery_state_ops;		entry->proc_fops = &acpi_battery_state_ops;
	entry->data = acpi_driver_data(device);		entry->data = acpi_driver_data(device);
	@@ -630,19 +621,18 @@ static int acpi_battery_add_fs(struct acpi_device *device)
	S_IFREG \| S_IRUGO \| S_IWUSR,		S_IFREG \| S_IRUGO \| S_IWUSR,
	acpi_device_dir(device));		acpi_device_dir(device));
	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	else {		else {
	entry->proc_fops = &acpi_battery_alarm_ops;		entry->proc_fops = &acpi_battery_alarm_ops;
	entry->data = acpi_driver_data(device);		entry->data = acpi_driver_data(device);
	entry->owner = THIS_MODULE;		entry->owner = THIS_MODULE;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_battery_remove_fs(struct acpi_device *device)		static int acpi_battery_remove_fs(struct acpi_device *device)
	{		{
	ACPI_FUNCTION_TRACE("acpi_battery_remove_fs");

	if (acpi_device_dir(device)) {		if (acpi_device_dir(device)) {
	remove_proc_entry(ACPI_BATTERY_FILE_ALARM,		remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
	@@ -656,7 +646,7 @@ static int acpi_battery_remove_fs(struct acpi_device *device)
	acpi_device_dir(device) = NULL;		acpi_device_dir(device) = NULL;
	}		}

	return_VALUE(0);		return 0;
	}		}

	/* --------------------------------------------------------------------------		/* --------------------------------------------------------------------------
	@@ -668,13 +658,12 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
	struct acpi_battery battery = (struct acpi_battery )data;		struct acpi_battery battery = (struct acpi_battery )data;
	struct acpi_device *device = NULL;		struct acpi_device *device = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_notify");

	if (!battery)		if (!battery)
	return_VOID;		return;

	if (acpi_bus_get_device(handle, &device))		if (acpi_bus_get_device(handle, &device))
	return_VOID;		return;

	switch (event) {		switch (event) {
	case ACPI_BATTERY_NOTIFY_STATUS:		case ACPI_BATTERY_NOTIFY_STATUS:
	@@ -688,7 +677,7 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
	break;		break;
	}		}

	return_VOID;		return;
	}		}

	static int acpi_battery_add(struct acpi_device *device)		static int acpi_battery_add(struct acpi_device *device)
	@@ -697,14 +686,13 @@ static int acpi_battery_add(struct acpi_device *device)
	acpi_status status = 0;		acpi_status status = 0;
	struct acpi_battery *battery = NULL;		struct acpi_battery *battery = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_add");

	if (!device)		if (!device)
	return_VALUE(-EINVAL);		return -EINVAL;

	battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);		battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);
	if (!battery)		if (!battery)
	return_VALUE(-ENOMEM);		return -ENOMEM;
	memset(battery, 0, sizeof(struct acpi_battery));		memset(battery, 0, sizeof(struct acpi_battery));

	battery->handle = device->handle;		battery->handle = device->handle;
	@@ -738,7 +726,7 @@ static int acpi_battery_add(struct acpi_device *device)
	kfree(battery);		kfree(battery);
	}		}

	return_VALUE(result);		return result;
	}		}

	static int acpi_battery_remove(struct acpi_device *device, int type)		static int acpi_battery_remove(struct acpi_device *device, int type)
	@@ -746,10 +734,9 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
	acpi_status status = 0;		acpi_status status = 0;
	struct acpi_battery *battery = NULL;		struct acpi_battery *battery = NULL;

	ACPI_FUNCTION_TRACE("acpi_battery_remove");

	if (!device \|\| !acpi_driver_data(device))		if (!device \|\| !acpi_driver_data(device))
	return_VALUE(-EINVAL);		return -EINVAL;

	battery = (struct acpi_battery *)acpi_driver_data(device);		battery = (struct acpi_battery *)acpi_driver_data(device);

	@@ -761,38 +748,36 @@ static int acpi_battery_remove(struct acpi_device *device, int type)

	kfree(battery);		kfree(battery);

	return_VALUE(0);		return 0;
	}		}

	static int __init acpi_battery_init(void)		static int __init acpi_battery_init(void)
	{		{
	int result = 0;		int result = 0;

	ACPI_FUNCTION_TRACE("acpi_battery_init");

	acpi_battery_dir = proc_mkdir(ACPI_BATTERY_CLASS, acpi_root_dir);		acpi_battery_dir = proc_mkdir(ACPI_BATTERY_CLASS, acpi_root_dir);
	if (!acpi_battery_dir)		if (!acpi_battery_dir)
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_battery_dir->owner = THIS_MODULE;		acpi_battery_dir->owner = THIS_MODULE;

	result = acpi_bus_register_driver(&acpi_battery_driver);		result = acpi_bus_register_driver(&acpi_battery_driver);
	if (result < 0) {		if (result < 0) {
	remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static void __exit acpi_battery_exit(void)		static void __exit acpi_battery_exit(void)
	{		{
	ACPI_FUNCTION_TRACE("acpi_battery_exit");

	acpi_bus_unregister_driver(&acpi_battery_driver);		acpi_bus_unregister_driver(&acpi_battery_driver);

	remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);

	return_VOID;		return;
	}		}

	module_init(acpi_battery_init);		module_init(acpi_battery_init);

drivers/acpi/bus.c

+46 −59

File changed.

Preview size limit exceeded, changes collapsed.

drivers/acpi/button.c

+23 −33

Original line number	Original line	Diff line number	Diff line
	@@ -112,15 +112,14 @@ static int acpi_button_info_seq_show(struct seq_file seq, void offset)
	{		{
	struct acpi_button button = (struct acpi_button )seq->private;		struct acpi_button button = (struct acpi_button )seq->private;

	ACPI_FUNCTION_TRACE("acpi_button_info_seq_show");

	if (!button \|\| !button->device)		if (!button \|\| !button->device)
	return_VALUE(0);		return 0;

	seq_printf(seq, "type: %s\n",		seq_printf(seq, "type: %s\n",
	acpi_device_name(button->device));		acpi_device_name(button->device));

	return_VALUE(0);		return 0;
	}		}

	static int acpi_button_info_open_fs(struct inode inode, struct file file)		static int acpi_button_info_open_fs(struct inode inode, struct file file)
	@@ -134,10 +133,9 @@ static int acpi_button_state_seq_show(struct seq_file seq, void offset)
	acpi_status status;		acpi_status status;
	unsigned long state;		unsigned long state;

	ACPI_FUNCTION_TRACE("acpi_button_state_seq_show");

	if (!button \|\| !button->device)		if (!button \|\| !button->device)
	return_VALUE(0);		return 0;

	status = acpi_evaluate_integer(button->handle, "_LID", NULL, &state);		status = acpi_evaluate_integer(button->handle, "_LID", NULL, &state);
	if (ACPI_FAILURE(status)) {		if (ACPI_FAILURE(status)) {
	@@ -147,7 +145,7 @@ static int acpi_button_state_seq_show(struct seq_file seq, void offset)
	(state ? "open" : "closed"));		(state ? "open" : "closed"));
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_button_state_open_fs(struct inode inode, struct file file)		static int acpi_button_state_open_fs(struct inode inode, struct file file)
	@@ -164,10 +162,9 @@ static int acpi_button_add_fs(struct acpi_device *device)
	struct proc_dir_entry *entry = NULL;		struct proc_dir_entry *entry = NULL;
	struct acpi_button *button = NULL;		struct acpi_button *button = NULL;

	ACPI_FUNCTION_TRACE("acpi_button_add_fs");

	if (!device \|\| !acpi_driver_data(device))		if (!device \|\| !acpi_driver_data(device))
	return_VALUE(-EINVAL);		return -EINVAL;

	button = acpi_driver_data(device);		button = acpi_driver_data(device);

	@@ -195,19 +192,19 @@ static int acpi_button_add_fs(struct acpi_device *device)
	}		}

	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	entry->owner = THIS_MODULE;		entry->owner = THIS_MODULE;

	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
	if (!acpi_device_dir(device))		if (!acpi_device_dir(device))
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_device_dir(device)->owner = THIS_MODULE;		acpi_device_dir(device)->owner = THIS_MODULE;

	/* 'info' [R] */		/* 'info' [R] */
	entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,		entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
	S_IRUGO, acpi_device_dir(device));		S_IRUGO, acpi_device_dir(device));
	if (!entry)		if (!entry)
	return_VALUE(-ENODEV);		return -ENODEV;
	else {		else {
	entry->proc_fops = &acpi_button_info_fops;		entry->proc_fops = &acpi_button_info_fops;
	entry->data = acpi_driver_data(device);		entry->data = acpi_driver_data(device);
	@@ -227,14 +224,13 @@ static int acpi_button_add_fs(struct acpi_device *device)
	}		}
	}		}

	return_VALUE(0);		return 0;
	}		}

	static int acpi_button_remove_fs(struct acpi_device *device)		static int acpi_button_remove_fs(struct acpi_device *device)
	{		{
	struct acpi_button *button = NULL;		struct acpi_button *button = NULL;

	ACPI_FUNCTION_TRACE("acpi_button_remove_fs");

	button = acpi_driver_data(device);		button = acpi_driver_data(device);
	if (acpi_device_dir(device)) {		if (acpi_device_dir(device)) {
	@@ -249,7 +245,7 @@ static int acpi_button_remove_fs(struct acpi_device *device)
	acpi_device_dir(device) = NULL;		acpi_device_dir(device) = NULL;
	}		}

	return_VALUE(0);		return 0;
	}		}

	/* --------------------------------------------------------------------------		/* --------------------------------------------------------------------------
	@@ -260,10 +256,9 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
	{		{
	struct acpi_button button = (struct acpi_button )data;		struct acpi_button button = (struct acpi_button )data;

	ACPI_FUNCTION_TRACE("acpi_button_notify");

	if (!button \|\| !button->device)		if (!button \|\| !button->device)
	return_VOID;		return;

	switch (event) {		switch (event) {
	case ACPI_BUTTON_NOTIFY_STATUS:		case ACPI_BUTTON_NOTIFY_STATUS:
	@@ -276,21 +271,20 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
	break;		break;
	}		}

	return_VOID;		return;
	}		}

	static acpi_status acpi_button_notify_fixed(void *data)		static acpi_status acpi_button_notify_fixed(void *data)
	{		{
	struct acpi_button button = (struct acpi_button )data;		struct acpi_button button = (struct acpi_button )data;

	ACPI_FUNCTION_TRACE("acpi_button_notify_fixed");

	if (!button)		if (!button)
	return_ACPI_STATUS(AE_BAD_PARAMETER);		return AE_BAD_PARAMETER;

	acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);		acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);

	return_ACPI_STATUS(AE_OK);		return AE_OK;
	}		}

	static int acpi_button_add(struct acpi_device *device)		static int acpi_button_add(struct acpi_device *device)
	@@ -299,14 +293,13 @@ static int acpi_button_add(struct acpi_device *device)
	acpi_status status = AE_OK;		acpi_status status = AE_OK;
	struct acpi_button *button = NULL;		struct acpi_button *button = NULL;

	ACPI_FUNCTION_TRACE("acpi_button_add");

	if (!device)		if (!device)
	return_VALUE(-EINVAL);		return -EINVAL;

	button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);		button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
	if (!button)		if (!button)
	return_VALUE(-ENOMEM);		return -ENOMEM;
	memset(button, 0, sizeof(struct acpi_button));		memset(button, 0, sizeof(struct acpi_button));

	button->device = device;		button->device = device;
	@@ -400,7 +393,7 @@ static int acpi_button_add(struct acpi_device *device)
	kfree(button);		kfree(button);
	}		}

	return_VALUE(result);		return result;
	}		}

	static int acpi_button_remove(struct acpi_device *device, int type)		static int acpi_button_remove(struct acpi_device *device, int type)
	@@ -408,10 +401,9 @@ static int acpi_button_remove(struct acpi_device *device, int type)
	acpi_status status = 0;		acpi_status status = 0;
	struct acpi_button *button = NULL;		struct acpi_button *button = NULL;

	ACPI_FUNCTION_TRACE("acpi_button_remove");

	if (!device \|\| !acpi_driver_data(device))		if (!device \|\| !acpi_driver_data(device))
	return_VALUE(-EINVAL);		return -EINVAL;

	button = acpi_driver_data(device);		button = acpi_driver_data(device);

	@@ -438,31 +430,29 @@ static int acpi_button_remove(struct acpi_device *device, int type)

	kfree(button);		kfree(button);

	return_VALUE(0);		return 0;
	}		}

	static int __init acpi_button_init(void)		static int __init acpi_button_init(void)
	{		{
	int result = 0;		int result = 0;

	ACPI_FUNCTION_TRACE("acpi_button_init");

	acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);		acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
	if (!acpi_button_dir)		if (!acpi_button_dir)
	return_VALUE(-ENODEV);		return -ENODEV;
	acpi_button_dir->owner = THIS_MODULE;		acpi_button_dir->owner = THIS_MODULE;
	result = acpi_bus_register_driver(&acpi_button_driver);		result = acpi_bus_register_driver(&acpi_button_driver);
	if (result < 0) {		if (result < 0) {
	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
	return_VALUE(-ENODEV);		return -ENODEV;
	}		}

	return_VALUE(0);		return 0;
	}		}

	static void __exit acpi_button_exit(void)		static void __exit acpi_button_exit(void)
	{		{
	ACPI_FUNCTION_TRACE("acpi_button_exit");

	acpi_bus_unregister_driver(&acpi_button_driver);		acpi_bus_unregister_driver(&acpi_button_driver);

	@@ -474,7 +464,7 @@ static void __exit acpi_button_exit(void)
	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);		remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);		remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);

	return_VOID;		return;
	}		}

	module_init(acpi_button_init);		module_init(acpi_button_init);