Move PcatRealTimeClockRuntimeDxe driver to PcAtChipsetPkg

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8766 6f19259b-4bc3-4df7-8a09-765794883524

4 files changed, 1643 insertions, 0 deletions

diff --git a/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.c b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.c
new file mode 100644
index 0000000..d26e923
--- /dev/null
+++ b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.c
@@ -0,0 +1,1059 @@
+/** @file

+  RTC Architectural Protocol GUID as defined in DxeCis 0.96.

+

+Copyright (c) 2006 - 2007, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "PcRtc.h"

+

+/**

+  Compare the Hour, Minute and Second of the From time and the To time.

+  

+  Only compare H/M/S in EFI_TIME and ignore other fields here.

+

+  @param From   the first time

+  @param To     the second time

+

+  @return  >0   The H/M/S of the From time is later than those of To time

+  @return  ==0  The H/M/S of the From time is same as those of To time

+  @return  <0   The H/M/S of the From time is earlier than those of To time

+**/

+INTN

+CompareHMS (

+  IN EFI_TIME   *From,

+  IN EFI_TIME   *To

+  );

+

+/**

+  To check if second date is later than first date within 24 hours.

+

+  @param  From   the first date

+  @param  To     the second date

+

+  @retval TRUE   From is previous to To within 24 hours.

+  @retval FALSE  From is later, or it is previous to To more than 24 hours.

+**/

+BOOLEAN

+IsWithinOneDay (

+  IN EFI_TIME   *From,

+  IN EFI_TIME   *To

+  );

+

+/**

+  Read RTC content through its registers.

+

+  @param  Address  Address offset of RTC. It is recommended to use macros such as

+                   RTC_ADDRESS_SECONDS.

+

+  @return The data of UINT8 type read from RTC.

+**/

+UINT8

+RtcRead (

+  IN  UINT8 Address

+  )

+{

+  IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));

+  return IoRead8 (PCAT_RTC_DATA_REGISTER);

+}

+

+/**

+  Write RTC through its registers.

+

+  @param  Address  Address offset of RTC. It is recommended to use macros such as

+                   RTC_ADDRESS_SECONDS.

+  @param  Data     The content you want to write into RTC.

+

+**/

+VOID

+RtcWrite (

+  IN  UINT8   Address,

+  IN  UINT8   Data

+  )

+{

+  IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));

+  IoWrite8 (PCAT_RTC_DATA_REGISTER, Data);

+}

+

+/**

+  Initialize RTC.

+

+  @param  Global            For global use inside this module.

+

+  @retval EFI_DEVICE_ERROR  Initialization failed due to device error.

+  @retval EFI_SUCCESS       Initialization successful.

+

+**/

+EFI_STATUS

+PcRtcInit (

+  IN PC_RTC_MODULE_GLOBALS  *Global

+  )

+{

+  EFI_STATUS      Status;

+  RTC_REGISTER_A  RegisterA;

+  RTC_REGISTER_B  RegisterB;

+  RTC_REGISTER_D  RegisterD;

+  UINT8           Century;

+  EFI_TIME        Time;

+  UINTN           DataSize;

+  UINT32          TimerVar;

+

+  //

+  // Acquire RTC Lock to make access to RTC atomic

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (&Global->RtcLock);

+  }

+  //

+  // Initialize RTC Register

+  //

+  // Make sure Division Chain is properly configured,

+  // or RTC clock won't "tick" -- time won't increment

+  //

+  RegisterA.Data = RTC_INIT_REGISTER_A;

+  RtcWrite (RTC_ADDRESS_REGISTER_A, RegisterA.Data);

+

+  //

+  // Read Register B

+  //

+  RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);

+

+  //

+  // Clear RTC flag register

+  //

+  RtcRead (RTC_ADDRESS_REGISTER_C);

+

+  //

+  // Clear RTC register D

+  //

+  RegisterD.Data = RTC_INIT_REGISTER_D;

+  RtcWrite (RTC_ADDRESS_REGISTER_D, RegisterD.Data);

+

+  //

+  // Wait for up to 0.1 seconds for the RTC to be updated

+  //

+  Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));

+  if (EFI_ERROR (Status)) {

+    //Code here doesn't consider the runtime environment.

+    if (!EfiAtRuntime ()) {

+      EfiReleaseLock (&Global->RtcLock);

+    }

+    return EFI_DEVICE_ERROR;

+  }

+  //

+  // Get the Time/Date/Daylight Savings values.

+  //

+  Time.Second = RtcRead (RTC_ADDRESS_SECONDS);

+  Time.Minute = RtcRead (RTC_ADDRESS_MINUTES);

+  Time.Hour   = RtcRead (RTC_ADDRESS_HOURS);

+  Time.Day    = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);

+  Time.Month  = RtcRead (RTC_ADDRESS_MONTH);

+  Time.Year   = RtcRead (RTC_ADDRESS_YEAR);

+

+  Century = RtcRead (RTC_ADDRESS_CENTURY);

+  

+  //

+  // Set RTC configuration after get original time

+  // The value of bit AIE should be reserved.

+  //

+  RtcWrite (RTC_ADDRESS_REGISTER_B, (UINT8)(RTC_INIT_REGISTER_B | (RegisterB.Data & BIT5)));

+

+  //

+  // Release RTC Lock.

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+  }

+ 

+  //

+  // Validate time fields

+  //

+  Status = ConvertRtcTimeToEfiTime (&Time, Century, RegisterB);

+  if (!EFI_ERROR (Status)) {

+    Status = RtcTimeFieldsValid (&Time);

+  }

+  if (EFI_ERROR (Status)) {

+    Time.Second = RTC_INIT_SECOND;

+    Time.Minute = RTC_INIT_MINUTE;

+    Time.Hour   = RTC_INIT_HOUR;

+    Time.Day    = RTC_INIT_DAY;

+    Time.Month  = RTC_INIT_MONTH;

+    Time.Year   = RTC_INIT_YEAR;

+  }

+  //

+  // Get the data of Daylight saving and time zone, if they have been

+  // stored in NV variable during previous boot.

+  //

+  DataSize = sizeof (UINT32);

+  Status = EfiGetVariable (

+             L"RTC",

+             &gEfiCallerIdGuid,

+             NULL,

+             &DataSize,

+             (VOID *) &TimerVar

+             );

+  if (!EFI_ERROR (Status)) {

+    Global->SavedTimeZone = (INT16) TimerVar;

+    Global->Daylight      = (UINT8) (TimerVar >> 16);

+

+    Time.TimeZone = Global->SavedTimeZone;

+    Time.Daylight = Global->Daylight;

+  }

+  //

