achware.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ACPI_SST_INDICATOR_OFF   0
#define	ACPI_SST_WORKING   1
#define	ACPI_SST_WAKING   2
#define	ACPI_SST_SLEEPING   3
#define	ACPI_SST_SLEEP_CONTEXT   4

Functions
ACPI_STATUS	AcpiHwSetMode (UINT32 Mode)
UINT32	AcpiHwGetMode (void)
ACPI_STATUS	AcpiHwValidateRegister (ACPI_GENERIC_ADDRESS *Reg, UINT8 MaxBitWidth, UINT64 *Address)
ACPI_STATUS	AcpiHwRead (UINT64 *Value, ACPI_GENERIC_ADDRESS *Reg)
ACPI_STATUS	AcpiHwWrite (UINT64 Value, ACPI_GENERIC_ADDRESS *Reg)
ACPI_BIT_REGISTER_INFO *	AcpiHwGetBitRegisterInfo (UINT32 RegisterId)
ACPI_STATUS	AcpiHwWritePm1Control (UINT32 Pm1aControl, UINT32 Pm1bControl)
ACPI_STATUS	AcpiHwRegisterRead (UINT32 RegisterId, UINT32 *ReturnValue)
ACPI_STATUS	AcpiHwRegisterWrite (UINT32 RegisterId, UINT32 Value)
ACPI_STATUS	AcpiHwClearAcpiStatus (void)
ACPI_STATUS	AcpiHwLegacySleep (UINT8 SleepState)
ACPI_STATUS	AcpiHwLegacyWakePrep (UINT8 SleepState)
ACPI_STATUS	AcpiHwLegacyWake (UINT8 SleepState)
void	AcpiHwExecuteSleepMethod (char *MethodName, UINT32 IntegerArgument)
ACPI_STATUS	AcpiHwExtendedSleep (UINT8 SleepState)
ACPI_STATUS	AcpiHwExtendedWakePrep (UINT8 SleepState)
ACPI_STATUS	AcpiHwExtendedWake (UINT8 SleepState)
ACPI_STATUS	AcpiHwReadPort (ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width)
ACPI_STATUS	AcpiHwWritePort (ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
UINT32	AcpiHwGetGpeRegisterBit (ACPI_GPE_EVENT_INFO *GpeEventInfo)
ACPI_STATUS	AcpiHwLowSetGpe (ACPI_GPE_EVENT_INFO *GpeEventInfo, UINT32 Action)
ACPI_STATUS	AcpiHwDisableGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
ACPI_STATUS	AcpiHwClearGpe (ACPI_GPE_EVENT_INFO *GpeEventInfo)
ACPI_STATUS	AcpiHwClearGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
ACPI_STATUS	AcpiHwGetGpeStatus (ACPI_GPE_EVENT_INFO *GpeEventInfo, ACPI_EVENT_STATUS *EventStatus)
ACPI_STATUS	AcpiHwDisableAllGpes (void)
ACPI_STATUS	AcpiHwEnableAllRuntimeGpes (void)
ACPI_STATUS	AcpiHwEnableAllWakeupGpes (void)
UINT8	AcpiHwCheckAllGpes (void)
ACPI_STATUS	AcpiHwEnableRuntimeGpeBlock (ACPI_GPE_XRUPT_INFO *GpeXruptInfo, ACPI_GPE_BLOCK_INFO *GpeBlock, void *Context)
ACPI_STATUS	AcpiHwDerivePciId (ACPI_PCI_ID *PciId, ACPI_HANDLE RootPciDevice, ACPI_HANDLE PciRegion)

Macro Definition Documentation

ACPI_SST_INDICATOR_OFF

#define ACPI_SST_INDICATOR_OFF   0

Definition at line 50 of file achware.h.

ACPI_SST_SLEEP_CONTEXT

#define ACPI_SST_SLEEP_CONTEXT   4

Definition at line 54 of file achware.h.

ACPI_SST_SLEEPING

#define ACPI_SST_SLEEPING   3

Definition at line 53 of file achware.h.

ACPI_SST_WAKING

#define ACPI_SST_WAKING   2

Definition at line 52 of file achware.h.

ACPI_SST_WORKING

#define ACPI_SST_WORKING   1

Definition at line 51 of file achware.h.

Function Documentation

AcpiHwCheckAllGpes()

UINT8 AcpiHwCheckAllGpes

(

void

)

Definition at line 677 of file hwgpe.c.

{
    UINT8                      Ret = 0;
 
 
    ACPI_FUNCTION_TRACE (AcpiHwCheckAllGpes);
 
    (void) AcpiEvWalkGpeList (AcpiHwGetGpeBlockStatus, &Ret);
    return (Ret != 0);
}

Referenced by AcpiAnyGpeStatusSet(), and AcpiHwCheckAllGpes().

AcpiHwClearAcpiStatus()

ACPI_STATUS AcpiHwClearAcpiStatus

(

void

)

Definition at line 452 of file hwregs.c.

{
    ACPI_STATUS             Status;
    ACPI_CPU_FLAGS          LockFlags = 0;
 
 
    ACPI_FUNCTION_TRACE (HwClearAcpiStatus);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
        ACPI_BITMASK_ALL_FIXED_STATUS,
        ACPI_FORMAT_UINT64 (AcpiGbl_XPm1aStatus.Address)));
 
    LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock);
 
    /* Clear the fixed events in PM1 A/B */
 
    Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS,
        ACPI_BITMASK_ALL_FIXED_STATUS);
 
    AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags);
 
    if (ACPI_FAILURE (Status))
    {
        goto Exit;
    }
 
    /* Clear the GPE Bits in all GPE registers in all GPE blocks */
 
    Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
 
Exit:
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnterSleepStateS4bios(), and AcpiHwLegacySleep().

AcpiHwClearGpe()

ACPI_STATUS AcpiHwClearGpe

(

ACPI_GPE_EVENT_INFO *

GpeEventInfo

)

Definition at line 190 of file hwgpe.c.

