VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/EmbeddedPkg/Library/VirtualRealTimeClockLib/VirtualRealTimeClockLib.c@ 105381

Last change on this file since 105381 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 12.4 KB
Line 
1/** @file
2 *
3 * Implement virtual EFI RealTimeClock runtime services.
4 *
5 * Coypright (c) 2019, Pete Batard <pete@akeo.ie>
6 * Copyright (c) 2018, Andrei Warkentin <andrey.warkentin@gmail.com>
7 * Copyright (c) 2011-2021, ARM Ltd. All rights reserved.
8 * Copyright (c) 2008-2010, Apple Inc. All rights reserved.
9 * Copyright (c) Microsoft Corporation. All rights reserved.
10 *
11 * SPDX-License-Identifier: BSD-2-Clause-Patent
12 *
13 * Based on ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf
14 *
15 **/
16
17#include <PiDxe.h>
18#include <Library/BaseLib.h>
19#include <Library/DebugLib.h>
20#include <Library/IoLib.h>
21#include <Library/RealTimeClockLib.h>
22#include <Library/TimerLib.h>
23#include <Library/TimeBaseLib.h>
24#include <Library/UefiRuntimeLib.h>
25
26STATIC CONST CHAR16 mEpochVariableName[] = L"RtcEpochSeconds";
27STATIC CONST CHAR16 mTimeZoneVariableName[] = L"RtcTimeZone";
28STATIC CONST CHAR16 mDaylightVariableName[] = L"RtcDaylight";
29
30/**
31 Returns the current time and date information, and the time-keeping capabilities
32 of the virtual RTC.
33
34 @param Time A pointer to storage to receive a snapshot of the current time.
35 @param Capabilities An optional pointer to a buffer to receive the real time clock
36 device's capabilities.
37
38 @retval EFI_SUCCESS The operation completed successfully.
39 @retval EFI_INVALID_PARAMETER Time is NULL.
40 @retval EFI_DEVICE_ERROR The time could not be retrieved due to hardware error.
41
42**/
43EFI_STATUS
44EFIAPI
45LibGetTime (
46 OUT EFI_TIME *Time,
47 OUT EFI_TIME_CAPABILITIES *Capabilities
48 )
49{
50 EFI_STATUS Status;
51 INT16 TimeZone;
52 UINT8 Daylight;
53 UINT64 Freq;
54 UINT64 Counter;
55 UINT64 Remainder;
56 UINTN EpochSeconds;
57 UINTN Size;
58
59 if (Time == NULL) {
60 return EFI_INVALID_PARAMETER;
61 }
62
63 // Get the counter frequency
64 Freq = GetPerformanceCounterProperties (NULL, NULL);
65 if (Freq == 0) {
66 return EFI_DEVICE_ERROR;
67 }
68
69 // Get the epoch time from non-volatile storage
70 Size = sizeof (UINTN);
71 EpochSeconds = 0;
72 Status = EfiGetVariable (
73 (CHAR16 *)mEpochVariableName,
74 &gEfiCallerIdGuid,
75 NULL,
76 &Size,
77 (VOID *)&EpochSeconds
78 );
79 // Fall back to compilation-time epoch if not set
80 if (EFI_ERROR (Status)) {
81 ASSERT (Status != EFI_INVALID_PARAMETER);
82 ASSERT (Status != EFI_BUFFER_TOO_SMALL);
83 //
84 // The following is intended to produce a compilation error on build
85 // environments where BUILD_EPOCH can not be set from inline shell.
86 // If you are attempting to use this library on such an environment, please
87 // contact the edk2 mailing list, so we can try to add support for it.
88 //
89 EpochSeconds = BUILD_EPOCH;
90 DEBUG ((
91 DEBUG_INFO,
92 "LibGetTime: %s non volatile variable was not found - Using compilation time epoch.\n",
93 mEpochVariableName
94 ));
95
96 EfiSetVariable (
97 (CHAR16 *)mEpochVariableName,
98 &gEfiCallerIdGuid,
99 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
100 sizeof (EpochSeconds),
101 &EpochSeconds
102 );
103 }
104
105 Counter = GetPerformanceCounter ();
106 EpochSeconds += DivU64x64Remainder (Counter, Freq, &Remainder);
107
108 // Get the current time zone information from non-volatile storage
109 Size = sizeof (TimeZone);
110 Status = EfiGetVariable (
111 (CHAR16 *)mTimeZoneVariableName,
112 &gEfiCallerIdGuid,
113 NULL,
114 &Size,
115 (VOID *)&TimeZone
116 );
117
118 if (EFI_ERROR (Status)) {
119 ASSERT (Status != EFI_INVALID_PARAMETER);
120 ASSERT (Status != EFI_BUFFER_TOO_SMALL);
121
122 if (Status != EFI_NOT_FOUND) {
123 return Status;
124 }
125
126 // The time zone variable does not exist in non-volatile storage, so create it.
127 Time->TimeZone = EFI_UNSPECIFIED_TIMEZONE;
128 // Store it
129 Status = EfiSetVariable (
130 (CHAR16 *)mTimeZoneVariableName,
131 &gEfiCallerIdGuid,
132 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
133 Size,
134 (VOID *)&(Time->TimeZone)
135 );
136 if (EFI_ERROR (Status)) {
137 DEBUG ((
138 DEBUG_ERROR,
139 "LibGetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",
140 mTimeZoneVariableName,
141 Status
142 ));
143 return Status;
144 }
145 } else {
146 // Got the time zone
147 Time->TimeZone = TimeZone;
148
149 // Check TimeZone bounds: -1440 to 1440 or 2047
150 if ( ((Time->TimeZone < -1440) || (Time->TimeZone > 1440))
151 && (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE))
152 {
153 Time->TimeZone = EFI_UNSPECIFIED_TIMEZONE;
154 }
155
156 // Adjust for the correct time zone
157 if (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
158 EpochSeconds += Time->TimeZone * SEC_PER_MIN;
159 }
160 }
161
162 // Get the current daylight information from non-volatile storage
163 Size = sizeof (Daylight);
164 Status = EfiGetVariable (
165 (CHAR16 *)mDaylightVariableName,
166 &gEfiCallerIdGuid,
167 NULL,
168 &Size,
169 (VOID *)&Daylight
170 );
171
172 if (EFI_ERROR (Status)) {
173 ASSERT (Status != EFI_INVALID_PARAMETER);
174 ASSERT (Status != EFI_BUFFER_TOO_SMALL);
175
176 if (Status != EFI_NOT_FOUND) {
177 return Status;
178 }
179
180 // The daylight variable does not exist in non-volatile storage, so create it.
181 Time->Daylight = 0;
182 // Store it
183 Status = EfiSetVariable (
184 (CHAR16 *)mDaylightVariableName,
185 &gEfiCallerIdGuid,
186 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
187 Size,
188 (VOID *)&(Time->Daylight)
189 );
190 if (EFI_ERROR (Status)) {
191 DEBUG ((
192 DEBUG_ERROR,
193 "LibGetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",
194 mDaylightVariableName,
195 Status
196 ));
197 return Status;
198 }
199 } else {
200 // Got the daylight information
201 Time->Daylight = Daylight;
202
203 // Adjust for the correct period
204 if ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT) {
205 // Convert to adjusted time, i.e. spring forwards one hour
206 EpochSeconds += SEC_PER_HOUR;
207 }
208 }
209
210 EpochToEfiTime (EpochSeconds, Time);
211
212 // Because we use the performance counter, we can fill the Nanosecond attribute
213 // provided that the remainder doesn't overflow 64-bit during multiplication.
214 if (Remainder <= 18446744073U) {
215 Time->Nanosecond = (UINT32)(MultU64x64 (Remainder, 1000000000U) / Freq);
216 } else {
217 DEBUG ((DEBUG_WARN, "LibGetTime: Nanosecond value not set (64-bit overflow).\n"));
218 }
219
220 if (Capabilities) {
221 Capabilities->Accuracy = 0;
222 Capabilities->Resolution = 1;
223 Capabilities->SetsToZero = FALSE;
224 }
225
226 return EFI_SUCCESS;
227}
228
229/**
230 Sets the current local time and date information.
231
232 @param Time A pointer to the current time.
233
234 @retval EFI_SUCCESS The operation completed successfully.
235 @retval EFI_INVALID_PARAMETER A time field is out of range.
236 @retval EFI_DEVICE_ERROR The time could not be set due to hardware error.
237
238**/
239EFI_STATUS
240EFIAPI
241LibSetTime (
242 IN EFI_TIME *Time
243 )
244{
245 EFI_STATUS Status;
246 UINT64 Freq;
247 UINT64 Counter;
248 UINT64 Remainder;
249 UINTN EpochSeconds;
250
251 if (!IsTimeValid (Time)) {
252 return EFI_INVALID_PARAMETER;
253 }
254
255 EpochSeconds = EfiTimeToEpoch (Time);
256
257 // Adjust for the correct time zone, i.e. convert to UTC time zone
258 if ( (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE)
259 && (EpochSeconds > Time->TimeZone * SEC_PER_MIN))
260 {
261 EpochSeconds -= Time->TimeZone * SEC_PER_MIN;
262 }
263
264 // Adjust for the correct period
265 if ( ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT)
266 && (EpochSeconds > SEC_PER_HOUR))
267 {
268 // Convert to un-adjusted time, i.e. fall back one hour
269 EpochSeconds -= SEC_PER_HOUR;
270 }
271
272 // Use the performance counter to subtract the number of seconds
273 // since platform reset. Without this, setting time from the shell
274 // and immediately reading it back would result in a forward time
275 // offset, of the duration during which the platform has been up.
276 Freq = GetPerformanceCounterProperties (NULL, NULL);
277 if (Freq != 0) {
278 Counter = GetPerformanceCounter ();
279 if (EpochSeconds > DivU64x64Remainder (Counter, Freq, &Remainder)) {
280 EpochSeconds -= DivU64x64Remainder (Counter, Freq, &Remainder);
281 }
282 }
283
284 // Save the current time zone information into non-volatile storage
285 Status = EfiSetVariable (
286 (CHAR16 *)mTimeZoneVariableName,
287 &gEfiCallerIdGuid,
288 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
289 sizeof (Time->TimeZone),
290 (VOID *)&(Time->TimeZone)
291 );
292 if (EFI_ERROR (Status)) {
293 DEBUG ((
294 DEBUG_ERROR,
295 "LibSetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",
296 mTimeZoneVariableName,
297 Status
298 ));
299 return Status;
300 }
301
302 // Save the current daylight information into non-volatile storage
303 Status = EfiSetVariable (
304 (CHAR16 *)mDaylightVariableName,
305 &gEfiCallerIdGuid,
306 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
307 sizeof (Time->Daylight),
308 (VOID *)&(Time->Daylight)
309 );
310 if (EFI_ERROR (Status)) {
311 DEBUG ((
312 DEBUG_ERROR,
313 "LibSetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",
314 mDaylightVariableName,
315 Status
316 ));
317 return Status;
318 }
319
320 Status = EfiSetVariable (
321 (CHAR16 *)mEpochVariableName,
322 &gEfiCallerIdGuid,
323 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
324 sizeof (EpochSeconds),
325 &EpochSeconds
326 );
327 if (EFI_ERROR (Status)) {
328 DEBUG ((
329 DEBUG_ERROR,
330 "LibSetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",
331 mEpochVariableName,
332 Status
333 ));
334 return Status;
335 }
336
337 return EFI_SUCCESS;
338}
339
340/**
341 Returns the current wakeup alarm clock setting.
342
343 @param Enabled Indicates if the alarm is currently enabled or disabled.
344 @param Pending Indicates if the alarm signal is pending and requires acknowledgement.
345 @param Time The current alarm setting.
346
347 @retval EFI_SUCCESS The alarm settings were returned.
348 @retval EFI_INVALID_PARAMETER Any parameter is NULL.
349 @retval EFI_DEVICE_ERROR The wakeup time could not be retrieved due to a hardware error.
350
351**/
352EFI_STATUS
353EFIAPI
354LibGetWakeupTime (
355 OUT BOOLEAN *Enabled,
356 OUT BOOLEAN *Pending,
357 OUT EFI_TIME *Time
358 )
359{
360 return EFI_UNSUPPORTED;
361}
362
363/**
364 Sets the system wakeup alarm clock time.
365
366 @param Enabled Enable or disable the wakeup alarm.
367 @param Time If Enable is TRUE, the time to set the wakeup alarm for.
368
369 @retval EFI_SUCCESS If Enable is TRUE, then the wakeup alarm was enabled. If
370 Enable is FALSE, then the wakeup alarm was disabled.
371 @retval EFI_INVALID_PARAMETER A time field is out of range.
372 @retval EFI_DEVICE_ERROR The wakeup time could not be set due to a hardware error.
373 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
374
375**/
376EFI_STATUS
377EFIAPI
378LibSetWakeupTime (
379 IN BOOLEAN Enabled,
380 OUT EFI_TIME *Time
381 )
382{
383 return EFI_UNSUPPORTED;
384}
385
386/**
387 This is the declaration of an EFI image entry point. This can be the entry point to an application
388 written to this specification, an EFI boot service driver, or an EFI runtime driver.
389
390 @param ImageHandle Handle that identifies the loaded image.
391 @param SystemTable System Table for this image.
392
393 @retval EFI_SUCCESS The operation completed successfully.
394
395**/
396EFI_STATUS
397EFIAPI
398LibRtcInitialize (
399 IN EFI_HANDLE ImageHandle,
400 IN EFI_SYSTEM_TABLE *SystemTable
401 )
402{
403 return EFI_SUCCESS;
404}
405
406/**
407 Fixup internal data so that EFI can be call in virtual mode.
408 Call the passed in Child Notify event and convert any pointers in
409 lib to virtual mode.
410
411 @param[in] Event The Event that is being processed
412 @param[in] Context Event Context
413**/
414VOID
415EFIAPI
416LibRtcVirtualNotifyEvent (
417 IN EFI_EVENT Event,
418 IN VOID *Context
419 )
420{
421 return;
422}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette