MdePkg/Library/BaseTimerLibLocalApic/x86TimerLib.c

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