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->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 info->op_region_count++; 270 break; 271 272 case ACPI_TYPE_BUFFER_FIELD: 273 info->field_count++; 274 break; 275 276 case ACPI_TYPE_LOCAL_BANK_FIELD: 277 info->field_count++; 278 break; 279 280 case ACPI_TYPE_BUFFER: 281 info->buffer_count++; 282 break; 283 284 case ACPI_TYPE_PACKAGE: 285 info->package_count++; 286 break; 287 288 default: 289 290 /* No init required, just exit now */ 291 return (AE_OK); 292 } 293 294 /* If the object is already initialized, nothing else to do */ 295 296 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { 297 return (AE_OK); 298 } 299 300 /* Must lock the interpreter before executing AML code */ 301 302 acpi_ex_enter_interpreter(); 303 304 /* 305 * Each of these types can contain executable AML code within the 306 * declaration. 307 */ 308 switch (type) { 309 case ACPI_TYPE_REGION: 310 311 info->op_region_init++; 312 status = acpi_ds_get_region_arguments(obj_desc); 313 break; 314 315 case ACPI_TYPE_BUFFER_FIELD: 316 317 info->field_init++; 318 status = acpi_ds_get_buffer_field_arguments(obj_desc); 319 break; 320 321 case ACPI_TYPE_LOCAL_BANK_FIELD: 322 323 info->field_init++; 324 status = acpi_ds_get_bank_field_arguments(obj_desc); 325 break; 326 327 case ACPI_TYPE_BUFFER: 328 329 info->buffer_init++; 330 status = acpi_ds_get_buffer_arguments(obj_desc); 331 break; 332 333 case ACPI_TYPE_PACKAGE: 334 335 info->package_init++; 336 status = acpi_ds_get_package_arguments(obj_desc); 337 break; 338 339 default: 340 /* No other types can get here */ 341 break; 342 } 343 344 if (ACPI_FAILURE(status)) { 345 ACPI_EXCEPTION((AE_INFO, status, 346 "Could not execute arguments for [%4.4s] (%s)", 347 acpi_ut_get_node_name(node), 348 acpi_ut_get_type_name(type))); 349 } 350 351 /* 352 * We ignore errors from above, and always return OK, since we don't want 353 * to abort the walk on any single error. 354 */ 355 acpi_ex_exit_interpreter(); 356 return (AE_OK); 357 } 358 359 /******************************************************************************* 360 * 361 * FUNCTION: acpi_ns_find_ini_methods 362 * 363 * PARAMETERS: acpi_walk_callback 364 * 365 * RETURN: acpi_status 366 * 367 * DESCRIPTION: Called during namespace walk. Finds objects named _INI under 368 * device/processor/thermal objects, and marks the entire subtree 369 * with a SUBTREE_HAS_INI flag. This flag is used during the 370 * subsequent device initialization walk to avoid entire subtrees 371 * that do not contain an _INI. 372 * 373 ******************************************************************************/ 374 375 static acpi_status 376 acpi_ns_find_ini_methods(acpi_handle obj_handle, 377 u32 nesting_level, void *context, void **return_value) 378 { 379 struct acpi_device_walk_info *info = 380 ACPI_CAST_PTR(struct acpi_device_walk_info, context); 381 struct acpi_namespace_node *node; 382 struct acpi_namespace_node *parent_node; 383 384 /* Keep count of device/processor/thermal objects */ 385 386 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); 387 if ((node->type == ACPI_TYPE_DEVICE) || 388 (node->type == ACPI_TYPE_PROCESSOR) || 389 (node->type == ACPI_TYPE_THERMAL)) { 390 info->device_count++; 391 return (AE_OK); 392 } 393 394 /* We are only looking for methods named _INI */ 395 396 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) { 397 return (AE_OK); 398 } 399 400 /* 401 * The only _INI methods that we care about are those that are 402 * present under Device, Processor, and Thermal objects. 403 */ 404 parent_node = node->parent; 405 switch (parent_node->type) { 406 case ACPI_TYPE_DEVICE: 407 case ACPI_TYPE_PROCESSOR: 408 case ACPI_TYPE_THERMAL: 409 410 /* Mark parent and bubble up the INI present flag to the root */ 411 412 while (parent_node) { 413 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI; 414 parent_node = parent_node->parent; 415 } 416 break; 417 418 default: 419 break; 420 } 421 422 return (AE_OK); 423 } 424 425 /******************************************************************************* 426 * 427 * FUNCTION: acpi_ns_init_one_device 428 * 429 * PARAMETERS: acpi_walk_callback 430 * 431 * RETURN: acpi_status 432 * 433 * DESCRIPTION: This is called once per device soon after ACPI is enabled 434 * to initialize each device. It determines if the device is 435 * present, and if so, calls _INI. 436 * 437 ******************************************************************************/ 438 439 static acpi_status 440 acpi_ns_init_one_device(acpi_handle obj_handle, 441 u32 nesting_level, void *context, void **return_value) 442 { 443 struct acpi_device_walk_info *walk_info = 444 ACPI_CAST_PTR(struct acpi_device_walk_info, context); 445 struct acpi_evaluate_info *info = walk_info->evaluate_info; 446 u32 flags; 447 acpi_status status; 448 struct acpi_namespace_node *device_node; 449 450 ACPI_FUNCTION_TRACE(ns_init_one_device); 451 452 /* We are interested in Devices, Processors and thermal_zones only */ 453 454 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); 455 if ((device_node->type != ACPI_TYPE_DEVICE) && 456 (device_node->type != ACPI_TYPE_PROCESSOR) && 457 (device_node->type != ACPI_TYPE_THERMAL)) { 458 return_ACPI_STATUS(AE_OK); 459 } 460 461 /* 462 * Because of an earlier namespace analysis, all subtrees that contain an 463 * _INI method are tagged. 464 * 465 * If this device subtree does not contain any _INI methods, we 466 * can exit now and stop traversing this entire subtree. 467 */ 468 if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) { 469 return_ACPI_STATUS(AE_CTRL_DEPTH); 470 } 471 472 /* 473 * Run _STA to determine if this device is present and functioning. We 474 * must know this information for two important reasons (from ACPI spec): 475 * 476 * 1) We can only run _INI if the device is present. 477 * 2) We must abort the device tree walk on this subtree if the device is 478 * not present and is not functional (we will not examine the children) 479 * 480 * The _STA method is not required to be present under the device, we 481 * assume the device is present if _STA does not exist. 482 */ 483 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname 484 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA)); 485 486 status = acpi_ut_execute_STA(device_node, &flags); 487 if (ACPI_FAILURE(status)) { 488 489 /* Ignore error and move on to next device */ 490 491 return_ACPI_STATUS(AE_OK); 492 } 493 494 /* 495 * Flags == -1 means that _STA was not found. In this case, we assume that 496 * the device is both present and functional. 497 * 498 * From the ACPI spec, description of _STA: 499 * 500 * "If a device object (including the processor object) does not have an 501 * _STA object, then OSPM assumes that all of the above bits are set (in 502 * other words, the device is present, ..., and functioning)" 503 */ 504 if (flags != ACPI_UINT32_MAX) { 505 walk_info->num_STA++; 506 } 507 508 /* 509 * Examine the PRESENT and FUNCTIONING status bits 510 * 511 * Note: ACPI spec does not seem to specify behavior for the present but 512 * not functioning case, so we assume functioning if present. 513 */ 514 if (!(flags & ACPI_STA_DEVICE_PRESENT)) { 515 516 /* Device is not present, we must examine the Functioning bit */ 517 518 if (flags & ACPI_STA_DEVICE_FUNCTIONING) { 519 /* 520 * Device is not present but is "functioning". In this case, 521 * we will not run _INI, but we continue to examine the children 522 * of this device. 523 * 524 * From the ACPI spec, description of _STA: (note - no mention 525 * of whether to run _INI or not on the device in question) 526 * 527 * "_STA may return bit 0 clear (not present) with bit 3 set 528 * (device is functional). This case is used to indicate a valid 529 * device for which no device driver should be loaded (for example, 530 * a bridge device.) Children of this device may be present and 531 * valid. OSPM should continue enumeration below a device whose 532 * _STA returns this bit combination" 533 */ 534 return_ACPI_STATUS(AE_OK); 535 } else { 536 /* 537 * Device is not present and is not functioning. We must abort the 538 * walk of this subtree immediately -- don't look at the children 539 * of such a device. 540 * 541 * From the ACPI spec, description of _INI: 542 * 543 * "If the _STA method indicates that the device is not present, 544 * OSPM will not run the _INI and will not examine the children 545 * of the device for _INI methods" 546 */ 547 return_ACPI_STATUS(AE_CTRL_DEPTH); 548 } 549 } 550 551 /* 552 * The device is present or is assumed present if no _STA exists. 553 * Run the _INI if it exists (not required to exist) 554 * 555 * Note: We know there is an _INI within this subtree, but it may not be 556 * under this particular device, it may be lower in the branch. 557 */ 558 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname 559 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__INI)); 560 561 ACPI_MEMSET(info, 0, sizeof(struct acpi_evaluate_info)); 562 info->prefix_node = device_node; 563 info->pathname = METHOD_NAME__INI; 564 info->parameters = NULL; 565 info->flags = ACPI_IGNORE_RETURN_VALUE; 566 567 status = acpi_ns_evaluate(info); 568 569 if (ACPI_SUCCESS(status)) { 570 walk_info->num_INI++; 571 } 572 #ifdef ACPI_DEBUG_OUTPUT 573 else if (status != AE_NOT_FOUND) { 574 575 /* Ignore error and move on to next device */ 576 577 char *scope_name = 578 acpi_ns_get_external_pathname(info->resolved_node); 579 580 ACPI_EXCEPTION((AE_INFO, status, "during %s._INI execution", 581 scope_name)); 582 ACPI_FREE(scope_name); 583 } 584 #endif 585 586 /* Ignore errors from above */ 587 588 status = AE_OK; 589 590 /* 591 * The _INI method has been run if present; call the Global Initialization 592 * Handler for this device. 593 */ 594 if (acpi_gbl_init_handler) { 595 status = 596 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI); 597 } 598 599 return_ACPI_STATUS(status); 600 } 601