ArmPlatformPkg/ArmJunoPkg: Move the watchdog generic driver to ArmPkg/Drivers

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Ronald Cron <Ronald.Cron@arm.com>
Reviewed-by: Olivier Martin <olivier.martin@arm.com>



git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@16512 6f19259b-4bc3-4df7-8a09-765794883524

3 files changed, 436 insertions, 0 deletions

diff --git a/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdog.h b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdog.h
new file mode 100644
index 0000000000..578fd1e85f
--- /dev/null
+++ b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdog.h
@@ -0,0 +1,29 @@
+/** @file

+*

+*  Copyright (c) 2013-2014, 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.

+*

+**/

+#ifndef __GENERIC_WATCHDOG_H__

+#define __GENERIC_WATCHDOG_H__

+

+// Refresh Frame:

+#define GENERIC_WDOG_REFRESH_REG              ((UINT32)FixedPcdGet32 (PcdGenericWatchdogRefreshBase) + 0x000)

+

+// Control Frame:

+#define GENERIC_WDOG_CONTROL_STATUS_REG       ((UINT32)FixedPcdGet32 (PcdGenericWatchdogControlBase) + 0x000)

+#define GENERIC_WDOG_OFFSET_REG               ((UINT32)FixedPcdGet32 (PcdGenericWatchdogControlBase) + 0x008)

+#define GENERIC_WDOG_COMPARE_VALUE_REG        ((UINT32)FixedPcdGet32 (PcdGenericWatchdogControlBase) + 0x010)

+

+// Values of bit 0 of the Control/Status Register

+#define GENERIC_WDOG_ENABLED          1

+#define GENERIC_WDOG_DISABLED         0

+

+#endif  // __GENERIC_WATCHDOG_H__

diff --git a/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c
new file mode 100644
index 0000000000..ba09227806
--- /dev/null
+++ b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c
@@ -0,0 +1,354 @@
+/** @file

+*

+*  Copyright (c) 2013-2014, 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/WatchdogTimer.h>

+#include <Protocol/HardwareInterrupt.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 that is the basis of the generic watchdog

+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.

+UINT64 mNumTimerTicks = 0;

+

+EFI_HARDWARE_INTERRUPT_PROTOCOL *mInterruptProtocol;

+

+EFI_STATUS

+WatchdogWriteOffsetRegister (

+  UINT32  Value

+  )

+{

+  return MmioWrite32 (GENERIC_WDOG_OFFSET_REG, Value);

+}

+

+EFI_STATUS

+WatchdogWriteCompareRegister (

+  UINT64  Value

+  )

+{

+  return MmioWrite64 (GENERIC_WDOG_COMPARE_VALUE_REG, Value);

+}

+

+EFI_STATUS

+WatchdogEnable (

+  VOID

+  )

+{

+  return MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_ENABLED);

+}

+

+EFI_STATUS

+WatchdogDisable (

+  VOID

+  )

+{

+  return MmioWrite32 (GENERIC_WDOG_CONTROL_STATUS_REG, GENERIC_WDOG_DISABLED);

+}

+

+/**

+    On exiting boot services we must make sure the Watchdog Timer

+    is stopped.

+**/

+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.

+*/

+VOID

+EFIAPI

+WatchdogInterruptHandler (

+  IN  HARDWARE_INTERRUPT_SOURCE   Source,

+  IN  EFI_SYSTEM_CONTEXT          SystemContext

+  )

