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 - 2009, 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     /* If configured, initialize the AML debugger */
 197
 198     ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
 199     return_ACPI_STATUS (Status);
 200 }
 201
 202 ACPI_EXPORT_SYMBOL (AcpiInitializeSubsystem)
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    AcpiEnableSubsystem
 208  *
 209  * PARAMETERS:  Flags           - Init/enable Options
 210  *
 211  * RETURN:      Status
 212  *
 213  * DESCRIPTION: Completes the subsystem initialization including hardware.
 214  *              Puts system into ACPI mode if it isn't already.
 215  *
 216  ******************************************************************************/
 217
 218 ACPI_STATUS
 219 AcpiEnableSubsystem (
 220     UINT32                  Flags)
 221 {
 222     ACPI_STATUS             Status = AE_OK;
 223
 224
 225     ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
 226
 227
 228     /* Enable ACPI mode */
 229
 230     if (!(Flags & ACPI_NO_ACPI_ENABLE))
 231     {
 232         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
 233
 234         AcpiGbl_OriginalMode = AcpiHwGetMode();
 235
 236         Status = AcpiEnable ();
 237         if (ACPI_FAILURE (Status))
 238         {
 239             ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
 240             return_ACPI_STATUS (Status);
 241         }
 242     }
 243
 244     /*
 245      * Obtain a permanent mapping for the FACS. This is required for the
 246      * Global Lock and the Firmware Waking Vector
 247      */
 248     Status = AcpiTbInitializeFacs ();
 249     if (ACPI_FAILURE (Status))
 250     {
 251         ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
 252         return_ACPI_STATUS (Status);
 253     }
 254
 255     /*
 256      * Install the default OpRegion handlers.  These are installed unless
 257      * other handlers have already been installed via the
 258      * InstallAddressSpaceHandler interface.
 259      */
 260     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 261     {
 262         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 263             "[Init] Installing default address space handlers\n"));
 264
 265         Status = AcpiEvInstallRegionHandlers ();
 266         if (ACPI_FAILURE (Status))
 267         {
 268             return_ACPI_STATUS (Status);
 269         }
 270     }
 271
 272     /*
 273      * Initialize ACPI Event handling (Fixed and General Purpose)
 274      *
 275      * Note1: We must have the hardware and events initialized before we can
 276      * execute any control methods safely. Any control method can require
 277      * ACPI hardware support, so the hardware must be fully initialized before
 278      * any method execution!
 279      *
 280      * Note2: Fixed events are initialized and enabled here. GPEs are
 281      * initialized, but cannot be enabled until after the hardware is
 282      * completely initialized (SCI and GlobalLock activated) and the various
 283      * initialization control methods are run (_REG, _STA, _INI) on the
 284      * entire namespace.
 285      */
 286     if (!(Flags & ACPI_NO_EVENT_INIT))
 287     {
 288         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 289             "[Init] Initializing ACPI events\n"));
 290
 291         Status = AcpiEvInitializeEvents ();
 292         if (ACPI_FAILURE (Status))
 293         {
 294             return_ACPI_STATUS (Status);
 295         }
 296     }
 297
 298     /*
 299      * Install the SCI handler and Global Lock handler. This completes the
 300      * hardware initialization.
 301      */
 302     if (!(Flags & ACPI_NO_HANDLER_INIT))
 303     {
 304         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 305             "[Init] Installing SCI/GL handlers\n"));
 306
 307         Status = AcpiEvInstallXruptHandlers ();
 308         if (ACPI_FAILURE (Status))
 309         {
 310             return_ACPI_STATUS (Status);
 311         }
 312     }
 313
 314     return_ACPI_STATUS (Status);
 315 }
 316
 317 ACPI_EXPORT_SYMBOL (AcpiEnableSubsystem)
 318
 319
 320 /*******************************************************************************
 321  *
 322  * FUNCTION:    AcpiInitializeObjects
 323  *
 324  * PARAMETERS:  Flags           - Init/enable Options
 325  *
 326  * RETURN:      Status
 327  *
 328  * DESCRIPTION: Completes namespace initialization by initializing device
 329  *              objects and executing AML code for Regions, buffers, etc.
 330  *
 331  ******************************************************************************/
 332
 333 ACPI_STATUS
 334 AcpiInitializeObjects (
 335     UINT32                  Flags)
 336 {
 337     ACPI_STATUS             Status = AE_OK;
 338
 339
 340     ACPI_FUNCTION_TRACE (AcpiInitializeObjects);
 341
 342
 343     /*
 344      * Run all _REG methods
 345      *
 346      * Note: Any objects accessed by the _REG methods will be automatically
 347      * initialized, even if they contain executable AML (see the call to
 348      * AcpiNsInitializeObjects below).
 349      */
 350     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 351     {
 352         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 353             "[Init] Executing _REG OpRegion methods\n"));
 354
 355         Status = AcpiEvInitializeOpRegions ();
 356         if (ACPI_FAILURE (Status))
 357         {
 358             return_ACPI_STATUS (Status);
 359         }
 360     }
 361
 362     /*
 363      * Initialize the objects that remain uninitialized. This runs the
 364      * executable AML that may be part of the declaration of these objects:
 365      * OperationRegions, BufferFields, Buffers, and Packages.
 366      */
 367     if (!(Flags & ACPI_NO_OBJECT_INIT))
 368     {
 369         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 370             "[Init] Completing Initialization of ACPI Objects\n"));
 371
 372         Status = AcpiNsInitializeObjects ();
 373         if (ACPI_FAILURE (Status))
 374         {
 375             return_ACPI_STATUS (Status);
 376         }
 377     }
 378
 379     /*
 380      * Initialize all device objects in the namespace. This runs the device
 381      * _STA and _INI methods.
 382      */
 383     if (!(Flags & ACPI_NO_DEVICE_INIT))
 384     {
 385         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 386             "[Init] Initializing ACPI Devices\n"));
 387
 388         Status = AcpiNsInitializeDevices ();
 389         if (ACPI_FAILURE (Status))
 390         {
 391             return_ACPI_STATUS (Status);
 392         }
 393     }
 394
 395     /*
 396      * Initialize the GPE blocks defined in the FADT (GPE block 0 and 1).
 397      * The runtime GPEs are enabled here.
 398      *
 399      * This is where the _PRW methods are executed for the GPEs. These
 400      * methods can only be executed after the SCI and Global Lock handlers are
 401      * installed and initialized.
 402      *
 403      * GPEs can only be enabled after the _REG, _STA, and _INI methods have
 404      * been run. This ensures that all Operation Regions and all Devices have
 405      * been initialized and are ready.
 406      */
 407     if (!(Flags & ACPI_NO_EVENT_INIT))
 408     {
 409         Status = AcpiEvInstallFadtGpes ();
 410         if (ACPI_FAILURE (Status))
 411         {
 412             return (Status);
 413         }
 414     }
 415
 416     /*
 417      * Empty the caches (delete the cached objects) on the assumption that
 418      * the table load filled them up more than they will be at runtime --
 419      * thus wasting non-paged memory.
 420      */
 421     Status = AcpiPurgeCachedObjects ();
 422
 423     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 424     return_ACPI_STATUS (Status);
 425 }
 426
 427 ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
 428
 429
 430 #endif
 431
 432 /*******************************************************************************
 433  *
 434  * FUNCTION:    AcpiTerminate
 435  *
 436  * PARAMETERS:  None
 437  *
 438  * RETURN:      Status
 439  *
 440  * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
 441  *
 442  ******************************************************************************/
 443
 444 ACPI_STATUS
 445 AcpiTerminate (
 446     void)
 447 {
 448     ACPI_STATUS         Status;
 449
 450
 451     ACPI_FUNCTION_TRACE (AcpiTerminate);
 452
 453
 454     /* Terminate the AML Debugger if present */
 455
 456     ACPI_DEBUGGER_EXEC(AcpiGbl_DbTerminateThreads = TRUE);
 457
 458     /* Shutdown and free all resources */
 459
 460     AcpiUtSubsystemShutdown ();
 461
 462
 463     /* Free the mutex objects */
 464
 465     AcpiUtMutexTerminate ();
 466
 467
 468 #ifdef ACPI_DEBUGGER
 469
 470     /* Shut down the debugger */
 471
 472     AcpiDbTerminate ();
 473 #endif
 474
 475     /* Now we can shutdown the OS-dependent layer */
 476
 477     Status = AcpiOsTerminate ();
 478     return_ACPI_STATUS (Status);
 479 }
 480
 481 ACPI_EXPORT_SYMBOL (AcpiTerminate)
 482
 483 #ifndef ACPI_ASL_COMPILER
 484
 485 /*******************************************************************************
 486  *
 487  * FUNCTION:    AcpiSubsystemStatus
 488  *
 489  * PARAMETERS:  None
 490  *
 491  * RETURN:      Status of the ACPI subsystem
 492  *
 493  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 494  *              before making any other calls, to ensure the subsystem
 495  *              initialized successfully.
 496  *
 497  ******************************************************************************/
 498
 499 ACPI_STATUS
 500 AcpiSubsystemStatus (
 501     void)
 502 {
 503
 504     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 505     {
 506         return (AE_OK);
 507     }
 508     else
 509     {
 510         return (AE_ERROR);
 511     }
 512 }
 513
 514 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 515
 516
 517 /*******************************************************************************
 518  *
 519  * FUNCTION:    AcpiGetSystemInfo
 520  *
 521  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 522  *                                device
 523  *
 524  * RETURN:      Status          - the status of the call
 525  *
 526  * DESCRIPTION: This function is called to get information about the current
 527  *              state of the ACPI subsystem.  It will return system information
 528  *              in the OutBuffer.
 529  *
 530  *              If the function fails an appropriate status will be returned
 531  *              and the value of OutBuffer is undefined.
 532  *
 533  ******************************************************************************/
 534
 535 ACPI_STATUS
 536 AcpiGetSystemInfo (
 537     ACPI_BUFFER             *OutBuffer)
 538 {
 539     ACPI_SYSTEM_INFO        *InfoPtr;
 540     ACPI_STATUS             Status;
 541
 542
 543     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 544
 545
 546     /* Parameter validation */
 547
 548     Status = AcpiUtValidateBuffer (OutBuffer);
 549     if (ACPI_FAILURE (Status))
 550     {
 551         return_ACPI_STATUS (Status);
 552     }
 553
 554     /* Validate/Allocate/Clear caller buffer */
 555
 556     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 557     if (ACPI_FAILURE (Status))
 558     {
 559         return_ACPI_STATUS (Status);
 560     }
 561
 562     /*
 563      * Populate the return buffer
 564      */
 565     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 566
 567     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 568
 569     /* System flags (ACPI capabilities) */
 570
 571     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 572
 573     /* Timer resolution - 24 or 32 bits  */
 574
 575     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 576     {
 577         InfoPtr->TimerResolution = 24;
 578     }
 579     else
 580     {
 581         InfoPtr->TimerResolution = 32;
 582     }
 583
 584     /* Clear the reserved fields */
 585
 586     InfoPtr->Reserved1 = 0;
 587     InfoPtr->Reserved2 = 0;
 588
 589     /* Current debug levels */
 590
 591     InfoPtr->DebugLayer = AcpiDbgLayer;
 592     InfoPtr->DebugLevel = AcpiDbgLevel;
 593
 594     return_ACPI_STATUS (AE_OK);
 595 }
 596
 597 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 598
 599
 600 /*******************************************************************************
 601  *
 602  * FUNCTION:    AcpiGetStatistics
 603  *
 604  * PARAMETERS:  Stats           - Where the statistics are returned
 605  *
 606  * RETURN:      Status          - the status of the call
 607  *
 608  * DESCRIPTION: Get the contents of the various system counters
 609  *
 610  ******************************************************************************/
 611
 612 ACPI_STATUS
 613 AcpiGetStatistics (
 614     ACPI_STATISTICS         *Stats)
 615 {
 616     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 617
 618
 619     /* Parameter validation */
 620
 621     if (!Stats)
 622     {
 623         return_ACPI_STATUS (AE_BAD_PARAMETER);
 624     }
 625
 626     /* Various interrupt-based event counters */
 627
 628     Stats->SciCount = AcpiSciCount;
 629     Stats->GpeCount = AcpiGpeCount;
 630
 631     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 632         sizeof (AcpiFixedEventCount));
 633
 634
 635     /* Other counters */
 636
 637     Stats->MethodCount = AcpiMethodCount;
 638
 639     return_ACPI_STATUS (AE_OK);
 640 }
 641
 642 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 643
 644
 645 /*****************************************************************************
 646  *
 647  * FUNCTION:    AcpiInstallInitializationHandler
 648  *
 649  * PARAMETERS:  Handler             - Callback procedure
 650  *              Function            - Not (currently) used, see below
 651  *
 652  * RETURN:      Status
 653  *
 654  * DESCRIPTION: Install an initialization handler
 655  *
 656  * TBD: When a second function is added, must save the Function also.
 657  *
 658  ****************************************************************************/
 659
 660 ACPI_STATUS
 661 AcpiInstallInitializationHandler (
 662     ACPI_INIT_HANDLER       Handler,
 663     UINT32                  Function)
 664 {
 665
 666     if (!Handler)
 667     {
 668         return (AE_BAD_PARAMETER);
 669     }
 670
 671     if (AcpiGbl_InitHandler)
 672     {
 673         return (AE_ALREADY_EXISTS);
 674     }
 675
 676     AcpiGbl_InitHandler = Handler;
 677     return AE_OK;
 678 }
 679
 680 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 681
 682
 683 /*****************************************************************************
 684  *
 685  * FUNCTION:    AcpiPurgeCachedObjects
 686  *
 687  * PARAMETERS:  None
 688  *
 689  * RETURN:      Status
 690  *
 691  * DESCRIPTION: Empty all caches (delete the cached objects)
 692  *
 693  ****************************************************************************/
 694
 695 ACPI_STATUS
 696 AcpiPurgeCachedObjects (
 697     void)
 698 {
 699     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 700
 701     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 702     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 703     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 704     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 705     return_ACPI_STATUS (AE_OK);
 706 }
 707
 708 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 709
 710 #endif /* ACPI_ASL_COMPILER */
 711