fsl_cdog.h

Go to the documentation of this file.

/*
 * Copyright 2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_CDOG_H_
#define _FSL_CDOG_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 *******************************************************************************/
 
#define FSL_CDOG_DRIVER_VERSION (MAKE_VERSION(2, 1, 1))
typedef struct
{
    uint8_t lock : 2;
    uint8_t timeout : 3;
    uint8_t miscompare : 3;
    uint8_t sequence : 3;
    uint8_t state : 3;
    uint8_t address : 3;
    uint8_t reserved : 8;
    uint8_t irq_pause : 2;
    uint8_t debug_halt : 2;
} cdog_config_t;
 
enum __cdog_debug_Action_ctrl_enum
{
    kCDOG_DebugHaltCtrl_Run   = 0x1,
    kCDOG_DebugHaltCtrl_Pause = 0x2,
};
 
enum __cdog_irq_pause_ctrl_enum
{
    kCDOG_IrqPauseCtrl_Run   = 0x1,
    kCDOG_IrqPauseCtrl_Pause = 0x2,
};
 
enum __cdog_fault_ctrl_enum
{
    kCDOG_FaultCtrl_EnableReset     = 0x1U,
    kCDOG_FaultCtrl_EnableInterrupt = 0x2U,
    kCDOG_FaultCtrl_NoAction        = 0x4U,
};
 
enum __code_lock_ctrl_enum
{
    kCDOG_LockCtrl_Lock   = 0x1,
    kCDOG_LockCtrl_Unlock = 0x2,
};
 
typedef uint32_t secure_counter_t;
 
#define SC_ADD(add)                          \
    do                                       \
    {                                        \
        CDOG->ADD = (secure_counter_t)(add); \
    } while (0)
 
#define SC_ADD1                              \
    do                                       \
    {                                        \
        CDOG->ADD1 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_ADD16                              \
    do                                        \
    {                                         \
        CDOG->ADD16 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_ADD256                              \
    do                                         \
    {                                          \
        CDOG->ADD256 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_SUB(sub)                          \
    do                                       \
    {                                        \
        CDOG->SUB = (secure_counter_t)(sub); \
    } while (0)
 
#define SC_SUB1                              \
    do                                       \
    {                                        \
        CDOG->SUB1 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_SUB16                              \
    do                                        \
    {                                         \
        CDOG->SUB16 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_SUB256                              \
    do                                         \
    {                                          \
        CDOG->SUB256 = (secure_counter_t)0x1U; \
    } while (0)
 
#define SC_CHECK(val)                          \
    do                                         \
    {                                          \
        CDOG->RESTART = (secure_counter_t)val; \
    } while (0)
 
/*******************************************************************************
 * API
 *******************************************************************************/
 
extern void CDOG_DriverIRQHandler(void);
 
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
 
status_t CDOG_Init(CDOG_Type *base, cdog_config_t *conf);
 
void CDOG_Deinit(CDOG_Type *base);
 
void CDOG_GetDefaultConfig(cdog_config_t *conf);
 
void CDOG_Stop(CDOG_Type *base, uint32_t stop);
 
void CDOG_Start(CDOG_Type *base, uint32_t reload, uint32_t start);
 
void CDOG_Check(CDOG_Type *base, uint32_t check);
 
void CDOG_Set(CDOG_Type *base, uint32_t stop, uint32_t reload, uint32_t start);
 
void CDOG_Add(CDOG_Type *base, uint32_t add);
 
void CDOG_Add1(CDOG_Type *base);
 
void CDOG_Add16(CDOG_Type *base);
 
void CDOG_Add256(CDOG_Type *base);
 
void CDOG_Sub(CDOG_Type *base, uint32_t sub);
 
void CDOG_Sub1(CDOG_Type *base);
 
void CDOG_Sub16(CDOG_Type *base);
 
void CDOG_Sub256(CDOG_Type *base);
 
void CDOG_WritePersistent(CDOG_Type *base, uint32_t value);
 
uint32_t CDOG_ReadPersistent(CDOG_Type *base);
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
 /* end of group cdog */
 
#endif /* _FSL_CDOG_H_ */