+{

+  STATIC CONST CHAR16      ResetString[] = L"The generic watchdog timer ran out.";

+

+  WatchdogDisable ();

+

+  mInterruptProtocol->EndOfInterrupt (mInterruptProtocol, Source);

+

+  gRT->ResetSystem (

+         EfiResetCold,

+         EFI_TIMEOUT,

+         StrSize (ResetString),

+         &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_SUCCESS           The watchdog timer handler was registered.

+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already

+                                registered.

+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not

+                                previously registered.

+

+**/

+EFI_STATUS

+EFIAPI

+WatchdogRegisterHandler (

+  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,

+  IN EFI_WATCHDOG_TIMER_NOTIFY                NotifyFunction

+  )

+{

+  // ERROR: This function is not supported.

+  // The watchdog will reset the board

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  This function sets the amount of time to wait before firing the watchdog

+  timer to TimerPeriod 100 nS 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 100 nS 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 Time

+                                100 nS units.

+  @retval EFI_DEVICE_ERROR      A watchdog timer could not be programmed due to a device

+                                error.

+

+**/

+EFI_STATUS

+EFIAPI

+WatchdogSetTimerPeriod (

+  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,

+  IN UINT64                                   TimerPeriod   // In 100ns units

+  )

+{

+  UINTN       TimerVal;

+  EFI_STATUS  Status;

+

+  // if TimerPerdiod is 0, this is a request to stop the watchdog.

+  if (TimerPeriod == 0) {

+    mNumTimerTicks = 0;

+    return WatchdogDisable ();

+  }

+

+  // 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 number 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.

+    //

+    Status = WatchdogWriteOffsetRegister (MAX_UINT32);

+    if (EFI_ERROR (Status)) {

+      return Status;

+    }

+    WatchdogEnable ();

+    TimerVal = ArmGenericTimerGetTimerVal ();

+    Status = WatchdogWriteCompareRegister (TimerVal + mNumTimerTicks);

+  } else {

+    Status = WatchdogWriteOffsetRegister ((UINT32)mNumTimerTicks);

+    WatchdogEnable ();

+  }

+

+  return Status;

+}

+

+/**

+  This function retrieves the period of timer interrupts in 100 ns 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 100

+                           ns 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.

+

+**/

+EFI_STATUS

+EFIAPI

+WatchdogGetTimerPeriod (

+  IN CONST 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 100 nS 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 100 nS units.

+

+**/

+EFI_WATCHDOG_TIMER_ARCH_PROTOCOL    gWatchdogTimer = {

+  (EFI_WATCHDOG_TIMER_REGISTER_HANDLER) WatchdogRegisterHandler,

+  (EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD) WatchdogSetTimerPeriod,

+  (EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD) WatchdogGetTimerPeriod

+};

+

+EFI_EVENT                           EfiExitBootServicesEvent = (EFI_EVENT)NULL;

+

+EFI_STATUS

+EFIAPI

+GenericWatchdogEntry (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS                      Status;

+  EFI_HANDLE                      Handle;

+

+  //

+  // 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);

+

+  // Register for an ExitBootServicesEvent

+  Status = gBS->CreateEvent (

+                  EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY,

+                  WatchdogExitBootServicesEvent, NULL, &EfiExitBootServicesEvent

+                  );

+  if (!EFI_ERROR (Status)) {

+    // Install interrupt handler

+    Status = gBS->LocateProtocol (

+                    &gHardwareInterruptProtocolGuid,

+                    NULL,

+                    (VOID **)&mInterruptProtocol

+                    );

+    if (!EFI_ERROR (Status)) {

+      Status = mInterruptProtocol->RegisterInterruptSource (

+                                    mInterruptProtocol,

+                                    FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),

+                                    WatchdogInterruptHandler

+                                    );

+      if (!EFI_ERROR (Status)) {

+        // Install the Timer Architectural Protocol onto a new handle

+        Handle = NULL;

+        Status = gBS->InstallMultipleProtocolInterfaces (

+                        &Handle,

+                        &gEfiWatchdogTimerArchProtocolGuid, &gWatchdogTimer,

+                        NULL

+                        );

+      }

+    }

+  }

+

+  if (EFI_ERROR (Status)) {

+    // The watchdog failed to initialize

+    ASSERT (FALSE);

+  }

+

+  mNumTimerTicks = 0;

+  WatchdogDisable ();

+

+  return Status;

+}

diff --git a/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.inf b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.inf
new file mode 100644
index 0000000000..fece14cc18
--- /dev/null
+++ b/ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.inf
@@ -0,0 +1,53 @@
+#

+#  Copyright (c) 2013-2014, 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.

+#

+

+[Defines]

+  INF_VERSION                    = 0x00010016

+  BASE_NAME                      = GenericWatchdogDxe

+  FILE_GUID                      = 0619f5c2-4858-4caa-a86a-73a21a18df6b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = GenericWatchdogEntry

+

+[Sources.common]

+  GenericWatchdogDxe.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  ArmGenericTimerCounterLib

+  BaseLib

+  BaseMemoryLib

+  DebugLib

+  IoLib

+  PcdLib

+  UefiLib

+  UefiBootServicesTableLib

+  UefiDriverEntryPoint

+  UefiRuntimeServicesTableLib

+

+[Pcd.common]

+  gArmTokenSpaceGuid.PcdGenericWatchdogControlBase

+  gArmTokenSpaceGuid.PcdGenericWatchdogRefreshBase

+  gArmTokenSpaceGuid.PcdGenericWatchdogEl2IntrNum

+

+[Protocols]

+  gEfiWatchdogTimerArchProtocolGuid

+  gHardwareInterruptProtocolGuid

+

+[Depex]

+  gHardwareInterruptProtocolGuid