ba808d11f6
Even though UEFI does not appear to use it, let's implement the complete PI watchdog protocol, including handler registration, which will be invoked before the ResetSystem() runtime service when the watchdog timer expires. Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org> Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>
370 lines
12 KiB
C
370 lines
12 KiB
C
/** @file
|
|
*
|
|
* Copyright (c) 2013-2018, ARM Limited. All rights reserved.
|
|
*
|
|
* This program and the accompanying materials
|
|
* are licensed and made available under the terms and conditions of the BSD
|
|
* License which accompanies this distribution. The full text of the license
|
|
* may be found at http://opensource.org/licenses/bsd-license.php
|
|
*
|
|
* THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
*
|
|
**/
|
|
|
|
#include <PiDxe.h>
|
|
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/IoLib.h>
|
|
#include <Library/PcdLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include <Library/UefiRuntimeServicesTableLib.h>
|
|
#include <Library/UefiLib.h>
|
|
#include <Library/ArmGenericTimerCounterLib.h>
|
|
|
|
#include <Protocol/HardwareInterrupt2.h>
|
|
#include <Protocol/WatchdogTimer.h>
|
|
|
|
#include "GenericWatchdog.h"
|
|
|
|
/* The number of 100ns periods (the unit of time passed to these functions)
|
|
in a second */
|
|
#define TIME_UNITS_PER_SECOND 10000000
|
|
|
|
// Tick frequency of the generic timer basis of the generic watchdog.
|
|
STATIC UINTN mTimerFrequencyHz = 0;
|
|
|
|
/* In cases where the compare register was set manually, information about
|
|
how long the watchdog was asked to wait cannot be retrieved from hardware.
|
|
It is therefore stored here. 0 means the timer is not running. */
|
|
STATIC UINT64 mNumTimerTicks = 0;
|
|
|
|
STATIC EFI_HARDWARE_INTERRUPT2_PROTOCOL *mInterruptProtocol;
|
|
STATIC EFI_WATCHDOG_TIMER_NOTIFY mWatchdogNotify;
|
|
|
|
STATIC
|
|
VOID
|
|
WatchdogWriteOffsetRegister (
|
|
UINT32 Value
|
|
)
|
|
{
|
|
MmioWrite32 (GENERIC_WDOG_OFFSET_REG, Value);
|
|
}
|
|
|
|
STATIC
|
|
VOID
|
|
WatchdogWriteCompareRegister (
|
|
UINT64 Value
|
|
)
|
|
{
|
|
MmioWrite32 (GENERIC_WDOG_COMPARE_VALUE_REG_LOW, Value & MAX_UINT32);
|
|
MmioWrite32 (GENERIC_WDOG_COMPARE_VALUE_REG_HIGH, (Value >> 32) & MAX_UINT32);
|
|
}
|
|
|
|
STATIC
|
|
VOID
|
|
WatchdogEnable (
|
|
VOID
|
|
)
|
|
{
|
|
MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_ENABLED);
|
|
}
|
|
|
|
STATIC
|
|
VOID
|
|
WatchdogDisable (
|
|
VOID
|
|
)
|
|
{
|
|
MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_DISABLED);
|
|
}
|
|
|
|
/** On exiting boot services we must make sure the Watchdog Timer
|
|
is stopped.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
WatchdogExitBootServicesEvent (
|
|
IN EFI_EVENT Event,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
WatchdogDisable ();
|
|
mNumTimerTicks = 0;
|
|
}
|
|
|
|
/* This function is called when the watchdog's first signal (WS0) goes high.
|
|
It uses the ResetSystem Runtime Service to reset the board.
|
|
*/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
WatchdogInterruptHandler (
|
|
IN HARDWARE_INTERRUPT_SOURCE Source,
|
|
IN EFI_SYSTEM_CONTEXT SystemContext
|
|
)
|
|
{
|
|
STATIC CONST CHAR16 ResetString[]= L"The generic watchdog timer ran out.";
|
|
UINT64 TimerPeriod;
|
|
|
|
WatchdogDisable ();
|
|
|
|
mInterruptProtocol->EndOfInterrupt (mInterruptProtocol, Source);
|
|
|
|
//
|
|
// The notify function should be called with the elapsed number of ticks
|
|
// since the watchdog was armed, which should exceed the timer period.
|
|
// We don't actually know the elapsed number of ticks, so let's return
|
|
// the timer period plus 1.
|
|
//
|
|
if (mWatchdogNotify != NULL) {
|
|
TimerPeriod = ((TIME_UNITS_PER_SECOND / mTimerFrequencyHz) * mNumTimerTicks);
|
|
mWatchdogNotify (TimerPeriod + 1);
|
|
}
|
|
|
|
gRT->ResetSystem (EfiResetCold, EFI_TIMEOUT, StrSize (ResetString),
|
|
(CHAR16 *)ResetString);
|
|
|
|
// If we got here then the reset didn't work
|
|
ASSERT (FALSE);
|
|
}
|
|
|
|
/**
|
|
This function registers the handler NotifyFunction so it is called every time
|
|
the watchdog timer expires. It also passes the amount of time since the last
|
|
handler call to the NotifyFunction.
|
|
If NotifyFunction is not NULL and a handler is not already registered,
|
|
then the new handler is registered and EFI_SUCCESS is returned.
|
|
If NotifyFunction is NULL, and a handler is already registered,
|
|
then that handler is unregistered.
|
|
If an attempt is made to register a handler when a handler is already
|
|
registered, then EFI_ALREADY_STARTED is returned.
|
|
If an attempt is made to unregister a handler when a handler is not
|
|
registered, then EFI_INVALID_PARAMETER is returned.
|
|
|
|
@param This The EFI_TIMER_ARCH_PROTOCOL instance.
|
|
@param NotifyFunction The function to call when a timer interrupt fires.
|
|
This function executes at TPL_HIGH_LEVEL. The DXE
|
|
Core will register a handler for the timer interrupt,
|
|
so it can know how much time has passed. This
|
|
information is used to signal timer based events.
|
|
NULL will unregister the handler.
|
|
|
|
@retval EFI_UNSUPPORTED The code does not support NotifyFunction.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
WatchdogRegisterHandler (
|
|
IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *This,
|
|
IN EFI_WATCHDOG_TIMER_NOTIFY NotifyFunction
|
|
)
|
|
{
|
|
if (mWatchdogNotify == NULL && NotifyFunction == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (mWatchdogNotify != NULL && NotifyFunction != NULL) {
|
|
return EFI_ALREADY_STARTED;
|
|
}
|
|
|
|
mWatchdogNotify = NotifyFunction;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
This function sets the amount of time to wait before firing the watchdog
|
|
timer to TimerPeriod 100ns units. If TimerPeriod is 0, then the watchdog
|
|
timer is disabled.
|
|
|
|
@param This The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
|
|
@param TimerPeriod The amount of time in 100ns units to wait before
|
|
the watchdog timer is fired. If TimerPeriod is zero,
|
|
then the watchdog timer is disabled.
|
|
|
|
@retval EFI_SUCCESS The watchdog timer has been programmed to fire
|
|
in TimerPeriod 100ns units.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
WatchdogSetTimerPeriod (
|
|
IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *This,
|
|
IN UINT64 TimerPeriod // In 100ns units
|
|
)
|
|
{
|
|
UINTN SystemCount;
|
|
|
|
// if TimerPeriod is 0, this is a request to stop the watchdog.
|
|
if (TimerPeriod == 0) {
|
|
mNumTimerTicks = 0;
|
|
WatchdogDisable ();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
// Work out how many timer ticks will equate to TimerPeriod
|
|
mNumTimerTicks = (mTimerFrequencyHz * TimerPeriod) / TIME_UNITS_PER_SECOND;
|
|
|
|
/* If the number of required ticks is greater than the max the watchdog's
|
|
offset register (WOR) can hold, we need to manually compute and set
|
|
the compare register (WCV) */
|
|
if (mNumTimerTicks > MAX_UINT32) {
|
|
/* We need to enable the watchdog *before* writing to the compare register,
|
|
because enabling the watchdog causes an "explicit refresh", which
|
|
clobbers the compare register (WCV). In order to make sure this doesn't
|
|
trigger an interrupt, set the offset to max. */
|
|
WatchdogWriteOffsetRegister (MAX_UINT32);
|
|
WatchdogEnable ();
|
|
SystemCount = ArmGenericTimerGetSystemCount ();
|
|
WatchdogWriteCompareRegister (SystemCount + mNumTimerTicks);
|
|
} else {
|
|
WatchdogWriteOffsetRegister ((UINT32)mNumTimerTicks);
|
|
WatchdogEnable ();
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
This function retrieves the period of timer interrupts in 100ns units,
|
|
returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
|
|
is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
|
|
returned, then the timer is currently disabled.
|
|
|
|
@param This The EFI_TIMER_ARCH_PROTOCOL instance.
|
|
@param TimerPeriod A pointer to the timer period to retrieve in
|
|
100ns units. If 0 is returned, then the timer is
|
|
currently disabled.
|
|
|
|
|
|
@retval EFI_SUCCESS The timer period was returned in TimerPeriod.
|
|
@retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
WatchdogGetTimerPeriod (
|
|
IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *This,
|
|
OUT UINT64 *TimerPeriod
|
|
)
|
|
{
|
|
if (TimerPeriod == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*TimerPeriod = ((TIME_UNITS_PER_SECOND / mTimerFrequencyHz) * mNumTimerTicks);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Interface structure for the Watchdog Architectural Protocol.
|
|
|
|
@par Protocol Description:
|
|
This protocol provides a service to set the amount of time to wait
|
|
before firing the watchdog timer, and it also provides a service to
|
|
register a handler that is invoked when the watchdog timer fires.
|
|
|
|
@par When the watchdog timer fires, control will be passed to a handler
|
|
if one has been registered. If no handler has been registered,
|
|
or the registered handler returns, then the system will be
|
|
reset by calling the Runtime Service ResetSystem().
|
|
|
|
@param RegisterHandler
|
|
Registers a handler that will be called each time the
|
|
watchdogtimer interrupt fires. TimerPeriod defines the minimum
|
|
time between timer interrupts, so TimerPeriod will also
|
|
be the minimum time between calls to the registered
|
|
handler.
|
|
NOTE: If the watchdog resets the system in hardware, then
|
|
this function will not have any chance of executing.
|
|
|
|
@param SetTimerPeriod
|
|
Sets the period of the timer interrupt in 100ns units.
|
|
This function is optional, and may return EFI_UNSUPPORTED.
|
|
If this function is supported, then the timer period will
|
|
be rounded up to the nearest supported timer period.
|
|
|
|
@param GetTimerPeriod
|
|
Retrieves the period of the timer interrupt in 100ns units.
|
|
|
|
**/
|
|
STATIC EFI_WATCHDOG_TIMER_ARCH_PROTOCOL mWatchdogTimer = {
|
|
WatchdogRegisterHandler,
|
|
WatchdogSetTimerPeriod,
|
|
WatchdogGetTimerPeriod
|
|
};
|
|
|
|
STATIC EFI_EVENT mEfiExitBootServicesEvent;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
GenericWatchdogEntry (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_HANDLE Handle;
|
|
|
|
Status = gBS->LocateProtocol (&gHardwareInterrupt2ProtocolGuid, NULL,
|
|
(VOID **)&mInterruptProtocol);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
/* Make sure the Watchdog Timer Architectural Protocol has not been installed
|
|
in the system yet.
|
|
This will avoid conflicts with the universal watchdog */
|
|
ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiWatchdogTimerArchProtocolGuid);
|
|
|
|
mTimerFrequencyHz = ArmGenericTimerGetTimerFreq ();
|
|
ASSERT (mTimerFrequencyHz != 0);
|
|
|
|
// Install interrupt handler
|
|
Status = mInterruptProtocol->RegisterInterruptSource (mInterruptProtocol,
|
|
FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
|
|
WatchdogInterruptHandler);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
Status = mInterruptProtocol->SetTriggerType (mInterruptProtocol,
|
|
FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
|
|
EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING);
|
|
if (EFI_ERROR (Status)) {
|
|
goto UnregisterHandler;
|
|
}
|
|
|
|
// Install the Timer Architectural Protocol onto a new handle
|
|
Handle = NULL;
|
|
Status = gBS->InstallMultipleProtocolInterfaces (&Handle,
|
|
&gEfiWatchdogTimerArchProtocolGuid, &mWatchdogTimer,
|
|
NULL);
|
|
if (EFI_ERROR (Status)) {
|
|
goto UnregisterHandler;
|
|
}
|
|
|
|
// Register for an ExitBootServicesEvent
|
|
Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY,
|
|
WatchdogExitBootServicesEvent, NULL,
|
|
&mEfiExitBootServicesEvent);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
mNumTimerTicks = 0;
|
|
WatchdogDisable ();
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
UnregisterHandler:
|
|
// Unregister the handler
|
|
mInterruptProtocol->RegisterInterruptSource (mInterruptProtocol,
|
|
FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
|
|
NULL);
|
|
return Status;
|
|
}
|