fsl_snvs_hp.h

/*
 * Copyright (c) 2016, Freescale Semiconductor, Inc.
 * Copyright 2017-2022, NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_SNVS_HP_H_
#define _FSL_SNVS_HP_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_SNVS_HP_DRIVER_VERSION (MAKE_VERSION(2, 3, 2)) 
 
typedef enum _snvs_hp_interrupts
{
    kSNVS_RTC_AlarmInterrupt    = SNVS_HPCR_HPTA_EN_MASK, 
    kSNVS_RTC_PeriodicInterrupt = SNVS_HPCR_PI_EN_MASK,   
} snvs_hp_interrupts_t;
 
typedef enum _snvs_hp_status_flags
{
    kSNVS_RTC_AlarmInterruptFlag    = SNVS_HPSR_HPTA_MASK,          
    kSNVS_RTC_PeriodicInterruptFlag = SNVS_HPSR_PI_MASK,            
    kSNVS_ZMK_ZeroFlag              = (int)SNVS_HPSR_ZMK_ZERO_MASK, 
    kSNVS_OTPMK_ZeroFlag            = SNVS_HPSR_OTPMK_ZERO_MASK,    
} snvs_hp_status_flags_t;
 
/* Re-map Security Violation for RT11xx specific violation*/
#ifndef SNVS_HPSVSR_SV0_MASK
#define SNVS_HPSVSR_SV0_MASK SNVS_HPSVSR_CAAM_MASK
#endif
 
#ifndef SNVS_HPSVSR_SV1_MASK
#define SNVS_HPSVSR_SV1_MASK SNVS_HPSVSR_JTAGC_MASK
#endif
 
#ifndef SNVS_HPSVSR_SV2_MASK
#define SNVS_HPSVSR_SV2_MASK SNVS_HPSVSR_WDOG2_MASK
#endif
 
#ifndef SNVS_HPSVSR_SV4_MASK
#define SNVS_HPSVSR_SV4_MASK SNVS_HPSVSR_SRC_MASK
#endif
 
#ifndef SNVS_HPSVSR_SV5_MASK
#define SNVS_HPSVSR_SV5_MASK SNVS_HPSVSR_OCOTP_MASK
#endif
 
typedef enum _snvs_hp_sv_status_flags
{
    kSNVS_LP_ViolationFlag = SNVS_HPSVSR_SW_LPSV_MASK,           
    kSNVS_ZMK_EccFailFlag  = SNVS_HPSVSR_ZMK_ECC_FAIL_MASK,      
    kSNVS_LP_SoftwareViolationFlag   = SNVS_HPSVSR_SW_LPSV_MASK, 
    kSNVS_FatalSoftwareViolationFlag = SNVS_HPSVSR_SW_FSV_MASK,  
    kSNVS_SoftwareViolationFlag      = SNVS_HPSVSR_SW_SV_MASK,   
    kSNVS_Violation0Flag             = SNVS_HPSVSR_SV0_MASK,     
    kSNVS_Violation1Flag             = SNVS_HPSVSR_SV1_MASK,     
    kSNVS_Violation2Flag             = SNVS_HPSVSR_SV2_MASK,     
#if defined(SNVS_HPSVSR_SV3_MASK)
    kSNVS_Violation3Flag = SNVS_HPSVSR_SV3_MASK, 
#endif                                           /* SNVS_HPSVSR_SV3_MASK */
    kSNVS_Violation4Flag = SNVS_HPSVSR_SV4_MASK, 
    kSNVS_Violation5Flag = SNVS_HPSVSR_SV5_MASK, 
} snvs_hp_sv_status_flags_t;
 
#define SNVS_MAKE_HP_SV_FLAG(x) (1U << (SNVS_HPSVSR_SV0_SHIFT + (x)))
 
typedef struct _snvs_hp_rtc_datetime
{
    uint16_t year;  
    uint8_t month;  
    uint8_t day;    
    uint8_t hour;   
    uint8_t minute; 
    uint8_t second; 
} snvs_hp_rtc_datetime_t;
 
typedef struct _snvs_hp_rtc_config
{
    bool rtcCalEnable;              
    uint32_t rtcCalValue;           
    uint32_t periodicInterruptFreq; 
} snvs_hp_rtc_config_t;
 
typedef enum _snvs_hp_ssm_state
{
    kSNVS_SSMInit      = 0x00, 
    kSNVS_SSMHardFail  = 0x01, 
    kSNVS_SSMSoftFail  = 0x03, 
    kSNVS_SSMInitInter = 0x08, 
    kSNVS_SSMCheck     = 0x09, 
    kSNVS_SSMNonSecure = 0x0B, 
    kSNVS_SSMTrusted   = 0x0D, 
    kSNVS_SSMSecure    = 0x0F, 
} snvs_hp_ssm_state_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
void SNVS_HP_Init(SNVS_Type *base);
 
void SNVS_HP_Deinit(SNVS_Type *base);
 
void SNVS_HP_RTC_Init(SNVS_Type *base, const snvs_hp_rtc_config_t *config);
 
void SNVS_HP_RTC_Deinit(SNVS_Type *base);
 
void SNVS_HP_RTC_GetDefaultConfig(snvs_hp_rtc_config_t *config);
 
status_t SNVS_HP_RTC_SetDatetime(SNVS_Type *base, const snvs_hp_rtc_datetime_t *datetime);
 
void SNVS_HP_RTC_GetDatetime(SNVS_Type *base, snvs_hp_rtc_datetime_t *datetime);
 
