1 /******************************************************************************
3 * Module Name: evrgnini- ACPI address_space (op_region) init
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2006, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h>
48 #define _COMPONENT ACPI_EVENTS
49 ACPI_MODULE_NAME("evrgnini")
51 /*******************************************************************************
53 * FUNCTION: acpi_ev_system_memory_region_setup
55 * PARAMETERS: Handle - Region we are interested in
56 * Function - Start or stop
57 * handler_context - Address space handler context
58 * region_context - Region specific context
62 * DESCRIPTION: Setup a system_memory operation region
64 ******************************************************************************/
66 acpi_ev_system_memory_region_setup(acpi_handle handle
,
68 void *handler_context
, void **region_context
)
70 union acpi_operand_object
*region_desc
=
71 (union acpi_operand_object
*)handle
;
72 struct acpi_mem_space_context
*local_region_context
;
74 ACPI_FUNCTION_TRACE("ev_system_memory_region_setup");
76 if (function
== ACPI_REGION_DEACTIVATE
) {
77 if (*region_context
) {
78 ACPI_MEM_FREE(*region_context
);
79 *region_context
= NULL
;
81 return_ACPI_STATUS(AE_OK
);
84 /* Create a new context */
86 local_region_context
=
87 ACPI_MEM_CALLOCATE(sizeof(struct acpi_mem_space_context
));
88 if (!(local_region_context
)) {
89 return_ACPI_STATUS(AE_NO_MEMORY
);
92 /* Save the region length and address for use in the handler */
94 local_region_context
->length
= region_desc
->region
.length
;
95 local_region_context
->address
= region_desc
->region
.address
;
97 *region_context
= local_region_context
;
98 return_ACPI_STATUS(AE_OK
);
101 /*******************************************************************************
103 * FUNCTION: acpi_ev_io_space_region_setup
105 * PARAMETERS: Handle - Region we are interested in
106 * Function - Start or stop
107 * handler_context - Address space handler context
108 * region_context - Region specific context
112 * DESCRIPTION: Setup a IO operation region
114 ******************************************************************************/
117 acpi_ev_io_space_region_setup(acpi_handle handle
,
119 void *handler_context
, void **region_context
)
121 ACPI_FUNCTION_TRACE("ev_io_space_region_setup");
123 if (function
== ACPI_REGION_DEACTIVATE
) {
124 *region_context
= NULL
;
126 *region_context
= handler_context
;
129 return_ACPI_STATUS(AE_OK
);
132 /*******************************************************************************
134 * FUNCTION: acpi_ev_pci_config_region_setup
136 * PARAMETERS: Handle - Region we are interested in
137 * Function - Start or stop
138 * handler_context - Address space handler context
139 * region_context - Region specific context
143 * DESCRIPTION: Setup a PCI_Config operation region
145 * MUTEX: Assumes namespace is not locked
147 ******************************************************************************/
150 acpi_ev_pci_config_region_setup(acpi_handle handle
,
152 void *handler_context
, void **region_context
)
154 acpi_status status
= AE_OK
;
155 acpi_integer pci_value
;
156 struct acpi_pci_id
*pci_id
= *region_context
;
157 union acpi_operand_object
*handler_obj
;
158 struct acpi_namespace_node
*parent_node
;
159 struct acpi_namespace_node
*pci_root_node
;
160 union acpi_operand_object
*region_obj
=
161 (union acpi_operand_object
*)handle
;
162 struct acpi_device_id object_hID
;
164 ACPI_FUNCTION_TRACE("ev_pci_config_region_setup");
166 handler_obj
= region_obj
->region
.handler
;
169 * No installed handler. This shouldn't happen because the dispatch
170 * routine checks before we get here, but we check again just in case.
172 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION
,
173 "Attempting to init a region %p, with no handler\n",
175 return_ACPI_STATUS(AE_NOT_EXIST
);
178 *region_context
= NULL
;
179 if (function
== ACPI_REGION_DEACTIVATE
) {
181 ACPI_MEM_FREE(pci_id
);
183 return_ACPI_STATUS(status
);
186 parent_node
= acpi_ns_get_parent_node(region_obj
->region
.node
);
189 * Get the _SEG and _BBN values from the device upon which the handler
192 * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
193 * This is the device the handler has been registered to handle.
197 * If the address_space.Node is still pointing to the root, we need
198 * to scan upward for a PCI Root bridge and re-associate the op_region
199 * handlers with that device.
201 if (handler_obj
->address_space
.node
== acpi_gbl_root_node
) {
203 /* Start search from the parent object */
205 pci_root_node
= parent_node
;
206 while (pci_root_node
!= acpi_gbl_root_node
) {
208 acpi_ut_execute_HID(pci_root_node
, &object_hID
);
209 if (ACPI_SUCCESS(status
)) {
211 * Got a valid _HID string, check if this is a PCI root.
212 * New for ACPI 3.0: check for a PCI Express root also.
216 (object_hID
.value
, PCI_ROOT_HID_STRING
,
217 sizeof(PCI_ROOT_HID_STRING
))
221 PCI_EXPRESS_ROOT_HID_STRING
,
222 sizeof(PCI_EXPRESS_ROOT_HID_STRING
)))))
225 /* Install a handler for this PCI root bridge */
228 acpi_install_address_space_handler((acpi_handle
) pci_root_node
, ACPI_ADR_SPACE_PCI_CONFIG
, ACPI_DEFAULT_HANDLER
, NULL
, NULL
);
229 if (ACPI_FAILURE(status
)) {
230 if (status
== AE_SAME_HANDLER
) {
232 * It is OK if the handler is already installed on the root
233 * bridge. Still need to return a context object for the
234 * new PCI_Config operation region, however.
238 ACPI_EXCEPTION((AE_INFO
,
240 "Could not install pci_config handler for Root Bridge %4.4s",
241 acpi_ut_get_node_name
249 pci_root_node
= acpi_ns_get_parent_node(pci_root_node
);
252 /* PCI root bridge not found, use namespace root node */
254 pci_root_node
= handler_obj
->address_space
.node
;
258 * If this region is now initialized, we are done.
259 * (install_address_space_handler could have initialized it)
261 if (region_obj
->region
.flags
& AOPOBJ_SETUP_COMPLETE
) {
262 return_ACPI_STATUS(AE_OK
);
265 /* Region is still not initialized. Create a new context */
267 pci_id
= ACPI_MEM_CALLOCATE(sizeof(struct acpi_pci_id
));
269 return_ACPI_STATUS(AE_NO_MEMORY
);
273 * For PCI_Config space access, we need the segment, bus,
274 * device and function numbers. Acquire them here.
278 * Get the PCI device and function numbers from the _ADR object
279 * contained in the parent's scope.
282 acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR
, parent_node
,
286 * The default is zero, and since the allocation above zeroed
287 * the data, just do nothing on failure.
289 if (ACPI_SUCCESS(status
)) {
290 pci_id
->device
= ACPI_HIWORD(ACPI_LODWORD(pci_value
));
291 pci_id
->function
= ACPI_LOWORD(ACPI_LODWORD(pci_value
));
294 /* The PCI segment number comes from the _SEG method */
297 acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG
, pci_root_node
,
299 if (ACPI_SUCCESS(status
)) {
300 pci_id
->segment
= ACPI_LOWORD(pci_value
);
303 /* The PCI bus number comes from the _BBN method */
306 acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN
, pci_root_node
,
308 if (ACPI_SUCCESS(status
)) {
309 pci_id
->bus
= ACPI_LOWORD(pci_value
);
312 /* Complete this device's pci_id */
314 acpi_os_derive_pci_id(pci_root_node
, region_obj
->region
.node
, &pci_id
);
316 *region_context
= pci_id
;
317 return_ACPI_STATUS(AE_OK
);
320 /*******************************************************************************
322 * FUNCTION: acpi_ev_pci_bar_region_setup
324 * PARAMETERS: Handle - Region we are interested in
325 * Function - Start or stop
326 * handler_context - Address space handler context
327 * region_context - Region specific context
331 * DESCRIPTION: Setup a pci_bAR operation region
333 * MUTEX: Assumes namespace is not locked
335 ******************************************************************************/
338 acpi_ev_pci_bar_region_setup(acpi_handle handle
,
340 void *handler_context
, void **region_context
)
342 ACPI_FUNCTION_TRACE("ev_pci_bar_region_setup");
344 return_ACPI_STATUS(AE_OK
);
347 /*******************************************************************************
349 * FUNCTION: acpi_ev_cmos_region_setup
351 * PARAMETERS: Handle - Region we are interested in
352 * Function - Start or stop
353 * handler_context - Address space handler context
354 * region_context - Region specific context
358 * DESCRIPTION: Setup a CMOS operation region
360 * MUTEX: Assumes namespace is not locked
362 ******************************************************************************/
365 acpi_ev_cmos_region_setup(acpi_handle handle
,
367 void *handler_context
, void **region_context
)
369 ACPI_FUNCTION_TRACE("ev_cmos_region_setup");
371 return_ACPI_STATUS(AE_OK
);
374 /*******************************************************************************
376 * FUNCTION: acpi_ev_default_region_setup
378 * PARAMETERS: Handle - Region we are interested in
379 * Function - Start or stop
380 * handler_context - Address space handler context
381 * region_context - Region specific context
385 * DESCRIPTION: Default region initialization
387 ******************************************************************************/
390 acpi_ev_default_region_setup(acpi_handle handle
,
392 void *handler_context
, void **region_context
)
394 ACPI_FUNCTION_TRACE("ev_default_region_setup");
396 if (function
== ACPI_REGION_DEACTIVATE
) {
397 *region_context
= NULL
;
399 *region_context
= handler_context
;
402 return_ACPI_STATUS(AE_OK
);
405 /*******************************************************************************
407 * FUNCTION: acpi_ev_initialize_region
409 * PARAMETERS: region_obj - Region we are initializing
410 * acpi_ns_locked - Is namespace locked?
414 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
415 * for execution at a later time
417 * Get the appropriate address space handler for a newly
420 * This also performs address space specific initialization. For
421 * example, PCI regions must have an _ADR object that contains
422 * a PCI address in the scope of the definition. This address is
423 * required to perform an access to PCI config space.
425 ******************************************************************************/
428 acpi_ev_initialize_region(union acpi_operand_object
*region_obj
,
431 union acpi_operand_object
*handler_obj
;
432 union acpi_operand_object
*obj_desc
;
433 acpi_adr_space_type space_id
;
434 struct acpi_namespace_node
*node
;
436 struct acpi_namespace_node
*method_node
;
437 acpi_name
*reg_name_ptr
= (acpi_name
*) METHOD_NAME__REG
;
438 union acpi_operand_object
*region_obj2
;
440 ACPI_FUNCTION_TRACE_U32("ev_initialize_region", acpi_ns_locked
);
443 return_ACPI_STATUS(AE_BAD_PARAMETER
);
446 if (region_obj
->common
.flags
& AOPOBJ_OBJECT_INITIALIZED
) {
447 return_ACPI_STATUS(AE_OK
);
450 region_obj2
= acpi_ns_get_secondary_object(region_obj
);
452 return_ACPI_STATUS(AE_NOT_EXIST
);
455 node
= acpi_ns_get_parent_node(region_obj
->region
.node
);
456 space_id
= region_obj
->region
.space_id
;
460 region_obj
->region
.handler
= NULL
;
461 region_obj2
->extra
.method_REG
= NULL
;
462 region_obj
->common
.flags
&= ~(AOPOBJ_SETUP_COMPLETE
);
463 region_obj
->common
.flags
|= AOPOBJ_OBJECT_INITIALIZED
;
465 /* Find any "_REG" method associated with this region definition */
467 status
= acpi_ns_search_node(*reg_name_ptr
, node
,
468 ACPI_TYPE_METHOD
, &method_node
);
469 if (ACPI_SUCCESS(status
)) {
471 * The _REG method is optional and there can be only one per region
472 * definition. This will be executed when the handler is attached
475 region_obj2
->extra
.method_REG
= method_node
;
479 * The following loop depends upon the root Node having no parent
480 * ie: acpi_gbl_root_node->parent_entry being set to NULL
484 /* Check to see if a handler exists */
487 obj_desc
= acpi_ns_get_attached_object(node
);
490 /* Can only be a handler if the object exists */
492 switch (node
->type
) {
493 case ACPI_TYPE_DEVICE
:
495 handler_obj
= obj_desc
->device
.handler
;
498 case ACPI_TYPE_PROCESSOR
:
500 handler_obj
= obj_desc
->processor
.handler
;
503 case ACPI_TYPE_THERMAL
:
505 handler_obj
= obj_desc
->thermal_zone
.handler
;
509 /* Ignore other objects */
513 while (handler_obj
) {
515 /* Is this handler of the correct type? */
517 if (handler_obj
->address_space
.space_id
==
520 /* Found correct handler */
522 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION
,
523 "Found handler %p for region %p in obj %p\n",
529 acpi_ev_attach_region(handler_obj
,
534 * Tell all users that this region is usable by running the _REG
537 if (acpi_ns_locked
) {
539 acpi_ut_release_mutex
540 (ACPI_MTX_NAMESPACE
);
541 if (ACPI_FAILURE(status
)) {
548 acpi_ev_execute_reg_method
551 if (acpi_ns_locked
) {
553 acpi_ut_acquire_mutex
554 (ACPI_MTX_NAMESPACE
);
555 if (ACPI_FAILURE(status
)) {
561 return_ACPI_STATUS(AE_OK
);
564 /* Try next handler in the list */
566 handler_obj
= handler_obj
->address_space
.next
;
571 * This node does not have the handler we need;
574 node
= acpi_ns_get_parent_node(node
);
577 /* If we get here, there is no handler for this region */
579 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION
,
580 "No handler for region_type %s(%X) (region_obj %p)\n",
581 acpi_ut_get_region_name(space_id
), space_id
,
584 return_ACPI_STATUS(AE_NOT_EXIST
);