diff options
Diffstat (limited to 'bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp')
-rw-r--r-- | bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.c | 1358 | ||||
-rw-r--r-- | bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.h | 733 |
2 files changed, 2091 insertions, 0 deletions
diff --git a/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.c b/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.c new file mode 100644 index 0000000000..c9a703eebe --- /dev/null +++ b/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.c @@ -0,0 +1,1358 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2017-2022, 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); + + SNVS_LP_Init(base); + + 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; + + SNVS_LP_Deinit(base); +} + +/*! + * 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 */ diff --git a/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.h b/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.h new file mode 100644 index 0000000000..44b9aa02d6 --- /dev/null +++ b/bsps/arm/imxrt/mcux-sdk/drivers/snvs_lp/fsl_snvs_lp.h @@ -0,0 +1,733 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2017-2022, NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _FSL_SNVS_LP_H_ +#define _FSL_SNVS_LP_H_ + +#include "fsl_common.h" + +/*! + * @addtogroup snvs_lp + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @name Driver version */ +/*@{*/ +#define FSL_SNVS_LP_DRIVER_VERSION (MAKE_VERSION(2, 4, 4)) /*!< Version 2.4.4 */ +/*@}*/ + +/*! @brief Define of SNVS_LP Zeroizable Master Key registers */ +#define SNVS_ZMK_REG_COUNT 8U /* 8 Zeroizable Master Key registers. */ + +/*! @brief List of SNVS_LP interrupts */ +typedef enum _snvs_lp_srtc_interrupts +{ + kSNVS_SRTC_AlarmInterrupt = SNVS_LPCR_LPTA_EN_MASK, /*!< SRTC time alarm.*/ +} snvs_lp_srtc_interrupts_t; + +/*! @brief List of SNVS_LP flags */ +typedef enum _snvs_lp_srtc_status_flags +{ + kSNVS_SRTC_AlarmInterruptFlag = SNVS_LPSR_LPTA_MASK, /*!< SRTC time alarm flag */ +} snvs_lp_srtc_status_flags_t; + +#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0) + +/*! @brief List of SNVS_LP external tampers */ +typedef enum _snvs_lp_external_tamper +{ + kSNVS_ExternalTamper1 = 1U, +#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1) + kSNVS_ExternalTamper2 = 2U, + kSNVS_ExternalTamper3 = 3U, + kSNVS_ExternalTamper4 = 4U, + kSNVS_ExternalTamper5 = 5U, + kSNVS_ExternalTamper6 = 6U, + kSNVS_ExternalTamper7 = 7U, + kSNVS_ExternalTamper8 = 8U, + kSNVS_ExternalTamper9 = 9U, + kSNVS_ExternalTamper10 = 10U +#endif /* defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1) */ +} snvs_lp_external_tamper_t; + +#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 List of SNVS_LP active tampers */ +typedef enum _snvs_lp_active_tamper +{ + kSNVS_ActiveTamper1 = 1U, + kSNVS_ActiveTamper2 = 2U, + kSNVS_ActiveTamper3 = 3U, + kSNVS_ActiveTamper4 = 4U, + kSNVS_ActiveTamper5 = 5U, +} snvs_lp_active_tx_tamper_t; + +/*! @brief List of SNVS_LP external tampers */ +typedef enum _snvs_lp_active_clock +{ + kSNVS_ActiveTamper16HZ = 0U, + kSNVS_ActiveTamper8HZ = 1U, + kSNVS_ActiveTamper4HZ = 2U, + kSNVS_ActiveTamper2HZ = 3U +} snvs_lp_active_clock_t; + +/*! @brief Structure is used to configure SNVS LP active TX tamper pins */ +typedef struct +{ + uint16_t polynomial; + uint16_t seed; + snvs_lp_active_clock_t clock; +} tamper_active_tx_config_t; + +/*! @brief Structure is used to configure SNVS LP active RX tamper pins */ +typedef struct +{ + uint16_t filterenable; + uint8_t filter; + snvs_lp_active_tx_tamper_t activeTamper; +} tamper_active_rx_config_t; + +#endif /* FSL_FEATURE_SNVS_HAS_ACTIVE_TAMPERS */ + +/*! @brief Structure is used to configure SNVS LP passive tamper pins */ +typedef struct +{ + uint8_t polarity; +#if defined(FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER) && (FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER > 0) + uint8_t filterenable; + uint8_t filter; +#endif /* FSL_FEATURE_SNVS_PASSIVE_TAMPER_FILTER */ +} snvs_lp_passive_tamper_t; + +/* define max possible tamper present */ +/*! @brief Define of SNVS_LP Max possible tamper */ +#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 1) +#define SNVS_LP_MAX_TAMPER kSNVS_ExternalTamper10 +#else +#define SNVS_LP_MAX_TAMPER kSNVS_ExternalTamper1 +#endif + +/*! @brief List of SNVS_LP external tampers status */ +typedef enum _snvs_lp_external_tamper_status +{ + kSNVS_TamperNotDetected = 0U, + kSNVS_TamperDetected = 1U +} snvs_lp_external_tamper_status_t; + +/*! @brief SNVS_LP external tamper polarity */ +typedef enum _snvs_lp_external_tamper_polarity +{ + kSNVS_ExternalTamperActiveLow = 0U, + kSNVS_ExternalTamperActiveHigh = 1U +} snvs_lp_external_tamper_polarity_t; + +/*! @brief Structure is used to hold the date and time */ +typedef struct _snvs_lp_srtc_datetime +{ + uint16_t year; /*!< Range from 1970 to 2099.*/ + uint8_t month; /*!< Range from 1 to 12.*/ + uint8_t day; /*!< Range from 1 to 31 (depending on month).*/ + uint8_t hour; /*!< Range from 0 to 23.*/ + uint8_t minute; /*!< Range from 0 to 59.*/ + uint8_t second; /*!< Range from 0 to 59.*/ +} snvs_lp_srtc_datetime_t; + +/*! + * @brief SNVS_LP config structure + * + * This structure holds the configuration settings for the SNVS_LP peripheral. To initialize this + * structure to reasonable defaults, call the SNVS_LP_GetDefaultConfig() function and pass a + * pointer to your config structure instance. + * + * The config struct can be made const so it resides in flash + */ +typedef struct _snvs_lp_srtc_config +{ + bool srtcCalEnable; /*!< true: SRTC calibration mechanism is enabled; + false: No calibration is used */ + uint32_t srtcCalValue; /*!< Defines signed calibration value for SRTC; + This is a 5-bit 2's complement value, range from -16 to +15 */ +} snvs_lp_srtc_config_t; + +/*! + * @brief SNVS_LP Zeroizable Master Key programming mode. + */ +typedef enum _snvs_lp_zmk_program_mode +{ + kSNVS_ZMKSoftwareProgram, /*!< Software programming mode. */ + kSNVS_ZMKHardwareProgram, /*!< Hardware programming mode. */ +} snvs_lp_zmk_program_mode_t; + +/*! + * @brief SNVS_LP Master Key mode. + */ +typedef enum _snvs_lp_master_key_mode +{ + kSNVS_OTPMK = 0, /*!< One Time Programmable Master Key. */ + kSNVS_ZMK = 2, /*!< Zeroizable Master Key. */ + kSNVS_CMK = 3, /*!< Combined Master Key, it is XOR of OPTMK and ZMK. */ +} snvs_lp_master_key_mode_t; + +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @name Initialization and deinitialization + * @{ + */ + +/*! + * @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 + */ +void SNVS_LP_Init(SNVS_Type *base); + +/*! + * @brief Deinit the SNVS LP section. + * + * @param base SNVS peripheral base address + */ +void SNVS_LP_Deinit(SNVS_Type *base); + +/*! @}*/ + +/*! + * @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); + +/*! + * @brief Stops the SRTC timer. + * + * @param base SNVS peripheral base address + */ +void SNVS_LP_SRTC_Deinit(SNVS_Type *base); + +/*! + * @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); + +/*! + * @name Secure RTC (SRTC) current Time & Alarm + * @{ + */ + +/*! + * @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); + +/*! + * @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); + +/*! + * @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); + +/*! + * @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); + +/*! @}*/ + +/*! + * @name Interrupt Interface + * @{ + */ + +/*! + * @brief Enables the selected SNVS interrupts. + * + * @param base SNVS peripheral base address + * @param mask The interrupts to enable. This is a logical OR of members of the + * enumeration :: _snvs_lp_srtc_interrupts + */ +static inline void SNVS_LP_SRTC_EnableInterrupts(SNVS_Type *base, uint32_t mask) +{ + base->LPCR |= mask; +} + +/*! + * @brief Disables the selected SNVS interrupts. + * + * @param base SNVS peripheral base address + * @param mask The interrupts to enable. This is a logical OR of members of the + * enumeration :: _snvs_lp_srtc_interrupts + */ +static inline void SNVS_LP_SRTC_DisableInterrupts(SNVS_Type *base, uint32_t mask) +{ + base->LPCR &= ~mask; +} + +/*! + * @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_lp_srtc_interrupts + */ +uint32_t SNVS_LP_SRTC_GetEnabledInterrupts(SNVS_Type *base); + +/*! @}*/ + +/*! + * @name Status Interface + * @{ + */ + +/*! + * @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_lp_srtc_status_flags + */ +uint32_t SNVS_LP_SRTC_GetStatusFlags(SNVS_Type *base); + +/*! + * @brief Clears the SNVS status flags. + * + * @param base SNVS peripheral base address + * @param mask The status flags to clear. This is a logical OR of members of the + * enumeration :: _snvs_lp_srtc_status_flags + */ +static inline void SNVS_LP_SRTC_ClearStatusFlags(SNVS_Type *base, uint32_t mask) +{ + base->LPSR |= mask; +} + +/*! @}*/ + +/*! + * @name Timer Start and Stop + * @{ + */ + +/*! + * @brief Starts the SNVS SRTC time counter. + * + * @param base SNVS peripheral base address + */ +static inline void SNVS_LP_SRTC_StartTimer(SNVS_Type *base) +{ + base->LPCR |= SNVS_LPCR_SRTC_ENV_MASK; + while ((0U == (base->LPCR & SNVS_LPCR_SRTC_ENV_MASK))) + { + } +} + +/*! + * @brief Stops the SNVS SRTC time counter. + * + * @param base SNVS peripheral base address + */ +static inline void SNVS_LP_SRTC_StopTimer(SNVS_Type *base) +{ + base->LPCR &= ~SNVS_LPCR_SRTC_ENV_MASK; + while ((base->LPCR & SNVS_LPCR_SRTC_ENV_MASK) != 0U) + { + } +} + +/*! @}*/ + +/*! + * @name External tampering + * @{ + */ + +#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); + +#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 active tamper pin + * @param config Configuration structure of external active tamper + */ +status_t SNVS_LP_EnableTxActiveTamper(SNVS_Type *base, + snvs_lp_active_tx_tamper_t pin, + tamper_active_tx_config_t config); + +/*! + * @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); + +/*! + * @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); + +/*! + * @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); + +/*! + * @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); + +/*! + * brief Check voltage tamper + * + * param base SNVS peripheral base address + */ +snvs_lp_external_tamper_status_t SNVS_LP_CheckVoltageTamper(SNVS_Type *base); + +/*! + * @brief Check temperature tamper + * + * @param base SNVS peripheral base address + */ +snvs_lp_external_tamper_status_t SNVS_LP_CheckTemperatureTamper(SNVS_Type *base); + +/*! + * brief Check clock tamper + * + * param base SNVS peripheral base address + */ +snvs_lp_external_tamper_status_t SNVS_LP_CheckClockTamper(SNVS_Type *base); + +/*! + * @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); + +/*! + * 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); +#endif /* 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->polarity = 0U; + * config->filterenable = 0U; if available on SoC + * config->filter = 0U; if available on SoC + * endcode + * @param config Pointer to the user's SNVS configuration structure. + */ +void SNVS_LP_PassiveTamperPin_GetDefaultConfig(snvs_lp_passive_tamper_t *config); + +#if defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0) + +/*! + * @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); + +/*! + * @brief Disable all external tamper. + * + * @param base SNVS peripheral base address + */ +void SNVS_LP_DisableAllExternalTamper(SNVS_Type *base); + +/*! + * @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_lp_external_tamper_status + */ +snvs_lp_external_tamper_status_t SNVS_LP_GetExternalTamperStatus(SNVS_Type *base, snvs_lp_external_tamper_t pin); + +/*! + * @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); + +/*! + * @brief Clears status of the all external tamper. + * + * @param base SNVS peripheral base address + */ +void SNVS_LP_ClearAllExternalTamperStatus(SNVS_Type *base); + +#endif /* defined(FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER) && (FSL_FEATURE_SNVS_HAS_MULTIPLE_TAMPER > 0) */ + +/*! @}*/ + +/*! + * @name Monotonic Counter (MC) + * @{ + */ + +/*! + * @brief Enable or disable the Monotonic Counter. + * + * @param base SNVS peripheral base address + * @param enable Pass true to enable, false to disable. + */ +static inline void SNVS_LP_EnableMonotonicCounter(SNVS_Type *base, bool enable) +{ + if (enable) + { + base->LPCR |= SNVS_LPCR_MC_ENV_MASK; + } + else + { + base->LPCR &= (~SNVS_LPCR_MC_ENV_MASK); + } +} + +/*! + * @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); + +/*! + * @brief Increase the Monotonic Counter. + * + * Increase the Monotonic Counter by 1. + * + * @param base SNVS peripheral base address + */ +static inline void SNVS_LP_IncreaseMonotonicCounter(SNVS_Type *base) +{ + /* Write to the LPSMCLR or LPSMCLR, the counter increases. */ + *((volatile uint32_t *)(uint32_t)(&(base->LPSMCLR))) = 0xFFFFFFFFU; +} + +/*! @}*/ + +/*! + * @name Zeroizable Master Key (ZMK) + * @{ + */ + +/*! + * @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]); + +/*! + * @brief Set Zeroizable Master Key valid. + * + * This API could only be called when using software programming mode. After writing + * ZMK using @ref SNVS_LP_WriteZeroizableMasterKey, call this API to make the ZMK + * valid. + * + * @param base SNVS peripheral base address + * @param valid Pass true to set valid, false to set invalid. + */ +static inline void SNVS_LP_SetZeroizableMasterKeyValid(SNVS_Type *base, bool valid) +{ + if (valid) + { + base->LPMKCR |= SNVS_LPMKCR_ZMK_VAL_MASK; + } + else + { + base->LPMKCR &= (~SNVS_LPMKCR_ZMK_VAL_MASK); + } +} + +/*! + * @brief Get Zeroizable Master Key valid status. + * + * In hardware programming mode, call this API to check whether the ZMK is valid. + * + * @param base SNVS peripheral base address + * @return true if valid, false if invalid. + */ +static inline bool SNVS_LP_GetZeroizableMasterKeyValid(SNVS_Type *base) +{ + return (SNVS_LPMKCR_ZMK_VAL_MASK == (base->LPMKCR & SNVS_LPMKCR_ZMK_VAL_MASK)); +} + +/*! + * @brief Set Zeroizable Master Key programming mode. + * + * @param base SNVS peripheral base address + * @param mode ZMK programming mode. + */ +static inline void SNVS_LP_SetZeroizableMasterKeyProgramMode(SNVS_Type *base, snvs_lp_zmk_program_mode_t mode) +{ + if (kSNVS_ZMKSoftwareProgram == mode) + { + base->LPMKCR &= (~SNVS_LPMKCR_ZMK_HWP_MASK); + } + else + { + base->LPMKCR |= SNVS_LPMKCR_ZMK_HWP_MASK; + } +} + +/*! + * @brief Enable or disable Zeroizable Master Key ECC. + * + * @param base SNVS peripheral base address + * @param enable Pass true to enable, false to disable. + */ +static inline void SNVS_LP_EnableZeroizableMasterKeyECC(SNVS_Type *base, bool enable) +{ + if (enable) + { + base->LPMKCR |= SNVS_LPMKCR_ZMK_ECC_EN_MASK; + } + else + { + base->LPMKCR &= (~SNVS_LPMKCR_ZMK_ECC_EN_MASK); + } +} + +/*! + * @brief Set SNVS Master Key mode. + * + * @param base SNVS peripheral base address + * @param mode Master Key mode. + * @note When @ref kSNVS_ZMK or @ref kSNVS_CMK used, the SNVS_HP must be configured + * to enable the master key selection. + */ +static inline void SNVS_LP_SetMasterKeyMode(SNVS_Type *base, snvs_lp_master_key_mode_t mode) +{ + uint32_t lpmkcr = base->LPMKCR; + lpmkcr = (lpmkcr & (~SNVS_LPMKCR_MASTER_KEY_SEL_MASK)) | SNVS_LPMKCR_MASTER_KEY_SEL(mode); + base->LPMKCR = lpmkcr; +} + +#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); +#endif /* FSL_FEATURE_SNVS_HAS_STATE_TRANSITION */ + +/*! @}*/ + +#if defined(__cplusplus) +} +#endif + +/*! @}*/ + +#endif /* _FSL_SNVS_LP_H_ */ |