status_t SNVS_HP_RTC_SetAlarm(SNVS_Type *base, const snvs_hp_rtc_datetime_t *alarmTime);
 
void SNVS_HP_RTC_GetAlarm(SNVS_Type *base, snvs_hp_rtc_datetime_t *datetime);
 
#if (defined(FSL_FEATURE_SNVS_HAS_SRTC) && (FSL_FEATURE_SNVS_HAS_SRTC > 0))
void SNVS_HP_RTC_TimeSynchronize(SNVS_Type *base);
#endif /* FSL_FEATURE_SNVS_HAS_SRTC */
 
static inline void SNVS_HP_RTC_EnableInterrupts(SNVS_Type *base, uint32_t mask)
{
    base->HPCR |= mask;
}
 
static inline void SNVS_HP_RTC_DisableInterrupts(SNVS_Type *base, uint32_t mask)
{
    base->HPCR &= ~mask;
}
 
uint32_t SNVS_HP_RTC_GetEnabledInterrupts(SNVS_Type *base);
 
uint32_t SNVS_HP_RTC_GetStatusFlags(SNVS_Type *base);
 
static inline void SNVS_HP_RTC_ClearStatusFlags(SNVS_Type *base, uint32_t mask)
{
    base->HPSR |= mask;
}
 
static inline void SNVS_HP_RTC_StartTimer(SNVS_Type *base)
{
    base->HPCR |= SNVS_HPCR_RTC_EN_MASK;
    while (0U == (base->HPCR & SNVS_HPCR_RTC_EN_MASK))
    {
    }
}
 
static inline void SNVS_HP_RTC_StopTimer(SNVS_Type *base)
{
    base->HPCR &= ~SNVS_HPCR_RTC_EN_MASK;
    while ((base->HPCR & SNVS_HPCR_RTC_EN_MASK) != 0U)
    {
    }
}
 
static inline void SNVS_HP_EnableMasterKeySelection(SNVS_Type *base, bool enable)
{
    if (enable)
    {
        base->HPCOMR |= SNVS_HPCOMR_MKS_EN_MASK;
    }
    else
    {
        base->HPCOMR &= (~SNVS_HPCOMR_MKS_EN_MASK);
    }
}
 
static inline void SNVS_HP_ProgramZeroizableMasterKey(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_PROG_ZMK_MASK;
}
 
static inline void SNVS_HP_ChangeSSMState(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_SSM_ST_MASK;
}
 
static inline void SNVS_HP_SetSoftwareFatalSecurityViolation(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_SW_FSV_MASK;
}
 
static inline void SNVS_HP_SetSoftwareSecurityViolation(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_SW_SV_MASK;
}
 
static inline snvs_hp_ssm_state_t SNVS_HP_GetSSMState(SNVS_Type *base)
{
    return (snvs_hp_ssm_state_t)((uint32_t)((base->HPSR & SNVS_HPSR_SSM_STATE_MASK) >> SNVS_HPSR_SSM_STATE_SHIFT));
}
 
static inline void SNVS_HP_ResetLP(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_LP_SWR_MASK;
}
 
static inline void SNVS_HP_EnableHighAssuranceCounter(SNVS_Type *base, bool enable)
{
    if (enable)
    {
        base->HPCOMR |= SNVS_HPCOMR_HAC_EN_MASK;
    }
    else
    {
        base->HPCOMR &= (~SNVS_HPCOMR_HAC_EN_MASK);
    }
}
 
static inline void SNVS_HP_StartHighAssuranceCounter(SNVS_Type *base, bool start)
{
    if (start)
    {
        base->HPCOMR &= (~SNVS_HPCOMR_HAC_STOP_MASK);
    }
    else
    {
        base->HPCOMR |= SNVS_HPCOMR_HAC_STOP_MASK;
    }
}
 
static inline void SNVS_HP_SetHighAssuranceCounterInitialValue(SNVS_Type *base, uint32_t value)
{
    base->HPHACIVR = value;
}
 
static inline void SNVS_HP_LoadHighAssuranceCounter(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_HAC_LOAD_MASK;
}
 
static inline uint32_t SNVS_HP_GetHighAssuranceCounter(SNVS_Type *base)
{
    return base->HPHACR;
}
 
static inline void SNVS_HP_ClearHighAssuranceCounter(SNVS_Type *base)
{
    base->HPCOMR |= SNVS_HPCOMR_HAC_CLEAR_MASK;
}
 
static inline void SNVS_HP_LockHighAssuranceCounter(SNVS_Type *base)
{
    base->HPLR |= SNVS_HPLR_HAC_L_MASK;
}
 
static inline uint32_t SNVS_HP_GetStatusFlags(SNVS_Type *base)
{
    return base->HPSR;
}
 
static inline void SNVS_HP_ClearStatusFlags(SNVS_Type *base, uint32_t mask)
{
    base->HPSR = mask;
}
 
static inline uint32_t SNVS_HP_GetSecurityViolationStatusFlags(SNVS_Type *base)
{
    return base->HPSVSR;
}
 
static inline void SNVS_HP_ClearSecurityViolationStatusFlags(SNVS_Type *base, uint32_t mask)
{
    base->HPSVSR = mask;
}
 
#if defined(FSL_FEATURE_SNVS_HAS_SET_LOCK) && (FSL_FEATURE_SNVS_HAS_SET_LOCK > 0)
void SNVS_HP_SetLocks(SNVS_Type *base);
#endif /* FSL_FEATURE_SNVS_HAS_SET_LOCK */
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_SNVS_HP_H_ */