+  // Reset time value according to new RTC configuration

+  //

+  PcRtcSetTime (&Time, Global);

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Returns the current time and date information, and the time-keeping capabilities

+  of the hardware platform.

+

+  @param  Time          A pointer to storage to receive a snapshot of the current time.

+  @param  Capabilities  An optional pointer to a buffer to receive the real time clock

+                        device's capabilities.

+  @param  Global        For global use inside this module.

+

+  @retval EFI_SUCCESS            The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER  Time is NULL.

+  @retval EFI_DEVICE_ERROR       The time could not be retrieved due to hardware error.

+

+**/

+EFI_STATUS

+PcRtcGetTime (

+  OUT  EFI_TIME               *Time,

+  OUT  EFI_TIME_CAPABILITIES  *Capabilities,  OPTIONAL

+  IN   PC_RTC_MODULE_GLOBALS  *Global

+  )

+{

+  EFI_STATUS      Status;

+  RTC_REGISTER_B  RegisterB;

+  UINT8           Century;

+

+  //

+  // Check parameters for null pointer

+  //

+  if (Time == NULL) {

+    return EFI_INVALID_PARAMETER;

+

+  }

+  //

+  // Acquire RTC Lock to make access to RTC atomic

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (&Global->RtcLock);

+  }

+  //

+  // Wait for up to 0.1 seconds for the RTC to be updated

+  //

+  Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));

+  if (EFI_ERROR (Status)) {

+      //Code here doesn't consider the runtime environment.

+      if (!EfiAtRuntime ()) {

+        EfiReleaseLock (&Global->RtcLock);

+      }

+    return Status;

+  }

+  //

+  // Read Register B

+  //

+  RegisterB.Data = RtcRead (RTC_ADDRESS_REGISTER_B);

+

+  //

+  // Get the Time/Date/Daylight Savings values.

+  //

+  Time->Second  = RtcRead (RTC_ADDRESS_SECONDS);

+  Time->Minute  = RtcRead (RTC_ADDRESS_MINUTES);

+  Time->Hour    = RtcRead (RTC_ADDRESS_HOURS);

+  Time->Day     = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);

+  Time->Month   = RtcRead (RTC_ADDRESS_MONTH);

+  Time->Year    = RtcRead (RTC_ADDRESS_YEAR);

+

+  Century = RtcRead (RTC_ADDRESS_CENTURY);

+  

+  //

+  // Release RTC Lock.

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+  }

+  //

+  // Get the variable that contains the TimeZone and Daylight fields

+  //

+  Time->TimeZone  = Global->SavedTimeZone;

+  Time->Daylight  = Global->Daylight;

+

+  //

+  // Make sure all field values are in correct range

+  //

+  Status = ConvertRtcTimeToEfiTime (Time, Century, RegisterB);

+  if (!EFI_ERROR (Status)) {

+    Status = RtcTimeFieldsValid (Time);

+  }

+  if (EFI_ERROR (Status)) {

+    return EFI_DEVICE_ERROR;

+  }

+  //

+  //  Fill in Capabilities if it was passed in

+  //

+  if (Capabilities != NULL) {

+    Capabilities->Resolution = 1;

+    //

+    // 1 hertz

+    //

+    Capabilities->Accuracy = 50000000;

+    //

+    // 50 ppm

+    //

+    Capabilities->SetsToZero = FALSE;

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Sets the current local time and date information.

+

+  @param  Time                  A pointer to the current time.

+  @param  Global                For global use inside this module.

+

+  @retval EFI_SUCCESS           The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The time could not be set due due to hardware error.

+

+**/

+EFI_STATUS

+PcRtcSetTime (

+  IN EFI_TIME                *Time,

+  IN PC_RTC_MODULE_GLOBALS   *Global

+  )

+{

+  EFI_STATUS      Status;

+  EFI_TIME        RtcTime;

+  RTC_REGISTER_B  RegisterB;

+  UINT8           Century;

+  UINT32          TimerVar;

+

+  if (Time == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+  //

+  // Make sure that the time fields are valid

+  //

+  Status = RtcTimeFieldsValid (Time);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  CopyMem (&RtcTime, Time, sizeof (EFI_TIME));

+

+  //

+  // Acquire RTC Lock to make access to RTC atomic

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (&Global->RtcLock);

+  }

+  //

+  // Wait for up to 0.1 seconds for the RTC to be updated

+  //

+  Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));

+  if (EFI_ERROR (Status)) {

+     //Code here doesn't consider the runtime environment.

+     if (!EfiAtRuntime ()) {

+       EfiReleaseLock (&Global->RtcLock);

+     }

+    return Status;

+  }

+  //

+  // Read Register B, and inhibit updates of the RTC

+  //

+  RegisterB.Data      = RtcRead (RTC_ADDRESS_REGISTER_B);

+  RegisterB.Bits.SET  = 1;

+  RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);

+

+  ConvertEfiTimeToRtcTime (&RtcTime, RegisterB, &Century);

+

+  RtcWrite (RTC_ADDRESS_SECONDS, RtcTime.Second);

+  RtcWrite (RTC_ADDRESS_MINUTES, RtcTime.Minute);

+  RtcWrite (RTC_ADDRESS_HOURS, RtcTime.Hour);

+  RtcWrite (RTC_ADDRESS_DAY_OF_THE_MONTH, RtcTime.Day);

+  RtcWrite (RTC_ADDRESS_MONTH, RtcTime.Month);

+  RtcWrite (RTC_ADDRESS_YEAR, (UINT8) RtcTime.Year);

+  RtcWrite (RTC_ADDRESS_CENTURY, Century);

+

+  //

+  // Allow updates of the RTC registers

+  //

+  RegisterB.Bits.SET = 0;

+  RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);

+

+  //

+  // Release RTC Lock.

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+  }

+  //

+  // Set the variable that contains the TimeZone and Daylight fields

+  //

+  Global->SavedTimeZone = Time->TimeZone;

+  Global->Daylight      = Time->Daylight;

+

+  TimerVar = Time->Daylight;

+  TimerVar = (UINT32) ((TimerVar << 16) | Time->TimeZone);

+  Status =  EfiSetVariable (

+              L"RTC",

+              &gEfiCallerIdGuid,

+              EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,

+              sizeof (TimerVar),

+              &TimerVar

+              );

+  ASSERT_EFI_ERROR (Status);

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Returns the current wakeup alarm clock setting.

+

+  @param  Enabled  Indicates if the alarm is currently enabled or disabled.

+  @param  Pending  Indicates if the alarm signal is pending and requires acknowledgment.

+  @param  Time     The current alarm setting.

+  @param  Global   For global use inside this module.

