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