/*
 * 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 */
