1/****************************************************************************** 2 * 3 * Module Name: evrgnini- ACPI address_space (op_region) init 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, Intel Corp. 9 * All rights reserved. 10 * 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. 25 * 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. 29 * 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. 42 */ 43 44#include <acpi/acpi.h> 45#include "accommon.h" 46#include "acevents.h" 47#include "acnamesp.h" 48 49#define _COMPONENT ACPI_EVENTS 50ACPI_MODULE_NAME("evrgnini") 51 52/* Local prototypes */ 53static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node); 54 55/******************************************************************************* 56 * 57 * FUNCTION: acpi_ev_system_memory_region_setup 58 * 59 * PARAMETERS: Handle - Region we are interested in 60 * Function - Start or stop 61 * handler_context - Address space handler context 62 * region_context - Region specific context 63 * 64 * RETURN: Status 65 * 66 * DESCRIPTION: Setup a system_memory operation region 67 * 68 ******************************************************************************/ 69 70acpi_status 71acpi_ev_system_memory_region_setup(acpi_handle handle, 72 u32 function, 73 void *handler_context, void **region_context) 74{ 75 union acpi_operand_object *region_desc = 76 (union acpi_operand_object *)handle; 77 struct acpi_mem_space_context *local_region_context; 78 79 ACPI_FUNCTION_TRACE(ev_system_memory_region_setup); 80 81 if (function == ACPI_REGION_DEACTIVATE) { 82 if (*region_context) { 83 local_region_context = 84 (struct acpi_mem_space_context *)*region_context; 85 86 /* Delete a cached mapping if present */ 87 88 if (local_region_context->mapped_length) { 89 acpi_os_unmap_memory(local_region_context-> 90 mapped_logical_address, 91 local_region_context-> 92 mapped_length); 93 } 94 ACPI_FREE(local_region_context); 95 *region_context = NULL; 96 } 97 return_ACPI_STATUS(AE_OK); 98 } 99 100 /* Create a new context */ 101 102 local_region_context = 103 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context)); 104 if (!(local_region_context)) { 105 return_ACPI_STATUS(AE_NO_MEMORY); 106 } 107 108 /* Save the region length and address for use in the handler */ 109 110 local_region_context->length = region_desc->region.length; 111 local_region_context->address = region_desc->region.address; 112 113 *region_context = local_region_context; 114 return_ACPI_STATUS(AE_OK); 115} 116 117/******************************************************************************* 118 * 119 * FUNCTION: acpi_ev_io_space_region_setup 120 * 121 * PARAMETERS: Handle - Region we are interested in 122 * Function - Start or stop 123 * handler_context - Address space handler context 124 * region_context - Region specific context 125 * 126 * RETURN: Status 127 * 128 * DESCRIPTION: Setup a IO operation region 129 * 130 ******************************************************************************/ 131 132acpi_status 133acpi_ev_io_space_region_setup(acpi_handle handle, 134 u32 function, 135 void *handler_context, void **region_context) 136{ 137 ACPI_FUNCTION_TRACE(ev_io_space_region_setup); 138 139 if (function == ACPI_REGION_DEACTIVATE) { 140 *region_context = NULL; 141 } else { 142 *region_context = handler_context; 143 } 144 145 return_ACPI_STATUS(AE_OK); 146} 147 148/******************************************************************************* 149 * 150 * FUNCTION: acpi_ev_pci_config_region_setup 151 * 152 * PARAMETERS: Handle - Region we are interested in 153 * Function - Start or stop 154 * handler_context - Address space handler context 155 * region_context - Region specific context 156 * 157 * RETURN: Status 158 * 159 * DESCRIPTION: Setup a PCI_Config operation region 160 * 161 * MUTEX: Assumes namespace is not locked 162 * 163 ******************************************************************************/ 164 165acpi_status 166acpi_ev_pci_config_region_setup(acpi_handle handle, 167 u32 function, 168 void *handler_context, void **region_context) 169{ 170 acpi_status status = AE_OK; 171 u64 pci_value; 172 struct acpi_pci_id *pci_id = *region_context; 173 union acpi_operand_object *handler_obj; 174 struct acpi_namespace_node *parent_node; 175 struct acpi_namespace_node *pci_root_node; 176 struct acpi_namespace_node *pci_device_node; 177 union acpi_operand_object *region_obj = 178 (union acpi_operand_object *)handle; 179 180 ACPI_FUNCTION_TRACE(ev_pci_config_region_setup); 181 182 handler_obj = region_obj->region.handler; 183 if (!handler_obj) { 184 /* 185 * No installed handler. This shouldn't happen because the dispatch 186 * routine checks before we get here, but we check again just in case. 187 */ 188 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 189 "Attempting to init a region %p, with no handler\n", 190 region_obj)); 191 return_ACPI_STATUS(AE_NOT_EXIST); 192 } 193 194 *region_context = NULL; 195 if (function == ACPI_REGION_DEACTIVATE) { 196 if (pci_id) { 197 ACPI_FREE(pci_id); 198 } 199 return_ACPI_STATUS(status); 200 } 201 202 parent_node = region_obj->region.node->parent; 203 204 /* 205 * Get the _SEG and _BBN values from the device upon which the handler 206 * is installed. 207 * 208 * We need to get the _SEG and _BBN objects relative to the PCI BUS device. 209 * This is the device the handler has been registered to handle. 210 */ 211 212 /* 213 * If the address_space.Node is still pointing to the root, we need 214 * to scan upward for a PCI Root bridge and re-associate the op_region 215 * handlers with that device. 216 */ 217 if (handler_obj->address_space.node == acpi_gbl_root_node) { 218 219 /* Start search from the parent object */ 220 221 pci_root_node = parent_node; 222 while (pci_root_node != acpi_gbl_root_node) { 223 224 /* Get the _HID/_CID in order to detect a root_bridge */ 225 226 if (acpi_ev_is_pci_root_bridge(pci_root_node)) { 227 228 /* Install a handler for this PCI root bridge */ 229 230 status = 231 acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); 232 if (ACPI_FAILURE(status)) { 233 if (status == AE_SAME_HANDLER) { 234 /* 235 * It is OK if the handler is already installed on the 236 * root bridge. Still need to return a context object 237 * for the new PCI_Config operation region, however. 238 */ 239 status = AE_OK; 240 } else { 241 ACPI_EXCEPTION((AE_INFO, status, 242 "Could not install PciConfig handler " 243 "for Root Bridge %4.4s", 244 acpi_ut_get_node_name 245 (pci_root_node))); 246 } 247 } 248 break; 249 } 250 251 pci_root_node = pci_root_node->parent; 252 } 253 254 /* PCI root bridge not found, use namespace root node */ 255 } else { 256 pci_root_node = handler_obj->address_space.node; 257 } 258 259 /* 260 * If this region is now initialized, we are done. 261 * (install_address_space_handler could have initialized it) 262 */ 263 if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) { 264 return_ACPI_STATUS(AE_OK); 265 } 266 267 /* Region is still not initialized. Create a new context */ 268 269 pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id)); 270 if (!pci_id) { 271 return_ACPI_STATUS(AE_NO_MEMORY); 272 } 273 274 /* 275 * For PCI_Config space access, we need the segment, bus, device and 276 * function numbers. Acquire them here. 277 * 278 * Find the parent device object. (This allows the operation region to be 279 * within a subscope under the device, such as a control method.) 280 */ 281 pci_device_node = region_obj->region.node; 282 while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) { 283 pci_device_node = pci_device_node->parent; 284 } 285 286 if (!pci_device_node) { 287 ACPI_FREE(pci_id); 288 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 289 } 290 291 /* 292 * Get the PCI device and function numbers from the _ADR object contained 293 * in the parent's scope. 294 */ 295 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, 296 pci_device_node, &pci_value); 297 298 /* 299 * The default is zero, and since the allocation above zeroed the data, 300 * just do nothing on failure. 301 */ 302 if (ACPI_SUCCESS(status)) { 303 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value)); 304 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value)); 305 } 306 307 /* The PCI segment number comes from the _SEG method */ 308 309 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, 310 pci_root_node, &pci_value); 311 if (ACPI_SUCCESS(status)) { 312 pci_id->segment = ACPI_LOWORD(pci_value); 313 } 314 315 /* The PCI bus number comes from the _BBN method */ 316 317 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, 318 pci_root_node, &pci_value); 319 if (ACPI_SUCCESS(status)) { 320 pci_id->bus = ACPI_LOWORD(pci_value); 321 } 322 323 /* Complete this device's pci_id */ 324 325 acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id); 326 327 *region_context = pci_id; 328 return_ACPI_STATUS(AE_OK); 329} 330 331/******************************************************************************* 332 * 333 * FUNCTION: acpi_ev_is_pci_root_bridge 334 * 335 * PARAMETERS: Node - Device node being examined 336 * 337 * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge 338 * 339 * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by 340 * examining the _HID and _CID for the device. 341 * 342 ******************************************************************************/ 343 344static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) 345{ 346 acpi_status status; 347 struct acpica_device_id *hid; 348 struct acpica_device_id_list *cid; 349 u32 i; 350 u8 match; 351 352 /* Get the _HID and check for a PCI Root Bridge */ 353 354 status = acpi_ut_execute_HID(node, &hid); 355 if (ACPI_FAILURE(status)) { 356 return (FALSE); 357 } 358 359 match = acpi_ut_is_pci_root_bridge(hid->string); 360 ACPI_FREE(hid); 361 362 if (match) { 363 return (TRUE); 364 } 365 366 /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ 367 368 status = acpi_ut_execute_CID(node, &cid); 369 if (ACPI_FAILURE(status)) { 370 return (FALSE); 371 } 372 373 /* Check all _CIDs in the returned list */ 374 375 for (i = 0; i < cid->count; i++) { 376 if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) { 377 ACPI_FREE(cid); 378 return (TRUE); 379 } 380 } 381 382 ACPI_FREE(cid); 383 return (FALSE); 384} 385 386/******************************************************************************* 387 * 388 * FUNCTION: acpi_ev_pci_bar_region_setup 389 * 390 * PARAMETERS: Handle - Region we are interested in 391 * Function - Start or stop 392 * handler_context - Address space handler context 393 * region_context - Region specific context 394 * 395 * RETURN: Status 396 * 397 * DESCRIPTION: Setup a pci_bAR operation region 398 * 399 * MUTEX: Assumes namespace is not locked 400 * 401 ******************************************************************************/ 402 403acpi_status 404acpi_ev_pci_bar_region_setup(acpi_handle handle, 405 u32 function, 406 void *handler_context, void **region_context) 407{ 408 ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); 409 410 return_ACPI_STATUS(AE_OK); 411} 412 413/******************************************************************************* 414 * 415 * FUNCTION: acpi_ev_cmos_region_setup 416 * 417 * PARAMETERS: Handle - Region we are interested in 418 * Function - Start or stop 419 * handler_context - Address space handler context 420 * region_context - Region specific context 421 * 422 * RETURN: Status 423 * 424 * DESCRIPTION: Setup a CMOS operation region 425 * 426 * MUTEX: Assumes namespace is not locked 427 * 428 ******************************************************************************/ 429 430acpi_status 431acpi_ev_cmos_region_setup(acpi_handle handle, 432 u32 function, 433 void *handler_context, void **region_context) 434{ 435 ACPI_FUNCTION_TRACE(ev_cmos_region_setup); 436 437 return_ACPI_STATUS(AE_OK); 438} 439 440/******************************************************************************* 441 * 442 * FUNCTION: acpi_ev_default_region_setup 443 * 444 * PARAMETERS: Handle - Region we are interested in 445 * Function - Start or stop 446 * handler_context - Address space handler context 447 * region_context - Region specific context 448 * 449 * RETURN: Status 450 * 451 * DESCRIPTION: Default region initialization 452 * 453 ******************************************************************************/ 454 455acpi_status 456acpi_ev_default_region_setup(acpi_handle handle, 457 u32 function, 458 void *handler_context, void **region_context) 459{ 460 ACPI_FUNCTION_TRACE(ev_default_region_setup); 461 462 if (function == ACPI_REGION_DEACTIVATE) { 463 *region_context = NULL; 464 } else { 465 *region_context = handler_context; 466 } 467 468 return_ACPI_STATUS(AE_OK); 469} 470 471/******************************************************************************* 472 * 473 * FUNCTION: acpi_ev_initialize_region 474 * 475 * PARAMETERS: region_obj - Region we are initializing 476 * acpi_ns_locked - Is namespace locked? 477 * 478 * RETURN: Status 479 * 480 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them 481 * for execution at a later time 482 * 483 * Get the appropriate address space handler for a newly 484 * created region. 485 * 486 * This also performs address space specific initialization. For 487 * example, PCI regions must have an _ADR object that contains 488 * a PCI address in the scope of the definition. This address is 489 * required to perform an access to PCI config space. 490 * 491 * MUTEX: Interpreter should be unlocked, because we may run the _REG 492 * method for this region. 493 * 494 ******************************************************************************/ 495 496acpi_status 497acpi_ev_initialize_region(union acpi_operand_object *region_obj, 498 u8 acpi_ns_locked) 499{ 500 union acpi_operand_object *handler_obj; 501 union acpi_operand_object *obj_desc; 502 acpi_adr_space_type space_id; 503 struct acpi_namespace_node *node; 504 acpi_status status; 505 struct acpi_namespace_node *method_node; 506 acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG; 507 union acpi_operand_object *region_obj2; 508 509 ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked); 510 511 if (!region_obj) { 512 return_ACPI_STATUS(AE_BAD_PARAMETER); 513 } 514 515 if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { 516 return_ACPI_STATUS(AE_OK); 517 } 518 519 region_obj2 = acpi_ns_get_secondary_object(region_obj); 520 if (!region_obj2) { 521 return_ACPI_STATUS(AE_NOT_EXIST); 522 } 523 524 node = region_obj->region.node->parent; 525 space_id = region_obj->region.space_id; 526 527 /* Setup defaults */ 528 529 region_obj->region.handler = NULL; 530 region_obj2->extra.method_REG = NULL; 531 region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE); 532 region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; 533 534 /* Find any "_REG" method associated with this region definition */ 535 536 status = 537 acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD, 538 &method_node); 539 if (ACPI_SUCCESS(status)) { 540 /* 541 * The _REG method is optional and there can be only one per region 542 * definition. This will be executed when the handler is attached 543 * or removed 544 */ 545 region_obj2->extra.method_REG = method_node; 546 } 547 548 /* 549 * The following loop depends upon the root Node having no parent 550 * ie: acpi_gbl_root_node->parent_entry being set to NULL 551 */ 552 while (node) { 553 554 /* Check to see if a handler exists */ 555 556 handler_obj = NULL; 557 obj_desc = acpi_ns_get_attached_object(node); 558 if (obj_desc) { 559 560 /* Can only be a handler if the object exists */ 561 562 switch (node->type) { 563 case ACPI_TYPE_DEVICE: 564 565 handler_obj = obj_desc->device.handler; 566 break; 567 568 case ACPI_TYPE_PROCESSOR: 569 570 handler_obj = obj_desc->processor.handler; 571 break; 572 573 case ACPI_TYPE_THERMAL: 574 575 handler_obj = obj_desc->thermal_zone.handler; 576 break; 577 578 case ACPI_TYPE_METHOD: 579 /* 580 * If we are executing module level code, the original 581 * Node's object was replaced by this Method object and we 582 * saved the handler in the method object. 583 * 584 * See acpi_ns_exec_module_code 585 */ 586 if (obj_desc->method. 587 flags & AOPOBJ_MODULE_LEVEL) { 588 handler_obj = 589 obj_desc->method.extra.handler; 590 } 591 break; 592 593 default: 594 /* Ignore other objects */ 595 break; 596 } 597 598 while (handler_obj) { 599 600 /* Is this handler of the correct type? */ 601 602 if (handler_obj->address_space.space_id == 603 space_id) { 604 605 /* Found correct handler */ 606 607 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 608 "Found handler %p for region %p in obj %p\n", 609 handler_obj, 610 region_obj, 611 obj_desc)); 612 613 status = 614 acpi_ev_attach_region(handler_obj, 615 region_obj, 616 acpi_ns_locked); 617 618 /* 619 * Tell all users that this region is usable by 620 * running the _REG method 621 */ 622 if (acpi_ns_locked) { 623 status = 624 acpi_ut_release_mutex 625 (ACPI_MTX_NAMESPACE); 626 if (ACPI_FAILURE(status)) { 627 return_ACPI_STATUS 628 (status); 629 } 630 } 631 632 status = 633 acpi_ev_execute_reg_method 634 (region_obj, 1); 635 636 if (acpi_ns_locked) { 637 status = 638 acpi_ut_acquire_mutex 639 (ACPI_MTX_NAMESPACE); 640 if (ACPI_FAILURE(status)) { 641 return_ACPI_STATUS 642 (status); 643 } 644 } 645 646 return_ACPI_STATUS(AE_OK); 647 } 648 649 /* Try next handler in the list */ 650 651 handler_obj = handler_obj->address_space.next; 652 } 653 } 654 655 /* This node does not have the handler we need; Pop up one level */ 656 657 node = node->parent; 658 } 659 660 /* If we get here, there is no handler for this region */ 661 662 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 663 "No handler for RegionType %s(%X) (RegionObj %p)\n", 664 acpi_ut_get_region_name(space_id), space_id, 665 region_obj)); 666 667 return_ACPI_STATUS(AE_NOT_EXIST); 668} 669