flight/pios/stm32f10x/pios_wdg.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup   PIOS_WDG Watchdog Functions
   6  * @brief PIOS Comamnds to initialize and clear watchdog timer
   7  * @{
   8  *
   9  * @file       pios_spi.c
  10  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
  11  *              Parts by Thorsten Klose (tk@midibox.org) (tk@midibox.org)
  12  * @brief      Hardware Abstraction Layer for SPI ports of STM32
  13  * @see        The GNU Public License (GPL) Version 3
  14  * @notes
  15  *
  16  * The PIOS Watchdog provides a HAL to initialize a watchdog
  17  *
  18  *****************************************************************************/
  19 /*
  20  * This program is free software; you can redistribute it and/or modify
  21  * it under the terms of the GNU General Public License as published by
  22  * the Free Software Foundation; either version 3 of the License, or
  23  * (at your option) any later version.
  24  *
  25  * This program is distributed in the hope that it will be useful, but
  26  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  27  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  28  * for more details.
  29  *
  30  * You should have received a copy of the GNU General Public License along
  31  * with this program; if not, write to the Free Software Foundation, Inc.,
  32  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  33  */
  34
  35 #include "pios.h"
  36
  37 #ifdef PIOS_INCLUDE_WDG
  38
  39 #include "stm32f10x_iwdg.h"
  40 #include "stm32f10x_dbgmcu.h"
  41
  42 static struct wdg_configuration {
  43     uint16_t used_flags;
  44     uint16_t bootup_flags;
  45 } wdg_configuration;
  46
  47 /**
  48  * @brief Initialize the watchdog timer for a specified timeout
  49  *
  50  * It is important to note that this function returns the achieved timeout
  51  * for this hardware.  For hardware indendence this should be checked when
  52  * scheduling updates.  Other hardware dependent details may need to be
  53  * considered such as a window time which sets a minimum update time,
  54  * and this function should return a recommended delay for clearing.
  55  *
  56  * For the STM32 nominal clock rate is 32 khz, but for the maximum clock rate of
  57  * 60 khz and a prescalar of 4 yields a clock rate of 15 khz.  The delay that is
  58  * set in the watchdog assumes the nominal clock rate, but the delay for FreeRTOS
  59  * to use is 75% of the minimal delay.
  60  *
  61  * @returns Maximum recommended delay between updates based on PIOS_WATCHDOG_TIMEOUT constant
  62  */
  63 uint16_t PIOS_WDG_Init()
  64 {
  65     uint16_t delay = ((uint32_t)PIOS_WATCHDOG_TIMEOUT * 60) / 16;
  66
  67     if (delay > 0x0fff) {
  68         delay = 0x0fff;
  69     }
  70 #if defined(PIOS_INCLUDE_WDG)
  71     DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE); // make the watchdog stop counting in debug mode
  72     IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
  73     IWDG_SetPrescaler(IWDG_Prescaler_16);
  74     IWDG_SetReload(delay);
  75     IWDG_ReloadCounter();
  76     IWDG_Enable();
  77
  78     // watchdog flags now stored in backup registers
  79     PWR_BackupAccessCmd(ENABLE);
  80
  81     BKP_WriteBackupRegister(PIOS_WDG_REGISTER, 0x0);
  82     wdg_configuration.bootup_flags = BKP_ReadBackupRegister(PIOS_WDG_REGISTER);
  83 #endif
  84     return delay;
  85 }
  86
  87 /**
  88  * @brief Register a module against the watchdog
  89  *
  90  * There are two ways to use PIOS WDG: this is for when
  91  * multiple modules must be monitored.  In this case they
  92  * must first register against the watchdog system and
  93  * only when all of the modules have been updated with the
  94  * watchdog be cleared.  Each module must have its own
  95  * bit in the 16 bit
  96  *
  97  * @param[in] flag the bit this module wants to use
  98  * @returns True if that bit is unregistered
  99  */
 100 bool PIOS_WDG_RegisterFlag(uint16_t flag_requested)
 101 {
 102     // flag are being registered so we are in module initialization phase
 103     // clear the WDG to prevent timeout while initializing modules. (OP-815)
 104     PIOS_WDG_Clear();
 105
 106     /* Fail if flag already registered */
 107     if (wdg_configuration.used_flags & flag_requested) {
 108         return false;
 109     }
 110
 111     // FIXME: Protect with semaphore
 112     wdg_configuration.used_flags |= flag_requested;
 113
 114     return true;
 115 }
 116
 117 /**
 118  * @brief Function called by modules to indicate they are still running
 119  *
 120  * This function will set this flag in the active flags register (which is
 121  * a backup regsiter) and if all the registered flags are set will clear
 122  * the watchdog and set only this flag in the backup register
 123  *
 124  * @param[in] flag the flag to set
 125  * @return true if the watchdog cleared, false if flags are pending
 126  */
 127 bool PIOS_WDG_UpdateFlag(uint16_t flag)
 128 {
 129     // we can probably avoid using a semaphore here which will be good for
 130     // efficiency and not blocking critical tasks.  race condition could
 131     // overwrite their flag update, but unlikely to block _all_ of them
 132     // for the timeout window
 133     uint16_t cur_flags = BKP_ReadBackupRegister(PIOS_WDG_REGISTER);
 134
 135     if ((cur_flags | flag) == wdg_configuration.used_flags) {
 136         PIOS_WDG_Clear();
 137         BKP_WriteBackupRegister(PIOS_WDG_REGISTER, flag);
 138         return true;
 139     } else {
 140         BKP_WriteBackupRegister(PIOS_WDG_REGISTER, cur_flags | flag);
 141         return false;
 142     }
 143 }
 144
 145 /**
 146  * @brief Returns the flags that were set at bootup
 147  *
 148  * This is used for diagnostics, if only one flag not set this
 149  * was likely the module that wasn't running before reset
 150  *
 151  * @return The active flags register from bootup
 152  */
 153 uint16_t PIOS_WDG_GetBootupFlags()
 154 {
 155     return wdg_configuration.bootup_flags;
 156 }
 157
 158 /**
 159  * @brief Returns the currently active flags
 160  *
 161  * For external monitoring
 162  *
 163  * @return The active flags register
 164  */
 165 uint16_t PIOS_WDG_GetActiveFlags()
 166 {
 167     return BKP_ReadBackupRegister(PIOS_WDG_REGISTER);
 168 }
 169
 170 /**
 171  * @brief Clear the watchdog timer
 172  *
 173  * This function must be called at the appropriate delay to prevent a reset event occuring
 174  */
 175 void PIOS_WDG_Clear(void)
 176 {
 177 #if defined(PIOS_INCLUDE_WDG)
 178     IWDG_ReloadCounter();
 179 #endif
 180 }
 181
 182 #endif /* PIOS_INCLUDE_WDG */