{
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_STATUS             Status;
    UINT32                  RegisterBit;
 
 
    ACPI_FUNCTION_ENTRY ();
 
    /* Get the info block for the entire GPE register */
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
    if (!GpeRegisterInfo)
    {
        return (AE_NOT_EXIST);
    }
 
    /*
     * Write a one to the appropriate bit in the status register to
     * clear this GPE.
     */
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 
    Status = AcpiHwWrite (RegisterBit, &GpeRegisterInfo->StatusAddress);
    return (Status);
}

Referenced by AcpiClearGpe(), AcpiEvAddGpeReference(), AcpiEvFinishGpe(), and AcpiEvGpeDispatch().

AcpiHwClearGpeBlock()

ACPI_STATUS AcpiHwClearGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 404 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        /* Clear status on all GPEs in this register */
 
        Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiHwClearAcpiStatus().

AcpiHwDerivePciId()

ACPI_STATUS AcpiHwDerivePciId	(	ACPI_PCI_ID *	PciId,
		ACPI_HANDLE	RootPciDevice,
		ACPI_HANDLE	PciRegion
	)

Definition at line 137 of file hwpci.c.

{
    ACPI_STATUS             Status;
    ACPI_PCI_DEVICE         *ListHead;
 
 
    ACPI_FUNCTION_TRACE (HwDerivePciId);
 
 
    if (!PciId)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Build a list of PCI devices, from PciRegion up to RootPciDevice */
 
    Status = AcpiHwBuildPciList (RootPciDevice, PciRegion, &ListHead);
    if (ACPI_SUCCESS (Status))
    {
        /* Walk the list, updating the PCI device/function/bus numbers */
 
        Status = AcpiHwProcessPciList (PciId, ListHead);
 
        /* Delete the list */
 
        AcpiHwDeletePciList (ListHead);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvPciConfigRegionSetup().

AcpiHwDisableAllGpes()

ACPI_STATUS AcpiHwDisableAllGpes

(

void

)

Definition at line 595 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwDisableAllGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDisableAllGpes(), AcpiEnterSleepStateS4bios(), AcpiHwLegacySleep(), and AcpiHwLegacyWake().

AcpiHwDisableGpeBlock()

ACPI_STATUS AcpiHwDisableGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 364 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
 
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        /* Disable all GPEs in this register */
 
        Status = AcpiHwGpeEnableWrite (0x00, &GpeBlock->RegisterInfo[i]);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiEvDeleteGpeBlock(), AcpiEvTerminate(), and AcpiHwDisableAllGpes().

AcpiHwEnableAllRuntimeGpes()

ACPI_STATUS AcpiHwEnableAllRuntimeGpes

(

void

)

Definition at line 622 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwEnableRuntimeGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllRuntimeGpes(), and AcpiHwLegacyWake().

AcpiHwEnableAllWakeupGpes()

ACPI_STATUS AcpiHwEnableAllWakeupGpes

(

void

)

Definition at line 649 of file hwgpe.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
 
 
    Status = AcpiEvWalkGpeList (AcpiHwEnableWakeupGpeBlock, NULL);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEnableAllWakeupGpes(), AcpiEnterSleepStateS4bios(), and AcpiHwLegacySleep().

AcpiHwEnableRuntimeGpeBlock()

ACPI_STATUS AcpiHwEnableRuntimeGpeBlock	(	ACPI_GPE_XRUPT_INFO *	GpeXruptInfo,
		ACPI_GPE_BLOCK_INFO *	GpeBlock,
		void *	Context
	)

Definition at line 445 of file hwgpe.c.

{
    UINT32                  i;
    ACPI_STATUS             Status;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    UINT8                   EnableMask;
 
 
    /* NOTE: assumes that all GPEs are currently disabled */
 
    /* Examine each GPE Register within the block */
 
    for (i = 0; i < GpeBlock->RegisterCount; i++)
    {
        GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
        if (!GpeRegisterInfo->EnableForRun)
        {
            continue;
        }
 
        /* Enable all "runtime" GPEs in this register */
 
        EnableMask = GpeRegisterInfo->EnableForRun &
            ~GpeRegisterInfo->MaskForRun;
        Status = AcpiHwGpeEnableWrite (EnableMask, GpeRegisterInfo);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
    }
 
    return (AE_OK);
}

Referenced by AcpiHwEnableAllRuntimeGpes().

AcpiHwExecuteSleepMethod()

void AcpiHwExecuteSleepMethod	(	char *	MethodName,
		UINT32	IntegerArgument
	)

Definition at line 67 of file hwesleep.c.

{
    ACPI_OBJECT_LIST        ArgList;
    ACPI_OBJECT             Arg;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwExecuteSleepMethod);
 
 
    /* One argument, IntegerArgument; No return value expected */
 
    ArgList.Count = 1;
    ArgList.Pointer = &Arg;
    Arg.Type = ACPI_TYPE_INTEGER;
    Arg.Integer.Value = (UINT64) IntegerArgument;
 
    Status = AcpiEvaluateObject (NULL, MethodPathname, &ArgList, NULL);
    if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
    {
        ACPI_EXCEPTION ((AE_INFO, Status, "While executing method %s",
            MethodPathname));
    }
 
    return_VOID;
}

Referenced by AcpiEnterSleepStatePrep(), AcpiHwExtendedWake(), and AcpiHwLegacyWake().

AcpiHwExtendedSleep()

ACPI_STATUS AcpiHwExtendedSleep

(

UINT8

SleepState

)

Definition at line 112 of file hwesleep.c.

{
    ACPI_STATUS             Status;
    UINT8                   SleepControl;
    UINT64                  SleepStatus;
 
 
    ACPI_FUNCTION_TRACE (HwExtendedSleep);
 
 
    /* Extended sleep registers must be valid */
 
    if (!AcpiGbl_FADT.SleepControl.Address ||
        !AcpiGbl_FADT.SleepStatus.Address)
    {
        return_ACPI_STATUS (AE_NOT_EXIST);
    }
 
    /* Clear wake status (WAK_STS) */
 
    Status = AcpiWrite ((UINT64) ACPI_X_WAKE_STATUS,
        &AcpiGbl_FADT.SleepStatus);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    AcpiGbl_SystemAwakeAndRunning = FALSE;
 
    /*
     * Set the SLP_TYP and SLP_EN bits.
     *
     * Note: We only use the first value returned by the \_Sx method
     * (AcpiGbl_SleepTypeA) - As per ACPI specification.
     */
    ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
        "Entering sleep state [S%u]\n", SleepState));
 
    SleepControl = ((AcpiGbl_SleepTypeA << ACPI_X_SLEEP_TYPE_POSITION) &
        ACPI_X_SLEEP_TYPE_MASK) | ACPI_X_SLEEP_ENABLE;
 
    /* Flush caches, as per ACPI specification */
 
    if (SleepState < ACPI_STATE_S4)
    {
        ACPI_FLUSH_CPU_CACHE ();
    }
 
    Status = AcpiOsEnterSleep (SleepState, SleepControl, 0);
    if (Status == AE_CTRL_TERMINATE)
    {
        return_ACPI_STATUS (AE_OK);
    }
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiWrite ((UINT64) SleepControl, &AcpiGbl_FADT.SleepControl);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Wait for transition back to Working State */
 
    do
    {
        Status = AcpiRead (&SleepStatus, &AcpiGbl_FADT.SleepStatus);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
    } while (!(((UINT8) SleepStatus) & ACPI_X_WAKE_STATUS));
 
    return_ACPI_STATUS (AE_OK);
}

