ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2013-2017, ARM Limited. All rights reserved.
   4 *
   5 *  This program and the accompanying materials
   6 *  are licensed and made available under the terms and conditions of the BSD
   7 *  License which accompanies this distribution.  The full text of the license
   8 *  may be found at http://opensource.org/licenses/bsd-license.php
   9 *
  10 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 *
  13 **/
  14
  15 #include <PiDxe.h>
  16
  17 #include <Library/BaseLib.h>
  18 #include <Library/BaseMemoryLib.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/IoLib.h>
  21 #include <Library/PcdLib.h>
  22 #include <Library/UefiBootServicesTableLib.h>
  23 #include <Library/UefiRuntimeServicesTableLib.h>
  24 #include <Library/UefiLib.h>
  25 #include <Library/ArmGenericTimerCounterLib.h>
  26
  27 #include <Protocol/WatchdogTimer.h>
  28 #include <Protocol/HardwareInterrupt.h>
  29
  30 #include "GenericWatchdog.h"
  31
  32 /* The number of 100ns periods (the unit of time passed to these functions)
  33    in a second */
  34 #define TIME_UNITS_PER_SECOND 10000000
  35
  36 // Tick frequency of the generic timer basis of the generic watchdog.
  37 UINTN mTimerFrequencyHz = 0;
  38
  39 /* In cases where the compare register was set manually, information about
  40    how long the watchdog was asked to wait cannot be retrieved from hardware.
  41    It is therefore stored here. 0 means the timer is not running. */
  42 UINT64 mNumTimerTicks = 0;
  43
  44 EFI_HARDWARE_INTERRUPT_PROTOCOL *mInterruptProtocol;
  45
  46 EFI_STATUS
  47 WatchdogWriteOffsetRegister (
  48   UINT32  Value
  49   )
  50 {
  51   return MmioWrite32 (GENERIC_WDOG_OFFSET_REG, Value);
  52 }
  53
  54 EFI_STATUS
  55 WatchdogWriteCompareRegister (
  56   UINT64  Value
  57   )
  58 {
  59   return MmioWrite64 (GENERIC_WDOG_COMPARE_VALUE_REG, Value);
  60 }
  61
  62 EFI_STATUS
  63 WatchdogEnable (
  64   VOID
  65   )
  66 {
  67   return MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_ENABLED);
  68 }
  69
  70 EFI_STATUS
  71 WatchdogDisable (
  72   VOID
  73   )
  74 {
  75   return MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_DISABLED);
  76 }
  77
  78 /** On exiting boot services we must make sure the Watchdog Timer
  79     is stopped.
  80 **/
  81 VOID
  82 EFIAPI
  83 WatchdogExitBootServicesEvent (
  84   IN EFI_EVENT  Event,
  85   IN VOID       *Context
  86   )
  87 {
  88   WatchdogDisable ();
  89   mNumTimerTicks = 0;
  90 }
  91
  92 /* This function is called when the watchdog's first signal (WS0) goes high.
  93    It uses the ResetSystem Runtime Service to reset the board.
  94 */
  95 VOID
  96 EFIAPI
  97 WatchdogInterruptHandler (
  98   IN  HARDWARE_INTERRUPT_SOURCE   Source,
  99   IN  EFI_SYSTEM_CONTEXT          SystemContext
 100   )
 101 {
 102   STATIC CONST CHAR16 ResetString[]= L"The generic watchdog timer ran out.";
 103
 104   WatchdogDisable ();
 105
 106   mInterruptProtocol->EndOfInterrupt (mInterruptProtocol, Source);
 107
 108   gRT->ResetSystem (
 109          EfiResetCold,
 110          EFI_TIMEOUT,
 111          StrSize (ResetString),
 112          (VOID *) &ResetString
 113          );
 114
 115   // If we got here then the reset didn't work
 116   ASSERT (FALSE);
 117 }
 118
 119 /**
 120   This function registers the handler NotifyFunction so it is called every time
 121   the watchdog timer expires.  It also passes the amount of time since the last
 122   handler call to the NotifyFunction.
 123   If NotifyFunction is not NULL and a handler is not already registered,
 124   then the new handler is registered and EFI_SUCCESS is returned.
 125   If NotifyFunction is NULL, and a handler is already registered,
 126   then that handler is unregistered.
 127   If an attempt is made to register a handler when a handler is already
 128   registered, then EFI_ALREADY_STARTED is returned.
 129   If an attempt is made to unregister a handler when a handler is not
 130   registered, then EFI_INVALID_PARAMETER is returned.
 131
 132   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 133   @param  NotifyFunction   The function to call when a timer interrupt fires.
 134                            This function executes at TPL_HIGH_LEVEL. The DXE
 135                            Core will register a handler for the timer interrupt,
 136                            so it can know how much time has passed. This
 137                            information is used to signal timer based events.
 138                            NULL will unregister the handler.
 139
 140   @retval EFI_UNSUPPORTED       The code does not support NotifyFunction.
 141
 142 **/
 143 EFI_STATUS
 144 EFIAPI
 145 WatchdogRegisterHandler (
 146   IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
 147   IN EFI_WATCHDOG_TIMER_NOTIFY                NotifyFunction
 148   )
 149 {
 150   // ERROR: This function is not supported.
 151   // The watchdog will reset the board
 152   return EFI_UNSUPPORTED;
 153 }
 154
 155 /**
 156   This function sets the amount of time to wait before firing the watchdog
 157   timer to TimerPeriod 100ns units.  If TimerPeriod is 0, then the watchdog
 158   timer is disabled.
 159
 160   @param  This             The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
 161   @param  TimerPeriod      The amount of time in 100ns units to wait before
 162                            the watchdog timer is fired. If TimerPeriod is zero,
 163                            then the watchdog timer is disabled.
 164
 165   @retval EFI_SUCCESS           The watchdog timer has been programmed to fire
 166                                 in Time  100ns units.
 167   @retval EFI_DEVICE_ERROR      A watchdog timer could not be programmed due
 168                                 to a device error.
 169
 170 **/
 171 EFI_STATUS
 172 EFIAPI
 173 WatchdogSetTimerPeriod (
 174   IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
 175   IN UINT64                                   TimerPeriod   // In 100ns units
 176   )
 177 {
 178   UINTN       SystemCount;
 179   EFI_STATUS  Status;
 180
 181   // if TimerPeriod is 0, this is a request to stop the watchdog.
 182   if (TimerPeriod == 0) {
 183     mNumTimerTicks = 0;
 184     return WatchdogDisable ();
 185   }
 186
 187   // Work out how many timer ticks will equate to TimerPeriod
 188   mNumTimerTicks = (mTimerFrequencyHz * TimerPeriod) / TIME_UNITS_PER_SECOND;
 189
 190   /* If the number of required ticks is greater than the max the watchdog's
 191      offset register (WOR) can hold, we need to manually compute and set
 192      the compare register (WCV) */
 193   if (mNumTimerTicks > MAX_UINT32) {
 194     /* We need to enable the watchdog *before* writing to the compare register,
 195        because enabling the watchdog causes an "explicit refresh", which
 196        clobbers the compare register (WCV). In order to make sure this doesn't
 197        trigger an interrupt, set the offset to max. */
 198     Status = WatchdogWriteOffsetRegister (MAX_UINT32);
 199     if (EFI_ERROR (Status)) {
 200       return Status;
 201     }
 202     WatchdogEnable ();
 203     SystemCount = ArmGenericTimerGetSystemCount ();
 204     Status      = WatchdogWriteCompareRegister (SystemCount + mNumTimerTicks);
 205   } else {
 206     Status = WatchdogWriteOffsetRegister ((UINT32)mNumTimerTicks);
 207     WatchdogEnable ();
 208   }
 209
 210   return Status;
 211 }
 212
 213 /**
 214   This function retrieves the period of timer interrupts in 100ns units,
 215   returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod
 216   is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is
 217   returned, then the timer is currently disabled.
 218
 219   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 220   @param  TimerPeriod      A pointer to the timer period to retrieve in
 221                            100ns units. If 0 is returned, then the timer is
 222                            currently disabled.
 223
 224
 225   @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
 226   @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
 227
 228 **/
 229 EFI_STATUS
 230 EFIAPI
 231 WatchdogGetTimerPeriod (
 232   IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
 233   OUT UINT64                                  *TimerPeriod
 234   )
 235 {
 236   if (TimerPeriod == NULL) {
 237     return EFI_INVALID_PARAMETER;
 238   }
 239
 240   *TimerPeriod = ((TIME_UNITS_PER_SECOND / mTimerFrequencyHz) * mNumTimerTicks);
 241
 242   return EFI_SUCCESS;
 243 }
 244
 245 /**
 246   Interface structure for the Watchdog Architectural Protocol.
 247
 248   @par Protocol Description:
 249   This protocol provides a service to set the amount of time to wait
 250   before firing the watchdog timer, and it also provides a service to
 251   register a handler that is invoked when the watchdog timer fires.
 252
 253   @par When the watchdog timer fires, control will be passed to a handler
 254   if one has been registered.  If no handler has been registered,
 255   or the registered handler returns, then the system will be
 256   reset by calling the Runtime Service ResetSystem().
 257
 258   @param RegisterHandler
 259   Registers a handler that will be called each time the
 260   watchdogtimer interrupt fires.  TimerPeriod defines the minimum
 261   time between timer interrupts, so TimerPeriod will also
 262   be the minimum time between calls to the registered
 263   handler.
 264   NOTE: If the watchdog resets the system in hardware, then
 265         this function will not have any chance of executing.
 266
 267   @param SetTimerPeriod
 268   Sets the period of the timer interrupt in 100ns units.
 269   This function is optional, and may return EFI_UNSUPPORTED.
 270   If this function is supported, then the timer period will
 271   be rounded up to the nearest supported timer period.
 272
 273   @param GetTimerPeriod
 274   Retrieves the period of the timer interrupt in 100ns units.
 275
 276 **/
 277 EFI_WATCHDOG_TIMER_ARCH_PROTOCOL    gWatchdogTimer = {
 278   (EFI_WATCHDOG_TIMER_REGISTER_HANDLER)WatchdogRegisterHandler,
 279   (EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD)WatchdogSetTimerPeriod,
 280   (EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD)WatchdogGetTimerPeriod
 281 };
 282
 283 EFI_EVENT                           EfiExitBootServicesEvent = (EFI_EVENT)NULL;
 284
 285 EFI_STATUS
 286 EFIAPI
 287 GenericWatchdogEntry (
 288   IN EFI_HANDLE         ImageHandle,
 289   IN EFI_SYSTEM_TABLE   *SystemTable
 290   )
 291 {
 292   EFI_STATUS                      Status;
 293   EFI_HANDLE                      Handle;
 294
 295   /* Make sure the Watchdog Timer Architectural Protocol has not been installed
 296      in the system yet.
 297      This will avoid conflicts with the universal watchdog */
 298   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiWatchdogTimerArchProtocolGuid);
 299
 300   mTimerFrequencyHz = ArmGenericTimerGetTimerFreq ();
 301   ASSERT (mTimerFrequencyHz != 0);
 302
 303   // Register for an ExitBootServicesEvent
 304   Status = gBS->CreateEvent (
 305                   EVT_SIGNAL_EXIT_BOOT_SERVICES,
 306                   TPL_NOTIFY,
 307                   WatchdogExitBootServicesEvent,
 308                   NULL,
 309                   &EfiExitBootServicesEvent
 310                   );
 311   if (!EFI_ERROR (Status)) {
 312     // Install interrupt handler
 313     Status = gBS->LocateProtocol (
 314                     &gHardwareInterruptProtocolGuid,
 315                     NULL,
 316                     (VOID **)&mInterruptProtocol
 317                     );
 318     if (!EFI_ERROR (Status)) {
 319       Status = mInterruptProtocol->RegisterInterruptSource (
 320                  mInterruptProtocol,
 321                  FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
 322                  WatchdogInterruptHandler
 323                  );
 324       if (!EFI_ERROR (Status)) {
 325         // Install the Timer Architectural Protocol onto a new handle
 326         Handle = NULL;
 327         Status = gBS->InstallMultipleProtocolInterfaces (
 328                         &Handle,
 329                         &gEfiWatchdogTimerArchProtocolGuid,
 330                         &gWatchdogTimer,
 331                         NULL
 332                         );
 333       }
 334     }
 335   }
 336
 337   ASSERT_EFI_ERROR (Status);
 338
 339   mNumTimerTicks = 0;
 340   WatchdogDisable ();
 341
 342   return Status;
 343 }