From 16bb6612f489f912d355d3713302bc4f267826da Mon Sep 17 00:00:00 2001 From: aystarik Date: Wed, 29 Jun 2005 16:53:22 +0000 Subject: [PATCH] Support for GAS GPEs/FixedEvents/Timer date 2002.03.27.22.14.00; author rmoore1; state Exp; --- source/components/hardware/hwgpe.c | 206 ++++---- source/components/hardware/hwregs.c | 710 +++++++++------------------ source/components/hardware/hwtimer.c | 62 +-- 3 files changed, 386 insertions(+), 592 deletions(-) diff --git a/source/components/hardware/hwgpe.c b/source/components/hardware/hwgpe.c index bdfcc12cd..e9c1ed4e2 100644 --- a/source/components/hardware/hwgpe.c +++ b/source/components/hardware/hwgpe.c @@ -2,7 +2,7 @@ /****************************************************************************** * * Module Name: hwgpe - Low level GPE enable/disable/clear functions - * $Revision: 1.35 $ + * $Revision: 1.40 $ * *****************************************************************************/ @@ -10,7 +10,7 @@ * * 1. Copyright Notice * - * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. + * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp. * All rights reserved. * * 2. License @@ -121,7 +121,27 @@ #include "acevents.h" #define _COMPONENT ACPI_HARDWARE - MODULE_NAME ("hwgpe") + ACPI_MODULE_NAME ("hwgpe") + + +/****************************************************************************** + * + * FUNCTION: AcpiHwGetGpeBitMask + * + * PARAMETERS: GpeNumber - The GPE + * + * RETURN: Gpe register bitmask for this gpe level + * + * DESCRIPTION: Get the bitmask for this GPE + * + ******************************************************************************/ + +UINT32 +AcpiHwGetGpeBitMask ( + UINT32 GpeNumber) +{ + return (AcpiGbl_GpeNumberInfo [AcpiEvGetGpeNumberIndex (GpeNumber)].BitMask); +} /****************************************************************************** @@ -145,29 +165,28 @@ AcpiHwEnableGpe ( UINT32 BitMask; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); /* * Read the current value of the register, set the appropriate bit * to enable the GPE, and write out the new register. */ - InByte = 0; - AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8); - AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, - (InByte | BitMask), 8); + InByte = AcpiHwLowLevelRead (8, + &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0); + AcpiHwLowLevelWrite (8, (InByte | BitMask), + &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0); } + /****************************************************************************** * * FUNCTION: AcpiHwEnableGpeForWakeup @@ -189,25 +208,24 @@ AcpiHwEnableGpeForWakeup ( UINT32 BitMask; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); /* * Set the bit so we will not disable this when sleeping */ - AcpiGbl_GpeRegisters[RegisterIndex].WakeEnable |= BitMask; + AcpiGbl_GpeRegisterInfo[RegisterIndex].WakeEnable |= BitMask; } + /****************************************************************************** * * FUNCTION: AcpiHwDisableGpe @@ -229,31 +247,30 @@ AcpiHwDisableGpe ( UINT32 BitMask; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); /* * Read the current value of the register, clear the appropriate bit, * and write out the new register value to disable the GPE. */ - InByte = 0; - AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8); - AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, - (InByte & ~BitMask), 8); + InByte = AcpiHwLowLevelRead (8, + &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0); + AcpiHwLowLevelWrite (8, (InByte & ~BitMask), + &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0); AcpiHwDisableGpeForWakeup(GpeNumber); } + /****************************************************************************** * * FUNCTION: AcpiHwDisableGpeForWakeup @@ -275,25 +292,24 @@ AcpiHwDisableGpeForWakeup ( UINT32 BitMask; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); /* * Clear the bit so we will disable this when sleeping */ - AcpiGbl_GpeRegisters[RegisterIndex].WakeEnable &= ~BitMask; + AcpiGbl_GpeRegisterInfo[RegisterIndex].WakeEnable &= ~BitMask; } + /****************************************************************************** * * FUNCTION: AcpiHwClearGpe @@ -314,24 +330,23 @@ AcpiHwClearGpe ( UINT32 BitMask; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); /* * Write a one to the appropriate bit in the status register to * clear this GPE. */ - AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, BitMask, 8); + AcpiHwLowLevelWrite (8, BitMask, + &AcpiGbl_GpeRegisterInfo[RegisterIndex].StatusAddress, 0); } @@ -355,9 +370,10 @@ AcpiHwGetGpeStatus ( UINT32 InByte = 0; UINT32 RegisterIndex = 0; UINT32 BitMask = 0; + ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; - FUNCTION_ENTRY (); + ACPI_FUNCTION_ENTRY (); if (!EventStatus) @@ -367,45 +383,40 @@ AcpiHwGetGpeStatus ( (*EventStatus) = 0; - /* - * Translate GPE number to index into global registers array. - */ - RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; + /* Translate GPE number to index into global registers array. */ - /* - * Figure out the bit offset for this GPE within the target register. - */ - BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; + RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber); + GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[RegisterIndex]; - /* - * Enabled?: - */ - InByte = 0; - AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8); + /* Get the register bitmask for this GPE */ + + BitMask = AcpiHwGetGpeBitMask (GpeNumber); + + /* GPE Enabled? */ + + InByte = AcpiHwLowLevelRead (8, &GpeRegisterInfo->EnableAddress, 0); if (BitMask & InByte) { (*EventStatus) |= ACPI_EVENT_FLAG_ENABLED; } - /* - * Enabled for wake?: - */ - if (BitMask & AcpiGbl_GpeRegisters[RegisterIndex].WakeEnable) + /* GPE Enabled for wake? */ + + if (BitMask & GpeRegisterInfo->WakeEnable) { (*EventStatus) |= ACPI_EVENT_FLAG_WAKE_ENABLED; } - /* - * Set? - */ - InByte = 0; - AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, &InByte, 8); + /* GPE active (set)? */ + + InByte = AcpiHwLowLevelRead (8, &GpeRegisterInfo->StatusAddress, 0); if (BitMask & InByte) { (*EventStatus) |= ACPI_EVENT_FLAG_SET; } } + /****************************************************************************** * * FUNCTION: AcpiHwDisableNonWakeupGpes @@ -416,7 +427,7 @@ AcpiHwGetGpeStatus ( * * DESCRIPTION: Disable all non-wakeup GPEs * Call with interrupts disabled. The interrupt handler also - * modifies AcpiGbl_GpeRegisters[i].Enable, so it should not be + * modifies AcpiGbl_GpeRegisterInfo[i].Enable, so it should not be * given the chance to run until after non-wake GPEs are * re-enabled. * @@ -427,26 +438,32 @@ AcpiHwDisableNonWakeupGpes ( void) { UINT32 i; + ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; + + + ACPI_FUNCTION_ENTRY (); - FUNCTION_ENTRY (); for (i = 0; i < AcpiGbl_GpeRegisterCount; i++) { + GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[i]; + /* * Read the enabled status of all GPEs. We * will be using it to restore all the GPEs later. */ - AcpiOsReadPort (AcpiGbl_GpeRegisters[i].EnableAddr, - &AcpiGbl_GpeRegisters[i].Enable, 8); + GpeRegisterInfo->Enable = (UINT8) AcpiHwLowLevelRead (8, + &GpeRegisterInfo->EnableAddress, 0); /* - * Disable all GPEs but wakeup GPEs. + * Disable all GPEs except wakeup GPEs. */ - AcpiOsWritePort(AcpiGbl_GpeRegisters[i].EnableAddr, - AcpiGbl_GpeRegisters[i].WakeEnable, 8); + AcpiHwLowLevelWrite (8, GpeRegisterInfo->WakeEnable, + &GpeRegisterInfo->EnableAddress, 0); } } + /****************************************************************************** * * FUNCTION: AcpiHwEnableNonWakeupGpes @@ -464,16 +481,21 @@ AcpiHwEnableNonWakeupGpes ( void) { UINT32 i; + ACPI_GPE_REGISTER_INFO *GpeRegisterInfo; + + + ACPI_FUNCTION_ENTRY (); - FUNCTION_ENTRY (); for (i = 0; i < AcpiGbl_GpeRegisterCount; i++) { + GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[i]; + /* * We previously stored the enabled status of all GPEs. * Blast them back in. */ - AcpiOsWritePort(AcpiGbl_GpeRegisters[i].EnableAddr, - AcpiGbl_GpeRegisters[i].Enable, 8); + AcpiHwLowLevelWrite (8, GpeRegisterInfo->Enable, & + GpeRegisterInfo->EnableAddress, 0); } } diff --git a/source/components/hardware/hwregs.c b/source/components/hardware/hwregs.c index f5ae4dfcc..26f84c4eb 100644 --- a/source/components/hardware/hwregs.c +++ b/source/components/hardware/hwregs.c @@ -3,7 +3,7 @@ * * Module Name: hwregs - Read/write access functions for the various ACPI * control and status registers. - * $Revision: 1.102 $ + * $Revision: 1.121 $ * ******************************************************************************/ @@ -11,7 +11,7 @@ * * 1. Copyright Notice * - * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. + * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp. * All rights reserved. * * 2. License @@ -123,43 +123,7 @@ #include "acnamesp.h" #define _COMPONENT ACPI_HARDWARE - MODULE_NAME ("hwregs") - - -/* This matches the #defines in actypes.h. */ - -NATIVE_CHAR *SleepStateTable[] = {"\\_S0_","\\_S1_","\\_S2_","\\_S3_", - "\\_S4_","\\_S5_","\\_S4B"}; - - -/******************************************************************************* - * - * FUNCTION: AcpiHwGetBitShift - * - * PARAMETERS: Mask - Input mask to determine bit shift from. - * Must have at least 1 bit set. - * - * RETURN: Bit location of the lsb of the mask - * - * DESCRIPTION: Returns the bit number for the low order bit that's set. - * - ******************************************************************************/ - -UINT32 -AcpiHwGetBitShift ( - UINT32 Mask) -{ - UINT32 Shift; - - - FUNCTION_TRACE ("HwGetBitShift"); - - - for (Shift = 0; ((Mask >> Shift) & 1) == 0; Shift++) - { ; } - - return_VALUE (Shift); -} + ACPI_MODULE_NAME ("hwregs") /******************************************************************************* @@ -177,95 +141,85 @@ AcpiHwGetBitShift ( void AcpiHwClearAcpiStatus (void) { - UINT16 GpeLength; - UINT16 Index; + NATIVE_UINT i; + NATIVE_UINT GpeBlock; + ACPI_STATUS Status; - FUNCTION_TRACE ("HwClearAcpiStatus"); + ACPI_FUNCTION_TRACE ("HwClearAcpiStatus"); - DEBUG_PRINTP (TRACE_IO, ("About to write %04X to %04X\n", - ALL_FIXED_STS_BITS, + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %04X\n", + ACPI_BITMASK_ALL_FIXED_STATUS, (UINT16) ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm1aEvtBlk.Address))); - AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); + Status = AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); + if (ACPI_FAILURE (Status)) + { + return_VOID; + } - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_STS, ALL_FIXED_STS_BITS); + AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_STATUS, + ACPI_BITMASK_ALL_FIXED_STATUS); + /* Clear the fixed events */ if (ACPI_VALID_ADDRESS (AcpiGbl_FADT->XPm1bEvtBlk.Address)) { - AcpiOsWritePort ((ACPI_IO_ADDRESS) - ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm1bEvtBlk.Address), - ALL_FIXED_STS_BITS, 16); + AcpiHwLowLevelWrite (16, ACPI_BITMASK_ALL_FIXED_STATUS, + &AcpiGbl_FADT->XPm1bEvtBlk, 0); } - /* now clear the GPE Bits */ + /* Clear the GPE Bits */ - if (AcpiGbl_FADT->Gpe0BlkLen) + for (GpeBlock = 0; GpeBlock < ACPI_MAX_GPE_BLOCKS; GpeBlock++) { - GpeLength = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); - - for (Index = 0; Index < GpeLength; Index++) + for (i = 0; i < AcpiGbl_GpeBlockInfo[GpeBlock].RegisterCount; i++) { - AcpiOsWritePort ((ACPI_IO_ADDRESS) ( - ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe0Blk.Address) + Index), - 0xFF, 8); + AcpiHwLowLevelWrite (8, 0xFF, + AcpiGbl_GpeBlockInfo[GpeBlock].BlockAddress, i); } } - if (AcpiGbl_FADT->Gpe1BlkLen) - { - GpeLength = (UINT16) DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); - - for (Index = 0; Index < GpeLength; Index++) - { - AcpiOsWritePort ((ACPI_IO_ADDRESS) ( - ACPI_GET_ADDRESS (AcpiGbl_FADT->XGpe1Blk.Address) + Index), - 0xFF, 8); - } - } - - AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); + (void) AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); return_VOID; } /******************************************************************************* * - * FUNCTION: AcpiHwObtainSleepTypeRegisterData + * FUNCTION: AcpiHwGetSleepTypeData * - * PARAMETERS: SleepState - Numeric state requested - * *Slp_TypA - Pointer to byte to receive SLP_TYPa value - * *Slp_TypB - Pointer to byte to receive SLP_TYPb value + * PARAMETERS: SleepState - Numeric sleep state + * *SleepTypeA - Where SLP_TYPa is returned + * *SleepTypeB - Where SLP_TYPb is returned * * RETURN: Status - ACPI status * - * DESCRIPTION: AcpiHwObtainSleepTypeRegisterData() obtains the SLP_TYP and - * SLP_TYPb values for the sleep state requested. + * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep + * state. * ******************************************************************************/ ACPI_STATUS -AcpiHwObtainSleepTypeRegisterData ( +AcpiHwGetSleepTypeData ( UINT8 SleepState, - UINT8 *Slp_TypA, - UINT8 *Slp_TypB) + UINT8 *SleepTypeA, + UINT8 *SleepTypeB) { ACPI_STATUS Status = AE_OK; ACPI_OPERAND_OBJECT *ObjDesc; - FUNCTION_TRACE ("HwObtainSleepTypeRegisterData"); + ACPI_FUNCTION_TRACE ("HwGetSleepTypeData"); /* * Validate parameters */ - if ((SleepState > ACPI_S_STATES_MAX) || - !Slp_TypA || !Slp_TypB) + !SleepTypeA || !SleepTypeB) { return_ACPI_STATUS (AE_BAD_PARAMETER); } @@ -273,8 +227,8 @@ AcpiHwObtainSleepTypeRegisterData ( /* * AcpiEvaluate the namespace object containing the values for this state */ - - Status = AcpiNsEvaluateByName (SleepStateTable[SleepState], NULL, &ObjDesc); + Status = AcpiNsEvaluateByName ((NATIVE_CHAR *) AcpiGbl_DbSleepStates[SleepState], + NULL, &ObjDesc); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); @@ -282,7 +236,7 @@ AcpiHwObtainSleepTypeRegisterData ( if (!ObjDesc) { - REPORT_ERROR (("Missing Sleep State object\n")); + ACPI_REPORT_ERROR (("Missing Sleep State object\n")); return_ACPI_STATUS (AE_NOT_EXIST); } @@ -293,7 +247,7 @@ AcpiHwObtainSleepTypeRegisterData ( */ /* Even though AcpiEvaluateObject resolves package references, - * NsEvaluate dpesn't. So, we do it here. + * NsEvaluate doesn't. So, we do it here. */ Status = AcpiUtResolvePackageReferences(ObjDesc); @@ -301,89 +255,173 @@ AcpiHwObtainSleepTypeRegisterData ( { /* Must have at least two elements */ - REPORT_ERROR (("Sleep State package does not have at least two elements\n")); - Status = AE_ERROR; + ACPI_REPORT_ERROR (("Sleep State package does not have at least two elements\n")); + Status = AE_AML_NO_OPERAND; } - - else if (((ObjDesc->Package.Elements[0])->Common.Type != - ACPI_TYPE_INTEGER) || - ((ObjDesc->Package.Elements[1])->Common.Type != - ACPI_TYPE_INTEGER)) + else if (((ObjDesc->Package.Elements[0])->Common.Type != ACPI_TYPE_INTEGER) || + ((ObjDesc->Package.Elements[1])->Common.Type != ACPI_TYPE_INTEGER)) { /* Must have two */ - REPORT_ERROR (("Sleep State package elements are not both of type Number\n")); - Status = AE_ERROR; + ACPI_REPORT_ERROR (("Sleep State package elements are not both of type Number\n")); + Status = AE_AML_OPERAND_TYPE; } - else { /* * Valid _Sx_ package size, type, and value */ - *Slp_TypA = (UINT8) (ObjDesc->Package.Elements[0])->Integer.Value; - - *Slp_TypB = (UINT8) (ObjDesc->Package.Elements[1])->Integer.Value; + *SleepTypeA = (UINT8) (ObjDesc->Package.Elements[0])->Integer.Value; + *SleepTypeB = (UINT8) (ObjDesc->Package.Elements[1])->Integer.Value; } - if (ACPI_FAILURE (Status)) { - DEBUG_PRINTP (ACPI_ERROR, ("Bad Sleep object %p type %X\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad Sleep object %p type %X\n", ObjDesc, ObjDesc->Common.Type)); } AcpiUtRemoveReference (ObjDesc); - return_ACPI_STATUS (Status); } /******************************************************************************* * - * FUNCTION: AcpiHwRegisterBitAccess + * FUNCTION: AcpiHwGetRegisterBitMask * - * PARAMETERS: ReadWrite - Either ACPI_READ or ACPI_WRITE. + * PARAMETERS: RegisterId - index of ACPI Register to access + * + * RETURN: The bit mask to be used when accessing the register + * + * DESCRIPTION: Map RegisterId into a register bit mask. + * + ******************************************************************************/ + +ACPI_BIT_REGISTER_INFO * +AcpiHwGetBitRegisterInfo ( + UINT32 RegisterId) +{ + ACPI_FUNCTION_NAME ("HwGetBitRegisterInfo"); + + + if (RegisterId > ACPI_BITREG_MAX) + { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid BitRegister ID: %X\n", RegisterId)); + return (NULL); + } + + return (&AcpiGbl_BitRegisterInfo[RegisterId]); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiHwBitRegisterRead + * + * PARAMETERS: RegisterId - index of ACPI Register to access * UseLock - Lock the hardware - * RegisterId - index of ACPI Register to access - * Value - (only used on write) value to write to the - * Register. Shifted all the way right. * - * RETURN: Value written to or read from specified Register. This value - * is shifted all the way right. + * RETURN: Value is read from specified Register. Value returned is + * normalized to bit0 (is shifted all the way right) * - * DESCRIPTION: Generic ACPI Register read/write function. + * DESCRIPTION: ACPI BitRegister read function. * ******************************************************************************/ UINT32 -AcpiHwRegisterBitAccess ( - NATIVE_UINT ReadWrite, - BOOLEAN UseLock, +AcpiHwBitRegisterRead ( UINT32 RegisterId, - ...) /* Value (only used on write) */ + UINT32 Flags) { UINT32 RegisterValue = 0; - UINT32 Mask = 0; - UINT32 Value = 0; - va_list marker; + ACPI_BIT_REGISTER_INFO *BitRegInfo; - FUNCTION_TRACE ("HwRegisterBitAccess"); + ACPI_FUNCTION_TRACE ("HwBitRegisterRead"); - if (ReadWrite == ACPI_WRITE) + if (Flags & ACPI_MTX_LOCK) { - va_start (marker, RegisterId); - Value = va_arg (marker, UINT32); - va_end (marker); + if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_HARDWARE))) + { + return_VALUE (0); + } } - if (ACPI_MTX_LOCK == UseLock) + /* Get the info structure corresponding to the requested ACPI Register */ + + BitRegInfo = AcpiHwGetBitRegisterInfo (RegisterId); + if (!BitRegInfo) { - AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); + return_ACPI_STATUS (AE_BAD_PARAMETER); } + RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, BitRegInfo->ParentRegister); + + if (Flags & ACPI_MTX_LOCK) + { + (void) AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); + } + + /* Normalize the value that was read */ + + RegisterValue = ((RegisterValue & BitRegInfo->AccessBitMask) >> BitRegInfo->BitPosition); + + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "ACPI RegisterRead: got %X\n", RegisterValue)); + return_VALUE (RegisterValue); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiHwBitRegisterWrite + * + * PARAMETERS: RegisterId - ID of ACPI BitRegister to access + * Value - (only used on write) value to write to the + * Register, NOT pre-normalized to the bit pos. + * Flags - Lock the hardware or not + * + * RETURN: Value written to from specified Register. This value + * is shifted all the way right. + * + * DESCRIPTION: ACPI Bit Register write function. + * + ******************************************************************************/ + +UINT32 +AcpiHwBitRegisterWrite ( + UINT32 RegisterId, + UINT32 Value, + UINT32 Flags) +{ + UINT32 RegisterValue = 0; + ACPI_BIT_REGISTER_INFO *BitRegInfo; + + + ACPI_FUNCTION_TRACE_U32 ("HwBitRegisterWrite", RegisterId); + + + if (Flags & ACPI_MTX_LOCK) + { + if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_HARDWARE))) + { + return_VALUE (0); + } + } + + /* Get the info structure corresponding to the requested ACPI Register */ + + BitRegInfo = AcpiHwGetBitRegisterInfo (RegisterId); + if (!BitRegInfo) + { + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + /* Always do a register read first so we can insert the new bits */ + + RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, BitRegInfo->ParentRegister); + /* * Decode the Register ID * Register id = Register block id | bit id @@ -391,302 +429,84 @@ AcpiHwRegisterBitAccess ( * Check bit id to fine locate Register offset. * Check Mask to determine Register offset, and then read-write. */ - - switch (REGISTER_BLOCK_ID (RegisterId)) + switch (BitRegInfo->ParentRegister) { - case PM1_STS: + case ACPI_REGISTER_PM1_STATUS: - switch (RegisterId) + /* + * Status Registers are different from the rest. Clear by + * writing 1, writing 0 has no effect. So, the only relevent + * information is the single bit we're interested in, all others should + * be written as 0 so they will be left unchanged + */ + Value = ACPI_REGISTER_PREPARE_BITS (Value, BitRegInfo->BitPosition, BitRegInfo->AccessBitMask); + if (Value) { - case TMR_STS: - Mask = TMR_STS_MASK; - break; - - case BM_STS: - Mask = BM_STS_MASK; - break; - - case GBL_STS: - Mask = GBL_STS_MASK; - break; - - case PWRBTN_STS: - Mask = PWRBTN_STS_MASK; - break; - - case SLPBTN_STS: - Mask = SLPBTN_STS_MASK; - break; - - case RTC_STS: - Mask = RTC_STS_MASK; - break; - - case WAK_STS: - Mask = WAK_STS_MASK; - break; - - default: - Mask = 0; - break; + AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_STATUS, + (UINT16) Value); + RegisterValue = 0; } - - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_STS); - - if (ReadWrite == ACPI_WRITE) - { - /* - * Status Registers are different from the rest. Clear by - * writing 1, writing 0 has no effect. So, the only relevent - * information is the single bit we're interested in, all - * others should be written as 0 so they will be left - * unchanged - */ - - Value <<= AcpiHwGetBitShift (Mask); - Value &= Mask; - - if (Value) - { - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_STS, - (UINT16) Value); - RegisterValue = 0; - } - } - break; - case PM1_EN: + case ACPI_REGISTER_PM1_ENABLE: - switch (RegisterId) - { - case TMR_EN: - Mask = TMR_EN_MASK; - break; - - case GBL_EN: - Mask = GBL_EN_MASK; - break; - - case PWRBTN_EN: - Mask = PWRBTN_EN_MASK; - break; - - case SLPBTN_EN: - Mask = SLPBTN_EN_MASK; - break; - - case RTC_EN: - Mask = RTC_EN_MASK; - break; - - default: - Mask = 0; - break; - } - - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_EN); - - if (ReadWrite == ACPI_WRITE) - { - RegisterValue &= ~Mask; - Value <<= AcpiHwGetBitShift (Mask); - Value &= Mask; - RegisterValue |= Value; - - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, PM1_EN, (UINT16) RegisterValue); - } + ACPI_REGISTER_INSERT_VALUE (RegisterValue, BitRegInfo->BitPosition, BitRegInfo->AccessBitMask, Value); + AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_ENABLE, (UINT16) RegisterValue); break; - case PM1_CONTROL: - - switch (RegisterId) - { - case SCI_EN: - Mask = SCI_EN_MASK; - break; - - case BM_RLD: - Mask = BM_RLD_MASK; - break; - - case GBL_RLS: - Mask = GBL_RLS_MASK; - break; - - case SLP_TYPE_A: - case SLP_TYPE_B: - Mask = SLP_TYPE_X_MASK; - break; - - case SLP_EN: - Mask = SLP_EN_MASK; - break; - - default: - Mask = 0; - break; - } - + case ACPI_REGISTER_PM1_CONTROL: /* * Read the PM1 Control register. * Note that at this level, the fact that there are actually TWO - * registers (A and B) and that B may not exist, are abstracted. + * registers (A and B - and that B may not exist) is abstracted. */ - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM1_CONTROL); + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM1 control: Read %X\n", RegisterValue)); - DEBUG_PRINT (TRACE_IO, ("PM1 control: Read %X\n", RegisterValue)); + ACPI_REGISTER_INSERT_VALUE (RegisterValue, BitRegInfo->BitPosition, BitRegInfo->AccessBitMask, Value); - if (ReadWrite == ACPI_WRITE) - { - RegisterValue &= ~Mask; - Value <<= AcpiHwGetBitShift (Mask); - Value &= Mask; - RegisterValue |= Value; - - /* - * SLP_TYPE_x Registers are written differently - * than any other control Registers with - * respect to A and B Registers. The value - * for A may be different than the value for B - * - * Therefore, pass the RegisterId, not just generic PM1_CONTROL, - * because we need to do different things. Yuck. - */ - - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, RegisterId, - (UINT16) RegisterValue); - } + AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, RegisterId, + (UINT16) RegisterValue); break; - case PM2_CONTROL: + case ACPI_REGISTER_PM2_CONTROL: - switch (RegisterId) - { - case ARB_DIS: - Mask = ARB_DIS_MASK; - break; + RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM2_CONTROL); - default: - Mask = 0; - break; - } + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM2 control: Read %X from %8.8X%8.8X\n", + RegisterValue, ACPI_HIDWORD (AcpiGbl_FADT->XPm2CntBlk.Address), + ACPI_LODWORD (AcpiGbl_FADT->XPm2CntBlk.Address))); - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, PM2_CONTROL); + ACPI_REGISTER_INSERT_VALUE (RegisterValue, BitRegInfo->BitPosition, BitRegInfo->AccessBitMask, Value); - DEBUG_PRINT (TRACE_IO, ("PM2 control: Read %X from %p\n", - RegisterValue, ACPI_GET_ADDRESS (AcpiGbl_FADT->XPm2CntBlk.Address))); + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n", + RegisterValue, + ACPI_HIDWORD (AcpiGbl_FADT->XPm2CntBlk.Address), + ACPI_LODWORD (AcpiGbl_FADT->XPm2CntBlk.Address))); - if (ReadWrite == ACPI_WRITE) - { - RegisterValue &= ~Mask; - Value <<= AcpiHwGetBitShift (Mask); - Value &= Mask; - RegisterValue |= Value; - - DEBUG_PRINT (TRACE_IO, ("About to write %04X to %p\n", RegisterValue, - AcpiGbl_FADT->XPm2CntBlk.Address)); - - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, - PM2_CONTROL, (UINT8) (RegisterValue)); - } + AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, + ACPI_REGISTER_PM2_CONTROL, (UINT8) (RegisterValue)); break; - case PM_TIMER: - - Mask = TMR_VAL_MASK; - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, - PM_TIMER); - DEBUG_PRINT (TRACE_IO, ("PM_TIMER: Read %X from %p\n", - RegisterValue, ACPI_GET_ADDRESS (AcpiGbl_FADT->XPmTmrBlk.Address))); - - break; - - - case GPE1_EN_BLOCK: - case GPE1_STS_BLOCK: - case GPE0_EN_BLOCK: - case GPE0_STS_BLOCK: - - /* Determine the bit to be accessed - * - * (UINT32) RegisterId: - * 31 24 16 8 0 - * +--------+--------+--------+--------+ - * | gpe_block_id | gpe_bit_number | - * +--------+--------+--------+--------+ - * - * gpe_block_id is one of GPE[01]_EN_BLOCK and GPE[01]_STS_BLOCK - * gpe_bit_number is relative from the gpe_block (0x00~0xFF) - */ - - Mask = REGISTER_BIT_ID(RegisterId); /* gpe_bit_number */ - RegisterId = REGISTER_BLOCK_ID(RegisterId) | (Mask >> 3); - Mask = AcpiGbl_DecodeTo8bit [Mask % 8]; - - /* - * The base address of the GPE 0 Register Block - * Plus 1/2 the length of the GPE 0 Register Block - * The enable Register is the Register following the Status Register - * and each Register is defined as 1/2 of the total Register Block - */ - - /* - * This sets the bit within EnableBit that needs to be written to - * the Register indicated in Mask to a 1, all others are 0 - */ - - /* Now get the current Enable Bits in the selected Reg */ - - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, RegisterId); - DEBUG_PRINT (TRACE_IO, ("GPE Enable bits: Read %X from %X\n", - RegisterValue, RegisterId)); - - if (ReadWrite == ACPI_WRITE) - { - RegisterValue &= ~Mask; - Value <<= AcpiHwGetBitShift (Mask); - Value &= Mask; - RegisterValue |= Value; - - /* This write will put the Action state into the General Purpose */ - /* Enable Register indexed by the value in Mask */ - - DEBUG_PRINT (TRACE_IO, ("About to write %04X to %04X\n", - RegisterValue, RegisterId)); - AcpiHwRegisterWrite (ACPI_MTX_DO_NOT_LOCK, RegisterId, - (UINT8) RegisterValue); - RegisterValue = AcpiHwRegisterRead (ACPI_MTX_DO_NOT_LOCK, - RegisterId); - } - break; - - - case SMI_CMD_BLOCK: - case PROCESSOR_BLOCK: - /* Not used by any callers at this time - therefore, not implemented */ - default: - - Mask = 0; break; } - if (ACPI_MTX_LOCK == UseLock) { - AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); + if (Flags & ACPI_MTX_LOCK) + { + (void) AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } + /* Normalize the value that was read */ - RegisterValue &= Mask; - RegisterValue >>= AcpiHwGetBitShift (Mask); + RegisterValue = ((RegisterValue & BitRegInfo->AccessBitMask) >> BitRegInfo->BitPosition); - DEBUG_PRINT (TRACE_IO, ("Register I/O: returning %X\n", RegisterValue)); + ACPI_DEBUG_PRINT ((ACPI_DB_IO, "ACPI RegisterWrite actual %X\n", RegisterValue)); return_VALUE (RegisterValue); } @@ -714,92 +534,65 @@ AcpiHwRegisterRead ( UINT32 BankOffset; - FUNCTION_TRACE ("AcpiHwRegisterRead"); + ACPI_FUNCTION_TRACE ("HwRegisterRead"); if (ACPI_MTX_LOCK == UseLock) { - AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); + if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_HARDWARE))) + { + return_VALUE (0); + } } - - switch (REGISTER_BLOCK_ID(RegisterId)) + switch (RegisterId) { - case PM1_STS: /* 16-bit access */ + case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aEvtBlk, 0); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bEvtBlk, 0); break; - case PM1_EN: /* 16-bit access*/ + case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access*/ - BankOffset = DIV_2 (AcpiGbl_FADT->Pm1EvtLen); + BankOffset = ACPI_DIV_2 (AcpiGbl_FADT->Pm1EvtLen); Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aEvtBlk, BankOffset); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bEvtBlk, BankOffset); break; - case PM1_CONTROL: /* 16-bit access */ + case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ Value = AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1aCntBlk, 0); Value |= AcpiHwLowLevelRead (16, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; - case PM2_CONTROL: /* 8-bit access */ + case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XPm2CntBlk, 0); break; - case PM_TIMER: /* 32-bit access */ + case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ Value = AcpiHwLowLevelRead (32, &AcpiGbl_FADT->XPmTmrBlk, 0); break; - - case GPE0_STS_BLOCK: /* 8-bit access */ - - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, 0); - break; - - - case GPE0_EN_BLOCK: /* 8-bit access */ - - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe0Blk, BankOffset); - break; - - - case GPE1_STS_BLOCK: /* 8-bit access */ - - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, 0); - break; - - - case GPE1_EN_BLOCK: /* 8-bit access */ - - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); - Value = AcpiHwLowLevelRead (8, &AcpiGbl_FADT->XGpe1Blk, BankOffset); - break; - - - case SMI_CMD_BLOCK: /* 8bit */ + case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ AcpiOsReadPort (AcpiGbl_FADT->SmiCmd, &Value, 8); break; - default: /* Value will be returned as 0 */ break; } - if (ACPI_MTX_LOCK == UseLock) { - AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); + (void) AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } return_VALUE (Value); @@ -828,93 +621,69 @@ AcpiHwRegisterWrite ( { UINT32 BankOffset; - FUNCTION_TRACE ("AcpiHwRegisterWrite"); + + ACPI_FUNCTION_TRACE ("HwRegisterWrite"); if (ACPI_MTX_LOCK == UseLock) { - AcpiUtAcquireMutex (ACPI_MTX_HARDWARE); + if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_HARDWARE))) + { + return_VOID; + } } - - switch (REGISTER_BLOCK_ID (RegisterId)) + switch (RegisterId) { - case PM1_STS: /* 16-bit access */ + case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aEvtBlk, 0); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bEvtBlk, 0); break; - case PM1_EN: /* 16-bit access*/ + case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access*/ - BankOffset = DIV_2 (AcpiGbl_FADT->Pm1EvtLen); + BankOffset = ACPI_DIV_2 (AcpiGbl_FADT->Pm1EvtLen); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aEvtBlk, BankOffset); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bEvtBlk, BankOffset); break; - case PM1_CONTROL: /* 16-bit access */ + case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aCntBlk, 0); AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; - case PM1A_CONTROL: /* 16-bit access */ + case ACPI_REGISTER_PM1A_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1aCntBlk, 0); break; - case PM1B_CONTROL: /* 16-bit access */ + case ACPI_REGISTER_PM1B_CONTROL: /* 16-bit access */ AcpiHwLowLevelWrite (16, Value, &AcpiGbl_FADT->XPm1bCntBlk, 0); break; - case PM2_CONTROL: /* 8-bit access */ + case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XPm2CntBlk, 0); break; - case PM_TIMER: /* 32-bit access */ + case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ AcpiHwLowLevelWrite (32, Value, &AcpiGbl_FADT->XPmTmrBlk, 0); break; - case GPE0_STS_BLOCK: /* 8-bit access */ + case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe0Blk, 0); - break; - - - case GPE0_EN_BLOCK: /* 8-bit access */ - - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe0BlkLen); - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe0Blk, BankOffset); - break; - - - case GPE1_STS_BLOCK: /* 8-bit access */ - - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe1Blk, 0); - break; - - - case GPE1_EN_BLOCK: /* 8-bit access */ - - BankOffset = DIV_2 (AcpiGbl_FADT->Gpe1BlkLen); - AcpiHwLowLevelWrite (8, Value, &AcpiGbl_FADT->XGpe1Blk, BankOffset); - break; - - - case SMI_CMD_BLOCK: /* 8bit */ - - /* For 2.0, SMI_CMD is always in IO space */ - /* TBD: what about 1.0? 0.71? */ + /* SMI_CMD is currently always in IO space */ AcpiOsWritePort (AcpiGbl_FADT->SmiCmd, Value, 8); break; @@ -925,10 +694,9 @@ AcpiHwRegisterWrite ( break; } - if (ACPI_MTX_LOCK == UseLock) { - AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); + (void) AcpiUtReleaseMutex (ACPI_MTX_HARDWARE); } return_VOID; @@ -962,6 +730,9 @@ AcpiHwLowLevelRead ( UINT16 PciRegister; + ACPI_FUNCTION_ENTRY (); + + /* * Must have a valid pointer to a GAS structure, and * a non-zero address within @@ -972,12 +743,10 @@ AcpiHwLowLevelRead ( return 0; } - /* * Three address spaces supported: * Memory, Io, or PCI config. */ - switch (Reg->AddressSpaceId) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: @@ -1041,6 +810,9 @@ AcpiHwLowLevelWrite ( UINT16 PciRegister; + ACPI_FUNCTION_ENTRY (); + + /* * Must have a valid pointer to a GAS structure, and * a non-zero address within @@ -1051,12 +823,10 @@ AcpiHwLowLevelWrite ( return; } - /* * Three address spaces supported: * Memory, Io, or PCI config. */ - switch (Reg->AddressSpaceId) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: diff --git a/source/components/hardware/hwtimer.c b/source/components/hardware/hwtimer.c index f6297d034..7c8836576 100644 --- a/source/components/hardware/hwtimer.c +++ b/source/components/hardware/hwtimer.c @@ -2,7 +2,7 @@ /****************************************************************************** * * Name: hwtimer.c - ACPI Power Management Timer Interface - * $Revision: 1.30 $ + * $Revision: 1.20 $ * *****************************************************************************/ @@ -10,7 +10,7 @@ * * 1. Copyright Notice * - * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp. + * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp. * All rights reserved. * * 2. License @@ -116,6 +116,7 @@ *****************************************************************************/ #include "acpi.h" +#include "achware.h" #define _COMPONENT ACPI_HARDWARE ACPI_MODULE_NAME ("hwtimer") @@ -125,11 +126,11 @@ * * FUNCTION: AcpiGetTimerResolution * - * PARAMETERS: Resolution - Where the resolution is returned + * PARAMETERS: none * - * RETURN: Status and timer resolution + * RETURN: Number of bits of resolution in the PM Timer (24 or 32). * - * DESCRIPTION: Obtains resolution of the ACPI PM Timer (24 or 32 bits). + * DESCRIPTION: Obtains resolution of the ACPI PM Timer. * ******************************************************************************/ @@ -162,11 +163,11 @@ AcpiGetTimerResolution ( * * FUNCTION: AcpiGetTimer * - * PARAMETERS: Ticks - Where the timer value is returned + * PARAMETERS: none * - * RETURN: Status and current timer value (ticks) + * RETURN: Current value of the ACPI PM Timer (in ticks). * - * DESCRIPTION: Obtains current value of ACPI PM Timer (in ticks). + * DESCRIPTION: Obtains current value of ACPI PM Timer. * ******************************************************************************/ @@ -174,9 +175,6 @@ ACPI_STATUS AcpiGetTimer ( UINT32 *Ticks) { - ACPI_STATUS Status; - - ACPI_FUNCTION_TRACE ("AcpiGetTimer"); @@ -185,9 +183,9 @@ AcpiGetTimer ( return_ACPI_STATUS (AE_BAD_PARAMETER); } - Status = AcpiHwLowLevelRead (32, Ticks, &AcpiGbl_FADT->XPmTmrBlk); + *Ticks = AcpiHwLowLevelRead (32, &AcpiGbl_FADT->XPmTmrBlk, 0); - return_ACPI_STATUS (Status); + return_ACPI_STATUS (AE_OK); } @@ -195,11 +193,11 @@ AcpiGetTimer ( * * FUNCTION: AcpiGetTimerDuration * - * PARAMETERS: StartTicks - Starting timestamp - * EndTicks - End timestamp - * TimeElapsed - Where the elapsed time is returned + * PARAMETERS: StartTicks + * EndTicks + * TimeElapsed * - * RETURN: Status and TimeElapsed + * RETURN: TimeElapsed * * DESCRIPTION: Computes the time elapsed (in microseconds) between two * PM Timer time stamps, taking into account the possibility of @@ -210,13 +208,10 @@ AcpiGetTimer ( * transitions (unlike many CPU timestamp counters) -- making it * a versatile and accurate timer. * - * Note that this function accommodates only a single timer + * Note that this function accomodates only a single timer * rollover. Thus for 24-bit timers, this function should only * be used for calculating durations less than ~4.6 seconds - * (~20 minutes for 32-bit timers) -- calculations below: - * - * 2**24 Ticks / 3,600,000 Ticks/Sec = 4.66 sec - * 2**32 Ticks / 3,600,000 Ticks/Sec = 1193 sec or 19.88 minutes + * (~20 hours for 32-bit timers). * ******************************************************************************/ @@ -226,9 +221,10 @@ AcpiGetTimerDuration ( UINT32 EndTicks, UINT32 *TimeElapsed) { + UINT32 DeltaTicks = 0; + UINT64_OVERLAY NormalizedTicks; ACPI_STATUS Status; - UINT32 DeltaTicks; - ACPI_INTEGER Quotient; + ACPI_INTEGER OutQuotient; ACPI_FUNCTION_TRACE ("AcpiGetTimerDuration"); @@ -241,7 +237,8 @@ AcpiGetTimerDuration ( /* * Compute Tick Delta: - * Handle (max one) timer rollovers on 24-bit versus 32-bit timers. + * ------------------- + * Handle (max one) timer rollovers on 24- versus 32-bit timers. */ if (StartTicks < EndTicks) { @@ -262,21 +259,26 @@ AcpiGetTimerDuration ( DeltaTicks = (0xFFFFFFFF - StartTicks) + EndTicks; } } - else /* StartTicks == EndTicks */ + else { *TimeElapsed = 0; return_ACPI_STATUS (AE_OK); } /* - * Compute Duration (Requires a 64-bit multiply and divide): + * Compute Duration: + * ----------------- + * + * Requires a 64-bit divide: * * TimeElapsed = (DeltaTicks * 1000000) / PM_TIMER_FREQUENCY; */ - Status = AcpiUtShortDivide (((UINT64) DeltaTicks) * 1000000, - PM_TIMER_FREQUENCY, &Quotient, NULL); + NormalizedTicks.Full = ((UINT64) DeltaTicks) * 1000000; - *TimeElapsed = (UINT32) Quotient; + Status = AcpiUtShortDivide (&NormalizedTicks.Full, PM_TIMER_FREQUENCY, + &OutQuotient, NULL); + + *TimeElapsed = (UINT32) OutQuotient; return_ACPI_STATUS (Status); }