utosi.c File Reference

#include "acpi.h"
#include "accommon.h"

Include dependency graph for utosi.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_UTILITIES

Functions
ACPI_STATUS	AcpiUtInitializeInterfaces (void)
ACPI_STATUS	AcpiUtInterfaceTerminate (void)
ACPI_STATUS	AcpiUtInstallInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtRemoveInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtUpdateInterfaces (UINT8 Action)
ACPI_INTERFACE_INFO *	AcpiUtGetInterface (ACPI_STRING InterfaceName)
ACPI_STATUS	AcpiUtOsiImplementation (ACPI_WALK_STATE *WalkState)

Variables
static ACPI_INTERFACE_INFO	AcpiDefaultSupportedInterfaces []

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_UTILITIES

Definition at line 48 of file utosi.c.

Function Documentation

AcpiUtGetInterface()

ACPI_INTERFACE_INFO * AcpiUtGetInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 425 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (!strcmp (InterfaceName, NextInterface->Name))
        {
            return (NextInterface);
        }
 
        NextInterface = NextInterface->Next;
    }
 
    return (NULL);
}

Referenced by AcpiInstallInterface(), and AcpiUtOsiImplementation().

AcpiUtInitializeInterfaces()

ACPI_STATUS AcpiUtInitializeInterfaces

(

void

)

Definition at line 150 of file utosi.c.

{
    ACPI_STATUS             Status;
    UINT32                  i;
 
 
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    AcpiGbl_SupportedInterfaces = AcpiDefaultSupportedInterfaces;
 
    /* Link the static list of supported interfaces */
 
    for (i = 0;
        i < (ACPI_ARRAY_LENGTH (AcpiDefaultSupportedInterfaces) - 1);
        i++)
    {
        AcpiDefaultSupportedInterfaces[i].Next =
            &AcpiDefaultSupportedInterfaces[(ACPI_SIZE) i + 1];
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
    return (AE_OK);
}

Referenced by AcpiInitializeSubsystem().

AcpiUtInstallInterface()

ACPI_STATUS AcpiUtInstallInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 255 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *InterfaceInfo;
 
 
    /* Allocate info block and space for the name string */
 
    InterfaceInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_INTERFACE_INFO));
    if (!InterfaceInfo)
    {
        return (AE_NO_MEMORY);
    }
 
    InterfaceInfo->Name = ACPI_ALLOCATE_ZEROED (strlen (InterfaceName) + 1);
    if (!InterfaceInfo->Name)
    {
        ACPI_FREE (InterfaceInfo);
        return (AE_NO_MEMORY);
    }
 
    /* Initialize new info and insert at the head of the global list */
 
    strcpy (InterfaceInfo->Name, InterfaceName);
    InterfaceInfo->Flags = ACPI_OSI_DYNAMIC;
    InterfaceInfo->Next = AcpiGbl_SupportedInterfaces;
 
    AcpiGbl_SupportedInterfaces = InterfaceInfo;
    return (AE_OK);
}

Referenced by AcpiInstallInterface().

AcpiUtInterfaceTerminate()

ACPI_STATUS AcpiUtInterfaceTerminate

(

void

)

Definition at line 194 of file utosi.c.

