1 /** @file
2 UEFI Miscellaneous boot Services Stall service implementation
3
4 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
5 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 //
16 // Include statements
17 //
18
19 #include "DxeMain.h"
20
21 /**
22 Internal worker function to call the Metronome Architectural Protocol for
23 the number of ticks specified by the UINT64 Counter value. WaitForTick()
24 service of the Metronome Architectural Protocol uses a UINT32 for the number
25 of ticks to wait, so this function loops when Counter is larger than 0xffffffff.
26
27 @param Counter Number of ticks to wait.
28
29 **/
30 VOID
CoreInternalWaitForTick(IN UINT64 Counter)31 CoreInternalWaitForTick (
32 IN UINT64 Counter
33 )
34 {
35 while (RShiftU64 (Counter, 32) > 0) {
36 gMetronome->WaitForTick (gMetronome, 0xffffffff);
37 Counter -= 0xffffffff;
38 }
39 gMetronome->WaitForTick (gMetronome, (UINT32)Counter);
40 }
41
42 /**
43 Introduces a fine-grained stall.
44
45 @param Microseconds The number of microseconds to stall execution.
46
47 @retval EFI_SUCCESS Execution was stalled for at least the requested
48 amount of microseconds.
49 @retval EFI_NOT_AVAILABLE_YET gMetronome is not available yet
50
51 **/
52 EFI_STATUS
53 EFIAPI
CoreStall(IN UINTN Microseconds)54 CoreStall (
55 IN UINTN Microseconds
56 )
57 {
58 UINT64 Counter;
59 UINT32 Remainder;
60 UINTN Index;
61
62 if (gMetronome == NULL) {
63 return EFI_NOT_AVAILABLE_YET;
64 }
65
66 //
67 // Counter = Microseconds * 10 / gMetronome->TickPeriod
68 // 0x1999999999999999 = (2^64 - 1) / 10
69 //
70 if (Microseconds > 0x1999999999999999ULL) {
71 //
72 // Microseconds is too large to multiple by 10 first. Perform the divide
73 // operation first and loop 10 times to avoid 64-bit math overflow.
74 //
75 Counter = DivU64x32Remainder (
76 Microseconds,
77 gMetronome->TickPeriod,
78 &Remainder
79 );
80 for (Index = 0; Index < 10; Index++) {
81 CoreInternalWaitForTick (Counter);
82 }
83
84 if (Remainder != 0) {
85 //
86 // If Remainder was not zero, then normally, Counter would be rounded
87 // up by 1 tick. In this case, since a loop for 10 counts was used
88 // to emulate the multiply by 10 operation, Counter needs to be rounded
89 // up by 10 counts.
90 //
91 CoreInternalWaitForTick (10);
92 }
93 } else {
94 //
95 // Calculate the number of ticks by dividing the number of microseconds by
96 // the TickPeriod. Calculation is based on 100ns unit.
97 //
98 Counter = DivU64x32Remainder (
99 MultU64x32 (Microseconds, 10),
100 gMetronome->TickPeriod,
101 &Remainder
102 );
103 if (Remainder != 0) {
104 //
105 // If Remainder is not zero, then round Counter up by one tick.
106 //
107 Counter++;
108 }
109 CoreInternalWaitForTick (Counter);
110 }
111
112 return EFI_SUCCESS;
113 }
114