2 RTC Architectural Protocol GUID as defined in DxeCis 0.96.
4 Copyright (c) 2006 - 2007, Intel Corporation
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
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.
18 Compare the Hour, Minute and Second of the From time and the To time.
20 Only compare H/M/S in EFI_TIME and ignore other fields here.
22 @param From the first time
23 @param To the second time
25 @return >0 The H/M/S of the From time is later than those of To time
26 @return ==0 The H/M/S of the From time is same as those of To time
27 @return <0 The H/M/S of the From time is earlier than those of To time
36 To check if second date is later than first date within 24 hours.
38 @param From the first date
39 @param To the second date
41 @retval TRUE From is previous to To within 24 hours.
42 @retval FALSE From is later, or it is previous to To more than 24 hours.
51 Read RTC content through its registers.
53 @param Address Address offset of RTC. It is recommended to use macros such as
56 @return The data of UINT8 type read from RTC.
63 IoWrite8 (PCAT_RTC_ADDRESS_REGISTER
, (UINT8
) (Address
| (UINT8
) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER
) & 0x80)));
64 return IoRead8 (PCAT_RTC_DATA_REGISTER
);
68 Write RTC through its registers.
70 @param Address Address offset of RTC. It is recommended to use macros such as
72 @param Data The content you want to write into RTC.
81 IoWrite8 (PCAT_RTC_ADDRESS_REGISTER
, (UINT8
) (Address
| (UINT8
) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER
) & 0x80)));
82 IoWrite8 (PCAT_RTC_DATA_REGISTER
, Data
);
88 @param Global For global use inside this module.
90 @retval EFI_DEVICE_ERROR Initialization failed due to device error.
91 @retval EFI_SUCCESS Initialization successful.
96 IN PC_RTC_MODULE_GLOBALS
*Global
100 RTC_REGISTER_A RegisterA
;
101 RTC_REGISTER_B RegisterB
;
102 RTC_REGISTER_D RegisterD
;
109 // Acquire RTC Lock to make access to RTC atomic
111 //Code here doesn't consider the runtime environment.
112 if (!EfiAtRuntime ()) {
113 EfiAcquireLock (&Global
->RtcLock
);
116 // Initialize RTC Register
118 // Make sure Division Chain is properly configured,
119 // or RTC clock won't "tick" -- time won't increment
121 RegisterA
.Data
= RTC_INIT_REGISTER_A
;
122 RtcWrite (RTC_ADDRESS_REGISTER_A
, RegisterA
.Data
);
127 RegisterB
.Data
= RtcRead (RTC_ADDRESS_REGISTER_B
);
130 // Clear RTC flag register
132 RtcRead (RTC_ADDRESS_REGISTER_C
);
135 // Clear RTC register D
137 RegisterD
.Data
= RTC_INIT_REGISTER_D
;
138 RtcWrite (RTC_ADDRESS_REGISTER_D
, RegisterD
.Data
);
141 // Wait for up to 0.1 seconds for the RTC to be updated
143 Status
= RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout
));
144 if (EFI_ERROR (Status
)) {
145 //Code here doesn't consider the runtime environment.
146 if (!EfiAtRuntime ()) {
147 EfiReleaseLock (&Global
->RtcLock
);
149 return EFI_DEVICE_ERROR
;
152 // Get the Time/Date/Daylight Savings values.
154 Time
.Second
= RtcRead (RTC_ADDRESS_SECONDS
);
155 Time
.Minute
= RtcRead (RTC_ADDRESS_MINUTES
);
156 Time
.Hour
= RtcRead (RTC_ADDRESS_HOURS
);
157 Time
.Day
= RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH
);
158 Time
.Month
= RtcRead (RTC_ADDRESS_MONTH
);
159 Time
.Year
= RtcRead (RTC_ADDRESS_YEAR
);
161 Century
= RtcRead (RTC_ADDRESS_CENTURY
);
164 // Set RTC configuration after get original time
165 // The value of bit AIE should be reserved.
167 RtcWrite (RTC_ADDRESS_REGISTER_B
, (UINT8
)(RTC_INIT_REGISTER_B
| (RegisterB
.Data
& BIT5
)));
172 //Code here doesn't consider the runtime environment.
173 if (!EfiAtRuntime ()) {
174 EfiReleaseLock (&Global
->RtcLock
);
178 // Validate time fields
180 Status
= ConvertRtcTimeToEfiTime (&Time
, Century
, RegisterB
);
181 if (!EFI_ERROR (Status
)) {
182 Status
= RtcTimeFieldsValid (&Time
);
184 if (EFI_ERROR (Status
)) {
185 Time
.Second
= RTC_INIT_SECOND
;
186 Time
.Minute
= RTC_INIT_MINUTE
;
187 Time
.Hour
= RTC_INIT_HOUR
;
188 Time
.Day
= RTC_INIT_DAY
;
189 Time
.Month
= RTC_INIT_MONTH
;
190 Time
.Year
= RTC_INIT_YEAR
;
193 // Get the data of Daylight saving and time zone, if they have been
194 // stored in NV variable during previous boot.
196 DataSize
= sizeof (UINT32
);
197 Status
= EfiGetVariable (
204 if (!EFI_ERROR (Status
)) {
205 Global
->SavedTimeZone
= (INT16
) TimerVar
;
206 Global
->Daylight
= (UINT8
) (TimerVar
>> 16);
208 Time
.TimeZone
= Global
->SavedTimeZone
;
209 Time
.Daylight
= Global
->Daylight
;
212 // Reset time value according to new RTC configuration
214 PcRtcSetTime (&Time
, Global
);
220 Returns the current time and date information, and the time-keeping capabilities
221 of the hardware platform.
223 @param Time A pointer to storage to receive a snapshot of the current time.
224 @param Capabilities An optional pointer to a buffer to receive the real time clock
225 device's capabilities.
226 @param Global For global use inside this module.
228 @retval EFI_SUCCESS The operation completed successfully.
229 @retval EFI_INVALID_PARAMETER Time is NULL.
230 @retval EFI_DEVICE_ERROR The time could not be retrieved due to hardware error.
236 OUT EFI_TIME_CAPABILITIES
*Capabilities
, OPTIONAL
237 IN PC_RTC_MODULE_GLOBALS
*Global
241 RTC_REGISTER_B RegisterB
;
245 // Check parameters for null pointer
248 return EFI_INVALID_PARAMETER
;
252 // Acquire RTC Lock to make access to RTC atomic
254 //Code here doesn't consider the runtime environment.
255 if (!EfiAtRuntime ()) {
256 EfiAcquireLock (&Global
->RtcLock
);
259 // Wait for up to 0.1 seconds for the RTC to be updated
261 Status
= RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout
));
262 if (EFI_ERROR (Status
)) {
263 //Code here doesn't consider the runtime environment.
264 if (!EfiAtRuntime ()) {
265 EfiReleaseLock (&Global
->RtcLock
);
272 RegisterB
.Data
= RtcRead (RTC_ADDRESS_REGISTER_B
);
275 // Get the Time/Date/Daylight Savings values.
277 Time
->Second
= RtcRead (RTC_ADDRESS_SECONDS
);
278 Time
->Minute
= RtcRead (RTC_ADDRESS_MINUTES
);
279 Time
->Hour
= RtcRead (RTC_ADDRESS_HOURS
);
280 Time
->Day
= RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH
);
281 Time
->Month
= RtcRead (RTC_ADDRESS_MONTH
);
282 Time
->Year
= RtcRead (RTC_ADDRESS_YEAR
);
284 Century
= RtcRead (RTC_ADDRESS_CENTURY
);
289 //Code here doesn't consider the runtime environment.
290 if (!EfiAtRuntime ()) {
291 EfiReleaseLock (&Global
->RtcLock
);
294 // Get the variable that contains the TimeZone and Daylight fields
296 Time
->TimeZone
= Global
->SavedTimeZone
;
297 Time
->Daylight
= Global
->Daylight
;
300 // Make sure all field values are in correct range
302 Status
= ConvertRtcTimeToEfiTime (Time
, Century
, RegisterB
);
303 if (!EFI_ERROR (Status
)) {
304 Status
= RtcTimeFieldsValid (Time
);
306 if (EFI_ERROR (Status
)) {
307 return EFI_DEVICE_ERROR
;
310 // Fill in Capabilities if it was passed in
312 if (Capabilities
!= NULL
) {
313 Capabilities
->Resolution
= 1;
317 Capabilities
->Accuracy
= 50000000;
321 Capabilities
->SetsToZero
= FALSE
;
328 Sets the current local time and date information.
330 @param Time A pointer to the current time.
331 @param Global For global use inside this module.
333 @retval EFI_SUCCESS The operation completed successfully.
334 @retval EFI_INVALID_PARAMETER A time field is out of range.
335 @retval EFI_DEVICE_ERROR The time could not be set due due to hardware error.
341 IN PC_RTC_MODULE_GLOBALS
*Global
346 RTC_REGISTER_B RegisterB
;
351 return EFI_INVALID_PARAMETER
;
354 // Make sure that the time fields are valid
356 Status
= RtcTimeFieldsValid (Time
);
357 if (EFI_ERROR (Status
)) {
361 CopyMem (&RtcTime
, Time
, sizeof (EFI_TIME
));
364 // Acquire RTC Lock to make access to RTC atomic
366 //Code here doesn't consider the runtime environment.
367 if (!EfiAtRuntime ()) {
368 EfiAcquireLock (&Global
->RtcLock
);
371 // Wait for up to 0.1 seconds for the RTC to be updated
373 Status
= RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout
));
374 if (EFI_ERROR (Status
)) {
375 //Code here doesn't consider the runtime environment.
376 if (!EfiAtRuntime ()) {
377 EfiReleaseLock (&Global
->RtcLock
);
382 // Read Register B, and inhibit updates of the RTC
384 RegisterB
.Data
= RtcRead (RTC_ADDRESS_REGISTER_B
);
385 RegisterB
.Bits
.SET
= 1;
386 RtcWrite (RTC_ADDRESS_REGISTER_B
, RegisterB
.Data
);
388 ConvertEfiTimeToRtcTime (&RtcTime
, RegisterB
, &Century
);
390 RtcWrite (RTC_ADDRESS_SECONDS
, RtcTime
.Second
);
391 RtcWrite (RTC_ADDRESS_MINUTES
, RtcTime
.Minute
);
392 RtcWrite (RTC_ADDRESS_HOURS
, RtcTime
.Hour
);
393 RtcWrite (RTC_ADDRESS_DAY_OF_THE_MONTH
, RtcTime
.Day
);
394 RtcWrite (RTC_ADDRESS_MONTH
, RtcTime
.Month
);
395 RtcWrite (RTC_ADDRESS_YEAR
, (UINT8
) RtcTime
.Year
);
396 RtcWrite (RTC_ADDRESS_CENTURY
, Century
);
399 // Allow updates of the RTC registers
401 RegisterB
.Bits
.SET
= 0;
402 RtcWrite (RTC_ADDRESS_REGISTER_B
, RegisterB
.Data
);
407 //Code here doesn't consider the runtime environment.
408 if (!EfiAtRuntime ()) {
409 EfiReleaseLock (&Global
->RtcLock
);
412 // Set the variable that contains the TimeZone and Daylight fields
414 Global
->SavedTimeZone
= Time
->TimeZone
;
415 Global
->Daylight
= Time
->Daylight
;
417 TimerVar
= Time
->Daylight
;
418 TimerVar
= (UINT32
) ((TimerVar
<< 16) | Time
->TimeZone
);
419 Status
= EfiSetVariable (
422 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
426 ASSERT_EFI_ERROR (Status
);
432 Returns the current wakeup alarm clock setting.
434 @param Enabled Indicates if the alarm is currently enabled or disabled.
435 @param Pending Indicates if the alarm signal is pending and requires acknowledgment.
436 @param Time The current alarm setting.
437 @param Global For global use inside this module.
439 @retval EFI_SUCCESS The alarm settings were returned.
440 @retval EFI_INVALID_PARAMETER Enabled is NULL.
441 @retval EFI_INVALID_PARAMETER Pending is NULL.
442 @retval EFI_INVALID_PARAMETER Time is NULL.
443 @retval EFI_DEVICE_ERROR The wakeup time could not be retrieved due to a hardware error.
444 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
449 OUT BOOLEAN
*Enabled
,
450 OUT BOOLEAN
*Pending
,
452 IN PC_RTC_MODULE_GLOBALS
*Global
456 RTC_REGISTER_B RegisterB
;
457 RTC_REGISTER_C RegisterC
;
461 // Check parameters for null pointers
463 if ((Enabled
== NULL
) || (Pending
== NULL
) || (Time
== NULL
)) {
464 return EFI_INVALID_PARAMETER
;
468 // Acquire RTC Lock to make access to RTC atomic
470 //Code here doesn't consider the runtime environment.
471 if (!EfiAtRuntime ()) {
472 EfiAcquireLock (&Global
->RtcLock
);
475 // Wait for up to 0.1 seconds for the RTC to be updated
477 Status
= RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout
));
478 if (EFI_ERROR (Status
)) {
479 //Code here doesn't consider the runtime environment.
480 if (!EfiAtRuntime ()) {
481 EfiReleaseLock (&Global
->RtcLock
);
483 return EFI_DEVICE_ERROR
;
486 // Read Register B and Register C
488 RegisterB
.Data
= RtcRead (RTC_ADDRESS_REGISTER_B
);
489 RegisterC
.Data
= RtcRead (RTC_ADDRESS_REGISTER_C
);
492 // Get the Time/Date/Daylight Savings values.
494 *Enabled
= RegisterB
.Bits
.AIE
;
496 Time
->Second
= RtcRead (RTC_ADDRESS_SECONDS_ALARM
);
497 Time
->Minute
= RtcRead (RTC_ADDRESS_MINUTES_ALARM
);
498 Time
->Hour
= RtcRead (RTC_ADDRESS_HOURS_ALARM
);
499 Time
->Day
= RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH
);
500 Time
->Month
= RtcRead (RTC_ADDRESS_MONTH
);
501 Time
->Year
= RtcRead (RTC_ADDRESS_YEAR
);
506 Time
->Day
= RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH
);
507 Time
->Month
= RtcRead (RTC_ADDRESS_MONTH
);
508 Time
->Year
= RtcRead (RTC_ADDRESS_YEAR
);
511 Century
= RtcRead (RTC_ADDRESS_CENTURY
);
516 //Code here doesn't consider the runtime environment.
517 if (!EfiAtRuntime ()) {
518 EfiReleaseLock (&Global
->RtcLock
);
521 // Make sure all field values are in correct range
523 Status
= ConvertRtcTimeToEfiTime (Time
, Century
, RegisterB
);
524 if (!EFI_ERROR (Status
)) {
525 Status
= RtcTimeFieldsValid (Time
);
527 if (EFI_ERROR (Status
)) {
528 return EFI_DEVICE_ERROR
;
531 *Pending
= RegisterC
.Bits
.AF
;
537 Sets the system wakeup alarm clock time.
539 @param Enabled Enable or disable the wakeup alarm.
540 @param Time If Enable is TRUE, the time to set the wakeup alarm for.
541 If Enable is FALSE, then this parameter is optional, and may be NULL.
542 @param Global For global use inside this module.
544 @retval EFI_SUCCESS If Enable is TRUE, then the wakeup alarm was enabled.
545 If Enable is FALSE, then the wakeup alarm was disabled.
546 @retval EFI_INVALID_PARAMETER A time field is out of range.
547 @retval EFI_DEVICE_ERROR The wakeup time could not be set due to a hardware error.
548 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
554 IN EFI_TIME
*Time
, OPTIONAL
555 IN PC_RTC_MODULE_GLOBALS
*Global
560 RTC_REGISTER_B RegisterB
;
562 EFI_TIME_CAPABILITIES Capabilities
;
567 return EFI_INVALID_PARAMETER
;
570 // Make sure that the time fields are valid
572 Status
= RtcTimeFieldsValid (Time
);
573 if (EFI_ERROR (Status
)) {
574 return EFI_INVALID_PARAMETER
;
577 // Just support set alarm time within 24 hours
579 PcRtcGetTime (&RtcTime
, &Capabilities
, Global
);
580 Status
= RtcTimeFieldsValid (&RtcTime
);
581 if (EFI_ERROR (Status
)) {
582 return EFI_DEVICE_ERROR
;
584 if (!IsWithinOneDay (&RtcTime
, Time
)) {
585 return EFI_UNSUPPORTED
;
588 // Make a local copy of the time and date
590 CopyMem (&RtcTime
, Time
, sizeof (EFI_TIME
));
594 // Acquire RTC Lock to make access to RTC atomic
596 //Code here doesn't consider the runtime environment.
597 if (!EfiAtRuntime ()) {
598 EfiAcquireLock (&Global
->RtcLock
);
601 // Wait for up to 0.1 seconds for the RTC to be updated
603 Status
= RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout
));
604 if (EFI_ERROR (Status
)) {
605 //Code here doesn't consider the runtime environment.
606 if (!EfiAtRuntime ()) {
607 EfiReleaseLock (&Global
->RtcLock
);
609 return EFI_DEVICE_ERROR
;
612 // Read Register B, and inhibit updates of the RTC
614 RegisterB
.Data
= RtcRead (RTC_ADDRESS_REGISTER_B
);
616 RegisterB
.Bits
.SET
= 1;
617 RtcWrite (RTC_ADDRESS_REGISTER_B
, RegisterB
.Data
);
620 ConvertEfiTimeToRtcTime (&RtcTime
, RegisterB
, &Century
);
623 // Set RTC alarm time
625 RtcWrite (RTC_ADDRESS_SECONDS_ALARM
, RtcTime
.Second
);
626 RtcWrite (RTC_ADDRESS_MINUTES_ALARM
, RtcTime
.Minute
);
627 RtcWrite (RTC_ADDRESS_HOURS_ALARM
, RtcTime
.Hour
);
629 RegisterB
.Bits
.AIE
= 1;
632 RegisterB
.Bits
.AIE
= 0;
635 // Allow updates of the RTC registers
637 RegisterB
.Bits
.SET
= 0;
638 RtcWrite (RTC_ADDRESS_REGISTER_B
, RegisterB
.Data
);
643 //Code here doesn't consider the runtime environment.
644 if (!EfiAtRuntime ()) {
645 EfiReleaseLock (&Global
->RtcLock
);
652 Checks an 8-bit BCD value, and converts to an 8-bit value if valid.
654 This function checks the 8-bit BCD value specified by Value.
655 If valid, the function converts it to an 8-bit value and returns it.
656 Otherwise, return 0xff.
658 @param Value The 8-bit BCD value to check and convert
660 @return The 8-bit value converted. Or 0xff if Value is invalid.
664 CheckAndConvertBcd8ToDecimal8 (
668 if ((Value
< 0xa0) && ((Value
& 0xf) < 0xa)) {
669 return BcdToDecimal8 (Value
);
676 Converts time read from RTC to EFI_TIME format defined by UEFI spec.
678 This function converts raw time data read from RTC to the EFI_TIME format
679 defined by UEFI spec.
680 If data mode of RTC is BCD, then converts it to decimal,
681 If RTC is in 12-hour format, then converts it to 24-hour format.
683 @param Time On input, the time data read from RTC to convert
684 On output, the time converted to UEFI format
685 @param Century Value of century read from RTC.
686 @param RegisterB Value of Register B of RTC, indicating data mode
689 @retval EFI_INVALID_PARAMETER Parameters passed in are invalid.
690 @retval EFI_SUCCESS Convert RTC time to EFI time successfully.
694 ConvertRtcTimeToEfiTime (
695 IN OUT EFI_TIME
*Time
,
697 IN RTC_REGISTER_B RegisterB
702 if ((Time
->Hour
& 0x80) != 0) {
708 Time
->Hour
= (UINT8
) (Time
->Hour
& 0x7f);
710 if (RegisterB
.Bits
.DM
== 0) {
711 Time
->Year
= CheckAndConvertBcd8ToDecimal8 ((UINT8
) Time
->Year
);
712 Time
->Month
= CheckAndConvertBcd8ToDecimal8 (Time
->Month
);
713 Time
->Day
= CheckAndConvertBcd8ToDecimal8 (Time
->Day
);
714 Time
->Hour
= CheckAndConvertBcd8ToDecimal8 (Time
->Hour
);
715 Time
->Minute
= CheckAndConvertBcd8ToDecimal8 (Time
->Minute
);
716 Time
->Second
= CheckAndConvertBcd8ToDecimal8 (Time
->Second
);
718 Century
= CheckAndConvertBcd8ToDecimal8 (Century
);
720 if (Time
->Year
== 0xff || Time
->Month
== 0xff || Time
->Day
== 0xff ||
721 Time
->Hour
== 0xff || Time
->Minute
== 0xff || Time
->Second
== 0xff ||
723 return EFI_INVALID_PARAMETER
;
726 Time
->Year
= (UINT16
) (Century
* 100 + Time
->Year
);
729 // If time is in 12 hour format, convert it to 24 hour format
731 if (RegisterB
.Bits
.MIL
== 0) {
732 if (IsPM
&& Time
->Hour
< 12) {
733 Time
->Hour
= (UINT8
) (Time
->Hour
+ 12);
736 if (!IsPM
&& Time
->Hour
== 12) {
741 Time
->Nanosecond
= 0;
742 Time
->TimeZone
= EFI_UNSPECIFIED_TIMEZONE
;
749 Wait for a period for the RTC to be ready.
751 @param Timeout Tell how long it should take to wait.
753 @retval EFI_DEVICE_ERROR RTC device error.
754 @retval EFI_SUCCESS RTC is updated and ready.
761 RTC_REGISTER_A RegisterA
;
762 RTC_REGISTER_D RegisterD
;
765 // See if the RTC is functioning correctly
767 RegisterD
.Data
= RtcRead (RTC_ADDRESS_REGISTER_D
);
769 if (RegisterD
.Bits
.VRT
== 0) {
770 return EFI_DEVICE_ERROR
;
773 // Wait for up to 0.1 seconds for the RTC to be ready.
775 Timeout
= (Timeout
/ 10) + 1;
776 RegisterA
.Data
= RtcRead (RTC_ADDRESS_REGISTER_A
);
777 while (RegisterA
.Bits
.UIP
== 1 && Timeout
> 0) {
778 MicroSecondDelay (10);
779 RegisterA
.Data
= RtcRead (RTC_ADDRESS_REGISTER_A
);
783 RegisterD
.Data
= RtcRead (RTC_ADDRESS_REGISTER_D
);
784 if (Timeout
== 0 || RegisterD
.Bits
.VRT
== 0) {
785 return EFI_DEVICE_ERROR
;
792 See if all fields of a variable of EFI_TIME type is correct.
794 @param Time The time to be checked.
796 @retval EFI_INVALID_PARAMETER Some fields of Time are not correct.
797 @retval EFI_SUCCESS Time is a valid EFI_TIME variable.
805 if (Time
->Year
< 1998 ||
812 Time
->Nanosecond
> 999999999 ||
813 (!(Time
->TimeZone
== EFI_UNSPECIFIED_TIMEZONE
|| (Time
->TimeZone
>= -1440 && Time
->TimeZone
<= 1440))) ||
814 ((Time
->Daylight
& (~(EFI_TIME_ADJUST_DAYLIGHT
| EFI_TIME_IN_DAYLIGHT
))) != 0)
816 if (!DayValid (Time
)) {
817 return EFI_INVALID_PARAMETER
;
825 See if field Day of an EFI_TIME is correct.
827 @param Time Its Day field is to be checked.
829 @retval TRUE Day field of Time is correct.
830 @retval FALSE Day field of Time is NOT correct.
853 // The validity of Time->Month field should be checked before
855 ASSERT (Time
->Month
>=1);
856 ASSERT (Time
->Month
<=12);
858 Time
->Day
> DayOfMonth
[Time
->Month
- 1] ||
859 (Time
->Month
== 2 && (!IsLeapYear (Time
) && Time
->Day
> 28))
868 Check if it is a leap year.
870 @param Time The time to be checked.
872 @retval TRUE It is a leap year.
873 @retval FALSE It is NOT a leap year.
880 if (Time
->Year
% 4 == 0) {
881 if (Time
->Year
% 100 == 0) {
882 if (Time
->Year
% 400 == 0) {
896 Converts time from EFI_TIME format defined by UEFI spec to RTC's.
898 This function converts time from EFI_TIME format defined by UEFI spec to RTC's.
899 If data mode of RTC is BCD, then converts EFI_TIME to it.
900 If RTC is in 12-hour format, then converts EFI_TIME to it.
902 @param Time On input, the time data read from UEFI to convert
903 On output, the time converted to RTC format
904 @param RegisterB Value of Register B of RTC, indicating data mode
905 @param Century It is set according to EFI_TIME Time.
909 ConvertEfiTimeToRtcTime (
910 IN OUT EFI_TIME
*Time
,
911 IN RTC_REGISTER_B RegisterB
,
919 // Adjust hour field if RTC is in 12 hour mode
921 if (RegisterB
.Bits
.MIL
== 0) {
922 if (Time
->Hour
< 12) {
926 if (Time
->Hour
>= 13) {
927 Time
->Hour
= (UINT8
) (Time
->Hour
- 12);
928 } else if (Time
->Hour
== 0) {
933 // Set the Time/Date/Daylight Savings values.
935 *Century
= DecimalToBcd8 ((UINT8
) (Time
->Year
/ 100));
937 Time
->Year
= (UINT16
) (Time
->Year
% 100);
939 if (RegisterB
.Bits
.DM
== 0) {
940 Time
->Year
= DecimalToBcd8 ((UINT8
) Time
->Year
);
941 Time
->Month
= DecimalToBcd8 (Time
->Month
);
942 Time
->Day
= DecimalToBcd8 (Time
->Day
);
943 Time
->Hour
= DecimalToBcd8 (Time
->Hour
);
944 Time
->Minute
= DecimalToBcd8 (Time
->Minute
);
945 Time
->Second
= DecimalToBcd8 (Time
->Second
);
948 // If we are in 12 hour mode and PM is set, then set bit 7 of the Hour field.
950 if (RegisterB
.Bits
.MIL
== 0 && IsPM
) {
951 Time
->Hour
= (UINT8
) (Time
->Hour
| 0x80);
956 Compare the Hour, Minute and Second of the From time and the To time.
958 Only compare H/M/S in EFI_TIME and ignore other fields here.
960 @param From the first time
961 @param To the second time
963 @return >0 The H/M/S of the From time is later than those of To time
964 @return ==0 The H/M/S of the From time is same as those of To time
965 @return <0 The H/M/S of the From time is earlier than those of To time
973 if ((From
->Hour
> To
->Hour
) ||
974 ((From
->Hour
== To
->Hour
) && (From
->Minute
> To
->Minute
)) ||
975 ((From
->Hour
== To
->Hour
) && (From
->Minute
== To
->Minute
) && (From
->Second
> To
->Second
))) {
977 } else if ((From
->Hour
== To
->Hour
) && (From
->Minute
== To
->Minute
) && (From
->Second
== To
->Second
)) {
985 To check if second date is later than first date within 24 hours.
987 @param From the first date
988 @param To the second date
990 @retval TRUE From is previous to To within 24 hours.
991 @retval FALSE From is later, or it is previous to To more than 24 hours.
999 UINT8 DayOfMonth
[12];
1012 DayOfMonth
[10] = 30;
1013 DayOfMonth
[11] = 31;
1018 // The validity of From->Month field should be checked before
1020 ASSERT (From
->Month
>=1);
1021 ASSERT (From
->Month
<=12);
1023 if (From
->Year
== To
->Year
) {
1024 if (From
->Month
== To
->Month
) {
1025 if ((From
->Day
+ 1) == To
->Day
) {
1026 if ((CompareHMS(From
, To
) >= 0)) {
1029 } else if (From
->Day
== To
->Day
) {
1030 if ((CompareHMS(From
, To
) <= 0)) {
1034 } else if (((From
->Month
+ 1) == To
->Month
) && (To
->Day
== 1)) {
1035 if ((From
->Month
== 2) && !IsLeapYear(From
)) {
1036 if (From
->Day
== 28) {
1037 if ((CompareHMS(From
, To
) >= 0)) {
1041 } else if (From
->Day
== DayOfMonth
[From
->Month
- 1]) {
1042 if ((CompareHMS(From
, To
) >= 0)) {
1047 } else if (((From
->Year
+ 1) == To
->Year
) &&
1048 (From
->Month
== 12) &&
1049 (From
->Day
== 31) &&
1052 if ((CompareHMS(From
, To
) >= 0)) {