MdePkg/Library/SecPeiDxeTimerLibCpu/IpfTimerLib.c

   1 /** @file
   2   Timer Library functions built upon ITC on IPF.
   3
   4   Copyright (c) 2006 - 2007, 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   Module Name:  IpfTimerLib.c
  14
  15 **/
  16
  17 #include <Base.h>
  18 #include <Library/TimerLib.h>
  19 #include <Library/BaseLib.h>
  20 #include <Library/IoLib.h>
  21 #include <Library/DebugLib.h>
  22 #include <Library/PcdLib.h>
  23
  24
  25 /**
  26   Performs a delay measured as number of ticks.
  27
  28   An internal function to perform a delay measured as number of ticks. It's
  29   invoked by MicroSecondDelay() and NanoSecondDelay().
  30
  31   @param  Delay Number of ticks to delay.
  32
  33 **/
  34 STATIC
  35 VOID
  36 InternalIpfDelay (
  37   IN      INT64                     Delay
  38   )
  39 {
  40   INT64                             Ticks;
  41
  42   //
  43   // The target timer count is calculated here
  44   //
  45   Ticks = (INT64)AsmReadItc () + Delay;
  46
  47   //
  48   // Wait until time out
  49   // Delay > 2^63 could not be handled by this function
  50   // Timer wrap-arounds are handled correctly by this function
  51   //
  52   while (Ticks - (INT64)AsmReadItc() >= 0);
  53 }
  54
  55 /**
  56   Stalls the CPU for at least the given number of microseconds.
  57
  58   Stalls the CPU for the number of microseconds specified by MicroSeconds.
  59
  60   @param  MicroSeconds  The minimum number of microseconds to delay.
  61
  62   @return MicroSeconds
  63
  64 **/
  65 UINTN
  66 EFIAPI
  67 MicroSecondDelay (
  68   IN      UINTN                     MicroSeconds
  69   )
  70 {
  71   InternalIpfDelay (
  72     GetPerformanceCounterProperties (NULL, NULL) *
  73     MicroSeconds /
  74     1000000
  75     );
  76   return MicroSeconds;
  77 }
  78
  79 /**
  80   Stalls the CPU for at least the given number of nanoseconds.
  81
  82   Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
  83
  84   @param  NanoSeconds The minimum number of nanoseconds to delay.
  85
  86   @return NanoSeconds
  87
  88 **/
  89 UINTN
  90 EFIAPI
  91 NanoSecondDelay (
  92   IN      UINTN                     NanoSeconds
  93   )
  94 {
  95   InternalIpfDelay (
  96     GetPerformanceCounterProperties (NULL, NULL) *
  97     NanoSeconds /
  98     1000000000
  99     );
 100   return NanoSeconds;
 101 }
 102
 103 /**
 104   Retrieves the current value of a 64-bit free running performance counter.
 105
 106   Retrieves the current value of a 64-bit free running performance counter. The
 107   counter can either count up by 1 or count down by 1. If the physical
 108   performance counter counts by a larger increment, then the counter values
 109   must be translated. The properties of the counter can be retrieved from
 110   GetPerformanceCounterProperties().
 111
 112   @return The current value of the free running performance counter.
 113
 114 **/
 115 UINT64
 116 EFIAPI
 117 GetPerformanceCounter (
 118   VOID
 119   )
 120 {
 121   return AsmReadItc ();
 122 }
 123
 124 /**
 125   Retrieves the 64-bit frequency in Hz and the range of performance counter
 126   values.
 127
 128   If StartValue is not NULL, then the value that the performance counter starts
 129   with immediately after is it rolls over is returned in StartValue. If
 130   EndValue is not NULL, then the value that the performance counter end with
 131   immediately before it rolls over is returned in EndValue. The 64-bit
 132   frequency of the performance counter in Hz is always returned. If StartValue
 133   is less than EndValue, then the performance counter counts up. If StartValue
 134   is greater than EndValue, then the performance counter counts down. For
 135   example, a 64-bit free running counter that counts up would have a StartValue
 136   of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
 137   that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
 138
 139   @param  StartValue  The value the performance counter starts with when it
 140                       rolls over.
 141   @param  EndValue    The value that the performance counter ends with before
 142                       it rolls over.
 143
 144   @return The frequency in Hz.
 145
 146 **/
 147 UINT64
 148 EFIAPI
 149 GetPerformanceCounterProperties (
 150   OUT      UINT64                    *StartValue,  OPTIONAL
 151   OUT      UINT64                    *EndValue     OPTIONAL
 152   )
 153 {
 154   PAL_CALL_RETURN                   PalRet;
 155   UINT64                            BaseFrequence;
 156
 157   PalRet = PalCallStatic (NULL, 13, 0, 0, 0);
 158   ASSERT (PalRet.Status == 0);
 159   BaseFrequence = PalRet.r9;
 160
 161   PalRet = PalCallStatic (NULL, 14, 0, 0, 0);
 162   ASSERT (PalRet.Status == 0);
 163
 164   if (StartValue != NULL) {
 165     *StartValue = 0;
 166   }
 167
 168   if (EndValue != NULL) {
 169     *EndValue = (UINT64)(-1);
 170   }
 171
 172   return BaseFrequence * (PalRet.r11 >> 32) / (UINT32)PalRet.r11;
 173 }