1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: nsinit - namespace initialization 5 * 6 * Copyright (C) 2000 - 2018, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "acnamesp.h" 13 #include "acdispat.h" 14 #include "acinterp.h" 15 #include "acevents.h" 16 17 #define _COMPONENT ACPI_NAMESPACE 18 ACPI_MODULE_NAME("nsinit") 19 20 /* Local prototypes */ 21 static acpi_status 22 acpi_ns_init_one_object(acpi_handle obj_handle, 23 u32 level, void *context, void **return_value); 24 25 static acpi_status 26 acpi_ns_init_one_device(acpi_handle obj_handle, 27 u32 nesting_level, void *context, void **return_value); 28 29 static acpi_status 30 acpi_ns_find_ini_methods(acpi_handle obj_handle, 31 u32 nesting_level, void *context, void **return_value); 32 33 /******************************************************************************* 34 * 35 * FUNCTION: acpi_ns_initialize_objects 36 * 37 * PARAMETERS: None 38 * 39 * RETURN: Status 40 * 41 * DESCRIPTION: Walk the entire namespace and perform any necessary 42 * initialization on the objects found therein 43 * 44 ******************************************************************************/ 45 46 acpi_status acpi_ns_initialize_objects(void) 47 { 48 acpi_status status; 49 struct acpi_init_walk_info info; 50 51 ACPI_FUNCTION_TRACE(ns_initialize_objects); 52 53 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 54 "[Init] Completing Initialization of ACPI Objects\n")); 55 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 56 "**** Starting initialization of namespace objects ****\n")); 57 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 58 "Completing Region/Field/Buffer/Package initialization:\n")); 59 60 /* Set all init info to zero */ 61 62 memset(&info, 0, sizeof(struct acpi_init_walk_info)); 63 64 /* Walk entire namespace from the supplied root */ 65 66 status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 67 ACPI_UINT32_MAX, acpi_ns_init_one_object, 68 NULL, &info, NULL); 69 if (ACPI_FAILURE(status)) { 70 ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace")); 71 } 72 73 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 74 " Initialized %u/%u Regions %u/%u Fields %u/%u " 75 "Buffers %u/%u Packages (%u nodes)\n", 76 info.op_region_init, info.op_region_count, 77 info.field_init, info.field_count, 78 info.buffer_init, info.buffer_count, 79 info.package_init, info.package_count, 80 info.object_count)); 81 82 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 83 "%u Control Methods found\n%u Op Regions found\n", 84 info.method_count, info.op_region_count)); 85 86 return_ACPI_STATUS(AE_OK); 87 } 88 89 /******************************************************************************* 90 * 91 * FUNCTION: acpi_ns_initialize_devices 92 * 93 * PARAMETERS: None 94 * 95 * RETURN: acpi_status 96 * 97 * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices. 98 * This means running _INI on all present devices. 99 * 100 * Note: We install PCI config space handler on region access, 101 * not here. 102 * 103 ******************************************************************************/ 104 105 acpi_status acpi_ns_initialize_devices(u32 flags) 106 { 107 acpi_status status = AE_OK; 108 struct acpi_device_walk_info info; 109 acpi_handle handle; 110 111 ACPI_FUNCTION_TRACE(ns_initialize_devices); 112 113 if (!(flags & ACPI_NO_DEVICE_INIT)) { 114 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 115 "[Init] Initializing ACPI Devices\n")); 116 117 /* Init counters */ 118 119 info.device_count = 0; 120 info.num_STA = 0; 121 info.num_INI = 0; 122 123 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 124 "Initializing Device/Processor/Thermal objects " 125 "and executing _INI/_STA methods:\n")); 126 127 /* Tree analysis: find all subtrees that contain _INI methods */ 128 129 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 130 ACPI_UINT32_MAX, FALSE, 131 acpi_ns_find_ini_methods, NULL, 132 &info, NULL); 133 if (ACPI_FAILURE(status)) { 134 goto error_exit; 135 } 136 137 /* Allocate the evaluation information block */ 138 139 info.evaluate_info = 140 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 141 if (!info.evaluate_info) { 142 status = AE_NO_MEMORY; 143 goto error_exit; 144 } 145 146 /* 147 * Execute the "global" _INI method that may appear at the root. 148 * This support is provided for Windows compatibility (Vista+) and 149 * is not part of the ACPI specification. 150 */ 151 info.evaluate_info->prefix_node = acpi_gbl_root_node; 152 info.evaluate_info->relative_pathname = METHOD_NAME__INI; 153 info.evaluate_info->parameters = NULL; 154 info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE; 155 156 status = acpi_ns_evaluate(info.evaluate_info); 157 if (ACPI_SUCCESS(status)) { 158 info.num_INI++; 159 } 160 161 /* 162 * Execute \_SB._INI. 163 * There appears to be a strict order requirement for \_SB._INI, 164 * which should be evaluated before any _REG evaluations. 165 */ 166 status = acpi_get_handle(NULL, "\\_SB", &handle); 167 if (ACPI_SUCCESS(status)) { 168 memset(info.evaluate_info, 0, 169 sizeof(struct acpi_evaluate_info)); 170 info.evaluate_info->prefix_node = handle; 171 info.evaluate_info->relative_pathname = 172 METHOD_NAME__INI; 173 info.evaluate_info->parameters = NULL; 174 info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE; 175 176 status = acpi_ns_evaluate(info.evaluate_info); 177 if (ACPI_SUCCESS(status)) { 178 info.num_INI++; 179 } 180 } 181 } 182 183 /* 184 * Run all _REG methods 185 * 186 * Note: Any objects accessed by the _REG methods will be automatically 187 * initialized, even if they contain executable AML (see the call to 188 * acpi_ns_initialize_objects below). 189 * 190 * Note: According to the ACPI specification, we actually needn't execute 191 * _REG for system_memory/system_io operation regions, but for PCI_Config 192 * operation regions, it is required to evaluate _REG for those on a PCI 193 * root bus that doesn't contain _BBN object. So this code is kept here 194 * in order not to break things. 195 */ 196 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) { 197 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 198 "[Init] Executing _REG OpRegion methods\n")); 199 200 status = acpi_ev_initialize_op_regions(); 201 if (ACPI_FAILURE(status)) { 202 goto error_exit; 203 } 204 } 205 206 if (!(flags & ACPI_NO_DEVICE_INIT)) { 207 208 /* Walk namespace to execute all _INIs on present devices */ 209 210 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 211 ACPI_UINT32_MAX, FALSE, 212 acpi_ns_init_one_device, NULL, 213 &info, NULL); 214 215 /* 216 * Any _OSI requests should be completed by now. If the BIOS has 217 * requested any Windows OSI strings, we will always truncate 218 * I/O addresses to 16 bits -- for Windows compatibility. 219 */ 220 if (acpi_gbl_osi_data >= ACPI_OSI_WIN_2000) { 221 acpi_gbl_truncate_io_addresses = TRUE; 222 } 223 224 ACPI_FREE(info.evaluate_info); 225 if (ACPI_FAILURE(status)) { 226 goto error_exit; 227 } 228 229 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 230 " Executed %u _INI methods requiring %u _STA executions " 231 "(examined %u objects)\n", 232 info.num_INI, info.num_STA, 233 info.device_count)); 234 } 235 236 return_ACPI_STATUS(status); 237 238 error_exit: 239 ACPI_EXCEPTION((AE_INFO, status, "During device initialization")); 240 return_ACPI_STATUS(status); 241 } 242 243 /******************************************************************************* 244 * 245 * FUNCTION: acpi_ns_init_one_object 246 * 247 * PARAMETERS: obj_handle - Node 248 * level - Current nesting level 249 * context - Points to a init info struct 250 * return_value - Not used 251 * 252 * RETURN: Status 253 * 254 * DESCRIPTION: Callback from acpi_walk_namespace. Invoked for every object 255 * within the namespace. 256 * 257 * Currently, the only objects that require initialization are: 258 * 1) Methods 259 * 2) Op Regions 260 * 261 ******************************************************************************/ 262 263 static acpi_status 264 acpi_ns_init_one_object(acpi_handle obj_handle, 265 u32 level, void *context, void **return_value) 266 { 267 acpi_object_type type; 268 acpi_status status = AE_OK; 269 struct acpi_init_walk_info *info = 270 (struct acpi_init_walk_info *)context; 271 struct acpi_namespace_node *node = 272 (struct acpi_namespace_node *)obj_handle; 273 union acpi_operand_object *obj_desc; 274 275 ACPI_FUNCTION_NAME(ns_init_one_object); 276 277 info->object_count++; 278 279 /* And even then, we are only interested in a few object types */ 280 281 type = acpi_ns_get_type(obj_handle); 282 obj_desc = acpi_ns_get_attached_object(node); 283 if (!obj_desc) { 284 return (AE_OK); 285 } 286 287 /* Increment counters for object types we are looking for */ 288 289 switch (type) { 290 case ACPI_TYPE_REGION: 291 292 info->op_region_count++; 293 break; 294 295 case ACPI_TYPE_BUFFER_FIELD: 296 297 info->field_count++; 298 break; 299 300 case ACPI_TYPE_LOCAL_BANK_FIELD: 301 302 info->field_count++; 303 break; 304 305 case ACPI_TYPE_BUFFER: 306 307 info->buffer_count++; 308 break; 309 310 case ACPI_TYPE_PACKAGE: 311 312 info->package_count++; 313 break; 314 315 default: 316 317 /* No init required, just exit now */ 318 319 return (AE_OK); 320 } 321 322 /* If the object is already initialized, nothing else to do */ 323 324 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { 325 return (AE_OK); 326 } 327 328 /* Must lock the interpreter before executing AML code */ 329 330 acpi_ex_enter_interpreter(); 331 332 /* 333 * Each of these types can contain executable AML code within the 334 * declaration. 335 */ 336 switch (type) { 337 case ACPI_TYPE_REGION: 338 339 info->op_region_init++; 340 status = acpi_ds_get_region_arguments(obj_desc); 341 break; 342 343 case ACPI_TYPE_BUFFER_FIELD: 344 345 info->field_init++; 346 status = acpi_ds_get_buffer_field_arguments(obj_desc); 347 break; 348 349 case ACPI_TYPE_LOCAL_BANK_FIELD: 350 351 info->field_init++; 352 status = acpi_ds_get_bank_field_arguments(obj_desc); 353 break; 354 355 case ACPI_TYPE_BUFFER: 356 357 info->buffer_init++; 358 status = acpi_ds_get_buffer_arguments(obj_desc); 359 break; 360 361 case ACPI_TYPE_PACKAGE: 362 363 info->package_init++; 364 status = acpi_ds_get_package_arguments(obj_desc); 365 if (ACPI_FAILURE(status)) { 366 break; 367 } 368 369 ACPI_DEBUG_PRINT_RAW((ACPI_DB_PARSE, 370 "%s: Completing resolution of Package elements\n", 371 ACPI_GET_FUNCTION_NAME)); 372 373 /* 374 * Resolve all named references in package objects (and all 375 * sub-packages). This action has been deferred until the entire 376 * namespace has been loaded, in order to support external and 377 * forward references from individual package elements (05/2017). 378 */ 379 status = acpi_ut_walk_package_tree(obj_desc, NULL, 380 acpi_ds_init_package_element, 381 NULL); 382 383 obj_desc->package.flags |= AOPOBJ_DATA_VALID; 384 break; 385 386 default: 387 388 /* No other types can get here */ 389 390 break; 391 } 392 393 if (ACPI_FAILURE(status)) { 394 ACPI_EXCEPTION((AE_INFO, status, 395 "Could not execute arguments for [%4.4s] (%s)", 396 acpi_ut_get_node_name(node), 397 acpi_ut_get_type_name(type))); 398 } 399 400 /* 401 * We ignore errors from above, and always return OK, since we don't want 402 * to abort the walk on any single error. 403 */ 404 acpi_ex_exit_interpreter(); 405 return (AE_OK); 406 } 407 408 /******************************************************************************* 409 * 410 * FUNCTION: acpi_ns_find_ini_methods 411 * 412 * PARAMETERS: acpi_walk_callback 413 * 414 * RETURN: acpi_status 415 * 416 * DESCRIPTION: Called during namespace walk. Finds objects named _INI under 417 * device/processor/thermal objects, and marks the entire subtree 418 * with a SUBTREE_HAS_INI flag. This flag is used during the 419 * subsequent device initialization walk to avoid entire subtrees 420 * that do not contain an _INI. 421 * 422 ******************************************************************************/ 423 424 static acpi_status 425 acpi_ns_find_ini_methods(acpi_handle obj_handle, 426 u32 nesting_level, void *context, void **return_value) 427 { 428 struct acpi_device_walk_info *info = 429 ACPI_CAST_PTR(struct acpi_device_walk_info, context); 430 struct acpi_namespace_node *node; 431 struct acpi_namespace_node *parent_node; 432 433 /* Keep count of device/processor/thermal objects */ 434 435 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); 436 if ((node->type == ACPI_TYPE_DEVICE) || 437 (node->type == ACPI_TYPE_PROCESSOR) || 438 (node->type == ACPI_TYPE_THERMAL)) { 439 info->device_count++; 440 return (AE_OK); 441 } 442 443 /* We are only looking for methods named _INI */ 444 445 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) { 446 return (AE_OK); 447 } 448 449 /* 450 * The only _INI methods that we care about are those that are 451 * present under Device, Processor, and Thermal objects. 452 */ 453 parent_node = node->parent; 454 switch (parent_node->type) { 455 case ACPI_TYPE_DEVICE: 456 case ACPI_TYPE_PROCESSOR: 457 case ACPI_TYPE_THERMAL: 458 459 /* Mark parent and bubble up the INI present flag to the root */ 460 461 while (parent_node) { 462 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI; 463 parent_node = parent_node->parent; 464 } 465 break; 466 467 default: 468 469 break; 470 } 471 472 return (AE_OK); 473 } 474 475 /******************************************************************************* 476 * 477 * FUNCTION: acpi_ns_init_one_device 478 * 479 * PARAMETERS: acpi_walk_callback 480 * 481 * RETURN: acpi_status 482 * 483 * DESCRIPTION: This is called once per device soon after ACPI is enabled 484 * to initialize each device. It determines if the device is 485 * present, and if so, calls _INI. 486 * 487 ******************************************************************************/ 488 489 static acpi_status 490 acpi_ns_init_one_device(acpi_handle obj_handle, 491 u32 nesting_level, void *context, void **return_value) 492 { 493 struct acpi_device_walk_info *walk_info = 494 ACPI_CAST_PTR(struct acpi_device_walk_info, context); 495 struct acpi_evaluate_info *info = walk_info->evaluate_info; 496 u32 flags; 497 acpi_status status; 498 struct acpi_namespace_node *device_node; 499 500 ACPI_FUNCTION_TRACE(ns_init_one_device); 501 502 /* We are interested in Devices, Processors and thermal_zones only */ 503 504 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); 505 if ((device_node->type != ACPI_TYPE_DEVICE) && 506 (device_node->type != ACPI_TYPE_PROCESSOR) && 507 (device_node->type != ACPI_TYPE_THERMAL)) { 508 return_ACPI_STATUS(AE_OK); 509 } 510 511 /* 512 * Because of an earlier namespace analysis, all subtrees that contain an 513 * _INI method are tagged. 514 * 515 * If this device subtree does not contain any _INI methods, we 516 * can exit now and stop traversing this entire subtree. 517 */ 518 if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) { 519 return_ACPI_STATUS(AE_CTRL_DEPTH); 520 } 521 522 /* 523 * Run _STA to determine if this device is present and functioning. We 524 * must know this information for two important reasons (from ACPI spec): 525 * 526 * 1) We can only run _INI if the device is present. 527 * 2) We must abort the device tree walk on this subtree if the device is 528 * not present and is not functional (we will not examine the children) 529 * 530 * The _STA method is not required to be present under the device, we 531 * assume the device is present if _STA does not exist. 532 */ 533 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname 534 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA)); 535 536 status = acpi_ut_execute_STA(device_node, &flags); 537 if (ACPI_FAILURE(status)) { 538 539 /* Ignore error and move on to next device */ 540 541 return_ACPI_STATUS(AE_OK); 542 } 543 544 /* 545 * Flags == -1 means that _STA was not found. In this case, we assume that 546 * the device is both present and functional. 547 * 548 * From the ACPI spec, description of _STA: 549 * 550 * "If a device object (including the processor object) does not have an 551 * _STA object, then OSPM assumes that all of the above bits are set (in 552 * other words, the device is present, ..., and functioning)" 553 */ 554 if (flags != ACPI_UINT32_MAX) { 555 walk_info->num_STA++; 556 } 557 558 /* 559 * Examine the PRESENT and FUNCTIONING status bits 560 * 561 * Note: ACPI spec does not seem to specify behavior for the present but 562 * not functioning case, so we assume functioning if present. 563 */ 564 if (!(flags & ACPI_STA_DEVICE_PRESENT)) { 565 566 /* Device is not present, we must examine the Functioning bit */ 567 568 if (flags & ACPI_STA_DEVICE_FUNCTIONING) { 569 /* 570 * Device is not present but is "functioning". In this case, 571 * we will not run _INI, but we continue to examine the children 572 * of this device. 573 * 574 * From the ACPI spec, description of _STA: (note - no mention 575 * of whether to run _INI or not on the device in question) 576 * 577 * "_STA may return bit 0 clear (not present) with bit 3 set 578 * (device is functional). This case is used to indicate a valid 579 * device for which no device driver should be loaded (for example, 580 * a bridge device.) Children of this device may be present and 581 * valid. OSPM should continue enumeration below a device whose 582 * _STA returns this bit combination" 583 */ 584 return_ACPI_STATUS(AE_OK); 585 } else { 586 /* 587 * Device is not present and is not functioning. We must abort the 588 * walk of this subtree immediately -- don't look at the children 589 * of such a device. 590 * 591 * From the ACPI spec, description of _INI: 592 * 593 * "If the _STA method indicates that the device is not present, 594 * OSPM will not run the _INI and will not examine the children 595 * of the device for _INI methods" 596 */ 597 return_ACPI_STATUS(AE_CTRL_DEPTH); 598 } 599 } 600 601 /* 602 * The device is present or is assumed present if no _STA exists. 603 * Run the _INI if it exists (not required to exist) 604 * 605 * Note: We know there is an _INI within this subtree, but it may not be 606 * under this particular device, it may be lower in the branch. 607 */ 608 if (!ACPI_COMPARE_NAME(device_node->name.ascii, "_SB_") || 609 device_node->parent != acpi_gbl_root_node) { 610 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname 611 (ACPI_TYPE_METHOD, device_node, 612 METHOD_NAME__INI)); 613 614 memset(info, 0, sizeof(struct acpi_evaluate_info)); 615 info->prefix_node = device_node; 616 info->relative_pathname = METHOD_NAME__INI; 617 info->parameters = NULL; 618 info->flags = ACPI_IGNORE_RETURN_VALUE; 619 620 status = acpi_ns_evaluate(info); 621 if (ACPI_SUCCESS(status)) { 622 walk_info->num_INI++; 623 } 624 #ifdef ACPI_DEBUG_OUTPUT 625 else if (status != AE_NOT_FOUND) { 626 627 /* Ignore error and move on to next device */ 628 629 char *scope_name = 630 acpi_ns_get_normalized_pathname(device_node, TRUE); 631 632 ACPI_EXCEPTION((AE_INFO, status, 633 "during %s._INI execution", 634 scope_name)); 635 ACPI_FREE(scope_name); 636 } 637 #endif 638 } 639 640 /* Ignore errors from above */ 641 642 status = AE_OK; 643 644 /* 645 * The _INI method has been run if present; call the Global Initialization 646 * Handler for this device. 647 */ 648 if (acpi_gbl_init_handler) { 649 status = 650 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI); 651 } 652 653 return_ACPI_STATUS(status); 654 } 655