RefRefine soma code to make code run safely.
[mirror_edk2.git] / PcAtChipsetPkg / PcatRealTimeClockRuntimeDxe / PcRtc.c
1 /** @file
2 RTC Architectural Protocol GUID as defined in DxeCis 0.96.
3
4 Copyright (c) 2006 - 2007, 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 #include "PcRtc.h"
16
17 /**
18 Compare the Hour, Minute and Second of the From time and the To time.
19
20 Only compare H/M/S in EFI_TIME and ignore other fields here.
21
22 @param From the first time
23 @param To the second time
24
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
28 **/
29 INTN
30 CompareHMS (
31 IN EFI_TIME *From,
32 IN EFI_TIME *To
33 );
34
35 /**
36 To check if second date is later than first date within 24 hours.
37
38 @param From the first date
39 @param To the second date
40
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.
43 **/
44 BOOLEAN
45 IsWithinOneDay (
46 IN EFI_TIME *From,
47 IN EFI_TIME *To
48 );
49
50 /**
51 Read RTC content through its registers.
52
53 @param Address Address offset of RTC. It is recommended to use macros such as
54 RTC_ADDRESS_SECONDS.
55
56 @return The data of UINT8 type read from RTC.
57 **/
58 UINT8
59 RtcRead (
60 IN UINT8 Address
61 )
62 {
63 IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));
64 return IoRead8 (PCAT_RTC_DATA_REGISTER);
65 }
66
67 /**
68 Write RTC through its registers.
69
70 @param Address Address offset of RTC. It is recommended to use macros such as
71 RTC_ADDRESS_SECONDS.
72 @param Data The content you want to write into RTC.
73
74 **/
75 VOID
76 RtcWrite (
77 IN UINT8 Address,
78 IN UINT8 Data
79 )
80 {
81 IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));
82 IoWrite8 (PCAT_RTC_DATA_REGISTER, Data);
83 }
84
85 /**
86 Initialize RTC.
87
88 @param Global For global use inside this module.
89
90 @retval EFI_DEVICE_ERROR Initialization failed due to device error.
91 @retval EFI_SUCCESS Initialization successful.
92
93 **/
94 EFI_STATUS
95 PcRtcInit (
96 IN PC_RTC_MODULE_GLOBALS *Global
97 )
98 {
99 EFI_STATUS Status;
100 RTC_REGISTER_A RegisterA;
101 RTC_REGISTER_B RegisterB;
102 RTC_REGISTER_D RegisterD;
103 UINT8 Century;
104 EFI_TIME Time;
105 UINTN DataSize;
106 UINT32 TimerVar;
107
108 //
109 // Acquire RTC Lock to make access to RTC atomic
110 //
111 if (!EfiAtRuntime ()) {
112 EfiAcquireLock (&Global->RtcLock);
113 }
114 //
115 // Initialize RTC Register
116 //
117 // Make sure Division Chain is properly configured,
118 // or RTC clock won't "tick" -- time won't increment
119 //
120 RegisterA.Data = RTC_INIT_REGISTER_A;
121 RtcWrite (RTC_ADDRESS_REGISTER_A, RegisterA.Data);
122
123 //
124 // Read Register B
125 //
126 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
127
128 //
129 // Clear RTC flag register
130 //
131 RtcRead (RTC_ADDRESS_REGISTER_C);
132
133 //
134 // Clear RTC register D
135 //
136 RegisterD.Data = RTC_INIT_REGISTER_D;
137 RtcWrite (RTC_ADDRESS_REGISTER_D, RegisterD.Data);
138
139 //
140 // Wait for up to 0.1 seconds for the RTC to be updated
141 //
142 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
143 if (EFI_ERROR (Status)) {
144 if (!EfiAtRuntime ()) {
145 EfiReleaseLock (&Global->RtcLock);
146 }
147 return EFI_DEVICE_ERROR;
148 }
149 //
150 // Get the Time/Date/Daylight Savings values.
151 //
152 Time.Second = RtcRead (RTC_ADDRESS_SECONDS);
153 Time.Minute = RtcRead (RTC_ADDRESS_MINUTES);
154 Time.Hour = RtcRead (RTC_ADDRESS_HOURS);
155 Time.Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
156 Time.Month = RtcRead (RTC_ADDRESS_MONTH);
157 Time.Year = RtcRead (RTC_ADDRESS_YEAR);
158
159 Century = RtcRead (RTC_ADDRESS_CENTURY);
160
161 //
162 // Set RTC configuration after get original time
163 // The value of bit AIE should be reserved.
164 //
165 RtcWrite (RTC_ADDRESS_REGISTER_B, (UINT8)(RTC_INIT_REGISTER_B | (RegisterB.Data & BIT5)));
166
167 //
168 // Release RTC Lock.
169 //
170 if (!EfiAtRuntime ()) {
171 EfiReleaseLock (&Global->RtcLock);
172 }
173
174 //
175 // Get the data of Daylight saving and time zone, if they have been
176 // stored in NV variable during previous boot.
177 //
178 DataSize = sizeof (UINT32);
179 Status = EfiGetVariable (
180 L"RTC",
181 &gEfiCallerIdGuid,
182 NULL,
183 &DataSize,
184 (VOID *) &TimerVar
185 );
186 if (!EFI_ERROR (Status)) {
187 Time.TimeZone = (INT16) TimerVar;
188 Time.Daylight = (UINT8) (TimerVar >> 16);
189 } else {
190 Time.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
191 Time.Daylight = 0;
192 }
193
194 //
195 // Validate time fields
196 //
197 Status = ConvertRtcTimeToEfiTime (&Time, Century, RegisterB);
198 if (!EFI_ERROR (Status)) {
199 Status = RtcTimeFieldsValid (&Time);
200 }
201 if (EFI_ERROR (Status)) {
202 Time.Second = RTC_INIT_SECOND;
203 Time.Minute = RTC_INIT_MINUTE;
204 Time.Hour = RTC_INIT_HOUR;
205 Time.Day = RTC_INIT_DAY;
206 Time.Month = RTC_INIT_MONTH;
207 Time.Year = RTC_INIT_YEAR;
208 Time.Nanosecond = 0;
209 }
210
211 //
212 // Reset time value according to new RTC configuration
213 //
214 Status = PcRtcSetTime (&Time, Global);
215 if(!EFI_ERROR (Status)) {
216 return EFI_SUCCESS;
217 } else {
218 return EFI_DEVICE_ERROR;
219 }
220 }
221
222 /**
223 Returns the current time and date information, and the time-keeping capabilities
224 of the hardware platform.
225
226 @param Time A pointer to storage to receive a snapshot of the current time.
227 @param Capabilities An optional pointer to a buffer to receive the real time clock
228 device's capabilities.
229 @param Global For global use inside this module.
230
231 @retval EFI_SUCCESS The operation completed successfully.
232 @retval EFI_INVALID_PARAMETER Time is NULL.
233 @retval EFI_DEVICE_ERROR The time could not be retrieved due to hardware error.
234
235 **/
236 EFI_STATUS
237 PcRtcGetTime (
238 OUT EFI_TIME *Time,
239 OUT EFI_TIME_CAPABILITIES *Capabilities, OPTIONAL
240 IN PC_RTC_MODULE_GLOBALS *Global
241 )
242 {
243 EFI_STATUS Status;
244 RTC_REGISTER_B RegisterB;
245 UINT8 Century;
246
247 //
248 // Check parameters for null pointer
249 //
250 if (Time == NULL) {
251 return EFI_INVALID_PARAMETER;
252
253 }
254 //
255 // Acquire RTC Lock to make access to RTC atomic
256 //
257 if (!EfiAtRuntime ()) {
258 EfiAcquireLock (&Global->RtcLock);
259 }
260 //
261 // Wait for up to 0.1 seconds for the RTC to be updated
262 //
263 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
264 if (EFI_ERROR (Status)) {
265 if (!EfiAtRuntime ()) {
266 EfiReleaseLock (&Global->RtcLock);
267 }
268 return Status;
269 }
270 //
271 // Read Register B
272 //
273 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
274
275 //
276 // Get the Time/Date/Daylight Savings values.
277 //
278 Time->Second = RtcRead (RTC_ADDRESS_SECONDS);
279 Time->Minute = RtcRead (RTC_ADDRESS_MINUTES);
280 Time->Hour = RtcRead (RTC_ADDRESS_HOURS);
281 Time->Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
282 Time->Month = RtcRead (RTC_ADDRESS_MONTH);
283 Time->Year = RtcRead (RTC_ADDRESS_YEAR);
284
285 Century = RtcRead (RTC_ADDRESS_CENTURY);
286
287 //
288 // Release RTC Lock.
289 //
290 if (!EfiAtRuntime ()) {
291 EfiReleaseLock (&Global->RtcLock);
292 }
293
294 //
295 // Get the variable that contains the TimeZone and Daylight fields
296 //
297 Time->TimeZone = Global->SavedTimeZone;
298 Time->Daylight = Global->Daylight;
299
300 //
301 // Make sure all field values are in correct range
302 //
303 Status = ConvertRtcTimeToEfiTime (Time, Century, RegisterB);
304 if (!EFI_ERROR (Status)) {
305 Status = RtcTimeFieldsValid (Time);
306 }
307 if (EFI_ERROR (Status)) {
308 return EFI_DEVICE_ERROR;
309 }
310
311 //
312 // Fill in Capabilities if it was passed in
313 //
314 if (Capabilities != NULL) {
315 Capabilities->Resolution = 1;
316 //
317 // 1 hertz
318 //
319 Capabilities->Accuracy = 50000000;
320 //
321 // 50 ppm
322 //
323 Capabilities->SetsToZero = FALSE;
324 }
325
326 return EFI_SUCCESS;
327 }
328
329 /**
330 Sets the current local time and date information.
331
332 @param Time A pointer to the current time.
333 @param Global For global use inside this module.
334
335 @retval EFI_SUCCESS The operation completed successfully.
336 @retval EFI_INVALID_PARAMETER A time field is out of range.
337 @retval EFI_DEVICE_ERROR The time could not be set due due to hardware error.
338
339 **/
340 EFI_STATUS
341 PcRtcSetTime (
342 IN EFI_TIME *Time,
343 IN PC_RTC_MODULE_GLOBALS *Global
344 )
345 {
346 EFI_STATUS Status;
347 EFI_TIME RtcTime;
348 RTC_REGISTER_B RegisterB;
349 UINT8 Century;
350 UINT32 TimerVar;
351
352 if (Time == NULL) {
353 return EFI_INVALID_PARAMETER;
354 }
355 //
356 // Make sure that the time fields are valid
357 //
358 Status = RtcTimeFieldsValid (Time);
359 if (EFI_ERROR (Status)) {
360 return Status;
361 }
362
363 CopyMem (&RtcTime, Time, sizeof (EFI_TIME));
364
365 //
366 // Acquire RTC Lock to make access to RTC atomic
367 //
368 if (!EfiAtRuntime ()) {
369 EfiAcquireLock (&Global->RtcLock);
370 }
371 //
372 // Wait for up to 0.1 seconds for the RTC to be updated
373 //
374 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
375 if (EFI_ERROR (Status)) {
376 if (!EfiAtRuntime ()) {
377 EfiReleaseLock (&Global->RtcLock);
378 }
379 return Status;
380 }
381 //
382 // Read Register B, and inhibit updates of the RTC
383 //
384 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
385 RegisterB.Bits.Set = 1;
386 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
387
388 ConvertEfiTimeToRtcTime (&RtcTime, RegisterB, &Century);
389
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);
397
398 //
399 // Allow updates of the RTC registers
400 //
401 RegisterB.Bits.Set = 0;
402 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
403
404 //
405 // Release RTC Lock.
406 //
407 if (!EfiAtRuntime ()) {
408 EfiReleaseLock (&Global->RtcLock);
409 }
410 //
411 // Set the variable that contains the TimeZone and Daylight fields
412 //
413 Global->SavedTimeZone = Time->TimeZone;
414 Global->Daylight = Time->Daylight;
415
416 TimerVar = Time->Daylight;
417 TimerVar = (UINT32) ((TimerVar << 16) | Time->TimeZone);
418 Status = EfiSetVariable (
419 L"RTC",
420 &gEfiCallerIdGuid,
421 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
422 sizeof (TimerVar),
423 &TimerVar
424 );
425 ASSERT_EFI_ERROR (Status);
426
427 return EFI_SUCCESS;
428 }
429
430 /**
431 Returns the current wakeup alarm clock setting.
432
433 @param Enabled Indicates if the alarm is currently enabled or disabled.
434 @param Pending Indicates if the alarm signal is pending and requires acknowledgment.
435 @param Time The current alarm setting.
436 @param Global For global use inside this module.
437
438 @retval EFI_SUCCESS The alarm settings were returned.
439 @retval EFI_INVALID_PARAMETER Enabled is NULL.
440 @retval EFI_INVALID_PARAMETER Pending is NULL.
441 @retval EFI_INVALID_PARAMETER Time is NULL.
442 @retval EFI_DEVICE_ERROR The wakeup time could not be retrieved due to a hardware error.
443 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
444
445 **/
446 EFI_STATUS
447 PcRtcGetWakeupTime (
448 OUT BOOLEAN *Enabled,
449 OUT BOOLEAN *Pending,
450 OUT EFI_TIME *Time,
451 IN PC_RTC_MODULE_GLOBALS *Global
452 )
453 {
454 EFI_STATUS Status;
455 RTC_REGISTER_B RegisterB;
456 RTC_REGISTER_C RegisterC;
457 UINT8 Century;
458
459 //
460 // Check parameters for null pointers
461 //
462 if ((Enabled == NULL) || (Pending == NULL) || (Time == NULL)) {
463 return EFI_INVALID_PARAMETER;
464
465 }
466 //
467 // Acquire RTC Lock to make access to RTC atomic
468 //
469 if (!EfiAtRuntime ()) {
470 EfiAcquireLock (&Global->RtcLock);
471 }
472 //
473 // Wait for up to 0.1 seconds for the RTC to be updated
474 //
475 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
476 if (EFI_ERROR (Status)) {
477 if (!EfiAtRuntime ()) {
478 EfiReleaseLock (&Global->RtcLock);
479 }
480 return EFI_DEVICE_ERROR;
481 }
482 //
483 // Read Register B and Register C
484 //
485 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
486 RegisterC.Data = RtcRead (RTC_ADDRESS_REGISTER_C);
487
488 //
489 // Get the Time/Date/Daylight Savings values.
490 //
491 *Enabled = RegisterB.Bits.Aie;
492 if (*Enabled) {
493 Time->Second = RtcRead (RTC_ADDRESS_SECONDS_ALARM);
494 Time->Minute = RtcRead (RTC_ADDRESS_MINUTES_ALARM);
495 Time->Hour = RtcRead (RTC_ADDRESS_HOURS_ALARM);
496 Time->Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
497 Time->Month = RtcRead (RTC_ADDRESS_MONTH);
498 Time->Year = RtcRead (RTC_ADDRESS_YEAR);
499 } else {
500 Time->Second = 0;
501 Time->Minute = 0;
502 Time->Hour = 0;
503 Time->Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
504 Time->Month = RtcRead (RTC_ADDRESS_MONTH);
505 Time->Year = RtcRead (RTC_ADDRESS_YEAR);
506 }
507
508 Century = RtcRead (RTC_ADDRESS_CENTURY);
509
510 //
511 // Release RTC Lock.
512 //
513 if (!EfiAtRuntime ()) {
514 EfiReleaseLock (&Global->RtcLock);
515 }
516
517 //
518 // Get the variable that contains the TimeZone and Daylight fields
519 //
520 Time->TimeZone = Global->SavedTimeZone;
521 Time->Daylight = Global->Daylight;
522
523 //
524 // Make sure all field values are in correct range
525 //
526 Status = ConvertRtcTimeToEfiTime (Time, Century, RegisterB);
527 if (!EFI_ERROR (Status)) {
528 Status = RtcTimeFieldsValid (Time);
529 }
530 if (EFI_ERROR (Status)) {
531 return EFI_DEVICE_ERROR;
532 }
533
534 *Pending = RegisterC.Bits.Af;
535
536 return EFI_SUCCESS;
537 }
538
539 /**
540 Sets the system wakeup alarm clock time.
541
542 @param Enabled Enable or disable the wakeup alarm.
543 @param Time If Enable is TRUE, the time to set the wakeup alarm for.
544 If Enable is FALSE, then this parameter is optional, and may be NULL.
545 @param Global For global use inside this module.
546
547 @retval EFI_SUCCESS If Enable is TRUE, then the wakeup alarm was enabled.
548 If Enable is FALSE, then the wakeup alarm was disabled.
549 @retval EFI_INVALID_PARAMETER A time field is out of range.
550 @retval EFI_DEVICE_ERROR The wakeup time could not be set due to a hardware error.
551 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
552
553 **/
554 EFI_STATUS
555 PcRtcSetWakeupTime (
556 IN BOOLEAN Enable,
557 IN EFI_TIME *Time, OPTIONAL
558 IN PC_RTC_MODULE_GLOBALS *Global
559 )
560 {
561 EFI_STATUS Status;
562 EFI_TIME RtcTime;
563 RTC_REGISTER_B RegisterB;
564 UINT8 Century;
565 EFI_TIME_CAPABILITIES Capabilities;
566
567 if (Enable) {
568
569 if (Time == NULL) {
570 return EFI_INVALID_PARAMETER;
571 }
572 //
573 // Make sure that the time fields are valid
574 //
575 Status = RtcTimeFieldsValid (Time);
576 if (EFI_ERROR (Status)) {
577 return EFI_INVALID_PARAMETER;
578 }
579 //
580 // Just support set alarm time within 24 hours
581 //
582 PcRtcGetTime (&RtcTime, &Capabilities, Global);
583 Status = RtcTimeFieldsValid (&RtcTime);
584 if (EFI_ERROR (Status)) {
585 return EFI_DEVICE_ERROR;
586 }
587 if (!IsWithinOneDay (&RtcTime, Time)) {
588 return EFI_UNSUPPORTED;
589 }
590 //
591 // Make a local copy of the time and date
592 //
593 CopyMem (&RtcTime, Time, sizeof (EFI_TIME));
594
595 }
596 //
597 // Acquire RTC Lock to make access to RTC atomic
598 //
599 if (!EfiAtRuntime ()) {
600 EfiAcquireLock (&Global->RtcLock);
601 }
602 //
603 // Wait for up to 0.1 seconds for the RTC to be updated
604 //
605 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
606 if (EFI_ERROR (Status)) {
607 if (!EfiAtRuntime ()) {
608 EfiReleaseLock (&Global->RtcLock);
609 }
610 return EFI_DEVICE_ERROR;
611 }
612 //
613 // Read Register B, and inhibit updates of the RTC
614 //
615 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
616
617 RegisterB.Bits.Set = 1;
618 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
619
620 if (Enable) {
621 ConvertEfiTimeToRtcTime (&RtcTime, RegisterB, &Century);
622
623 //
624 // Set RTC alarm time
625 //
626 RtcWrite (RTC_ADDRESS_SECONDS_ALARM, RtcTime.Second);
627 RtcWrite (RTC_ADDRESS_MINUTES_ALARM, RtcTime.Minute);
628 RtcWrite (RTC_ADDRESS_HOURS_ALARM, RtcTime.Hour);
629
630 RegisterB.Bits.Aie = 1;
631
632 } else {
633 RegisterB.Bits.Aie = 0;
634 }
635 //
636 // Allow updates of the RTC registers
637 //
638 RegisterB.Bits.Set = 0;
639 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
640
641 //
642 // Release RTC Lock.
643 //
644 if (!EfiAtRuntime ()) {
645 EfiReleaseLock (&Global->RtcLock);
646 }
647 return EFI_SUCCESS;
648 }
649
650
651 /**
652 Checks an 8-bit BCD value, and converts to an 8-bit value if valid.
653
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.
657
658 @param Value The 8-bit BCD value to check and convert
659
660 @return The 8-bit value converted. Or 0xff if Value is invalid.
661
662 **/
663 UINT8
664 CheckAndConvertBcd8ToDecimal8 (
665 IN UINT8 Value
666 )
667 {
668 if ((Value < 0xa0) && ((Value & 0xf) < 0xa)) {
669 return BcdToDecimal8 (Value);
670 }
671
672 return 0xff;
673 }
674
675 /**
676 Converts time read from RTC to EFI_TIME format defined by UEFI spec.
677
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.
682
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
687 and hour format.
688
689 @retval EFI_INVALID_PARAMETER Parameters passed in are invalid.
690 @retval EFI_SUCCESS Convert RTC time to EFI time successfully.
691
692 **/
693 EFI_STATUS
694 ConvertRtcTimeToEfiTime (
695 IN OUT EFI_TIME *Time,
696 IN UINT8 Century,
697 IN RTC_REGISTER_B RegisterB
698 )
699 {
700 BOOLEAN IsPM;
701
702 if ((Time->Hour & 0x80) != 0) {
703 IsPM = TRUE;
704 } else {
705 IsPM = FALSE;
706 }
707
708 Time->Hour = (UINT8) (Time->Hour & 0x7f);
709
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);
717 }
718 Century = CheckAndConvertBcd8ToDecimal8 (Century);
719
720 if (Time->Year == 0xff || Time->Month == 0xff || Time->Day == 0xff ||
721 Time->Hour == 0xff || Time->Minute == 0xff || Time->Second == 0xff ||
722 Century == 0xff) {
723 return EFI_INVALID_PARAMETER;
724 }
725
726 Time->Year = (UINT16) (Century * 100 + Time->Year);
727
728 //
729 // If time is in 12 hour format, convert it to 24 hour format
730 //
731 if (RegisterB.Bits.Mil == 0) {
732 if (IsPM && Time->Hour < 12) {
733 Time->Hour = (UINT8) (Time->Hour + 12);
734 }
735
736 if (!IsPM && Time->Hour == 12) {
737 Time->Hour = 0;
738 }
739 }
740
741 Time->Nanosecond = 0;
742
743 return EFI_SUCCESS;
744 }
745
746 /**
747 Wait for a period for the RTC to be ready.
748
749 @param Timeout Tell how long it should take to wait.
750
751 @retval EFI_DEVICE_ERROR RTC device error.
752 @retval EFI_SUCCESS RTC is updated and ready.
753 **/
754 EFI_STATUS
755 RtcWaitToUpdate (
756 UINTN Timeout
757 )
758 {
759 RTC_REGISTER_A RegisterA;
760 RTC_REGISTER_D RegisterD;
761
762 //
763 // See if the RTC is functioning correctly
764 //
765 RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);
766
767 if (RegisterD.Bits.Vrt == 0) {
768 return EFI_DEVICE_ERROR;
769 }
770 //
771 // Wait for up to 0.1 seconds for the RTC to be ready.
772 //
773 Timeout = (Timeout / 10) + 1;
774 RegisterA.Data = RtcRead (RTC_ADDRESS_REGISTER_A);
775 while (RegisterA.Bits.Uip == 1 && Timeout > 0) {
776 MicroSecondDelay (10);
777 RegisterA.Data = RtcRead (RTC_ADDRESS_REGISTER_A);
778 Timeout--;
779 }
780
781 RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);
782 if (Timeout == 0 || RegisterD.Bits.Vrt == 0) {
783 return EFI_DEVICE_ERROR;
784 }
785
786 return EFI_SUCCESS;
787 }
788
789 /**
790 See if all fields of a variable of EFI_TIME type is correct.
791
792 @param Time The time to be checked.
793
794 @retval EFI_INVALID_PARAMETER Some fields of Time are not correct.
795 @retval EFI_SUCCESS Time is a valid EFI_TIME variable.
796
797 **/
798 EFI_STATUS
799 RtcTimeFieldsValid (
800 IN EFI_TIME *Time
801 )
802 {
803 if (Time->Year < 1998 ||
804 Time->Year > 2099 ||
805 Time->Month < 1 ||
806 Time->Month > 12 ||
807 (!DayValid (Time)) ||
808 Time->Hour > 23 ||
809 Time->Minute > 59 ||
810 Time->Second > 59 ||
811 Time->Nanosecond > 999999999 ||
812 (!(Time->TimeZone == EFI_UNSPECIFIED_TIMEZONE || (Time->TimeZone >= -1440 && Time->TimeZone <= 1440))) ||
813 ((Time->Daylight & (~(EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT))) != 0)) {
814 return EFI_INVALID_PARAMETER;
815 }
816
817 return EFI_SUCCESS;
818 }
819
820 /**
821 See if field Day of an EFI_TIME is correct.
822
823 @param Time Its Day field is to be checked.
824
825 @retval TRUE Day field of Time is correct.
826 @retval FALSE Day field of Time is NOT correct.
827 **/
828 BOOLEAN
829 DayValid (
830 IN EFI_TIME *Time
831 )
832 {
833 INTN DayOfMonth[12];
834
835 DayOfMonth[0] = 31;
836 DayOfMonth[1] = 29;
837 DayOfMonth[2] = 31;
838 DayOfMonth[3] = 30;
839 DayOfMonth[4] = 31;
840 DayOfMonth[5] = 30;
841 DayOfMonth[6] = 31;
842 DayOfMonth[7] = 31;
843 DayOfMonth[8] = 30;
844 DayOfMonth[9] = 31;
845 DayOfMonth[10] = 30;
846 DayOfMonth[11] = 31;
847
848 //
849 // The validity of Time->Month field should be checked before
850 //
851 ASSERT (Time->Month >=1);
852 ASSERT (Time->Month <=12);
853 if (Time->Day < 1 ||
854 Time->Day > DayOfMonth[Time->Month - 1] ||
855 (Time->Month == 2 && (!IsLeapYear (Time) && Time->Day > 28))
856 ) {
857 return FALSE;
858 }
859
860 return TRUE;
861 }
862
863 /**
864 Check if it is a leap year.
865
866 @param Time The time to be checked.
867
868 @retval TRUE It is a leap year.
869 @retval FALSE It is NOT a leap year.
870 **/
871 BOOLEAN
872 IsLeapYear (
873 IN EFI_TIME *Time
874 )
875 {
876 if (Time->Year % 4 == 0) {
877 if (Time->Year % 100 == 0) {
878 if (Time->Year % 400 == 0) {
879 return TRUE;
880 } else {
881 return FALSE;
882 }
883 } else {
884 return TRUE;
885 }
886 } else {
887 return FALSE;
888 }
889 }
890
891 /**
892 Converts time from EFI_TIME format defined by UEFI spec to RTC's.
893
894 This function converts time from EFI_TIME format defined by UEFI spec to RTC's.
895 If data mode of RTC is BCD, then converts EFI_TIME to it.
896 If RTC is in 12-hour format, then converts EFI_TIME to it.
897
898 @param Time On input, the time data read from UEFI to convert
899 On output, the time converted to RTC format
900 @param RegisterB Value of Register B of RTC, indicating data mode
901 @param Century It is set according to EFI_TIME Time.
902
903 **/
904 VOID
905 ConvertEfiTimeToRtcTime (
906 IN OUT EFI_TIME *Time,
907 IN RTC_REGISTER_B RegisterB,
908 OUT UINT8 *Century
909 )
910 {
911 BOOLEAN IsPM;
912
913 IsPM = TRUE;
914 //
915 // Adjust hour field if RTC is in 12 hour mode
916 //
917 if (RegisterB.Bits.Mil == 0) {
918 if (Time->Hour < 12) {
919 IsPM = FALSE;
920 }
921
922 if (Time->Hour >= 13) {
923 Time->Hour = (UINT8) (Time->Hour - 12);
924 } else if (Time->Hour == 0) {
925 Time->Hour = 12;
926 }
927 }
928 //
929 // Set the Time/Date/Daylight Savings values.
930 //
931 *Century = DecimalToBcd8 ((UINT8) (Time->Year / 100));
932
933 Time->Year = (UINT16) (Time->Year % 100);
934
935 if (RegisterB.Bits.Dm == 0) {
936 Time->Year = DecimalToBcd8 ((UINT8) Time->Year);
937 Time->Month = DecimalToBcd8 (Time->Month);
938 Time->Day = DecimalToBcd8 (Time->Day);
939 Time->Hour = DecimalToBcd8 (Time->Hour);
940 Time->Minute = DecimalToBcd8 (Time->Minute);
941 Time->Second = DecimalToBcd8 (Time->Second);
942 }
943 //
944 // If we are in 12 hour mode and PM is set, then set bit 7 of the Hour field.
945 //
946 if (RegisterB.Bits.Mil == 0 && IsPM) {
947 Time->Hour = (UINT8) (Time->Hour | 0x80);
948 }
949 }
950
951 /**
952 Compare the Hour, Minute and Second of the From time and the To time.
953
954 Only compare H/M/S in EFI_TIME and ignore other fields here.
955
956 @param From the first time
957 @param To the second time
958
959 @return >0 The H/M/S of the From time is later than those of To time
960 @return ==0 The H/M/S of the From time is same as those of To time
961 @return <0 The H/M/S of the From time is earlier than those of To time
962 **/
963 INTN
964 CompareHMS (
965 IN EFI_TIME *From,
966 IN EFI_TIME *To
967 )
968 {
969 if ((From->Hour > To->Hour) ||
970 ((From->Hour == To->Hour) && (From->Minute > To->Minute)) ||
971 ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second > To->Second))) {
972 return 1;
973 } else if ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second == To->Second)) {
974 return 0;
975 } else {
976 return -1;
977 }
978 }
979
980 /**
981 To check if second date is later than first date within 24 hours.
982
983 @param From the first date
984 @param To the second date
985
986 @retval TRUE From is previous to To within 24 hours.
987 @retval FALSE From is later, or it is previous to To more than 24 hours.
988 **/
989 BOOLEAN
990 IsWithinOneDay (
991 IN EFI_TIME *From,
992 IN EFI_TIME *To
993 )
994 {
995 UINT8 DayOfMonth[12];
996 BOOLEAN Adjacent;
997
998 DayOfMonth[0] = 31;
999 DayOfMonth[1] = 29;
1000 DayOfMonth[2] = 31;
1001 DayOfMonth[3] = 30;
1002 DayOfMonth[4] = 31;
1003 DayOfMonth[5] = 30;
1004 DayOfMonth[6] = 31;
1005 DayOfMonth[7] = 31;
1006 DayOfMonth[8] = 30;
1007 DayOfMonth[9] = 31;
1008 DayOfMonth[10] = 30;
1009 DayOfMonth[11] = 31;
1010
1011 Adjacent = FALSE;
1012
1013 //
1014 // The validity of From->Month field should be checked before
1015 //
1016 ASSERT (From->Month >=1);
1017 ASSERT (From->Month <=12);
1018
1019 if (From->Year == To->Year) {
1020 if (From->Month == To->Month) {
1021 if ((From->Day + 1) == To->Day) {
1022 if ((CompareHMS(From, To) >= 0)) {
1023 Adjacent = TRUE;
1024 }
1025 } else if (From->Day == To->Day) {
1026 if ((CompareHMS(From, To) <= 0)) {
1027 Adjacent = TRUE;
1028 }
1029 }
1030 } else if (((From->Month + 1) == To->Month) && (To->Day == 1)) {
1031 if ((From->Month == 2) && !IsLeapYear(From)) {
1032 if (From->Day == 28) {
1033 if ((CompareHMS(From, To) >= 0)) {
1034 Adjacent = TRUE;
1035 }
1036 }
1037 } else if (From->Day == DayOfMonth[From->Month - 1]) {
1038 if ((CompareHMS(From, To) >= 0)) {
1039 Adjacent = TRUE;
1040 }
1041 }
1042 }
1043 } else if (((From->Year + 1) == To->Year) &&
1044 (From->Month == 12) &&
1045 (From->Day == 31) &&
1046 (To->Month == 1) &&
1047 (To->Day == 1)) {
1048 if ((CompareHMS(From, To) >= 0)) {
1049 Adjacent = TRUE;
1050 }
1051 }
1052
1053 return Adjacent;
1054 }
1055