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