1/****************************************************************************** 2 * 3 * Module Name: nsinit - namespace initialization 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, 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 <linux/nmi.h> 50 51#define _COMPONENT ACPI_NAMESPACE 52ACPI_MODULE_NAME("nsinit") 53 54/* Local prototypes */ 55static acpi_status 56acpi_ns_init_one_object(acpi_handle obj_handle, 57 u32 level, void *context, void **return_value); 58 59static acpi_status 60acpi_ns_init_one_device(acpi_handle obj_handle, 61 u32 nesting_level, void *context, void **return_value); 62 63static acpi_status 64acpi_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 80acpi_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_DISPATCH, 88 "**** Starting initialization of namespace objects ****\n")); 89 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 90 "Completing Region/Field/Buffer/Package initialization:")); 91 92 /* Set all init info to zero */ 93 94 ACPI_MEMSET(&info, 0, sizeof(struct acpi_init_walk_info)); 95 96 /* Walk entire namespace from the supplied root */ 97 98 status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 99 ACPI_UINT32_MAX, acpi_ns_init_one_object, NULL, 100 &info, NULL); 101 if (ACPI_FAILURE(status)) { 102 ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace")); 103 } 104 105 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 106 "\nInitialized %u/%u Regions %u/%u Fields %u/%u " 107 "Buffers %u/%u Packages (%u nodes)\n", 108 info.op_region_init, info.op_region_count, 109 info.field_init, info.field_count, 110 info.buffer_init, info.buffer_count, 111 info.package_init, info.package_count, 112 info.object_count)); 113 114 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 115 "%u Control Methods found\n", info.method_count)); 116 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 117 "%u Op Regions found\n", info.op_region_count)); 118 119 return_ACPI_STATUS(AE_OK); 120} 121 122/******************************************************************************* 123 * 124 * FUNCTION: acpi_ns_initialize_devices 125 * 126 * PARAMETERS: None 127 * 128 * RETURN: acpi_status 129 * 130 * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices. 131 * This means running _INI on all present devices. 132 * 133 * Note: We install PCI config space handler on region access, 134 * not here. 135 * 136 ******************************************************************************/ 137 138acpi_status acpi_ns_initialize_devices(void) 139{ 140 acpi_status status; 141 struct acpi_device_walk_info info; 142 143 ACPI_FUNCTION_TRACE(ns_initialize_devices); 144 145 /* Init counters */ 146 147 info.device_count = 0; 148 info.num_STA = 0; 149 info.num_INI = 0; 150 151 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 152 "Initializing Device/Processor/Thermal objects " 153 "by executing _INI methods:")); 154 155 /* Tree analysis: find all subtrees that contain _INI methods */ 156 157 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 158 ACPI_UINT32_MAX, FALSE, 159 acpi_ns_find_ini_methods, NULL, &info, 160 NULL); 161 if (ACPI_FAILURE(status)) { 162 goto error_exit; 163 } 164 165 /* Allocate the evaluation information block */ 166 167 info.evaluate_info = 168 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 169 if (!info.evaluate_info) { 170 status = AE_NO_MEMORY; 171 goto error_exit; 172 } 173 174 /* 175 * Execute the "global" _INI method that may appear at the root. This 176 * support is provided for Windows compatibility (Vista+) and is not 177 * part of the ACPI specification. 178 */ 179 info.evaluate_info->prefix_node = acpi_gbl_root_node; 180 info.evaluate_info->pathname = METHOD_NAME__INI; 181 info.evaluate_info->parameters = NULL; 182 info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE; 183 184 status = acpi_ns_evaluate(info.evaluate_info); 185 if (ACPI_SUCCESS(status)) { 186 info.num_INI++; 187 } 188 189 /* Walk namespace to execute all _INIs on present devices */ 190 191 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 192 ACPI_UINT32_MAX, FALSE, 193 acpi_ns_init_one_device, NULL, &info, 194 NULL); 195 196 /* 197 * Any _OSI requests should be completed by now. If the BIOS has 198 * requested any Windows OSI strings, we will always truncate 199 * I/O addresses to 16 bits -- for Windows compatibility. 200 */ 201 if (acpi_gbl_osi_data >= ACPI_OSI_WIN_2000) { 202 acpi_gbl_truncate_io_addresses = TRUE; 203 } 204 205 ACPI_FREE(info.evaluate_info); 206 if (ACPI_FAILURE(status)) { 207 goto error_exit; 208 } 209 210 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, 211 "\nExecuted %u _INI methods requiring %u _STA executions " 212 "(examined %u objects)\n", 213 info.num_INI, info.num_STA, info.device_count)); 214 215 return_ACPI_STATUS(status); 216 217 error_exit: 218 ACPI_EXCEPTION((AE_INFO, status, "During device initialization")); 219 return_ACPI_STATUS(status); 220} 221 222/******************************************************************************* 223 * 224 * FUNCTION: acpi_ns_init_one_object 225 * 226 * PARAMETERS: obj_handle - Node 227 * Level - Current nesting level 228 * Context - Points to a init info struct 229 * return_value - Not used 230 * 231 * RETURN: Status 232 * 233 * DESCRIPTION: Callback from acpi_walk_namespace. Invoked for every object 234 * within the namespace. 235 * 236 * Currently, the only objects that require initialization are: 237 * 1) Methods 238 * 2) Op Regions 239 * 240 ******************************************************************************/ 241 242static acpi_status 243acpi_ns_init_one_object(acpi_handle obj_handle, 244 u32 level, void *context, void **return_value) 245{ 246 acpi_object_type type; 247 acpi_status status = AE_OK; 248 struct acpi_init_walk_info *info = 249 (struct acpi_init_walk_info *)context; 250 struct acpi_namespace_node *node = 251 (struct acpi_namespace_node *)obj_handle; 252 union acpi_operand_object *obj_desc; 253 254 ACPI_FUNCTION_NAME(ns_init_one_object); 255 256 info->object_count++; 257 258 /* And even then, we are only interested in a few object types */ 259 260 type = acpi_ns_get_type(obj_handle); 261 obj_desc = acpi_ns_get_attached_object(node); 262 if (!obj_desc) { 263 return (AE_OK); 264 } 265 266 /* Increment counters for object types we are looking for */ 267 268 switch (type) { 269 case ACPI_TYPE_REGION: 270 info->op_region_count++; 271 break; 272 273 case ACPI_TYPE_BUFFER_FIELD: 274 info->field_count++; 275 break; 276 277 case ACPI_TYPE_LOCAL_BANK_FIELD: 278 info->field_count++; 279 break; 280 281 case ACPI_TYPE_BUFFER: 282 info->buffer_count++; 283 break; 284 285 case ACPI_TYPE_PACKAGE: 286 info->package_count++; 287 break; 288 289 default: 290 291 /* No init required, just exit now */ 292 return (AE_OK); 293 } 294 295 /* If the object is already initialized, nothing else to do */ 296 297 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { 298 return (AE_OK); 299 } 300 301 /* Must lock the interpreter before executing AML code */ 302 303 acpi_ex_enter_interpreter(); 304 305 /* 306 * Each of these types can contain executable AML code within the 307 * declaration. 308 */ 309 switch (type) { 310 case ACPI_TYPE_REGION: 311 312 info->op_region_init++; 313 status = acpi_ds_get_region_arguments(obj_desc); 314 break; 315 316 case ACPI_TYPE_BUFFER_FIELD: 317 318 info->field_init++; 319 status = acpi_ds_get_buffer_field_arguments(obj_desc); 320 break; 321 322 case ACPI_TYPE_LOCAL_BANK_FIELD: 323 324 info->field_init++; 325 status = acpi_ds_get_bank_field_arguments(obj_desc); 326 break; 327 328 case ACPI_TYPE_BUFFER: 329 330 info->buffer_init++; 331 status = acpi_ds_get_buffer_arguments(obj_desc); 332 break; 333 334 case ACPI_TYPE_PACKAGE: 335 336 info->package_init++; 337 status = acpi_ds_get_package_arguments(obj_desc); 338 break; 339 340 default: 341 /* No other types can get here */ 342 break; 343 } 344 345 if (ACPI_FAILURE(status)) { 346 ACPI_EXCEPTION((AE_INFO, status, 347 "Could not execute arguments for [%4.4s] (%s)", 348 acpi_ut_get_node_name(node), 349 acpi_ut_get_type_name(type))); 350 } 351 352 /* 353 * Print a dot for each object unless we are going to print the entire 354 * pathname 355 */ 356 if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) { 357 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, ".")); 358 } 359 360 /* 361 * We ignore errors from above, and always return OK, since we don't want 362 * to abort the walk on any single error. 363 */ 364 acpi_ex_exit_interpreter(); 365 return (AE_OK); 366} 367 368/******************************************************************************* 369 * 370 * FUNCTION: acpi_ns_find_ini_methods 371 * 372 * PARAMETERS: acpi_walk_callback 373 * 374 * RETURN: acpi_status 375 * 376 * DESCRIPTION: Called during namespace walk. Finds objects named _INI under 377 * device/processor/thermal objects, and marks the entire subtree 378 * with a SUBTREE_HAS_INI flag. This flag is used during the 379 * subsequent device initialization walk to avoid entire subtrees 380 * that do not contain an _INI. 381 * 382 ******************************************************************************/ 383 384static acpi_status 385acpi_ns_find_ini_methods(acpi_handle obj_handle, 386 u32 nesting_level, void *context, void **return_value) 387{ 388 struct acpi_device_walk_info *info = 389 ACPI_CAST_PTR(struct acpi_device_walk_info, context); 390 struct acpi_namespace_node *node; 391 struct acpi_namespace_node *parent_node; 392 393 /* Keep count of device/processor/thermal objects */ 394 395 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); 396 if ((node->type == ACPI_TYPE_DEVICE) || 397 (node->type == ACPI_TYPE_PROCESSOR) || 398 (node->type == ACPI_TYPE_THERMAL)) { 399 info->device_count++; 400 return (AE_OK); 401 } 402 403 /* We are only looking for methods named _INI */ 404 405 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) { 406 return (AE_OK); 407 } 408 409 /* 410 * The only _INI methods that we care about are those that are 411 * present under Device, Processor, and Thermal objects. 412 */ 413 parent_node = node->parent; 414 switch (parent_node->type) { 415 case ACPI_TYPE_DEVICE: 416 case ACPI_TYPE_PROCESSOR: 417 case ACPI_TYPE_THERMAL: 418 419 /* Mark parent and bubble up the INI present flag to the root */ 420 421 while (parent_node) { 422 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI; 423 parent_node = parent_node->parent; 424 } 425 break; 426 427 default: 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 448static acpi_status 449acpi_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 info->prefix_node = device_node; 571 info->pathname = METHOD_NAME__INI; 572 info->parameters = NULL; 573 info->flags = ACPI_IGNORE_RETURN_VALUE; 574 575 /* 576 * Some hardware relies on this being executed as atomically 577 * as possible (without an NMI being received in the middle of 578 * this) - so disable NMIs and initialize the device: 579 */ 580 acpi_nmi_disable(); 581 status = acpi_ns_evaluate(info); 582 acpi_nmi_enable(); 583 584 if (ACPI_SUCCESS(status)) { 585 walk_info->num_INI++; 586 587 if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) && 588 (!(acpi_dbg_level & ACPI_LV_INFO))) { 589 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, ".")); 590 } 591 } 592#ifdef ACPI_DEBUG_OUTPUT 593 else if (status != AE_NOT_FOUND) { 594 595 /* Ignore error and move on to next device */ 596 597 char *scope_name = 598 acpi_ns_get_external_pathname(info->resolved_node); 599 600 ACPI_EXCEPTION((AE_INFO, status, "during %s._INI execution", 601 scope_name)); 602 ACPI_FREE(scope_name); 603 } 604#endif 605 606 /* Ignore errors from above */ 607 608 status = AE_OK; 609 610 /* 611 * The _INI method has been run if present; call the Global Initialization 612 * Handler for this device. 613 */ 614 if (acpi_gbl_init_handler) { 615 status = 616 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI); 617 } 618 619 return_ACPI_STATUS(status); 620} 621