+

+  @retval EFI_SUCCESS           The alarm settings were returned.

+  @retval EFI_INVALID_PARAMETER Enabled is NULL.

+  @retval EFI_INVALID_PARAMETER Pending is NULL.

+  @retval EFI_INVALID_PARAMETER Time is NULL.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+PcRtcGetWakeupTime (

+  OUT BOOLEAN                *Enabled,

+  OUT BOOLEAN                *Pending,

+  OUT EFI_TIME               *Time,

+  IN  PC_RTC_MODULE_GLOBALS  *Global

+  )

+{

+  EFI_STATUS      Status;

+  RTC_REGISTER_B  RegisterB;

+  RTC_REGISTER_C  RegisterC;

+  UINT8           Century;

+

+  //

+  // Check parameters for null pointers

+  //

+  if ((Enabled == NULL) || (Pending == NULL) || (Time == NULL)) {

+    return EFI_INVALID_PARAMETER;

+

+  }

+  //

+  // Acquire RTC Lock to make access to RTC atomic

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (&Global->RtcLock);

+  }

+  //

+  // Wait for up to 0.1 seconds for the RTC to be updated

+  //

+  Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));

+  if (EFI_ERROR (Status)) {

+    //Code here doesn't consider the runtime environment.

+    if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+    }

+    return EFI_DEVICE_ERROR;

+  }

+  //

+  // Read Register B and Register C

+  //

+  RegisterB.Data  = RtcRead (RTC_ADDRESS_REGISTER_B);

+  RegisterC.Data  = RtcRead (RTC_ADDRESS_REGISTER_C);

+

+  //

+  // Get the Time/Date/Daylight Savings values.

+  //

+  *Enabled = RegisterB.Bits.AIE;

+  if (*Enabled) {

+    Time->Second  = RtcRead (RTC_ADDRESS_SECONDS_ALARM);

+    Time->Minute  = RtcRead (RTC_ADDRESS_MINUTES_ALARM);

+    Time->Hour    = RtcRead (RTC_ADDRESS_HOURS_ALARM);

+    Time->Day     = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);

+    Time->Month   = RtcRead (RTC_ADDRESS_MONTH);

+    Time->Year    = RtcRead (RTC_ADDRESS_YEAR);

+  } else {

+    Time->Second  = 0;

+    Time->Minute  = 0;

+    Time->Hour    = 0;

+    Time->Day     = RtcRead (RTC_ADDRESS_DAY_OF_THE_MONTH);

+    Time->Month   = RtcRead (RTC_ADDRESS_MONTH);

+    Time->Year    = RtcRead (RTC_ADDRESS_YEAR);

+  }

+

+  Century = RtcRead (RTC_ADDRESS_CENTURY);

+  

+  //

+  // Release RTC Lock.

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+  }

+  //

+  // Make sure all field values are in correct range

+  //

+  Status = ConvertRtcTimeToEfiTime (Time, Century, RegisterB);

+  if (!EFI_ERROR (Status)) {

+    Status = RtcTimeFieldsValid (Time);

+  }

+  if (EFI_ERROR (Status)) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  *Pending = RegisterC.Bits.AF;

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Sets the system wakeup alarm clock time.

+

+  @param  Enabled  Enable or disable the wakeup alarm.

+  @param  Time     If Enable is TRUE, the time to set the wakeup alarm for.

+                   If Enable is FALSE, then this parameter is optional, and may be NULL.

+  @param  Global   For global use inside this module.

+

+  @retval EFI_SUCCESS           If Enable is TRUE, then the wakeup alarm was enabled.

+                                If Enable is FALSE, then the wakeup alarm was disabled.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be set due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+PcRtcSetWakeupTime (

+  IN BOOLEAN                Enable,

+  IN EFI_TIME               *Time,   OPTIONAL

+  IN PC_RTC_MODULE_GLOBALS  *Global

+  )

+{

+  EFI_STATUS            Status;

+  EFI_TIME              RtcTime;

+  RTC_REGISTER_B        RegisterB;

+  UINT8                 Century;

+  EFI_TIME_CAPABILITIES Capabilities;

+

+  if (Enable) {

+

+    if (Time == NULL) {

+      return EFI_INVALID_PARAMETER;

+    }

+    //

+    // Make sure that the time fields are valid

+    //

+    Status = RtcTimeFieldsValid (Time);

+    if (EFI_ERROR (Status)) {

+      return EFI_INVALID_PARAMETER;

+    }

+    //

+    // Just support set alarm time within 24 hours

+    //

+    PcRtcGetTime (&RtcTime, &Capabilities, Global);

+    Status = RtcTimeFieldsValid (&RtcTime);

+    if (EFI_ERROR (Status)) {

+      return EFI_DEVICE_ERROR;

+    }

+    if (!IsWithinOneDay (&RtcTime, Time)) {

+      return EFI_UNSUPPORTED;

+    }

+    //

+    // Make a local copy of the time and date

+    //

+    CopyMem (&RtcTime, Time, sizeof (EFI_TIME));

+

+  }

+  //

+  // Acquire RTC Lock to make access to RTC atomic

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (&Global->RtcLock);

+  }

+  //

+  // Wait for up to 0.1 seconds for the RTC to be updated

+  //

+  Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));

+  if (EFI_ERROR (Status)) {

+    //Code here doesn't consider the runtime environment.

+    if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+    }

+    return EFI_DEVICE_ERROR;

+  }

+  //

+  // Read Register B, and inhibit updates of the RTC

+  //

+  RegisterB.Data      = RtcRead (RTC_ADDRESS_REGISTER_B);

+

+  RegisterB.Bits.SET  = 1;

+  RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);

+

+  if (Enable) {

+    ConvertEfiTimeToRtcTime (&RtcTime, RegisterB, &Century);

+

+    //

+    // Set RTC alarm time

+    //

+    RtcWrite (RTC_ADDRESS_SECONDS_ALARM, RtcTime.Second);

+    RtcWrite (RTC_ADDRESS_MINUTES_ALARM, RtcTime.Minute);

+    RtcWrite (RTC_ADDRESS_HOURS_ALARM, RtcTime.Hour);

+

+    RegisterB.Bits.AIE = 1;

+

+  } else {

+    RegisterB.Bits.AIE = 0;

+  }

+  //

+  // Allow updates of the RTC registers

+  //

+  RegisterB.Bits.SET = 0;

+  RtcWrite (RTC_ADDRESS_REGISTER_B, RegisterB.Data);

+

+  //

+  // Release RTC Lock.

+  //

+  //Code here doesn't consider the runtime environment.

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (&Global->RtcLock);

