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