PcRtcEntry.c

Go to the documentation of this file.

 
#include <Library/DxeServicesTableLib.h>
#include "PcRtc.h"
 
PC_RTC_MODULE_GLOBALS  mModuleGlobal;
 
EFI_HANDLE  mHandle = NULL;
 
STATIC EFI_EVENT  mVirtualAddrChangeEvent;
 
UINTN   mRtcIndexRegister;
UINTN   mRtcTargetRegister;
UINT16  mRtcDefaultYear;
UINT16  mMinimalValidYear;
UINT16  mMaximalValidYear;
 
EFI_STATUS
EFIAPI
PcRtcEfiGetTime (
  OUT EFI_TIME               *Time,
  OUT EFI_TIME_CAPABILITIES  *Capabilities  OPTIONAL
  )
{
  return PcRtcGetTime (Time, Capabilities, &mModuleGlobal);
}
 
EFI_STATUS
EFIAPI
PcRtcEfiSetTime (
  IN EFI_TIME  *Time
  )
{
  return PcRtcSetTime (Time, &mModuleGlobal);
}
 
EFI_STATUS
EFIAPI
PcRtcEfiGetWakeupTime (
  OUT BOOLEAN   *Enabled,
  OUT BOOLEAN   *Pending,
  OUT EFI_TIME  *Time
  )
{
  return PcRtcGetWakeupTime (Enabled, Pending, Time, &mModuleGlobal);
}
 
EFI_STATUS
EFIAPI
PcRtcEfiSetWakeupTime (
  IN BOOLEAN   Enabled,
  IN EFI_TIME  *Time       OPTIONAL
  )
{
  return PcRtcSetWakeupTime (Enabled, Time, &mModuleGlobal);
}
 
STATIC
VOID
EFIAPI
VirtualNotifyEvent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  // Only needed if you are going to support the OS calling RTC functions in
  // virtual mode. You will need to call EfiConvertPointer (). To convert any
  // stored physical addresses to virtual address. After the OS transitions to
  // calling in virtual mode, all future runtime calls will be made in virtual
  // mode.
  EfiConvertPointer (0x0, (VOID **)&mRtcIndexRegister);
  EfiConvertPointer (0x0, (VOID **)&mRtcTargetRegister);
}
 
EFI_STATUS
EFIAPI
InitializePcRtc (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
  EFI_EVENT   Event;
 
  EfiInitializeLock (&mModuleGlobal.RtcLock, TPL_CALLBACK);
  mModuleGlobal.CenturyRtcAddress = GetCenturyRtcAddress ();
 
  if (FeaturePcdGet (PcdRtcUseMmio)) {
    mRtcIndexRegister  = (UINTN)PcdGet64 (PcdRtcIndexRegister64);
    mRtcTargetRegister = (UINTN)PcdGet64 (PcdRtcTargetRegister64);
  } else {
    mRtcIndexRegister  = (UINTN)PcdGet8 (PcdRtcIndexRegister);
    mRtcTargetRegister = (UINTN)PcdGet8 (PcdRtcTargetRegister);
  }
 
  mRtcDefaultYear   = PcdGet16 (PcdRtcDefaultYear);
  mMinimalValidYear = PcdGet16 (PcdMinimalValidYear);
  mMaximalValidYear = PcdGet16 (PcdMaximalValidYear);
 
  Status = PcRtcInit (&mModuleGlobal);
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  PcRtcAcpiTableChangeCallback,
                  NULL,
                  &gEfiAcpi10TableGuid,
                  &Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  PcRtcAcpiTableChangeCallback,
                  NULL,
                  &gEfiAcpiTableGuid,
                  &Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  gRT->GetTime       = PcRtcEfiGetTime;
  gRT->SetTime       = PcRtcEfiSetTime;
  gRT->GetWakeupTime = PcRtcEfiGetWakeupTime;
  gRT->SetWakeupTime = PcRtcEfiSetWakeupTime;
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &mHandle,
                  &gEfiRealTimeClockArchProtocolGuid,
                  NULL,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  if (FeaturePcdGet (PcdRtcUseMmio)) {
    // Register for the virtual address change event
    Status = gBS->CreateEventEx (
                    EVT_NOTIFY_SIGNAL,
                    TPL_NOTIFY,
                    VirtualNotifyEvent,
                    NULL,
                    &gEfiEventVirtualAddressChangeGuid,
                    &mVirtualAddrChangeEvent
                    );
    ASSERT_EFI_ERROR (Status);
  }
 
  return Status;
}