rt-thread-official/bsp/lpc408x/Libraries/Drivers/source/lpc_wwdt.c

485 lines
14 KiB
C
Raw Normal View History

2014-01-02 18:30:13 +08:00
/**********************************************************************
* $Id$ lpc_wwdt.c 2011-06-02
*//**
* @file lpc_wwdt.c
* @brief Contains all functions support for Wachtdog Timer
* firmware library on LPC
* @version 1.0
* @date 02. June. 2011
* @author NXP MCU SW Application Team
*
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
* Permission to use, copy, modify, and distribute this software and its
* documentation is hereby granted, under NXP Semiconductors'
* relevant copyright in the software, without fee, provided that it
* is used in conjunction with NXP Semiconductors microcontrollers. This
* copyright, permission, and disclaimer notice must appear in all copies of
* this code.
**********************************************************************/
/* Peripheral group ----------------------------------------------------------- */
/** @addtogroup WWDT
* @{
*/
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc_libcfg.h"
#else
#include "lpc_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */
#ifdef _WDT
/* Includes ------------------------------------------------------------------- */
#include "lpc_wwdt.h"
#include "lpc_clkpwr.h"
#include "lpc_pinsel.h"
/* Public Functions ----------------------------------------------------------- */
/** @addtogroup WDT_Public_Functions
* @{
*/
/********************************************************************//**
* @brief Set timeout value to Timer Constant register
* (if enable) to generate a WatchDog event if match
*
* @param[in] timeoutVal The value (counter) will write directly to
* Register w/o pre-calc
*
* @return None
*********************************************************************/
int8_t WWDT_SetTimeOutRaw(uint32_t timeoutVal)
{
int8_t retval = 0;
if(timeoutVal < WWDT_TIMEOUT_MIN)
{
timeoutVal = WWDT_TIMEOUT_MIN;
retval = WWDT_FUNC_BAD_PARAM;
}
else if (timeoutVal > WWDT_TIMEOUT_MAX)
{
timeoutVal = WWDT_TIMEOUT_MAX;
retval = WWDT_FUNC_BAD_PARAM;
}
LPC_WDT->TC = timeoutVal;
return retval;
}
/********************************************************************//**
* @brief Set WDT timeout (cal by usec) to TC register
*
* @param[in] timeout The time (usec) to generate watchdog event if
* the watchdog counter reach this value
*
* @return WWDT_FUNC_OK if success
*********************************************************************/
int8_t WWDT_SetTimeOut(uint32_t timeout)
{
return WWDT_SetTimeOutRaw(WDT_GET_FROM_USEC(timeout));
}
/*********************************************************************//**
* @brief Initial for Watchdog function by setting timeout
*
* @param[in] TimeOut time out value, should be in range:
* 2048 .. 134217728
*
* @return WWDT_FUNC_OK if success
**********************************************************************/
int8_t WWDT_Init(uint32_t TimeOut)
{
return WWDT_SetTimeOut(TimeOut);
}
/*********************************************************************//**
* @brief Configure the WatchDog by initialization all the timing
* value for register (Warning value, Window value,...)
*
* @param wdtCfg a the st_Wdt_Config type value
*
* @return None
**********************************************************************/
void WWDT_Configure(st_Wdt_Config wdtCfg)
{
WWDT_SetTimeOut(wdtCfg.wdtTmrConst);
if(wdtCfg.wdtEnable)
{
LPC_WDT->MOD |= WWDT_WDMOD_WDEN;
}
else
{
LPC_WDT->MOD &= ~WWDT_WDMOD_WDEN;
}
if(wdtCfg.wdtReset)
{
LPC_WDT->MOD |= WWDT_WDMOD_WDRESET;
}
else
{
LPC_WDT->MOD &= ~WWDT_WDMOD_WDRESET;
}
if(wdtCfg.wdtProtect)
{
LPC_WDT->MOD |= WWDT_WDMOD_WDPROTECT;
}
else
{
LPC_WDT->MOD &= ~WWDT_WDMOD_WDPROTECT;
}
WWDT_SetWarning(wdtCfg.wdtWarningVal);
WWDT_SetWindow(wdtCfg.wdtWindowVal);
}
/*********************************************************************//**
* @brief Start WatchDog with specific Timeout
*
* @param TimeOut specific Timeout for WatchDog event
*
* @return WWDT_FUNC_OK if success
**********************************************************************/
int8_t WWDT_Start(uint32_t TimeOut)
{
int8_t retval = WWDT_FUNC_OK;
retval = WWDT_SetTimeOut(TimeOut);
WWDT_Cmd(ENABLE);
return retval;
}
/********************************************************************//**
* @brief Update WDT timeout value and feed
*
* @param[in] WarnTime time to generate watchdog warning interrupt(us)
* should be in range: 2048 .. 134217728
*
* @return None
*********************************************************************/
void WWDT_SetTimerConstant(uint32_t constVal)
{
LPC_WDT->TC = constVal;
}
/*********************************************************************//**
* @brief Enable/Disable WDT function
*
* @param[in] Mode WWDT mode that will be enabled/disabled, should be:
* - WWDT_PROTECT_MODE : protect mode
* - WWDT_RESET_MODE : reset mode
*
* @param[in] NewState new state of protection function, should be:
* - ENABLE: The watchdog reload value can be changed at any time
* - DISABLE: The watchdog reload value can be changed only after
* the counter is below the value of WDWARNINT and WDWINDOW
*
* @return None
**********************************************************************/
void WWDT_SetMode(uint8_t mode, FunctionalState NewState)
{
if (mode == WWDT_PROTECT_MODE )
{
if(NewState == ENABLE)
LPC_WDT->MOD |= WWDT_WDMOD_WDPROTECT;
else
LPC_WDT->MOD &= ~WWDT_WDMOD_WDPROTECT;
}
else if(mode == WWDT_RESET_MODE)
{
if(NewState == ENABLE)
LPC_WDT->MOD |= WWDT_WDMOD_WDRESET;
else
LPC_WDT->MOD &= ~WWDT_WDMOD_WDRESET;
}
}
/*********************************************************************//**
* @brief Enable/Disable WWDT activity
*
* @param[in] NewState To enable/disable the WatchDog
*
* @return None
**********************************************************************/
void WWDT_Enable(FunctionalState NewState)
{
if(NewState == ENABLE)
{
LPC_WDT->MOD |= WWDT_WDMOD_WDEN;
}
else
{
LPC_WDT->MOD &= ~WWDT_WDMOD_WDEN;
}
}
/*********************************************************************//**
* @brief Enable/Disable WWDT activity. In case of Enable, it will
* do feeding WatchDog for its normal operation.
*
* @param[in] NewState To enable/disable the WatchDog
*
* @return None
**********************************************************************/
void WWDT_Cmd(FunctionalState NewState)
{
if(NewState == ENABLE)
{
LPC_WDT->MOD |= WWDT_WDMOD_WDEN;
//Load the Feed register to start using WDT
WWDT_Feed();
}
else
{
LPC_WDT->MOD &= ~WWDT_WDMOD_WDEN;
}
}
/********************************************************************//**
* @brief Set the warning value to register to generate interrupt
* (if enable) if the watchdog timer matches this value.
*
* @param[in] warnVal The value (counter) will write directly to Warning
* Register w/o pre-calc
*
* @return WWDT_FUNC_OK if success
*********************************************************************/
int8_t WWDT_SetWarningRaw(uint32_t warnVal)
{
int8_t retval = WWDT_FUNC_OK;
if(warnVal < WWDT_WARNINT_MIN)
{
warnVal = WWDT_WARNINT_MIN;
retval = WWDT_FUNC_BAD_PARAM;
}
else if (warnVal > WWDT_WARNINT_MAX)
{
warnVal = WWDT_WARNINT_MAX;
retval = WWDT_FUNC_BAD_PARAM;
}
LPC_WDT->WARNINT = warnVal;
return retval;
}
/********************************************************************//**
* @brief Update WDT warning time (cal by usec) to warning register
*
* @param[in] WarnTime The time (usec) to generate watchdog warning
* interrupt should be in range: 2048 .. 8192
*
* @return WWDT_FUNC_OK if success
*********************************************************************/
int8_t WWDT_SetWarning(uint32_t WarnTime)
{
return WWDT_SetWarningRaw(WDT_GET_FROM_USEC(WarnTime));
}
/********************************************************************//**
* @brief Update WDT Windows value (by counter) to Window Register
* of WatchDog
*
* @param[in] wndVal The value (counter) will write directly to Window
* Register w/o pre-calc
*
* @return WWDT_FUNC_OK if success
*********************************************************************/
int8_t WWDT_SetWindowRaw(uint32_t wndVal)
{
int8_t retval = WWDT_FUNC_OK;
if(wndVal < WWDT_WINDOW_MIN)
{
wndVal = WWDT_WINDOW_MIN;
retval = WWDT_FUNC_BAD_PARAM;
}
else if (wndVal > WWDT_WINDOW_MAX)
{
wndVal = WWDT_WINDOW_MAX;
retval = WWDT_FUNC_BAD_PARAM;
}
LPC_WDT->WINDOW = wndVal;
return retval;
}
/********************************************************************//**
* @brief Update WDT Windows value (by usec) to Window Register
* of WatchDog
*
* @param[in] WindowedTime Expected time (usec) to set watchdog window event
*
* @return WWDT_FUNC_OK if success
*********************************************************************/
int8_t WWDT_SetWindow(uint32_t WindowedTime)
{
return WWDT_SetWindowRaw(WDT_GET_FROM_USEC(WindowedTime));
}
/********************************************************************//**
* @brief Update WDT timeout value for WatchDog event(s)
*
* @param[in] TimeOut Time Out value (usec) to be updated, should be
* in range: 2048 .. 134217728
*
* @return None
*********************************************************************/
void WDT_UpdateTimeOut(uint32_t TimeOut)
{
/* check WDPROTECT,
* if it is enable, wait until the counter is below the value of
* WDWARNINT and WDWINDOW
*/
if(LPC_WDT->MOD & (1<<4))
{
while((LPC_WDT->TV <(LPC_WDT->WARNINT & WWDT_WDWARNINT_MASK))\
&&(LPC_WDT->TV <(LPC_WDT->WINDOW & WWDT_WDTC_MASK)));
}
WWDT_SetTimeOut(TimeOut);
}
/********************************************************************//**
* @brief Read WWDT status flag
*
* @param[in] Status kind of status flag that you want to get, should be:
* - WWDT_WARNINT_FLAG: watchdog interrupt flag
* - WWDT_TIMEOUT_FLAG: watchdog time-out flag
*
* @return Time out flag status of WDT
*********************************************************************/
FlagStatus WWDT_GetStatus (uint8_t Status)
{
if(Status == WWDT_WARNINT_FLAG)
{
return ((FlagStatus)(LPC_WDT->MOD & (1<<3)));
}
else if (Status == WWDT_TIMEOUT_FLAG)
{
return ((FlagStatus)(LPC_WDT->MOD & (1<<2)));
}
return RESET;
}
/********************************************************************//**
* @brief Clear WWDT status flag
*
* @param[in] Status kind of status flag that you want to get, should be:
* - WWDT_WARNINT_FLAG: watchdog interrupt flag
* - WWDT_TIMEOUT_FLAG: watchdog time-out flag
*
* @return None
*********************************************************************/
void WWDT_ClearStatusFlag (uint8_t flag)
{
if(flag == WWDT_WARNINT_FLAG)
{
// Write 1 to this bit to clear itself
LPC_WDT->MOD |= WWDT_WDMOD_WDINT;
}
else if(flag == WWDT_TIMEOUT_FLAG)
{
// Write 0 to this bit to clear itself
LPC_WDT->MOD &= ~ WWDT_WDMOD_WDTOF;
}
}
/********************************************************************//**
* @brief Clear WDT Time out flag
* @param None
* @return None
*********************************************************************/
void WWDT_ClrTimeOutFlag (void)
{
LPC_WDT->MOD &= ~ WWDT_WDMOD_WDTOF;
}
/********************************************************************//**
* @brief Following the standard sequence to Feed the WatchDog Timer
*
* @param None
*
* @return None
*********************************************************************/
void WWDT_FeedStdSeq (void)
{
LPC_WDT->FEED = 0xAA;
LPC_WDT->FEED = 0x55;
}
/********************************************************************//**
* @brief After set WDTEN, call this function to start Watchdog
* or reload the Watchdog timer
*
* @param None
*
* @return None
*********************************************************************/
void WWDT_Feed (void)
{
// Disable irq interrupt
__disable_irq();
WWDT_FeedStdSeq();
// Then enable irq interrupt
__enable_irq();
}
/********************************************************************//**
* @brief Get the current value of WDT
*
* @param None
*
* @return Current value of WDT
*********************************************************************/
uint32_t WWDT_GetCurrentCount(void)
{
return LPC_WDT->TV;
}
/**
* @}
*/
#endif /*_WDT*/
/**
* @}
*/
/* --------------------------------- End Of File ------------------------------ */