hwxface.c File Reference

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

Include dependency graph for hwxface.c:

Go to the source code of this file.

Macros
#define	EXPORT_ACPI_INTERFACES
#define	_COMPONENT   ACPI_HARDWARE

Functions
ACPI_STATUS	AcpiReset (void)
ACPI_STATUS	AcpiRead (UINT64 *ReturnValue, ACPI_GENERIC_ADDRESS *Reg)
ACPI_STATUS	AcpiWrite (UINT64 Value, ACPI_GENERIC_ADDRESS *Reg)
ACPI_STATUS	AcpiReadBitRegister (UINT32 RegisterId, UINT32 *ReturnValue)
ACPI_STATUS	AcpiWriteBitRegister (UINT32 RegisterId, UINT32 Value)
ACPI_STATUS	AcpiGetSleepTypeData (UINT8 SleepState, UINT8 *SleepTypeA, UINT8 *SleepTypeB)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_HARDWARE

Definition at line 50 of file hwxface.c.

EXPORT_ACPI_INTERFACES

#define EXPORT_ACPI_INTERFACES

Definition at line 44 of file hwxface.c.

Function Documentation

AcpiGetSleepTypeData()

ACPI_STATUS AcpiGetSleepTypeData	(	UINT8	SleepState,
		UINT8 *	SleepTypeA,
		UINT8 *	SleepTypeB
	)

Definition at line 411 of file hwxface.c.

{
    ACPI_STATUS             Status;
    ACPI_EVALUATE_INFO      *Info;
    ACPI_OPERAND_OBJECT     **Elements;
 
 
    ACPI_FUNCTION_TRACE (AcpiGetSleepTypeData);
 
 
    /* Validate parameters */
 
    if ((SleepState > ACPI_S_STATES_MAX) ||
        !SleepTypeA || !SleepTypeB)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Allocate the evaluation information block */
 
    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
    if (!Info)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /*
     * Evaluate the \_Sx namespace object containing the register values
     * for this state
     */
    Info->RelativePathname = AcpiGbl_SleepStateNames[SleepState];
 
    Status = AcpiNsEvaluate (Info);
    if (ACPI_FAILURE (Status))
    {
        if (Status == AE_NOT_FOUND)
        {
            /* The _Sx states are optional, ignore NOT_FOUND */
 
            goto FinalCleanup;
        }
 
        goto WarningCleanup;
    }
 
    /* Must have a return object */
 
    if (!Info->ReturnObject)
    {
        ACPI_ERROR ((AE_INFO, "No Sleep State object returned from [%s]",
            Info->RelativePathname));
        Status = AE_AML_NO_RETURN_VALUE;
        goto WarningCleanup;
    }
 
    /* Return object must be of type Package */
 
    if (Info->ReturnObject->Common.Type != ACPI_TYPE_PACKAGE)
    {
        ACPI_ERROR ((AE_INFO, "Sleep State return object is not a Package"));
        Status = AE_AML_OPERAND_TYPE;
        goto ReturnValueCleanup;
    }
 
    /*
     * Any warnings about the package length or the object types have
     * already been issued by the predefined name module -- there is no
     * need to repeat them here.
     */
    Elements = Info->ReturnObject->Package.Elements;
    switch (Info->ReturnObject->Package.Count)
    {
    case 0:
 
        Status = AE_AML_PACKAGE_LIMIT;
        break;
 
    case 1:
 
        if (Elements[0]->Common.Type != ACPI_TYPE_INTEGER)
        {
            Status = AE_AML_OPERAND_TYPE;
            break;
        }
 
        /* A valid _Sx_ package with one integer */
 
        *SleepTypeA = (UINT8) Elements[0]->Integer.Value;
        *SleepTypeB = (UINT8) (Elements[0]->Integer.Value >> 8);
        break;
 
    case 2:
    default:
 
        if ((Elements[0]->Common.Type != ACPI_TYPE_INTEGER) ||
            (Elements[1]->Common.Type != ACPI_TYPE_INTEGER))
        {
            Status = AE_AML_OPERAND_TYPE;
            break;
        }
 
        /* A valid _Sx_ package with two integers */
 
        *SleepTypeA = (UINT8) Elements[0]->Integer.Value;
        *SleepTypeB = (UINT8) Elements[1]->Integer.Value;
        break;
    }
 
ReturnValueCleanup:
    AcpiUtRemoveReference (Info->ReturnObject);
 
WarningCleanup:
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "While evaluating Sleep State [%s]",
            Info->RelativePathname));
    }
 
FinalCleanup:
    ACPI_FREE (Info);
    return_ACPI_STATUS (Status);
}

Referenced by acpi_system_add(), AcpiEnterSleepStatePrep(), and AcpiGetSleepTypeData().

AcpiRead()

ACPI_STATUS AcpiRead	(	UINT64 *	ReturnValue,
		ACPI_GENERIC_ADDRESS *	Reg
	)

Definition at line 138 of file hwxface.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_NAME (AcpiRead);
 
 
    Status = AcpiHwRead (ReturnValue, Reg);
    return (Status);
}

Referenced by AcpiHwExtendedSleep(), and AcpiRead().

AcpiReadBitRegister()

ACPI_STATUS AcpiReadBitRegister	(	UINT32	RegisterId,
		UINT32 *	ReturnValue
	)

Definition at line 213 of file hwxface.c.

