]> git.proxmox.com Git - mirror_edk2.git/blob - PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PcAtChipsetPkg/PcRtc: Add assertion to pass static code checker
[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 - 2015, 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 EFI_TIME Time;
104 UINTN DataSize;
105 UINT32 TimerVar;
106 BOOLEAN Enabled;
107 BOOLEAN Pending;
108
109 //
110 // Acquire RTC Lock to make access to RTC atomic
111 //
112 if (!EfiAtRuntime ()) {
113 EfiAcquireLock (&Global->RtcLock);
114 }
115 //
116 // Initialize RTC Register
117 //
118 // Make sure Division Chain is properly configured,
119 // or RTC clock won't "tick" -- time won't increment
120 //
121 RegisterA.Data = RTC_INIT_REGISTER_A;
122 RtcWrite (RTC_ADDRESS_REGISTER_A, RegisterA.Data);
123
124 //
125 // Read Register B
126 //
127 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
128
129 //
130 // Clear RTC flag register
131 //
132 RtcRead (RTC_ADDRESS_REGISTER_C);
133
134 //
135 // Clear RTC register D
136 //
137 RegisterD.Data = RTC_INIT_REGISTER_D;
138 RtcWrite (RTC_ADDRESS_REGISTER_D, RegisterD.Data);
139
140 //
141 // Wait for up to 0.1 seconds for the RTC to be updated
142 //
143 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
144 if (EFI_ERROR (Status)) {
145 //
146 // Set the variable with default value if the RTC is functioning incorrectly.
147 //
148 Global->SavedTimeZone = EFI_UNSPECIFIED_TIMEZONE;
149 Global->Daylight = 0;
150 if (!EfiAtRuntime ()) {
151 EfiReleaseLock (&Global->RtcLock);
152 }
153 return EFI_DEVICE_ERROR;
154 }
155 //
156 // Get the Time/Date/Daylight Savings values.
157 //
158 Time.Second = RtcRead (RTC_ADDRESS_SECONDS);
159 Time.Minute = RtcRead (RTC_ADDRESS_MINUTES);
160 Time.Hour = RtcRead (RTC_ADDRESS_HOURS);
161 Time.Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
162 Time.Month = RtcRead (RTC_ADDRESS_MONTH);
163 Time.Year = RtcRead (RTC_ADDRESS_YEAR);
164
165 //
166 // Set RTC configuration after get original time
167 // The value of bit AIE should be reserved.
168 //
169 RegisterB.Data = RTC_INIT_REGISTER_B | (RegisterB.Data & BIT5);
170 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
171
172 //
173 // Release RTC Lock.
174 //
175 if (!EfiAtRuntime ()) {
176 EfiReleaseLock (&Global->RtcLock);
177 }
178
179 //
180 // Get the data of Daylight saving and time zone, if they have been
181 // stored in NV variable during previous boot.
182 //
183 DataSize = sizeof (UINT32);
184 Status = EfiGetVariable (
185 L"RTC",
186 &gEfiCallerIdGuid,
187 NULL,
188 &DataSize,
189 (VOID *) &TimerVar
190 );
191 if (!EFI_ERROR (Status)) {
192 Time.TimeZone = (INT16) TimerVar;
193 Time.Daylight = (UINT8) (TimerVar >> 16);
194 } else {
195 Time.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
196 Time.Daylight = 0;
197 }
198
199 //
200 // Validate time fields
201 //
202 Status = ConvertRtcTimeToEfiTime (&Time, RegisterB);
203 if (!EFI_ERROR (Status)) {
204 Status = RtcTimeFieldsValid (&Time);
205 }
206 if (EFI_ERROR (Status)) {
207 //
208 // Report Status Code to indicate that the RTC has bad date and time
209 //
210 REPORT_STATUS_CODE (
211 EFI_ERROR_CODE | EFI_ERROR_MINOR,
212 (EFI_SOFTWARE_DXE_RT_DRIVER | EFI_SW_EC_BAD_DATE_TIME)
213 );
214 Time.Second = RTC_INIT_SECOND;
215 Time.Minute = RTC_INIT_MINUTE;
216 Time.Hour = RTC_INIT_HOUR;
217 Time.Day = RTC_INIT_DAY;
218 Time.Month = RTC_INIT_MONTH;
219 Time.Year = PcdGet16 (PcdMinimalValidYear);
220 Time.Nanosecond = 0;
221 Time.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
222 Time.Daylight = 0;
223 }
224
225 //
226 // Reset time value according to new RTC configuration
227 //
228 Status = PcRtcSetTime (&Time, Global);
229 if (EFI_ERROR (Status)) {
230 return EFI_DEVICE_ERROR;
231 }
232
233 //
234 // Reset wakeup time value to valid state when wakeup alarm is disabled and wakeup time is invalid.
235 // Global variable has already had valid SavedTimeZone and Daylight,
236 // so we can use them to get and set wakeup time.
237 //
238 Status = PcRtcGetWakeupTime (&Enabled, &Pending, &Time, Global);
239 if ((Enabled) || (!EFI_ERROR (Status))) {
240 return EFI_SUCCESS;
241 }
242
243 //
244 // When wakeup time is disabled and invalid, reset wakeup time register to valid state
245 // but keep wakeup alarm disabled.
246 //
247 Time.Second = RTC_INIT_SECOND;
248 Time.Minute = RTC_INIT_MINUTE;
249 Time.Hour = RTC_INIT_HOUR;
250 Time.Day = RTC_INIT_DAY;
251 Time.Month = RTC_INIT_MONTH;
252 Time.Year = PcdGet16 (PcdMinimalValidYear);
253 Time.Nanosecond = 0;
254 Time.TimeZone = Global->SavedTimeZone;
255 Time.Daylight = Global->Daylight;;
256
257 //
258 // Acquire RTC Lock to make access to RTC atomic
259 //
260 if (!EfiAtRuntime ()) {
261 EfiAcquireLock (&Global->RtcLock);
262 }
263 //
264 // Wait for up to 0.1 seconds for the RTC to be updated
265 //
266 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
267 if (EFI_ERROR (Status)) {
268 if (!EfiAtRuntime ()) {
269 EfiReleaseLock (&Global->RtcLock);
270 }
271 return EFI_DEVICE_ERROR;
272 }
273
274 ConvertEfiTimeToRtcTime (&Time, RegisterB);
275
276 //
277 // Set the Y/M/D info to variable as it has no corresponding hw registers.
278 //
279 Status = EfiSetVariable (
280 L"RTCALARM",
281 &gEfiCallerIdGuid,
282 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
283 sizeof (Time),
284 &Time
285 );
286 if (EFI_ERROR (Status)) {
287 if (!EfiAtRuntime ()) {
288 EfiReleaseLock (&Global->RtcLock);
289 }
290 return EFI_DEVICE_ERROR;
291 }
292
293 //
294 // Inhibit updates of the RTC
295 //
296 RegisterB.Bits.Set = 1;
297 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
298
299 //
300 // Set RTC alarm time registers
301 //
302 RtcWrite (RTC_ADDRESS_SECONDS_ALARM, Time.Second);
303 RtcWrite (RTC_ADDRESS_MINUTES_ALARM, Time.Minute);
304 RtcWrite (RTC_ADDRESS_HOURS_ALARM, Time.Hour);
305
306 //
307 // Allow updates of the RTC registers
308 //
309 RegisterB.Bits.Set = 0;
310 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
311
312 //
313 // Release RTC Lock.
314 //
315 if (!EfiAtRuntime ()) {
316 EfiReleaseLock (&Global->RtcLock);
317 }
318 return EFI_SUCCESS;
319 }
320
321 /**
322 Returns the current time and date information, and the time-keeping capabilities
323 of the hardware platform.
324
325 @param Time A pointer to storage to receive a snapshot of the current time.
326 @param Capabilities An optional pointer to a buffer to receive the real time clock
327 device's capabilities.
328 @param Global For global use inside this module.
329
330 @retval EFI_SUCCESS The operation completed successfully.
331 @retval EFI_INVALID_PARAMETER Time is NULL.
332 @retval EFI_DEVICE_ERROR The time could not be retrieved due to hardware error.
333
334 **/
335 EFI_STATUS
336 PcRtcGetTime (
337 OUT EFI_TIME *Time,
338 OUT EFI_TIME_CAPABILITIES *Capabilities, OPTIONAL
339 IN PC_RTC_MODULE_GLOBALS *Global
340 )
341 {
342 EFI_STATUS Status;
343 RTC_REGISTER_B RegisterB;
344
345 //
346 // Check parameters for null pointer
347 //
348 if (Time == NULL) {
349 return EFI_INVALID_PARAMETER;
350
351 }
352 //
353 // Acquire RTC Lock to make access to RTC atomic
354 //
355 if (!EfiAtRuntime ()) {
356 EfiAcquireLock (&Global->RtcLock);
357 }
358 //
359 // Wait for up to 0.1 seconds for the RTC to be updated
360 //
361 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
362 if (EFI_ERROR (Status)) {
363 if (!EfiAtRuntime ()) {
364 EfiReleaseLock (&Global->RtcLock);
365 }
366 return Status;
367 }
368 //
369 // Read Register B
370 //
371 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
372
373 //
374 // Get the Time/Date/Daylight Savings values.
375 //
376 Time->Second = RtcRead (RTC_ADDRESS_SECONDS);
377 Time->Minute = RtcRead (RTC_ADDRESS_MINUTES);
378 Time->Hour = RtcRead (RTC_ADDRESS_HOURS);
379 Time->Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
380 Time->Month = RtcRead (RTC_ADDRESS_MONTH);
381 Time->Year = RtcRead (RTC_ADDRESS_YEAR);
382
383 //
384 // Release RTC Lock.
385 //
386 if (!EfiAtRuntime ()) {
387 EfiReleaseLock (&Global->RtcLock);
388 }
389
390 //
391 // Get the variable that contains the TimeZone and Daylight fields
392 //
393 Time->TimeZone = Global->SavedTimeZone;
394 Time->Daylight = Global->Daylight;
395
396 //
397 // Make sure all field values are in correct range
398 //
399 Status = ConvertRtcTimeToEfiTime (Time, RegisterB);
400 if (!EFI_ERROR (Status)) {
401 Status = RtcTimeFieldsValid (Time);
402 }
403 if (EFI_ERROR (Status)) {
404 return EFI_DEVICE_ERROR;
405 }
406
407 //
408 // Fill in Capabilities if it was passed in
409 //
410 if (Capabilities != NULL) {
411 Capabilities->Resolution = 1;
412 //
413 // 1 hertz
414 //
415 Capabilities->Accuracy = 50000000;
416 //
417 // 50 ppm
418 //
419 Capabilities->SetsToZero = FALSE;
420 }
421
422 return EFI_SUCCESS;
423 }
424
425 /**
426 Sets the current local time and date information.
427
428 @param Time A pointer to the current time.
429 @param Global For global use inside this module.
430
431 @retval EFI_SUCCESS The operation completed successfully.
432 @retval EFI_INVALID_PARAMETER A time field is out of range.
433 @retval EFI_DEVICE_ERROR The time could not be set due due to hardware error.
434
435 **/
436 EFI_STATUS
437 PcRtcSetTime (
438 IN EFI_TIME *Time,
439 IN PC_RTC_MODULE_GLOBALS *Global
440 )
441 {
442 EFI_STATUS Status;
443 EFI_TIME RtcTime;
444 RTC_REGISTER_B RegisterB;
445 UINT32 TimerVar;
446
447 if (Time == NULL) {
448 return EFI_INVALID_PARAMETER;
449 }
450 //
451 // Make sure that the time fields are valid
452 //
453 Status = RtcTimeFieldsValid (Time);
454 if (EFI_ERROR (Status)) {
455 return Status;
456 }
457
458 CopyMem (&RtcTime, Time, sizeof (EFI_TIME));
459
460 //
461 // Acquire RTC Lock to make access to RTC atomic
462 //
463 if (!EfiAtRuntime ()) {
464 EfiAcquireLock (&Global->RtcLock);
465 }
466 //
467 // Wait for up to 0.1 seconds for the RTC to be updated
468 //
469 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
470 if (EFI_ERROR (Status)) {
471 if (!EfiAtRuntime ()) {
472 EfiReleaseLock (&Global->RtcLock);
473 }
474 return Status;
475 }
476
477 //
478 // Write timezone and daylight to RTC variable
479 //
480 TimerVar = Time->Daylight;
481 TimerVar = (UINT32) ((TimerVar << 16) | (UINT16)(Time->TimeZone));
482 Status = EfiSetVariable (
483 L"RTC",
484 &gEfiCallerIdGuid,
485 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
486 sizeof (TimerVar),
487 &TimerVar
488 );
489 if (EFI_ERROR (Status)) {
490 if (!EfiAtRuntime ()) {
491 EfiReleaseLock (&Global->RtcLock);
492 }
493 return EFI_DEVICE_ERROR;
494 }
495
496 //
497 // Read Register B, and inhibit updates of the RTC
498 //
499 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
500 RegisterB.Bits.Set = 1;
501 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
502
503 //
504 // Store the century value to RTC before converting to BCD format.
505 //
506 if (Global->CenturyRtcAddress != 0) {
507 RtcWrite (Global->CenturyRtcAddress, DecimalToBcd8 ((UINT8) (RtcTime.Year / 100)));
508 }
509
510 ConvertEfiTimeToRtcTime (&RtcTime, RegisterB);
511
512 RtcWrite (RTC_ADDRESS_SECONDS, RtcTime.Second);
513 RtcWrite (RTC_ADDRESS_MINUTES, RtcTime.Minute);
514 RtcWrite (RTC_ADDRESS_HOURS, RtcTime.Hour);
515 RtcWrite (RTC_ADDRESS_DAY_OF_THE_MONTH, RtcTime.Day);
516 RtcWrite (RTC_ADDRESS_MONTH, RtcTime.Month);
517 RtcWrite (RTC_ADDRESS_YEAR, (UINT8) RtcTime.Year);
518
519 //
520 // Allow updates of the RTC registers
521 //
522 RegisterB.Bits.Set = 0;
523 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
524
525 //
526 // Release RTC Lock.
527 //
528 if (!EfiAtRuntime ()) {
529 EfiReleaseLock (&Global->RtcLock);
530 }
531 //
532 // Set the variable that contains the TimeZone and Daylight fields
533 //
534 Global->SavedTimeZone = Time->TimeZone;
535 Global->Daylight = Time->Daylight;
536
537 return EFI_SUCCESS;
538 }
539
540 /**
541 Returns the current wakeup alarm clock setting.
542
543 @param Enabled Indicates if the alarm is currently enabled or disabled.
544 @param Pending Indicates if the alarm signal is pending and requires acknowledgment.
545 @param Time The current alarm setting.
546 @param Global For global use inside this module.
547
548 @retval EFI_SUCCESS The alarm settings were returned.
549 @retval EFI_INVALID_PARAMETER Enabled is NULL.
550 @retval EFI_INVALID_PARAMETER Pending is NULL.
551 @retval EFI_INVALID_PARAMETER Time is NULL.
552 @retval EFI_DEVICE_ERROR The wakeup time could not be retrieved due to a hardware error.
553 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
554
555 **/
556 EFI_STATUS
557 PcRtcGetWakeupTime (
558 OUT BOOLEAN *Enabled,
559 OUT BOOLEAN *Pending,
560 OUT EFI_TIME *Time,
561 IN PC_RTC_MODULE_GLOBALS *Global
562 )
563 {
564 EFI_STATUS Status;
565 RTC_REGISTER_B RegisterB;
566 RTC_REGISTER_C RegisterC;
567 EFI_TIME RtcTime;
568 UINTN DataSize;
569
570 //
571 // Check parameters for null pointers
572 //
573 if ((Enabled == NULL) || (Pending == NULL) || (Time == NULL)) {
574 return EFI_INVALID_PARAMETER;
575
576 }
577 //
578 // Acquire RTC Lock to make access to RTC atomic
579 //
580 if (!EfiAtRuntime ()) {
581 EfiAcquireLock (&Global->RtcLock);
582 }
583 //
584 // Wait for up to 0.1 seconds for the RTC to be updated
585 //
586 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
587 if (EFI_ERROR (Status)) {
588 if (!EfiAtRuntime ()) {
589 EfiReleaseLock (&Global->RtcLock);
590 }
591 return EFI_DEVICE_ERROR;
592 }
593 //
594 // Read Register B and Register C
595 //
596 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
597 RegisterC.Data = RtcRead (RTC_ADDRESS_REGISTER_C);
598
599 //
600 // Get the Time/Date/Daylight Savings values.
601 //
602 *Enabled = RegisterB.Bits.Aie;
603 *Pending = RegisterC.Bits.Af;
604
605 Time->Second = RtcRead (RTC_ADDRESS_SECONDS_ALARM);
606 Time->Minute = RtcRead (RTC_ADDRESS_MINUTES_ALARM);
607 Time->Hour = RtcRead (RTC_ADDRESS_HOURS_ALARM);
608 Time->Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
609 Time->Month = RtcRead (RTC_ADDRESS_MONTH);
610 Time->Year = RtcRead (RTC_ADDRESS_YEAR);
611 Time->TimeZone = Global->SavedTimeZone;
612 Time->Daylight = Global->Daylight;
613
614 //
615 // Get the alarm info from variable
616 //
617 DataSize = sizeof (EFI_TIME);
618 Status = EfiGetVariable (
619 L"RTCALARM",
620 &gEfiCallerIdGuid,
621 NULL,
622 &DataSize,
623 &RtcTime
624 );
625 if (!EFI_ERROR (Status)) {
626 //
627 // The alarm variable exists. In this case, we read variable to get info.
628 //
629 Time->Day = RtcTime.Day;
630 Time->Month = RtcTime.Month;
631 Time->Year = RtcTime.Year;
632 }
633
634 //
635 // Release RTC Lock.
636 //
637 if (!EfiAtRuntime ()) {
638 EfiReleaseLock (&Global->RtcLock);
639 }
640
641 //
642 // Make sure all field values are in correct range
643 //
644 Status = ConvertRtcTimeToEfiTime (Time, RegisterB);
645 if (!EFI_ERROR (Status)) {
646 Status = RtcTimeFieldsValid (Time);
647 }
648 if (EFI_ERROR (Status)) {
649 return EFI_DEVICE_ERROR;
650 }
651
652 return EFI_SUCCESS;
653 }
654
655 /**
656 Sets the system wakeup alarm clock time.
657
658 @param Enabled Enable or disable the wakeup alarm.
659 @param Time If Enable is TRUE, the time to set the wakeup alarm for.
660 If Enable is FALSE, then this parameter is optional, and may be NULL.
661 @param Global For global use inside this module.
662
663 @retval EFI_SUCCESS If Enable is TRUE, then the wakeup alarm was enabled.
664 If Enable is FALSE, then the wakeup alarm was disabled.
665 @retval EFI_INVALID_PARAMETER A time field is out of range.
666 @retval EFI_DEVICE_ERROR The wakeup time could not be set due to a hardware error.
667 @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
668
669 **/
670 EFI_STATUS
671 PcRtcSetWakeupTime (
672 IN BOOLEAN Enable,
673 IN EFI_TIME *Time, OPTIONAL
674 IN PC_RTC_MODULE_GLOBALS *Global
675 )
676 {
677 EFI_STATUS Status;
678 EFI_TIME RtcTime;
679 RTC_REGISTER_B RegisterB;
680 EFI_TIME_CAPABILITIES Capabilities;
681
682 ZeroMem (&RtcTime, sizeof (RtcTime));
683
684 if (Enable) {
685
686 if (Time == NULL) {
687 return EFI_INVALID_PARAMETER;
688 }
689 //
690 // Make sure that the time fields are valid
691 //
692 Status = RtcTimeFieldsValid (Time);
693 if (EFI_ERROR (Status)) {
694 return EFI_INVALID_PARAMETER;
695 }
696 //
697 // Just support set alarm time within 24 hours
698 //
699 PcRtcGetTime (&RtcTime, &Capabilities, Global);
700 Status = RtcTimeFieldsValid (&RtcTime);
701 if (EFI_ERROR (Status)) {
702 return EFI_DEVICE_ERROR;
703 }
704 if (!IsWithinOneDay (&RtcTime, Time)) {
705 return EFI_UNSUPPORTED;
706 }
707 //
708 // Make a local copy of the time and date
709 //
710 CopyMem (&RtcTime, Time, sizeof (EFI_TIME));
711
712 }
713 //
714 // Acquire RTC Lock to make access to RTC atomic
715 //
716 if (!EfiAtRuntime ()) {
717 EfiAcquireLock (&Global->RtcLock);
718 }
719 //
720 // Wait for up to 0.1 seconds for the RTC to be updated
721 //
722 Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
723 if (EFI_ERROR (Status)) {
724 if (!EfiAtRuntime ()) {
725 EfiReleaseLock (&Global->RtcLock);
726 }
727 return EFI_DEVICE_ERROR;
728 }
729 //
730 // Read Register B
731 //
732 RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);
733
734 if (Enable) {
735 ConvertEfiTimeToRtcTime (&RtcTime, RegisterB);
736 } else {
737 //
738 // if the alarm is disable, record the current setting.
739 //
740 RtcTime.Second = RtcRead (RTC_ADDRESS_SECONDS_ALARM);
741 RtcTime.Minute = RtcRead (RTC_ADDRESS_MINUTES_ALARM);
742 RtcTime.Hour = RtcRead (RTC_ADDRESS_HOURS_ALARM);
743 RtcTime.Day = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);
744 RtcTime.Month = RtcRead (RTC_ADDRESS_MONTH);
745 RtcTime.Year = RtcRead (RTC_ADDRESS_YEAR);
746 RtcTime.TimeZone = Global->SavedTimeZone;
747 RtcTime.Daylight = Global->Daylight;
748 }
749
750 //
751 // Set the Y/M/D info to variable as it has no corresponding hw registers.
752 //
753 Status = EfiSetVariable (
754 L"RTCALARM",
755 &gEfiCallerIdGuid,
756 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
757 sizeof (RtcTime),
758 &RtcTime
759 );
760 if (EFI_ERROR (Status)) {
761 if (!EfiAtRuntime ()) {
762 EfiReleaseLock (&Global->RtcLock);
763 }
764 return EFI_DEVICE_ERROR;
765 }
766
767 //
768 // Inhibit updates of the RTC
769 //
770 RegisterB.Bits.Set = 1;
771 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
772
773 if (Enable) {
774 //
775 // Set RTC alarm time
776 //
777 RtcWrite (RTC_ADDRESS_SECONDS_ALARM, RtcTime.Second);
778 RtcWrite (RTC_ADDRESS_MINUTES_ALARM, RtcTime.Minute);
779 RtcWrite (RTC_ADDRESS_HOURS_ALARM, RtcTime.Hour);
780
781 RegisterB.Bits.Aie = 1;
782
783 } else {
784 RegisterB.Bits.Aie = 0;
785 }
786 //
787 // Allow updates of the RTC registers
788 //
789 RegisterB.Bits.Set = 0;
790 RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);
791
792 //
793 // Release RTC Lock.
794 //
795 if (!EfiAtRuntime ()) {
796 EfiReleaseLock (&Global->RtcLock);
797 }
798 return EFI_SUCCESS;
799 }
800
801
802 /**
803 Checks an 8-bit BCD value, and converts to an 8-bit value if valid.
804
805 This function checks the 8-bit BCD value specified by Value.
806 If valid, the function converts it to an 8-bit value and returns it.
807 Otherwise, return 0xff.
808
809 @param Value The 8-bit BCD value to check and convert
810
811 @return The 8-bit value converted. Or 0xff if Value is invalid.
812
813 **/
814 UINT8
815 CheckAndConvertBcd8ToDecimal8 (
816 IN UINT8 Value
817 )
818 {
819 if ((Value < 0xa0) && ((Value & 0xf) < 0xa)) {
820 return BcdToDecimal8 (Value);
821 }
822
823 return 0xff;
824 }
825
826 /**
827 Converts time read from RTC to EFI_TIME format defined by UEFI spec.
828
829 This function converts raw time data read from RTC to the EFI_TIME format
830 defined by UEFI spec.
831 If data mode of RTC is BCD, then converts it to decimal,
832 If RTC is in 12-hour format, then converts it to 24-hour format.
833
834 @param Time On input, the time data read from RTC to convert
835 On output, the time converted to UEFI format
836 @param RegisterB Value of Register B of RTC, indicating data mode
837 and hour format.
838
839 @retval EFI_INVALID_PARAMETER Parameters passed in are invalid.
840 @retval EFI_SUCCESS Convert RTC time to EFI time successfully.
841
842 **/
843 EFI_STATUS
844 ConvertRtcTimeToEfiTime (
845 IN OUT EFI_TIME *Time,
846 IN RTC_REGISTER_B RegisterB
847 )
848 {
849 BOOLEAN IsPM;
850 UINT8 Century;
851
852 if ((Time->Hour & 0x80) != 0) {
853 IsPM = TRUE;
854 } else {
855 IsPM = FALSE;
856 }
857
858 Time->Hour = (UINT8) (Time->Hour & 0x7f);
859
860 if (RegisterB.Bits.Dm == 0) {
861 Time->Year = CheckAndConvertBcd8ToDecimal8 ((UINT8) Time->Year);
862 Time->Month = CheckAndConvertBcd8ToDecimal8 (Time->Month);
863 Time->Day = CheckAndConvertBcd8ToDecimal8 (Time->Day);
864 Time->Hour = CheckAndConvertBcd8ToDecimal8 (Time->Hour);
865 Time->Minute = CheckAndConvertBcd8ToDecimal8 (Time->Minute);
866 Time->Second = CheckAndConvertBcd8ToDecimal8 (Time->Second);
867 }
868
869 if (Time->Year == 0xff || Time->Month == 0xff || Time->Day == 0xff ||
870 Time->Hour == 0xff || Time->Minute == 0xff || Time->Second == 0xff) {
871 return EFI_INVALID_PARAMETER;
872 }
873
874 //
875 // For minimal/maximum year range [1970, 2069],
876 // Century is 19 if RTC year >= 70,
877 // Century is 20 otherwise.
878 //
879 Century = (UINT8) (PcdGet16 (PcdMinimalValidYear) / 100);
880 if (Time->Year < PcdGet16 (PcdMinimalValidYear) % 100) {
881 Century++;
882 }
883 Time->Year = (UINT16) (Century * 100 + Time->Year);
884
885 //
886 // If time is in 12 hour format, convert it to 24 hour format
887 //
888 if (RegisterB.Bits.Mil == 0) {
889 if (IsPM && Time->Hour < 12) {
890 Time->Hour = (UINT8) (Time->Hour + 12);
891 }
892
893 if (!IsPM && Time->Hour == 12) {
894 Time->Hour = 0;
895 }
896 }
897
898 Time->Nanosecond = 0;
899
900 return EFI_SUCCESS;
901 }
902
903 /**
904 Wait for a period for the RTC to be ready.
905
906 @param Timeout Tell how long it should take to wait.
907
908 @retval EFI_DEVICE_ERROR RTC device error.
909 @retval EFI_SUCCESS RTC is updated and ready.
910 **/
911 EFI_STATUS
912 RtcWaitToUpdate (
913 UINTN Timeout
914 )
915 {
916 RTC_REGISTER_A RegisterA;
917 RTC_REGISTER_D RegisterD;
918
919 //
920 // See if the RTC is functioning correctly
921 //
922 RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);
923
924 if (RegisterD.Bits.Vrt == 0) {
925 return EFI_DEVICE_ERROR;
926 }
927 //
928 // Wait for up to 0.1 seconds for the RTC to be ready.
929 //
930 Timeout = (Timeout / 10) + 1;
931 RegisterA.Data = RtcRead (RTC_ADDRESS_REGISTER_A);
932 while (RegisterA.Bits.Uip == 1 && Timeout > 0) {
933 MicroSecondDelay (10);
934 RegisterA.Data = RtcRead (RTC_ADDRESS_REGISTER_A);
935 Timeout--;
936 }
937
938 RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);
939 if (Timeout == 0 || RegisterD.Bits.Vrt == 0) {
940 return EFI_DEVICE_ERROR;
941 }
942
943 return EFI_SUCCESS;
944 }
945
946 /**
947 See if all fields of a variable of EFI_TIME type is correct.
948
949 @param Time The time to be checked.
950
951 @retval EFI_INVALID_PARAMETER Some fields of Time are not correct.
952 @retval EFI_SUCCESS Time is a valid EFI_TIME variable.
953
954 **/
955 EFI_STATUS
956 RtcTimeFieldsValid (
957 IN EFI_TIME *Time
958 )
959 {
960 if (Time->Year < PcdGet16 (PcdMinimalValidYear) ||
961 Time->Year > PcdGet16 (PcdMaximalValidYear) ||
962 Time->Month < 1 ||
963 Time->Month > 12 ||
964 (!DayValid (Time)) ||
965 Time->Hour > 23 ||
966 Time->Minute > 59 ||
967 Time->Second > 59 ||
968 Time->Nanosecond > 999999999 ||
969 (!(Time->TimeZone == EFI_UNSPECIFIED_TIMEZONE || (Time->TimeZone >= -1440 && Time->TimeZone <= 1440))) ||
970 ((Time->Daylight & (~(EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT))) != 0)) {
971 return EFI_INVALID_PARAMETER;
972 }
973
974 return EFI_SUCCESS;
975 }
976
977 /**
978 See if field Day of an EFI_TIME is correct.
979
980 @param Time Its Day field is to be checked.
981
982 @retval TRUE Day field of Time is correct.
983 @retval FALSE Day field of Time is NOT correct.
984 **/
985 BOOLEAN
986 DayValid (
987 IN EFI_TIME *Time
988 )
989 {
990 INTN DayOfMonth[12];
991
992 DayOfMonth[0] = 31;
993 DayOfMonth[1] = 29;
994 DayOfMonth[2] = 31;
995 DayOfMonth[3] = 30;
996 DayOfMonth[4] = 31;
997 DayOfMonth[5] = 30;
998 DayOfMonth[6] = 31;
999 DayOfMonth[7] = 31;
1000 DayOfMonth[8] = 30;
1001 DayOfMonth[9] = 31;
1002 DayOfMonth[10] = 30;
1003 DayOfMonth[11] = 31;
1004
1005 //
1006 // The validity of Time->Month field should be checked before
1007 //
1008 ASSERT (Time->Month >=1);
1009 ASSERT (Time->Month <=12);
1010 if (Time->Day < 1 ||
1011 Time->Day > DayOfMonth[Time->Month - 1] ||
1012 (Time->Month == 2 && (!IsLeapYear (Time) && Time->Day > 28))
1013 ) {
1014 return FALSE;
1015 }
1016
1017 return TRUE;
1018 }
1019
1020 /**
1021 Check if it is a leap year.
1022
1023 @param Time The time to be checked.
1024
1025 @retval TRUE It is a leap year.
1026 @retval FALSE It is NOT a leap year.
1027 **/
1028 BOOLEAN
1029 IsLeapYear (
1030 IN EFI_TIME *Time
1031 )
1032 {
1033 if (Time->Year % 4 == 0) {
1034 if (Time->Year % 100 == 0) {
1035 if (Time->Year % 400 == 0) {
1036 return TRUE;
1037 } else {
1038 return FALSE;
1039 }
1040 } else {
1041 return TRUE;
1042 }
1043 } else {
1044 return FALSE;
1045 }
1046 }
1047
1048 /**
1049 Converts time from EFI_TIME format defined by UEFI spec to RTC's.
1050
1051 This function converts time from EFI_TIME format defined by UEFI spec to RTC's.
1052 If data mode of RTC is BCD, then converts EFI_TIME to it.
1053 If RTC is in 12-hour format, then converts EFI_TIME to it.
1054
1055 @param Time On input, the time data read from UEFI to convert
1056 On output, the time converted to RTC format
1057 @param RegisterB Value of Register B of RTC, indicating data mode
1058 **/
1059 VOID
1060 ConvertEfiTimeToRtcTime (
1061 IN OUT EFI_TIME *Time,
1062 IN RTC_REGISTER_B RegisterB
1063 )
1064 {
1065 BOOLEAN IsPM;
1066
1067 IsPM = TRUE;
1068 //
1069 // Adjust hour field if RTC is in 12 hour mode
1070 //
1071 if (RegisterB.Bits.Mil == 0) {
1072 if (Time->Hour < 12) {
1073 IsPM = FALSE;
1074 }
1075
1076 if (Time->Hour >= 13) {
1077 Time->Hour = (UINT8) (Time->Hour - 12);
1078 } else if (Time->Hour == 0) {
1079 Time->Hour = 12;
1080 }
1081 }
1082 //
1083 // Set the Time/Date values.
1084 //
1085 Time->Year = (UINT16) (Time->Year % 100);
1086
1087 if (RegisterB.Bits.Dm == 0) {
1088 Time->Year = DecimalToBcd8 ((UINT8) Time->Year);
1089 Time->Month = DecimalToBcd8 (Time->Month);
1090 Time->Day = DecimalToBcd8 (Time->Day);
1091 Time->Hour = DecimalToBcd8 (Time->Hour);
1092 Time->Minute = DecimalToBcd8 (Time->Minute);
1093 Time->Second = DecimalToBcd8 (Time->Second);
1094 }
1095 //
1096 // If we are in 12 hour mode and PM is set, then set bit 7 of the Hour field.
1097 //
1098 if (RegisterB.Bits.Mil == 0 && IsPM) {
1099 Time->Hour = (UINT8) (Time->Hour | 0x80);
1100 }
1101 }
1102
1103 /**
1104 Compare the Hour, Minute and Second of the From time and the To time.
1105
1106 Only compare H/M/S in EFI_TIME and ignore other fields here.
1107
1108 @param From the first time
1109 @param To the second time
1110
1111 @return >0 The H/M/S of the From time is later than those of To time
1112 @return ==0 The H/M/S of the From time is same as those of To time
1113 @return <0 The H/M/S of the From time is earlier than those of To time
1114 **/
1115 INTN
1116 CompareHMS (
1117 IN EFI_TIME *From,
1118 IN EFI_TIME *To
1119 )
1120 {
1121 if ((From->Hour > To->Hour) ||
1122 ((From->Hour == To->Hour) && (From->Minute > To->Minute)) ||
1123 ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second > To->Second))) {
1124 return 1;
1125 } else if ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second == To->Second)) {
1126 return 0;
1127 } else {
1128 return -1;
1129 }
1130 }
1131
1132 /**
1133 To check if second date is later than first date within 24 hours.
1134
1135 @param From the first date
1136 @param To the second date
1137
1138 @retval TRUE From is previous to To within 24 hours.
1139 @retval FALSE From is later, or it is previous to To more than 24 hours.
1140 **/
1141 BOOLEAN
1142 IsWithinOneDay (
1143 IN EFI_TIME *From,
1144 IN EFI_TIME *To
1145 )
1146 {
1147 UINT8 DayOfMonth[12];
1148 BOOLEAN Adjacent;
1149
1150 DayOfMonth[0] = 31;
1151 DayOfMonth[1] = 29;
1152 DayOfMonth[2] = 31;
1153 DayOfMonth[3] = 30;
1154 DayOfMonth[4] = 31;
1155 DayOfMonth[5] = 30;
1156 DayOfMonth[6] = 31;
1157 DayOfMonth[7] = 31;
1158 DayOfMonth[8] = 30;
1159 DayOfMonth[9] = 31;
1160 DayOfMonth[10] = 30;
1161 DayOfMonth[11] = 31;
1162
1163 Adjacent = FALSE;
1164
1165 //
1166 // The validity of From->Month field should be checked before
1167 //
1168 ASSERT (From->Month >=1);
1169 ASSERT (From->Month <=12);
1170
1171 if (From->Year == To->Year) {
1172 if (From->Month == To->Month) {
1173 if ((From->Day + 1) == To->Day) {
1174 if ((CompareHMS(From, To) >= 0)) {
1175 Adjacent = TRUE;
1176 }
1177 } else if (From->Day == To->Day) {
1178 if ((CompareHMS(From, To) <= 0)) {
1179 Adjacent = TRUE;
1180 }
1181 }
1182 } else if (((From->Month + 1) == To->Month) && (To->Day == 1)) {
1183 if ((From->Month == 2) && !IsLeapYear(From)) {
1184 if (From->Day == 28) {
1185 if ((CompareHMS(From, To) >= 0)) {
1186 Adjacent = TRUE;
1187 }
1188 }
1189 } else if (From->Day == DayOfMonth[From->Month - 1]) {
1190 if ((CompareHMS(From, To) >= 0)) {
1191 Adjacent = TRUE;
1192 }
1193 }
1194 }
1195 } else if (((From->Year + 1) == To->Year) &&
1196 (From->Month == 12) &&
1197 (From->Day == 31) &&
1198 (To->Month == 1) &&
1199 (To->Day == 1)) {
1200 if ((CompareHMS(From, To) >= 0)) {
1201 Adjacent = TRUE;
1202 }
1203 }
1204
1205 return Adjacent;
1206 }
1207
1208 /**
1209 This function find ACPI table with the specified signature in RSDT or XSDT.
1210
1211 @param Sdt ACPI RSDT or XSDT.
1212 @param Signature ACPI table signature.
1213 @param TablePointerSize Size of table pointer: 4 or 8.
1214
1215 @return ACPI table or NULL if not found.
1216 **/
1217 VOID *
1218 ScanTableInSDT (
1219 IN EFI_ACPI_DESCRIPTION_HEADER *Sdt,
1220 IN UINT32 Signature,
1221 IN UINTN TablePointerSize
1222 )
1223 {
1224 UINTN Index;
1225 UINTN EntryCount;
1226 UINTN EntryBase;
1227 EFI_ACPI_DESCRIPTION_HEADER *Table;
1228
1229 EntryCount = (Sdt->Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / TablePointerSize;
1230
1231 EntryBase = (UINTN) (Sdt + 1);
1232 for (Index = 0; Index < EntryCount; Index++) {
1233 //
1234 // When TablePointerSize is 4 while sizeof (VOID *) is 8, make sure the upper 4 bytes are zero.
1235 //
1236 Table = 0;
1237 CopyMem (&Table, (VOID *) (EntryBase + Index * TablePointerSize), TablePointerSize);
1238 if (Table->Signature == Signature) {
1239 return Table;
1240 }
1241 }
1242
1243 return NULL;
1244 }
1245
1246 /**
1247 Notification function of ACPI Table change.
1248
1249 This is a notification function registered on ACPI Table change event.
1250 It saves the Century address stored in ACPI FADT table.
1251
1252 @param Event Event whose notification function is being invoked.
1253 @param Context Pointer to the notification function's context.
1254
1255 **/
1256 VOID
1257 EFIAPI
1258 PcRtcAcpiTableChangeCallback (
1259 IN EFI_EVENT Event,
1260 IN VOID *Context
1261 )
1262 {
1263 EFI_STATUS Status;
1264 EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp;
1265 EFI_ACPI_DESCRIPTION_HEADER *Rsdt;
1266 EFI_ACPI_DESCRIPTION_HEADER *Xsdt;
1267 EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *Fadt;
1268 EFI_TIME Time;
1269 UINT8 Century;
1270
1271 Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **) &Rsdp);
1272 if (EFI_ERROR (Status)) {
1273 Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **) &Rsdp);
1274 }
1275
1276 if (EFI_ERROR (Status)) {
1277 return;
1278 }
1279
1280 ASSERT (Rsdp != NULL);
1281
1282 //
1283 // Find FADT in XSDT
1284 //
1285 Fadt = NULL;
1286 if (Rsdp->Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION) {
1287 Xsdt = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN) Rsdp->XsdtAddress;
1288 Fadt = ScanTableInSDT (Xsdt, EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE, sizeof (UINT64));
1289 }
1290
1291 if (Fadt == NULL) {
1292 //
1293 // Find FADT in RSDT
1294 //
1295 Rsdt = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN) Rsdp->RsdtAddress;
1296 Fadt = ScanTableInSDT (Rsdt, EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE, sizeof (UINT32));
1297 }
1298
1299 if ((Fadt != NULL) &&
1300 (Fadt->Century > RTC_ADDRESS_REGISTER_D) && (Fadt->Century < 0x80) &&
1301 (mModuleGlobal.CenturyRtcAddress != Fadt->Century)
1302 ) {
1303 mModuleGlobal.CenturyRtcAddress = Fadt->Century;
1304 Status = PcRtcGetTime (&Time, NULL, &mModuleGlobal);
1305 if (!EFI_ERROR (Status)) {
1306 Century = (UINT8) (Time.Year / 100);
1307 Century = DecimalToBcd8 (Century);
1308 DEBUG ((EFI_D_INFO, "PcRtc: Write 0x%x to CMOS location 0x%x\n", Century, mModuleGlobal.CenturyRtcAddress));
1309 RtcWrite (mModuleGlobal.CenturyRtcAddress, Century);
1310 }
1311 }
1312 }
EFI Development Kit II mirror for PVE