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