AcpiHwExtendedWake()

ACPI_STATUS AcpiHwExtendedWake

(

UINT8

SleepState

)

Definition at line 243 of file hwesleep.c.

{
    ACPI_FUNCTION_TRACE (HwExtendedWake);
 
 
    /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */
 
    AcpiGbl_SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
 
    /* Execute the wake methods */
 
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WAKING);
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__WAK, SleepState);
 
    /*
     * Some BIOS code assumes that WAK_STS will be cleared on resume
     * and use it to determine whether the system is rebooting or
     * resuming. Clear WAK_STS for compatibility.
     */
    (void) AcpiWrite ((UINT64) ACPI_X_WAKE_STATUS, &AcpiGbl_FADT.SleepStatus);
    AcpiGbl_SystemAwakeAndRunning = TRUE;
 
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);
    return_ACPI_STATUS (AE_OK);
}

AcpiHwExtendedWakePrep()

ACPI_STATUS AcpiHwExtendedWakePrep

(

UINT8

SleepState

)

Definition at line 207 of file hwesleep.c.

{
    UINT8                   SleepTypeValue;
 
 
    ACPI_FUNCTION_TRACE (HwExtendedWakePrep);
 
 
    if (AcpiGbl_SleepTypeAS0 != ACPI_SLEEP_TYPE_INVALID)
    {
        SleepTypeValue = ((AcpiGbl_SleepTypeAS0 << ACPI_X_SLEEP_TYPE_POSITION) &
            ACPI_X_SLEEP_TYPE_MASK);
 
        (void) AcpiWrite ((UINT64) (SleepTypeValue | ACPI_X_SLEEP_ENABLE),
            &AcpiGbl_FADT.SleepControl);
    }
 
    return_ACPI_STATUS (AE_OK);
}

AcpiHwGetBitRegisterInfo()

ACPI_BIT_REGISTER_INFO * AcpiHwGetBitRegisterInfo

(

UINT32

RegisterId

)

Definition at line 502 of file hwregs.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    if (RegisterId > ACPI_BITREG_MAX)
    {
        ACPI_ERROR ((AE_INFO, "Invalid BitRegister ID: 0x%X", RegisterId));
        return (NULL);
    }
 
    return (&AcpiGbl_BitRegisterInfo[RegisterId]);
}

Referenced by AcpiHwLegacySleep(), AcpiHwLegacyWakePrep(), AcpiReadBitRegister(), and AcpiWriteBitRegister().

AcpiHwGetGpeRegisterBit()

UINT32 AcpiHwGetGpeRegisterBit

(

ACPI_GPE_EVENT_INFO *

GpeEventInfo

)

Definition at line 81 of file hwgpe.c.

{
 
    return ((UINT32) 1 <<
        (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
}

Referenced by AcpiEvDetectGpe(), AcpiEvMaskGpe(), AcpiEvUpdateGpeEnableMask(), AcpiHwClearGpe(), AcpiHwGetGpeStatus(), AcpiHwLowSetGpe(), and AcpiSetGpeWakeMask().

AcpiHwGetGpeStatus()

ACPI_STATUS AcpiHwGetGpeStatus	(	ACPI_GPE_EVENT_INFO *	GpeEventInfo,
		ACPI_EVENT_STATUS *	EventStatus
	)

Definition at line 233 of file hwgpe.c.

{
    UINT64                  InByte;
    UINT32                  RegisterBit;
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_EVENT_STATUS       LocalEventStatus = 0;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!EventStatus)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /* GPE currently handled? */
 
    if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) !=
        ACPI_GPE_DISPATCH_NONE)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
    }
 
    /* Get the info block for the entire GPE register */
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
 
    /* Get the register bitmask for this GPE */
 
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
 
    /* GPE currently enabled? (enabled for runtime?) */
 
    if (RegisterBit & GpeRegisterInfo->EnableForRun)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
    }
 
    /* GPE currently masked? (masked for runtime?) */
 
    if (RegisterBit & GpeRegisterInfo->MaskForRun)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_MASKED;
    }
 
    /* GPE enabled for wake? */
 
    if (RegisterBit & GpeRegisterInfo->EnableForWake)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
    }
 
    /* GPE currently enabled (enable bit == 1)? */
 
    Status = AcpiHwRead (&InByte, &GpeRegisterInfo->EnableAddress);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    if (RegisterBit & InByte)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_ENABLE_SET;
    }
 
    /* GPE currently active (status bit == 1)? */
 
    Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    if (RegisterBit & InByte)
    {
        LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
    }
 
    /* Set return value */
 
    (*EventStatus) = LocalEventStatus;
    return (AE_OK);
}

