pios_wdg.c

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 */

/*
 * @todo This is virtually identical to the F1xx code and should be merged.
 */

#include "pios.h"
#if defined(STM32F40_41xxx) || defined(STM32F446xx)  /* F4 */
#include "stm32f4xx_iwdg.h"
#include "stm32f4xx_dbgmcu.h"
#include "stm32f4xx_rtc.h"
#elif defined(STM32F30X) /* F3 */
#include "stm32f30x_iwdg.h"
#include "stm32f30x_dbgmcu.h"
#include "stm32f30x_rtc.h"
#elif defined(STM32F10X_MD) /* F1 */
#include "stm32f10x_iwdg.h"
#include "stm32f10x_dbgmcu.h"

#define RTC_ReadBackupRegister BKP_ReadBackupRegister
#define RTC_WriteBackupRegister BKP_WriteBackupRegister
#elif defined(STM32F0XX) /* F0 */
#include "stm32f0xx_iwdg.h"
#include "stm32f0xx_dbgmcu.h"
#else 
#error Attempted to build on unsupported target
#endif

#if defined(PIOS_WDG_REGISTER)
static struct wdg_configuration {
        uint16_t used_flags;
        uint16_t bootup_flags;
} wdg_configuration;
#endif

uint16_t PIOS_WDG_Init()
{
        uint16_t delay = ((uint32_t) PIOS_WATCHDOG_TIMEOUT * 60) / 16;
        if (delay > 0x0fff)
                delay = 0x0fff;
#if defined(PIOS_INCLUDE_WDG)
        DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE);        // make the watchdog stop counting in debug mode
        IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
        IWDG_SetPrescaler(IWDG_Prescaler_16);
        IWDG_SetReload(delay);
        IWDG_ReloadCounter();
        IWDG_Enable();

        // PIOS_WDG_REGISTER is used to choose whether the flag-mode is available
        // for watchdog.. for maximal compatability with existing targets
#ifdef PIOS_WDG_REGISTER
        // watchdog flags now stored in backup registers
        PWR_BackupAccessCmd(ENABLE);

        wdg_configuration.bootup_flags = RTC_ReadBackupRegister(PIOS_WDG_REGISTER);

        /*
         * Start from an empty set of registered flags so previous boots
         * can't influence the current one
         */
        RTC_WriteBackupRegister(PIOS_WDG_REGISTER, 0);
#endif // PIOS_WDG_REGISTER
#endif
        return delay;
}

#ifdef PIOS_WDG_REGISTER

bool PIOS_WDG_RegisterFlag(uint16_t flag_requested) 
{
        
        /* Fail if flag already registered */
        if(wdg_configuration.used_flags & flag_requested)
                return false;
        
        // FIXME: Protect with semaphore
        wdg_configuration.used_flags |= flag_requested;
        
        return true;
}

bool PIOS_WDG_UpdateFlag(uint16_t flag) 
{       
        // Validate that the flag has been registered. If not, halt the program.
        if ((wdg_configuration.used_flags & flag) == 0) {
                PIOS_Assert(0);
        }

        // we can probably avoid using a semaphore here which will be good for
        // efficiency and not blocking critical tasks.  race condition could 
        // overwrite their flag update, but unlikely to block _all_ of them 
        // for the timeout window
        uint16_t cur_flags = RTC_ReadBackupRegister(PIOS_WDG_REGISTER);
        
        if((cur_flags | flag) == wdg_configuration.used_flags) {
                PIOS_WDG_Clear();
                RTC_WriteBackupRegister(PIOS_WDG_REGISTER, flag);
                return true;
        } else {
                RTC_WriteBackupRegister(PIOS_WDG_REGISTER, cur_flags | flag);
                return false;
        }
}

uint16_t PIOS_WDG_GetBootupFlags()
{
        return wdg_configuration.bootup_flags;  
}

uint16_t PIOS_WDG_GetActiveFlags()
{
        return RTC_ReadBackupRegister(PIOS_WDG_REGISTER);
}
#endif //PIOS_WDG_REGISTER

void PIOS_WDG_Clear(void)
{
#if defined(PIOS_INCLUDE_WDG)
        IWDG_ReloadCounter();
#endif
}