sys/contrib/dev/acpica/utilities/utxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utxface - External interfaces for "global" ACPI functions
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116
 117 #define __UTXFACE_C__
 118
 119 #include <contrib/dev/acpica/include/acpi.h>
 120 #include <contrib/dev/acpica/include/accommon.h>
 121 #include <contrib/dev/acpica/include/acevents.h>
 122 #include <contrib/dev/acpica/include/acnamesp.h>
 123 #include <contrib/dev/acpica/include/acdebug.h>
 124 #include <contrib/dev/acpica/include/actables.h>
 125
 126 #define _COMPONENT          ACPI_UTILITIES
 127         ACPI_MODULE_NAME    ("utxface")
 128
 129
 130 #ifndef ACPI_ASL_COMPILER
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    AcpiInitializeSubsystem
 135  *
 136  * PARAMETERS:  None
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Initializes all global variables.  This is the first function
 141  *              called, so any early initialization belongs here.
 142  *
 143  ******************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiInitializeSubsystem (
 147     void)
 148 {
 149     ACPI_STATUS             Status;
 150
 151
 152     ACPI_FUNCTION_TRACE (AcpiInitializeSubsystem);
 153
 154
 155     AcpiGbl_StartupFlags = ACPI_SUBSYSTEM_INITIALIZE;
 156     ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
 157
 158     /* Initialize the OS-Dependent layer */
 159
 160     Status = AcpiOsInitialize ();
 161     if (ACPI_FAILURE (Status))
 162     {
 163         ACPI_EXCEPTION ((AE_INFO, Status, "During OSL initialization"));
 164         return_ACPI_STATUS (Status);
 165     }
 166
 167     /* Initialize all globals used by the subsystem */
 168
 169     Status = AcpiUtInitGlobals ();
 170     if (ACPI_FAILURE (Status))
 171     {
 172         ACPI_EXCEPTION ((AE_INFO, Status, "During initialization of globals"));
 173         return_ACPI_STATUS (Status);
 174     }
 175
 176     /* Create the default mutex objects */
 177
 178     Status = AcpiUtMutexInitialize ();
 179     if (ACPI_FAILURE (Status))
 180     {
 181         ACPI_EXCEPTION ((AE_INFO, Status, "During Global Mutex creation"));
 182         return_ACPI_STATUS (Status);
 183     }
 184
 185     /*
 186      * Initialize the namespace manager and
 187      * the root of the namespace tree
 188      */
 189     Status = AcpiNsRootInitialize ();
 190     if (ACPI_FAILURE (Status))
 191     {
 192         ACPI_EXCEPTION ((AE_INFO, Status, "During Namespace initialization"));
 193         return_ACPI_STATUS (Status);
 194     }
 195
 196     /* Initialize the global OSI interfaces list with the static names */
 197
 198     Status = AcpiUtInitializeInterfaces ();
 199     if (ACPI_FAILURE (Status))
 200     {
 201         ACPI_EXCEPTION ((AE_INFO, Status, "During OSI interfaces initialization"));
 202         return_ACPI_STATUS (Status);
 203     }
 204
 205     /* If configured, initialize the AML debugger */
 206
 207     ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
 208     return_ACPI_STATUS (Status);
 209 }
 210
 211 ACPI_EXPORT_SYMBOL (AcpiInitializeSubsystem)
 212
 213
 214 /*******************************************************************************
 215  *
 216  * FUNCTION:    AcpiEnableSubsystem
 217  *
 218  * PARAMETERS:  Flags           - Init/enable Options
 219  *
 220  * RETURN:      Status
 221  *
 222  * DESCRIPTION: Completes the subsystem initialization including hardware.
 223  *              Puts system into ACPI mode if it isn't already.
 224  *
 225  ******************************************************************************/
 226
 227 ACPI_STATUS
 228 AcpiEnableSubsystem (
 229     UINT32                  Flags)
 230 {
 231     ACPI_STATUS             Status = AE_OK;
 232
 233
 234     ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
 235
 236
 237     /* Enable ACPI mode */
 238
 239     if (!(Flags & ACPI_NO_ACPI_ENABLE))
 240     {
 241         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
 242
 243         AcpiGbl_OriginalMode = AcpiHwGetMode();
 244
 245         Status = AcpiEnable ();
 246         if (ACPI_FAILURE (Status))
 247         {
 248             ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
 249             return_ACPI_STATUS (Status);
 250         }
 251     }
 252
 253     /*
 254      * Obtain a permanent mapping for the FACS. This is required for the
 255      * Global Lock and the Firmware Waking Vector
 256      */
 257     Status = AcpiTbInitializeFacs ();
 258     if (ACPI_FAILURE (Status))
 259     {
 260         ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
 261         return_ACPI_STATUS (Status);
 262     }
 263
 264     /*
 265      * Install the default OpRegion handlers.  These are installed unless
 266      * other handlers have already been installed via the
 267      * InstallAddressSpaceHandler interface.
 268      */
 269     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 270     {
 271         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 272             "[Init] Installing default address space handlers\n"));
 273
 274         Status = AcpiEvInstallRegionHandlers ();
 275         if (ACPI_FAILURE (Status))
 276         {
 277             return_ACPI_STATUS (Status);
 278         }
 279     }
 280
 281     /*
 282      * Initialize ACPI Event handling (Fixed and General Purpose)
 283      *
 284      * Note1: We must have the hardware and events initialized before we can
 285      * execute any control methods safely. Any control method can require
 286      * ACPI hardware support, so the hardware must be fully initialized before
 287      * any method execution!
 288      *
 289      * Note2: Fixed events are initialized and enabled here. GPEs are
 290      * initialized, but cannot be enabled until after the hardware is
 291      * completely initialized (SCI and GlobalLock activated) and the various
 292      * initialization control methods are run (_REG, _STA, _INI) on the
 293      * entire namespace.
 294      */
 295     if (!(Flags & ACPI_NO_EVENT_INIT))
 296     {
 297         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 298             "[Init] Initializing ACPI events\n"));
 299
 300         Status = AcpiEvInitializeEvents ();
 301         if (ACPI_FAILURE (Status))
 302         {
 303             return_ACPI_STATUS (Status);
 304         }
 305     }
 306
 307     /*
 308      * Install the SCI handler and Global Lock handler. This completes the
 309      * hardware initialization.
 310      */
 311     if (!(Flags & ACPI_NO_HANDLER_INIT))
 312     {
 313         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 314             "[Init] Installing SCI/GL handlers\n"));
 315
 316         Status = AcpiEvInstallXruptHandlers ();
 317         if (ACPI_FAILURE (Status))
 318         {
 319             return_ACPI_STATUS (Status);
 320         }
 321     }
 322
 323     return_ACPI_STATUS (Status);
 324 }
 325
 326 ACPI_EXPORT_SYMBOL (AcpiEnableSubsystem)
 327
 328
 329 /*******************************************************************************
 330  *
 331  * FUNCTION:    AcpiInitializeObjects
 332  *
 333  * PARAMETERS:  Flags           - Init/enable Options
 334  *
 335  * RETURN:      Status
 336  *
 337  * DESCRIPTION: Completes namespace initialization by initializing device
 338  *              objects and executing AML code for Regions, buffers, etc.
 339  *
 340  ******************************************************************************/
 341
 342 ACPI_STATUS
 343 AcpiInitializeObjects (
 344     UINT32                  Flags)
 345 {
 346     ACPI_STATUS             Status = AE_OK;
 347
 348
 349     ACPI_FUNCTION_TRACE (AcpiInitializeObjects);
 350
 351
 352     /*
 353      * Run all _REG methods
 354      *
 355      * Note: Any objects accessed by the _REG methods will be automatically
 356      * initialized, even if they contain executable AML (see the call to
 357      * AcpiNsInitializeObjects below).
 358      */
 359     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 360     {
 361         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 362             "[Init] Executing _REG OpRegion methods\n"));
 363
 364         Status = AcpiEvInitializeOpRegions ();
 365         if (ACPI_FAILURE (Status))
 366         {
 367             return_ACPI_STATUS (Status);
 368         }
 369     }
 370
 371     /*
 372      * Execute any module-level code that was detected during the table load
 373      * phase. Although illegal since ACPI 2.0, there are many machines that
 374      * contain this type of code. Each block of detected executable AML code
 375      * outside of any control method is wrapped with a temporary control
 376      * method object and placed on a global list. The methods on this list
 377      * are executed below.
 378      */
 379     AcpiNsExecModuleCodeList ();
 380
 381     /*
 382      * Initialize the objects that remain uninitialized. This runs the
 383      * executable AML that may be part of the declaration of these objects:
 384      * OperationRegions, BufferFields, Buffers, and Packages.
 385      */
 386     if (!(Flags & ACPI_NO_OBJECT_INIT))
 387     {
 388         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 389             "[Init] Completing Initialization of ACPI Objects\n"));
 390
 391         Status = AcpiNsInitializeObjects ();
 392         if (ACPI_FAILURE (Status))
 393         {
 394             return_ACPI_STATUS (Status);
 395         }
 396     }
 397
 398     /*
 399      * Initialize all device objects in the namespace. This runs the device
 400      * _STA and _INI methods.
 401      */
 402     if (!(Flags & ACPI_NO_DEVICE_INIT))
 403     {
 404         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 405             "[Init] Initializing ACPI Devices\n"));
 406
 407         Status = AcpiNsInitializeDevices ();
 408         if (ACPI_FAILURE (Status))
 409         {
 410             return_ACPI_STATUS (Status);
 411         }
 412     }
 413
 414     /*
 415      * Initialize the GPE blocks defined in the FADT (GPE block 0 and 1).
 416      * The runtime GPEs are enabled here.
 417      *
 418      * This is where the _PRW methods are executed for the GPEs. These
 419      * methods can only be executed after the SCI and Global Lock handlers are
 420      * installed and initialized.
 421      *
 422      * GPEs can only be enabled after the _REG, _STA, and _INI methods have
 423      * been run. This ensures that all Operation Regions and all Devices have
 424      * been initialized and are ready.
 425      */
 426     if (!(Flags & ACPI_NO_EVENT_INIT))
 427     {
 428         Status = AcpiEvInstallFadtGpes ();
 429         if (ACPI_FAILURE (Status))
 430         {
 431             return (Status);
 432         }
 433     }
 434
 435     /*
 436      * Empty the caches (delete the cached objects) on the assumption that
 437      * the table load filled them up more than they will be at runtime --
 438      * thus wasting non-paged memory.
 439      */
 440     Status = AcpiPurgeCachedObjects ();
 441
 442     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 443     return_ACPI_STATUS (Status);
 444 }
 445
 446 ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
 447
 448
 449 #endif
 450
 451 /*******************************************************************************
 452  *
 453  * FUNCTION:    AcpiTerminate
 454  *
 455  * PARAMETERS:  None
 456  *
 457  * RETURN:      Status
 458  *
 459  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
 460  *
 461  ******************************************************************************/
 462
 463 ACPI_STATUS
 464 AcpiTerminate (
 465     void)
 466 {
 467     ACPI_STATUS         Status;
 468
 469
 470     ACPI_FUNCTION_TRACE (AcpiTerminate);
 471
 472
 473     /* Just exit if subsystem is already shutdown */
 474
 475     if (AcpiGbl_Shutdown)
 476     {
 477         ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
 478         return_ACPI_STATUS (AE_OK);
 479     }
 480
 481     /* Subsystem appears active, go ahead and shut it down */
 482
 483     AcpiGbl_Shutdown = TRUE;
 484     AcpiGbl_StartupFlags = 0;
 485     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
 486
 487     /* Terminate the AML Debugger if present */
 488
 489     ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
 490
 491     /* Shutdown and free all resources */
 492
 493     AcpiUtSubsystemShutdown ();
 494
 495     /* Free the mutex objects */
 496
 497     AcpiUtMutexTerminate ();
 498
 499
 500 #ifdef ACPI_DEBUGGER
 501
 502     /* Shut down the debugger */
 503
 504     AcpiDbTerminate ();
 505 #endif
 506
 507     /* Now we can shutdown the OS-dependent layer */
 508
 509     Status = AcpiOsTerminate ();
 510     return_ACPI_STATUS (Status);
 511 }
 512
 513 ACPI_EXPORT_SYMBOL (AcpiTerminate)
 514
 515
 516 #ifndef ACPI_ASL_COMPILER
 517 /*******************************************************************************
 518  *
 519  * FUNCTION:    AcpiSubsystemStatus
 520  *
 521  * PARAMETERS:  None
 522  *
 523  * RETURN:      Status of the ACPI subsystem
 524  *
 525  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 526  *              before making any other calls, to ensure the subsystem
 527  *              initialized successfully.
 528  *
 529  ******************************************************************************/
 530
 531 ACPI_STATUS
 532 AcpiSubsystemStatus (
 533     void)
 534 {
 535
 536     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 537     {
 538         return (AE_OK);
 539     }
 540     else
 541     {
 542         return (AE_ERROR);
 543     }
 544 }
 545
 546 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 547
 548
 549 /*******************************************************************************
 550  *
 551  * FUNCTION:    AcpiGetSystemInfo
 552  *
 553  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 554  *                                device
 555  *
 556  * RETURN:      Status          - the status of the call
 557  *
 558  * DESCRIPTION: This function is called to get information about the current
 559  *              state of the ACPI subsystem.  It will return system information
 560  *              in the OutBuffer.
 561  *
 562  *              If the function fails an appropriate status will be returned
 563  *              and the value of OutBuffer is undefined.
 564  *
 565  ******************************************************************************/
 566
 567 ACPI_STATUS
 568 AcpiGetSystemInfo (
 569     ACPI_BUFFER             *OutBuffer)
 570 {
 571     ACPI_SYSTEM_INFO        *InfoPtr;
 572     ACPI_STATUS             Status;
 573
 574
 575     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 576
 577
 578     /* Parameter validation */
 579
 580     Status = AcpiUtValidateBuffer (OutBuffer);
 581     if (ACPI_FAILURE (Status))
 582     {
 583         return_ACPI_STATUS (Status);
 584     }
 585
 586     /* Validate/Allocate/Clear caller buffer */
 587
 588     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 589     if (ACPI_FAILURE (Status))
 590     {
 591         return_ACPI_STATUS (Status);
 592     }
 593
 594     /*
 595      * Populate the return buffer
 596      */
 597     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 598
 599     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 600
 601     /* System flags (ACPI capabilities) */
 602
 603     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 604
 605     /* Timer resolution - 24 or 32 bits  */
 606
 607     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 608     {
 609         InfoPtr->TimerResolution = 24;
 610     }
 611     else
 612     {
 613         InfoPtr->TimerResolution = 32;
 614     }
 615
 616     /* Clear the reserved fields */
 617
 618     InfoPtr->Reserved1 = 0;
 619     InfoPtr->Reserved2 = 0;
 620
 621     /* Current debug levels */
 622
 623     InfoPtr->DebugLayer = AcpiDbgLayer;
 624     InfoPtr->DebugLevel = AcpiDbgLevel;
 625
 626     return_ACPI_STATUS (AE_OK);
 627 }
 628
 629 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 630
 631
 632 /*******************************************************************************
 633  *
 634  * FUNCTION:    AcpiGetStatistics
 635  *
 636  * PARAMETERS:  Stats           - Where the statistics are returned
 637  *
 638  * RETURN:      Status          - the status of the call
 639  *
 640  * DESCRIPTION: Get the contents of the various system counters
 641  *
 642  ******************************************************************************/
 643
 644 ACPI_STATUS
 645 AcpiGetStatistics (
 646     ACPI_STATISTICS         *Stats)
 647 {
 648     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 649
 650
 651     /* Parameter validation */
 652
 653     if (!Stats)
 654     {
 655         return_ACPI_STATUS (AE_BAD_PARAMETER);
 656     }
 657
 658     /* Various interrupt-based event counters */
 659
 660     Stats->SciCount = AcpiSciCount;
 661     Stats->GpeCount = AcpiGpeCount;
 662
 663     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 664         sizeof (AcpiFixedEventCount));
 665
 666
 667     /* Other counters */
 668
 669     Stats->MethodCount = AcpiMethodCount;
 670
 671     return_ACPI_STATUS (AE_OK);
 672 }
 673
 674 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 675
 676
 677 /*****************************************************************************
 678  *
 679  * FUNCTION:    AcpiInstallInitializationHandler
 680  *
 681  * PARAMETERS:  Handler             - Callback procedure
 682  *              Function            - Not (currently) used, see below
 683  *
 684  * RETURN:      Status
 685  *
 686  * DESCRIPTION: Install an initialization handler
 687  *
 688  * TBD: When a second function is added, must save the Function also.
 689  *
 690  ****************************************************************************/
 691
 692 ACPI_STATUS
 693 AcpiInstallInitializationHandler (
 694     ACPI_INIT_HANDLER       Handler,
 695     UINT32                  Function)
 696 {
 697
 698     if (!Handler)
 699     {
 700         return (AE_BAD_PARAMETER);
 701     }
 702
 703     if (AcpiGbl_InitHandler)
 704     {
 705         return (AE_ALREADY_EXISTS);
 706     }
 707
 708     AcpiGbl_InitHandler = Handler;
 709     return AE_OK;
 710 }
 711
 712 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 713
 714
 715 /*****************************************************************************
 716  *
 717  * FUNCTION:    AcpiPurgeCachedObjects
 718  *
 719  * PARAMETERS:  None
 720  *
 721  * RETURN:      Status
 722  *
 723  * DESCRIPTION: Empty all caches (delete the cached objects)
 724  *
 725  ****************************************************************************/
 726
 727 ACPI_STATUS
 728 AcpiPurgeCachedObjects (
 729     void)
 730 {
 731     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 732
 733     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 734     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 735     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 736     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 737     return_ACPI_STATUS (AE_OK);
 738 }
 739
 740 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 741
 742
 743 /*****************************************************************************
 744  *
 745  * FUNCTION:    AcpiInstallInterface
 746  *
 747  * PARAMETERS:  InterfaceName       - The interface to install
 748  *
 749  * RETURN:      Status
 750  *
 751  * DESCRIPTION: Install an _OSI interface to the global list
 752  *
 753  ****************************************************************************/
 754
 755 ACPI_STATUS
 756 AcpiInstallInterface (
 757     ACPI_STRING             InterfaceName)
 758 {
 759     ACPI_STATUS             Status;
 760     ACPI_INTERFACE_INFO     *InterfaceInfo;
 761
 762
 763     /* Parameter validation */
 764
 765     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 766     {
 767         return (AE_BAD_PARAMETER);
 768     }
 769
 770     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 771
 772     /* Check if the interface name is already in the global list */
 773
 774     InterfaceInfo = AcpiUtGetInterface (InterfaceName);
 775     if (InterfaceInfo)
 776     {
 777         /*
 778          * The interface already exists in the list. This is OK if the
 779          * interface has been marked invalid -- just clear the bit.
 780          */
 781         if (InterfaceInfo->Flags & ACPI_OSI_INVALID)
 782         {
 783             InterfaceInfo->Flags &= ~ACPI_OSI_INVALID;
 784             Status = AE_OK;
 785         }
 786         else
 787         {
 788             Status = AE_ALREADY_EXISTS;
 789         }
 790     }
 791     else
 792     {
 793         /* New interface name, install into the global list */
 794
 795         Status = AcpiUtInstallInterface (InterfaceName);
 796     }
 797
 798     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 799     return (Status);
 800 }
 801
 802 ACPI_EXPORT_SYMBOL (AcpiInstallInterface)
 803
 804
 805 /*****************************************************************************
 806  *
 807  * FUNCTION:    AcpiRemoveInterface
 808  *
 809  * PARAMETERS:  InterfaceName       - The interface to remove
 810  *
 811  * RETURN:      Status
 812  *
 813  * DESCRIPTION: Remove an _OSI interface from the global list
 814  *
 815  ****************************************************************************/
 816
 817 ACPI_STATUS
 818 AcpiRemoveInterface (
 819     ACPI_STRING             InterfaceName)
 820 {
 821     ACPI_STATUS             Status;
 822
 823
 824     /* Parameter validation */
 825
 826     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 827     {
 828         return (AE_BAD_PARAMETER);
 829     }
 830
 831     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 832
 833     Status = AcpiUtRemoveInterface (InterfaceName);
 834
 835     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 836     return (Status);
 837 }
 838
 839 ACPI_EXPORT_SYMBOL (AcpiRemoveInterface)
 840
 841
 842 /*****************************************************************************
 843  *
 844  * FUNCTION:    AcpiInstallInterfaceHandler
 845  *
 846  * PARAMETERS:  Handler             - The _OSI interface handler to install
 847  *                                    NULL means "remove existing handler"
 848  *
 849  * RETURN:      Status
 850  *
 851  * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
 852  *              invoked during execution of the internal implementation of
 853  *              _OSI. A NULL handler simply removes any existing handler.
 854  *
 855  ****************************************************************************/
 856
 857 ACPI_STATUS
 858 AcpiInstallInterfaceHandler (
 859     ACPI_INTERFACE_HANDLER  Handler)
 860 {
 861     ACPI_STATUS             Status = AE_OK;
 862
 863
 864     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 865
 866     if (Handler && AcpiGbl_InterfaceHandler)
 867     {
 868         Status = AE_ALREADY_EXISTS;
 869     }
 870     else
 871     {
 872         AcpiGbl_InterfaceHandler = Handler;
 873     }
 874
 875     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 876     return (Status);
 877 }
 878
 879 ACPI_EXPORT_SYMBOL (AcpiInstallInterfaceHandler)
 880
 881 #endif /* !ACPI_ASL_COMPILER */
 882