OcTimerLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
 
#include <IndustryStandard/GenericIch.h>
#include <IndustryStandard/Pci.h>
#include <IndustryStandard/CpuId.h>
 
#include <Library/BaseLib.h>
#include <Library/OcCpuLib.h>
#include <Library/DebugLib.h>
#include <Library/IoLib.h>
#include <Library/PciLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/TimerLib.h>
 
STATIC UINT64  mTscFrequency = 0;
 
STATIC
VOID
InternalCpuDelay (
  IN UINT64  Delay
  )
{
  UINT64  Ticks;
 
  //
  // The target timer count is calculated here
  //
  Ticks = AsmReadTsc () + Delay;
 
  //
  // Wait until time out
  // Timer wrap-arounds are NOT handled correctly by this function.
  // Thus, this function must be called within 10 years of reset since
  // Intel guarantees a minimum of 10 years before the TSC wraps.
  //
  while (AsmReadTsc () <= Ticks) {
    CpuPause ();
  }
}
 
UINTN
EFIAPI
MicroSecondDelay (
  IN      UINTN  MicroSeconds
  )
{
  if (mTscFrequency > 0) {
    InternalCpuDelay (
      DivU64x32 (
        MultU64x64 (
          MicroSeconds,
          mTscFrequency
          ),
        1000000u
        )
      );
  }
 
  return MicroSeconds;
}
 
UINTN
EFIAPI
NanoSecondDelay (
  IN      UINTN  NanoSeconds
  )
{
  if (mTscFrequency > 0) {
    InternalCpuDelay (
      DivU64x32 (
        MultU64x64 (
          NanoSeconds,
          mTscFrequency
          ),
        1000000000u
        )
      );
  }
 
  return NanoSeconds;
}
 
UINT64
EFIAPI
GetPerformanceCounter (
  VOID
  )
{
  return AsmReadTsc ();
}
 
UINT64
EFIAPI
GetPerformanceCounterProperties (
  OUT      UINT64 *StartValue, OPTIONAL
  OUT      UINT64                    *EndValue     OPTIONAL
  )
{
  if (StartValue != NULL) {
    *StartValue = 0;
  }
 
  if (EndValue != NULL) {
    *EndValue = 0xffffffffffffffffULL;
  }
 
  return mTscFrequency;
}
 
UINT64
EFIAPI
GetTimeInNanoSecond (
  IN UINT64  Ticks
  )
{
  UINT64  Frequency;
  UINT64  NanoSeconds;
  UINT64  Remainder;
  INTN    Shift;
 
  Frequency = GetPerformanceCounterProperties (NULL, NULL);
 
  if (Frequency == 0) {
    return 0;
  }
 
  //
  //          Ticks
  // Time = --------- x 1,000,000,000
  //        Frequency
  //
  NanoSeconds = MultU64x32 (DivU64x64Remainder (Ticks, Frequency, &Remainder), 1000000000u);
 
  //
  // Ensure (Remainder * 1,000,000,000) will not overflow 64-bit.
  // Since 2^29 < 1,000,000,000 = 0x3B9ACA00 < 2^30, Remainder should < 2^(64-30) = 2^34,
  // i.e. highest bit set in Remainder should <= 33.
  //
  Shift        = MAX (0, HighBitSet64 (Remainder) - 33);
  Remainder    = RShiftU64 (Remainder, (UINTN)Shift);
  Frequency    = RShiftU64 (Frequency, (UINTN)Shift);
  NanoSeconds += DivU64x64Remainder (MultU64x32 (Remainder, 1000000000u), Frequency, NULL);
 
  return NanoSeconds;
}
 
UINT64
EFIAPI
GetTscFrequency (
  VOID
  )
{
  return mTscFrequency;
}
 
EFI_STATUS
EFIAPI
OcTimerLibConstructor (
  VOID
  )
{
  mTscFrequency = OcGetTSCFrequency ();
 
  return EFI_SUCCESS;
}