/* *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $) * *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License as published by *  the Free Software Foundation; either version 2 of the License, or (at *  your option) any later version. * *  This program is distributed in the hope that it will be useful, but *  WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *  General Public License for more details. * *  You should have received a copy of the GNU General Public License along *  with this program; if not, write to the Free Software Foundation, Inc., *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */#include <linux/module.h>#include <linux/init.h>#include <linux/ioport.h>#include <linux/kernel.h>#include <linux/list.h>#include <linux/sched.h>#include <linux/pm.h>#include <linux/device.h>#include <linux/proc_fs.h>#ifdef CONFIG_X86#include <asm/mpspec.h>#endif#include <acpi/acpi_bus.h>#include <acpi/acpi_drivers.h>#define _COMPONENT		ACPI_BUS_COMPONENTACPI_MODULE_NAME("bus");#ifdef	CONFIG_X86extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);#endifstruct acpi_device *acpi_root;struct proc_dir_entry *acpi_root_dir;EXPORT_SYMBOL(acpi_root_dir);#define STRUCT_TO_INT(s)	(*((int*)&s))/* --------------------------------------------------------------------------                                Device Management   -------------------------------------------------------------------------- */int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device){	acpi_status status = AE_OK;	if (!device)		return -EINVAL;	/* TBD: Support fixed-feature devices */	status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);	if (ACPI_FAILURE(status) || !*device) {		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",				  handle));		return -ENODEV;	}	return 0;}EXPORT_SYMBOL(acpi_bus_get_device);int acpi_bus_get_status(struct acpi_device *device){	acpi_status status = AE_OK;	unsigned long sta = 0;	if (!device)		return -EINVAL;	/*	 * Evaluate _STA if present.	 */	if (device->flags.dynamic_status) {		status =		    acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);		if (ACPI_FAILURE(status))			return -ENODEV;		STRUCT_TO_INT(device->status) = (int)sta;	}	/*	 * Otherwise we assume the status of our parent (unless we don't	 * have one, in which case status is implied).	 */	else if (device->parent)		device->status = device->parent->status;	else		STRUCT_TO_INT(device->status) =		    ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |		    ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;	if (device->status.functional && !device->status.present) {		printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "		       "functional but not present; setting present\n",		       device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status));		device->status.present = 1;	}	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",			  device->pnp.bus_id,			  (u32) STRUCT_TO_INT(device->status)));	return 0;}EXPORT_SYMBOL(acpi_bus_get_status);/* --------------------------------------------------------------------------                                 Power Management   -------------------------------------------------------------------------- */int acpi_bus_get_power(acpi_handle handle, int *state){	int result = 0;	acpi_status status = 0;	struct acpi_device *device = NULL;	unsigned long psc = 0;	result = acpi_bus_get_device(handle, &device);	if (result)		return result;	*state = ACPI_STATE_UNKNOWN;	if (!device->flags.power_manageable) {		/* TBD: Non-recursive algorithm for walking up hierarchy */		if (device->parent)			*state = device->parent->power.state;		else			*state = ACPI_STATE_D0;	} else {		/*		 * Get the device's power state either directly (via _PSC) or		 * indirectly (via power resources).		 */		if (device->power.flags.explicit_get) {			status = acpi_evaluate_integer(device->handle, "_PSC",						       NULL, &psc);			if (ACPI_FAILURE(status))				return -ENODEV;			device->power.state = (int)psc;		} else if (device->power.flags.power_resources) {			result = acpi_power_get_inferred_state(device);			if (result)				return result;		}		*state = device->power.state;	}	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",			  device->pnp.bus_id, device->power.state));	return 0;}EXPORT_SYMBOL(acpi_bus_get_power);int acpi_bus_set_power(acpi_handle handle, int state){	int result = 0;	acpi_status status = AE_OK;	struct acpi_device *device = NULL;	char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };	result = acpi_bus_get_device(handle, &device);	if (result)		return result;	if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))		return -EINVAL;	/* Make sure this is a valid target state */	if (!device->flags.power_manageable) {		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",				kobject_name(&device->dev.kobj)));		return -ENODEV;	}	/*	 * Get device's current power state	 */	acpi_bus_get_power(device->handle, &device->power.state);	if ((state == device->power.state) && !device->flags.force_power_state) {		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",				  state));		return 0;	}	if (!device->power.states[state].flags.valid) {		printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);		return -ENODEV;	}	if (device->parent && (state < device->parent->power.state)) {		printk(KERN_WARNING PREFIX			      "Cannot set device to a higher-powered"			      " state than parent\n");		return -ENODEV;	}	/*	 * Transition Power	 * ----------------	 * On transitions to a high-powered state we first apply power (via	 * power resources) then evalute _PSx.  Conversly for transitions to	 * a lower-powered state.	 */	if (state < device->power.state) {		if (device->power.flags.power_resources) {			result = acpi_power_transition(device, state);			if (result)				goto end;		}		if (device->power.states[state].flags.explicit_set) {			status = acpi_evaluate_object(device->handle,						      object_name, NULL, NULL);			if (ACPI_FAILURE(status)) {				result = -ENODEV;				goto end;			}		}	} else {		if (device->power.states[state].flags.explicit_set) {			status = acpi_evaluate_object(device->handle,						      object_name, NULL, NULL);			if (ACPI_FAILURE(status)) {				result = -ENODEV;				goto end;			}		}		if (device->power.flags.power_resources) {			result = acpi_power_transition(device, state);			if (result)				goto end;		}	}      end:	if (result)		printk(KERN_WARNING PREFIX			      "Transitioning device [%s] to D%d\n",			      device->pnp.bus_id, state);	else {		device->power.state = state;		ACPI_DEBUG_PRINT((ACPI_DB_INFO,				  "Device [%s] transitioned to D%d\n",				  device->pnp.bus_id, state));	}	return result;}EXPORT_SYMBOL(acpi_bus_set_power);/* --------------------------------------------------------------------------                                Event Management   -------------------------------------------------------------------------- */#ifdef CONFIG_ACPI_PROC_EVENTstatic DEFINE_SPINLOCK(acpi_bus_event_lock);LIST_HEAD(acpi_bus_event_list);DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);extern int event_is_open;int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data){	struct acpi_bus_event *event;	unsigned long flags = 0;	/* drop event on the floor if no one's listening */	if (!event_is_open)		return 0;	event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);	if (!event)		return -ENOMEM;	strcpy(event->device_class, device_class);	strcpy(event->bus_id, bus_id);	event->type = type;	event->data = data;	spin_lock_irqsave(&acpi_bus_event_lock, flags);	list_add_tail(&event->node, &acpi_bus_event_list);	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);	wake_up_interruptible(&acpi_bus_event_queue);	return 0;}EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data){	if (!device)		return -EINVAL;	return acpi_bus_generate_proc_event4(device->pnp.device_class,					     device->pnp.bus_id, type, data);}EXPORT_SYMBOL(acpi_bus_generate_proc_event);int acpi_bus_receive_event(struct acpi_bus_event *event){	unsigned long flags = 0;	struct acpi_bus_event *entry = NULL;	DECLARE_WAITQUEUE(wait, current);	if (!event)		return -EINVAL;	if (list_empty(&acpi_bus_event_list)) {		set_current_state(TASK_INTERRUPTIBLE);		add_wait_queue(&acpi_bus_event_queue, &wait);		if (list_empty(&acpi_bus_event_list))			schedule();		remove_wait_queue(&acpi_bus_event_queue, &wait);		set_current_state(TASK_RUNNING);		if (signal_pending(current))			return -ERESTARTSYS;	}	spin_lock_irqsave(&acpi_bus_event_lock, flags);	entry =	    list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);	if (entry)		list_del(&entry->node);	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);	if (!entry)		return -ENODEV;	memcpy(event, entry, sizeof(struct acpi_bus_event));	kfree(entry);	return 0;}EXPORT_SYMBOL(acpi_bus_receive_event);#endif	/* CONFIG_ACPI_PROC_EVENT *//* --------------------------------------------------------------------------                             Notification Handling   -------------------------------------------------------------------------- */static intacpi_bus_check_device(struct acpi_device *device, int *status_changed){	acpi_status status = 0;	struct acpi_device_status old_status;	if (!device)		return -EINVAL;	if (status_changed)		*status_changed = 0;	old_status = device->status;	/*