utilities/utxface.c

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