Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / acpi / events / evrgnini.c
blob203d1359190af2c8d52f694f506eda23d75de4bd
1 /******************************************************************************
3 * Module Name: evrgnini- ACPI address_space (op_region) init
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2006, R. Byron Moore
9 * All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
30 * NO WARRANTY
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
60 * RETURN: Status
62 * DESCRIPTION: Setup a system_memory operation region
64 ******************************************************************************/
65 acpi_status
66 acpi_ev_system_memory_region_setup(acpi_handle handle,
67 u32 function,
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 local_region_context =
79 (struct acpi_mem_space_context *)*region_context;
81 /* Delete a cached mapping if present */
83 if (local_region_context->mapped_length) {
84 acpi_os_unmap_memory(local_region_context->
85 mapped_logical_address,
86 local_region_context->
87 mapped_length);
89 ACPI_FREE(local_region_context);
90 *region_context = NULL;
92 return_ACPI_STATUS(AE_OK);
95 /* Create a new context */
97 local_region_context =
98 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
99 if (!(local_region_context)) {
100 return_ACPI_STATUS(AE_NO_MEMORY);
103 /* Save the region length and address for use in the handler */
105 local_region_context->length = region_desc->region.length;
106 local_region_context->address = region_desc->region.address;
108 *region_context = local_region_context;
109 return_ACPI_STATUS(AE_OK);
112 /*******************************************************************************
114 * FUNCTION: acpi_ev_io_space_region_setup
116 * PARAMETERS: Handle - Region we are interested in
117 * Function - Start or stop
118 * handler_context - Address space handler context
119 * region_context - Region specific context
121 * RETURN: Status
123 * DESCRIPTION: Setup a IO operation region
125 ******************************************************************************/
127 acpi_status
128 acpi_ev_io_space_region_setup(acpi_handle handle,
129 u32 function,
130 void *handler_context, void **region_context)
132 ACPI_FUNCTION_TRACE(ev_io_space_region_setup);
134 if (function == ACPI_REGION_DEACTIVATE) {
135 *region_context = NULL;
136 } else {
137 *region_context = handler_context;
140 return_ACPI_STATUS(AE_OK);
143 /*******************************************************************************
145 * FUNCTION: acpi_ev_pci_config_region_setup
147 * PARAMETERS: Handle - Region we are interested in
148 * Function - Start or stop
149 * handler_context - Address space handler context
150 * region_context - Region specific context
152 * RETURN: Status
154 * DESCRIPTION: Setup a PCI_Config operation region
156 * MUTEX: Assumes namespace is not locked
158 ******************************************************************************/
160 acpi_status
161 acpi_ev_pci_config_region_setup(acpi_handle handle,
162 u32 function,
163 void *handler_context, void **region_context)
165 acpi_status status = AE_OK;
166 acpi_integer pci_value;
167 struct acpi_pci_id *pci_id = *region_context;
168 union acpi_operand_object *handler_obj;
169 struct acpi_namespace_node *parent_node;
170 struct acpi_namespace_node *pci_root_node;
171 union acpi_operand_object *region_obj =
172 (union acpi_operand_object *)handle;
173 struct acpi_device_id object_hID;
175 ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
177 handler_obj = region_obj->region.handler;
178 if (!handler_obj) {
180 * No installed handler. This shouldn't happen because the dispatch
181 * routine checks before we get here, but we check again just in case.
183 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
184 "Attempting to init a region %p, with no handler\n",
185 region_obj));
186 return_ACPI_STATUS(AE_NOT_EXIST);
189 *region_context = NULL;
190 if (function == ACPI_REGION_DEACTIVATE) {
191 if (pci_id) {
192 ACPI_FREE(pci_id);
194 return_ACPI_STATUS(status);
197 parent_node = acpi_ns_get_parent_node(region_obj->region.node);
200 * Get the _SEG and _BBN values from the device upon which the handler
201 * is installed.
203 * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
204 * This is the device the handler has been registered to handle.
208 * If the address_space.Node is still pointing to the root, we need
209 * to scan upward for a PCI Root bridge and re-associate the op_region
210 * handlers with that device.
212 if (handler_obj->address_space.node == acpi_gbl_root_node) {
214 /* Start search from the parent object */
216 pci_root_node = parent_node;
217 while (pci_root_node != acpi_gbl_root_node) {
218 status =
219 acpi_ut_execute_HID(pci_root_node, &object_hID);
220 if (ACPI_SUCCESS(status)) {
222 * Got a valid _HID string, check if this is a PCI root.
223 * New for ACPI 3.0: check for a PCI Express root also.
225 if (!
226 (ACPI_STRNCMP
227 (object_hID.value, PCI_ROOT_HID_STRING,
228 sizeof(PCI_ROOT_HID_STRING)))
230 !(ACPI_STRNCMP
231 (object_hID.value,
232 PCI_EXPRESS_ROOT_HID_STRING,
233 sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) {
235 /* Install a handler for this PCI root bridge */
237 status =
238 acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
239 if (ACPI_FAILURE(status)) {
240 if (status == AE_SAME_HANDLER) {
242 * It is OK if the handler is already installed on the root
243 * bridge. Still need to return a context object for the
244 * new PCI_Config operation region, however.
246 status = AE_OK;
247 } else {
248 ACPI_EXCEPTION((AE_INFO,
249 status,
250 "Could not install PciConfig handler for Root Bridge %4.4s",
251 acpi_ut_get_node_name
252 (pci_root_node)));
255 break;
259 pci_root_node = acpi_ns_get_parent_node(pci_root_node);
262 /* PCI root bridge not found, use namespace root node */
263 } else {
264 pci_root_node = handler_obj->address_space.node;
268 * If this region is now initialized, we are done.
269 * (install_address_space_handler could have initialized it)
271 if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
272 return_ACPI_STATUS(AE_OK);
275 /* Region is still not initialized. Create a new context */
277 pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
278 if (!pci_id) {
279 return_ACPI_STATUS(AE_NO_MEMORY);
283 * For PCI_Config space access, we need the segment, bus,
284 * device and function numbers. Acquire them here.
288 * Get the PCI device and function numbers from the _ADR object
289 * contained in the parent's scope.
291 status =
292 acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, parent_node,
293 &pci_value);
296 * The default is zero, and since the allocation above zeroed
297 * the data, just do nothing on failure.
299 if (ACPI_SUCCESS(status)) {
300 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
301 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
304 /* The PCI segment number comes from the _SEG method */
306 status =
307 acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, pci_root_node,
308 &pci_value);
309 if (ACPI_SUCCESS(status)) {
310 pci_id->segment = ACPI_LOWORD(pci_value);
313 /* The PCI bus number comes from the _BBN method */
315 status =
316 acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, pci_root_node,
317 &pci_value);
318 if (ACPI_SUCCESS(status)) {
319 pci_id->bus = ACPI_LOWORD(pci_value);
322 /* Complete this device's pci_id */
324 acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id);
326 *region_context = pci_id;
327 return_ACPI_STATUS(AE_OK);
330 /*******************************************************************************
332 * FUNCTION: acpi_ev_pci_bar_region_setup
334 * PARAMETERS: Handle - Region we are interested in
335 * Function - Start or stop
336 * handler_context - Address space handler context
337 * region_context - Region specific context
339 * RETURN: Status
341 * DESCRIPTION: Setup a pci_bAR operation region
343 * MUTEX: Assumes namespace is not locked
345 ******************************************************************************/
347 acpi_status
348 acpi_ev_pci_bar_region_setup(acpi_handle handle,
349 u32 function,
350 void *handler_context, void **region_context)
352 ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup);
354 return_ACPI_STATUS(AE_OK);
357 /*******************************************************************************
359 * FUNCTION: acpi_ev_cmos_region_setup
361 * PARAMETERS: Handle - Region we are interested in
362 * Function - Start or stop
363 * handler_context - Address space handler context
364 * region_context - Region specific context
366 * RETURN: Status
368 * DESCRIPTION: Setup a CMOS operation region
370 * MUTEX: Assumes namespace is not locked
372 ******************************************************************************/
374 acpi_status
375 acpi_ev_cmos_region_setup(acpi_handle handle,
376 u32 function,
377 void *handler_context, void **region_context)
379 ACPI_FUNCTION_TRACE(ev_cmos_region_setup);
381 return_ACPI_STATUS(AE_OK);
384 /*******************************************************************************
386 * FUNCTION: acpi_ev_default_region_setup
388 * PARAMETERS: Handle - Region we are interested in
389 * Function - Start or stop
390 * handler_context - Address space handler context
391 * region_context - Region specific context
393 * RETURN: Status
395 * DESCRIPTION: Default region initialization
397 ******************************************************************************/
399 acpi_status
400 acpi_ev_default_region_setup(acpi_handle handle,
401 u32 function,
402 void *handler_context, void **region_context)
404 ACPI_FUNCTION_TRACE(ev_default_region_setup);
406 if (function == ACPI_REGION_DEACTIVATE) {
407 *region_context = NULL;
408 } else {
409 *region_context = handler_context;
412 return_ACPI_STATUS(AE_OK);
415 /*******************************************************************************
417 * FUNCTION: acpi_ev_initialize_region
419 * PARAMETERS: region_obj - Region we are initializing
420 * acpi_ns_locked - Is namespace locked?
422 * RETURN: Status
424 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
425 * for execution at a later time
427 * Get the appropriate address space handler for a newly
428 * created region.
430 * This also performs address space specific initialization. For
431 * example, PCI regions must have an _ADR object that contains
432 * a PCI address in the scope of the definition. This address is
433 * required to perform an access to PCI config space.
435 ******************************************************************************/
437 acpi_status
438 acpi_ev_initialize_region(union acpi_operand_object *region_obj,
439 u8 acpi_ns_locked)
441 union acpi_operand_object *handler_obj;
442 union acpi_operand_object *obj_desc;
443 acpi_adr_space_type space_id;
444 struct acpi_namespace_node *node;
445 acpi_status status;
446 struct acpi_namespace_node *method_node;
447 acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG;
448 union acpi_operand_object *region_obj2;
450 ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked);
452 if (!region_obj) {
453 return_ACPI_STATUS(AE_BAD_PARAMETER);
456 if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
457 return_ACPI_STATUS(AE_OK);
460 region_obj2 = acpi_ns_get_secondary_object(region_obj);
461 if (!region_obj2) {
462 return_ACPI_STATUS(AE_NOT_EXIST);
465 node = acpi_ns_get_parent_node(region_obj->region.node);
466 space_id = region_obj->region.space_id;
468 /* Setup defaults */
470 region_obj->region.handler = NULL;
471 region_obj2->extra.method_REG = NULL;
472 region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE);
473 region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
475 /* Find any "_REG" method associated with this region definition */
477 status =
478 acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD,
479 &method_node);
480 if (ACPI_SUCCESS(status)) {
482 * The _REG method is optional and there can be only one per region
483 * definition. This will be executed when the handler is attached
484 * or removed
486 region_obj2->extra.method_REG = method_node;
490 * The following loop depends upon the root Node having no parent
491 * ie: acpi_gbl_root_node->parent_entry being set to NULL
493 while (node) {
495 /* Check to see if a handler exists */
497 handler_obj = NULL;
498 obj_desc = acpi_ns_get_attached_object(node);
499 if (obj_desc) {
501 /* Can only be a handler if the object exists */
503 switch (node->type) {
504 case ACPI_TYPE_DEVICE:
506 handler_obj = obj_desc->device.handler;
507 break;
509 case ACPI_TYPE_PROCESSOR:
511 handler_obj = obj_desc->processor.handler;
512 break;
514 case ACPI_TYPE_THERMAL:
516 handler_obj = obj_desc->thermal_zone.handler;
517 break;
519 default:
520 /* Ignore other objects */
521 break;
524 while (handler_obj) {
526 /* Is this handler of the correct type? */
528 if (handler_obj->address_space.space_id ==
529 space_id) {
531 /* Found correct handler */
533 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
534 "Found handler %p for region %p in obj %p\n",
535 handler_obj,
536 region_obj,
537 obj_desc));
539 status =
540 acpi_ev_attach_region(handler_obj,
541 region_obj,
542 acpi_ns_locked);
545 * Tell all users that this region is usable by running the _REG
546 * method
548 if (acpi_ns_locked) {
549 status =
550 acpi_ut_release_mutex
551 (ACPI_MTX_NAMESPACE);
552 if (ACPI_FAILURE(status)) {
553 return_ACPI_STATUS
554 (status);
558 status =
559 acpi_ev_execute_reg_method
560 (region_obj, 1);
562 if (acpi_ns_locked) {
563 status =
564 acpi_ut_acquire_mutex
565 (ACPI_MTX_NAMESPACE);
566 if (ACPI_FAILURE(status)) {
567 return_ACPI_STATUS
568 (status);
572 return_ACPI_STATUS(AE_OK);
575 /* Try next handler in the list */
577 handler_obj = handler_obj->address_space.next;
582 * This node does not have the handler we need;
583 * Pop up one level
585 node = acpi_ns_get_parent_node(node);
588 /* If we get here, there is no handler for this region */
590 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
591 "No handler for RegionType %s(%X) (RegionObj %p)\n",
592 acpi_ut_get_region_name(space_id), space_id,
593 region_obj));
595 return_ACPI_STATUS(AE_NOT_EXIST);