195b482a8SLen Brown /****************************************************************************** 295b482a8SLen Brown * 395b482a8SLen Brown * Module Name: evrgnini- ACPI address_space (op_region) init 495b482a8SLen Brown * 595b482a8SLen Brown *****************************************************************************/ 695b482a8SLen Brown 795b482a8SLen Brown /* 8a8357b0cSBob Moore * Copyright (C) 2000 - 2010, Intel Corp. 995b482a8SLen Brown * All rights reserved. 1095b482a8SLen Brown * 1195b482a8SLen Brown * Redistribution and use in source and binary forms, with or without 1295b482a8SLen Brown * modification, are permitted provided that the following conditions 1395b482a8SLen Brown * are met: 1495b482a8SLen Brown * 1. Redistributions of source code must retain the above copyright 1595b482a8SLen Brown * notice, this list of conditions, and the following disclaimer, 1695b482a8SLen Brown * without modification. 1795b482a8SLen Brown * 2. Redistributions in binary form must reproduce at minimum a disclaimer 1895b482a8SLen Brown * substantially similar to the "NO WARRANTY" disclaimer below 1995b482a8SLen Brown * ("Disclaimer") and any redistribution must be conditioned upon 2095b482a8SLen Brown * including a substantially similar Disclaimer requirement for further 2195b482a8SLen Brown * binary redistribution. 2295b482a8SLen Brown * 3. Neither the names of the above-listed copyright holders nor the names 2395b482a8SLen Brown * of any contributors may be used to endorse or promote products derived 2495b482a8SLen Brown * from this software without specific prior written permission. 2595b482a8SLen Brown * 2695b482a8SLen Brown * Alternatively, this software may be distributed under the terms of the 2795b482a8SLen Brown * GNU General Public License ("GPL") version 2 as published by the Free 2895b482a8SLen Brown * Software Foundation. 2995b482a8SLen Brown * 3095b482a8SLen Brown * NO WARRANTY 3195b482a8SLen Brown * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 3295b482a8SLen Brown * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 3395b482a8SLen Brown * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 3495b482a8SLen Brown * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 3595b482a8SLen Brown * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 3695b482a8SLen Brown * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 3795b482a8SLen Brown * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3895b482a8SLen Brown * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 3995b482a8SLen Brown * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 4095b482a8SLen Brown * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 4195b482a8SLen Brown * POSSIBILITY OF SUCH DAMAGES. 4295b482a8SLen Brown */ 4395b482a8SLen Brown 4495b482a8SLen Brown #include <acpi/acpi.h> 45e2f7a777SLen Brown #include "accommon.h" 46e2f7a777SLen Brown #include "acevents.h" 47e2f7a777SLen Brown #include "acnamesp.h" 4895b482a8SLen Brown 4995b482a8SLen Brown #define _COMPONENT ACPI_EVENTS 5095b482a8SLen Brown ACPI_MODULE_NAME("evrgnini") 5195b482a8SLen Brown 5295b482a8SLen Brown /* Local prototypes */ 5395b482a8SLen Brown static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node); 5495b482a8SLen Brown 5595b482a8SLen Brown /******************************************************************************* 5695b482a8SLen Brown * 5795b482a8SLen Brown * FUNCTION: acpi_ev_system_memory_region_setup 5895b482a8SLen Brown * 5995b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 6095b482a8SLen Brown * Function - Start or stop 6195b482a8SLen Brown * handler_context - Address space handler context 6295b482a8SLen Brown * region_context - Region specific context 6395b482a8SLen Brown * 6495b482a8SLen Brown * RETURN: Status 6595b482a8SLen Brown * 6695b482a8SLen Brown * DESCRIPTION: Setup a system_memory operation region 6795b482a8SLen Brown * 6895b482a8SLen Brown ******************************************************************************/ 6995b482a8SLen Brown 7095b482a8SLen Brown acpi_status 7195b482a8SLen Brown acpi_ev_system_memory_region_setup(acpi_handle handle, 7295b482a8SLen Brown u32 function, 7395b482a8SLen Brown void *handler_context, void **region_context) 7495b482a8SLen Brown { 7595b482a8SLen Brown union acpi_operand_object *region_desc = 7695b482a8SLen Brown (union acpi_operand_object *)handle; 7795b482a8SLen Brown struct acpi_mem_space_context *local_region_context; 7895b482a8SLen Brown 7995b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_system_memory_region_setup); 8095b482a8SLen Brown 8195b482a8SLen Brown if (function == ACPI_REGION_DEACTIVATE) { 8295b482a8SLen Brown if (*region_context) { 8395b482a8SLen Brown local_region_context = 8495b482a8SLen Brown (struct acpi_mem_space_context *)*region_context; 8595b482a8SLen Brown 8695b482a8SLen Brown /* Delete a cached mapping if present */ 8795b482a8SLen Brown 8895b482a8SLen Brown if (local_region_context->mapped_length) { 8995b482a8SLen Brown acpi_os_unmap_memory(local_region_context-> 9095b482a8SLen Brown mapped_logical_address, 9195b482a8SLen Brown local_region_context-> 9295b482a8SLen Brown mapped_length); 9395b482a8SLen Brown } 9495b482a8SLen Brown ACPI_FREE(local_region_context); 9595b482a8SLen Brown *region_context = NULL; 9695b482a8SLen Brown } 9795b482a8SLen Brown return_ACPI_STATUS(AE_OK); 9895b482a8SLen Brown } 9995b482a8SLen Brown 10095b482a8SLen Brown /* Create a new context */ 10195b482a8SLen Brown 10295b482a8SLen Brown local_region_context = 10395b482a8SLen Brown ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context)); 10495b482a8SLen Brown if (!(local_region_context)) { 10595b482a8SLen Brown return_ACPI_STATUS(AE_NO_MEMORY); 10695b482a8SLen Brown } 10795b482a8SLen Brown 10895b482a8SLen Brown /* Save the region length and address for use in the handler */ 10995b482a8SLen Brown 11095b482a8SLen Brown local_region_context->length = region_desc->region.length; 11195b482a8SLen Brown local_region_context->address = region_desc->region.address; 11295b482a8SLen Brown 11395b482a8SLen Brown *region_context = local_region_context; 11495b482a8SLen Brown return_ACPI_STATUS(AE_OK); 11595b482a8SLen Brown } 11695b482a8SLen Brown 11795b482a8SLen Brown /******************************************************************************* 11895b482a8SLen Brown * 11995b482a8SLen Brown * FUNCTION: acpi_ev_io_space_region_setup 12095b482a8SLen Brown * 12195b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 12295b482a8SLen Brown * Function - Start or stop 12395b482a8SLen Brown * handler_context - Address space handler context 12495b482a8SLen Brown * region_context - Region specific context 12595b482a8SLen Brown * 12695b482a8SLen Brown * RETURN: Status 12795b482a8SLen Brown * 12895b482a8SLen Brown * DESCRIPTION: Setup a IO operation region 12995b482a8SLen Brown * 13095b482a8SLen Brown ******************************************************************************/ 13195b482a8SLen Brown 13295b482a8SLen Brown acpi_status 13395b482a8SLen Brown acpi_ev_io_space_region_setup(acpi_handle handle, 13495b482a8SLen Brown u32 function, 13595b482a8SLen Brown void *handler_context, void **region_context) 13695b482a8SLen Brown { 13795b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_io_space_region_setup); 13895b482a8SLen Brown 13995b482a8SLen Brown if (function == ACPI_REGION_DEACTIVATE) { 14095b482a8SLen Brown *region_context = NULL; 14195b482a8SLen Brown } else { 14295b482a8SLen Brown *region_context = handler_context; 14395b482a8SLen Brown } 14495b482a8SLen Brown 14595b482a8SLen Brown return_ACPI_STATUS(AE_OK); 14695b482a8SLen Brown } 14795b482a8SLen Brown 14895b482a8SLen Brown /******************************************************************************* 14995b482a8SLen Brown * 15095b482a8SLen Brown * FUNCTION: acpi_ev_pci_config_region_setup 15195b482a8SLen Brown * 15295b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 15395b482a8SLen Brown * Function - Start or stop 15495b482a8SLen Brown * handler_context - Address space handler context 15595b482a8SLen Brown * region_context - Region specific context 15695b482a8SLen Brown * 15795b482a8SLen Brown * RETURN: Status 15895b482a8SLen Brown * 15995b482a8SLen Brown * DESCRIPTION: Setup a PCI_Config operation region 16095b482a8SLen Brown * 16195b482a8SLen Brown * MUTEX: Assumes namespace is not locked 16295b482a8SLen Brown * 16395b482a8SLen Brown ******************************************************************************/ 16495b482a8SLen Brown 16595b482a8SLen Brown acpi_status 16695b482a8SLen Brown acpi_ev_pci_config_region_setup(acpi_handle handle, 16795b482a8SLen Brown u32 function, 16895b482a8SLen Brown void *handler_context, void **region_context) 16995b482a8SLen Brown { 17095b482a8SLen Brown acpi_status status = AE_OK; 1715df7e6cbSBob Moore u64 pci_value; 17295b482a8SLen Brown struct acpi_pci_id *pci_id = *region_context; 17395b482a8SLen Brown union acpi_operand_object *handler_obj; 17495b482a8SLen Brown struct acpi_namespace_node *parent_node; 17595b482a8SLen Brown struct acpi_namespace_node *pci_root_node; 17695b482a8SLen Brown struct acpi_namespace_node *pci_device_node; 17795b482a8SLen Brown union acpi_operand_object *region_obj = 17895b482a8SLen Brown (union acpi_operand_object *)handle; 17995b482a8SLen Brown 18095b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_pci_config_region_setup); 18195b482a8SLen Brown 18295b482a8SLen Brown handler_obj = region_obj->region.handler; 18395b482a8SLen Brown if (!handler_obj) { 18495b482a8SLen Brown /* 18595b482a8SLen Brown * No installed handler. This shouldn't happen because the dispatch 18695b482a8SLen Brown * routine checks before we get here, but we check again just in case. 18795b482a8SLen Brown */ 18895b482a8SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 18995b482a8SLen Brown "Attempting to init a region %p, with no handler\n", 19095b482a8SLen Brown region_obj)); 19195b482a8SLen Brown return_ACPI_STATUS(AE_NOT_EXIST); 19295b482a8SLen Brown } 19395b482a8SLen Brown 19495b482a8SLen Brown *region_context = NULL; 19595b482a8SLen Brown if (function == ACPI_REGION_DEACTIVATE) { 19695b482a8SLen Brown if (pci_id) { 19795b482a8SLen Brown ACPI_FREE(pci_id); 19895b482a8SLen Brown } 19995b482a8SLen Brown return_ACPI_STATUS(status); 20095b482a8SLen Brown } 20195b482a8SLen Brown 202*c45b5c09SAlexey Starikovskiy parent_node = region_obj->region.node->parent; 20395b482a8SLen Brown 20495b482a8SLen Brown /* 20595b482a8SLen Brown * Get the _SEG and _BBN values from the device upon which the handler 20695b482a8SLen Brown * is installed. 20795b482a8SLen Brown * 20895b482a8SLen Brown * We need to get the _SEG and _BBN objects relative to the PCI BUS device. 20995b482a8SLen Brown * This is the device the handler has been registered to handle. 21095b482a8SLen Brown */ 21195b482a8SLen Brown 21295b482a8SLen Brown /* 21395b482a8SLen Brown * If the address_space.Node is still pointing to the root, we need 21495b482a8SLen Brown * to scan upward for a PCI Root bridge and re-associate the op_region 21595b482a8SLen Brown * handlers with that device. 21695b482a8SLen Brown */ 21795b482a8SLen Brown if (handler_obj->address_space.node == acpi_gbl_root_node) { 21895b482a8SLen Brown 21995b482a8SLen Brown /* Start search from the parent object */ 22095b482a8SLen Brown 22195b482a8SLen Brown pci_root_node = parent_node; 22295b482a8SLen Brown while (pci_root_node != acpi_gbl_root_node) { 22395b482a8SLen Brown 22495b482a8SLen Brown /* Get the _HID/_CID in order to detect a root_bridge */ 22595b482a8SLen Brown 22695b482a8SLen Brown if (acpi_ev_is_pci_root_bridge(pci_root_node)) { 22795b482a8SLen Brown 22895b482a8SLen Brown /* Install a handler for this PCI root bridge */ 22995b482a8SLen Brown 23095b482a8SLen Brown status = 23195b482a8SLen Brown acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); 23295b482a8SLen Brown if (ACPI_FAILURE(status)) { 23395b482a8SLen Brown if (status == AE_SAME_HANDLER) { 23495b482a8SLen Brown /* 23595b482a8SLen Brown * It is OK if the handler is already installed on the 23695b482a8SLen Brown * root bridge. Still need to return a context object 23795b482a8SLen Brown * for the new PCI_Config operation region, however. 23895b482a8SLen Brown */ 23995b482a8SLen Brown status = AE_OK; 24095b482a8SLen Brown } else { 24195b482a8SLen Brown ACPI_EXCEPTION((AE_INFO, status, 242d4913dc6SBob Moore "Could not install PciConfig handler " 243d4913dc6SBob Moore "for Root Bridge %4.4s", 24495b482a8SLen Brown acpi_ut_get_node_name 24595b482a8SLen Brown (pci_root_node))); 24695b482a8SLen Brown } 24795b482a8SLen Brown } 24895b482a8SLen Brown break; 24995b482a8SLen Brown } 25095b482a8SLen Brown 251*c45b5c09SAlexey Starikovskiy pci_root_node = pci_root_node->parent; 25295b482a8SLen Brown } 25395b482a8SLen Brown 25495b482a8SLen Brown /* PCI root bridge not found, use namespace root node */ 25595b482a8SLen Brown } else { 25695b482a8SLen Brown pci_root_node = handler_obj->address_space.node; 25795b482a8SLen Brown } 25895b482a8SLen Brown 25995b482a8SLen Brown /* 26095b482a8SLen Brown * If this region is now initialized, we are done. 26195b482a8SLen Brown * (install_address_space_handler could have initialized it) 26295b482a8SLen Brown */ 26395b482a8SLen Brown if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) { 26495b482a8SLen Brown return_ACPI_STATUS(AE_OK); 26595b482a8SLen Brown } 26695b482a8SLen Brown 26795b482a8SLen Brown /* Region is still not initialized. Create a new context */ 26895b482a8SLen Brown 26995b482a8SLen Brown pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id)); 27095b482a8SLen Brown if (!pci_id) { 27195b482a8SLen Brown return_ACPI_STATUS(AE_NO_MEMORY); 27295b482a8SLen Brown } 27395b482a8SLen Brown 27495b482a8SLen Brown /* 27595b482a8SLen Brown * For PCI_Config space access, we need the segment, bus, device and 27695b482a8SLen Brown * function numbers. Acquire them here. 27795b482a8SLen Brown * 27895b482a8SLen Brown * Find the parent device object. (This allows the operation region to be 27995b482a8SLen Brown * within a subscope under the device, such as a control method.) 28095b482a8SLen Brown */ 28195b482a8SLen Brown pci_device_node = region_obj->region.node; 28295b482a8SLen Brown while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) { 283*c45b5c09SAlexey Starikovskiy pci_device_node = pci_device_node->parent; 28495b482a8SLen Brown } 28595b482a8SLen Brown 28695b482a8SLen Brown if (!pci_device_node) { 28795b482a8SLen Brown ACPI_FREE(pci_id); 28895b482a8SLen Brown return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 28995b482a8SLen Brown } 29095b482a8SLen Brown 29195b482a8SLen Brown /* 29295b482a8SLen Brown * Get the PCI device and function numbers from the _ADR object contained 29395b482a8SLen Brown * in the parent's scope. 29495b482a8SLen Brown */ 295d4913dc6SBob Moore status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, 296d4913dc6SBob Moore pci_device_node, &pci_value); 29795b482a8SLen Brown 29895b482a8SLen Brown /* 29995b482a8SLen Brown * The default is zero, and since the allocation above zeroed the data, 30095b482a8SLen Brown * just do nothing on failure. 30195b482a8SLen Brown */ 30295b482a8SLen Brown if (ACPI_SUCCESS(status)) { 30395b482a8SLen Brown pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value)); 30495b482a8SLen Brown pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value)); 30595b482a8SLen Brown } 30695b482a8SLen Brown 30795b482a8SLen Brown /* The PCI segment number comes from the _SEG method */ 30895b482a8SLen Brown 309d4913dc6SBob Moore status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, 310d4913dc6SBob Moore pci_root_node, &pci_value); 31195b482a8SLen Brown if (ACPI_SUCCESS(status)) { 31295b482a8SLen Brown pci_id->segment = ACPI_LOWORD(pci_value); 31395b482a8SLen Brown } 31495b482a8SLen Brown 31595b482a8SLen Brown /* The PCI bus number comes from the _BBN method */ 31695b482a8SLen Brown 317d4913dc6SBob Moore status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, 318d4913dc6SBob Moore pci_root_node, &pci_value); 31995b482a8SLen Brown if (ACPI_SUCCESS(status)) { 32095b482a8SLen Brown pci_id->bus = ACPI_LOWORD(pci_value); 32195b482a8SLen Brown } 32295b482a8SLen Brown 32395b482a8SLen Brown /* Complete this device's pci_id */ 32495b482a8SLen Brown 32595b482a8SLen Brown acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id); 32695b482a8SLen Brown 32795b482a8SLen Brown *region_context = pci_id; 32895b482a8SLen Brown return_ACPI_STATUS(AE_OK); 32995b482a8SLen Brown } 33095b482a8SLen Brown 33195b482a8SLen Brown /******************************************************************************* 33295b482a8SLen Brown * 33395b482a8SLen Brown * FUNCTION: acpi_ev_is_pci_root_bridge 33495b482a8SLen Brown * 33595b482a8SLen Brown * PARAMETERS: Node - Device node being examined 33695b482a8SLen Brown * 33795b482a8SLen Brown * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge 33895b482a8SLen Brown * 33995b482a8SLen Brown * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by 34095b482a8SLen Brown * examining the _HID and _CID for the device. 34195b482a8SLen Brown * 34295b482a8SLen Brown ******************************************************************************/ 34395b482a8SLen Brown 34495b482a8SLen Brown static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) 34595b482a8SLen Brown { 34695b482a8SLen Brown acpi_status status; 34715b8dd53SBob Moore struct acpica_device_id *hid; 34815b8dd53SBob Moore struct acpica_device_id_list *cid; 34995b482a8SLen Brown u32 i; 35015b8dd53SBob Moore u8 match; 35195b482a8SLen Brown 35295b482a8SLen Brown /* Get the _HID and check for a PCI Root Bridge */ 35395b482a8SLen Brown 35495b482a8SLen Brown status = acpi_ut_execute_HID(node, &hid); 35595b482a8SLen Brown if (ACPI_FAILURE(status)) { 35695b482a8SLen Brown return (FALSE); 35795b482a8SLen Brown } 35895b482a8SLen Brown 35915b8dd53SBob Moore match = acpi_ut_is_pci_root_bridge(hid->string); 36015b8dd53SBob Moore ACPI_FREE(hid); 36115b8dd53SBob Moore 36215b8dd53SBob Moore if (match) { 36395b482a8SLen Brown return (TRUE); 36495b482a8SLen Brown } 36595b482a8SLen Brown 36695b482a8SLen Brown /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ 36795b482a8SLen Brown 36895b482a8SLen Brown status = acpi_ut_execute_CID(node, &cid); 36995b482a8SLen Brown if (ACPI_FAILURE(status)) { 37095b482a8SLen Brown return (FALSE); 37195b482a8SLen Brown } 37295b482a8SLen Brown 37395b482a8SLen Brown /* Check all _CIDs in the returned list */ 37495b482a8SLen Brown 37595b482a8SLen Brown for (i = 0; i < cid->count; i++) { 37615b8dd53SBob Moore if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) { 37795b482a8SLen Brown ACPI_FREE(cid); 37895b482a8SLen Brown return (TRUE); 37995b482a8SLen Brown } 38095b482a8SLen Brown } 38195b482a8SLen Brown 38295b482a8SLen Brown ACPI_FREE(cid); 38395b482a8SLen Brown return (FALSE); 38495b482a8SLen Brown } 38595b482a8SLen Brown 38695b482a8SLen Brown /******************************************************************************* 38795b482a8SLen Brown * 38895b482a8SLen Brown * FUNCTION: acpi_ev_pci_bar_region_setup 38995b482a8SLen Brown * 39095b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 39195b482a8SLen Brown * Function - Start or stop 39295b482a8SLen Brown * handler_context - Address space handler context 39395b482a8SLen Brown * region_context - Region specific context 39495b482a8SLen Brown * 39595b482a8SLen Brown * RETURN: Status 39695b482a8SLen Brown * 39795b482a8SLen Brown * DESCRIPTION: Setup a pci_bAR operation region 39895b482a8SLen Brown * 39995b482a8SLen Brown * MUTEX: Assumes namespace is not locked 40095b482a8SLen Brown * 40195b482a8SLen Brown ******************************************************************************/ 40295b482a8SLen Brown 40395b482a8SLen Brown acpi_status 40495b482a8SLen Brown acpi_ev_pci_bar_region_setup(acpi_handle handle, 40595b482a8SLen Brown u32 function, 40695b482a8SLen Brown void *handler_context, void **region_context) 40795b482a8SLen Brown { 40895b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); 40995b482a8SLen Brown 41095b482a8SLen Brown return_ACPI_STATUS(AE_OK); 41195b482a8SLen Brown } 41295b482a8SLen Brown 41395b482a8SLen Brown /******************************************************************************* 41495b482a8SLen Brown * 41595b482a8SLen Brown * FUNCTION: acpi_ev_cmos_region_setup 41695b482a8SLen Brown * 41795b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 41895b482a8SLen Brown * Function - Start or stop 41995b482a8SLen Brown * handler_context - Address space handler context 42095b482a8SLen Brown * region_context - Region specific context 42195b482a8SLen Brown * 42295b482a8SLen Brown * RETURN: Status 42395b482a8SLen Brown * 42495b482a8SLen Brown * DESCRIPTION: Setup a CMOS operation region 42595b482a8SLen Brown * 42695b482a8SLen Brown * MUTEX: Assumes namespace is not locked 42795b482a8SLen Brown * 42895b482a8SLen Brown ******************************************************************************/ 42995b482a8SLen Brown 43095b482a8SLen Brown acpi_status 43195b482a8SLen Brown acpi_ev_cmos_region_setup(acpi_handle handle, 43295b482a8SLen Brown u32 function, 43395b482a8SLen Brown void *handler_context, void **region_context) 43495b482a8SLen Brown { 43595b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_cmos_region_setup); 43695b482a8SLen Brown 43795b482a8SLen Brown return_ACPI_STATUS(AE_OK); 43895b482a8SLen Brown } 43995b482a8SLen Brown 44095b482a8SLen Brown /******************************************************************************* 44195b482a8SLen Brown * 44295b482a8SLen Brown * FUNCTION: acpi_ev_default_region_setup 44395b482a8SLen Brown * 44495b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 44595b482a8SLen Brown * Function - Start or stop 44695b482a8SLen Brown * handler_context - Address space handler context 44795b482a8SLen Brown * region_context - Region specific context 44895b482a8SLen Brown * 44995b482a8SLen Brown * RETURN: Status 45095b482a8SLen Brown * 45195b482a8SLen Brown * DESCRIPTION: Default region initialization 45295b482a8SLen Brown * 45395b482a8SLen Brown ******************************************************************************/ 45495b482a8SLen Brown 45595b482a8SLen Brown acpi_status 45695b482a8SLen Brown acpi_ev_default_region_setup(acpi_handle handle, 45795b482a8SLen Brown u32 function, 45895b482a8SLen Brown void *handler_context, void **region_context) 45995b482a8SLen Brown { 46095b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_default_region_setup); 46195b482a8SLen Brown 46295b482a8SLen Brown if (function == ACPI_REGION_DEACTIVATE) { 46395b482a8SLen Brown *region_context = NULL; 46495b482a8SLen Brown } else { 46595b482a8SLen Brown *region_context = handler_context; 46695b482a8SLen Brown } 46795b482a8SLen Brown 46895b482a8SLen Brown return_ACPI_STATUS(AE_OK); 46995b482a8SLen Brown } 47095b482a8SLen Brown 47195b482a8SLen Brown /******************************************************************************* 47295b482a8SLen Brown * 47395b482a8SLen Brown * FUNCTION: acpi_ev_initialize_region 47495b482a8SLen Brown * 47595b482a8SLen Brown * PARAMETERS: region_obj - Region we are initializing 47695b482a8SLen Brown * acpi_ns_locked - Is namespace locked? 47795b482a8SLen Brown * 47895b482a8SLen Brown * RETURN: Status 47995b482a8SLen Brown * 48095b482a8SLen Brown * DESCRIPTION: Initializes the region, finds any _REG methods and saves them 48195b482a8SLen Brown * for execution at a later time 48295b482a8SLen Brown * 48395b482a8SLen Brown * Get the appropriate address space handler for a newly 48495b482a8SLen Brown * created region. 48595b482a8SLen Brown * 48695b482a8SLen Brown * This also performs address space specific initialization. For 48795b482a8SLen Brown * example, PCI regions must have an _ADR object that contains 48895b482a8SLen Brown * a PCI address in the scope of the definition. This address is 48995b482a8SLen Brown * required to perform an access to PCI config space. 49095b482a8SLen Brown * 49195b482a8SLen Brown * MUTEX: Interpreter should be unlocked, because we may run the _REG 49295b482a8SLen Brown * method for this region. 49395b482a8SLen Brown * 49495b482a8SLen Brown ******************************************************************************/ 49595b482a8SLen Brown 49695b482a8SLen Brown acpi_status 49795b482a8SLen Brown acpi_ev_initialize_region(union acpi_operand_object *region_obj, 49895b482a8SLen Brown u8 acpi_ns_locked) 49995b482a8SLen Brown { 50095b482a8SLen Brown union acpi_operand_object *handler_obj; 50195b482a8SLen Brown union acpi_operand_object *obj_desc; 50295b482a8SLen Brown acpi_adr_space_type space_id; 50395b482a8SLen Brown struct acpi_namespace_node *node; 50495b482a8SLen Brown acpi_status status; 50595b482a8SLen Brown struct acpi_namespace_node *method_node; 50695b482a8SLen Brown acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG; 50795b482a8SLen Brown union acpi_operand_object *region_obj2; 50895b482a8SLen Brown 50995b482a8SLen Brown ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked); 51095b482a8SLen Brown 51195b482a8SLen Brown if (!region_obj) { 51295b482a8SLen Brown return_ACPI_STATUS(AE_BAD_PARAMETER); 51395b482a8SLen Brown } 51495b482a8SLen Brown 51595b482a8SLen Brown if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { 51695b482a8SLen Brown return_ACPI_STATUS(AE_OK); 51795b482a8SLen Brown } 51895b482a8SLen Brown 51995b482a8SLen Brown region_obj2 = acpi_ns_get_secondary_object(region_obj); 52095b482a8SLen Brown if (!region_obj2) { 52195b482a8SLen Brown return_ACPI_STATUS(AE_NOT_EXIST); 52295b482a8SLen Brown } 52395b482a8SLen Brown 524*c45b5c09SAlexey Starikovskiy node = region_obj->region.node->parent; 52595b482a8SLen Brown space_id = region_obj->region.space_id; 52695b482a8SLen Brown 52795b482a8SLen Brown /* Setup defaults */ 52895b482a8SLen Brown 52995b482a8SLen Brown region_obj->region.handler = NULL; 53095b482a8SLen Brown region_obj2->extra.method_REG = NULL; 53195b482a8SLen Brown region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE); 53295b482a8SLen Brown region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; 53395b482a8SLen Brown 53495b482a8SLen Brown /* Find any "_REG" method associated with this region definition */ 53595b482a8SLen Brown 53695b482a8SLen Brown status = 53795b482a8SLen Brown acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD, 53895b482a8SLen Brown &method_node); 53995b482a8SLen Brown if (ACPI_SUCCESS(status)) { 54095b482a8SLen Brown /* 54195b482a8SLen Brown * The _REG method is optional and there can be only one per region 54295b482a8SLen Brown * definition. This will be executed when the handler is attached 54395b482a8SLen Brown * or removed 54495b482a8SLen Brown */ 54595b482a8SLen Brown region_obj2->extra.method_REG = method_node; 54695b482a8SLen Brown } 54795b482a8SLen Brown 54895b482a8SLen Brown /* 54995b482a8SLen Brown * The following loop depends upon the root Node having no parent 55095b482a8SLen Brown * ie: acpi_gbl_root_node->parent_entry being set to NULL 55195b482a8SLen Brown */ 55295b482a8SLen Brown while (node) { 55395b482a8SLen Brown 55495b482a8SLen Brown /* Check to see if a handler exists */ 55595b482a8SLen Brown 55695b482a8SLen Brown handler_obj = NULL; 55795b482a8SLen Brown obj_desc = acpi_ns_get_attached_object(node); 55895b482a8SLen Brown if (obj_desc) { 55995b482a8SLen Brown 56095b482a8SLen Brown /* Can only be a handler if the object exists */ 56195b482a8SLen Brown 56295b482a8SLen Brown switch (node->type) { 56395b482a8SLen Brown case ACPI_TYPE_DEVICE: 56495b482a8SLen Brown 56595b482a8SLen Brown handler_obj = obj_desc->device.handler; 56695b482a8SLen Brown break; 56795b482a8SLen Brown 56895b482a8SLen Brown case ACPI_TYPE_PROCESSOR: 56995b482a8SLen Brown 57095b482a8SLen Brown handler_obj = obj_desc->processor.handler; 57195b482a8SLen Brown break; 57295b482a8SLen Brown 57395b482a8SLen Brown case ACPI_TYPE_THERMAL: 57495b482a8SLen Brown 57595b482a8SLen Brown handler_obj = obj_desc->thermal_zone.handler; 57695b482a8SLen Brown break; 57795b482a8SLen Brown 578e31c32cfSLin Ming case ACPI_TYPE_METHOD: 579e31c32cfSLin Ming /* 580e31c32cfSLin Ming * If we are executing module level code, the original 581e31c32cfSLin Ming * Node's object was replaced by this Method object and we 582e31c32cfSLin Ming * saved the handler in the method object. 583e31c32cfSLin Ming * 584e31c32cfSLin Ming * See acpi_ns_exec_module_code 585e31c32cfSLin Ming */ 586e31c32cfSLin Ming if (obj_desc->method. 587e31c32cfSLin Ming flags & AOPOBJ_MODULE_LEVEL) { 588e31c32cfSLin Ming handler_obj = 589e31c32cfSLin Ming obj_desc->method.extra.handler; 590e31c32cfSLin Ming } 591e31c32cfSLin Ming break; 592e31c32cfSLin Ming 59395b482a8SLen Brown default: 59495b482a8SLen Brown /* Ignore other objects */ 59595b482a8SLen Brown break; 59695b482a8SLen Brown } 59795b482a8SLen Brown 59895b482a8SLen Brown while (handler_obj) { 59995b482a8SLen Brown 60095b482a8SLen Brown /* Is this handler of the correct type? */ 60195b482a8SLen Brown 60295b482a8SLen Brown if (handler_obj->address_space.space_id == 60395b482a8SLen Brown space_id) { 60495b482a8SLen Brown 60595b482a8SLen Brown /* Found correct handler */ 60695b482a8SLen Brown 60795b482a8SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 60895b482a8SLen Brown "Found handler %p for region %p in obj %p\n", 60995b482a8SLen Brown handler_obj, 61095b482a8SLen Brown region_obj, 61195b482a8SLen Brown obj_desc)); 61295b482a8SLen Brown 61395b482a8SLen Brown status = 61495b482a8SLen Brown acpi_ev_attach_region(handler_obj, 61595b482a8SLen Brown region_obj, 61695b482a8SLen Brown acpi_ns_locked); 61795b482a8SLen Brown 61895b482a8SLen Brown /* 619d4913dc6SBob Moore * Tell all users that this region is usable by 620d4913dc6SBob Moore * running the _REG method 62195b482a8SLen Brown */ 62295b482a8SLen Brown if (acpi_ns_locked) { 62395b482a8SLen Brown status = 62495b482a8SLen Brown acpi_ut_release_mutex 62595b482a8SLen Brown (ACPI_MTX_NAMESPACE); 62695b482a8SLen Brown if (ACPI_FAILURE(status)) { 62795b482a8SLen Brown return_ACPI_STATUS 62895b482a8SLen Brown (status); 62995b482a8SLen Brown } 63095b482a8SLen Brown } 63195b482a8SLen Brown 63295b482a8SLen Brown status = 63395b482a8SLen Brown acpi_ev_execute_reg_method 63495b482a8SLen Brown (region_obj, 1); 63595b482a8SLen Brown 63695b482a8SLen Brown if (acpi_ns_locked) { 63795b482a8SLen Brown status = 63895b482a8SLen Brown acpi_ut_acquire_mutex 63995b482a8SLen Brown (ACPI_MTX_NAMESPACE); 64095b482a8SLen Brown if (ACPI_FAILURE(status)) { 64195b482a8SLen Brown return_ACPI_STATUS 64295b482a8SLen Brown (status); 64395b482a8SLen Brown } 64495b482a8SLen Brown } 64595b482a8SLen Brown 64695b482a8SLen Brown return_ACPI_STATUS(AE_OK); 64795b482a8SLen Brown } 64895b482a8SLen Brown 64995b482a8SLen Brown /* Try next handler in the list */ 65095b482a8SLen Brown 65195b482a8SLen Brown handler_obj = handler_obj->address_space.next; 65295b482a8SLen Brown } 65395b482a8SLen Brown } 65495b482a8SLen Brown 65595b482a8SLen Brown /* This node does not have the handler we need; Pop up one level */ 65695b482a8SLen Brown 657*c45b5c09SAlexey Starikovskiy node = node->parent; 65895b482a8SLen Brown } 65995b482a8SLen Brown 66095b482a8SLen Brown /* If we get here, there is no handler for this region */ 66195b482a8SLen Brown 66295b482a8SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 66395b482a8SLen Brown "No handler for RegionType %s(%X) (RegionObj %p)\n", 66495b482a8SLen Brown acpi_ut_get_region_name(space_id), space_id, 66595b482a8SLen Brown region_obj)); 66695b482a8SLen Brown 66795b482a8SLen Brown return_ACPI_STATUS(AE_NOT_EXIST); 66895b482a8SLen Brown } 669