1 /****************************************************************************** 2 * 3 * Module Name: utxface - External interfaces for "global" ACPI functions 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 "acevents.h" 47 #include "acnamesp.h" 48 #include "acdebug.h" 49 #include "actables.h" 50 51 #define _COMPONENT ACPI_UTILITIES 52 ACPI_MODULE_NAME("utxface") 53 54 #ifndef ACPI_ASL_COMPILER 55 /******************************************************************************* 56 * 57 * FUNCTION: acpi_initialize_subsystem 58 * 59 * PARAMETERS: None 60 * 61 * RETURN: Status 62 * 63 * DESCRIPTION: Initializes all global variables. This is the first function 64 * called, so any early initialization belongs here. 65 * 66 ******************************************************************************/ 67 acpi_status __init acpi_initialize_subsystem(void) 68 { 69 acpi_status status; 70 71 ACPI_FUNCTION_TRACE(acpi_initialize_subsystem); 72 73 acpi_gbl_startup_flags = ACPI_SUBSYSTEM_INITIALIZE; 74 ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace()); 75 76 /* Initialize the OS-Dependent layer */ 77 78 status = acpi_os_initialize(); 79 if (ACPI_FAILURE(status)) { 80 ACPI_EXCEPTION((AE_INFO, status, "During OSL initialization")); 81 return_ACPI_STATUS(status); 82 } 83 84 /* Initialize all globals used by the subsystem */ 85 86 status = acpi_ut_init_globals(); 87 if (ACPI_FAILURE(status)) { 88 ACPI_EXCEPTION((AE_INFO, status, 89 "During initialization of globals")); 90 return_ACPI_STATUS(status); 91 } 92 93 /* Create the default mutex objects */ 94 95 status = acpi_ut_mutex_initialize(); 96 if (ACPI_FAILURE(status)) { 97 ACPI_EXCEPTION((AE_INFO, status, 98 "During Global Mutex creation")); 99 return_ACPI_STATUS(status); 100 } 101 102 /* 103 * Initialize the namespace manager and 104 * the root of the namespace tree 105 */ 106 status = acpi_ns_root_initialize(); 107 if (ACPI_FAILURE(status)) { 108 ACPI_EXCEPTION((AE_INFO, status, 109 "During Namespace initialization")); 110 return_ACPI_STATUS(status); 111 } 112 113 /* If configured, initialize the AML debugger */ 114 115 ACPI_DEBUGGER_EXEC(status = acpi_db_initialize()); 116 return_ACPI_STATUS(status); 117 } 118 119 /******************************************************************************* 120 * 121 * FUNCTION: acpi_enable_subsystem 122 * 123 * PARAMETERS: Flags - Init/enable Options 124 * 125 * RETURN: Status 126 * 127 * DESCRIPTION: Completes the subsystem initialization including hardware. 128 * Puts system into ACPI mode if it isn't already. 129 * 130 ******************************************************************************/ 131 acpi_status acpi_enable_subsystem(u32 flags) 132 { 133 acpi_status status = AE_OK; 134 135 ACPI_FUNCTION_TRACE(acpi_enable_subsystem); 136 137 /* Enable ACPI mode */ 138 139 if (!(flags & ACPI_NO_ACPI_ENABLE)) { 140 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 141 "[Init] Going into ACPI mode\n")); 142 143 acpi_gbl_original_mode = acpi_hw_get_mode(); 144 145 status = acpi_enable(); 146 if (ACPI_FAILURE(status)) { 147 ACPI_WARNING((AE_INFO, "AcpiEnable failed")); 148 return_ACPI_STATUS(status); 149 } 150 } 151 152 /* 153 * Obtain a permanent mapping for the FACS. This is required for the 154 * Global Lock and the Firmware Waking Vector 155 */ 156 status = acpi_tb_initialize_facs(); 157 if (ACPI_FAILURE(status)) { 158 ACPI_WARNING((AE_INFO, "Could not map the FACS table")); 159 return_ACPI_STATUS(status); 160 } 161 162 /* 163 * Install the default op_region handlers. These are installed unless 164 * other handlers have already been installed via the 165 * install_address_space_handler interface. 166 */ 167 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) { 168 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 169 "[Init] Installing default address space handlers\n")); 170 171 status = acpi_ev_install_region_handlers(); 172 if (ACPI_FAILURE(status)) { 173 return_ACPI_STATUS(status); 174 } 175 } 176 177 /* 178 * Initialize ACPI Event handling (Fixed and General Purpose) 179 * 180 * Note1: We must have the hardware and events initialized before we can 181 * execute any control methods safely. Any control method can require 182 * ACPI hardware support, so the hardware must be fully initialized before 183 * any method execution! 184 * 185 * Note2: Fixed events are initialized and enabled here. GPEs are 186 * initialized, but cannot be enabled until after the hardware is 187 * completely initialized (SCI and global_lock activated) 188 */ 189 if (!(flags & ACPI_NO_EVENT_INIT)) { 190 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 191 "[Init] Initializing ACPI events\n")); 192 193 status = acpi_ev_initialize_events(); 194 if (ACPI_FAILURE(status)) { 195 return_ACPI_STATUS(status); 196 } 197 } 198 199 /* 200 * Install the SCI handler and Global Lock handler. This completes the 201 * hardware initialization. 202 */ 203 if (!(flags & ACPI_NO_HANDLER_INIT)) { 204 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 205 "[Init] Installing SCI/GL handlers\n")); 206 207 status = acpi_ev_install_xrupt_handlers(); 208 if (ACPI_FAILURE(status)) { 209 return_ACPI_STATUS(status); 210 } 211 } 212 213 return_ACPI_STATUS(status); 214 } 215 216 ACPI_EXPORT_SYMBOL(acpi_enable_subsystem) 217 218 /******************************************************************************* 219 * 220 * FUNCTION: acpi_initialize_objects 221 * 222 * PARAMETERS: Flags - Init/enable Options 223 * 224 * RETURN: Status 225 * 226 * DESCRIPTION: Completes namespace initialization by initializing device 227 * objects and executing AML code for Regions, buffers, etc. 228 * 229 ******************************************************************************/ 230 acpi_status acpi_initialize_objects(u32 flags) 231 { 232 acpi_status status = AE_OK; 233 234 ACPI_FUNCTION_TRACE(acpi_initialize_objects); 235 236 /* 237 * Run all _REG methods 238 * 239 * Note: Any objects accessed by the _REG methods will be automatically 240 * initialized, even if they contain executable AML (see the call to 241 * acpi_ns_initialize_objects below). 242 */ 243 if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) { 244 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 245 "[Init] Executing _REG OpRegion methods\n")); 246 247 status = acpi_ev_initialize_op_regions(); 248 if (ACPI_FAILURE(status)) { 249 return_ACPI_STATUS(status); 250 } 251 } 252 253 /* 254 * Execute any module-level code that was detected during the table load 255 * phase. Although illegal since ACPI 2.0, there are many machines that 256 * contain this type of code. Each block of detected executable AML code 257 * outside of any control method is wrapped with a temporary control 258 * method object and placed on a global list. The methods on this list 259 * are executed below. 260 */ 261 acpi_ns_exec_module_code_list(); 262 263 /* 264 * Initialize the objects that remain uninitialized. This runs the 265 * executable AML that may be part of the declaration of these objects: 266 * operation_regions, buffer_fields, Buffers, and Packages. 267 */ 268 if (!(flags & ACPI_NO_OBJECT_INIT)) { 269 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 270 "[Init] Completing Initialization of ACPI Objects\n")); 271 272 status = acpi_ns_initialize_objects(); 273 if (ACPI_FAILURE(status)) { 274 return_ACPI_STATUS(status); 275 } 276 } 277 278 /* 279 * Initialize all device objects in the namespace. This runs the device 280 * _STA and _INI methods. 281 */ 282 if (!(flags & ACPI_NO_DEVICE_INIT)) { 283 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 284 "[Init] Initializing ACPI Devices\n")); 285 286 status = acpi_ns_initialize_devices(); 287 if (ACPI_FAILURE(status)) { 288 return_ACPI_STATUS(status); 289 } 290 } 291 292 /* 293 * Complete the GPE initialization for the GPE blocks defined in the FADT 294 * (GPE block 0 and 1). 295 * 296 * Note1: This is where the _PRW methods are executed for the GPEs. These 297 * methods can only be executed after the SCI and Global Lock handlers are 298 * installed and initialized. 299 * 300 * Note2: Currently, there seems to be no need to run the _REG methods 301 * before execution of the _PRW methods and enabling of the GPEs. 302 */ 303 if (!(flags & ACPI_NO_EVENT_INIT)) { 304 status = acpi_ev_install_fadt_gpes(); 305 if (ACPI_FAILURE(status)) 306 return (status); 307 } 308 309 /* 310 * Empty the caches (delete the cached objects) on the assumption that 311 * the table load filled them up more than they will be at runtime -- 312 * thus wasting non-paged memory. 313 */ 314 status = acpi_purge_cached_objects(); 315 316 acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK; 317 return_ACPI_STATUS(status); 318 } 319 320 ACPI_EXPORT_SYMBOL(acpi_initialize_objects) 321 322 #endif 323 /******************************************************************************* 324 * 325 * FUNCTION: acpi_terminate 326 * 327 * PARAMETERS: None 328 * 329 * RETURN: Status 330 * 331 * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources. 332 * 333 ******************************************************************************/ 334 acpi_status acpi_terminate(void) 335 { 336 acpi_status status; 337 338 ACPI_FUNCTION_TRACE(acpi_terminate); 339 340 /* Just exit if subsystem is already shutdown */ 341 342 if (acpi_gbl_shutdown) { 343 ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated")); 344 return_ACPI_STATUS(AE_OK); 345 } 346 347 /* Subsystem appears active, go ahead and shut it down */ 348 349 acpi_gbl_shutdown = TRUE; 350 acpi_gbl_startup_flags = 0; 351 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n")); 352 353 /* Terminate the AML Debugger if present */ 354 355 ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE); 356 357 /* Shutdown and free all resources */ 358 359 acpi_ut_subsystem_shutdown(); 360 361 /* Free the mutex objects */ 362 363 acpi_ut_mutex_terminate(); 364 365 #ifdef ACPI_DEBUGGER 366 367 /* Shut down the debugger */ 368 369 acpi_db_terminate(); 370 #endif 371 372 /* Now we can shutdown the OS-dependent layer */ 373 374 status = acpi_os_terminate(); 375 return_ACPI_STATUS(status); 376 } 377 378 ACPI_EXPORT_SYMBOL(acpi_terminate) 379 380 #ifndef ACPI_ASL_COMPILER 381 #ifdef ACPI_FUTURE_USAGE 382 /******************************************************************************* 383 * 384 * FUNCTION: acpi_subsystem_status 385 * 386 * PARAMETERS: None 387 * 388 * RETURN: Status of the ACPI subsystem 389 * 390 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this 391 * before making any other calls, to ensure the subsystem 392 * initialized successfully. 393 * 394 ******************************************************************************/ 395 acpi_status acpi_subsystem_status(void) 396 { 397 398 if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) { 399 return (AE_OK); 400 } else { 401 return (AE_ERROR); 402 } 403 } 404 405 ACPI_EXPORT_SYMBOL(acpi_subsystem_status) 406 407 /******************************************************************************* 408 * 409 * FUNCTION: acpi_get_system_info 410 * 411 * PARAMETERS: out_buffer - A buffer to receive the resources for the 412 * device 413 * 414 * RETURN: Status - the status of the call 415 * 416 * DESCRIPTION: This function is called to get information about the current 417 * state of the ACPI subsystem. It will return system information 418 * in the out_buffer. 419 * 420 * If the function fails an appropriate status will be returned 421 * and the value of out_buffer is undefined. 422 * 423 ******************************************************************************/ 424 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer) 425 { 426 struct acpi_system_info *info_ptr; 427 acpi_status status; 428 429 ACPI_FUNCTION_TRACE(acpi_get_system_info); 430 431 /* Parameter validation */ 432 433 status = acpi_ut_validate_buffer(out_buffer); 434 if (ACPI_FAILURE(status)) { 435 return_ACPI_STATUS(status); 436 } 437 438 /* Validate/Allocate/Clear caller buffer */ 439 440 status = 441 acpi_ut_initialize_buffer(out_buffer, 442 sizeof(struct acpi_system_info)); 443 if (ACPI_FAILURE(status)) { 444 return_ACPI_STATUS(status); 445 } 446 447 /* 448 * Populate the return buffer 449 */ 450 info_ptr = (struct acpi_system_info *)out_buffer->pointer; 451 452 info_ptr->acpi_ca_version = ACPI_CA_VERSION; 453 454 /* System flags (ACPI capabilities) */ 455 456 info_ptr->flags = ACPI_SYS_MODE_ACPI; 457 458 /* Timer resolution - 24 or 32 bits */ 459 460 if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) { 461 info_ptr->timer_resolution = 24; 462 } else { 463 info_ptr->timer_resolution = 32; 464 } 465 466 /* Clear the reserved fields */ 467 468 info_ptr->reserved1 = 0; 469 info_ptr->reserved2 = 0; 470 471 /* Current debug levels */ 472 473 info_ptr->debug_layer = acpi_dbg_layer; 474 info_ptr->debug_level = acpi_dbg_level; 475 476 return_ACPI_STATUS(AE_OK); 477 } 478 479 ACPI_EXPORT_SYMBOL(acpi_get_system_info) 480 481 /***************************************************************************** 482 * 483 * FUNCTION: acpi_install_initialization_handler 484 * 485 * PARAMETERS: Handler - Callback procedure 486 * Function - Not (currently) used, see below 487 * 488 * RETURN: Status 489 * 490 * DESCRIPTION: Install an initialization handler 491 * 492 * TBD: When a second function is added, must save the Function also. 493 * 494 ****************************************************************************/ 495 acpi_status 496 acpi_install_initialization_handler(acpi_init_handler handler, u32 function) 497 { 498 499 if (!handler) { 500 return (AE_BAD_PARAMETER); 501 } 502 503 if (acpi_gbl_init_handler) { 504 return (AE_ALREADY_EXISTS); 505 } 506 507 acpi_gbl_init_handler = handler; 508 return AE_OK; 509 } 510 511 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler) 512 #endif /* ACPI_FUTURE_USAGE */ 513 /***************************************************************************** 514 * 515 * FUNCTION: acpi_purge_cached_objects 516 * 517 * PARAMETERS: None 518 * 519 * RETURN: Status 520 * 521 * DESCRIPTION: Empty all caches (delete the cached objects) 522 * 523 ****************************************************************************/ 524 acpi_status acpi_purge_cached_objects(void) 525 { 526 ACPI_FUNCTION_TRACE(acpi_purge_cached_objects); 527 528 (void)acpi_os_purge_cache(acpi_gbl_state_cache); 529 (void)acpi_os_purge_cache(acpi_gbl_operand_cache); 530 (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache); 531 (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache); 532 return_ACPI_STATUS(AE_OK); 533 } 534 535 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects) 536 #endif 537