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