tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove original PcRtc driver. 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8780 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
klu2 2009-07-07 06:37:13 +00:00
parent cb8df8c596
commit b32a23104c
4 changed files with 0 additions and 1663 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

993
PcAtChipsetPkg/PcRtc/RealTimeClock.c
View File

@ -1,993 +0,0 @@
/*++
Copyright (c) 2005 - 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.
Module Name:
PcRtc.c
Abstract:
RTC Architectural Protocol GUID as defined in EFI 2.0
--*/
#include "RealTimeClock.h"
BOOLEAN
DayValid (
IN EFI_TIME *Time
);
BOOLEAN
IsLeapYear (
IN EFI_TIME *Time
);
BOOLEAN
IsWithinOneDay (
IN EFI_TIME *From,
IN EFI_TIME *To
);
INTN
CompareHMS (
IN EFI_TIME *From,
IN EFI_TIME *To
);
INTN mDayOfMonth[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
UINT8
RtcRead (
IN UINT8 Address
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Address - TODO: add argument description
Returns:
TODO: add return values
--*/
{
IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));
return IoRead8 (PCAT_RTC_DATA_REGISTER);
}
INTN
CompareHMS (
IN EFI_TIME *From,
IN EFI_TIME *To
)
/*++
Routine Description:
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.
Arguments:
From - the first time
To - the second time
Returns:
>0 : The H/M/S of the 'From' time is later than those of 'To' time
==0 : The H/M/S of the 'From' time is same as those of 'To' time
<0 : The H/M/S of the 'From' time is earlier than those of 'To' time
--*/
{
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;
}
}
VOID
RtcWrite (
IN UINT8 Address,
IN UINT8 Data
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Address - TODO: add argument description
Data - TODO: add argument description
Returns:
TODO: add return values
--*/
{
IoWrite8 (PCAT_RTC_ADDRESS_REGISTER, (UINT8) (Address | (UINT8) (IoRead8 (PCAT_RTC_ADDRESS_REGISTER) & 0x80)));
IoWrite8 (PCAT_RTC_DATA_REGISTER, Data);
}
EFI_STATUS
PcRtcInit (
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Global - TODO: add argument description
Returns:
EFI_DEVICE_ERROR - TODO: Add description for return value
EFI_SUCCESS - TODO: Add description for return value
--*/
{
EFI_STATUS Status;
RTC_REGISTER_A RegisterA;
RTC_REGISTER_B RegisterB;
//RTC_REGISTER_C RegisterC;
RTC_REGISTER_D RegisterD;
UINT8 Century;
EFI_TIME Time;
//
// Acquire RTC Lock to make access to RTC atomic
//
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
//
//RegisterC.Data = 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
//
// KEN: BUGBUG following wait action will cause failure under vmware environment.
//
//Status = RtcWaitToUpdate (100000);
//if (EFI_ERROR (Status)) {
// 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);
ConvertRtcTimeToEfiTime (&Time, RegisterB);
Century = BcdToDecimal8 (RtcRead (RTC_ADDRESS_CENTURY));
Time.Year = (UINT16) (Century * 100 + Time.Year);
//
// Set RTC configuration after get original time
//
RtcWrite (RTC_ADDRESS_REGISTER_B, RTC_INIT_REGISTER_B);
//
// Release RTC Lock.
//
EfiReleaseLock (&Global->RtcLock);
//
// Validate time fields
//
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;
}
//
// Reset time value according to new RTC configuration
//
PcRtcSetTime (&Time, Global);
return EFI_SUCCESS;
}
EFI_STATUS
PcRtcGetTime (
OUT EFI_TIME *Time,
IN EFI_TIME_CAPABILITIES *Capabilities,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Time - add argument and description to function comment
// TODO: Capabilities - add argument and description to function comment
// TODO: Global - add argument and description to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_SUCCESS - add return value to function comment
{
EFI_STATUS Status;
RTC_REGISTER_B RegisterB;
UINT8 Century;
//UINTN BufferSize;
//
// Check parameters for null pointer
//
if (Time == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Acquire RTC Lock to make access to RTC atomic
//
EfiAcquireLock (&Global->RtcLock);
//
// Wait for up to 0.1 seconds for the RTC to be updated
//
Status = RtcWaitToUpdate (100000);
if (EFI_ERROR (Status)) {
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);
ConvertRtcTimeToEfiTime (Time, RegisterB);
Century = BcdToDecimal8 (RtcRead (RTC_ADDRESS_CENTURY));
Time->Year = (UINT16) (Century * 100 + Time->Year);
//
// Release RTC Lock.
//
EfiReleaseLock (&Global->RtcLock);
//
// Get the variable that containts the TimeZone and Daylight fields
//
Time->TimeZone = Global->SavedTimeZone;
Time->Daylight = Global->Daylight;
//BufferSize = sizeof (INT16) + sizeof (UINT8);
//
// Make sure all field values are in correct range
//
Status = RtcTimeFieldsValid (Time);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
//
// Fill in Capabilities if it was passed in
//
if (Capabilities) {
Capabilities->Resolution = 1;
//
// 1 hertz
//
Capabilities->Accuracy = 50000000;
//
// 50 ppm
//
Capabilities->SetsToZero = FALSE;
}
return EFI_SUCCESS;
}
EFI_STATUS
PcRtcSetTime (
IN EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Time - add argument and description to function comment
// TODO: Global - add argument and description to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
{
EFI_STATUS Status;
EFI_TIME RtcTime;
RTC_REGISTER_B RegisterB;
UINT8 Century;
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
//
EfiAcquireLock (&Global->RtcLock);
//
// Wait for up to 0.1 seconds for the RTC to be updated
//
Status = RtcWaitToUpdate (100000);
if (EFI_ERROR (Status)) {
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.
//
EfiReleaseLock (&Global->RtcLock);
//
// Set the variable that containts the TimeZone and Daylight fields
//
Global->SavedTimeZone = Time->TimeZone;
Global->Daylight = Time->Daylight;
return Status;
}
EFI_STATUS
EFIAPI
PcRtcGetWakeupTime (
OUT BOOLEAN *Enabled,
OUT BOOLEAN *Pending,
OUT EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Enabled - add argument and description to function comment
// TODO: Pending - add argument and description to function comment
// TODO: Time - add argument and description to function comment
// TODO: Global - add argument and description to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_SUCCESS - add return value to function comment
{
EFI_STATUS Status;
RTC_REGISTER_B RegisterB;
RTC_REGISTER_C RegisterC;
UINT8 Century;
//
// Check paramters for null pointers
//
if ((Enabled == NULL) || (Pending == NULL) || (Time == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Acquire RTC Lock to make access to RTC atomic
//
EfiAcquireLock (&Global->RtcLock);
//
// Wait for up to 0.1 seconds for the RTC to be updated
//
Status = RtcWaitToUpdate (100000);
if (EFI_ERROR (Status)) {
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);
}
ConvertRtcTimeToEfiTime (Time, RegisterB);
Century = BcdToDecimal8 (RtcRead (RTC_ADDRESS_CENTURY));
Time->Year = (UINT16) (Century * 100 + Time->Year);
//
// Release RTC Lock.
//
EfiReleaseLock (&Global->RtcLock);
//
// Make sure all field values are in correct range
//
Status = RtcTimeFieldsValid (Time);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
*Pending = RegisterC.Bits.AF;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
PcRtcSetWakeupTime (
IN BOOLEAN Enable,
OUT EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Enable - add argument and description to function comment
// TODO: Time - add argument and description to function comment
// TODO: Global - add argument and description to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
// TODO: EFI_UNSUPPORTED - add return value to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_SUCCESS - add return value to function comment
{
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);
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
//
EfiAcquireLock (&Global->RtcLock);
//
// Wait for up to 0.1 seconds for the RTC to be updated
//
Status = RtcWaitToUpdate (100000);
if (EFI_ERROR (Status)) {
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.
//
EfiReleaseLock (&Global->RtcLock);
return EFI_SUCCESS;
}
VOID
ConvertRtcTimeToEfiTime (
IN EFI_TIME *Time,
IN RTC_REGISTER_B RegisterB
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Time - add argument and description to function comment
// TODO: RegisterB - add argument and description to function comment
{
BOOLEAN PM;
if ((Time->Hour) & 0x80) {
PM = TRUE;
} else {
PM = FALSE;
}
Time->Hour = (UINT8) (Time->Hour & 0x7f);
if (RegisterB.Bits.DM == 0) {
Time->Year = BcdToDecimal8 ((UINT8) Time->Year);
Time->Month = BcdToDecimal8 (Time->Month);
Time->Day = BcdToDecimal8 (Time->Day);
Time->Hour = BcdToDecimal8 (Time->Hour);
Time->Minute = BcdToDecimal8 (Time->Minute);
Time->Second = BcdToDecimal8 (Time->Second);
}
//
// If time is in 12 hour format, convert it to 24 hour format
//
if (RegisterB.Bits.MIL == 0) {
if (PM && Time->Hour < 12) {
Time->Hour = (UINT8) (Time->Hour + 12);
}
if (!PM && Time->Hour == 12) {
Time->Hour = 0;
}
}
Time->Nanosecond = 0;
Time->TimeZone = EFI_UNSPECIFIED_TIMEZONE;
Time->Daylight = 0;
}
EFI_STATUS
RtcWaitToUpdate (
UINTN Timeout
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Timeout - add argument and description to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_DEVICE_ERROR - add return value to function comment
// TODO: EFI_SUCCESS - add return value to function comment
{
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;
}
EFI_STATUS
RtcTimeFieldsValid (
IN EFI_TIME *Time
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Time - add argument and description to function comment
// TODO: EFI_INVALID_PARAMETER - add return value to function comment
// TODO: EFI_SUCCESS - add return value to function comment
{
if (Time->Year < 1998 ||
Time->Year > 2099 ||
Time->Month < 1 ||
Time->Month > 12 ||
(!DayValid (Time)) ||
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)))
) {
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
BOOLEAN
DayValid (
IN EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
{
if (Time->Day < 1 ||
Time->Day > mDayOfMonth[Time->Month - 1] ||
(Time->Month == 2 && (!IsLeapYear (Time) && Time->Day > 28))
) {
return FALSE;
}
return TRUE;
}
BOOLEAN
IsLeapYear (
IN EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
{
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;
}
}
VOID
ConvertEfiTimeToRtcTime (
IN EFI_TIME *Time,
IN RTC_REGISTER_B RegisterB,
IN UINT8 *Century
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: Time - add argument and description to function comment
// TODO: RegisterB - add argument and description to function comment
// TODO: Century - add argument and description to function comment
{
BOOLEAN PM;
PM = TRUE;
//
// Adjust hour field if RTC in in 12 hour mode
//
if (RegisterB.Bits.MIL == 0) {
if (Time->Hour < 12) {
PM = 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 = DecimaltoBcd ((UINT8) (Time->Year / 100));
Time->Year = (UINT16) (Time->Year % 100);
if (RegisterB.Bits.DM == 0) {
Time->Year = DecimaltoBcd ((UINT8) Time->Year);
Time->Month = DecimaltoBcd (Time->Month);
Time->Day = DecimaltoBcd (Time->Day);
Time->Hour = DecimaltoBcd (Time->Hour);
Time->Minute = DecimaltoBcd (Time->Minute);
Time->Second = DecimaltoBcd (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 && PM) {
Time->Hour = (UINT8) (Time->Hour | 0x80);
}
}
BOOLEAN
IsWithinOneDay (
IN EFI_TIME *From,
IN EFI_TIME *To
)
/*++
Routine Description:
Judge whether two days are adjacent.
Arguments:
From - the first day
To - the second day
Returns:
TRUE - The interval of two days are within one day.
FALSE - The interval of two days exceed ony day or parameter error.
--*/
{
BOOLEAN Adjacent = FALSE;
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 == mDayOfMonth[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;
}
UINT8
DecimaltoBcd (
IN UINT8 DecValue
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: DecValue - add argument and description to function comment
{
UINTN High;
UINTN Low;
High = DecValue / 10;
Low = DecValue - (High * 10);
return (UINT8) (Low + (High << 4));
}

449
PcAtChipsetPkg/PcRtc/RealTimeClock.h
View File

@ -1,449 +0,0 @@
/*++
Copyright (c) 2005, 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.
Module Name:
PcRtc.h
Abstract:
Include for real time clock driver
Revision History
--*/
#ifndef _RTC_H_
#define _RTC_H_
#include <FrameworkDxe.h>
#include <Protocol/RealTimeClock.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/IoLib.h>
#include <Library/TimerLib.h>
#include <Library/BaseMemoryLib.h>
typedef struct {
EFI_LOCK RtcLock;
UINT16 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()
EFI_STATUS
PcRtcInit (
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
PcRtcSetTime (
IN EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
PcRtcGetTime (
OUT EFI_TIME *Time,
IN EFI_TIME_CAPABILITIES *Capabilities,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Capabilities - TODO: add argument description
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
PcRtcSetWakeupTime (
IN BOOLEAN Enable,
OUT EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Enable - TODO: add argument description
Time - TODO: add argument description
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
PcRtcGetWakeupTime (
OUT BOOLEAN *Enabled,
OUT BOOLEAN *Pending,
OUT EFI_TIME *Time,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Enabled - TODO: add argument description
Pending - TODO: add argument description
Time - TODO: add argument description
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
InitializePcRtc (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
TODO: Add function description
Arguments:
ImageHandle - TODO: add argument description
SystemTable - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
RtcTimeFieldsValid (
IN EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
;
UINT8
DecimaltoBcd (
IN UINT8 DecValue
)
/*++
Routine Description:
TODO: Add function description
Arguments:
DecValue - TODO: add argument description
Returns:
TODO: add return values
--*/
;
VOID
ConvertEfiTimeToRtcTime (
IN EFI_TIME *Time,
IN RTC_REGISTER_B RegisterB,
IN UINT8 *Century
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
RegisterB - TODO: add argument description
Century - TODO: add argument description
Returns:
TODO: add return values
--*/
;
VOID
ConvertRtcTimeToEfiTime (
IN EFI_TIME *Time,
IN RTC_REGISTER_B RegisterB
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
RegisterB - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
RtcWaitToUpdate (
UINTN Timeout
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Timeout - TODO: add argument description
Returns:
TODO: add return values
--*/
;
UINT8
RtcSaveContext (
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
VOID
RtcRestoreContext (
IN UINT8 SavedAddressRegister,
IN PC_RTC_MODULE_GLOBALS *Global
)
/*++
Routine Description:
TODO: Add function description
Arguments:
SavedAddressRegister - TODO: add argument description
Global - TODO: add argument description
Returns:
TODO: add return values
--*/
;
#endif

55
PcAtChipsetPkg/PcRtc/RealTimeClock.inf
View File

@ -1,55 +0,0 @@
#/*++
#
# Copyright (c) 2005 - 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.
#
# Module Name:
#
# Abstract:
#
#--*/
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = RealTimeClock
FILE_GUID = 378D7B65-8DA9-4773-B6E4-A47826A833E1
MODULE_TYPE = DXE_RUNTIME_DRIVER
VERSION_STRING = 1.0
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000
ENTRY_POINT = InitializeRealTimeClock
[Packages]
MdePkg/MdePkg.dec
IntelFrameworkPkg/IntelFrameworkPkg.dec
[LibraryClasses]
UefiDriverEntryPoint
UefiBootServicesTableLib
UefiLib
IoLib
TimerLib
BaseMemoryLib
[Sources.common]
RealTimeClock.c
RealTimeClock.h
RealTimeClockEntry.c
[Protocols]
gEfiCpuArchProtocolGuid
gEfiMetronomeArchProtocolGuid
gEfiCpuIoProtocolGuid
gEfiRealTimeClockArchProtocolGuid
[Depex]
gEfiCpuArchProtocolGuid AND gEfiMetronomeArchProtocolGuid AND gEfiCpuIoProtocolGuid

166
PcAtChipsetPkg/PcRtc/RealTimeClockEntry.c
View File

@ -1,166 +0,0 @@
/*++
Copyright (c) 2009, 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 "RealTimeClock.h"
PC_RTC_MODULE_GLOBALS mModuleGlobal;
EFI_STATUS
EFIAPI
PcRtcEfiGetTime (
OUT EFI_TIME *Time,
OUT EFI_TIME_CAPABILITIES *Capabilities
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Capabilities - TODO: add argument description
Returns:
TODO: add return values
--*/
{
return PcRtcGetTime (Time, Capabilities, &mModuleGlobal);
}
EFI_STATUS
EFIAPI
PcRtcEfiSetTime (
IN EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
{
return PcRtcSetTime (Time, &mModuleGlobal);
}
EFI_STATUS
EFIAPI
PcRtcEfiGetWakeupTime (
OUT BOOLEAN *Enabled,
OUT BOOLEAN *Pending,
OUT EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Enabled - TODO: add argument description
Pending - TODO: add argument description
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
{
return PcRtcGetWakeupTime (Enabled, Pending, Time, &mModuleGlobal);
}
EFI_STATUS
EFIAPI
PcRtcEfiSetWakeupTime (
IN BOOLEAN Enabled,
OUT EFI_TIME *Time
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Enabled - TODO: add argument description
Time - TODO: add argument description
Returns:
TODO: add return values
--*/
{
return PcRtcSetWakeupTime (Enabled, Time, &mModuleGlobal);
}
EFI_STATUS
EFIAPI
InitializeRealTimeClock (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// TODO: ImageHandle - add argument and description to function comment
// TODO: SystemTable - add argument and description to function comment
{
EFI_STATUS Status;
EFI_HANDLE NewHandle;
EfiInitializeLock (&mModuleGlobal.RtcLock, TPL_HIGH_LEVEL);
Status = PcRtcInit (&mModuleGlobal);
if (EFI_ERROR (Status)) {
return Status;
}
SystemTable->RuntimeServices->GetTime = PcRtcEfiGetTime;
SystemTable->RuntimeServices->SetTime = PcRtcEfiSetTime;
SystemTable->RuntimeServices->GetWakeupTime = PcRtcEfiGetWakeupTime;
SystemTable->RuntimeServices->SetWakeupTime = PcRtcEfiSetWakeupTime;
NewHandle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&NewHandle,
&gEfiRealTimeClockArchProtocolGuid,
NULL,
NULL
);
return Status;
}