MdePkg/Library/SecPeiDxeTimerLibCpu/X86TimerLib.c

   1 /** @file
   2   Timer Library functions built upon local APIC on IA32/x64.
   3
   4   Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <Base.h>
  16 #include <Library/TimerLib.h>
  17 #include <Library/BaseLib.h>
  18 #include <Library/IoLib.h>
  19 #include <Library/PcdLib.h>
  20 #include <Library/DebugLib.h>
  21
  22 #define APIC_LVTERR     0x370
  23 #define APIC_TMICT      0x380
  24 #define APIC_TMCCT      0x390
  25 #define APIC_TDCR       0x3e0
  26
  27 //
  28 // The following array is used in calculating the frequency of local APIC
  29 // timer. Refer to IA-32 developers' manual for more details.
  30 //
  31 GLOBAL_REMOVE_IF_UNREFERENCED
  32 CONST UINT8                           mTimerLibLocalApicDivisor[] = {
  33   0x02, 0x04, 0x08, 0x10,
  34   0x02, 0x04, 0x08, 0x10,
  35   0x20, 0x40, 0x80, 0x01,
  36   0x20, 0x40, 0x80, 0x01
  37 };
  38
  39 /**
  40   Internal function to retrieve the base address of local APIC.
  41
  42   @return The base address of local APIC
  43
  44 **/
  45 UINTN
  46 EFIAPI
  47 InternalX86GetApicBase (
  48   VOID
  49   )
  50 {
  51   return (UINTN)AsmMsrBitFieldRead64 (27, 12, 35) << 12;
  52 }
  53
  54 /**
  55   Internal function to return the frequency of the local APIC timer.
  56
  57   @param  ApicBase  The base address of memory mapped registers of local APIC.
  58
  59   @return The frequency of the timer in Hz.
  60
  61 **/
  62 UINT32
  63 EFIAPI
  64 InternalX86GetTimerFrequency (
  65   IN      UINTN                     ApicBase
  66   )
  67 {
  68   return
  69     PcdGet32(PcdFSBClock) /
  70     mTimerLibLocalApicDivisor[MmioBitFieldRead32 (ApicBase + APIC_TDCR, 0, 3)];
  71 }
  72
  73 /**
  74   Internal function to read the current tick counter of local APIC.
  75
  76   @param  ApicBase  The base address of memory mapped registers of local APIC.
  77
  78   @return The tick counter read.
  79
  80 **/
  81 INT32
  82 EFIAPI
  83 InternalX86GetTimerTick (
  84   IN      UINTN                     ApicBase
  85   )
  86 {
  87   return MmioRead32 (ApicBase + APIC_TMCCT);
  88 }
  89
  90 /**
  91   Stalls the CPU for at least the given number of ticks.
  92
  93   Stalls the CPU for at least the given number of ticks. It's invoked by
  94   MicroSecondDelay() and NanoSecondDelay().
  95
  96   @param  ApicBase  The base address of memory mapped registers of local APIC.
  97   @param  Delay     A period of time to delay in ticks.
  98
  99 **/
 100 VOID
 101 EFIAPI
 102 InternalX86Delay (
 103   IN      UINTN                     ApicBase,
 104   IN      UINT32                    Delay
 105   )
 106 {
 107   INT32                             Ticks;
 108   UINT32                            PowerOfTwoCounter;
 109
 110   //
 111   // The target timer count is calculated here
 112   //
 113   Ticks = InternalX86GetTimerTick (ApicBase) - Delay;
 114
 115   //
 116   // Wait until time out
 117   // Delay > 2^31 could not be handled by this function
 118   // Timer wrap-arounds are handled correctly by this function
 119   //
 120   PowerOfTwoCounter = GetPowerOfTwo32 (MmioRead32 (ApicBase + APIC_TMICT));
 121   while (((UINT32)(InternalX86GetTimerTick (ApicBase) - Ticks) & PowerOfTwoCounter) == 0) {
 122     CpuPause ();
 123   }
 124 }
 125
 126 /**
 127   Stalls the CPU for at least the given number of microseconds.
 128
 129   Stalls the CPU for the number of microseconds specified by MicroSeconds.
 130
 131   @param  MicroSeconds  The minimum number of microseconds to delay.
 132
 133   @return The value of MicroSeconds inputted.
 134
 135 **/
 136 UINTN
 137 EFIAPI
 138 MicroSecondDelay (
 139   IN      UINTN                     MicroSeconds
 140   )
 141 {
 142   UINTN                             ApicBase;
 143
 144   ApicBase = InternalX86GetApicBase ();
 145   InternalX86Delay (
 146     ApicBase,
 147     (UINT32)DivU64x32 (
 148               MultU64x64 (
 149                 InternalX86GetTimerFrequency (ApicBase),
 150                 MicroSeconds
 151                 ),
 152               1000000u
 153               )
 154     );
 155   return MicroSeconds;
 156 }
 157
 158 /**
 159   Stalls the CPU for at least the given number of nanoseconds.
 160
 161   Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
 162
 163   @param  NanoSeconds The minimum number of nanoseconds to delay.
 164
 165   @return The value of NanoSeconds inputted.
 166
 167 **/
 168 UINTN
 169 EFIAPI
 170 NanoSecondDelay (
 171   IN      UINTN                     NanoSeconds
 172   )
 173 {
 174   UINTN                             ApicBase;
 175
 176   ApicBase = InternalX86GetApicBase ();
 177   InternalX86Delay (
 178     ApicBase,
 179     (UINT32)DivU64x32 (
 180               MultU64x64 (
 181                 InternalX86GetTimerFrequency (ApicBase),
 182                 NanoSeconds
 183                 ),
 184               1000000000u
 185               )
 186     );
 187   return NanoSeconds;
 188 }
 189
 190 /**
 191   Retrieves the current value of a 64-bit free running performance counter.
 192
 193   The counter can either count up by 1 or count down by 1. If the physical
 194   performance counter counts by a larger increment, then the counter values
 195   must be translated. The properties of the counter can be retrieved from
 196   GetPerformanceCounterProperties().
 197
 198   @return The current value of the free running performance counter.
 199
 200 **/
 201 UINT64
 202 EFIAPI
 203 GetPerformanceCounter (
 204   VOID
 205   )
 206 {
 207   return (UINT64)(UINT32)InternalX86GetTimerTick (InternalX86GetApicBase ());
 208 }
 209
 210 /**
 211   Retrieves the 64-bit frequency in Hz and the range of performance counter
 212   values.
 213
 214   If StartValue is not NULL, then the value that the performance counter starts
 215   with immediately after is it rolls over is returned in StartValue. If
 216   EndValue is not NULL, then the value that the performance counter end with
 217   immediately before it rolls over is returned in EndValue. The 64-bit
 218   frequency of the performance counter in Hz is always returned. If StartValue
 219   is less than EndValue, then the performance counter counts up. If StartValue
 220   is greater than EndValue, then the performance counter counts down. For
 221   example, a 64-bit free running counter that counts up would have a StartValue
 222   of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
 223   that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
 224
 225   @param  StartValue  The value the performance counter starts with when it
 226                       rolls over.
 227   @param  EndValue    The value that the performance counter ends with before
 228                       it rolls over.
 229
 230   @return The frequency in Hz.
 231
 232 **/
 233 UINT64
 234 EFIAPI
 235 GetPerformanceCounterProperties (
 236   OUT      UINT64                    *StartValue,  OPTIONAL
 237   OUT      UINT64                    *EndValue     OPTIONAL
 238   )
 239 {
 240   UINTN                             ApicBase;
 241
 242   ApicBase = InternalX86GetApicBase ();
 243
 244   if (StartValue != NULL) {
 245     *StartValue = MmioRead32 (ApicBase + APIC_TMICT);
 246     //
 247     // make sure StartValue is all 1s from High Bit
 248     //
 249     ASSERT ((*StartValue & (*StartValue + 1)) == 0);
 250   }
 251
 252   if (EndValue != NULL) {
 253     *EndValue = 0;
 254   }
 255
 256   return (UINT64) InternalX86GetTimerFrequency (ApicBase);
 257 }