Referenced by AcpiGetGpeStatus().

AcpiHwGetMode()

UINT32 AcpiHwGetMode

(

void

)

Definition at line 179 of file hwacpi.c.

{
    ACPI_STATUS             Status;
    UINT32                  Value;
 
 
    ACPI_FUNCTION_TRACE (HwGetMode);
 
 
    /* If the Hardware Reduced flag is set, machine is always in acpi mode */
 
    if (AcpiGbl_ReducedHardware)
    {
        return_UINT32 (ACPI_SYS_MODE_ACPI);
    }
 
    /*
     * ACPI 2.0 clarified that if SMI_CMD in FADT is zero,
     * system does not support mode transition.
     */
    if (!AcpiGbl_FADT.SmiCommand)
    {
        return_UINT32 (ACPI_SYS_MODE_ACPI);
    }
 
    Status = AcpiReadBitRegister (ACPI_BITREG_SCI_ENABLE, &Value);
    if (ACPI_FAILURE (Status))
    {
        return_UINT32 (ACPI_SYS_MODE_LEGACY);
    }
 
    if (Value)
    {
        return_UINT32 (ACPI_SYS_MODE_ACPI);
    }
    else
    {
        return_UINT32 (ACPI_SYS_MODE_LEGACY);
    }
}

Referenced by AcpiDisable(), AcpiEnable(), AcpiEnableSubsystem(), and AcpiHwSetMode().

AcpiHwLegacySleep()

ACPI_STATUS AcpiHwLegacySleep

(

UINT8

SleepState

)

Definition at line 67 of file hwsleep.c.

{
    ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
    ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
    UINT32                  Pm1aControl;
    UINT32                  Pm1bControl;
    UINT32                  InValue;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwLegacySleep);
 
 
    SleepTypeRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
    SleepEnableRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
 
    /* Clear wake status */
 
    Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS,
        ACPI_CLEAR_STATUS);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Disable all GPEs */
 
    Status = AcpiHwDisableAllGpes ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
    Status = AcpiHwClearAcpiStatus();
    if (ACPI_FAILURE(Status))
    {
        return_ACPI_STATUS(Status);
    }
    AcpiGbl_SystemAwakeAndRunning = FALSE;
 
    /* Enable all wakeup GPEs */
 
    Status = AcpiHwEnableAllWakeupGpes ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Get current value of PM1A control */
 
    Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
        &Pm1aControl);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
    ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
        "Entering sleep state [S%u]\n", SleepState));
 
    /* Clear the SLP_EN and SLP_TYP fields */
 
    Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
         SleepEnableRegInfo->AccessBitMask);
    Pm1bControl = Pm1aControl;
 
    /* Insert the SLP_TYP bits */
 
    Pm1aControl |= (AcpiGbl_SleepTypeA << SleepTypeRegInfo->BitPosition);
    Pm1bControl |= (AcpiGbl_SleepTypeB << SleepTypeRegInfo->BitPosition);
 
    /*
     * We split the writes of SLP_TYP and SLP_EN to workaround
     * poorly implemented hardware.
     */
 
    /* Write #1: write the SLP_TYP data to the PM1 Control registers */
 
    Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Insert the sleep enable (SLP_EN) bit */
 
    Pm1aControl |= SleepEnableRegInfo->AccessBitMask;
    Pm1bControl |= SleepEnableRegInfo->AccessBitMask;
 
    /* Flush caches, as per ACPI specification */
 
    if (SleepState < ACPI_STATE_S4)
    {
        ACPI_FLUSH_CPU_CACHE ();
    }
 
    Status = AcpiOsEnterSleep (SleepState, Pm1aControl, Pm1bControl);
    if (Status == AE_CTRL_TERMINATE)
    {
        return_ACPI_STATUS (AE_OK);
    }
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Write #2: Write both SLP_TYP + SLP_EN */
 
    Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (SleepState > ACPI_STATE_S3)
    {
        /*
         * We wanted to sleep > S3, but it didn't happen (by virtue of the
         * fact that we are still executing!)
         *
         * Wait ten seconds, then try again. This is to get S4/S5 to work on
         * all machines.
         *
         * We wait so long to allow chipsets that poll this reg very slowly
         * to still read the right value. Ideally, this block would go
         * away entirely.
         */
        AcpiOsStall (10 * ACPI_USEC_PER_SEC);
 
        Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_CONTROL,
            SleepEnableRegInfo->AccessBitMask);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /* Wait for transition back to Working State */
 
    do
    {
        Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
    } while (!InValue);
 
    return_ACPI_STATUS (AE_OK);
}

AcpiHwLegacyWake()

ACPI_STATUS AcpiHwLegacyWake

(

UINT8

SleepState

)

