patch-2.4.0-test3 linux/drivers/acpi/events/evregion.c

• Lines: 691
• Date: Wed Jul 5 11:23:12 2000
• Orig file: v2.4.0-test2/linux/drivers/acpi/events/evregion.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.4.0-test2/linux/drivers/acpi/events/evregion.c linux/drivers/acpi/events/evregion.c
@@ -0,0 +1,690 @@
+/******************************************************************************
+ *
+ * Module Name: evregion - ACPI Address_space / Op_region handler dispatch
+ *
+ *****************************************************************************/
+
+/*
+ *  Copyright (C) 2000 R. Byron Moore
+ *
+ *  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 "acpi.h"
+#include "events.h"
+#include "namesp.h"
+#include "interp.h"
+#include "amlcode.h"
+
+#define _COMPONENT          EVENT_HANDLING
+	 MODULE_NAME         ("evregion");
+
+
+#define PCI_ROOT_HID_STRING        "PNP0A03"
+#define PCI_ROOT_HID_VALUE         0x030AD041       /* EISAID("PNP0A03") */
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_find_one_pci_root_bus
+ *
+ * PARAMETERS:
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION:
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+acpi_ev_find_one_pci_root_bus (
+	ACPI_HANDLE             obj_handle,
+	u32                     nesting_level,
+	void                    *context,
+	void                    **return_value)
+{
+	ACPI_NAMED_OBJECT       *entry;
+	ACPI_OBJECT_INTERNAL    *obj_desc;
+	ACPI_STATUS             status;
+
+
+	entry = (ACPI_NAMED_OBJECT*) obj_handle;
+	obj_desc = ((ACPI_NAMED_OBJECT*)obj_handle)->object;
+
+
+	/*
+	 * We are looking for all valid _HID objects.
+	 */
+
+	if (STRNCMP ((char *)&entry->name, METHOD_NAME__HID, ACPI_NAME_SIZE) ||
+		(!obj_desc))
+	{
+		return AE_OK;
+	}
+
+
+	/*
+	 * Found an _HID object.
+	 * Now we need a HID with the value EISAID("PNP0A03")
+	 * HID can be either a number or a string.
+	 */
+
+	switch (obj_desc->common.type)
+	{
+	case ACPI_TYPE_NUMBER:
+
+		if (obj_desc->number.value != PCI_ROOT_HID_VALUE) {
+			return AE_OK;
+		}
+
+		break;
+
+	case ACPI_TYPE_STRING:
+
+		if (STRNCMP (obj_desc->string.pointer, PCI_ROOT_HID_STRING,
+				  sizeof (PCI_ROOT_HID_STRING)))
+		{
+			return AE_OK;
+		}
+
+		break;
+
+	default:
+
+		return AE_OK;
+	}
+
+
+	/*
+	 * We found a valid PCI_ROOT_HID.
+	 * The parent of the HID entry is the PCI device;  Install the default PCI
+	 * handler for this PCI device.
+	 */
+
+	status = acpi_install_address_space_handler (acpi_ns_get_parent_entry (entry),
+			   ADDRESS_SPACE_PCI_CONFIG,
+			   ACPI_DEFAULT_HANDLER, NULL, NULL);
+
+	return AE_OK;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_find_pci_root_buses
+ *
+ * PARAMETERS:
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION:
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+acpi_ev_find_pci_root_buses (
+	void)
+{
+
+	acpi_ns_walk_namespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
+			   FALSE, acpi_ev_find_one_pci_root_bus, NULL, NULL);
+
+	return AE_OK;
+}
+
+
+/**************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_install_default_address_space_handlers
+ *
+ * PARAMETERS:
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Installs the core subsystem address space handlers.
+ *
+ *************************************************************************/
+
+ACPI_STATUS
+acpi_ev_install_default_address_space_handlers (
+	void)
+{
+	ACPI_STATUS             status;
+
+
+	/*
+	 * NOTE:    All address spaces (PCI Config, EC, SMBus) are scope dependent
+	 *          and registration must occur for a specific device.  In the case
+	 *          system memory and IO address spaces there is currently no device
+	 *          associated with the address space.  For these we use the root.
+	 */
+
+	status = acpi_install_address_space_handler (acpi_gbl_root_object,
+			   ADDRESS_SPACE_SYSTEM_MEMORY,
+			   ACPI_DEFAULT_HANDLER, NULL, NULL);
+	if (ACPI_FAILURE (status)) {
+		return (status);
+	}
+
+	status = acpi_install_address_space_handler (acpi_gbl_root_object,
+			   ADDRESS_SPACE_SYSTEM_IO,
+			   ACPI_DEFAULT_HANDLER, NULL, NULL);
+	if (ACPI_FAILURE (status)) {
+		return (status);
+	}
+
+	/*
+	 *  Install PCI config space handler for all PCI root bridges.  A PCI root
+	 *  bridge is found by searching for devices containing a HID with the value
+	 *  EISAID("PNP0A03")
+	 */
+
+	acpi_ev_find_pci_root_buses ();
+
+
+	return (AE_OK);
+}
+
+
+/* TBD: [Restructure] Move to the methods directory */
+
+/**************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_execute_reg_method
+ *
+ * PARAMETERS:  Region_obj          - Object structure
+ *              Function            - On (1) or Off (0)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Execute _REG method for a region
+ *
+ *************************************************************************/
+
+ACPI_STATUS
+acpi_ev_execute_reg_method (
+	ACPI_OBJECT_INTERNAL   *region_obj,
+	u32                     function)
+{
+	ACPI_OBJECT_INTERNAL   *params[3];
+	ACPI_OBJECT_INTERNAL    space_iD_obj;
+	ACPI_OBJECT_INTERNAL    function_obj;
+	ACPI_STATUS             status;
+
+
+	if (region_obj->region.REGmethod == NULL) {
+		return (AE_OK);
+	}
+
+	/*
+	 *  _REG method has two arguments
+	 *  Arg0:   Integer: Operation region space ID
+	 *          Same value as Region_obj->Region.Space_id
+	 *  Arg1:   Integer: connection status
+	 *          1 for connecting the handler,
+	 *          0 for disconnecting the handler
+	 *          Passed as a parameter
+	 */
+
+	acpi_cm_init_static_object (&space_iD_obj);
+	acpi_cm_init_static_object (&function_obj);
+
+	/*
+	 *  Method requires two parameters.
+	 */
+	params [0] = &space_iD_obj;
+	params [1] = &function_obj;
+	params [2] = NULL;
+
+	/*
+	 *  Set up the parameter objects
+	 */
+	space_iD_obj.common.type   = ACPI_TYPE_NUMBER;
+	space_iD_obj.number.value  = region_obj->region.space_id;
+
+	function_obj.common.type   = ACPI_TYPE_NUMBER;
+	function_obj.number.value  = function;
+
+	/*
+	 *  Execute the method, no return value
+	 */
+	status = acpi_ns_evaluate_by_handle (region_obj->region.REGmethod, params, NULL);
+	return (status);
+}
+
+
+/**************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_address_space_dispatch
+ *
+ * PARAMETERS:  Region_obj          - internal region object
+ *              Space_id            - ID of the address space (0-255)
+ *              Function            - Read or Write operation
+ *              Address             - Where in the space to read or write
+ *              Bit_width           - Field width in bits (8, 16, or 32)
+ *              Value               - Pointer to in or out value
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Dispatch an address space or operation region access to
+ *              a previously installed handler.
+ *
+ *************************************************************************/
+
+ACPI_STATUS
+acpi_ev_address_space_dispatch (
+	ACPI_OBJECT_INTERNAL    *region_obj,
+	u32                     function,
+	u32                     address,
+	u32                     bit_width,
+	u32                     *value)
+{
+	ACPI_STATUS             status;
+	ADDRESS_SPACE_HANDLER   handler;
+	ADDRESS_SPACE_SETUP     region_setup;
+	ACPI_OBJECT_INTERNAL    *handler_desc;
+	void                    *region_context;
+
+
+	/*
+	 *  Check for an installed handler
+	 */
+	handler_desc = region_obj->region.addr_handler;
+
+	if (!handler_desc) {
+		return(AE_EXIST);
+	}
+
+	/*
+	 *  It may be the case that the region has never been initialized
+	 *  Some types of regions require special init code
+	 */
+	if (!(region_obj->region.region_flags & REGION_INITIALIZED)) {
+		/*
+		 *  This region has not been initialized yet, do it
+		 */
+		region_setup = handler_desc->addr_handler.setup;
+		if (!region_setup) {
+			/*
+			 *  Bad news, no init routine and not init'd
+			 */
+			return (AE_UNKNOWN_STATUS);
+		}
+
+		/*
+		 * We must exit the interpreter because the region setup will potentially
+		 * execute control methods
+		 */
+		acpi_aml_exit_interpreter ();
+
+		status = region_setup (region_obj, ACPI_REGION_ACTIVATE,
+				  handler_desc->addr_handler.context,
+				  &region_context);
+
+		/* Re-enter the interpreter */
+
+		acpi_aml_enter_interpreter ();
+
+		/*
+		 *  Init routine may fail
+		 */
+		if (ACPI_FAILURE (status)) {
+			return(status);
+		}
+
+		/*
+		 *  Save the returned context for use in all accesses to the region
+		 */
+		handler_desc->addr_handler.context = region_context;
+	}
+
+	/*
+	 *  We have everything we need, begin the process
+	 */
+	handler = handler_desc->addr_handler.handler;
+
+	if (!(handler_desc->addr_handler.flags & ADDR_HANDLER_DEFAULT_INSTALLED)) {
+		/*
+		 *  For handlers other than the default (supplied) handlers, we must
+		 *  exit the interpreter because the handler *might* block -- we don't
+		 *  know what it will do, so we can't hold the lock on the intepreter.
+		 */
+		acpi_aml_exit_interpreter();
+	}
+
+	/*
+	 *  Invoke the handler.
+	 */
+	status = handler (function, address, bit_width, value,
+			 handler_desc->addr_handler.context);
+
+
+	if (!(handler_desc->addr_handler.flags & ADDR_HANDLER_DEFAULT_INSTALLED)) {
+		/* We just returned from a non-default handler, we must re-enter the
+		interpreter */
+
+		acpi_aml_enter_interpreter ();
+	}
+
+	return (status);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_disassociate_region_and_handler
+ *
+ * PARAMETERS:  Handler_obj     - Handler Object
+ *              Region_obj      - Region Object
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Break the association between the handler and the region
+ *              this is a two way association.
+ *
+ ******************************************************************************/
+
+void
+acpi_ev_disassociate_region_from_handler(
+	ACPI_OBJECT_INTERNAL    *region_obj)
+{
+	ACPI_OBJECT_INTERNAL    *handler_obj;
+	ACPI_OBJECT_INTERNAL    *obj_desc;
+	ACPI_OBJECT_INTERNAL    **last_obj_ptr;
+	ADDRESS_SPACE_SETUP     region_setup;
+	void                    *region_context;
+	ACPI_STATUS             status;
+
+
+	/*
+	 *  Get the address handler from the region object
+	 */
+
+	handler_obj = region_obj->region.addr_handler;
+	if (!handler_obj) {
+		/*
+		 *  This region has no handler, all done
+		 */
+		return;
+	}
+
+
+	/*
+	 *  Find this region in the handler's list
+	 */
+
+	obj_desc = handler_obj->addr_handler.region_list;
+	last_obj_ptr = &handler_obj->addr_handler.region_list;
+
+	while (obj_desc) {
+		/*
+		 *  See if this is the one
+		 */
+		if (obj_desc == region_obj) {
+			/*
+			 *  This is it, remove it from the handler's list
+			 */
+			*last_obj_ptr = obj_desc->region.link;
+
+			/*
+			 *  Now stop region accesses by executing the _REG method
+			 */
+			acpi_ev_execute_reg_method (region_obj, 0);
+
+			/*
+			 *  Call the setup handler with the deactivate notification
+			 */
+			region_setup = handler_obj->addr_handler.setup;
+			status = region_setup (region_obj, ACPI_REGION_DEACTIVATE,
+					  handler_obj->addr_handler.context,
+					  &region_context);
+
+			/*
+			 *  Save the returned context (It is the original context
+			 *  passed into Install)
+			 */
+			handler_obj->addr_handler.context = region_context;
+
+			/*
+			 *  Init routine may fail, Just ignore errors
+			 */
+
+			/*
+			 *  Remove handler reference in the region
+			 *
+			 *  NOTE: this doesn't mean that the region goes away
+			 *  The region is just inaccessible as indicated to
+			 *  the _REG method
+			 *
+			 *  If the region is on the handler's list
+			 *  this better be the region's handler
+			 */
+			ACPI_ASSERT (region_obj->region.addr_handler == handler_obj);
+
+			region_obj->region.addr_handler = NULL;
+
+			return;
+
+		} /* found the right handler */
+
+		/*
+		 *  Move through the linked list of handlers
+		 */
+		last_obj_ptr = &obj_desc->region.link;
+		obj_desc = obj_desc->region.link;
+	}
+
+	/*
+	 *  If we get here, the region was not in the handler's region list
+	 */
+	return;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_associate_region_and_handler
+ *
+ * PARAMETERS:  Handler_obj     - Handler Object
+ *              Region_obj      - Region Object
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Create the association between the handler and the region
+ *              this is a two way association.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+acpi_ev_associate_region_and_handler(
+	ACPI_OBJECT_INTERNAL    *handler_obj,
+	ACPI_OBJECT_INTERNAL    *region_obj)
+{
+	ACPI_STATUS     status;
+
+
+	ACPI_ASSERT (region_obj->region.space_id == handler_obj->addr_handler.space_id);
+	ACPI_ASSERT (region_obj->region.addr_handler == 0);
+
+	/*
+	 *  Link this region to the front of the handler's list
+	 */
+
+	region_obj->region.link = handler_obj->addr_handler.region_list;
+	handler_obj->addr_handler.region_list = region_obj;
+
+	/*
+	 *  set the region's handler
+	 */
+
+/*
+	Handler_obj->Common.Reference_count =
+			  (u16) (Handler_obj->Common.Reference_count +
+			  Region_obj->Common.Reference_count - 1);
+*/
+	region_obj->region.addr_handler = handler_obj;
+
+	/*
+	 *  Last thing, tell all users that this region is usable
+	 */
+	acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
+	status = acpi_ev_execute_reg_method (region_obj, 1);
+	acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
+
+	return (status);
+}
+
+
+/****************************************************************************
+ *
+ * FUNCTION:    Acpi_ev_addr_handler_helper
+ *
+ * PARAMETERS:  Handle              - Entry to be dumped
+ *              Level               - Nesting level of the handle
+ *              Context             - Passed into Acpi_ns_walk_namespace
+ *
+ * DESCRIPTION: This routine checks to see if the object is a Region if it
+ *              is then the address handler is installed in it.
+ *
+ *              If the Object is a Device, and the device has a handler of
+ *              the same type then the search is terminated in that branch.
+ *
+ *              This is because the existing handler is closer in proximity
+ *              to any more regions than the one we are trying to install.
+ *
+ ***************************************************************************/
+
+ACPI_STATUS
+acpi_ev_addr_handler_helper (
+	ACPI_HANDLE             obj_handle,
+	u32                     level,
+	void                    *context,
+	void                    **return_value)
+{
+	ACPI_OBJECT_INTERNAL    *handler_obj;
+	ACPI_OBJECT_INTERNAL    *tmp_obj;
+	ACPI_OBJECT_INTERNAL    *obj_desc;
+	ACPI_NAMED_OBJECT       *obj_entry;
+	ACPI_STATUS             status;
+
+
+	handler_obj = (ACPI_OBJECT_INTERNAL *) context;
+
+	/* Parameter validation */
+
+	if (!handler_obj) {
+		return (AE_OK);
+	}
+
+	/* Convert and validate the device handle */
+
+	obj_entry = acpi_ns_convert_handle_to_entry (obj_handle);
+	if (!obj_entry) {
+		return (AE_BAD_PARAMETER);
+	}
+
+	/*
+	 *  We only care about regions.and objects
+	 *  that can have address handlers
+	 */
+
+	if ((obj_entry->type != ACPI_TYPE_DEVICE) &&
+		(obj_entry->type != ACPI_TYPE_REGION) &&
+		(obj_entry != acpi_gbl_root_object))
+	{
+		return (AE_OK);
+	}
+
+	/* Check for an existing internal object */
+
+	obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) obj_entry);
+	if (!obj_desc) {
+		/*
+		 *  The object DNE, we don't care about it
+		 */
+		return (AE_OK);
+	}
+
+	/*
+	 *  Devices are handled different than regions
+	 */
+	if (IS_THIS_OBJECT_TYPE (obj_desc, ACPI_TYPE_DEVICE)) {
+		/*
+		 *  See if this guy has any handlers
+		 */
+		tmp_obj = obj_desc->device.addr_handler;
+		while (tmp_obj) {
+			/*
+			 *  Now let's see if it's for the same address space.
+			 */
+			if (tmp_obj->addr_handler.space_id == handler_obj->addr_handler.space_id) {
+				/*
+				 *  It's for the same address space
+				 */
+
+				/*
+				 *  Since the object we found it on was a device, then it
+				 *  means that someone has already installed a handler for
+				 *  the branch of the namespace from this device on.  Just
+				 *  bail out telling the walk routine to not traverse this
+				 *  branch.  This preserves the scoping rule for handlers.
+				 */
+				return (AE_CTRL_DEPTH);
+			}
+
+			/*
+			 *  Move through the linked list of handlers
+			 */
+			tmp_obj = tmp_obj->addr_handler.link;
+		}
+
+		/*
+		 *  As long as the device didn't have a handler for this
+		 *  space we don't care about it.  We just ignore it and
+		 *  proceed.
+		 */
+		return (AE_OK);
+	}
+
+	/*
+	 *  Only here if it was a region
+	 */
+	ACPI_ASSERT (obj_desc->common.type == ACPI_TYPE_REGION);
+
+	if (obj_desc->region.space_id != handler_obj->addr_handler.space_id) {
+		/*
+		 *  This region is for a different address space
+		 *  ignore it
+		 */
+		return (AE_OK);
+	}
+
+	/*
+	 *  Now we have a region and it is for the handler's address
+	 *  space type.
+	 *
+	 *  First disconnect region for any previous handler (if any)
+	 */
+	acpi_ev_disassociate_region_from_handler (obj_desc);
+
+	/*
+	 *  Then connect the region to the new handler
+	 */
+	status = acpi_ev_associate_region_and_handler (handler_obj, obj_desc);
+
+	return (status);
+}
+
+