3 * Copyright (c) 2013-2018, ARM Limited. All rights reserved.
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
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.
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>
27 #include <Protocol/HardwareInterrupt2.h>
28 #include <Protocol/WatchdogTimer.h>
30 #include "GenericWatchdog.h"
32 /* The number of 100ns periods (the unit of time passed to these functions)
34 #define TIME_UNITS_PER_SECOND 10000000
36 // Tick frequency of the generic timer basis of the generic watchdog.
37 STATIC UINTN mTimerFrequencyHz
= 0;
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 STATIC UINT64 mNumTimerTicks
= 0;
44 STATIC EFI_HARDWARE_INTERRUPT2_PROTOCOL
*mInterruptProtocol
;
45 STATIC EFI_WATCHDOG_TIMER_NOTIFY mWatchdogNotify
;
49 WatchdogWriteOffsetRegister (
53 MmioWrite32 (GENERIC_WDOG_OFFSET_REG
, Value
);
58 WatchdogWriteCompareRegister (
62 MmioWrite32 (GENERIC_WDOG_COMPARE_VALUE_REG_LOW
, Value
& MAX_UINT32
);
63 MmioWrite32 (GENERIC_WDOG_COMPARE_VALUE_REG_HIGH
, (Value
>> 32) & MAX_UINT32
);
72 MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG
, GENERIC_WDOG_ENABLED
);
81 MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG
, GENERIC_WDOG_DISABLED
);
84 /** On exiting boot services we must make sure the Watchdog Timer
90 WatchdogExitBootServicesEvent (
99 /* This function is called when the watchdog's first signal (WS0) goes high.
100 It uses the ResetSystem Runtime Service to reset the board.
105 WatchdogInterruptHandler (
106 IN HARDWARE_INTERRUPT_SOURCE Source
,
107 IN EFI_SYSTEM_CONTEXT SystemContext
110 STATIC CONST CHAR16 ResetString
[]= L
"The generic watchdog timer ran out.";
115 mInterruptProtocol
->EndOfInterrupt (mInterruptProtocol
, Source
);
118 // The notify function should be called with the elapsed number of ticks
119 // since the watchdog was armed, which should exceed the timer period.
120 // We don't actually know the elapsed number of ticks, so let's return
121 // the timer period plus 1.
123 if (mWatchdogNotify
!= NULL
) {
124 TimerPeriod
= ((TIME_UNITS_PER_SECOND
/ mTimerFrequencyHz
) * mNumTimerTicks
);
125 mWatchdogNotify (TimerPeriod
+ 1);
128 gRT
->ResetSystem (EfiResetCold
, EFI_TIMEOUT
, StrSize (ResetString
),
129 (CHAR16
*)ResetString
);
131 // If we got here then the reset didn't work
136 This function registers the handler NotifyFunction so it is called every time
137 the watchdog timer expires. It also passes the amount of time since the last
138 handler call to the NotifyFunction.
139 If NotifyFunction is not NULL and a handler is not already registered,
140 then the new handler is registered and EFI_SUCCESS is returned.
141 If NotifyFunction is NULL, and a handler is already registered,
142 then that handler is unregistered.
143 If an attempt is made to register a handler when a handler is already
144 registered, then EFI_ALREADY_STARTED is returned.
145 If an attempt is made to unregister a handler when a handler is not
146 registered, then EFI_INVALID_PARAMETER is returned.
148 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
149 @param NotifyFunction The function to call when a timer interrupt fires.
150 This function executes at TPL_HIGH_LEVEL. The DXE
151 Core will register a handler for the timer interrupt,
152 so it can know how much time has passed. This
153 information is used to signal timer based events.
154 NULL will unregister the handler.
156 @retval EFI_UNSUPPORTED The code does not support NotifyFunction.
162 WatchdogRegisterHandler (
163 IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL
*This
,
164 IN EFI_WATCHDOG_TIMER_NOTIFY NotifyFunction
167 if (mWatchdogNotify
== NULL
&& NotifyFunction
== NULL
) {
168 return EFI_INVALID_PARAMETER
;
171 if (mWatchdogNotify
!= NULL
&& NotifyFunction
!= NULL
) {
172 return EFI_ALREADY_STARTED
;
175 mWatchdogNotify
= NotifyFunction
;
180 This function sets the amount of time to wait before firing the watchdog
181 timer to TimerPeriod 100ns units. If TimerPeriod is 0, then the watchdog
184 @param This The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
185 @param TimerPeriod The amount of time in 100ns units to wait before
186 the watchdog timer is fired. If TimerPeriod is zero,
187 then the watchdog timer is disabled.
189 @retval EFI_SUCCESS The watchdog timer has been programmed to fire
190 in TimerPeriod 100ns units.
196 WatchdogSetTimerPeriod (
197 IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL
*This
,
198 IN UINT64 TimerPeriod
// In 100ns units
203 // if TimerPeriod is 0, this is a request to stop the watchdog.
204 if (TimerPeriod
== 0) {
210 // Work out how many timer ticks will equate to TimerPeriod
211 mNumTimerTicks
= (mTimerFrequencyHz
* TimerPeriod
) / TIME_UNITS_PER_SECOND
;
213 /* If the number of required ticks is greater than the max the watchdog's
214 offset register (WOR) can hold, we need to manually compute and set
215 the compare register (WCV) */
216 if (mNumTimerTicks
> MAX_UINT32
) {
217 /* We need to enable the watchdog *before* writing to the compare register,
218 because enabling the watchdog causes an "explicit refresh", which
219 clobbers the compare register (WCV). In order to make sure this doesn't
220 trigger an interrupt, set the offset to max. */
221 WatchdogWriteOffsetRegister (MAX_UINT32
);
223 SystemCount
= ArmGenericTimerGetSystemCount ();
224 WatchdogWriteCompareRegister (SystemCount
+ mNumTimerTicks
);
226 WatchdogWriteOffsetRegister ((UINT32
)mNumTimerTicks
);
234 This function retrieves the period of timer interrupts in 100ns units,
235 returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
236 is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
237 returned, then the timer is currently disabled.
239 @param This The EFI_TIMER_ARCH_PROTOCOL instance.
240 @param TimerPeriod A pointer to the timer period to retrieve in
241 100ns units. If 0 is returned, then the timer is
245 @retval EFI_SUCCESS The timer period was returned in TimerPeriod.
246 @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
252 WatchdogGetTimerPeriod (
253 IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL
*This
,
254 OUT UINT64
*TimerPeriod
257 if (TimerPeriod
== NULL
) {
258 return EFI_INVALID_PARAMETER
;
261 *TimerPeriod
= ((TIME_UNITS_PER_SECOND
/ mTimerFrequencyHz
) * mNumTimerTicks
);
267 Interface structure for the Watchdog Architectural Protocol.
269 @par Protocol Description:
270 This protocol provides a service to set the amount of time to wait
271 before firing the watchdog timer, and it also provides a service to
272 register a handler that is invoked when the watchdog timer fires.
274 @par When the watchdog timer fires, control will be passed to a handler
275 if one has been registered. If no handler has been registered,
276 or the registered handler returns, then the system will be
277 reset by calling the Runtime Service ResetSystem().
279 @param RegisterHandler
280 Registers a handler that will be called each time the
281 watchdogtimer interrupt fires. TimerPeriod defines the minimum
282 time between timer interrupts, so TimerPeriod will also
283 be the minimum time between calls to the registered
285 NOTE: If the watchdog resets the system in hardware, then
286 this function will not have any chance of executing.
288 @param SetTimerPeriod
289 Sets the period of the timer interrupt in 100ns units.
290 This function is optional, and may return EFI_UNSUPPORTED.
291 If this function is supported, then the timer period will
292 be rounded up to the nearest supported timer period.
294 @param GetTimerPeriod
295 Retrieves the period of the timer interrupt in 100ns units.
298 STATIC EFI_WATCHDOG_TIMER_ARCH_PROTOCOL mWatchdogTimer
= {
299 WatchdogRegisterHandler
,
300 WatchdogSetTimerPeriod
,
301 WatchdogGetTimerPeriod
304 STATIC EFI_EVENT mEfiExitBootServicesEvent
;
308 GenericWatchdogEntry (
309 IN EFI_HANDLE ImageHandle
,
310 IN EFI_SYSTEM_TABLE
*SystemTable
316 Status
= gBS
->LocateProtocol (&gHardwareInterrupt2ProtocolGuid
, NULL
,
317 (VOID
**)&mInterruptProtocol
);
318 ASSERT_EFI_ERROR (Status
);
320 /* Make sure the Watchdog Timer Architectural Protocol has not been installed
322 This will avoid conflicts with the universal watchdog */
323 ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL
, &gEfiWatchdogTimerArchProtocolGuid
);
325 mTimerFrequencyHz
= ArmGenericTimerGetTimerFreq ();
326 ASSERT (mTimerFrequencyHz
!= 0);
328 // Install interrupt handler
329 Status
= mInterruptProtocol
->RegisterInterruptSource (mInterruptProtocol
,
330 FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum
),
331 WatchdogInterruptHandler
);
332 if (EFI_ERROR (Status
)) {
336 Status
= mInterruptProtocol
->SetTriggerType (mInterruptProtocol
,
337 FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum
),
338 EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING
);
339 if (EFI_ERROR (Status
)) {
340 goto UnregisterHandler
;
343 // Install the Timer Architectural Protocol onto a new handle
345 Status
= gBS
->InstallMultipleProtocolInterfaces (&Handle
,
346 &gEfiWatchdogTimerArchProtocolGuid
, &mWatchdogTimer
,
348 if (EFI_ERROR (Status
)) {
349 goto UnregisterHandler
;
352 // Register for an ExitBootServicesEvent
353 Status
= gBS
->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES
, TPL_NOTIFY
,
354 WatchdogExitBootServicesEvent
, NULL
,
355 &mEfiExitBootServicesEvent
);
356 ASSERT_EFI_ERROR (Status
);
364 // Unregister the handler
365 mInterruptProtocol
->RegisterInterruptSource (mInterruptProtocol
,
366 FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum
),