+  }

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Checks an 8-bit BCD value, and converts to an 8-bit value if valid.

+

+  This function checks the 8-bit BCD value specified by Value.

+  If valid, the function converts it to an 8-bit value and returns it.

+  Otherwise, return 0xff.

+

+  @param   Value The 8-bit BCD value to check and convert

+

+  @return  The 8-bit value converted. Or 0xff if Value is invalid.

+

+**/

+UINT8

+CheckAndConvertBcd8ToDecimal8 (

+  IN  UINT8  Value

+  )

+{

+  if ((Value < 0xa0) && ((Value & 0xf) < 0xa)) {

+    return BcdToDecimal8 (Value);

+  }

+

+  return 0xff;

+}

+

+/**

+  Converts time read from RTC to EFI_TIME format defined by UEFI spec.

+

+  This function converts raw time data read from RTC to the EFI_TIME format

+  defined by UEFI spec.

+  If data mode of RTC is BCD, then converts it to decimal,

+  If RTC is in 12-hour format, then converts it to 24-hour format.

+

+  @param   Time       On input, the time data read from RTC to convert

+                      On output, the time converted to UEFI format

+  @param   Century    Value of century read from RTC.

+  @param   RegisterB  Value of Register B of RTC, indicating data mode

+                      and hour format.

+

+  @retval  EFI_INVALID_PARAMETER  Parameters passed in are invalid.

+  @retval  EFI_SUCCESS            Convert RTC time to EFI time successfully.

+

+**/

+EFI_STATUS

+ConvertRtcTimeToEfiTime (

+  IN OUT EFI_TIME        *Time,

+  IN     UINT8           Century,

+  IN     RTC_REGISTER_B  RegisterB

+  )

