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