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