drivers/acpi/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 "acpi.h"
 120 #include "accommon.h"
 121 #include "acevents.h"
 122 #include "acnamesp.h"
 123 #include "acdebug.h"
 124 #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      * Execute any module-level code that was detected during the table load
 364      * phase. Although illegal since ACPI 2.0, there are many machines that
 365      * contain this type of code. Each block of detected executable AML code
 366      * outside of any control method is wrapped with a temporary control
 367      * method object and placed on a global list. The methods on this list
 368      * are executed below.
 369      */
 370     AcpiNsExecModuleCodeList ();
 371
 372     /*
 373      * Initialize the objects that remain uninitialized. This runs the
 374      * executable AML that may be part of the declaration of these objects:
 375      * OperationRegions, BufferFields, Buffers, and Packages.
 376      */
 377     if (!(Flags & ACPI_NO_OBJECT_INIT))
 378     {
 379         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 380             "[Init] Completing Initialization of ACPI Objects\n"));
 381
 382         Status = AcpiNsInitializeObjects ();
 383         if (ACPI_FAILURE (Status))
 384         {
 385             return_ACPI_STATUS (Status);
 386         }
 387     }
 388
 389     /*
 390      * Initialize all device objects in the namespace. This runs the device
 391      * _STA and _INI methods.
 392      */
 393     if (!(Flags & ACPI_NO_DEVICE_INIT))
 394     {
 395         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 396             "[Init] Initializing ACPI Devices\n"));
 397
 398         Status = AcpiNsInitializeDevices ();
 399         if (ACPI_FAILURE (Status))
 400         {
 401             return_ACPI_STATUS (Status);
 402         }
 403     }
 404
 405     /*
 406      * Initialize the GPE blocks defined in the FADT (GPE block 0 and 1).
 407      * The runtime GPEs are enabled here.
 408      *
 409      * This is where the _PRW methods are executed for the GPEs. These
 410      * methods can only be executed after the SCI and Global Lock handlers are
 411      * installed and initialized.
 412      *
 413      * GPEs can only be enabled after the _REG, _STA, and _INI methods have
 414      * been run. This ensures that all Operation Regions and all Devices have
 415      * been initialized and are ready.
 416      */
 417     if (!(Flags & ACPI_NO_EVENT_INIT))
 418     {
 419         Status = AcpiEvInstallFadtGpes ();
 420         if (ACPI_FAILURE (Status))
 421         {
 422             return (Status);
 423         }
 424     }
 425
 426     /*
 427      * Empty the caches (delete the cached objects) on the assumption that
 428      * the table load filled them up more than they will be at runtime --
 429      * thus wasting non-paged memory.
 430      */
 431     Status = AcpiPurgeCachedObjects ();
 432
 433     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 434     return_ACPI_STATUS (Status);
 435 }
 436
 437 ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
 438
 439
 440 #endif
 441
 442 /*******************************************************************************
 443  *
 444  * FUNCTION:    AcpiTerminate
 445  *
 446  * PARAMETERS:  None
 447  *
 448  * RETURN:      Status
 449  *
 450  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
 451  *
 452  ******************************************************************************/
 453
 454 ACPI_STATUS
 455 AcpiTerminate (
 456     void)
 457 {
 458     ACPI_STATUS         Status;
 459
 460
 461     ACPI_FUNCTION_TRACE (AcpiTerminate);
 462
 463
 464     /* Just exit if subsystem is already shutdown */
 465
 466     if (AcpiGbl_Shutdown)
 467     {
 468         ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
 469         return_ACPI_STATUS (AE_OK);
 470     }
 471
 472     /* Subsystem appears active, go ahead and shut it down */
 473
 474     AcpiGbl_Shutdown = TRUE;
 475     AcpiGbl_StartupFlags = 0;
 476     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
 477
 478     /* Terminate the AML Debugger if present */
 479
 480     ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
 481
 482     /* Shutdown and free all resources */
 483
 484     AcpiUtSubsystemShutdown ();
 485
 486     /* Free the mutex objects */
 487
 488     AcpiUtMutexTerminate ();
 489
 490
 491 #ifdef ACPI_DEBUGGER
 492
 493     /* Shut down the debugger */
 494
 495     AcpiDbTerminate ();
 496 #endif
 497
 498     /* Now we can shutdown the OS-dependent layer */
 499
 500     Status = AcpiOsTerminate ();
 501     return_ACPI_STATUS (Status);
 502 }
 503
 504 ACPI_EXPORT_SYMBOL (AcpiTerminate)
 505
 506
 507 #ifndef ACPI_ASL_COMPILER
 508 /*******************************************************************************
 509  *
 510  * FUNCTION:    AcpiSubsystemStatus
 511  *
 512  * PARAMETERS:  None
 513  *
 514  * RETURN:      Status of the ACPI subsystem
 515  *
 516  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 517  *              before making any other calls, to ensure the subsystem
 518  *              initialized successfully.
 519  *
 520  ******************************************************************************/
 521
 522 ACPI_STATUS
 523 AcpiSubsystemStatus (
 524     void)
 525 {
 526
 527     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 528     {
 529         return (AE_OK);
 530     }
 531     else
 532     {
 533         return (AE_ERROR);
 534     }
 535 }
 536
 537 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 538
 539
 540 /*******************************************************************************
 541  *
 542  * FUNCTION:    AcpiGetSystemInfo
 543  *
 544  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 545  *                                device
 546  *
 547  * RETURN:      Status          - the status of the call
 548  *
 549  * DESCRIPTION: This function is called to get information about the current
 550  *              state of the ACPI subsystem.  It will return system information
 551  *              in the OutBuffer.
 552  *
 553  *              If the function fails an appropriate status will be returned
 554  *              and the value of OutBuffer is undefined.
 555  *
 556  ******************************************************************************/
 557
 558 ACPI_STATUS
 559 AcpiGetSystemInfo (
 560     ACPI_BUFFER             *OutBuffer)
 561 {
 562     ACPI_SYSTEM_INFO        *InfoPtr;
 563     ACPI_STATUS             Status;
 564
 565
 566     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 567
 568
 569     /* Parameter validation */
 570
 571     Status = AcpiUtValidateBuffer (OutBuffer);
 572     if (ACPI_FAILURE (Status))
 573     {
 574         return_ACPI_STATUS (Status);
 575     }
 576
 577     /* Validate/Allocate/Clear caller buffer */
 578
 579     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 580     if (ACPI_FAILURE (Status))
 581     {
 582         return_ACPI_STATUS (Status);
 583     }
 584
 585     /*
 586      * Populate the return buffer
 587      */
 588     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 589
 590     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 591
 592     /* System flags (ACPI capabilities) */
 593
 594     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 595
 596     /* Timer resolution - 24 or 32 bits  */
 597
 598     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 599     {
 600         InfoPtr->TimerResolution = 24;
 601     }
 602     else
 603     {
 604         InfoPtr->TimerResolution = 32;
 605     }
 606
 607     /* Clear the reserved fields */
 608
 609     InfoPtr->Reserved1 = 0;
 610     InfoPtr->Reserved2 = 0;
 611
 612     /* Current debug levels */
 613
 614     InfoPtr->DebugLayer = AcpiDbgLayer;
 615     InfoPtr->DebugLevel = AcpiDbgLevel;
 616
 617     return_ACPI_STATUS (AE_OK);
 618 }
 619
 620 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 621
 622
 623 /*******************************************************************************
 624  *
 625  * FUNCTION:    AcpiGetStatistics
 626  *
 627  * PARAMETERS:  Stats           - Where the statistics are returned
 628  *
 629  * RETURN:      Status          - the status of the call
 630  *
 631  * DESCRIPTION: Get the contents of the various system counters
 632  *
 633  ******************************************************************************/
 634
 635 ACPI_STATUS
 636 AcpiGetStatistics (
 637     ACPI_STATISTICS         *Stats)
 638 {
 639     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 640
 641
 642     /* Parameter validation */
 643
 644     if (!Stats)
 645     {
 646         return_ACPI_STATUS (AE_BAD_PARAMETER);
 647     }
 648
 649     /* Various interrupt-based event counters */
 650
 651     Stats->SciCount = AcpiSciCount;
 652     Stats->GpeCount = AcpiGpeCount;
 653
 654     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 655         sizeof (AcpiFixedEventCount));
 656
 657
 658     /* Other counters */
 659
 660     Stats->MethodCount = AcpiMethodCount;
 661
 662     return_ACPI_STATUS (AE_OK);
 663 }
 664
 665 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 666
 667
 668 /*****************************************************************************
 669  *
 670  * FUNCTION:    AcpiInstallInitializationHandler
 671  *
 672  * PARAMETERS:  Handler             - Callback procedure
 673  *              Function            - Not (currently) used, see below
 674  *
 675  * RETURN:      Status
 676  *
 677  * DESCRIPTION: Install an initialization handler
 678  *
 679  * TBD: When a second function is added, must save the Function also.
 680  *
 681  ****************************************************************************/
 682
 683 ACPI_STATUS
 684 AcpiInstallInitializationHandler (
 685     ACPI_INIT_HANDLER       Handler,
 686     UINT32                  Function)
 687 {
 688
 689     if (!Handler)
 690     {
 691         return (AE_BAD_PARAMETER);
 692     }
 693
 694     if (AcpiGbl_InitHandler)
 695     {
 696         return (AE_ALREADY_EXISTS);
 697     }
 698
 699     AcpiGbl_InitHandler = Handler;
 700     return AE_OK;
 701 }
 702
 703 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 704
 705
 706 /*****************************************************************************
 707  *
 708  * FUNCTION:    AcpiPurgeCachedObjects
 709  *
 710  * PARAMETERS:  None
 711  *
 712  * RETURN:      Status
 713  *
 714  * DESCRIPTION: Empty all caches (delete the cached objects)
 715  *
 716  ****************************************************************************/
 717
 718 ACPI_STATUS
 719 AcpiPurgeCachedObjects (
 720     void)
 721 {
 722     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 723
 724     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 725     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 726     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 727     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 728     return_ACPI_STATUS (AE_OK);
 729 }
 730
 731 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 732
 733 #endif /* ACPI_ASL_COMPILER */
 734