1 /** @file 2 ACPI Timer implements one instance of Timer Library. 3 4 Copyright (c) 2008 - 2012, Intel Corporation. All rights reserved.<BR> 5 Copyright (c) 2011, Andrei Warkentin <andreiw (at) motorola.com> 6 7 This program and the accompanying materials are 8 licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include <Library/DebugLib.h> 18 #include <Library/BaseLib.h> 19 #include <IndustryStandard/Acpi.h> 20 21 #include "AcpiTimerLib.h" 22 23 // 24 // The ACPI Time is a 24-bit counter 25 // 26 #define ACPI_TIMER_COUNT_SIZE BIT24 27 28 /** 29 Stalls the CPU for at least the given number of ticks. 30 31 Stalls the CPU for at least the given number of ticks. It's invoked by 32 MicroSecondDelay() and NanoSecondDelay(). 33 34 @param Delay A period of time to delay in ticks. 35 36 **/ 37 VOID 38 InternalAcpiDelay ( 39 IN UINT32 Delay 40 ) 41 { 42 UINT32 Ticks; 43 UINT32 Times; 44 45 Times = Delay >> 22; 46 Delay &= BIT22 - 1; 47 do { 48 // 49 // The target timer count is calculated here 50 // 51 Ticks = InternalAcpiGetTimerTick () + Delay; 52 Delay = BIT22; 53 // 54 // Wait until time out 55 // Delay >= 2^23 could not be handled by this function 56 // Timer wrap-arounds are handled correctly by this function 57 // 58 while (((Ticks - InternalAcpiGetTimerTick ()) & BIT23) == 0) { 59 CpuPause (); 60 } 61 } while (Times-- > 0); 62 } 63 64 /** 65 Stalls the CPU for at least the given number of microseconds. 66 67 Stalls the CPU for the number of microseconds specified by MicroSeconds. 68 69 @param MicroSeconds The minimum number of microseconds to delay. 70 71 @return MicroSeconds 72 73 **/ 74 UINTN 75 EFIAPI 76 MicroSecondDelay ( 77 IN UINTN MicroSeconds 78 ) 79 { 80 InternalAcpiDelay ( 81 (UINT32)DivU64x32 ( 82 MultU64x32 ( 83 MicroSeconds, 84 ACPI_TIMER_FREQUENCY 85 ), 86 1000000u 87 ) 88 ); 89 return MicroSeconds; 90 } 91 92 /** 93 Stalls the CPU for at least the given number of nanoseconds. 94 95 Stalls the CPU for the number of nanoseconds specified by NanoSeconds. 96 97 @param NanoSeconds The minimum number of nanoseconds to delay. 98 99 @return NanoSeconds 100 101 **/ 102 UINTN 103 EFIAPI 104 NanoSecondDelay ( 105 IN UINTN NanoSeconds 106 ) 107 { 108 InternalAcpiDelay ( 109 (UINT32)DivU64x32 ( 110 MultU64x32 ( 111 NanoSeconds, 112 ACPI_TIMER_FREQUENCY 113 ), 114 1000000000u 115 ) 116 ); 117 return NanoSeconds; 118 } 119 120 /** 121 Retrieves the current value of a 64-bit free running performance counter. 122 123 Retrieves the current value of a 64-bit free running performance counter. The 124 counter can either count up by 1 or count down by 1. If the physical 125 performance counter counts by a larger increment, then the counter values 126 must be translated. The properties of the counter can be retrieved from 127 GetPerformanceCounterProperties(). 128 129 @return The current value of the free running performance counter. 130 131 **/ 132 UINT64 133 EFIAPI 134 GetPerformanceCounter ( 135 VOID 136 ) 137 { 138 return (UINT64)InternalAcpiGetTimerTick (); 139 } 140 141 /** 142 Retrieves the 64-bit frequency in Hz and the range of performance counter 143 values. 144 145 If StartValue is not NULL, then the value that the performance counter starts 146 with immediately after is it rolls over is returned in StartValue. If 147 EndValue is not NULL, then the value that the performance counter end with 148 immediately before it rolls over is returned in EndValue. The 64-bit 149 frequency of the performance counter in Hz is always returned. If StartValue 150 is less than EndValue, then the performance counter counts up. If StartValue 151 is greater than EndValue, then the performance counter counts down. For 152 example, a 64-bit free running counter that counts up would have a StartValue 153 of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter 154 that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0. 155 156 @param StartValue The value the performance counter starts with when it 157 rolls over. 158 @param EndValue The value that the performance counter ends with before 159 it rolls over. 160 161 @return The frequency in Hz. 162 163 **/ 164 UINT64 165 EFIAPI 166 GetPerformanceCounterProperties ( 167 OUT UINT64 *StartValue, OPTIONAL 168 OUT UINT64 *EndValue OPTIONAL 169 ) 170 { 171 if (StartValue != NULL) { 172 *StartValue = 0; 173 } 174 175 if (EndValue != NULL) { 176 *EndValue = ACPI_TIMER_COUNT_SIZE - 1; 177 } 178 179 return ACPI_TIMER_FREQUENCY; 180 } 181 182 /** 183 Converts elapsed ticks of performance counter to time in nanoseconds. 184 185 This function converts the elapsed ticks of running performance counter to 186 time value in unit of nanoseconds. 187 188 @param Ticks The number of elapsed ticks of running performance counter. 189 190 @return The elapsed time in nanoseconds. 191 192 **/ 193 UINT64 194 EFIAPI 195 GetTimeInNanoSecond ( 196 IN UINT64 Ticks 197 ) 198 { 199 UINT64 NanoSeconds; 200 UINT32 Remainder; 201 202 // 203 // Ticks 204 // Time = --------- x 1,000,000,000 205 // Frequency 206 // 207 NanoSeconds = MultU64x32 (DivU64x32Remainder (Ticks, ACPI_TIMER_FREQUENCY, &Remainder), 1000000000u); 208 209 // 210 // Frequency < 0x100000000, so Remainder < 0x100000000, then (Remainder * 1,000,000,000) 211 // will not overflow 64-bit. 212 // 213 NanoSeconds += DivU64x32 (MultU64x32 ((UINT64) Remainder, 1000000000u), ACPI_TIMER_FREQUENCY); 214 215 return NanoSeconds; 216 } 217
