ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2013-2018, 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/HardwareInterrupt2.h>
  28 #include <Protocol/WatchdogTimer.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_INTERRUPT2_PROTOCOL *mInterruptProtocol;
  45
  46 VOID
  47 WatchdogWriteOffsetRegister (
  48   UINT32  Value
  49   )
  50 {
  51   MmioWrite32 (GENERIC_WDOG_OFFSET_REG, Value);
  52 }
  53
  54 VOID
  55 WatchdogWriteCompareRegister (
  56   UINT64  Value
  57   )
  58 {
  59   MmioWrite64 (GENERIC_WDOG_COMPARE_VALUE_REG, Value);
  60 }
  61
  62 VOID
  63 WatchdogEnable (
  64   VOID
  65   )
  66 {
  67   MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_ENABLED);
  68 }
  69
  70 VOID
  71 WatchdogDisable (
  72   VOID
  73   )
  74 {
  75   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 TimerPeriod 100ns units.
 167
 168 **/
 169 EFI_STATUS
 170 EFIAPI
 171 WatchdogSetTimerPeriod (
 172   IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
 173   IN UINT64                                   TimerPeriod   // In 100ns units
 174   )
 175 {
 176   UINTN       SystemCount;
 177
 178   // if TimerPeriod is 0, this is a request to stop the watchdog.
 179   if (TimerPeriod == 0) {
 180     mNumTimerTicks = 0;
 181     WatchdogDisable ();
 182     return EFI_SUCCESS;
 183   }
 184
 185   // Work out how many timer ticks will equate to TimerPeriod
 186   mNumTimerTicks = (mTimerFrequencyHz * TimerPeriod) / TIME_UNITS_PER_SECOND;
 187
 188   /* If the number of required ticks is greater than the max the watchdog's
 189      offset register (WOR) can hold, we need to manually compute and set
 190      the compare register (WCV) */
 191   if (mNumTimerTicks > MAX_UINT32) {
 192     /* We need to enable the watchdog *before* writing to the compare register,
 193        because enabling the watchdog causes an "explicit refresh", which
 194        clobbers the compare register (WCV). In order to make sure this doesn't
 195        trigger an interrupt, set the offset to max. */
 196     WatchdogWriteOffsetRegister (MAX_UINT32);
 197     WatchdogEnable ();
 198     SystemCount = ArmGenericTimerGetSystemCount ();
 199     WatchdogWriteCompareRegister (SystemCount + mNumTimerTicks);
 200   } else {
 201     WatchdogWriteOffsetRegister ((UINT32)mNumTimerTicks);
 202     WatchdogEnable ();
 203   }
 204
 205   return EFI_SUCCESS;
 206 }
 207
 208 /**
 209   This function retrieves the period of timer interrupts in 100ns units,
 210   returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod
 211   is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is
 212   returned, then the timer is currently disabled.
 213
 214   @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
 215   @param  TimerPeriod      A pointer to the timer period to retrieve in
 216                            100ns units. If 0 is returned, then the timer is
 217                            currently disabled.
 218
 219
 220   @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
 221   @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
 222
 223 **/
 224 EFI_STATUS
 225 EFIAPI
 226 WatchdogGetTimerPeriod (
 227   IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
 228   OUT UINT64                                  *TimerPeriod
 229   )
 230 {
 231   if (TimerPeriod == NULL) {
 232     return EFI_INVALID_PARAMETER;
 233   }
 234
 235   *TimerPeriod = ((TIME_UNITS_PER_SECOND / mTimerFrequencyHz) * mNumTimerTicks);
 236
 237   return EFI_SUCCESS;
 238 }
 239
 240 /**
 241   Interface structure for the Watchdog Architectural Protocol.
 242
 243   @par Protocol Description:
 244   This protocol provides a service to set the amount of time to wait
 245   before firing the watchdog timer, and it also provides a service to
 246   register a handler that is invoked when the watchdog timer fires.
 247
 248   @par When the watchdog timer fires, control will be passed to a handler
 249   if one has been registered.  If no handler has been registered,
 250   or the registered handler returns, then the system will be
 251   reset by calling the Runtime Service ResetSystem().
 252
 253   @param RegisterHandler
 254   Registers a handler that will be called each time the
 255   watchdogtimer interrupt fires.  TimerPeriod defines the minimum
 256   time between timer interrupts, so TimerPeriod will also
 257   be the minimum time between calls to the registered
 258   handler.
 259   NOTE: If the watchdog resets the system in hardware, then
 260         this function will not have any chance of executing.
 261
 262   @param SetTimerPeriod
 263   Sets the period of the timer interrupt in 100ns units.
 264   This function is optional, and may return EFI_UNSUPPORTED.
 265   If this function is supported, then the timer period will
 266   be rounded up to the nearest supported timer period.
 267
 268   @param GetTimerPeriod
 269   Retrieves the period of the timer interrupt in 100ns units.
 270
 271 **/
 272 EFI_WATCHDOG_TIMER_ARCH_PROTOCOL    gWatchdogTimer = {
 273   (EFI_WATCHDOG_TIMER_REGISTER_HANDLER)WatchdogRegisterHandler,
 274   (EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD)WatchdogSetTimerPeriod,
 275   (EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD)WatchdogGetTimerPeriod
 276 };
 277
 278 EFI_EVENT                           EfiExitBootServicesEvent = (EFI_EVENT)NULL;
 279
 280 EFI_STATUS
 281 EFIAPI
 282 GenericWatchdogEntry (
 283   IN EFI_HANDLE         ImageHandle,
 284   IN EFI_SYSTEM_TABLE   *SystemTable
 285   )
 286 {
 287   EFI_STATUS                      Status;
 288   EFI_HANDLE                      Handle;
 289
 290   /* Make sure the Watchdog Timer Architectural Protocol has not been installed
 291      in the system yet.
 292      This will avoid conflicts with the universal watchdog */
 293   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiWatchdogTimerArchProtocolGuid);
 294
 295   mTimerFrequencyHz = ArmGenericTimerGetTimerFreq ();
 296   ASSERT (mTimerFrequencyHz != 0);
 297
 298   // Register for an ExitBootServicesEvent
 299   Status = gBS->CreateEvent (
 300                   EVT_SIGNAL_EXIT_BOOT_SERVICES,
 301                   TPL_NOTIFY,
 302                   WatchdogExitBootServicesEvent,
 303                   NULL,
 304                   &EfiExitBootServicesEvent
 305                   );
 306   if (!EFI_ERROR (Status)) {
 307     // Install interrupt handler
 308     Status = gBS->LocateProtocol (
 309                     &gHardwareInterrupt2ProtocolGuid,
 310                     NULL,
 311                     (VOID **)&mInterruptProtocol
 312                     );
 313     if (!EFI_ERROR (Status)) {
 314       Status = mInterruptProtocol->RegisterInterruptSource (
 315                  mInterruptProtocol,
 316                  FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
 317                  WatchdogInterruptHandler
 318                  );
 319       if (!EFI_ERROR (Status)) {
 320         Status = mInterruptProtocol->SetTriggerType (
 321                    mInterruptProtocol,
 322                    FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
 323                    EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING
 324                    );
 325         if (!EFI_ERROR (Status)) {
 326           // Install the Timer Architectural Protocol onto a new handle
 327           Handle = NULL;
 328           Status = gBS->InstallMultipleProtocolInterfaces (
 329                           &Handle,
 330                           &gEfiWatchdogTimerArchProtocolGuid,
 331                           &gWatchdogTimer,
 332                           NULL
 333                           );
 334         }
 335       }
 336     }
 337   }
 338
 339   ASSERT_EFI_ERROR (Status);
 340
 341   mNumTimerTicks = 0;
 342   WatchdogDisable ();
 343
 344   return Status;
 345 }