Definition at line 301 of file hwsleep.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwLegacyWake);
 
 
    /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */
 
    AcpiGbl_SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WAKING);
 
    /*
     * GPEs must be enabled before _WAK is called as GPEs
     * might get fired there
     *
     * Restore the GPEs:
     * 1) Disable all GPEs
     * 2) Enable all runtime GPEs
     */
    Status = AcpiHwDisableAllGpes ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiHwEnableAllRuntimeGpes ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Now we can execute _WAK, etc. Some machines require that the GPEs
     * are enabled before the wake methods are executed.
     */
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__WAK, SleepState);
 
    /*
     * Some BIOS code assumes that WAK_STS will be cleared on resume
     * and use it to determine whether the system is rebooting or
     * resuming. Clear WAK_STS for compatibility.
     */
    (void) AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS,
        ACPI_CLEAR_STATUS);
    AcpiGbl_SystemAwakeAndRunning = TRUE;
 
    /* Enable power button */
 
    (void) AcpiWriteBitRegister(
            AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].EnableRegisterId,
            ACPI_ENABLE_EVENT);
 
    (void) AcpiWriteBitRegister(
            AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].StatusRegisterId,
            ACPI_CLEAR_STATUS);
 
    /* Enable sleep button */
 
    (void) AcpiWriteBitRegister (
            AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].EnableRegisterId,
            ACPI_ENABLE_EVENT);
 
    (void) AcpiWriteBitRegister (
            AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].StatusRegisterId,
            ACPI_CLEAR_STATUS);
 
    /* Enable pcie wake event if support */
    if ((AcpiGbl_FADT.Flags & ACPI_FADT_PCI_EXPRESS_WAKE)) {
        (void) AcpiWriteBitRegister (
        AcpiGbl_FixedEventInfo[ACPI_EVENT_PCIE_WAKE].EnableRegisterId,
        ACPI_DISABLE_EVENT);
        (void) AcpiWriteBitRegister (
        AcpiGbl_FixedEventInfo[ACPI_EVENT_PCIE_WAKE].StatusRegisterId,
        ACPI_CLEAR_STATUS);
    }
 
    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);
    return_ACPI_STATUS (Status);
}

AcpiHwLegacyWakePrep()

ACPI_STATUS AcpiHwLegacyWakePrep

(

UINT8

SleepState

)

Definition at line 234 of file hwsleep.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
    ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
    UINT32                  Pm1aControl;
    UINT32                  Pm1bControl;
 
 
    ACPI_FUNCTION_TRACE (HwLegacyWakePrep);
 
    /*
     * Set SLP_TYPE and SLP_EN to state S0.
     * This is unclear from the ACPI Spec, but it is required
     * by some machines.
     */
    if (AcpiGbl_SleepTypeAS0 != ACPI_SLEEP_TYPE_INVALID)
    {
        SleepTypeRegInfo =
            AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
        SleepEnableRegInfo =
            AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
 
        /* Get current value of PM1A control */
 
        Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
            &Pm1aControl);
        if (ACPI_SUCCESS (Status))
        {
            /* Clear the SLP_EN and SLP_TYP fields */
 
            Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
                SleepEnableRegInfo->AccessBitMask);
            Pm1bControl = Pm1aControl;
 
            /* Insert the SLP_TYP bits */
 
            Pm1aControl |= (AcpiGbl_SleepTypeAS0 <<
                SleepTypeRegInfo->BitPosition);
            Pm1bControl |= (AcpiGbl_SleepTypeBS0 <<
                SleepTypeRegInfo->BitPosition);
 
            /* Write the control registers and ignore any errors */
 
            (void) AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
        }
    }
 
    return_ACPI_STATUS (Status);
}

AcpiHwLowSetGpe()

ACPI_STATUS AcpiHwLowSetGpe	(	ACPI_GPE_EVENT_INFO *	GpeEventInfo,
		UINT32	Action
	)

Definition at line 106 of file hwgpe.c.

{
    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
    ACPI_STATUS             Status = AE_OK;
    UINT64                  EnableMask;
    UINT32                  RegisterBit;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Get the info block for the entire GPE register */
 
    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
    if (!GpeRegisterInfo)
    {
        return (AE_NOT_EXIST);
    }
 
    /* Get current value of the enable register that contains this GPE */
 
    Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Set or clear just the bit that corresponds to this GPE */
 
    RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
    switch (Action)
    {
    case ACPI_GPE_CONDITIONAL_ENABLE:
 
        /* Only enable if the corresponding EnableMask bit is set */
 
        if (!(RegisterBit & GpeRegisterInfo->EnableMask))
        {
            return (AE_BAD_PARAMETER);
        }
 
        ACPI_FALLTHROUGH;
 
    case ACPI_GPE_ENABLE:
 
        ACPI_SET_BIT (EnableMask, RegisterBit);
        break;
 
    case ACPI_GPE_DISABLE:
 
        ACPI_CLEAR_BIT (EnableMask, (UINT64)RegisterBit);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u", Action));
        return (AE_BAD_PARAMETER);
    }
 
    if (!(RegisterBit & GpeRegisterInfo->MaskForRun))
    {
        /* Write the updated enable mask */
 
        Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
    }
    return (Status);
}

Referenced by AcpiEvEnableGpe(), AcpiEvFinishGpe(), AcpiEvGpeDispatch(), AcpiEvMaskGpe(), AcpiEvMatchGpeMethod(), AcpiEvRemoveGpeReference(), and AcpiSetGpe().

AcpiHwRead()

ACPI_STATUS AcpiHwRead	(	UINT64 *	Value,
		ACPI_GENERIC_ADDRESS *	Reg
	)

Definition at line 259 of file hwregs.c.

{
    UINT64                  Address;
    UINT8                   AccessWidth;
    UINT32                  BitWidth;
    UINT8                   BitOffset;
    UINT64                  Value64;
    UINT32                  Value32;
    UINT8                   Index;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_NAME (HwRead);
 
 
    /* Validate contents of the GAS register */
 
    Status = AcpiHwValidateRegister (Reg, 64, &Address);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /*
     * Initialize entire 64-bit return value to zero, convert AccessWidth
     * into number of bits based
     */
    *Value = 0;
    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
    BitWidth = Reg->BitOffset + Reg->BitWidth;
    BitOffset = Reg->BitOffset;
 
    /*
     * Two address spaces supported: Memory or IO. PCI_Config is
     * not supported here because the GAS structure is insufficient
     */
    Index = 0;
    while (BitWidth)
    {
        if (BitOffset >= AccessWidth)
        {
            Value64 = 0;
            BitOffset -= AccessWidth;
        }
        else
        {
            if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
            {
                Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
                    Address + Index * ACPI_DIV_8 (AccessWidth),
                    &Value64, AccessWidth);
            }
            else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
            {
                Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
                    Address + Index * ACPI_DIV_8 (AccessWidth),
                    &Value32, AccessWidth);
                Value64 = (UINT64) Value32;
            }
        }
 
        /*
         * Use offset style bit writes because "Index * AccessWidth" is
         * ensured to be less than 64-bits by AcpiHwValidateRegister().
         */
        ACPI_SET_BITS (Value, Index * AccessWidth,
            ACPI_MASK_BITS_ABOVE_64 (AccessWidth), Value64);
 
        BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
        Index++;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
        "Read:  %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
        ACPI_FORMAT_UINT64 (*Value), AccessWidth,
        ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
 
    return (Status);
}