{
    ACPI_STATUS             Status;
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        AcpiGbl_SupportedInterfaces = NextInterface->Next;
 
        if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
        {
            /* Only interfaces added at runtime can be freed */
 
            ACPI_FREE (NextInterface->Name);
            ACPI_FREE (NextInterface);
        }
        else
        {
            /* Interface is in static list. Reset it to invalid or valid. */
 
            if (NextInterface->Flags & ACPI_OSI_DEFAULT_INVALID)
            {
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
            else
            {
                NextInterface->Flags &= ~ACPI_OSI_INVALID;
            }
        }
 
        NextInterface = AcpiGbl_SupportedInterfaces;
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
    return (AE_OK);
}

Referenced by AcpiUtSubsystemShutdown().

AcpiUtOsiImplementation()

ACPI_STATUS AcpiUtOsiImplementation

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 472 of file utosi.c.

{
    ACPI_OPERAND_OBJECT     *StringDesc;
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    ACPI_INTERFACE_INFO     *InterfaceInfo;
    ACPI_INTERFACE_HANDLER  InterfaceHandler;
    ACPI_STATUS             Status;
    UINT64                  ReturnValue;
 
 
    ACPI_FUNCTION_TRACE (UtOsiImplementation);
 
 
    /* Validate the string input argument (from the AML caller) */
 
    StringDesc = WalkState->Arguments[0].Object;
    if (!StringDesc ||
        (StringDesc->Common.Type != ACPI_TYPE_STRING))
    {
        return_ACPI_STATUS (AE_TYPE);
    }
 
    /* Create a return object */
 
    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
    if (!ReturnDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Default return value is 0, NOT SUPPORTED */
 
    ReturnValue = 0;
    Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
        return_ACPI_STATUS (Status);
    }
 
    /* Lookup the interface in the global _OSI list */
 
    InterfaceInfo = AcpiUtGetInterface (StringDesc->String.Pointer);
    if (InterfaceInfo &&
        !(InterfaceInfo->Flags & ACPI_OSI_INVALID))
    {
        /*
         * The interface is supported.
         * Update the OsiData if necessary. We keep track of the latest
         * version of Windows that has been requested by the BIOS.
         */
        if (InterfaceInfo->Value > AcpiGbl_OsiData)
        {
            AcpiGbl_OsiData = InterfaceInfo->Value;
        }
 
        ReturnValue = ACPI_UINT64_MAX;
    }
 
    AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
 
    /*
     * Invoke an optional _OSI interface handler. The host OS may wish
     * to do some interface-specific handling. For example, warn about
     * certain interfaces or override the true/false support value.
     */
    InterfaceHandler = AcpiGbl_InterfaceHandler;
    if (InterfaceHandler)
    {
        if (InterfaceHandler (
            StringDesc->String.Pointer, (UINT32) ReturnValue))
        {
            ReturnValue = ACPI_UINT64_MAX;
        }
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
        "ACPI: BIOS _OSI(\"%s\") is %ssupported\n",
        StringDesc->String.Pointer, ReturnValue == 0 ? "not " : ""));
 
    /* Complete the return object */
 
    ReturnDesc->Integer.Value = ReturnValue;
    WalkState->ReturnDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiNsRootInitialize().

AcpiUtRemoveInterface()

ACPI_STATUS AcpiUtRemoveInterface

(

ACPI_STRING

InterfaceName

)

Definition at line 301 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *PreviousInterface;
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    PreviousInterface = NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (!strcmp (InterfaceName, NextInterface->Name))
        {
            /*
             * Found: name is in either the static list
             * or was added at runtime
             */
            if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
            {
                /* Interface was added dynamically, remove and free it */
 
                if (PreviousInterface == NextInterface)
                {
                    AcpiGbl_SupportedInterfaces = NextInterface->Next;
                }
                else
                {
                    PreviousInterface->Next = NextInterface->Next;
                }
 
                ACPI_FREE (NextInterface->Name);
                ACPI_FREE (NextInterface);
            }
            else
            {
                /*
                 * Interface is in static list. If marked invalid, then
                 * it does not actually exist. Else, mark it invalid.
                 */
                if (NextInterface->Flags & ACPI_OSI_INVALID)
                {
                    return (AE_NOT_EXIST);
                }
 
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
 
            return (AE_OK);
        }
 
        PreviousInterface = NextInterface;
        NextInterface = NextInterface->Next;
    }
 
    /* Interface was not found */
 
    return (AE_NOT_EXIST);
}

Referenced by AcpiRemoveInterface().

AcpiUtUpdateInterfaces()

ACPI_STATUS AcpiUtUpdateInterfaces

(

UINT8

Action

)

Definition at line 376 of file utosi.c.

{
    ACPI_INTERFACE_INFO     *NextInterface;
 
 
    NextInterface = AcpiGbl_SupportedInterfaces;
    while (NextInterface)
    {
        if (((NextInterface->Flags & ACPI_OSI_FEATURE) &&
             (Action & ACPI_FEATURE_STRINGS)) ||
            (!(NextInterface->Flags & ACPI_OSI_FEATURE) &&
             (Action & ACPI_VENDOR_STRINGS)))
        {
            if (Action & ACPI_DISABLE_INTERFACES)
            {
                /* Mark the interfaces as invalid */
 
                NextInterface->Flags |= ACPI_OSI_INVALID;
            }
            else
            {
                /* Mark the interfaces as valid */
 
                NextInterface->Flags &= ~ACPI_OSI_INVALID;
            }
        }
 
        NextInterface = NextInterface->Next;
    }
 
    return (AE_OK);
}

Referenced by AcpiUpdateInterfaces().

Variable Documentation

AcpiDefaultSupportedInterfaces

ACPI_INTERFACE_INFO AcpiDefaultSupportedInterfaces[]

static

Definition at line 91 of file utosi.c.

Referenced by AcpiUtInitializeInterfaces().