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