Referenced by AcpiEvDetectGpe(), AcpiGetTimer(), AcpiHwGetGpeBlockStatus(), AcpiHwGetGpeStatus(), AcpiHwLowSetGpe(), AcpiHwReadMultiple(), AcpiHwRegisterRead(), AcpiHwRegisterWrite(), and AcpiRead().

AcpiHwReadPort()

ACPI_STATUS AcpiHwReadPort	(	ACPI_IO_ADDRESS	Address,
		UINT32 *	Value,
		UINT32	Width
	)

Definition at line 237 of file hwvalid.c.

{
    ACPI_STATUS             Status;
    UINT32                  OneByte;
    UINT32                  i;
 
 
    /* Truncate address to 16 bits if requested */
 
    if (AcpiGbl_TruncateIoAddresses)
    {
        Address &= ACPI_UINT16_MAX;
    }
 
    /* Validate the entire request and perform the I/O */
 
    Status = AcpiHwValidateIoRequest (Address, Width);
    if (ACPI_SUCCESS (Status))
    {
        Status = AcpiOsReadPort (Address, Value, Width);
        return (Status);
    }
 
    if (Status != AE_AML_ILLEGAL_ADDRESS)
    {
        return (Status);
    }
 
    /*
     * There has been a protection violation within the request. Fall
     * back to byte granularity port I/O and ignore the failing bytes.
     * This provides compatibility with other ACPI implementations.
     */
    for (i = 0, *Value = 0; i < Width; i += 8)
    {
        /* Validate and read one byte */
 
        if (AcpiHwValidateIoRequest (Address, 8) == AE_OK)
        {
            Status = AcpiOsReadPort (Address, &OneByte, 8);
            if (ACPI_FAILURE (Status))
            {
                return (Status);
            }
 
            *Value |= (OneByte << i);
        }
 
        Address++;
    }
 
    return (AE_OK);
}

Referenced by AcpiExSystemIoSpaceHandler(), AcpiHwRead(), and AcpiHwRegisterRead().

AcpiHwRegisterRead()

ACPI_STATUS AcpiHwRegisterRead	(	UINT32	RegisterId,
		UINT32 *	ReturnValue
	)

Definition at line 574 of file hwregs.c.

{
    UINT32                  Value = 0;
    UINT64                  Value64;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwRegisterRead);
 
 
    switch (RegisterId)
    {
    case ACPI_REGISTER_PM1_STATUS:           /* PM1 A/B: 16-bit access each */
 
        Status = AcpiHwReadMultiple (&Value,
            &AcpiGbl_XPm1aStatus,
            &AcpiGbl_XPm1bStatus);
        break;
 
    case ACPI_REGISTER_PM1_ENABLE:           /* PM1 A/B: 16-bit access each */
 
        Status = AcpiHwReadMultiple (&Value,
            &AcpiGbl_XPm1aEnable,
            &AcpiGbl_XPm1bEnable);
        break;
 
    case ACPI_REGISTER_PM1_CONTROL:          /* PM1 A/B: 16-bit access each */
 
        Status = AcpiHwReadMultiple (&Value,
            &AcpiGbl_FADT.XPm1aControlBlock,
            &AcpiGbl_FADT.XPm1bControlBlock);
 
        /*
         * Zero the write-only bits. From the ACPI specification, "Hardware
         * Write-Only Bits": "Upon reads to registers with write-only bits,
         * software masks out all write-only bits."
         */
        Value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
        break;
 
    case ACPI_REGISTER_PM2_CONTROL:          /* 8-bit access */
 
        Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPm2ControlBlock);
        if (ACPI_SUCCESS (Status))
        {
            Value = (UINT32) Value64;
        }
        break;
 
    case ACPI_REGISTER_PM_TIMER:             /* 32-bit access */
 
        Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPmTimerBlock);
        if (ACPI_SUCCESS (Status))
        {
            Value = (UINT32) Value64;
        }
 
        break;
 
    case ACPI_REGISTER_SMI_COMMAND_BLOCK:    /* 8-bit access */
 
        Status = AcpiHwReadPort (AcpiGbl_FADT.SmiCommand, &Value, 8);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
            RegisterId));
        Status = AE_BAD_PARAMETER;
        break;
    }
 
    if (ACPI_SUCCESS (Status))
    {
        *ReturnValue = (UINT32) Value;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvFixedEventDetect(), AcpiHwLegacySleep(), AcpiHwLegacyWakePrep(), AcpiReadBitRegister(), and AcpiWriteBitRegister().

AcpiHwRegisterWrite()

ACPI_STATUS AcpiHwRegisterWrite	(	UINT32	RegisterId,
		UINT32	Value
	)

Definition at line 684 of file hwregs.c.

{
    ACPI_STATUS             Status;
    UINT32                  ReadValue;
    UINT64                  ReadValue64;
 
 
    ACPI_FUNCTION_TRACE (HwRegisterWrite);
 
 
    switch (RegisterId)
    {
    case ACPI_REGISTER_PM1_STATUS:           /* PM1 A/B: 16-bit access each */
        /*
         * Handle the "ignored" bit in PM1 Status. According to the ACPI
         * specification, ignored bits are to be preserved when writing.
         * Normally, this would mean a read/modify/write sequence. However,
         * preserving a bit in the status register is different. Writing a
         * one clears the status, and writing a zero preserves the status.
         * Therefore, we must always write zero to the ignored bit.
         *
         * This behavior is clarified in the ACPI 4.0 specification.
         */
        Value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
 
        Status = AcpiHwWriteMultiple (Value,
            &AcpiGbl_XPm1aStatus,
            &AcpiGbl_XPm1bStatus);
        break;
 
    case ACPI_REGISTER_PM1_ENABLE:           /* PM1 A/B: 16-bit access each */
 
        Status = AcpiHwWriteMultiple (Value,
            &AcpiGbl_XPm1aEnable,
            &AcpiGbl_XPm1bEnable);
        break;
 
    case ACPI_REGISTER_PM1_CONTROL:          /* PM1 A/B: 16-bit access each */
        /*
         * Perform a read first to preserve certain bits (per ACPI spec)
         * Note: This includes SCI_EN, we never want to change this bit
         */
        Status = AcpiHwReadMultiple (&ReadValue,
            &AcpiGbl_FADT.XPm1aControlBlock,
            &AcpiGbl_FADT.XPm1bControlBlock);
        if (ACPI_FAILURE (Status))
        {
            goto Exit;
        }
 
        /* Insert the bits to be preserved */
 
        ACPI_INSERT_BITS (Value, ACPI_PM1_CONTROL_PRESERVED_BITS, ReadValue);
 
        /* Now we can write the data */
 
        Status = AcpiHwWriteMultiple (Value,
            &AcpiGbl_FADT.XPm1aControlBlock,
            &AcpiGbl_FADT.XPm1bControlBlock);
        break;
 
    case ACPI_REGISTER_PM2_CONTROL:          /* 8-bit access */
        /*
         * For control registers, all reserved bits must be preserved,
         * as per the ACPI spec.
         */
        Status = AcpiHwRead (&ReadValue64, &AcpiGbl_FADT.XPm2ControlBlock);
        if (ACPI_FAILURE (Status))
        {
            goto Exit;
        }
        ReadValue = (UINT32) ReadValue64;
 
        /* Insert the bits to be preserved */
 
        ACPI_INSERT_BITS (Value, ACPI_PM2_CONTROL_PRESERVED_BITS, ReadValue);
 
        Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPm2ControlBlock);
        break;
 
    case ACPI_REGISTER_PM_TIMER:             /* 32-bit access */
 
        Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPmTimerBlock);
        break;
 
    case ACPI_REGISTER_SMI_COMMAND_BLOCK:    /* 8-bit access */
 
        /* SMI_CMD is currently always in IO space */
 
        Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, Value, 8);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
            RegisterId));
        Status = AE_BAD_PARAMETER;
        break;
    }
 
