LocalApicTimerDxe.c

Go to the documentation of this file.

 
#include <Library/NestedInterruptTplLib.h>
 
#include "LocalApicTimerDxe.h"
 
//
// The handle onto which the Timer Architectural Protocol will be installed
//
EFI_HANDLE  mTimerHandle = NULL;
 
//
// The Timer Architectural Protocol that this driver produces
//
EFI_TIMER_ARCH_PROTOCOL  mTimer = {
  TimerDriverRegisterHandler,
  TimerDriverSetTimerPeriod,
  TimerDriverGetTimerPeriod,
  TimerDriverGenerateSoftInterrupt
};
 
//
// Pointer to the CPU Architectural Protocol instance
//
EFI_CPU_ARCH_PROTOCOL  *mCpu;
 
//
// The notification function to call on every timer interrupt.
// A bug in the compiler prevents us from initializing this here.
//
EFI_TIMER_NOTIFY  mTimerNotifyFunction;
 
//
// The current period of the timer interrupt
//
volatile UINT64  mTimerPeriod = 0;
 
//
// Worker Functions
//
 
VOID
EFIAPI
TimerInterruptHandler (
  IN EFI_EXCEPTION_TYPE  InterruptType,
  IN EFI_SYSTEM_CONTEXT  SystemContext
  )
{
  STATIC NESTED_INTERRUPT_STATE  NestedInterruptState;
  EFI_TPL                        OriginalTPL;
 
  OriginalTPL = NestedInterruptRaiseTPL ();
 
  SendApicEoi ();
 
  if (mTimerNotifyFunction != NULL) {
    //
    // @bug : This does not handle missed timer interrupts
    //
    mTimerNotifyFunction (mTimerPeriod);
  }
 
  NestedInterruptRestoreTPL (OriginalTPL, SystemContext, &NestedInterruptState);
}
 
EFI_STATUS
EFIAPI
TimerDriverRegisterHandler (
  IN EFI_TIMER_ARCH_PROTOCOL  *This,
  IN EFI_TIMER_NOTIFY         NotifyFunction
  )
{
  //
  // Check for invalid parameters
  //
  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
    return EFI_ALREADY_STARTED;
  }
 
  mTimerNotifyFunction = NotifyFunction;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TimerDriverSetTimerPeriod (
  IN EFI_TIMER_ARCH_PROTOCOL  *This,
  IN UINT64                   TimerPeriod
  )
{
  UINT64  TimerCount;
  UINT32  TimerFrequency;
  UINT32  DivideValue = 1;
 
  if (TimerPeriod == 0) {
    //
    // Disable timer interrupt for a TimerPeriod of 0
    //
    DisableApicTimerInterrupt ();
  } else {
    TimerFrequency = PcdGet32 (PcdFSBClock) / (UINT32)DivideValue;
 
    //
    // Convert TimerPeriod into local APIC counts
    //
    // TimerPeriod is in 100ns
    // TimerPeriod/10000000 will be in seconds.
    TimerCount = DivU64x32 (
                   MultU64x32 (TimerPeriod, TimerFrequency),
                   10000000
                   );
 
    // Check for overflow
    if (TimerCount > MAX_UINT32) {
      TimerCount = MAX_UINT32;
      /* TimerPeriod = (MAX_UINT32 / TimerFrequency) * 10000000; */
      TimerPeriod = 429496730;
    }
 
    //
    // Program the timer with the new count value
    //
    InitializeApicTimer (DivideValue, (UINT32)TimerCount, TRUE, LOCAL_APIC_TIMER_VECTOR);
 
    //
    // Enable timer interrupt
    //
    EnableApicTimerInterrupt ();
  }
 
  //
  // Save the new timer period
  //
  mTimerPeriod = TimerPeriod;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TimerDriverGetTimerPeriod (
  IN EFI_TIMER_ARCH_PROTOCOL  *This,
  OUT UINT64                  *TimerPeriod
  )
{
  if (TimerPeriod == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  *TimerPeriod = mTimerPeriod;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TimerDriverGenerateSoftInterrupt (
  IN EFI_TIMER_ARCH_PROTOCOL  *This
  )
{
  EFI_TPL  OriginalTPL;
 
  if (GetApicTimerInterruptState ()) {
    //
    // Invoke the registered handler
    //
    OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
 
    if (mTimerNotifyFunction != NULL) {
      //
      // @bug : This does not handle missed timer interrupts
      //
      mTimerNotifyFunction (mTimerPeriod);
    }
 
    gBS->RestoreTPL (OriginalTPL);
  } else {
    return EFI_UNSUPPORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TimerDriverInitialize (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Initialize the pointer to our notify function.
  //
  mTimerNotifyFunction = NULL;
 
  //
  // Make sure the Timer Architectural Protocol is not already installed in the system
  //
  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiTimerArchProtocolGuid);
 
  //
  // Find the CPU architectural protocol.
  //
  Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&mCpu);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Force the timer to be disabled
  //
  Status = TimerDriverSetTimerPeriod (&mTimer, 0);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Install interrupt handler for Local APIC Timer
  //
  Status = mCpu->RegisterInterruptHandler (
                   mCpu,
                   LOCAL_APIC_TIMER_VECTOR,
                   TimerInterruptHandler
                   );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Force the timer to be enabled at its default period
  //
  Status = TimerDriverSetTimerPeriod (&mTimer, DEFAULT_TIMER_TICK_DURATION);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Install the Timer Architectural Protocol onto a new handle
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &mTimerHandle,
                  &gEfiTimerArchProtocolGuid,
                  &mTimer,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}