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      * Empty the caches (delete the cached objects) on the assumption that
 416      * the table load filled them up more than they will be at runtime --
 417      * thus wasting non-paged memory.
 418      */
 419     Status = AcpiPurgeCachedObjects ();
 420
 421     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 422     return_ACPI_STATUS (Status);
 423 }
 424
 425 ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
 426
 427
 428 #endif
 429
 430 /*******************************************************************************
 431  *
 432  * FUNCTION:    AcpiTerminate
 433  *
 434  * PARAMETERS:  None
 435  *
 436  * RETURN:      Status
 437  *
 438  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
 439  *
 440  ******************************************************************************/
 441
 442 ACPI_STATUS
 443 AcpiTerminate (
 444     void)
 445 {
 446     ACPI_STATUS         Status;
 447
 448
 449     ACPI_FUNCTION_TRACE (AcpiTerminate);
 450
 451
 452     /* Just exit if subsystem is already shutdown */
 453
 454     if (AcpiGbl_Shutdown)
 455     {
 456         ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
 457         return_ACPI_STATUS (AE_OK);
 458     }
 459
 460     /* Subsystem appears active, go ahead and shut it down */
 461
 462     AcpiGbl_Shutdown = TRUE;
 463     AcpiGbl_StartupFlags = 0;
 464     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
 465
 466     /* Terminate the AML Debugger if present */
 467
 468     ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
 469
 470     /* Shutdown and free all resources */
 471
 472     AcpiUtSubsystemShutdown ();
 473
 474     /* Free the mutex objects */
 475
 476     AcpiUtMutexTerminate ();
 477
 478
 479 #ifdef ACPI_DEBUGGER
 480
 481     /* Shut down the debugger */
 482
 483     AcpiDbTerminate ();
 484 #endif
 485
 486     /* Now we can shutdown the OS-dependent layer */
 487
 488     Status = AcpiOsTerminate ();
 489     return_ACPI_STATUS (Status);
 490 }
 491
 492 ACPI_EXPORT_SYMBOL (AcpiTerminate)
 493
 494
 495 #ifndef ACPI_ASL_COMPILER
 496 /*******************************************************************************
 497  *
 498  * FUNCTION:    AcpiSubsystemStatus
 499  *
 500  * PARAMETERS:  None
 501  *
 502  * RETURN:      Status of the ACPI subsystem
 503  *
 504  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 505  *              before making any other calls, to ensure the subsystem
 506  *              initialized successfully.
 507  *
 508  ******************************************************************************/
 509
 510 ACPI_STATUS
 511 AcpiSubsystemStatus (
 512     void)
 513 {
 514
 515     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 516     {
 517         return (AE_OK);
 518     }
 519     else
 520     {
 521         return (AE_ERROR);
 522     }
 523 }
 524
 525 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 526
 527
 528 /*******************************************************************************
 529  *
 530  * FUNCTION:    AcpiGetSystemInfo
 531  *
 532  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 533  *                                device
 534  *
 535  * RETURN:      Status          - the status of the call
 536  *
 537  * DESCRIPTION: This function is called to get information about the current
 538  *              state of the ACPI subsystem.  It will return system information
 539  *              in the OutBuffer.
 540  *
 541  *              If the function fails an appropriate status will be returned
 542  *              and the value of OutBuffer is undefined.
 543  *
 544  ******************************************************************************/
 545
 546 ACPI_STATUS
 547 AcpiGetSystemInfo (
 548     ACPI_BUFFER             *OutBuffer)
 549 {
 550     ACPI_SYSTEM_INFO        *InfoPtr;
 551     ACPI_STATUS             Status;
 552
 553
 554     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 555
 556
 557     /* Parameter validation */
 558
 559     Status = AcpiUtValidateBuffer (OutBuffer);
 560     if (ACPI_FAILURE (Status))
 561     {
 562         return_ACPI_STATUS (Status);
 563     }
 564
 565     /* Validate/Allocate/Clear caller buffer */
 566
 567     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 568     if (ACPI_FAILURE (Status))
 569     {
 570         return_ACPI_STATUS (Status);
 571     }
 572
 573     /*
 574      * Populate the return buffer
 575      */
 576     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 577
 578     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 579
 580     /* System flags (ACPI capabilities) */
 581
 582     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 583
 584     /* Timer resolution - 24 or 32 bits  */
 585
 586     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 587     {
 588         InfoPtr->TimerResolution = 24;
 589     }
 590     else
 591     {
 592         InfoPtr->TimerResolution = 32;
 593     }
 594
 595     /* Clear the reserved fields */
 596
 597     InfoPtr->Reserved1 = 0;
 598     InfoPtr->Reserved2 = 0;
 599
 600     /* Current debug levels */
 601
 602     InfoPtr->DebugLayer = AcpiDbgLayer;
 603     InfoPtr->DebugLevel = AcpiDbgLevel;
 604
 605     return_ACPI_STATUS (AE_OK);
 606 }
 607
 608 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 609
 610
 611 /*******************************************************************************
 612  *
 613  * FUNCTION:    AcpiGetStatistics
 614  *
 615  * PARAMETERS:  Stats           - Where the statistics are returned
 616  *
 617  * RETURN:      Status          - the status of the call
 618  *
 619  * DESCRIPTION: Get the contents of the various system counters
 620  *
 621  ******************************************************************************/
 622
 623 ACPI_STATUS
 624 AcpiGetStatistics (
 625     ACPI_STATISTICS         *Stats)
 626 {
 627     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 628
 629
 630     /* Parameter validation */
 631
 632     if (!Stats)
 633     {
 634         return_ACPI_STATUS (AE_BAD_PARAMETER);
 635     }
 636
 637     /* Various interrupt-based event counters */
 638
 639     Stats->SciCount = AcpiSciCount;
 640     Stats->GpeCount = AcpiGpeCount;
 641
 642     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 643         sizeof (AcpiFixedEventCount));
 644
 645
 646     /* Other counters */
 647
 648     Stats->MethodCount = AcpiMethodCount;
 649
 650     return_ACPI_STATUS (AE_OK);
 651 }
 652
 653 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 654
 655
 656 /*****************************************************************************
 657  *
 658  * FUNCTION:    AcpiInstallInitializationHandler
 659  *
 660  * PARAMETERS:  Handler             - Callback procedure
 661  *              Function            - Not (currently) used, see below
 662  *
 663  * RETURN:      Status
 664  *
 665  * DESCRIPTION: Install an initialization handler
 666  *
 667  * TBD: When a second function is added, must save the Function also.
 668  *
 669  ****************************************************************************/
 670
 671 ACPI_STATUS
 672 AcpiInstallInitializationHandler (
 673     ACPI_INIT_HANDLER       Handler,
 674     UINT32                  Function)
 675 {
 676
 677     if (!Handler)
 678     {
 679         return (AE_BAD_PARAMETER);
 680     }
 681
 682     if (AcpiGbl_InitHandler)
 683     {
 684         return (AE_ALREADY_EXISTS);
 685     }
 686
 687     AcpiGbl_InitHandler = Handler;
 688     return AE_OK;
 689 }
 690
 691 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 692
 693
 694 /*****************************************************************************
 695  *
 696  * FUNCTION:    AcpiPurgeCachedObjects
 697  *
 698  * PARAMETERS:  None
 699  *
 700  * RETURN:      Status
 701  *
 702  * DESCRIPTION: Empty all caches (delete the cached objects)
 703  *
 704  ****************************************************************************/
 705
 706 ACPI_STATUS
 707 AcpiPurgeCachedObjects (
 708     void)
 709 {
 710     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 711
 712     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 713     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 714     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 715     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 716     return_ACPI_STATUS (AE_OK);
 717 }
 718
 719 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 720
 721
 722 /*****************************************************************************
 723  *
 724  * FUNCTION:    AcpiInstallInterface
 725  *
 726  * PARAMETERS:  InterfaceName       - The interface to install
 727  *
 728  * RETURN:      Status
 729  *
 730  * DESCRIPTION: Install an _OSI interface to the global list
 731  *
 732  ****************************************************************************/
 733
 734 ACPI_STATUS
 735 AcpiInstallInterface (
 736     ACPI_STRING             InterfaceName)
 737 {
 738     ACPI_STATUS             Status;
 739     ACPI_INTERFACE_INFO     *InterfaceInfo;
 740
 741
 742     /* Parameter validation */
 743
 744     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 745     {
 746         return (AE_BAD_PARAMETER);
 747     }
 748
 749     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 750
 751     /* Check if the interface name is already in the global list */
 752
 753     InterfaceInfo = AcpiUtGetInterface (InterfaceName);
 754     if (InterfaceInfo)
 755     {
 756         /*
 757          * The interface already exists in the list. This is OK if the
 758          * interface has been marked invalid -- just clear the bit.
 759          */
 760         if (InterfaceInfo->Flags & ACPI_OSI_INVALID)
 761         {
 762             InterfaceInfo->Flags &= ~ACPI_OSI_INVALID;
 763             Status = AE_OK;
 764         }
 765         else
 766         {
 767             Status = AE_ALREADY_EXISTS;
 768         }
 769     }
 770     else
 771     {
 772         /* New interface name, install into the global list */
 773
 774         Status = AcpiUtInstallInterface (InterfaceName);
 775     }
 776
 777     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 778     return (Status);
 779 }
 780
 781 ACPI_EXPORT_SYMBOL (AcpiInstallInterface)
 782
 783
 784 /*****************************************************************************
 785  *
 786  * FUNCTION:    AcpiRemoveInterface
 787  *
 788  * PARAMETERS:  InterfaceName       - The interface to remove
 789  *
 790  * RETURN:      Status
 791  *
 792  * DESCRIPTION: Remove an _OSI interface from the global list
 793  *
 794  ****************************************************************************/
 795
 796 ACPI_STATUS
 797 AcpiRemoveInterface (
 798     ACPI_STRING             InterfaceName)
 799 {
 800     ACPI_STATUS             Status;
 801
 802
 803     /* Parameter validation */
 804
 805     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 806     {
 807         return (AE_BAD_PARAMETER);
 808     }
 809
 810     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 811
 812     Status = AcpiUtRemoveInterface (InterfaceName);
 813
 814     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 815     return (Status);
 816 }
 817
 818 ACPI_EXPORT_SYMBOL (AcpiRemoveInterface)
 819
 820
 821 /*****************************************************************************
 822  *
 823  * FUNCTION:    AcpiInstallInterfaceHandler
 824  *
 825  * PARAMETERS:  Handler             - The _OSI interface handler to install
 826  *                                    NULL means "remove existing handler"
 827  *
 828  * RETURN:      Status
 829  *
 830  * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
 831  *              invoked during execution of the internal implementation of
 832  *              _OSI. A NULL handler simply removes any existing handler.
 833  *
 834  ****************************************************************************/
 835
 836 ACPI_STATUS
 837 AcpiInstallInterfaceHandler (
 838     ACPI_INTERFACE_HANDLER  Handler)
 839 {
 840     ACPI_STATUS             Status = AE_OK;
 841
 842
 843     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 844
 845     if (Handler && AcpiGbl_InterfaceHandler)
 846     {
 847         Status = AE_ALREADY_EXISTS;
 848     }
 849     else
 850     {
 851         AcpiGbl_InterfaceHandler = Handler;
 852     }
 853
 854     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 855     return (Status);
 856 }
 857
 858 ACPI_EXPORT_SYMBOL (AcpiInstallInterfaceHandler)
 859
 860 #endif /* !ACPI_ASL_COMPILER */
 861