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

   1 /******************************************************************************
   2  *
   3  * Module Name: utxface - External interfaces for "global" ACPI functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2011, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #define __UTXFACE_C__
  46
  47 #include <contrib/dev/acpica/include/acpi.h>
  48 #include <contrib/dev/acpica/include/accommon.h>
  49 #include <contrib/dev/acpica/include/acevents.h>
  50 #include <contrib/dev/acpica/include/acnamesp.h>
  51 #include <contrib/dev/acpica/include/acdebug.h>
  52 #include <contrib/dev/acpica/include/actables.h>
  53
  54 #define _COMPONENT          ACPI_UTILITIES
  55         ACPI_MODULE_NAME    ("utxface")
  56
  57
  58 #ifndef ACPI_ASL_COMPILER
  59
  60 /*******************************************************************************
  61  *
  62  * FUNCTION:    AcpiInitializeSubsystem
  63  *
  64  * PARAMETERS:  None
  65  *
  66  * RETURN:      Status
  67  *
  68  * DESCRIPTION: Initializes all global variables.  This is the first function
  69  *              called, so any early initialization belongs here.
  70  *
  71  ******************************************************************************/
  72
  73 ACPI_STATUS
  74 AcpiInitializeSubsystem (
  75     void)
  76 {
  77     ACPI_STATUS             Status;
  78
  79
  80     ACPI_FUNCTION_TRACE (AcpiInitializeSubsystem);
  81
  82
  83     AcpiGbl_StartupFlags = ACPI_SUBSYSTEM_INITIALIZE;
  84     ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
  85
  86     /* Initialize the OS-Dependent layer */
  87
  88     Status = AcpiOsInitialize ();
  89     if (ACPI_FAILURE (Status))
  90     {
  91         ACPI_EXCEPTION ((AE_INFO, Status, "During OSL initialization"));
  92         return_ACPI_STATUS (Status);
  93     }
  94
  95     /* Initialize all globals used by the subsystem */
  96
  97     Status = AcpiUtInitGlobals ();
  98     if (ACPI_FAILURE (Status))
  99     {
 100         ACPI_EXCEPTION ((AE_INFO, Status, "During initialization of globals"));
 101         return_ACPI_STATUS (Status);
 102     }
 103
 104     /* Create the default mutex objects */
 105
 106     Status = AcpiUtMutexInitialize ();
 107     if (ACPI_FAILURE (Status))
 108     {
 109         ACPI_EXCEPTION ((AE_INFO, Status, "During Global Mutex creation"));
 110         return_ACPI_STATUS (Status);
 111     }
 112
 113     /*
 114      * Initialize the namespace manager and
 115      * the root of the namespace tree
 116      */
 117     Status = AcpiNsRootInitialize ();
 118     if (ACPI_FAILURE (Status))
 119     {
 120         ACPI_EXCEPTION ((AE_INFO, Status, "During Namespace initialization"));
 121         return_ACPI_STATUS (Status);
 122     }
 123
 124     /* Initialize the global OSI interfaces list with the static names */
 125
 126     Status = AcpiUtInitializeInterfaces ();
 127     if (ACPI_FAILURE (Status))
 128     {
 129         ACPI_EXCEPTION ((AE_INFO, Status, "During OSI interfaces initialization"));
 130         return_ACPI_STATUS (Status);
 131     }
 132
 133     /* If configured, initialize the AML debugger */
 134
 135     ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
 136     return_ACPI_STATUS (Status);
 137 }
 138
 139 ACPI_EXPORT_SYMBOL (AcpiInitializeSubsystem)
 140
 141
 142 /*******************************************************************************
 143  *
 144  * FUNCTION:    AcpiEnableSubsystem
 145  *
 146  * PARAMETERS:  Flags           - Init/enable Options
 147  *
 148  * RETURN:      Status
 149  *
 150  * DESCRIPTION: Completes the subsystem initialization including hardware.
 151  *              Puts system into ACPI mode if it isn't already.
 152  *
 153  ******************************************************************************/
 154
 155 ACPI_STATUS
 156 AcpiEnableSubsystem (
 157     UINT32                  Flags)
 158 {
 159     ACPI_STATUS             Status = AE_OK;
 160
 161
 162     ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
 163
 164
 165     /* Enable ACPI mode */
 166
 167     if (!(Flags & ACPI_NO_ACPI_ENABLE))
 168     {
 169         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
 170
 171         AcpiGbl_OriginalMode = AcpiHwGetMode();
 172
 173         Status = AcpiEnable ();
 174         if (ACPI_FAILURE (Status))
 175         {
 176             ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
 177             return_ACPI_STATUS (Status);
 178         }
 179     }
 180
 181     /*
 182      * Obtain a permanent mapping for the FACS. This is required for the
 183      * Global Lock and the Firmware Waking Vector
 184      */
 185     Status = AcpiTbInitializeFacs ();
 186     if (ACPI_FAILURE (Status))
 187     {
 188         ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
 189         return_ACPI_STATUS (Status);
 190     }
 191
 192     /*
 193      * Install the default OpRegion handlers.  These are installed unless
 194      * other handlers have already been installed via the
 195      * InstallAddressSpaceHandler interface.
 196      */
 197     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 198     {
 199         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 200             "[Init] Installing default address space handlers\n"));
 201
 202         Status = AcpiEvInstallRegionHandlers ();
 203         if (ACPI_FAILURE (Status))
 204         {
 205             return_ACPI_STATUS (Status);
 206         }
 207     }
 208
 209     /*
 210      * Initialize ACPI Event handling (Fixed and General Purpose)
 211      *
 212      * Note1: We must have the hardware and events initialized before we can
 213      * execute any control methods safely. Any control method can require
 214      * ACPI hardware support, so the hardware must be fully initialized before
 215      * any method execution!
 216      *
 217      * Note2: Fixed events are initialized and enabled here. GPEs are
 218      * initialized, but cannot be enabled until after the hardware is
 219      * completely initialized (SCI and GlobalLock activated) and the various
 220      * initialization control methods are run (_REG, _STA, _INI) on the
 221      * entire namespace.
 222      */
 223     if (!(Flags & ACPI_NO_EVENT_INIT))
 224     {
 225         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 226             "[Init] Initializing ACPI events\n"));
 227
 228         Status = AcpiEvInitializeEvents ();
 229         if (ACPI_FAILURE (Status))
 230         {
 231             return_ACPI_STATUS (Status);
 232         }
 233     }
 234
 235     /*
 236      * Install the SCI handler and Global Lock handler. This completes the
 237      * hardware initialization.
 238      */
 239     if (!(Flags & ACPI_NO_HANDLER_INIT))
 240     {
 241         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 242             "[Init] Installing SCI/GL handlers\n"));
 243
 244         Status = AcpiEvInstallXruptHandlers ();
 245         if (ACPI_FAILURE (Status))
 246         {
 247             return_ACPI_STATUS (Status);
 248         }
 249     }
 250
 251     return_ACPI_STATUS (Status);
 252 }
 253
 254 ACPI_EXPORT_SYMBOL (AcpiEnableSubsystem)
 255
 256
 257 /*******************************************************************************
 258  *
 259  * FUNCTION:    AcpiInitializeObjects
 260  *
 261  * PARAMETERS:  Flags           - Init/enable Options
 262  *
 263  * RETURN:      Status
 264  *
 265  * DESCRIPTION: Completes namespace initialization by initializing device
 266  *              objects and executing AML code for Regions, buffers, etc.
 267  *
 268  ******************************************************************************/
 269
 270 ACPI_STATUS
 271 AcpiInitializeObjects (
 272     UINT32                  Flags)
 273 {
 274     ACPI_STATUS             Status = AE_OK;
 275
 276
 277     ACPI_FUNCTION_TRACE (AcpiInitializeObjects);
 278
 279
 280     /*
 281      * Run all _REG methods
 282      *
 283      * Note: Any objects accessed by the _REG methods will be automatically
 284      * initialized, even if they contain executable AML (see the call to
 285      * AcpiNsInitializeObjects below).
 286      */
 287     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 288     {
 289         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 290             "[Init] Executing _REG OpRegion methods\n"));
 291
 292         Status = AcpiEvInitializeOpRegions ();
 293         if (ACPI_FAILURE (Status))
 294         {
 295             return_ACPI_STATUS (Status);
 296         }
 297     }
 298
 299     /*
 300      * Execute any module-level code that was detected during the table load
 301      * phase. Although illegal since ACPI 2.0, there are many machines that
 302      * contain this type of code. Each block of detected executable AML code
 303      * outside of any control method is wrapped with a temporary control
 304      * method object and placed on a global list. The methods on this list
 305      * are executed below.
 306      */
 307     AcpiNsExecModuleCodeList ();
 308
 309     /*
 310      * Initialize the objects that remain uninitialized. This runs the
 311      * executable AML that may be part of the declaration of these objects:
 312      * OperationRegions, BufferFields, Buffers, and Packages.
 313      */
 314     if (!(Flags & ACPI_NO_OBJECT_INIT))
 315     {
 316         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 317             "[Init] Completing Initialization of ACPI Objects\n"));
 318
 319         Status = AcpiNsInitializeObjects ();
 320         if (ACPI_FAILURE (Status))
 321         {
 322             return_ACPI_STATUS (Status);
 323         }
 324     }
 325
 326     /*
 327      * Initialize all device objects in the namespace. This runs the device
 328      * _STA and _INI methods.
 329      */
 330     if (!(Flags & ACPI_NO_DEVICE_INIT))
 331     {
 332         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 333             "[Init] Initializing ACPI Devices\n"));
 334
 335         Status = AcpiNsInitializeDevices ();
 336         if (ACPI_FAILURE (Status))
 337         {
 338             return_ACPI_STATUS (Status);
 339         }
 340     }
 341
 342     /*
 343      * Empty the caches (delete the cached objects) on the assumption that
 344      * the table load filled them up more than they will be at runtime --
 345      * thus wasting non-paged memory.
 346      */
 347     Status = AcpiPurgeCachedObjects ();
 348
 349     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 350     return_ACPI_STATUS (Status);
 351 }
 352
 353 ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
 354
 355
 356 #endif
 357
 358 /*******************************************************************************
 359  *
 360  * FUNCTION:    AcpiTerminate
 361  *
 362  * PARAMETERS:  None
 363  *
 364  * RETURN:      Status
 365  *
 366  * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
 367  *
 368  ******************************************************************************/
 369
 370 ACPI_STATUS
 371 AcpiTerminate (
 372     void)
 373 {
 374     ACPI_STATUS         Status;
 375
 376
 377     ACPI_FUNCTION_TRACE (AcpiTerminate);
 378
 379
 380     /* Just exit if subsystem is already shutdown */
 381
 382     if (AcpiGbl_Shutdown)
 383     {
 384         ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
 385         return_ACPI_STATUS (AE_OK);
 386     }
 387
 388     /* Subsystem appears active, go ahead and shut it down */
 389
 390     AcpiGbl_Shutdown = TRUE;
 391     AcpiGbl_StartupFlags = 0;
 392     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
 393
 394     /* Terminate the AML Debugger if present */
 395
 396     ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
 397
 398     /* Shutdown and free all resources */
 399
 400     AcpiUtSubsystemShutdown ();
 401
 402     /* Free the mutex objects */
 403
 404     AcpiUtMutexTerminate ();
 405
 406
 407 #ifdef ACPI_DEBUGGER
 408
 409     /* Shut down the debugger */
 410
 411     AcpiDbTerminate ();
 412 #endif
 413
 414     /* Now we can shutdown the OS-dependent layer */
 415
 416     Status = AcpiOsTerminate ();
 417     return_ACPI_STATUS (Status);
 418 }
 419
 420 ACPI_EXPORT_SYMBOL (AcpiTerminate)
 421
 422
 423 #ifndef ACPI_ASL_COMPILER
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    AcpiSubsystemStatus
 427  *
 428  * PARAMETERS:  None
 429  *
 430  * RETURN:      Status of the ACPI subsystem
 431  *
 432  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 433  *              before making any other calls, to ensure the subsystem
 434  *              initialized successfully.
 435  *
 436  ******************************************************************************/
 437
 438 ACPI_STATUS
 439 AcpiSubsystemStatus (
 440     void)
 441 {
 442
 443     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 444     {
 445         return (AE_OK);
 446     }
 447     else
 448     {
 449         return (AE_ERROR);
 450     }
 451 }
 452
 453 ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
 454
 455
 456 /*******************************************************************************
 457  *
 458  * FUNCTION:    AcpiGetSystemInfo
 459  *
 460  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 461  *                                device
 462  *
 463  * RETURN:      Status          - the status of the call
 464  *
 465  * DESCRIPTION: This function is called to get information about the current
 466  *              state of the ACPI subsystem.  It will return system information
 467  *              in the OutBuffer.
 468  *
 469  *              If the function fails an appropriate status will be returned
 470  *              and the value of OutBuffer is undefined.
 471  *
 472  ******************************************************************************/
 473
 474 ACPI_STATUS
 475 AcpiGetSystemInfo (
 476     ACPI_BUFFER             *OutBuffer)
 477 {
 478     ACPI_SYSTEM_INFO        *InfoPtr;
 479     ACPI_STATUS             Status;
 480
 481
 482     ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
 483
 484
 485     /* Parameter validation */
 486
 487     Status = AcpiUtValidateBuffer (OutBuffer);
 488     if (ACPI_FAILURE (Status))
 489     {
 490         return_ACPI_STATUS (Status);
 491     }
 492
 493     /* Validate/Allocate/Clear caller buffer */
 494
 495     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 496     if (ACPI_FAILURE (Status))
 497     {
 498         return_ACPI_STATUS (Status);
 499     }
 500
 501     /*
 502      * Populate the return buffer
 503      */
 504     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 505
 506     InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
 507
 508     /* System flags (ACPI capabilities) */
 509
 510     InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
 511
 512     /* Timer resolution - 24 or 32 bits  */
 513
 514     if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
 515     {
 516         InfoPtr->TimerResolution = 24;
 517     }
 518     else
 519     {
 520         InfoPtr->TimerResolution = 32;
 521     }
 522
 523     /* Clear the reserved fields */
 524
 525     InfoPtr->Reserved1 = 0;
 526     InfoPtr->Reserved2 = 0;
 527
 528     /* Current debug levels */
 529
 530     InfoPtr->DebugLayer = AcpiDbgLayer;
 531     InfoPtr->DebugLevel = AcpiDbgLevel;
 532
 533     return_ACPI_STATUS (AE_OK);
 534 }
 535
 536 ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
 537
 538
 539 /*******************************************************************************
 540  *
 541  * FUNCTION:    AcpiGetStatistics
 542  *
 543  * PARAMETERS:  Stats           - Where the statistics are returned
 544  *
 545  * RETURN:      Status          - the status of the call
 546  *
 547  * DESCRIPTION: Get the contents of the various system counters
 548  *
 549  ******************************************************************************/
 550
 551 ACPI_STATUS
 552 AcpiGetStatistics (
 553     ACPI_STATISTICS         *Stats)
 554 {
 555     ACPI_FUNCTION_TRACE (AcpiGetStatistics);
 556
 557
 558     /* Parameter validation */
 559
 560     if (!Stats)
 561     {
 562         return_ACPI_STATUS (AE_BAD_PARAMETER);
 563     }
 564
 565     /* Various interrupt-based event counters */
 566
 567     Stats->SciCount = AcpiSciCount;
 568     Stats->GpeCount = AcpiGpeCount;
 569
 570     ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
 571         sizeof (AcpiFixedEventCount));
 572
 573
 574     /* Other counters */
 575
 576     Stats->MethodCount = AcpiMethodCount;
 577
 578     return_ACPI_STATUS (AE_OK);
 579 }
 580
 581 ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
 582
 583
 584 /*****************************************************************************
 585  *
 586  * FUNCTION:    AcpiInstallInitializationHandler
 587  *
 588  * PARAMETERS:  Handler             - Callback procedure
 589  *              Function            - Not (currently) used, see below
 590  *
 591  * RETURN:      Status
 592  *
 593  * DESCRIPTION: Install an initialization handler
 594  *
 595  * TBD: When a second function is added, must save the Function also.
 596  *
 597  ****************************************************************************/
 598
 599 ACPI_STATUS
 600 AcpiInstallInitializationHandler (
 601     ACPI_INIT_HANDLER       Handler,
 602     UINT32                  Function)
 603 {
 604
 605     if (!Handler)
 606     {
 607         return (AE_BAD_PARAMETER);
 608     }
 609
 610     if (AcpiGbl_InitHandler)
 611     {
 612         return (AE_ALREADY_EXISTS);
 613     }
 614
 615     AcpiGbl_InitHandler = Handler;
 616     return AE_OK;
 617 }
 618
 619 ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
 620
 621
 622 /*****************************************************************************
 623  *
 624  * FUNCTION:    AcpiPurgeCachedObjects
 625  *
 626  * PARAMETERS:  None
 627  *
 628  * RETURN:      Status
 629  *
 630  * DESCRIPTION: Empty all caches (delete the cached objects)
 631  *
 632  ****************************************************************************/
 633
 634 ACPI_STATUS
 635 AcpiPurgeCachedObjects (
 636     void)
 637 {
 638     ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
 639
 640     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 641     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 642     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 643     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 644     return_ACPI_STATUS (AE_OK);
 645 }
 646
 647 ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
 648
 649
 650 /*****************************************************************************
 651  *
 652  * FUNCTION:    AcpiInstallInterface
 653  *
 654  * PARAMETERS:  InterfaceName       - The interface to install
 655  *
 656  * RETURN:      Status
 657  *
 658  * DESCRIPTION: Install an _OSI interface to the global list
 659  *
 660  ****************************************************************************/
 661
 662 ACPI_STATUS
 663 AcpiInstallInterface (
 664     ACPI_STRING             InterfaceName)
 665 {
 666     ACPI_STATUS             Status;
 667     ACPI_INTERFACE_INFO     *InterfaceInfo;
 668
 669
 670     /* Parameter validation */
 671
 672     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 673     {
 674         return (AE_BAD_PARAMETER);
 675     }
 676
 677     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 678
 679     /* Check if the interface name is already in the global list */
 680
 681     InterfaceInfo = AcpiUtGetInterface (InterfaceName);
 682     if (InterfaceInfo)
 683     {
 684         /*
 685          * The interface already exists in the list. This is OK if the
 686          * interface has been marked invalid -- just clear the bit.
 687          */
 688         if (InterfaceInfo->Flags & ACPI_OSI_INVALID)
 689         {
 690             InterfaceInfo->Flags &= ~ACPI_OSI_INVALID;
 691             Status = AE_OK;
 692         }
 693         else
 694         {
 695             Status = AE_ALREADY_EXISTS;
 696         }
 697     }
 698     else
 699     {
 700         /* New interface name, install into the global list */
 701
 702         Status = AcpiUtInstallInterface (InterfaceName);
 703     }
 704
 705     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 706     return (Status);
 707 }
 708
 709 ACPI_EXPORT_SYMBOL (AcpiInstallInterface)
 710
 711
 712 /*****************************************************************************
 713  *
 714  * FUNCTION:    AcpiRemoveInterface
 715  *
 716  * PARAMETERS:  InterfaceName       - The interface to remove
 717  *
 718  * RETURN:      Status
 719  *
 720  * DESCRIPTION: Remove an _OSI interface from the global list
 721  *
 722  ****************************************************************************/
 723
 724 ACPI_STATUS
 725 AcpiRemoveInterface (
 726     ACPI_STRING             InterfaceName)
 727 {
 728     ACPI_STATUS             Status;
 729
 730
 731     /* Parameter validation */
 732
 733     if (!InterfaceName || (ACPI_STRLEN (InterfaceName) == 0))
 734     {
 735         return (AE_BAD_PARAMETER);
 736     }
 737
 738     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 739
 740     Status = AcpiUtRemoveInterface (InterfaceName);
 741
 742     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 743     return (Status);
 744 }
 745
 746 ACPI_EXPORT_SYMBOL (AcpiRemoveInterface)
 747
 748
 749 /*****************************************************************************
 750  *
 751  * FUNCTION:    AcpiInstallInterfaceHandler
 752  *
 753  * PARAMETERS:  Handler             - The _OSI interface handler to install
 754  *                                    NULL means "remove existing handler"
 755  *
 756  * RETURN:      Status
 757  *
 758  * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
 759  *              invoked during execution of the internal implementation of
 760  *              _OSI. A NULL handler simply removes any existing handler.
 761  *
 762  ****************************************************************************/
 763
 764 ACPI_STATUS
 765 AcpiInstallInterfaceHandler (
 766     ACPI_INTERFACE_HANDLER  Handler)
 767 {
 768     ACPI_STATUS             Status = AE_OK;
 769
 770
 771     (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
 772
 773     if (Handler && AcpiGbl_InterfaceHandler)
 774     {
 775         Status = AE_ALREADY_EXISTS;
 776     }
 777     else
 778     {
 779         AcpiGbl_InterfaceHandler = Handler;
 780     }
 781
 782     AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 783     return (Status);
 784 }
 785
 786 ACPI_EXPORT_SYMBOL (AcpiInstallInterfaceHandler)
 787
 788 #endif /* !ACPI_ASL_COMPILER */
 789