ArmPkg/Drivers/TimerDxe/TimerDxe.c

   1 /** @file
   2   Timer Architecture Protocol driver of the ARM flavor
   3
   4   Copyright (c) 2011-2013 ARM Ltd. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16
  17 #include <PiDxe.h>
  18
  19 #include <Library/ArmLib.h>
  20 #include <Library/BaseLib.h>
  21 #include <Library/DebugLib.h>
  22 #include <Library/BaseMemoryLib.h>
  23 #include <Library/UefiBootServicesTableLib.h>
  24 #include <Library/UefiLib.h>
  25 #include <Library/PcdLib.h>
  26 #include <Library/IoLib.h>
  27 #include <Library/ArmGenericTimerCounterLib.h>
  28 #include <Library/ArmArchTimer.h>
  29
  30 #include <Protocol/Timer.h>
  31 #include <Protocol/HardwareInterrupt.h>
  32
  33 // The notification function to call on every timer interrupt.
  34 EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;
  35 EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;
  36
  37 // The current period of the timer interrupt
  38 UINT64 mTimerPeriod = 0;
  39 // The latest Timer Tick calculated for mTimerPeriod
  40 UINT64 mTimerTicks = 0;
  41 // Number of elapsed period since the last Timer interrupt
  42 UINT64 mElapsedPeriod = 1;
  43
  44 // Cached copy of the Hardware Interrupt protocol instance
  45 EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
  46
  47 /**
  48   This function registers the handler NotifyFunction so it is called every time
  49   the timer interrupt fires.  It also passes the amount of time since the last
  50   handler call to the NotifyFunction.  If NotifyFunction is NULL, then the
  51   handler is unregistered.  If the handler is registered, then EFI_SUCCESS is
  52   returned.  If the CPU does not support registering a timer interrupt handler,
  53   then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler
  54   when a handler is already registered, then EFI_ALREADY_STARTED is returned.
  55   If an attempt is made to unregister a handler when a handler is not registered,
  56   then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to
  57   register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
  58   is returned.
  59
  60   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
  61   @param  NotifyFunction   The function to call when a timer interrupt fires. This
  62                            function executes at TPL_HIGH_LEVEL. The DXE Core will
  63                            register a handler for the timer interrupt, so it can know
  64                            how much time has passed. This information is used to
  65                            signal timer based events. NULL will unregister the handler.
  66   @retval EFI_SUCCESS           The timer handler was registered.
  67   @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
  68   @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
  69                                 registered.
  70   @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
  71                                 previously registered.
  72   @retval EFI_DEVICE_ERROR      The timer handler could not be registered.
  73
  74 **/
  75 EFI_STATUS
  76 EFIAPI
  77 TimerDriverRegisterHandler (
  78   IN EFI_TIMER_ARCH_PROTOCOL  *This,
  79   IN EFI_TIMER_NOTIFY         NotifyFunction
  80   )
  81 {
  82   if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
  83     return EFI_INVALID_PARAMETER;
  84   }
  85
  86   if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
  87     return EFI_ALREADY_STARTED;
  88   }
  89
  90   mTimerNotifyFunction = NotifyFunction;
  91
  92   return EFI_SUCCESS;
  93 }
  94
  95 /**
  96     Disable the timer
  97 **/
  98 VOID
  99 EFIAPI
 100 ExitBootServicesEvent (
 101   IN EFI_EVENT  Event,
 102   IN VOID       *Context
 103   )
 104 {
 105   ArmGenericTimerDisableTimer ();
 106 }
 107
 108 /**
 109
 110   This function adjusts the period of timer interrupts to the value specified
 111   by TimerPeriod.  If the timer period is updated, then the selected timer
 112   period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If
 113   the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
 114   If an error occurs while attempting to update the timer period, then the
 115   timer hardware will be put back in its state prior to this call, and
 116   EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt
 117   is disabled.  This is not the same as disabling the CPU's interrupts.
 118   Instead, it must either turn off the timer hardware, or it must adjust the
 119   interrupt controller so that a CPU interrupt is not generated when the timer
 120   interrupt fires.
 121
 122   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 123   @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
 124                            the timer hardware is not programmable, then EFI_UNSUPPORTED is
 125                            returned. If the timer is programmable, then the timer period
 126                            will be rounded up to the nearest timer period that is supported
 127                            by the timer hardware. If TimerPeriod is set to 0, then the
 128                            timer interrupts will be disabled.
 129
 130
 131   @retval EFI_SUCCESS           The timer period was changed.
 132   @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
 133   @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
 134
 135 **/
 136 EFI_STATUS
 137 EFIAPI
 138 TimerDriverSetTimerPeriod (
 139   IN EFI_TIMER_ARCH_PROTOCOL  *This,
 140   IN UINT64                   TimerPeriod
 141   )
 142 {
 143   UINT64      CounterValue;
 144   UINT64      TimerTicks;
 145   EFI_TPL     OriginalTPL;
 146
 147   // Always disable the timer
 148   ArmGenericTimerDisableTimer ();
 149
 150   if (TimerPeriod != 0) {
 151     // mTimerTicks = TimerPeriod in 1ms unit x Frequency.10^-3
 152     //             = TimerPeriod.10^-4 x Frequency.10^-3
 153     //             = (TimerPeriod x Frequency) x 10^-7
 154     TimerTicks = MultU64x32 (TimerPeriod, ArmGenericTimerGetTimerFreq ());
 155     TimerTicks = DivU64x32 (TimerTicks, 10000000U);
 156
 157     // Raise TPL to update the mTimerTicks and mTimerPeriod to ensure these values
 158     // are coherent in the interrupt handler
 159     OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
 160
 161     mTimerTicks    = TimerTicks;
 162     mTimerPeriod   = TimerPeriod;
 163     mElapsedPeriod = 1;
 164
 165     gBS->RestoreTPL (OriginalTPL);
 166
 167     // Get value of the current timer
 168     CounterValue = ArmGenericTimerGetSystemCount ();
 169     // Set the interrupt in Current Time + mTimerTick
 170     ArmGenericTimerSetCompareVal (CounterValue + mTimerTicks);
 171
 172     // Enable the timer
 173     ArmGenericTimerEnableTimer ();
 174   } else {
 175     // Save the new timer period
 176     mTimerPeriod   = TimerPeriod;
 177     // Reset the elapsed period
 178     mElapsedPeriod = 1;
 179   }
 180
 181   return EFI_SUCCESS;
 182 }
 183
 184 /**
 185   This function retrieves the period of timer interrupts in 100 ns units,
 186   returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod
 187   is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is
 188   returned, then the timer is currently disabled.
 189
 190   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 191   @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
 192                            0 is returned, then the timer is currently disabled.
 193
 194
 195   @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
 196   @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
 197
 198 **/
 199 EFI_STATUS
 200 EFIAPI
 201 TimerDriverGetTimerPeriod (
 202   IN EFI_TIMER_ARCH_PROTOCOL   *This,
 203   OUT UINT64                   *TimerPeriod
 204   )
 205 {
 206   if (TimerPeriod == NULL) {
 207     return EFI_INVALID_PARAMETER;
 208   }
 209
 210   *TimerPeriod = mTimerPeriod;
 211   return EFI_SUCCESS;
 212 }
 213
 214 /**
 215   This function generates a soft timer interrupt. If the platform does not support soft
 216   timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
 217   If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
 218   service, then a soft timer interrupt will be generated. If the timer interrupt is
 219   enabled when this service is called, then the registered handler will be invoked. The
 220   registered handler should not be able to distinguish a hardware-generated timer
 221   interrupt from a software-generated timer interrupt.
 222
 223   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 224
 225   @retval EFI_SUCCESS           The soft timer interrupt was generated.
 226   @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.
 227
 228 **/
 229 EFI_STATUS
 230 EFIAPI
 231 TimerDriverGenerateSoftInterrupt (
 232   IN EFI_TIMER_ARCH_PROTOCOL  *This
 233   )
 234 {
 235   return EFI_UNSUPPORTED;
 236 }
 237
 238 /**
 239   Interface structure for the Timer Architectural Protocol.
 240
 241   @par Protocol Description:
 242   This protocol provides the services to initialize a periodic timer
 243   interrupt, and to register a handler that is called each time the timer
 244   interrupt fires.  It may also provide a service to adjust the rate of the
 245   periodic timer interrupt.  When a timer interrupt occurs, the handler is
 246   passed the amount of time that has passed since the previous timer
 247   interrupt.
 248
 249   @param RegisterHandler
 250   Registers a handler that will be called each time the
 251   timer interrupt fires.  TimerPeriod defines the minimum
 252   time between timer interrupts, so TimerPeriod will also
 253   be the minimum time between calls to the registered
 254   handler.
 255
 256   @param SetTimerPeriod
 257   Sets the period of the timer interrupt in 100 nS units.
 258   This function is optional, and may return EFI_UNSUPPORTED.
 259   If this function is supported, then the timer period will
 260   be rounded up to the nearest supported timer period.
 261
 262
 263   @param GetTimerPeriod
 264   Retrieves the period of the timer interrupt in 100 nS units.
 265
 266   @param GenerateSoftInterrupt
 267   Generates a soft timer interrupt that simulates the firing of
 268   the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for
 269   a period of time.
 270
 271 **/
 272 EFI_TIMER_ARCH_PROTOCOL   gTimer = {
 273   TimerDriverRegisterHandler,
 274   TimerDriverSetTimerPeriod,
 275   TimerDriverGetTimerPeriod,
 276   TimerDriverGenerateSoftInterrupt
 277 };
 278
 279 /**
 280
 281   C Interrupt Handler called in the interrupt context when Source interrupt is active.
 282
 283
 284   @param Source         Source of the interrupt. Hardware routing off a specific platform defines
 285                         what source means.
 286
 287   @param SystemContext  Pointer to system register context. Mostly used by debuggers and will
 288                         update the system context after the return from the interrupt if
 289                         modified. Don't change these values unless you know what you are doing
 290
 291 **/
 292 VOID
 293 EFIAPI
 294 TimerInterruptHandler (
 295   IN  HARDWARE_INTERRUPT_SOURCE   Source,
 296   IN  EFI_SYSTEM_CONTEXT          SystemContext
 297   )
 298 {
 299   EFI_TPL      OriginalTPL;
 300   UINT64       CurrentValue;
 301   UINT64       CompareValue;
 302
 303   //
 304   // DXE core uses this callback for the EFI timer tick. The DXE core uses locks
 305   // that raise to TPL_HIGH and then restore back to current level. Thus we need
 306   // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick.
 307   //
 308   OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
 309
 310   // Check if the timer interrupt is active
 311   if ((ArmGenericTimerGetTimerCtrlReg () ) & ARM_ARCH_TIMER_ISTATUS) {
 312
 313     // Signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers
 314     gInterrupt->EndOfInterrupt (gInterrupt, Source);
 315
 316     if (mTimerNotifyFunction) {
 317       mTimerNotifyFunction (mTimerPeriod * mElapsedPeriod);
 318     }
 319
 320     //
 321     // Reload the Timer
 322     //
 323
 324     // Get current counter value
 325     CurrentValue = ArmGenericTimerGetSystemCount ();
 326     // Get the counter value to compare with
 327     CompareValue = ArmGenericTimerGetCompareVal ();
 328
 329     // This loop is needed in case we missed interrupts (eg: case when the interrupt handling
 330     // has taken longer than mTickPeriod).
 331     // Note: Physical Counter is counting up
 332     mElapsedPeriod = 0;
 333     do {
 334       CompareValue += mTimerTicks;
 335       mElapsedPeriod++;
 336     } while (CompareValue < CurrentValue);
 337
 338     // Set next compare value
 339     ArmGenericTimerSetCompareVal (CompareValue);
 340   }
 341
 342   // Enable timer interrupts
 343   gInterrupt->EnableInterruptSource (gInterrupt, Source);
 344
 345   gBS->RestoreTPL (OriginalTPL);
 346 }
 347
 348
 349 /**
 350   Initialize the state information for the Timer Architectural Protocol and
 351   the Timer Debug support protocol that allows the debugger to break into a
 352   running program.
 353
 354   @param  ImageHandle   of the loaded driver
 355   @param  SystemTable   Pointer to the System Table
 356
 357   @retval EFI_SUCCESS           Protocol registered
 358   @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
 359   @retval EFI_DEVICE_ERROR      Hardware problems
 360
 361 **/
 362 EFI_STATUS
 363 EFIAPI
 364 TimerInitialize (
 365   IN EFI_HANDLE         ImageHandle,
 366   IN EFI_SYSTEM_TABLE   *SystemTable
 367   )
 368 {
 369   EFI_HANDLE  Handle = NULL;
 370   EFI_STATUS  Status;
 371   UINTN TimerCtrlReg;
 372
 373   if (ArmIsArchTimerImplemented () == 0) {
 374     DEBUG ((EFI_D_ERROR, "ARM Architectural Timer is not available in the CPU, hence cann't use this Driver \n"));
 375     ASSERT (0);
 376   }
 377
 378   // Find the interrupt controller protocol.  ASSERT if not found.
 379   Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);
 380   ASSERT_EFI_ERROR (Status);
 381
 382   // Disable the timer
 383   TimerCtrlReg = ArmGenericTimerGetTimerCtrlReg ();
 384   TimerCtrlReg |= ARM_ARCH_TIMER_IMASK;
 385   TimerCtrlReg &= ~ARM_ARCH_TIMER_ENABLE;
 386   ArmGenericTimerSetTimerCtrlReg (TimerCtrlReg);
 387   Status = TimerDriverSetTimerPeriod (&gTimer, 0);
 388   ASSERT_EFI_ERROR (Status);
 389
 390   // Install secure and Non-secure interrupt handlers
 391   // Note: Because it is not possible to determine the security state of the
 392   // CPU dynamically, we just install interrupt handler for both sec and non-sec
 393   // timer PPI
 394   Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerVirtIntrNum), TimerInterruptHandler);
 395   ASSERT_EFI_ERROR (Status);
 396
 397   Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerHypIntrNum), TimerInterruptHandler);
 398   ASSERT_EFI_ERROR (Status);
 399
 400   Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerSecIntrNum), TimerInterruptHandler);
 401   ASSERT_EFI_ERROR (Status);
 402
 403   Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerIntrNum), TimerInterruptHandler);
 404   ASSERT_EFI_ERROR (Status);
 405
 406   // Set up default timer
 407   Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
 408   ASSERT_EFI_ERROR (Status);
 409
 410   // Install the Timer Architectural Protocol onto a new handle
 411   Status = gBS->InstallMultipleProtocolInterfaces(
 412                   &Handle,
 413                   &gEfiTimerArchProtocolGuid,      &gTimer,
 414                   NULL
 415                   );
 416   ASSERT_EFI_ERROR(Status);
 417
 418   // Everything is ready, unmask and enable timer interrupts
 419   TimerCtrlReg = ARM_ARCH_TIMER_ENABLE;
 420   ArmGenericTimerSetTimerCtrlReg (TimerCtrlReg);
 421
 422   // Register for an ExitBootServicesEvent
 423   Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);
 424   ASSERT_EFI_ERROR (Status);
 425
 426   return Status;
 427 }