{
    ACPI_BIT_REGISTER_INFO  *BitRegInfo;
    UINT32                  RegisterValue;
    UINT32                  Value;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_U32 (AcpiReadBitRegister, RegisterId);
 
 
    /* Get the info structure corresponding to the requested ACPI Register */
 
    BitRegInfo = AcpiHwGetBitRegisterInfo (RegisterId);
    if (!BitRegInfo)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Read the entire parent register */
 
    Status = AcpiHwRegisterRead (BitRegInfo->ParentRegister,
        &RegisterValue);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Normalize the value that was read, mask off other bits */
 
    Value = ((RegisterValue & BitRegInfo->AccessBitMask)
        >> BitRegInfo->BitPosition);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
        "BitReg %X, ParentReg %X, Actual %8.8X, ReturnValue %8.8X\n",
        RegisterId, BitRegInfo->ParentRegister, RegisterValue, Value));
 
    *ReturnValue = Value;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDisableEvent(), AcpiEnableEvent(), AcpiEnterSleepStateS4bios(), AcpiGetEventStatus(), AcpiHwGetMode(), AcpiHwLegacySleep(), and AcpiReadBitRegister().

AcpiReset()

ACPI_STATUS AcpiReset

(

void

)

Definition at line 69 of file hwxface.c.

{
    ACPI_GENERIC_ADDRESS    *ResetReg;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiReset);
 
 
    ResetReg = &AcpiGbl_FADT.ResetRegister;
 
    /* Check if the reset register is supported */
 
    if (!(AcpiGbl_FADT.Flags & ACPI_FADT_RESET_REGISTER) ||
        !ResetReg->Address)
    {
        return_ACPI_STATUS (AE_NOT_EXIST);
    }
 
    if (ResetReg->SpaceId == ACPI_ADR_SPACE_SYSTEM_IO)
    {
        /*
         * For I/O space, write directly to the OSL. This bypasses the port
         * validation mechanism, which may block a valid write to the reset
         * register.
         *
         * NOTE:
         * The ACPI spec requires the reset register width to be 8, so we
         * hardcode it here and ignore the FADT value. This maintains
         * compatibility with other ACPI implementations that have allowed
         * BIOS code with bad register width values to go unnoticed.
         */
        Status = AcpiOsWritePort ((ACPI_IO_ADDRESS) ResetReg->Address,
            AcpiGbl_FADT.ResetValue, ACPI_RESET_REGISTER_WIDTH);
    }
    else
    {
        /* Write the reset value to the reset register */
 
        Status = AcpiHwWrite (AcpiGbl_FADT.ResetValue, ResetReg);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiReset().

AcpiWrite()

ACPI_STATUS AcpiWrite	(	UINT64	Value,
		ACPI_GENERIC_ADDRESS *	Reg
	)

Definition at line 169 of file hwxface.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_NAME (AcpiWrite);
 
 
    Status = AcpiHwWrite (Value, Reg);
    return (Status);
}

Referenced by AcpiHwExtendedSleep(), AcpiHwExtendedWake(), AcpiHwExtendedWakePrep(), and AcpiWrite().

AcpiWriteBitRegister()

ACPI_STATUS AcpiWriteBitRegister	(	UINT32	RegisterId,
		UINT32	Value
	)

Definition at line 282 of file hwxface.c.

{
    ACPI_BIT_REGISTER_INFO  *BitRegInfo;
    ACPI_CPU_FLAGS          LockFlags;
    UINT32                  RegisterValue;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_U32 (AcpiWriteBitRegister, RegisterId);
 
 
    /* Get the info structure corresponding to the requested ACPI Register */
 
    BitRegInfo = AcpiHwGetBitRegisterInfo (RegisterId);
    if (!BitRegInfo)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock);
 
    /*
     * At this point, we know that the parent register is one of the
     * following: PM1 Status, PM1 Enable, PM1 Control, or PM2 Control
     */
    if (BitRegInfo->ParentRegister != ACPI_REGISTER_PM1_STATUS)
    {
        /*
         * 1) Case for PM1 Enable, PM1 Control, and PM2 Control
         *
         * Perform a register read to preserve the bits that we are not
         * interested in
         */
        Status = AcpiHwRegisterRead (BitRegInfo->ParentRegister,
            &RegisterValue);
        if (ACPI_FAILURE (Status))
        {
            goto UnlockAndExit;
        }
 
        /*
         * Insert the input bit into the value that was just read
         * and write the register
         */
        ACPI_REGISTER_INSERT_VALUE (RegisterValue, BitRegInfo->BitPosition,
            BitRegInfo->AccessBitMask, Value);
 
        Status = AcpiHwRegisterWrite (BitRegInfo->ParentRegister,
            RegisterValue);
    }
    else
    {
        /*
         * 2) Case for PM1 Status
         *
         * The Status register is different from the rest. Clear an event
         * by writing 1, writing 0 has no effect. So, the only relevant
         * information is the single bit we're interested in, all others
         * should be written as 0 so they will be left unchanged.
         */
        RegisterValue = ACPI_REGISTER_PREPARE_BITS (Value,
            BitRegInfo->BitPosition, BitRegInfo->AccessBitMask);
 
        /* No need to write the register if value is all zeros */
 
        if (RegisterValue)
        {
            Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS,
                RegisterValue);
        }
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
        "BitReg %X, ParentReg %X, Value %8.8X, Actual %8.8X\n",
        RegisterId, BitRegInfo->ParentRegister, Value, RegisterValue));
 
 
UnlockAndExit:
 
    AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags);
    return_ACPI_STATUS (Status);
}

Referenced by acpi_bus_scan_fixed(), AcpiClearEvent(), AcpiDisableEvent(), AcpiEnableEvent(), AcpiEnterSleepStateS4bios(), AcpiEvFixedEventDispatch(), AcpiEvFixedEventInitialize(), AcpiEvReleaseGlobalLock(), AcpiHwLegacySleep(), AcpiHwLegacyWake(), and AcpiWriteBitRegister().