fsl_rtwdog.h

/*
 * Copyright (c) 2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_RTWDOG_H_
#define _FSL_RTWDOG_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 *******************************************************************************/
#define WDOG_FIRST_WORD_OF_UNLOCK  (RTWDOG_UPDATE_KEY & 0xFFFFU)          
#define WDOG_SECOND_WORD_OF_UNLOCK ((RTWDOG_UPDATE_KEY >> 16U) & 0xFFFFU) 
 
#define WDOG_FIRST_WORD_OF_REFRESH  (RTWDOG_REFRESH_KEY & 0xFFFFU)          
#define WDOG_SECOND_WORD_OF_REFRESH ((RTWDOG_REFRESH_KEY >> 16U) & 0xFFFFU) 
#define FSL_RTWDOG_DRIVER_VERSION (MAKE_VERSION(2, 1, 2))
typedef enum _rtwdog_clock_source
{
    kRTWDOG_ClockSource0 = 0U, 
    kRTWDOG_ClockSource1 = 1U, 
    kRTWDOG_ClockSource2 = 2U, 
    kRTWDOG_ClockSource3 = 3U, 
} rtwdog_clock_source_t;
 
typedef enum _rtwdog_clock_prescaler
{
    kRTWDOG_ClockPrescalerDivide1   = 0x0U, 
    kRTWDOG_ClockPrescalerDivide256 = 0x1U, 
} rtwdog_clock_prescaler_t;
 
typedef struct _rtwdog_work_mode
{
    bool enableWait;  
    bool enableStop;  
    bool enableDebug; 
} rtwdog_work_mode_t;
 
typedef enum _rtwdog_test_mode
{
    kRTWDOG_TestModeDisabled = 0U, 
    kRTWDOG_UserModeEnabled  = 1U, 
    kRTWDOG_LowByteTest      = 2U, 
    kRTWDOG_HighByteTest     = 3U, 
} rtwdog_test_mode_t;
 
typedef struct _rtwdog_config
{
    bool enableRtwdog;                  
    rtwdog_clock_source_t clockSource;  
    rtwdog_clock_prescaler_t prescaler; 
    rtwdog_work_mode_t workMode;        
    rtwdog_test_mode_t testMode;        
    bool enableUpdate;                  
    bool enableInterrupt;               
    bool enableWindowMode;              
    uint16_t windowValue;               
    uint16_t timeoutValue;              
} rtwdog_config_t;
 
enum _rtwdog_interrupt_enable_t
{
    kRTWDOG_InterruptEnable = RTWDOG_CS_INT_MASK, 
};
 
enum _rtwdog_status_flags_t
{
    kRTWDOG_RunningFlag   = RTWDOG_CS_EN_MASK,  
    kRTWDOG_InterruptFlag = RTWDOG_CS_FLG_MASK, 
};
 
/*******************************************************************************
 * API
 *******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
 
void RTWDOG_GetDefaultConfig(rtwdog_config_t *config);
 
#if defined(DOXYGEN_OUTPUT) && DOXYGEN_OUTPUT
void RTWDOG_Init(RTWDOG_Type *base, const rtwdog_config_t *config);
#else
AT_QUICKACCESS_SECTION_CODE(void RTWDOG_Init(RTWDOG_Type *base, const rtwdog_config_t *config));
#endif
 
void RTWDOG_Deinit(RTWDOG_Type *base);
 
/* @} */
 
static inline void RTWDOG_Enable(RTWDOG_Type *base)
{
    base->CS |= RTWDOG_CS_EN_MASK;
}
 
static inline void RTWDOG_Disable(RTWDOG_Type *base)
{
    base->CS &= ~RTWDOG_CS_EN_MASK;
}
 
static inline void RTWDOG_EnableInterrupts(RTWDOG_Type *base, uint32_t mask)
{
    base->CS |= mask;
}
 
static inline void RTWDOG_DisableInterrupts(RTWDOG_Type *base, uint32_t mask)
{
    base->CS &= ~mask;
}
 
static inline uint32_t RTWDOG_GetStatusFlags(RTWDOG_Type *base)
{
    return (base->CS & (RTWDOG_CS_EN_MASK | RTWDOG_CS_FLG_MASK));
}
 
static inline void RTWDOG_EnableWindowMode(RTWDOG_Type *base, bool enable)
{
    if (enable)
    {
        base->CS |= RTWDOG_CS_WIN_MASK;
    }
    else
    {
        base->CS &= ~RTWDOG_CS_WIN_MASK;
    }
}
 
static inline uint32_t RTWDOG_CountToMesec(RTWDOG_Type *base, uint32_t count, uint32_t clockFreqInHz)
{
    if ((base->CS & RTWDOG_CS_PRES_MASK) != 0U)
    {
        clockFreqInHz /= 256U;
    }
    return count * 1000U / clockFreqInHz;
}
 
void RTWDOG_ClearStatusFlags(RTWDOG_Type *base, uint32_t mask);
 
static inline void RTWDOG_SetTimeoutValue(RTWDOG_Type *base, uint16_t timeoutCount)
{
    base->TOVAL = timeoutCount;
}
 
static inline void RTWDOG_SetWindowValue(RTWDOG_Type *base, uint16_t windowValue)
{
    base->WIN = windowValue;
}
 
__STATIC_FORCEINLINE void RTWDOG_Unlock(RTWDOG_Type *base)
{
    if (((base->CS) & RTWDOG_CS_CMD32EN_MASK) != 0U)
    {
        base->CNT = RTWDOG_UPDATE_KEY;
    }
    else
    {
        base->CNT = WDOG_FIRST_WORD_OF_UNLOCK;
        base->CNT = WDOG_SECOND_WORD_OF_UNLOCK;
    }
    while ((base->CS & RTWDOG_CS_ULK_MASK) == 0U)
    {
    }
}
 
static inline void RTWDOG_Refresh(RTWDOG_Type *base)
{
    uint32_t primaskValue = 0U;
    primaskValue          = DisableGlobalIRQ();
    if (((base->CS) & RTWDOG_CS_CMD32EN_MASK) != 0U)
    {
        base->CNT = RTWDOG_REFRESH_KEY;
    }
    else
    {
        base->CNT = WDOG_FIRST_WORD_OF_REFRESH;
        base->CNT = WDOG_SECOND_WORD_OF_REFRESH;
    }
    EnableGlobalIRQ(primaskValue);
}
 
static inline uint16_t RTWDOG_GetCounterValue(RTWDOG_Type *base)
{
    return (uint16_t)base->CNT;
}
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
 
#endif /* _FSL_RTWDOG_H_ */