X86TimerLib.c

Go to the documentation of this file.

 
#include <Base.h>
#include <Library/TimerLib.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/HobLib.h>
#include <Guid/AcpiDescription.h>
#include <Library/IoLib.h>
#include <Library/PciLib.h>
 
EFI_ACPI_DESCRIPTION  *gAcpiDesc = NULL;
 
EFI_ACPI_DESCRIPTION *
InternalGetApciDescrptionTable (
  VOID
  )
{
  EFI_PEI_HOB_POINTERS  GuidHob;
 
  if (gAcpiDesc != NULL) {
    return gAcpiDesc;
  }
 
  GuidHob.Raw = GetFirstGuidHob (&gEfiAcpiDescriptionGuid);
  if (GuidHob.Raw != NULL) {
    gAcpiDesc = GET_GUID_HOB_DATA (GuidHob.Guid);
    DEBUG ((EFI_D_INFO, "ACPI Timer: PM_TMR_BLK.RegisterBitWidth = 0x%X\n", gAcpiDesc->PM_TMR_BLK.RegisterBitWidth));
    DEBUG ((EFI_D_INFO, "ACPI Timer: PM_TMR_BLK.Address = 0x%X\n", gAcpiDesc->PM_TMR_BLK.Address));
    return gAcpiDesc;
  } else {
    DEBUG ((EFI_D_ERROR, "Fail to get Acpi description table from hob\n"));
    return NULL;
  }
}
 
STATIC
UINT32
InternalAcpiGetTimerTick (
  VOID
  )
{
  return IoRead32 ((UINTN)gAcpiDesc->PM_TMR_BLK.Address);
}
 
STATIC
VOID
InternalAcpiDelay (
  IN      UINT32  Delay
  )
{
  UINT32  Ticks;
  UINT32  Times;
 
  Times  = Delay >> (gAcpiDesc->PM_TMR_BLK.RegisterBitWidth - 2);
  Delay &= (1 << (gAcpiDesc->PM_TMR_BLK.RegisterBitWidth - 2)) - 1;
  do {
    //
    // The target timer count is calculated here
    //
    Ticks = InternalAcpiGetTimerTick () + Delay;
    Delay = 1 << (gAcpiDesc->PM_TMR_BLK.RegisterBitWidth - 2);
    //
    // Wait until time out
    // Delay >= 2^23 (if ACPI provide 24-bit timer) or Delay >= 2^31 (if ACPI
    // provide 32-bit timer) could not be handled by this function
    // Timer wrap-arounds are handled correctly by this function
    //
    while (((Ticks - InternalAcpiGetTimerTick ()) & (1 << (gAcpiDesc->PM_TMR_BLK.RegisterBitWidth - 1))) == 0) {
      CpuPause ();
    }
  } while (Times-- > 0);
}
 
UINTN
EFIAPI
MicroSecondDelay (
  IN      UINTN  MicroSeconds
  )
{
  if (InternalGetApciDescrptionTable () == NULL) {
    return MicroSeconds;
  }
 
  InternalAcpiDelay (
    (UINT32)DivU64x32 (
              MultU64x32 (
                MicroSeconds,
                3579545
                ),
              1000000u
              )
    );
  return MicroSeconds;
}
 
UINTN
EFIAPI
NanoSecondDelay (
  IN      UINTN  NanoSeconds
  )
{
  if (InternalGetApciDescrptionTable () == NULL) {
    return NanoSeconds;
  }
 
  InternalAcpiDelay (
    (UINT32)DivU64x32 (
              MultU64x32 (
                NanoSeconds,
                3579545
                ),
              1000000000u
              )
    );
  return NanoSeconds;
}
 
UINT64
EFIAPI
GetPerformanceCounter (
  VOID
  )
{
  if (InternalGetApciDescrptionTable () == NULL) {
    return 0;
  }
 
  return (UINT64)InternalAcpiGetTimerTick ();
}
 
UINT64
EFIAPI
GetPerformanceCounterProperties (
  OUT      UINT64 *StartValue, OPTIONAL
  OUT      UINT64                    *EndValue     OPTIONAL
  )
{
  if (InternalGetApciDescrptionTable () == NULL) {
    return 0;
  }
 
  if (StartValue != NULL) {
    *StartValue = 0;
  }
 
  if (EndValue != NULL) {
    *EndValue = (1 << gAcpiDesc->PM_TMR_BLK.RegisterBitWidth) - 1;
  }
 
  return 3579545;
}
 
UINT64
EFIAPI
GetTimeInNanoSecond (
  IN      UINT64  Ticks
  )
{
  UINT64  NanoSeconds;
  UINT32  Remainder;
 
  //
  //          Ticks
  // Time = --------- x 1,000,000,000
  //        Frequency
  //
  NanoSeconds = MultU64x32 (DivU64x32Remainder (Ticks, 3579545, &Remainder), 1000000000u);
 
  //
  // Frequency < 0x100000000, so Remainder < 0x100000000, then (Remainder * 1,000,000,000)
  // will not overflow 64-bit.
  //
  NanoSeconds += DivU64x32 (MultU64x32 ((UINT64)Remainder, 1000000000u), 3579545);
 
  return NanoSeconds;
}