Exit:
    return_ACPI_STATUS (Status);
}

Referenced by AcpiHwClearAcpiStatus(), AcpiHwLegacySleep(), and AcpiWriteBitRegister().

AcpiHwSetMode()

ACPI_STATUS AcpiHwSetMode

(

UINT32

Mode

)

Definition at line 66 of file hwacpi.c.

{
 
    ACPI_STATUS             Status;
    UINT32                  Retry;
 
 
    ACPI_FUNCTION_TRACE (HwSetMode);
 
 
    /* If the Hardware Reduced flag is set, machine is always in acpi mode */
 
    if (AcpiGbl_ReducedHardware)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * ACPI 2.0 clarified that if SMI_CMD in FADT is zero,
     * system does not support mode transition.
     */
    if (!AcpiGbl_FADT.SmiCommand)
    {
        ACPI_ERROR ((AE_INFO, "No SMI_CMD in FADT, mode transition failed"));
        return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
    }
 
    /*
     * ACPI 2.0 clarified the meaning of ACPI_ENABLE and ACPI_DISABLE
     * in FADT: If it is zero, enabling or disabling is not supported.
     * As old systems may have used zero for mode transition,
     * we make sure both the numbers are zero to determine these
     * transitions are not supported.
     */
    if (!AcpiGbl_FADT.AcpiEnable && !AcpiGbl_FADT.AcpiDisable)
    {
        ACPI_ERROR ((AE_INFO,
            "No ACPI mode transition supported in this system "
            "(enable/disable both zero)"));
        return_ACPI_STATUS (AE_OK);
    }
 
    switch (Mode)
    {
    case ACPI_SYS_MODE_ACPI:
 
        /* BIOS should have disabled ALL fixed and GP events */
 
        Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand,
            (UINT32) AcpiGbl_FADT.AcpiEnable, 8);
        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Attempting to enable ACPI mode\n"));
        break;
 
    case ACPI_SYS_MODE_LEGACY:
        /*
         * BIOS should clear all fixed status bits and restore fixed event
         * enable bits to default
         */
        Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand,
            (UINT32) AcpiGbl_FADT.AcpiDisable, 8);
        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
            "Attempting to enable Legacy (non-ACPI) mode\n"));
        break;
 
    default:
 
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Could not write ACPI mode change"));
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Some hardware takes a LONG time to switch modes. Give them 3 sec to
     * do so, but allow faster systems to proceed more quickly.
     */
    Retry = 3000;
    while (Retry)
    {
        if (AcpiHwGetMode () == Mode)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
                "Mode %X successfully enabled\n", Mode));
            return_ACPI_STATUS (AE_OK);
        }
        AcpiOsStall (ACPI_USEC_PER_MSEC);
        Retry--;
    }
 
    ACPI_ERROR ((AE_INFO, "Hardware did not change modes"));
    return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
}

Referenced by AcpiDisable(), and AcpiEnable().

AcpiHwValidateRegister()

ACPI_STATUS AcpiHwValidateRegister	(	ACPI_GENERIC_ADDRESS *	Reg,
		UINT8	MaxBitWidth,
		UINT64 *	Address
	)

Definition at line 179 of file hwregs.c.