+{

+  BOOLEAN IsPM;

+

+  if ((Time->Hour & 0x80) != 0) {

+    IsPM = TRUE;

+  } else {

+    IsPM = FALSE;

+  }

+

+  Time->Hour = (UINT8) (Time->Hour & 0x7f);

+

+  if (RegisterB.Bits.DM == 0) {

+    Time->Year    = CheckAndConvertBcd8ToDecimal8 ((UINT8) Time->Year);

+    Time->Month   = CheckAndConvertBcd8ToDecimal8 (Time->Month);

+    Time->Day     = CheckAndConvertBcd8ToDecimal8 (Time->Day);

+    Time->Hour    = CheckAndConvertBcd8ToDecimal8 (Time->Hour);

+    Time->Minute  = CheckAndConvertBcd8ToDecimal8 (Time->Minute);

+    Time->Second  = CheckAndConvertBcd8ToDecimal8 (Time->Second);

+  }

+  Century       = CheckAndConvertBcd8ToDecimal8 (Century);

+

+  if (Time->Year == 0xff || Time->Month == 0xff || Time->Day == 0xff ||

+      Time->Hour == 0xff || Time->Minute == 0xff || Time->Second == 0xff ||

+      Century == 0xff) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  Time->Year = (UINT16) (Century * 100 + Time->Year);

+

+  //

+  // If time is in 12 hour format, convert it to 24 hour format

+  //

+  if (RegisterB.Bits.MIL == 0) {

+    if (IsPM && Time->Hour < 12) {

+      Time->Hour = (UINT8) (Time->Hour + 12);

+    }

+

+    if (!IsPM && Time->Hour == 12) {

+      Time->Hour = 0;

+    }

+  }

+

+  Time->Nanosecond  = 0;

+  Time->TimeZone    = EFI_UNSPECIFIED_TIMEZONE;

+  Time->Daylight    = 0;

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Wait for a period for the RTC to be ready.

+

+  @param    Timeout  Tell how long it should take to wait.

+

+  @retval   EFI_DEVICE_ERROR   RTC device error.

+  @retval   EFI_SUCCESS        RTC is updated and ready.  

+**/

+EFI_STATUS

+RtcWaitToUpdate (

+  UINTN Timeout

+  )

+{

+  RTC_REGISTER_A  RegisterA;

+  RTC_REGISTER_D  RegisterD;

+

+  //

+  // See if the RTC is functioning correctly

+  //

+  RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);

+

+  if (RegisterD.Bits.VRT == 0) {

+    return EFI_DEVICE_ERROR;

+  }

+  //

+  // Wait for up to 0.1 seconds for the RTC to be ready.

+  //

+  Timeout         = (Timeout / 10) + 1;

+  RegisterA.Data  = RtcRead (RTC_ADDRESS_REGISTER_A);

+  while (RegisterA.Bits.UIP == 1 && Timeout > 0) {

+    MicroSecondDelay (10);

+    RegisterA.Data = RtcRead (RTC_ADDRESS_REGISTER_A);

+    Timeout--;

+  }

+

+  RegisterD.Data = RtcRead (RTC_ADDRESS_REGISTER_D);

+  if (Timeout == 0 || RegisterD.Bits.VRT == 0) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

+  See if all fields of a variable of EFI_TIME type is correct.

+

+  @param   Time   The time to be checked.

+

+  @retval  EFI_INVALID_PARAMETER  Some fields of Time are not correct.

+  @retval  EFI_SUCCESS            Time is a valid EFI_TIME variable.

+

+**/

+EFI_STATUS

+RtcTimeFieldsValid (

+  IN EFI_TIME *Time

+  )

+{

+  if (Time->Year < 1998 ||

+      Time->Year > 2099 ||

+      Time->Month < 1 ||

+      Time->Month > 12 ||

+      Time->Hour > 23 ||

+      Time->Minute > 59 ||

+      Time->Second > 59 ||

+      Time->Nanosecond > 999999999 ||

+      (!(Time->TimeZone == EFI_UNSPECIFIED_TIMEZONE || (Time->TimeZone >= -1440 && Time->TimeZone <= 1440))) ||

+      ((Time->Daylight & (~(EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT))) != 0)

+      ) {

+    if (!DayValid (Time)) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

+  See if field Day of an EFI_TIME is correct.

+

+  @param    Time   Its Day field is to be checked.

+

+  @retval   TRUE   Day field of Time is correct.

+  @retval   FALSE  Day field of Time is NOT correct.

+**/

+BOOLEAN

+DayValid (

+  IN  EFI_TIME  *Time

+  )

+{

+  INTN  DayOfMonth[12];

+

+  DayOfMonth[0] = 31;

+  DayOfMonth[1] = 29;

+  DayOfMonth[2] = 31;

+  DayOfMonth[3] = 30;

+  DayOfMonth[4] = 31;

+  DayOfMonth[5] = 30;

+  DayOfMonth[6] = 31;

+  DayOfMonth[7] = 31;

+  DayOfMonth[8] = 30;

+  DayOfMonth[9] = 31;

+  DayOfMonth[10] = 30;

+  DayOfMonth[11] = 31;

+

+  //

+  // The validity of Time->Month field should be checked before

+  //

+  ASSERT (Time->Month >=1);

+  ASSERT (Time->Month <=12);

+  if (Time->Day < 1 ||

+      Time->Day > DayOfMonth[Time->Month - 1] ||

+      (Time->Month == 2 && (!IsLeapYear (Time) && Time->Day > 28))

+      ) {

+    return FALSE;

+  }

+

+  return TRUE;

+}

+

+/**

+  Check if it is a leap year.

+

+  @param    Time   The time to be checked.

+

+  @retval   TRUE   It is a leap year.

+  @retval   FALSE  It is NOT a leap year.

+**/

+BOOLEAN

+IsLeapYear (

+  IN EFI_TIME   *Time

+  )

+{

+  if (Time->Year % 4 == 0) {

+    if (Time->Year % 100 == 0) {

+      if (Time->Year % 400 == 0) {

+        return TRUE;

+      } else {

+        return FALSE;

+      }

+    } else {

+      return TRUE;

+    }

+  } else {

+    return FALSE;

+  }

+}

+

+/**

+  Converts time from EFI_TIME format defined by UEFI spec to RTC's.

+

+  This function converts time from EFI_TIME format defined by UEFI spec to RTC's.

+  If data mode of RTC is BCD, then converts EFI_TIME to it.

+  If RTC is in 12-hour format, then converts EFI_TIME to it.

+

+  @param   Time       On input, the time data read from UEFI to convert

+                      On output, the time converted to RTC format

+  @param   RegisterB  Value of Register B of RTC, indicating data mode

+  @param   Century    It is set according to EFI_TIME Time.

+

+**/

+VOID

+ConvertEfiTimeToRtcTime (

+  IN OUT EFI_TIME        *Time,

+  IN     RTC_REGISTER_B  RegisterB,

+     OUT UINT8           *Century

+  )

+{

+  BOOLEAN IsPM;

+

+  IsPM = TRUE;

+  //

+  // Adjust hour field if RTC is in 12 hour mode

+  //

+  if (RegisterB.Bits.MIL == 0) {

+    if (Time->Hour < 12) {

+      IsPM = FALSE;

+    }

+

+    if (Time->Hour >= 13) {

+      Time->Hour = (UINT8) (Time->Hour - 12);

+    } else if (Time->Hour == 0) {

+      Time->Hour = 12;

+    }

+  }

+  //

+  // Set the Time/Date/Daylight Savings values.

+  //

+  *Century    = DecimalToBcd8 ((UINT8) (Time->Year / 100));

+

+  Time->Year  = (UINT16) (Time->Year % 100);

+

+  if (RegisterB.Bits.DM == 0) {

+    Time->Year    = DecimalToBcd8 ((UINT8) Time->Year);

+    Time->Month   = DecimalToBcd8 (Time->Month);

+    Time->Day     = DecimalToBcd8 (Time->Day);

+    Time->Hour    = DecimalToBcd8 (Time->Hour);

+    Time->Minute  = DecimalToBcd8 (Time->Minute);

+    Time->Second  = DecimalToBcd8 (Time->Second);

+  }

+  //

+  // If we are in 12 hour mode and PM is set, then set bit 7 of the Hour field.

+  //

+  if (RegisterB.Bits.MIL == 0 && IsPM) {

+    Time->Hour = (UINT8) (Time->Hour | 0x80);

+  }

+}

+

+/**

+  Compare the Hour, Minute and Second of the From time and the To time.

+  

+  Only compare H/M/S in EFI_TIME and ignore other fields here.

+

+  @param From   the first time

+  @param To     the second time

+

+  @return  >0   The H/M/S of the From time is later than those of To time

+  @return  ==0  The H/M/S of the From time is same as those of To time

+  @return  <0   The H/M/S of the From time is earlier than those of To time

+**/

+INTN

+CompareHMS (

+  IN EFI_TIME   *From,

+  IN EFI_TIME   *To

+  )

+{

+  if ((From->Hour > To->Hour) ||

+     ((From->Hour == To->Hour) && (From->Minute > To->Minute)) ||

+     ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second > To->Second))) {

+    return 1;

+  } else if ((From->Hour == To->Hour) && (From->Minute == To->Minute) && (From->Second == To->Second)) {

+    return 0;

+  } else {

+    return -1;

+  }

+}

+

+/**

+  To check if second date is later than first date within 24 hours.

+

+  @param  From   the first date

+  @param  To     the second date

+

+  @retval TRUE   From is previous to To within 24 hours.

+  @retval FALSE  From is later, or it is previous to To more than 24 hours.

+**/

+BOOLEAN

+IsWithinOneDay (

+  IN EFI_TIME  *From,

+  IN EFI_TIME  *To

+  )

+{

+  UINT8   DayOfMonth[12];

+  BOOLEAN Adjacent;

+

+  DayOfMonth[0] = 31;

+  DayOfMonth[1] = 29;

+  DayOfMonth[2] = 31;

+  DayOfMonth[3] = 30;

+  DayOfMonth[4] = 31;

+  DayOfMonth[5] = 30;

+  DayOfMonth[6] = 31;

+  DayOfMonth[7] = 31;

+  DayOfMonth[8] = 30;

+  DayOfMonth[9] = 31;

+  DayOfMonth[10] = 30;

+  DayOfMonth[11] = 31;

+

+  Adjacent = FALSE;

+

+  //

+  // The validity of From->Month field should be checked before

+  //

+  ASSERT (From->Month >=1);

+  ASSERT (From->Month <=12);

+  

+  if (From->Year == To->Year) {

+    if (From->Month == To->Month) {

+      if ((From->Day + 1) == To->Day) {

+        if ((CompareHMS(From, To) >= 0)) {

+          Adjacent = TRUE;

+        }

+      } else if (From->Day == To->Day) {

+        if ((CompareHMS(From, To) <= 0)) {

+          Adjacent = TRUE;

+        }

+      }

+    } else if (((From->Month + 1) == To->Month) && (To->Day == 1)) {

+      if ((From->Month == 2) && !IsLeapYear(From)) {

+        if (From->Day == 28) {

+          if ((CompareHMS(From, To) >= 0)) {

+            Adjacent = TRUE;

+          }

+        }

+      } else if (From->Day == DayOfMonth[From->Month - 1]) {

+        if ((CompareHMS(From, To) >= 0)) {

+           Adjacent = TRUE;

+        }

+      }

+    }

+  } else if (((From->Year + 1) == To->Year) &&

+             (From->Month == 12) &&

+             (From->Day   == 31) &&

+             (To->Month   == 1)  &&

+             (To->Day     == 1)) {

+    if ((CompareHMS(From, To) >= 0)) {

+      Adjacent = TRUE;

+    }

+  }

+

+  return Adjacent;

+}

+

diff --git a/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.h b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.h
new file mode 100644
index 0000000..90cfa39
--- /dev/null
+++ b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.h
@@ -0,0 +1,364 @@
+/** @file

+  Header file for real time clock driver.

+

+Copyright (c) 2006 - 2007, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+

+#ifndef _RTC_H_

+#define _RTC_H_

+

+

+#include <Uefi.h>

+

+#include <Protocol/RealTimeClock.h>

+

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/IoLib.h>

+#include <Library/TimerLib.h>

+#include <Library/UefiDriverEntryPoint.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/PcdLib.h>

+

+

+typedef struct {

+  EFI_LOCK  RtcLock;

+  INT16     SavedTimeZone;

+  UINT8     Daylight;

+} PC_RTC_MODULE_GLOBALS;

+

+#define PCAT_RTC_ADDRESS_REGISTER 0x70

+#define PCAT_RTC_DATA_REGISTER    0x71

+

+//

+// Dallas DS12C887 Real Time Clock

+//

+#define RTC_ADDRESS_SECONDS           0   // R/W  Range 0..59

+#define RTC_ADDRESS_SECONDS_ALARM     1   // R/W  Range 0..59

+#define RTC_ADDRESS_MINUTES           2   // R/W  Range 0..59

+#define RTC_ADDRESS_MINUTES_ALARM     3   // R/W  Range 0..59

+#define RTC_ADDRESS_HOURS             4   // R/W  Range 1..12 or 0..23 Bit 7 is AM/PM

+#define RTC_ADDRESS_HOURS_ALARM       5   // R/W  Range 1..12 or 0..23 Bit 7 is AM/PM

+#define RTC_ADDRESS_DAY_OF_THE_WEEK   6   // R/W  Range 1..7

+#define RTC_ADDRESS_DAY_OF_THE_MONTH  7   // R/W  Range 1..31

+#define RTC_ADDRESS_MONTH             8   // R/W  Range 1..12

+#define RTC_ADDRESS_YEAR              9   // R/W  Range 0..99

+#define RTC_ADDRESS_REGISTER_A        10  // R/W[0..6]  R0[7]

+#define RTC_ADDRESS_REGISTER_B        11  // R/W

+#define RTC_ADDRESS_REGISTER_C        12  // RO

+#define RTC_ADDRESS_REGISTER_D        13  // RO

+#define RTC_ADDRESS_CENTURY           50  // R/W  Range 19..20 Bit 8 is R/W

+//

+// Date and time initial values.

+// They are used if the RTC values are invalid during driver initialization

+//

+#define RTC_INIT_SECOND 0

+#define RTC_INIT_MINUTE 0

+#define RTC_INIT_HOUR   0

+#define RTC_INIT_DAY    1

+#define RTC_INIT_MONTH  1

+#define RTC_INIT_YEAR   2001

+

+//

+// Register initial values

+//

+#define RTC_INIT_REGISTER_A 0x26

+#define RTC_INIT_REGISTER_B 0x02

+#define RTC_INIT_REGISTER_D 0x0

+

+#pragma pack(1)

+//

+// Register A

+//

+typedef struct {

+  UINT8 RS : 4;   // Rate Selection Bits

+  UINT8 DV : 3;   // Divisor

+  UINT8 UIP : 1;  // Update in progress

+} RTC_REGISTER_A_BITS;

+

+typedef union {

+  RTC_REGISTER_A_BITS Bits;

+  UINT8               Data;

+} RTC_REGISTER_A;

+

+//

+// Register B

+//

+typedef struct {

+  UINT8 DSE : 1;  // 0 - Daylight saving disabled  1 - Daylight savings enabled

+  UINT8 MIL : 1;  // 0 - 12 hour mode              1 - 24 hour mode

+  UINT8 DM : 1;   // 0 - BCD Format                1 - Binary Format

+  UINT8 SQWE : 1; // 0 - Disable SQWE output       1 - Enable SQWE output

+  UINT8 UIE : 1;  // 0 - Update INT disabled       1 - Update INT enabled

+  UINT8 AIE : 1;  // 0 - Alarm INT disabled        1 - Alarm INT Enabled

+  UINT8 PIE : 1;  // 0 - Periodic INT disabled     1 - Periodic INT Enabled

+  UINT8 SET : 1;  // 0 - Normal operation.         1 - Updates inhibited

+} RTC_REGISTER_B_BITS;

+

+typedef union {

+  RTC_REGISTER_B_BITS Bits;

+  UINT8               Data;

+} RTC_REGISTER_B;

+

+//

+// Register C

+//

+typedef struct {

+  UINT8 Reserved : 4; // Read as zero.  Can not be written.

+  UINT8 UF : 1;       // Update End Interrupt Flag

+  UINT8 AF : 1;       // Alarm Interrupt Flag

+  UINT8 PF : 1;       // Periodic Interrupt Flag

+  UINT8 IRQF : 1;     // Iterrupt Request Flag = PF & PIE | AF & AIE | UF & UIE

+} RTC_REGISTER_C_BITS;

+

+typedef union {

+  RTC_REGISTER_C_BITS Bits;

+  UINT8               Data;

+} RTC_REGISTER_C;

+

+//

+// Register D

+//

+typedef struct {

+  UINT8 Reserved : 7; // Read as zero.  Can not be written.

+  UINT8 VRT : 1;      // Valid RAM and Time

+} RTC_REGISTER_D_BITS;

+

+typedef union {

+  RTC_REGISTER_D_BITS Bits;

+  UINT8               Data;

+} RTC_REGISTER_D;

+

+#pragma pack()

+

+/**

+  Initialize RTC.

+

+  @param  Global            For global use inside this module.

+

+  @retval EFI_DEVICE_ERROR  Initialization failed due to device error.

+  @retval EFI_SUCCESS       Initialization successful.

+

+**/

+EFI_STATUS

+PcRtcInit (

+  IN PC_RTC_MODULE_GLOBALS  *Global

+  );

+

+/**

+  Sets the current local time and date information.

+

+  @param  Time                  A pointer to the current time.

+  @param  Global                For global use inside this module.

+

+  @retval EFI_SUCCESS           The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The time could not be set due due to hardware error.

+

+**/

+EFI_STATUS

+PcRtcSetTime (

+  IN EFI_TIME               *Time,

+  IN PC_RTC_MODULE_GLOBALS  *Global

+  );

+

+/**

+  Returns the current time and date information, and the time-keeping capabilities

+  of the hardware platform.

+

+  @param  Time          A pointer to storage to receive a snapshot of the current time.

+  @param  Capabilities  An optional pointer to a buffer to receive the real time clock

+                        device's capabilities.

+  @param  Global        For global use inside this module.

+

+  @retval EFI_SUCCESS            The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER  Time is NULL.

+  @retval EFI_DEVICE_ERROR       The time could not be retrieved due to hardware error.

+

+**/

+EFI_STATUS

+PcRtcGetTime (

+  OUT EFI_TIME              *Time,

+  OUT EFI_TIME_CAPABILITIES *Capabilities, OPTIONAL

+  IN  PC_RTC_MODULE_GLOBALS *Global

+  );

+

+/**

+  Sets the system wakeup alarm clock time.

+

+  @param  Enabled  Enable or disable the wakeup alarm.

+  @param  Time     If Enable is TRUE, the time to set the wakeup alarm for.

+                   If Enable is FALSE, then this parameter is optional, and may be NULL.

+  @param  Global   For global use inside this module.

+

+  @retval EFI_SUCCESS           If Enable is TRUE, then the wakeup alarm was enabled.

+                                If Enable is FALSE, then the wakeup alarm was disabled.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be set due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+PcRtcSetWakeupTime (

+  IN BOOLEAN                Enable,

+  IN EFI_TIME               *Time,  OPTIONAL

+  IN PC_RTC_MODULE_GLOBALS  *Global

+  );

+

+/**

+  Returns the current wakeup alarm clock setting.

+

+  @param  Enabled  Indicates if the alarm is currently enabled or disabled.

+  @param  Pending  Indicates if the alarm signal is pending and requires acknowledgement.

+  @param  Time     The current alarm setting.

+  @param  Global   For global use inside this module.

+

+  @retval EFI_SUCCESS           The alarm settings were returned.

+  @retval EFI_INVALID_PARAMETER Enabled is NULL.

+  @retval EFI_INVALID_PARAMETER Pending is NULL.

+  @retval EFI_INVALID_PARAMETER Time is NULL.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+PcRtcGetWakeupTime (

+  OUT BOOLEAN               *Enabled,

+  OUT BOOLEAN               *Pending,

+  OUT EFI_TIME              *Time,

+  IN  PC_RTC_MODULE_GLOBALS *Global

+  );

+

+/**

+  The user Entry Point for PcRTC module.

+

+  This is the entrhy point for PcRTC module. It installs the UEFI runtime service

+  including GetTime(),SetTime(),GetWakeupTime(),and SetWakeupTime().

+

+  @param  ImageHandle    The firmware allocated handle for the EFI image.

+  @param  SystemTable    A pointer to the EFI System Table.

+

+  @retval EFI_SUCCESS    The entry point is executed successfully.

+  @retval Others         Some error occurs when executing this entry point.

+

+**/

+EFI_STATUS

+EFIAPI

+InitializePcRtc (

+  IN EFI_HANDLE                            ImageHandle,

+  IN EFI_SYSTEM_TABLE                      *SystemTable

+  );

+

+/**

+  See if all fields of a variable of EFI_TIME type is correct.

+

+  @param   Time   The time to be checked.

+

+  @retval  EFI_INVALID_PARAMETER  Some fields of Time are not correct.

+  @retval  EFI_SUCCESS            Time is a valid EFI_TIME variable.

+

+**/

+EFI_STATUS

+RtcTimeFieldsValid (

+  IN EFI_TIME *Time

+  );

+

+/**

+  Converts time from EFI_TIME format defined by UEFI spec to RTC's.

+

+  This function converts time from EFI_TIME format defined by UEFI spec to RTC's.

+  If data mode of RTC is BCD, then converts EFI_TIME to it.

+  If RTC is in 12-hour format, then converts EFI_TIME to it.

+

+  @param   Time       On input, the time data read from UEFI to convert

+                      On output, the time converted to RTC format

+  @param   RegisterB  Value of Register B of RTC, indicating data mode

+  @param   Century    It is set according to EFI_TIME Time.

+

+**/

+VOID

+ConvertEfiTimeToRtcTime (

+  IN OUT EFI_TIME        *Time,

+  IN     RTC_REGISTER_B  RegisterB,

+  OUT    UINT8           *Century

+  );

+

+

+/**

+  Converts time read from RTC to EFI_TIME format defined by UEFI spec.

+

+  This function converts raw time data read from RTC to the EFI_TIME format

+  defined by UEFI spec.

+  If data mode of RTC is BCD, then converts it to decimal,

+  If RTC is in 12-hour format, then converts it to 24-hour format.

+

+  @param   Time       On input, the time data read from RTC to convert

+                      On output, the time converted to UEFI format

+  @param   Century    Value of century read from RTC.

+  @param   RegisterB  Value of Register B of RTC, indicating data mode

+                      and hour format.

+

+  @retval  EFI_INVALID_PARAMETER  Parameters passed in are invalid.

+  @retval  EFI_SUCCESS            Convert RTC time to EFI time successfully.

+

+**/

+EFI_STATUS

+ConvertRtcTimeToEfiTime (

+  IN OUT EFI_TIME        *Time,

+  IN     UINT8           Century,

+  IN     RTC_REGISTER_B  RegisterB

+  );

+

+/**

+  Wait for a period for the RTC to be ready.

+

+  @param    Timeout  Tell how long it should take to wait.

+

+  @retval   EFI_DEVICE_ERROR   RTC device error.

+  @retval   EFI_SUCCESS        RTC is updated and ready.  

+**/

+EFI_STATUS

+RtcWaitToUpdate (

+  UINTN Timeout

+  );

+

+/**

+  See if field Day of an EFI_TIME is correct.

+

+  @param    Time   Its Day field is to be checked.

+

+  @retval   TRUE   Day field of Time is correct.

+  @retval   FALSE  Day field of Time is NOT correct.

+**/

+BOOLEAN

+DayValid (

+  IN  EFI_TIME  *Time

+  );

+

+/**

+  Check if it is a leapyear.

+

+  @param    Time   The time to be checked.

+

+  @retval   TRUE   It is a leapyear.

+  @retval   FALSE  It is NOT a leapyear.

+**/

+BOOLEAN

+IsLeapYear (

+  IN EFI_TIME   *Time

+  );

+

+#endif

diff --git a/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtcEntry.c b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtcEntry.c
new file mode 100644
index 0000000..ce3fa90
--- /dev/null
+++ b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtcEntry.c
@@ -0,0 +1,158 @@
+/** @file

+  Provides Set/Get time operations.

+

+Copyright (c) 2006 - 2008, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "PcRtc.h"

+

+PC_RTC_MODULE_GLOBALS  mModuleGlobal;

+

+EFI_HANDLE             mHandle = NULL;

+

+

+/**

+  Returns the current time and date information, and the time-keeping capabilities

+  of the hardware platform.

+

+  @param  Time          A pointer to storage to receive a snapshot of the current time.

+  @param  Capabilities  An optional pointer to a buffer to receive the real time

+                        clock device's capabilities.

+

+  @retval EFI_SUCCESS            The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER  Time is NULL.

+  @retval EFI_DEVICE_ERROR       The time could not be retrieved due to hardware error.

+

+**/

+EFI_STATUS

+EFIAPI

+PcRtcEfiGetTime (

+  OUT EFI_TIME                *Time,

+  OUT EFI_TIME_CAPABILITIES   *Capabilities  OPTIONAL

+  )

+{

+  return PcRtcGetTime (Time, Capabilities, &mModuleGlobal);

+}

+

+/**

+  Sets the current local time and date information.

+

+  @param  Time                   A pointer to the current time.

+

+  @retval EFI_SUCCESS            The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER  A time field is out of range.

+  @retval EFI_DEVICE_ERROR       The time could not be set due due to hardware error.

+

+**/

+EFI_STATUS

+EFIAPI

+PcRtcEfiSetTime (

+  IN EFI_TIME                *Time

+  )

+{

+  return PcRtcSetTime (Time, &mModuleGlobal);

+}

+

+/**

+  Returns the current wakeup alarm clock setting.

+

+  @param  Enabled  Indicates if the alarm is currently enabled or disabled.

+  @param  Pending  Indicates if the alarm signal is pending and requires acknowledgement.

+  @param  Time     The current alarm setting.

+

+  @retval EFI_SUCCESS           The alarm settings were returned.

+  @retval EFI_INVALID_PARAMETER Enabled is NULL.

+  @retval EFI_INVALID_PARAMETER Pending is NULL.

+  @retval EFI_INVALID_PARAMETER Time is NULL.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+EFIAPI

+PcRtcEfiGetWakeupTime (

+  OUT BOOLEAN     *Enabled,

+  OUT BOOLEAN     *Pending,

+  OUT EFI_TIME    *Time

+  )

+{

+  return PcRtcGetWakeupTime (Enabled, Pending, Time, &mModuleGlobal);

+}

+

+

+/**

+  Sets the system wakeup alarm clock time.

+

+  @param  Enabled  Enable or disable the wakeup alarm.

+  @param  Time     If Enable is TRUE, the time to set the wakeup alarm for.

+                   If Enable is FALSE, then this parameter is optional, and may be NULL.

+

+  @retval EFI_SUCCESS            If Enable is TRUE, then the wakeup alarm was enabled.

+                                 If Enable is FALSE, then the wakeup alarm was disabled.

+  @retval EFI_INVALID_PARAMETER  A time field is out of range.

+  @retval EFI_DEVICE_ERROR       The wakeup time could not be set due to a hardware error.

+  @retval EFI_UNSUPPORTED        A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+EFIAPI

+PcRtcEfiSetWakeupTime (

+  IN BOOLEAN      Enabled,

+  IN EFI_TIME    *Time       OPTIONAL

+  )

+{

+  return PcRtcSetWakeupTime (Enabled, Time, &mModuleGlobal);

+}

+

+/**

+  The user Entry Point for PcRTC module.

+

+  This is the entrhy point for PcRTC module. It installs the UEFI runtime service

+  including GetTime(),SetTime(),GetWakeupTime(),and SetWakeupTime().

+

+  @param  ImageHandle    The firmware allocated handle for the EFI image.

+  @param  SystemTable    A pointer to the EFI System Table.

+

+  @retval EFI_SUCCESS    The entry point is executed successfully.

+  @retval Others         Some error occurs when executing this entry point.

+

+**/

+EFI_STATUS

+EFIAPI

+InitializePcRtc (

+  IN EFI_HANDLE                            ImageHandle,

+  IN EFI_SYSTEM_TABLE                      *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+

+  EfiInitializeLock (&mModuleGlobal.RtcLock, TPL_HIGH_LEVEL);

+

+  Status = PcRtcInit (&mModuleGlobal);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  gRT->GetTime       = PcRtcEfiGetTime;

+  gRT->SetTime       = PcRtcEfiSetTime;

+  gRT->GetWakeupTime = PcRtcEfiGetWakeupTime;

+  gRT->SetWakeupTime = PcRtcEfiSetWakeupTime;

+

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &mHandle,

+                  &gEfiRealTimeClockArchProtocolGuid,

+                  NULL,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

diff --git a/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcatRealTimeClockRuntimeDxe.inf b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcatRealTimeClockRuntimeDxe.inf
new file mode 100644
index 0000000..e9cdf48
--- /dev/null
+++ b/PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcatRealTimeClockRuntimeDxe.inf
@@ -0,0 +1,62 @@
+#/** @file

+#

+#  PcRtc driver to install EFI_REAL_TIME_CLOCK_ARCH_PROTOCOL.

+#

+#  This driver provides GetTime, SetTime, GetWakeupTime, SetWakeupTime services to Runtime Service Table.

+#  It will install a tagging protocol with gEfiRealTimeClockArchProtocolGuid.

+#

+#  Copyright (c) 2006 - 2008 Intel Corporation. <BR>

+#  All rights reserved. This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PcRtc

+  FILE_GUID                      = 378D7B65-8DA9-4773-B6E4-A47826A833E1

+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

+  VERSION_STRING                 = 1.0

+  ENTRY_POINT                    = InitializePcRtc

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64 EBC

+#

+

+[Sources.common]

+  PcRtcEntry.c

+  PcRtc.c

+  PcRtc.h

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+[LibraryClasses]

+  UefiRuntimeServicesTableLib

+  UefiRuntimeLib

+  UefiBootServicesTableLib

+  UefiDriverEntryPoint

+  TimerLib

+  IoLib

+  BaseMemoryLib

+  UefiLib

+  DebugLib

+  BaseLib

+  PcdLib

+

+[Protocols]

+  gEfiRealTimeClockArchProtocolGuid             ## PRODUCES

+

+[Depex]

+  gEfiVariableArchProtocolGuid AND gEfiVariableWriteArchProtocolGuid

+  

+[Pcd]

+  gEfiMdeModulePkgTokenSpaceGuid.PcdRealTimeClockUpdateTimeout         ## CONSUMES
\ No newline at end of file