1 /****************************************************************************** 2 * 3 * Module Name: evrgnini- ACPI address_space (op_region) init 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2017, 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 #include "acinterp.h" 49 50 #define _COMPONENT ACPI_EVENTS 51 ACPI_MODULE_NAME("evrgnini") 52 53 /* Local prototypes */ 54 static 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 71 acpi_status 72 acpi_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 133 acpi_status 134 acpi_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 166 acpi_status 167 acpi_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 u64 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 = region_obj->region.node->parent; 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 = 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 293 * contained 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/update the PCI ID for this device */ 324 325 status = 326 acpi_hw_derive_pci_id(pci_id, pci_root_node, 327 region_obj->region.node); 328 if (ACPI_FAILURE(status)) { 329 ACPI_FREE(pci_id); 330 return_ACPI_STATUS(status); 331 } 332 333 *region_context = pci_id; 334 return_ACPI_STATUS(AE_OK); 335 } 336 337 /******************************************************************************* 338 * 339 * FUNCTION: acpi_ev_is_pci_root_bridge 340 * 341 * PARAMETERS: node - Device node being examined 342 * 343 * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge 344 * 345 * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by 346 * examining the _HID and _CID for the device. 347 * 348 ******************************************************************************/ 349 350 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) 351 { 352 acpi_status status; 353 struct acpi_pnp_device_id *hid; 354 struct acpi_pnp_device_id_list *cid; 355 u32 i; 356 u8 match; 357 358 /* Get the _HID and check for a PCI Root Bridge */ 359 360 status = acpi_ut_execute_HID(node, &hid); 361 if (ACPI_FAILURE(status)) { 362 return (FALSE); 363 } 364 365 match = acpi_ut_is_pci_root_bridge(hid->string); 366 ACPI_FREE(hid); 367 368 if (match) { 369 return (TRUE); 370 } 371 372 /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ 373 374 status = acpi_ut_execute_CID(node, &cid); 375 if (ACPI_FAILURE(status)) { 376 return (FALSE); 377 } 378 379 /* Check all _CIDs in the returned list */ 380 381 for (i = 0; i < cid->count; i++) { 382 if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) { 383 ACPI_FREE(cid); 384 return (TRUE); 385 } 386 } 387 388 ACPI_FREE(cid); 389 return (FALSE); 390 } 391 392 /******************************************************************************* 393 * 394 * FUNCTION: acpi_ev_pci_bar_region_setup 395 * 396 * PARAMETERS: handle - Region we are interested in 397 * function - Start or stop 398 * handler_context - Address space handler context 399 * region_context - Region specific context 400 * 401 * RETURN: Status 402 * 403 * DESCRIPTION: Setup a pci_BAR operation region 404 * 405 * MUTEX: Assumes namespace is not locked 406 * 407 ******************************************************************************/ 408 409 acpi_status 410 acpi_ev_pci_bar_region_setup(acpi_handle handle, 411 u32 function, 412 void *handler_context, void **region_context) 413 { 414 ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); 415 416 return_ACPI_STATUS(AE_OK); 417 } 418 419 /******************************************************************************* 420 * 421 * FUNCTION: acpi_ev_cmos_region_setup 422 * 423 * PARAMETERS: handle - Region we are interested in 424 * function - Start or stop 425 * handler_context - Address space handler context 426 * region_context - Region specific context 427 * 428 * RETURN: Status 429 * 430 * DESCRIPTION: Setup a CMOS operation region 431 * 432 * MUTEX: Assumes namespace is not locked 433 * 434 ******************************************************************************/ 435 436 acpi_status 437 acpi_ev_cmos_region_setup(acpi_handle handle, 438 u32 function, 439 void *handler_context, void **region_context) 440 { 441 ACPI_FUNCTION_TRACE(ev_cmos_region_setup); 442 443 return_ACPI_STATUS(AE_OK); 444 } 445 446 /******************************************************************************* 447 * 448 * FUNCTION: acpi_ev_default_region_setup 449 * 450 * PARAMETERS: handle - Region we are interested in 451 * function - Start or stop 452 * handler_context - Address space handler context 453 * region_context - Region specific context 454 * 455 * RETURN: Status 456 * 457 * DESCRIPTION: Default region initialization 458 * 459 ******************************************************************************/ 460 461 acpi_status 462 acpi_ev_default_region_setup(acpi_handle handle, 463 u32 function, 464 void *handler_context, void **region_context) 465 { 466 ACPI_FUNCTION_TRACE(ev_default_region_setup); 467 468 if (function == ACPI_REGION_DEACTIVATE) { 469 *region_context = NULL; 470 } else { 471 *region_context = handler_context; 472 } 473 474 return_ACPI_STATUS(AE_OK); 475 } 476 477 /******************************************************************************* 478 * 479 * FUNCTION: acpi_ev_initialize_region 480 * 481 * PARAMETERS: region_obj - Region we are initializing 482 * 483 * RETURN: Status 484 * 485 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them 486 * for execution at a later time 487 * 488 * Get the appropriate address space handler for a newly 489 * created region. 490 * 491 * This also performs address space specific initialization. For 492 * example, PCI regions must have an _ADR object that contains 493 * a PCI address in the scope of the definition. This address is 494 * required to perform an access to PCI config space. 495 * 496 * MUTEX: Interpreter should be unlocked, because we may run the _REG 497 * method for this region. 498 * 499 * NOTE: Possible incompliance: 500 * There is a behavior conflict in automatic _REG execution: 501 * 1. When the interpreter is evaluating a method, we can only 502 * automatically run _REG for the following case: 503 * operation_region (OPR1, 0x80, 0x1000010, 0x4) 504 * 2. When the interpreter is loading a table, we can also 505 * automatically run _REG for the following case: 506 * operation_region (OPR1, 0x80, 0x1000010, 0x4) 507 * Though this may not be compliant to the de-facto standard, the 508 * logic is kept in order not to trigger regressions. And keeping 509 * this logic should be taken care by the caller of this function. 510 * 511 ******************************************************************************/ 512 513 acpi_status acpi_ev_initialize_region(union acpi_operand_object *region_obj) 514 { 515 union acpi_operand_object *handler_obj; 516 union acpi_operand_object *obj_desc; 517 acpi_adr_space_type space_id; 518 struct acpi_namespace_node *node; 519 520 ACPI_FUNCTION_TRACE(ev_initialize_region); 521 522 if (!region_obj) { 523 return_ACPI_STATUS(AE_BAD_PARAMETER); 524 } 525 526 if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { 527 return_ACPI_STATUS(AE_OK); 528 } 529 530 region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; 531 532 node = region_obj->region.node->parent; 533 space_id = region_obj->region.space_id; 534 535 /* 536 * The following loop depends upon the root Node having no parent 537 * ie: acpi_gbl_root_node->Parent being set to NULL 538 */ 539 while (node) { 540 541 /* Check to see if a handler exists */ 542 543 handler_obj = NULL; 544 obj_desc = acpi_ns_get_attached_object(node); 545 if (obj_desc) { 546 547 /* Can only be a handler if the object exists */ 548 549 switch (node->type) { 550 case ACPI_TYPE_DEVICE: 551 case ACPI_TYPE_PROCESSOR: 552 case ACPI_TYPE_THERMAL: 553 554 handler_obj = obj_desc->common_notify.handler; 555 break; 556 557 case ACPI_TYPE_METHOD: 558 /* 559 * If we are executing module level code, the original 560 * Node's object was replaced by this Method object and we 561 * saved the handler in the method object. 562 * 563 * See acpi_ns_exec_module_code 564 */ 565 if (!acpi_gbl_parse_table_as_term_list && 566 obj_desc->method. 567 info_flags & ACPI_METHOD_MODULE_LEVEL) { 568 handler_obj = 569 obj_desc->method.dispatch.handler; 570 } 571 break; 572 573 default: 574 575 /* Ignore other objects */ 576 577 break; 578 } 579 580 handler_obj = 581 acpi_ev_find_region_handler(space_id, handler_obj); 582 if (handler_obj) { 583 584 /* Found correct handler */ 585 586 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 587 "Found handler %p for region %p in obj %p\n", 588 handler_obj, region_obj, 589 obj_desc)); 590 591 (void)acpi_ev_attach_region(handler_obj, 592 region_obj, FALSE); 593 594 /* 595 * Tell all users that this region is usable by 596 * running the _REG method 597 */ 598 acpi_ex_exit_interpreter(); 599 (void)acpi_ev_execute_reg_method(region_obj, 600 ACPI_REG_CONNECT); 601 acpi_ex_enter_interpreter(); 602 return_ACPI_STATUS(AE_OK); 603 } 604 } 605 606 /* This node does not have the handler we need; Pop up one level */ 607 608 node = node->parent; 609 } 610 611 /* 612 * If we get here, there is no handler for this region. This is not 613 * fatal because many regions get created before a handler is installed 614 * for said region. 615 */ 616 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 617 "No handler for RegionType %s(%X) (RegionObj %p)\n", 618 acpi_ut_get_region_name(space_id), space_id, 619 region_obj)); 620 621 return_ACPI_STATUS(AE_OK); 622 } 623