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