drivers/acpi/utilities/utxface.c

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