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 202c45b5c09SAlexey 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 251c45b5c09SAlexey 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)) { 283c45b5c09SAlexey 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 /* 29295abccb5SBob Moore * Get the PCI device and function numbers from the _ADR object 29395abccb5SBob Moore * contained 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 32395abccb5SBob Moore /* Complete/update the PCI ID for this device */ 32495b482a8SLen Brown 32595abccb5SBob Moore status = 32695abccb5SBob Moore acpi_hw_derive_pci_id(pci_id, pci_root_node, 32795abccb5SBob Moore region_obj->region.node); 32895abccb5SBob Moore if (ACPI_FAILURE(status)) { 32995abccb5SBob Moore ACPI_FREE(pci_id); 33095abccb5SBob Moore return_ACPI_STATUS(status); 33195abccb5SBob Moore } 33295b482a8SLen Brown 33395b482a8SLen Brown *region_context = pci_id; 33495b482a8SLen Brown return_ACPI_STATUS(AE_OK); 33595b482a8SLen Brown } 33695b482a8SLen Brown 33795b482a8SLen Brown /******************************************************************************* 33895b482a8SLen Brown * 33995b482a8SLen Brown * FUNCTION: acpi_ev_is_pci_root_bridge 34095b482a8SLen Brown * 34195b482a8SLen Brown * PARAMETERS: Node - Device node being examined 34295b482a8SLen Brown * 34395b482a8SLen Brown * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge 34495b482a8SLen Brown * 34595b482a8SLen Brown * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by 34695b482a8SLen Brown * examining the _HID and _CID for the device. 34795b482a8SLen Brown * 34895b482a8SLen Brown ******************************************************************************/ 34995b482a8SLen Brown 35095b482a8SLen Brown static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) 35195b482a8SLen Brown { 35295b482a8SLen Brown acpi_status status; 35315b8dd53SBob Moore struct acpica_device_id *hid; 35415b8dd53SBob Moore struct acpica_device_id_list *cid; 35595b482a8SLen Brown u32 i; 35615b8dd53SBob Moore u8 match; 35795b482a8SLen Brown 35895b482a8SLen Brown /* Get the _HID and check for a PCI Root Bridge */ 35995b482a8SLen Brown 36095b482a8SLen Brown status = acpi_ut_execute_HID(node, &hid); 36195b482a8SLen Brown if (ACPI_FAILURE(status)) { 36295b482a8SLen Brown return (FALSE); 36395b482a8SLen Brown } 36495b482a8SLen Brown 36515b8dd53SBob Moore match = acpi_ut_is_pci_root_bridge(hid->string); 36615b8dd53SBob Moore ACPI_FREE(hid); 36715b8dd53SBob Moore 36815b8dd53SBob Moore if (match) { 36995b482a8SLen Brown return (TRUE); 37095b482a8SLen Brown } 37195b482a8SLen Brown 37295b482a8SLen Brown /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ 37395b482a8SLen Brown 37495b482a8SLen Brown status = acpi_ut_execute_CID(node, &cid); 37595b482a8SLen Brown if (ACPI_FAILURE(status)) { 37695b482a8SLen Brown return (FALSE); 37795b482a8SLen Brown } 37895b482a8SLen Brown 37995b482a8SLen Brown /* Check all _CIDs in the returned list */ 38095b482a8SLen Brown 38195b482a8SLen Brown for (i = 0; i < cid->count; i++) { 38215b8dd53SBob Moore if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) { 38395b482a8SLen Brown ACPI_FREE(cid); 38495b482a8SLen Brown return (TRUE); 38595b482a8SLen Brown } 38695b482a8SLen Brown } 38795b482a8SLen Brown 38895b482a8SLen Brown ACPI_FREE(cid); 38995b482a8SLen Brown return (FALSE); 39095b482a8SLen Brown } 39195b482a8SLen Brown 39295b482a8SLen Brown /******************************************************************************* 39395b482a8SLen Brown * 39495b482a8SLen Brown * FUNCTION: acpi_ev_pci_bar_region_setup 39595b482a8SLen Brown * 39695b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 39795b482a8SLen Brown * Function - Start or stop 39895b482a8SLen Brown * handler_context - Address space handler context 39995b482a8SLen Brown * region_context - Region specific context 40095b482a8SLen Brown * 40195b482a8SLen Brown * RETURN: Status 40295b482a8SLen Brown * 40395b482a8SLen Brown * DESCRIPTION: Setup a pci_bAR operation region 40495b482a8SLen Brown * 40595b482a8SLen Brown * MUTEX: Assumes namespace is not locked 40695b482a8SLen Brown * 40795b482a8SLen Brown ******************************************************************************/ 40895b482a8SLen Brown 40995b482a8SLen Brown acpi_status 41095b482a8SLen Brown acpi_ev_pci_bar_region_setup(acpi_handle handle, 41195b482a8SLen Brown u32 function, 41295b482a8SLen Brown void *handler_context, void **region_context) 41395b482a8SLen Brown { 41495b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); 41595b482a8SLen Brown 41695b482a8SLen Brown return_ACPI_STATUS(AE_OK); 41795b482a8SLen Brown } 41895b482a8SLen Brown 41995b482a8SLen Brown /******************************************************************************* 42095b482a8SLen Brown * 42195b482a8SLen Brown * FUNCTION: acpi_ev_cmos_region_setup 42295b482a8SLen Brown * 42395b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 42495b482a8SLen Brown * Function - Start or stop 42595b482a8SLen Brown * handler_context - Address space handler context 42695b482a8SLen Brown * region_context - Region specific context 42795b482a8SLen Brown * 42895b482a8SLen Brown * RETURN: Status 42995b482a8SLen Brown * 43095b482a8SLen Brown * DESCRIPTION: Setup a CMOS operation region 43195b482a8SLen Brown * 43295b482a8SLen Brown * MUTEX: Assumes namespace is not locked 43395b482a8SLen Brown * 43495b482a8SLen Brown ******************************************************************************/ 43595b482a8SLen Brown 43695b482a8SLen Brown acpi_status 43795b482a8SLen Brown acpi_ev_cmos_region_setup(acpi_handle handle, 43895b482a8SLen Brown u32 function, 43995b482a8SLen Brown void *handler_context, void **region_context) 44095b482a8SLen Brown { 44195b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_cmos_region_setup); 44295b482a8SLen Brown 44395b482a8SLen Brown return_ACPI_STATUS(AE_OK); 44495b482a8SLen Brown } 44595b482a8SLen Brown 44695b482a8SLen Brown /******************************************************************************* 44795b482a8SLen Brown * 44895b482a8SLen Brown * FUNCTION: acpi_ev_default_region_setup 44995b482a8SLen Brown * 45095b482a8SLen Brown * PARAMETERS: Handle - Region we are interested in 45195b482a8SLen Brown * Function - Start or stop 45295b482a8SLen Brown * handler_context - Address space handler context 45395b482a8SLen Brown * region_context - Region specific context 45495b482a8SLen Brown * 45595b482a8SLen Brown * RETURN: Status 45695b482a8SLen Brown * 45795b482a8SLen Brown * DESCRIPTION: Default region initialization 45895b482a8SLen Brown * 45995b482a8SLen Brown ******************************************************************************/ 46095b482a8SLen Brown 46195b482a8SLen Brown acpi_status 46295b482a8SLen Brown acpi_ev_default_region_setup(acpi_handle handle, 46395b482a8SLen Brown u32 function, 46495b482a8SLen Brown void *handler_context, void **region_context) 46595b482a8SLen Brown { 46695b482a8SLen Brown ACPI_FUNCTION_TRACE(ev_default_region_setup); 46795b482a8SLen Brown 46895b482a8SLen Brown if (function == ACPI_REGION_DEACTIVATE) { 46995b482a8SLen Brown *region_context = NULL; 47095b482a8SLen Brown } else { 47195b482a8SLen Brown *region_context = handler_context; 47295b482a8SLen Brown } 47395b482a8SLen Brown 47495b482a8SLen Brown return_ACPI_STATUS(AE_OK); 47595b482a8SLen Brown } 47695b482a8SLen Brown 47795b482a8SLen Brown /******************************************************************************* 47895b482a8SLen Brown * 47995b482a8SLen Brown * FUNCTION: acpi_ev_initialize_region 48095b482a8SLen Brown * 48195b482a8SLen Brown * PARAMETERS: region_obj - Region we are initializing 48295b482a8SLen Brown * acpi_ns_locked - Is namespace locked? 48395b482a8SLen Brown * 48495b482a8SLen Brown * RETURN: Status 48595b482a8SLen Brown * 48695b482a8SLen Brown * DESCRIPTION: Initializes the region, finds any _REG methods and saves them 48795b482a8SLen Brown * for execution at a later time 48895b482a8SLen Brown * 48995b482a8SLen Brown * Get the appropriate address space handler for a newly 49095b482a8SLen Brown * created region. 49195b482a8SLen Brown * 49295b482a8SLen Brown * This also performs address space specific initialization. For 49395b482a8SLen Brown * example, PCI regions must have an _ADR object that contains 49495b482a8SLen Brown * a PCI address in the scope of the definition. This address is 49595b482a8SLen Brown * required to perform an access to PCI config space. 49695b482a8SLen Brown * 49795b482a8SLen Brown * MUTEX: Interpreter should be unlocked, because we may run the _REG 49895b482a8SLen Brown * method for this region. 49995b482a8SLen Brown * 50095b482a8SLen Brown ******************************************************************************/ 50195b482a8SLen Brown 50295b482a8SLen Brown acpi_status 50395b482a8SLen Brown acpi_ev_initialize_region(union acpi_operand_object *region_obj, 50495b482a8SLen Brown u8 acpi_ns_locked) 50595b482a8SLen Brown { 50695b482a8SLen Brown union acpi_operand_object *handler_obj; 50795b482a8SLen Brown union acpi_operand_object *obj_desc; 50895b482a8SLen Brown acpi_adr_space_type space_id; 50995b482a8SLen Brown struct acpi_namespace_node *node; 51095b482a8SLen Brown acpi_status status; 51195b482a8SLen Brown struct acpi_namespace_node *method_node; 51295b482a8SLen Brown acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG; 51395b482a8SLen Brown union acpi_operand_object *region_obj2; 51495b482a8SLen Brown 51595b482a8SLen Brown ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked); 51695b482a8SLen Brown 51795b482a8SLen Brown if (!region_obj) { 51895b482a8SLen Brown return_ACPI_STATUS(AE_BAD_PARAMETER); 51995b482a8SLen Brown } 52095b482a8SLen Brown 52195b482a8SLen Brown if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { 52295b482a8SLen Brown return_ACPI_STATUS(AE_OK); 52395b482a8SLen Brown } 52495b482a8SLen Brown 52595b482a8SLen Brown region_obj2 = acpi_ns_get_secondary_object(region_obj); 52695b482a8SLen Brown if (!region_obj2) { 52795b482a8SLen Brown return_ACPI_STATUS(AE_NOT_EXIST); 52895b482a8SLen Brown } 52995b482a8SLen Brown 530c45b5c09SAlexey Starikovskiy node = region_obj->region.node->parent; 53195b482a8SLen Brown space_id = region_obj->region.space_id; 53295b482a8SLen Brown 53395b482a8SLen Brown /* Setup defaults */ 53495b482a8SLen Brown 53595b482a8SLen Brown region_obj->region.handler = NULL; 53695b482a8SLen Brown region_obj2->extra.method_REG = NULL; 53795b482a8SLen Brown region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE); 53895b482a8SLen Brown region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; 53995b482a8SLen Brown 54095b482a8SLen Brown /* Find any "_REG" method associated with this region definition */ 54195b482a8SLen Brown 54295b482a8SLen Brown status = 54395b482a8SLen Brown acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD, 54495b482a8SLen Brown &method_node); 54595b482a8SLen Brown if (ACPI_SUCCESS(status)) { 54695b482a8SLen Brown /* 54795b482a8SLen Brown * The _REG method is optional and there can be only one per region 54895b482a8SLen Brown * definition. This will be executed when the handler is attached 54995b482a8SLen Brown * or removed 55095b482a8SLen Brown */ 55195b482a8SLen Brown region_obj2->extra.method_REG = method_node; 55295b482a8SLen Brown } 55395b482a8SLen Brown 55495b482a8SLen Brown /* 55595b482a8SLen Brown * The following loop depends upon the root Node having no parent 55695b482a8SLen Brown * ie: acpi_gbl_root_node->parent_entry being set to NULL 55795b482a8SLen Brown */ 55895b482a8SLen Brown while (node) { 55995b482a8SLen Brown 56095b482a8SLen Brown /* Check to see if a handler exists */ 56195b482a8SLen Brown 56295b482a8SLen Brown handler_obj = NULL; 56395b482a8SLen Brown obj_desc = acpi_ns_get_attached_object(node); 56495b482a8SLen Brown if (obj_desc) { 56595b482a8SLen Brown 56695b482a8SLen Brown /* Can only be a handler if the object exists */ 56795b482a8SLen Brown 56895b482a8SLen Brown switch (node->type) { 56995b482a8SLen Brown case ACPI_TYPE_DEVICE: 57095b482a8SLen Brown 57195b482a8SLen Brown handler_obj = obj_desc->device.handler; 57295b482a8SLen Brown break; 57395b482a8SLen Brown 57495b482a8SLen Brown case ACPI_TYPE_PROCESSOR: 57595b482a8SLen Brown 57695b482a8SLen Brown handler_obj = obj_desc->processor.handler; 57795b482a8SLen Brown break; 57895b482a8SLen Brown 57995b482a8SLen Brown case ACPI_TYPE_THERMAL: 58095b482a8SLen Brown 58195b482a8SLen Brown handler_obj = obj_desc->thermal_zone.handler; 58295b482a8SLen Brown break; 58395b482a8SLen Brown 584e31c32cfSLin Ming case ACPI_TYPE_METHOD: 585e31c32cfSLin Ming /* 586e31c32cfSLin Ming * If we are executing module level code, the original 587e31c32cfSLin Ming * Node's object was replaced by this Method object and we 588e31c32cfSLin Ming * saved the handler in the method object. 589e31c32cfSLin Ming * 590e31c32cfSLin Ming * See acpi_ns_exec_module_code 591e31c32cfSLin Ming */ 592e31c32cfSLin Ming if (obj_desc->method. 593*26294842SLin Ming info_flags & ACPI_METHOD_MODULE_LEVEL) { 594e31c32cfSLin Ming handler_obj = 595*26294842SLin Ming obj_desc->method.dispatch.handler; 596e31c32cfSLin Ming } 597e31c32cfSLin Ming break; 598e31c32cfSLin Ming 59995b482a8SLen Brown default: 60095b482a8SLen Brown /* Ignore other objects */ 60195b482a8SLen Brown break; 60295b482a8SLen Brown } 60395b482a8SLen Brown 60495b482a8SLen Brown while (handler_obj) { 60595b482a8SLen Brown 60695b482a8SLen Brown /* Is this handler of the correct type? */ 60795b482a8SLen Brown 60895b482a8SLen Brown if (handler_obj->address_space.space_id == 60995b482a8SLen Brown space_id) { 61095b482a8SLen Brown 61195b482a8SLen Brown /* Found correct handler */ 61295b482a8SLen Brown 61395b482a8SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 61495b482a8SLen Brown "Found handler %p for region %p in obj %p\n", 61595b482a8SLen Brown handler_obj, 61695b482a8SLen Brown region_obj, 61795b482a8SLen Brown obj_desc)); 61895b482a8SLen Brown 61995b482a8SLen Brown status = 62095b482a8SLen Brown acpi_ev_attach_region(handler_obj, 62195b482a8SLen Brown region_obj, 62295b482a8SLen Brown acpi_ns_locked); 62395b482a8SLen Brown 62495b482a8SLen Brown /* 625d4913dc6SBob Moore * Tell all users that this region is usable by 626d4913dc6SBob Moore * running the _REG method 62795b482a8SLen Brown */ 62895b482a8SLen Brown if (acpi_ns_locked) { 62995b482a8SLen Brown status = 63095b482a8SLen Brown acpi_ut_release_mutex 63195b482a8SLen Brown (ACPI_MTX_NAMESPACE); 63295b482a8SLen Brown if (ACPI_FAILURE(status)) { 63395b482a8SLen Brown return_ACPI_STATUS 63495b482a8SLen Brown (status); 63595b482a8SLen Brown } 63695b482a8SLen Brown } 63795b482a8SLen Brown 63895b482a8SLen Brown status = 63995b482a8SLen Brown acpi_ev_execute_reg_method 64095b482a8SLen Brown (region_obj, 1); 64195b482a8SLen Brown 64295b482a8SLen Brown if (acpi_ns_locked) { 64395b482a8SLen Brown status = 64495b482a8SLen Brown acpi_ut_acquire_mutex 64595b482a8SLen Brown (ACPI_MTX_NAMESPACE); 64695b482a8SLen Brown if (ACPI_FAILURE(status)) { 64795b482a8SLen Brown return_ACPI_STATUS 64895b482a8SLen Brown (status); 64995b482a8SLen Brown } 65095b482a8SLen Brown } 65195b482a8SLen Brown 65295b482a8SLen Brown return_ACPI_STATUS(AE_OK); 65395b482a8SLen Brown } 65495b482a8SLen Brown 65595b482a8SLen Brown /* Try next handler in the list */ 65695b482a8SLen Brown 65795b482a8SLen Brown handler_obj = handler_obj->address_space.next; 65895b482a8SLen Brown } 65995b482a8SLen Brown } 66095b482a8SLen Brown 66195b482a8SLen Brown /* This node does not have the handler we need; Pop up one level */ 66295b482a8SLen Brown 663c45b5c09SAlexey Starikovskiy node = node->parent; 66495b482a8SLen Brown } 66595b482a8SLen Brown 66695b482a8SLen Brown /* If we get here, there is no handler for this region */ 66795b482a8SLen Brown 66895b482a8SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 66995b482a8SLen Brown "No handler for RegionType %s(%X) (RegionObj %p)\n", 67095b482a8SLen Brown acpi_ut_get_region_name(space_id), space_id, 67195b482a8SLen Brown region_obj)); 67295b482a8SLen Brown 67395b482a8SLen Brown return_ACPI_STATUS(AE_NOT_EXIST); 67495b482a8SLen Brown } 675