libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/imxrt/libraries/MIMXRT1020/MIMXRT1021/drivers/fsl_snvs_lp.c

1367 lines
46 KiB
C
Raw Blame History

/*
* Copyright (c) 2016, Freescale Semiconductor, Inc.
* Copyright 2017-2021, NXP
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "fsl_snvs_lp.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/* Component ID definition, used by tools. */
#ifndef FSL_COMPONENT_ID
#define FSL_COMPONENT_ID "platform.drivers.snvs_lp"
#endif
#define SECONDS_IN_A_DAY (86400U)
#define SECONDS_IN_A_HOUR (3600U)
#define SECONDS_IN_A_MINUTE (60U)
#define DAYS_IN_A_YEAR (365U)
#define YEAR_RANGE_START (1970U)
#define YEAR_RANGE_END (2099U)
#define SNVS_DEFAULT_PGD_VALUE (0x41736166U)
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief Checks whether the date and time passed in is valid
*
* @param datetime Pointer to structure where the date and time details are stored
*
* @return Returns false if the date & time details are out of range; true if in range
*/
static bool SNVS_LP_CheckDatetimeFormat(const snvs_lp_srtc_datetime_t *datetime);
/*!
* @brief Converts time data from datetime to seconds
*
* @param datetime Pointer to datetime structure where the date and time details are stored
*
* @return The result of the conversion in seconds
*/
static uint32_t SNVS_LP_ConvertDatetimeToSeconds(const snvs_lp_srtc_datetime_t *datetime);
/*!
* @brief Converts time data from seconds to a datetime structure
*
* @param seconds Seconds value that needs to be converted to datetime format
* @param datetime Pointer to the datetime structure where the result of the conversion is stored
*/
static void SNVS_LP_ConvertSecondsToDatetime(uint32_t seconds, snvs_lp_srtc_datetime_t *datetime);
/*!
* @brief Returns SRTC time in seconds.
*
* This function is used internally to get actual SRTC time in seconds.
*
* @param base SNVS peripheral base address
*
* @return SRTC time in seconds
*/
static uint32_t SNVS_LP_SRTC_GetSeconds(SNVS_Type *base);
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
/*!
* @brief Get the SNVS instance from peripheral base address.
*
* @param base SNVS peripheral base address.
*
* @return SNVS instance.
*/
static uint32_t SNVS_LP_GetInstance(SNVS_Type *base);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/*******************************************************************************
* Variables
******************************************************************************/
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
/*! @brief Pointer to snvs_lp clock. */
const clock_ip_name_t s_snvsLpClock[] = SNVS_LP_CLOCKS;
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/*******************************************************************************
* Code
******************************************************************************/
static bool SNVS_LP_CheckDatetimeFormat(const snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
/* Table of days in a month for a non leap year. First entry in the table is not used,
* valid months start from 1
*/
uint8_t daysPerMonth[] = {0U, 31U, 28U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
/* Check year, month, hour, minute, seconds */
if ((datetime->year < YEAR_RANGE_START) || (datetime->year > YEAR_RANGE_END) || (datetime->month > 12U) ||
(datetime->month < 1U) || (datetime->hour >= 24U) || (datetime->minute >= 60U) || (datetime->second >= 60U))
{
/* If not correct then error*/
return false;
}
/* Adjust the days in February for a leap year */
if ((((datetime->year & 3U) == 0U) && (datetime->year % 100U != 0U)) || (datetime->year % 400U == 0U))
{
daysPerMonth[2] = 29U;
}
/* Check the validity of the day */
if ((datetime->day > daysPerMonth[datetime->month]) || (datetime->day < 1U))
{
return false;
}
return true;
}
static uint32_t SNVS_LP_ConvertDatetimeToSeconds(const snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
/* Number of days from begin of the non Leap-year*/
/* Number of days from begin of the non Leap-year*/
uint16_t monthDays[] = {0U, 0U, 31U, 59U, 90U, 120U, 151U, 181U, 212U, 243U, 273U, 304U, 334U};
uint32_t seconds;
/* Compute number of days from 1970 till given year*/
seconds = ((uint32_t)datetime->year - 1970U) * DAYS_IN_A_YEAR;
/* Add leap year days */
seconds += (((uint32_t)datetime->year / 4U) - (1970U / 4U));
/* Add number of days till given month*/
seconds += monthDays[datetime->month];
/* Add days in given month. We subtract the current day as it is
* represented in the hours, minutes and seconds field*/
seconds += ((uint32_t)datetime->day - 1U);
/* For leap year if month less than or equal to Febraury, decrement day counter*/
if ((0U == (datetime->year & 3U)) && (datetime->month <= 2U))
{
seconds--;
}
seconds = (seconds * SECONDS_IN_A_DAY) + (datetime->hour * SECONDS_IN_A_HOUR) +
(datetime->minute * SECONDS_IN_A_MINUTE) + datetime->second;
return seconds;
}
static void SNVS_LP_ConvertSecondsToDatetime(uint32_t seconds, snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
uint32_t x;
uint32_t secondsRemaining, days;
uint16_t daysInYear;
/* Table of days in a month for a non leap year. First entry in the table is not used,
* valid months start from 1
*/
uint8_t daysPerMonth[] = {0U, 31U, 28U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
/* Start with the seconds value that is passed in to be converted to date time format */
secondsRemaining = seconds;
/* Calcuate the number of days, we add 1 for the current day which is represented in the
* hours and seconds field
*/
days = secondsRemaining / SECONDS_IN_A_DAY + 1U;
/* Update seconds left*/
secondsRemaining = secondsRemaining % SECONDS_IN_A_DAY;
/* Calculate the datetime hour, minute and second fields */
datetime->hour = (uint8_t)(secondsRemaining / SECONDS_IN_A_HOUR);
secondsRemaining = secondsRemaining % SECONDS_IN_A_HOUR;
datetime->minute = (uint8_t)(secondsRemaining / 60U);
datetime->second = (uint8_t)(secondsRemaining % SECONDS_IN_A_MINUTE);
/* Calculate year */
daysInYear = DAYS_IN_A_YEAR;
datetime->year = YEAR_RANGE_START;
while (days > daysInYear)
{
/* Decrease day count by a year and increment year by 1 */
days -= daysInYear;
datetime->year++;
/* Adjust the number of days for a leap year */
if ((datetime->year & 3U) != 0U)
{
daysInYear = DAYS_IN_A_YEAR;
}
else
{
daysInYear = DAYS_IN_A_YEAR + 1U;
}
}
/* Adjust the days in February for a leap year */
if (0U == (datetime->year & 3U))
{
daysPerMonth[2] = 29U;
}
for (x = 1U; x <= 12U; x++)
{
if (days <= daysPerMonth[x])
{
datetime->month = (uint8_t)x;
break;
}
else
{
days -= daysPerMonth[x];
}
}
datetime->day = (uint8_t)days;
}
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
static uint32_t SNVS_LP_GetInstance(SNVS_Type *base)
{
return 0U;
}
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/*!
* brief Ungates the SNVS clock and configures the peripheral for basic operation.
*
* note This API should be called at the beginning of the application using the SNVS driver.
*
* param base SNVS peripheral base address
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_Init(SNVS_Type *base)
{
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
uint32_t instance = SNVS_LP_GetInstance(base);
CLOCK_EnableClock(s_snvsLpClock[instance]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
/* Power glitch detector: set the PGD/LVD value and clear the previous status. */
#if defined(SNVS_LPPGDR_PGD)
base->LPPGDR = SNVS_DEFAULT_PGD_VALUE;
base->LPSR = SNVS_LPSR_PGD_MASK;
#elif defined(SNVS_LPLVDR_LVD)
base->LPLVDR = SNVS_DEFAULT_PGD_VALUE;
base->LPSR = SNVS_LPSR_LVD_MASK;
#else
#error "No power/voltage detector register defined"
#endif
}
/*!
* brief Deinit the SNVS LP section.
*
* param base SNVS peripheral base address
*/
void SNVS_LP_Deinit(SNVS_Type *base)
{
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
uint32_t instance = SNVS_LP_GetInstance(base);
CLOCK_DisableClock(s_snvsLpClock[instance]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}
/*!
* brief Ungates the SNVS clock and configures the peripheral for basic operation.
*
* note This API should be called at the beginning of the application using the SNVS driver.
*
* param base SNVS peripheral base address
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_SRTC_Init(SNVS_Type *base, const snvs_lp_srtc_config_t *config)
{
assert(config != NULL);
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
uint32_t instance = SNVS_LP_GetInstance(base);
CLOCK_EnableClock(s_snvsLpClock[instance]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
if (config->srtcCalEnable)
{
base->LPCR = (base->LPCR & ~SNVS_LPCR_LPCALB_VAL_MASK) | SNVS_LPCR_LPCALB_VAL(config->srtcCalValue);
base->LPCR |= SNVS_LPCR_LPCALB_EN_MASK;
}
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0)
int pin;
for (pin = (int32_t)kSNVS_ExternalTamper1; pin <= (int32_t)SNVS_LP_MAX_TAMPER; pin++)
{
SNVS_LP_DisableExternalTamper(SNVS, (snvs_lp_external_tamper_t)pin);
SNVS_LP_ClearExternalTamperStatus(SNVS, (snvs_lp_external_tamper_t)pin);
}
#endif /* defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0) */
}
/*!
* brief Stops the SRTC timer.
*
* param base SNVS peripheral base address
*/
void SNVS_LP_SRTC_Deinit(SNVS_Type *base)
{
base->LPCR &= ~SNVS_LPCR_SRTC_ENV_MASK;
#if (!(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && \
defined(SNVS_LP_CLOCKS))
uint32_t instance = SNVS_LP_GetInstance(base);
CLOCK_DisableClock(s_snvsLpClock[instance]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}
/*!
* brief Fills in the SNVS_LP config struct with the default settings.
*
* The default values are as follows.
* code
* config->srtccalenable = false;
* config->srtccalvalue = 0U;
* endcode
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_SRTC_GetDefaultConfig(snvs_lp_srtc_config_t *config)
{
assert(config != NULL);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->srtcCalEnable = false;
config->srtcCalValue = 0U;
}
static uint32_t SNVS_LP_SRTC_GetSeconds(SNVS_Type *base)
{
uint32_t seconds = 0;
uint32_t tmp = 0;
/* Do consecutive reads until value is correct */
do
{
seconds = tmp;
tmp = (base->LPSRTCMR << 17U);
tmp |= (base->LPSRTCLR >> 15U);
} while (tmp != seconds);
return seconds;
}
/*!
* brief Sets the SNVS SRTC date and time according to the given time structure.
*
* param base SNVS peripheral base address
* param datetime Pointer to the structure where the date and time details are stored.
*
* return kStatus_Success: Success in setting the time and starting the SNVS SRTC
* kStatus_InvalidArgument: Error because the datetime format is incorrect
*/
status_t SNVS_LP_SRTC_SetDatetime(SNVS_Type *base, const snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
uint32_t seconds = 0U;
uint32_t tmp = base->LPCR;
/* disable RTC */
SNVS_LP_SRTC_StopTimer(base);
/* Return error if the time provided is not valid */
if (!(SNVS_LP_CheckDatetimeFormat(datetime)))
{
return kStatus_InvalidArgument;
}
/* Set time in seconds */
seconds = SNVS_LP_ConvertDatetimeToSeconds(datetime);
base->LPSRTCMR = (uint32_t)(seconds >> 17U);
base->LPSRTCLR = (uint32_t)(seconds << 15U);
/* reenable SRTC in case that it was enabled before */
if ((tmp & SNVS_LPCR_SRTC_ENV_MASK) != 0U)
{
SNVS_LP_SRTC_StartTimer(base);
}
return kStatus_Success;
}
/*!
* brief Gets the SNVS SRTC time and stores it in the given time structure.
*
* param base SNVS peripheral base address
* param datetime Pointer to the structure where the date and time details are stored.
*/
void SNVS_LP_SRTC_GetDatetime(SNVS_Type *base, snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
SNVS_LP_ConvertSecondsToDatetime(SNVS_LP_SRTC_GetSeconds(base), datetime);
}
/*!
* brief Sets the SNVS SRTC alarm time.
*
* The function sets the SRTC alarm. It also checks whether the specified alarm
* time is greater than the present time. If not, the function does not set the alarm
* and returns an error.
* Please note, that SRTC alarm has limited resolution because only 32 most
* significant bits of SRTC counter are compared to SRTC Alarm register.
* If the alarm time is beyond SRTC resolution, the function does not set the alarm
* and returns an error.
*
* param base SNVS peripheral base address
* param alarmTime Pointer to the structure where the alarm time is stored.
*
* return kStatus_Success: success in setting the SNVS SRTC alarm
* kStatus_InvalidArgument: Error because the alarm datetime format is incorrect
* kStatus_Fail: Error because the alarm time has already passed or is beyond resolution
*/
status_t SNVS_LP_SRTC_SetAlarm(SNVS_Type *base, const snvs_lp_srtc_datetime_t *alarmTime)
{
assert(alarmTime != NULL);
uint32_t alarmSeconds = 0U;
uint32_t currSeconds = 0U;
uint32_t tmp = base->LPCR;
/* Return error if the alarm time provided is not valid */
if (!(SNVS_LP_CheckDatetimeFormat(alarmTime)))
{
return kStatus_InvalidArgument;
}
alarmSeconds = SNVS_LP_ConvertDatetimeToSeconds(alarmTime);
currSeconds = SNVS_LP_SRTC_GetSeconds(base);
/* Return error if the alarm time has passed */
if (alarmSeconds <= currSeconds)
{
return kStatus_Fail;
}
/* disable SRTC alarm interrupt */
base->LPCR &= ~SNVS_LPCR_LPTA_EN_MASK;
while ((base->LPCR & SNVS_LPCR_LPTA_EN_MASK) != 0U)
{
}
/* Set alarm in seconds*/
base->LPTAR = alarmSeconds;
/* reenable SRTC alarm interrupt in case that it was enabled before */
base->LPCR = tmp;
return kStatus_Success;
}
/*!
* brief Returns the SNVS SRTC alarm time.
*
* param base SNVS peripheral base address
* param datetime Pointer to the structure where the alarm date and time details are stored.
*/
void SNVS_LP_SRTC_GetAlarm(SNVS_Type *base, snvs_lp_srtc_datetime_t *datetime)
{
assert(datetime != NULL);
uint32_t alarmSeconds = 0U;
/* Get alarm in seconds */
alarmSeconds = base->LPTAR;
SNVS_LP_ConvertSecondsToDatetime(alarmSeconds, datetime);
}
/*!
* brief Gets the SNVS status flags.
*
* param base SNVS peripheral base address
*
* return The status flags. This is the logical OR of members of the
* enumeration ::snvs_status_flags_t
*/
uint32_t SNVS_LP_SRTC_GetStatusFlags(SNVS_Type *base)
{
uint32_t flags = 0U;
if ((base->LPSR & SNVS_LPSR_LPTA_MASK) != 0U)
{
flags |= (uint32_t)kSNVS_SRTC_AlarmInterruptFlag;
}
return flags;
}
/*!
* brief Gets the enabled SNVS interrupts.
*
* param base SNVS peripheral base address
*
* return The enabled interrupts. This is the logical OR of members of the
* enumeration ::snvs_interrupt_enable_t
*/
uint32_t SNVS_LP_SRTC_GetEnabledInterrupts(SNVS_Type *base)
{
uint32_t val = 0U;
if ((base->LPCR & SNVS_LPCR_LPTA_EN_MASK) != 0U)
{
val |= (uint32_t)kSNVS_SRTC_AlarmInterrupt;
}
return val;
}
/*!
* brief Fills in the SNVS tamper pin config struct with the default settings.
*
* The default values are as follows.
* code
* config->polarity = 0U;
* config->filterenable = 0U;
* config->filter = 0U;
* endcode
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_PassiveTamperPin_GetDefaultConfig(snvs_lp_passive_tamper_t *config)
{
assert(config != NULL);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->polarity = 0U;
#if defined(FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER) && (FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER > 0)
config->filterenable = 0U;
config->filter = 0U;
#endif /* FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER */
}
#if defined(FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS) && (FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS > 0)
/*!
* brief Fills in the SNVS tamper pin config struct with the default settings.
*
* The default values are as follows.
* code
* config->clock = kSNVS_ActiveTamper16HZ;
* config->seed = 0U;
* config->polynomial = 0U;
* endcode
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_TamperPinTx_GetDefaultConfig(tamper_active_tx_config_t *config)
{
assert(config != NULL);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->clock = kSNVS_ActiveTamper16HZ;
config->seed = 0U;
config->polynomial = 0U;
}
/*!
* brief Fills in the SNVS tamper pin config struct with the default settings.
*
* The default values are as follows.
* code
* config->filterenable = 0U;
* config->filter = 0U;
* config->tx = kSNVS_ActiveTamper1;
* endcode
* param config Pointer to the user's SNVS configuration structure.
*/
void SNVS_LP_TamperPinRx_GetDefaultConfig(tamper_active_rx_config_t *config)
{
assert(config != NULL);
/* Initializes the configure structure to zero. */
(void)memset(config, 0, sizeof(*config));
config->filterenable = 0U;
config->filter = 0U;
config->activeTamper = kSNVS_ActiveTamper1;
}
#endif /* FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS */
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0)
/*!
* brief Enables the specified SNVS external tamper.
*
* param base SNVS peripheral base address
* param pin SNVS external tamper pin
* param config Configuration structure of external passive tamper
*/
void SNVS_LP_EnablePassiveTamper(SNVS_Type *base, snvs_lp_external_tamper_t pin, snvs_lp_passive_tamper_t config)
{
switch (pin)
{
case (kSNVS_ExternalTamper1):
/* Set polarity */
if (config.polarity != 0U)
{
SNVS->LPTDCR |= SNVS_LPTDCR_ET1P_MASK;
}
else
{
SNVS->LPTDCR &= ~SNVS_LPTDCR_ET1P_MASK;
}
#if defined(FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER) && (FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER > 0)
/* Enable filter and set it's value, dissable otherwise */
if (config.filterenable != 0U)
{
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF1_EN_MASK;
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF1(config.filter);
}
else
{
SNVS->LPTGFCR &= ~SNVS_LPTGFCR_ETGF1_EN_MASK;
}
#endif /* FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER */
/* enable tamper pin */
base->LPTDCR |= SNVS_LPTDCR_ET1_EN_MASK;
break;
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1)
case (kSNVS_ExternalTamper2):
/* Set polarity */
base->LPTDCR =
(base->LPTDCR & ~(SNVS_LPTDCR_ET2P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDCR_ET2P_SHIFT);
/* Enable filter and set it's value, dissable otherwise */
if (config.filterenable != 0U)
{
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF2_EN_MASK;
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF2(config.filter);
}
else
{
SNVS->LPTGFCR &= ~SNVS_LPTGFCR_ETGF2_EN_MASK;
}
/* enable tamper pin */
SNVS->LPTDCR |= SNVS_LPTDCR_ET2_EN_MASK;
break;
case (kSNVS_ExternalTamper3):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET3P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET3P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF3(config.filter);
/* Enable tamper 3 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF3_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET3_EN_MASK;
break;
case (kSNVS_ExternalTamper4):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET4P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET4P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF4(config.filter);
/* Enable tamper 4 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF4_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET4_EN_MASK;
break;
case (kSNVS_ExternalTamper5):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET5P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET5P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF5(config.filter);
/* Enable tamper 5 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF5_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET5_EN_MASK;
break;
case (kSNVS_ExternalTamper6):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET6P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET6P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF6(config.filter);
/* Enable tamper 6 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF6_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET6_EN_MASK;
break;
case (kSNVS_ExternalTamper7):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET7P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET7P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF7(config.filter);
/* Enable tamper 6 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF7_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET7_EN_MASK;
break;
case (kSNVS_ExternalTamper8):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET8P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET8P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF8(config.filter);
/* Enable tamper 8 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF8_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET8_EN_MASK;
break;
case (kSNVS_ExternalTamper9):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET9P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET9P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF9(config.filter);
/* Enable tamper 9 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF9_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET9_EN_MASK;
break;
case (kSNVS_ExternalTamper10):
/* Set polarity */
base->LPTDC2R =
(base->LPTDC2R & ~(SNVS_LPTDC2R_ET10P_MASK)) | ((uint32_t)config.polarity << SNVS_LPTDC2R_ET10P_SHIFT);
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF10(config.filter);
/* Enable tamper 10 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF10_EN(1U);
}
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET10_EN_MASK;
break;
#endif
default:
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
}
/*!
* brief Disables the specified SNVS external tamper.
*
* param base SNVS peripheral base address
* param pin SNVS external tamper pin
*/
void SNVS_LP_DisableExternalTamper(SNVS_Type *base, snvs_lp_external_tamper_t pin)
{
switch (pin)
{
case (kSNVS_ExternalTamper1):
base->LPTDCR &= ~SNVS_LPTDCR_ET1_EN_MASK;
break;
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1)
case (kSNVS_ExternalTamper2):
base->LPTDCR &= ~SNVS_LPTDCR_ET2_EN_MASK;
break;
case (kSNVS_ExternalTamper3):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET3_EN_MASK;
break;
case (kSNVS_ExternalTamper4):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET4_EN_MASK;
break;
case (kSNVS_ExternalTamper5):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET5_EN_MASK;
break;
case (kSNVS_ExternalTamper6):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET6_EN_MASK;
break;
case (kSNVS_ExternalTamper7):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET7_EN_MASK;
break;
case (kSNVS_ExternalTamper8):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET8_EN_MASK;
break;
case (kSNVS_ExternalTamper9):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET9_EN_MASK;
break;
case (kSNVS_ExternalTamper10):
base->LPTDC2R &= ~SNVS_LPTDC2R_ET10_EN_MASK;
break;
#endif
default:
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
}
/*!
* brief Disable all external tamper.
*
* param base SNVS peripheral base address
*/
void SNVS_LP_DisableAllExternalTamper(SNVS_Type *base)
{
for (int pin = (int8_t)kSNVS_ExternalTamper1; pin <= (int8_t)SNVS_LP_MAX_TAMPER; pin++)
{
SNVS_LP_DisableExternalTamper(SNVS, (snvs_lp_external_tamper_t)pin);
}
}
/*!
* brief Returns status of the specified external tamper.
*
* param base SNVS peripheral base address
* param pin SNVS external tamper pin
*
* return The status flag. This is the enumeration ::snvs_external_tamper_status_t
*/
snvs_lp_external_tamper_status_t SNVS_LP_GetExternalTamperStatus(SNVS_Type *base, snvs_lp_external_tamper_t pin)
{
snvs_lp_external_tamper_status_t status = kSNVS_TamperNotDetected;
switch (pin)
{
case (kSNVS_ExternalTamper1):
status = (bool)(base->LPSR & SNVS_LPSR_ET1D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1)
case (kSNVS_ExternalTamper2):
status = (bool)(base->LPSR & SNVS_LPSR_ET2D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper3):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET3D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper4):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET4D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper5):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET5D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper6):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET6D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper7):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET7D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper8):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET8D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper9):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET9D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
case (kSNVS_ExternalTamper10):
status = (bool)(base->LPTDSR & SNVS_LPTDSR_ET10D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
break;
#endif
default:
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
return status;
}
/*!
* brief Clears status of the specified external tamper.
*
* param base SNVS peripheral base address
* param pin SNVS external tamper pin
*/
void SNVS_LP_ClearExternalTamperStatus(SNVS_Type *base, snvs_lp_external_tamper_t pin)
{
base->LPSR |= SNVS_LPSR_ET1D_MASK;
switch (pin)
{
case (kSNVS_ExternalTamper1):
base->LPSR |= SNVS_LPSR_ET1D_MASK;
break;
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1)
case (kSNVS_ExternalTamper2):
base->LPSR |= SNVS_LPSR_ET2D_MASK;
break;
case (kSNVS_ExternalTamper3):
base->LPTDSR |= SNVS_LPTDSR_ET3D_MASK;
break;
case (kSNVS_ExternalTamper4):
base->LPTDSR |= SNVS_LPTDSR_ET4D_MASK;
break;
case (kSNVS_ExternalTamper5):
base->LPTDSR |= SNVS_LPTDSR_ET5D_MASK;
break;
case (kSNVS_ExternalTamper6):
base->LPTDSR |= SNVS_LPTDSR_ET6D_MASK;
break;
case (kSNVS_ExternalTamper7):
base->LPTDSR |= SNVS_LPTDSR_ET7D_MASK;
break;
case (kSNVS_ExternalTamper8):
base->LPTDSR |= SNVS_LPTDSR_ET8D_MASK;
break;
case (kSNVS_ExternalTamper9):
base->LPTDSR |= SNVS_LPTDSR_ET9D_MASK;
break;
case (kSNVS_ExternalTamper10):
base->LPTDSR |= SNVS_LPTDSR_ET10D_MASK;
break;
#endif
default:
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
}
/*!
* brief Clears status of the all external tamper.
*
* param base SNVS peripheral base address
*/
void SNVS_LP_ClearAllExternalTamperStatus(SNVS_Type *base)
{
for (int pin = (int8_t)kSNVS_ExternalTamper1; pin <= (int8_t)SNVS_LP_MAX_TAMPER; pin++)
{
SNVS_LP_ClearExternalTamperStatus(SNVS, (snvs_lp_external_tamper_t)pin);
}
}
#endif /* (!(defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0)) */
#if defined(FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS) && (FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS > 0)
/*!
* brief Enable active tamper tx external pad
*
* param base SNVS peripheral base address
* param pin SNVS external tamper pin
*/
status_t SNVS_LP_EnableTxActiveTamper(SNVS_Type *base, snvs_lp_active_tx_tamper_t pin, tamper_active_tx_config_t config)
{
status_t status = kStatus_Success;
switch (pin)
{
case (kSNVS_ActiveTamper1):
{
/* Enable active tamper tx external pad */
base->LPATCTLR |= SNVS_LPATCTLR_AT1_PAD_EN_MASK;
/* Set seed and polynomial */
base->LPATCR[0] |= SNVS_LPATCR_Seed(config.seed) | SNVS_LPATCR_Polynomial(config.polynomial);
/* Set clock */
base->LPATCLKR |= SNVS_LPATCLKR_AT1_CLK_CTL(config.clock);
/* Enable active tamper pin */
base->LPATCTLR |= SNVS_LPATCTLR_AT1_EN_MASK;
break;
}
case (kSNVS_ActiveTamper2):
{
base->LPATCTLR |= SNVS_LPATCTLR_AT2_PAD_EN_MASK;
base->LPATCR[1] |= SNVS_LPATCR_Seed(config.seed) | SNVS_LPATCR_Polynomial(config.polynomial);
base->LPATCLKR |= SNVS_LPATCLKR_AT2_CLK_CTL(config.clock);
base->LPATCTLR |= SNVS_LPATCTLR_AT2_EN_MASK;
break;
}
case (kSNVS_ActiveTamper3):
{
base->LPATCTLR |= SNVS_LPATCTLR_AT3_PAD_EN_MASK;
base->LPATCR[2] |= SNVS_LPATCR_Seed(config.seed) | SNVS_LPATCR_Polynomial(config.polynomial);
base->LPATCLKR |= SNVS_LPATCLKR_AT3_CLK_CTL(config.clock);
base->LPATCTLR |= SNVS_LPATCTLR_AT3_EN_MASK;
break;
}
case (kSNVS_ActiveTamper4):
{
base->LPATCTLR |= SNVS_LPATCTLR_AT4_PAD_EN_MASK;
base->LPATCR[3] |= SNVS_LPATCR_Seed(config.seed) | SNVS_LPATCR_Polynomial(config.polynomial);
base->LPATCLKR |= SNVS_LPATCLKR_AT4_CLK_CTL(config.clock);
base->LPATCTLR |= SNVS_LPATCTLR_AT4_EN_MASK;
break;
}
case (kSNVS_ActiveTamper5):
{
base->LPATCTLR |= SNVS_LPATCTLR_AT5_PAD_EN_MASK;
base->LPATCR[4] |= SNVS_LPATCR_Seed(config.seed) | SNVS_LPATCR_Polynomial(config.polynomial);
base->LPATCLKR |= SNVS_LPATCLKR_AT5_CLK_CTL(config.clock);
base->LPATCTLR |= SNVS_LPATCTLR_AT5_EN_MASK;
break;
}
default:
status = kStatus_InvalidArgument;
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
return status;
}
/*!
* brief Enable active tamper rx external pad
*
* param base SNVS peripheral base address
* param rx SNVS external RX tamper pin
* param config SNVS RX tamper config structure
*/
status_t SNVS_LP_EnableRxActiveTamper(SNVS_Type *base, snvs_lp_external_tamper_t rx, tamper_active_rx_config_t config)
{
status_t status = kStatus_Success;
switch (rx)
{
case (kSNVS_ExternalTamper1):
/* Enable filter and set it's value, dissable otherwise */
if (config.filterenable != 0U)
{
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF1_EN_MASK;
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF1(config.filter);
}
else
{
SNVS->LPTGFCR &= ~SNVS_LPTGFCR_ETGF1_EN_MASK;
}
/* Route TX to external tamper 1 */
base->LPATRC1R = SNVS_LPATRC1R_ET1RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDCR |= SNVS_LPTDCR_ET1_EN_MASK;
break;
#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1)
case (kSNVS_ExternalTamper2):
/* Enable filter and set it's value, dissable otherwise */
if (config.filterenable != 0U)
{
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF2_EN_MASK;
SNVS->LPTGFCR |= SNVS_LPTGFCR_ETGF2(config.filter);
}
else
{
SNVS->LPTGFCR &= ~SNVS_LPTGFCR_ETGF2_EN_MASK;
}
/* Route TX to external tamper 2 */
base->LPATRC1R = SNVS_LPATRC1R_ET2RCTL(config.activeTamper);
/* enable tamper pin */
SNVS->LPTDCR |= SNVS_LPTDCR_ET2_EN_MASK;
break;
case (kSNVS_ExternalTamper3):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF3(config.filter);
/* Enable tamper 3 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF3_EN(1U);
}
/* Route TX to external tamper 3 */
base->LPATRC1R = SNVS_LPATRC1R_ET3RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET3_EN_MASK;
break;
case (kSNVS_ExternalTamper4):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF4(config.filter);
/* Enable tamper 4 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF4_EN(1U);
}
/* Route TX to external tamper 4 */
base->LPATRC1R = SNVS_LPATRC1R_ET4RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET4_EN_MASK;
break;
case (kSNVS_ExternalTamper5):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF5(config.filter);
/* Enable tamper 5 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF5_EN(1U);
}
/* Route TX to external tamper 5 */
base->LPATRC1R = SNVS_LPATRC1R_ET5RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET5_EN_MASK;
break;
case (kSNVS_ExternalTamper6):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF6(config.filter);
/* Enable tamper 6 glitch filter */
SNVS->LPTGF1CR |= SNVS_LPTGF1CR_ETGF6_EN(1U);
}
/* Route TX to external tamper 6 */
base->LPATRC1R = SNVS_LPATRC1R_ET6RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET6_EN_MASK;
break;
case (kSNVS_ExternalTamper7):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF7(config.filter);
/* Enable tamper 6 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF7_EN(1U);
}
/* Route TX to external tamper 7 */
base->LPATRC1R = SNVS_LPATRC1R_ET7RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET7_EN_MASK;
break;
case (kSNVS_ExternalTamper8):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF8(config.filter);
/* Enable tamper 8 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF8_EN(1U);
}
/* Route TX to external tamper 8 */
base->LPATRC1R = SNVS_LPATRC1R_ET8RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET8_EN_MASK;
break;
case (kSNVS_ExternalTamper9):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF9(config.filter);
/* Enable tamper 9 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF9_EN(1U);
}
/* Route TX to external tamper 9 */
base->LPATRC1R = SNVS_LPATRC2R_ET9RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET9_EN_MASK;
break;
case (kSNVS_ExternalTamper10):
/* Enable filter and set it's value if set */
if (config.filterenable != 0U)
{
/* Set filter value */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF10(config.filter);
/* Enable tamper 10 glitch filter */
SNVS->LPTGF2CR |= SNVS_LPTGF2CR_ETGF10_EN(1U);
}
/* Route TX to external tamper 10 */
base->LPATRC1R = SNVS_LPATRC2R_ET10RCTL(config.activeTamper);
/* enable tamper pin */
base->LPTDC2R |= SNVS_LPTDC2R_ET10_EN_MASK;
break;
#endif
default:
status = kStatus_InvalidArgument;
/* All the cases have been listed above, the default clause should not be reached. */
break;
}
return status;
}
/*!
* brief Sets voltage tamper detect
*
* param base SNVS peripheral base address
* param enable True if enable false if disable
*/
status_t SNVS_LP_SetVoltageTamper(SNVS_Type *base, bool enable)
{
base->LPTDCR |= SNVS_LPTDCR_VT_EN(enable);
return kStatus_Success;
}
/*!
* brief Sets temperature tamper detect
*
* param base SNVS peripheral base address
* param enable True if enable false if disable
*/
status_t SNVS_LP_SetTemperatureTamper(SNVS_Type *base, bool enable)
{
SNVS->LPTDCR |= SNVS_LPTDCR_TT_EN(enable);
return kStatus_Success;
}
/*!
* brief Sets clock tamper detect
*
* param base SNVS peripheral base address
* param enable True if enable false if disable
*/
status_t SNVS_LP_SetClockTamper(SNVS_Type *base, bool enable)
{
SNVS->LPTDCR |= SNVS_LPTDCR_CT_EN(enable);
return kStatus_Success;
}
/*!
* brief Check voltage tamper
*
* param base SNVS peripheral base address
*/
snvs_lp_external_tamper_status_t SNVS_LP_CheckVoltageTamper(SNVS_Type *base)
{
return ((SNVS->LPSR & SNVS_LPSR_VTD_MASK) != 0U) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
}
/*!
* brief Check temperature tamper
*
* param base SNVS peripheral base address
*/
snvs_lp_external_tamper_status_t SNVS_LP_CheckTemperatureTamper(SNVS_Type *base)
{
return ((SNVS->LPSR & SNVS_LPSR_TTD_MASK) != 0U) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
}
/*!
* brief Check clock tamper
*
* param base SNVS peripheral base address
*/
snvs_lp_external_tamper_status_t SNVS_LP_CheckClockTamper(SNVS_Type *base)
{
return ((SNVS->LPSR & SNVS_LPSR_CTD_MASK) != 0U) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
}
#endif /* defined(FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS) && (FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS > 0) */
/*!
* brief Get the current Monotonic Counter.
*
* param base SNVS peripheral base address
* return Current Monotonic Counter value.
*/
uint64_t SNVS_LP_GetMonotonicCounter(SNVS_Type *base)
{
uint32_t mc_lsb, mc_msb;
mc_msb = base->LPSMCMR;
mc_lsb = base->LPSMCLR;
return ((uint64_t)mc_msb << 32UL) | (uint64_t)mc_lsb;
}
/*!
* brief Write Zeroizable Master Key (ZMK) to the SNVS registers.
*
* param base SNVS peripheral base address
* param ZMKey The ZMK write to the SNVS register.
*/
void SNVS_LP_WriteZeroizableMasterKey(SNVS_Type *base, uint32_t ZMKey[SNVS_ZMK_REG_COUNT])
{
uint8_t i = 0;
for (i = 0; i < SNVS_ZMK_REG_COUNT; i++)
{
base->LPZMKR[i] = ZMKey[i];
}
}
#if defined(FSL_FEATURE_SNVS_HAS_STATE_TRANSITION) && (FSL_FEATURE_SNVS_HAS_STATE_TRANSITION > 0)
/*!
* brief Transition SNVS SSM state to Trusted/Non-secure from Check state
*
* param base SNVS peripheral base address
*
* return kStatus_Success: Success in transitioning SSM State
* kStatus_Fail: SSM State transition failed
*/
status_t SNVS_LP_SSM_State_Transition(SNVS_Type *base)
{
uint32_t curr_ssm_state = ((base->HPSR & SNVS_HPSR_SSM_STATE_MASK) >> SNVS_HPSR_SSM_STATE_SHIFT);
uint32_t sec_config = ((OCOTP_CTRL->HW_OCOTP_OTFAD_CFG3 & OCOTP_CTRL_HW_OCOTP_SEC_CONFIG1_MASK) >>
OCOTP_CTRL_HW_OCOTP_SEC_CONFIG1_SHIFT);
/* Check if SSM State is Check state */
if (curr_ssm_state == SNVS_SSM_STATE_CHECK)
{
if (sec_config == SEC_CONFIG_OPEN)
{
/* Transition to Non-secure state */
base->HPCOMR |= SNVS_HPCOMR_SW_SV(1);
}
else
{
/* Transition to Trusted state */
base->HPCOMR |= SNVS_HPCOMR_SSM_ST(1);
}
}
uint32_t new_ssm_state = ((base->HPSR & SNVS_HPSR_SSM_STATE_MASK) >> SNVS_HPSR_SSM_STATE_SHIFT);
if (new_ssm_state != SNVS_SSM_STATE_CHECK)
{
return kStatus_Success;
}
else
{
return kStatus_Fail;
}
}
#endif /* FSL_FEATURE_SNVS_HAS_STATE_TRANSITION */
View Git Blame Copy Permalink