evregion.c

winNT技术操作系统,国外开放的原代码和LIUX一样

/******************************************************************************
 *
 * Module Name: evregion - ACPI Address_space (Op_region) handler dispatch
 *              $Revision: 1.1 $
 *
 *****************************************************************************/

/*
 *  Copyright (C) 2000, 2001 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>

#define _COMPONENT          ACPI_EVENTS
	 MODULE_NAME         ("evregion")


/**************************************************************************
 *
 * 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;


	/*
	 * 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.
	 * We install the default PCI config space handler at the root so
	 * that this space is immediately available even though the we have
	 * not enumerated all the PCI Root Buses yet.  This is to conform
	 * to the ACPI specification which states that the PCI config
	 * space must be always available -- even though we are nowhere
	 * near ready to find the PCI root buses at this point.
	 *
	 * NOTE: We ignore AE_EXIST because this means that a handler has
	 * already been installed (via Acpi_install_address_space_handler)
	 */

	status = acpi_install_address_space_handler (acpi_gbl_root_node,
			   ADDRESS_SPACE_SYSTEM_MEMORY,
			   ACPI_DEFAULT_HANDLER, NULL, NULL);
	if ((ACPI_FAILURE (status)) &&
		(status != AE_EXIST)) {
		return (status);
	}

	status = acpi_install_address_space_handler (acpi_gbl_root_node,
			   ADDRESS_SPACE_SYSTEM_IO,
			   ACPI_DEFAULT_HANDLER, NULL, NULL);
	if ((ACPI_FAILURE (status)) &&
		(status != AE_EXIST)) {
		return (status);
	}

	status = acpi_install_address_space_handler (acpi_gbl_root_node,
			   ADDRESS_SPACE_PCI_CONFIG,
			   ACPI_DEFAULT_HANDLER, NULL, NULL);
	if ((ACPI_FAILURE (status)) &&
		(status != AE_EXIST)) {
		return (status);
	}


	return (AE_OK);
}


/* TBD: [Restructure] Move elsewhere */

/**************************************************************************
 *
 * 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
 *
 *************************************************************************/

static ACPI_STATUS
acpi_ev_execute_reg_method (
	ACPI_OPERAND_OBJECT    *region_obj,
	u32                     function)
{
	ACPI_OPERAND_OBJECT    *params[3];
	ACPI_OPERAND_OBJECT     space_id_desc;
	ACPI_OPERAND_OBJECT     function_desc;
	ACPI_STATUS             status;


	if (region_obj->region.extra->extra.method_REG == 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_desc);
	acpi_cm_init_static_object (&function_desc);

	/*
	 *  Method requires two parameters.
	 */
	params [0] = &space_id_desc;
	params [1] = &function_desc;
	params [2] = NULL;

	/*
	 *  Set up the parameter objects
	 */
	space_id_desc.common.type  = ACPI_TYPE_INTEGER;
	space_id_desc.integer.value = region_obj->region.space_id;

	function_desc.common.type  = ACPI_TYPE_INTEGER;
	function_desc.integer.value = function;

	/*
	 *  Execute the method, no return value
	 */
	status = acpi_ns_evaluate_by_handle (region_obj->region.extra->extra.method_REG, 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_OPERAND_OBJECT     *region_obj,
	u32                     function,
	ACPI_PHYSICAL_ADDRESS   address,
	u32                     bit_width,
	u32                     *value)
{
	ACPI_STATUS             status;
	ADDRESS_SPACE_HANDLER   handler;
	ADDRESS_SPACE_SETUP     region_setup;
	ACPI_OPERAND_OBJECT     *handler_desc;
	void                    *region_context = NULL;


	/*
	 * Ensure that there is a handler associated with this region
	 */
	handler_desc = region_obj->region.addr_handler;
	if (!handler_desc) {
		return(AE_NOT_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.flags & AOPOBJ_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);
		}

		region_obj->region.flags |= AOPOBJ_INITIALIZED;

		/*
		 *  Save the returned context for use in all accesses to
		 *  this particular region.
		 */
		region_obj->region.extra->extra.region_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,
			 region_obj->region.extra->extra.region_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_from_handler
 *
 * PARAMETERS:  Region_obj      - Region Object
 *              Acpi_ns_is_locked - Namespace Region Already Locked?
 *
 * 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_OPERAND_OBJECT     *region_obj,
	u8                      acpi_ns_is_locked)
{
	ACPI_OPERAND_OBJECT     *handler_obj;