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