{
    UINT8                   BitWidth;
    UINT8                   AccessWidth;
 
 
    /* Must have a valid pointer to a GAS structure */
 
    if (!Reg)
    {
        return (AE_BAD_PARAMETER);
    }
 
    /*
     * Copy the target address. This handles possible alignment issues.
     * Address must not be null. A null address also indicates an optional
     * ACPI register that is not supported, so no error message.
     */
    ACPI_MOVE_64_TO_64 (Address, &Reg->Address);
    if (!(*Address))
    {
        return (AE_BAD_ADDRESS);
    }
 
    /* Validate the SpaceID */
 
    if ((Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
        (Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
    {
        ACPI_ERROR ((AE_INFO,
            "Unsupported address space: 0x%X", Reg->SpaceId));
        return (AE_SUPPORT);
    }
 
    /* Validate the AccessWidth */
 
    if (Reg->AccessWidth > 4)
    {
        ACPI_ERROR ((AE_INFO,
            "Unsupported register access width: 0x%X", Reg->AccessWidth));
        return (AE_SUPPORT);
    }
 
    /* Validate the BitWidth, convert AccessWidth into number of bits */
 
    AccessWidth = AcpiHwGetAccessBitWidth (*Address, Reg, MaxBitWidth);
    BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);
    if (MaxBitWidth < BitWidth)
    {
        ACPI_WARNING ((AE_INFO,
            "Requested bit width 0x%X is smaller than register bit width 0x%X",
            MaxBitWidth, BitWidth));
        return (AE_SUPPORT);
    }
 
    return (AE_OK);
}

Referenced by AcpiHwRead(), and AcpiHwWrite().

AcpiHwWrite()

ACPI_STATUS AcpiHwWrite	(	UINT64	Value,
		ACPI_GENERIC_ADDRESS *	Reg
	)

Definition at line 357 of file hwregs.c.

{
    UINT64                  Address;
    UINT8                   AccessWidth;
    UINT32                  BitWidth;
    UINT8                   BitOffset;
    UINT64                  Value64;
    UINT8                   Index;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_NAME (HwWrite);
 
 
    /* Validate contents of the GAS register */
 
    Status = AcpiHwValidateRegister (Reg, 64, &Address);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Convert AccessWidth into number of bits based */
 
    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
    BitWidth = Reg->BitOffset + Reg->BitWidth;
    BitOffset = Reg->BitOffset;
 
    /*
     * Two address spaces supported: Memory or IO. PCI_Config is
     * not supported here because the GAS structure is insufficient
     */
    Index = 0;
    while (BitWidth)
    {
        /*
         * Use offset style bit reads because "Index * AccessWidth" is
         * ensured to be less than 64-bits by AcpiHwValidateRegister().
         */
        Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,
            ACPI_MASK_BITS_ABOVE_64 (AccessWidth));
 
        if (BitOffset >= AccessWidth)
        {
            BitOffset -= AccessWidth;
        }
        else
        {
            if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
            {
                Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
                    Address + Index * ACPI_DIV_8 (AccessWidth),
                    Value64, AccessWidth);
            }
            else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
            {
                Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
                    Address + Index * ACPI_DIV_8 (AccessWidth),
                    (UINT32) Value64, AccessWidth);
            }
        }
 
        /*
         * Index * AccessWidth is ensured to be less than 32-bits by
         * AcpiHwValidateRegister().
         */
        BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
        Index++;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_IO,
        "Wrote: %8.8X%8.8X width %2d   to %8.8X%8.8X (%s)\n",
        ACPI_FORMAT_UINT64 (Value), AccessWidth,
        ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
 
    return (Status);
}

Referenced by AcpiEvCreateGpeInfoBlocks(), AcpiHwClearGpe(), AcpiHwClearGpeBlock(), AcpiHwGpeEnableWrite(), AcpiHwLowSetGpe(), AcpiHwRegisterWrite(), AcpiHwWriteMultiple(), AcpiHwWritePm1Control(), AcpiReset(), and AcpiWrite().

AcpiHwWritePm1Control()

ACPI_STATUS AcpiHwWritePm1Control	(	UINT32	Pm1aControl,
		UINT32	Pm1bControl
	)

Definition at line 536 of file hwregs.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (HwWritePm1Control);
 
 
    Status = AcpiHwWrite (Pm1aControl, &AcpiGbl_FADT.XPm1aControlBlock);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (AcpiGbl_FADT.XPm1bControlBlock.Address)
    {
        Status = AcpiHwWrite (Pm1bControl, &AcpiGbl_FADT.XPm1bControlBlock);
    }
    return_ACPI_STATUS (Status);
}

Referenced by AcpiHwLegacySleep(), and AcpiHwLegacyWakePrep().

AcpiHwWritePort()

ACPI_STATUS AcpiHwWritePort	(	ACPI_IO_ADDRESS	Address,
		UINT32	Value,
		UINT32	Width
	)

Definition at line 312 of file hwvalid.c.

{
    ACPI_STATUS             Status;
    UINT32                  i;
 
 
    /* Truncate address to 16 bits if requested */
 
    if (AcpiGbl_TruncateIoAddresses)
    {
        Address &= ACPI_UINT16_MAX;
    }
 
    /* Validate the entire request and perform the I/O */
 
    Status = AcpiHwValidateIoRequest (Address, Width);
    if (ACPI_SUCCESS (Status))
    {
        Status = AcpiOsWritePort (Address, Value, Width);
        return (Status);
    }
 
    if (Status != AE_AML_ILLEGAL_ADDRESS)
    {
        return (Status);
    }
 
    /*
     * There has been a protection violation within the request. Fall
     * back to byte granularity port I/O and ignore the failing bytes.
     * This provides compatibility with other ACPI implementations.
     */
    for (i = 0; i < Width; i += 8)
    {
        /* Validate and write one byte */
 
        if (AcpiHwValidateIoRequest (Address, 8) == AE_OK)
        {
            Status = AcpiOsWritePort (Address, (Value >> i) & 0xFF, 8);
            if (ACPI_FAILURE (Status))
            {
                return (Status);
            }
        }
 
        Address++;
    }
 
    return (AE_OK);
}

Referenced by AcpiEnterSleepStateS4bios(), AcpiExSystemIoSpaceHandler(), AcpiHwRegisterWrite(), AcpiHwSetMode(), and AcpiHwWrite().