624 lines
21 KiB
C
624 lines
21 KiB
C
/*
|
|
* Copyright (c) 2017, Freescale Semiconductor, Inc.
|
|
* Copyright 2016-2017 NXP
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* o Redistributions of source code must retain the above copyright notice, this list
|
|
* of conditions and the following disclaimer.
|
|
*
|
|
* o Redistributions in binary form must reproduce the above copyright notice, this
|
|
* list of conditions and the following disclaimer in the documentation and/or
|
|
* other materials provided with the distribution.
|
|
*
|
|
* o Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "fsl_snvs_lp.h"
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
#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)
|
|
|
|
/*******************************************************************************
|
|
* 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);
|
|
|
|
/* 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) == 0) && (datetime->year % 100 != 0)) || (datetime->year % 400 == 0))
|
|
{
|
|
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);
|
|
|
|
/* 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 = (datetime->year - 1970U) * DAYS_IN_A_YEAR;
|
|
/* Add leap year days */
|
|
seconds += ((datetime->year / 4) - (1970U / 4));
|
|
/* 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 += (datetime->day - 1);
|
|
/* For leap year if month less than or equal to Febraury, decrement day counter*/
|
|
if ((!(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);
|
|
|
|
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 + 1;
|
|
|
|
/* Update seconds left*/
|
|
secondsRemaining = secondsRemaining % SECONDS_IN_A_DAY;
|
|
|
|
/* Calculate the datetime hour, minute and second fields */
|
|
datetime->hour = secondsRemaining / SECONDS_IN_A_HOUR;
|
|
secondsRemaining = secondsRemaining % SECONDS_IN_A_HOUR;
|
|
datetime->minute = secondsRemaining / 60U;
|
|
datetime->second = 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)
|
|
{
|
|
daysInYear = DAYS_IN_A_YEAR;
|
|
}
|
|
else
|
|
{
|
|
daysInYear = DAYS_IN_A_YEAR + 1;
|
|
}
|
|
}
|
|
|
|
/* Adjust the days in February for a leap year */
|
|
if (!(datetime->year & 3U))
|
|
{
|
|
daysPerMonth[2] = 29U;
|
|
}
|
|
|
|
for (x = 1U; x <= 12U; x++)
|
|
{
|
|
if (days <= daysPerMonth[x])
|
|
{
|
|
datetime->month = x;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
days -= daysPerMonth[x];
|
|
}
|
|
}
|
|
|
|
datetime->day = 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 */
|
|
|
|
void SNVS_LP_SRTC_Init(SNVS_Type *base, const snvs_lp_srtc_config_t *config)
|
|
{
|
|
assert(config);
|
|
|
|
#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 */
|
|
|
|
int pin;
|
|
|
|
if (config->srtcCalEnable)
|
|
{
|
|
base->LPCR = SNVS_LPCR_LPCALB_VAL_MASK & (config->srtcCalValue << SNVS_LPCR_LPCALB_VAL_SHIFT);
|
|
base->LPCR |= SNVS_LPCR_LPCALB_EN_MASK;
|
|
}
|
|
|
|
for (pin = kSNVS_ExternalTamper1; pin <= 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);
|
|
}
|
|
}
|
|
|
|
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 */
|
|
}
|
|
|
|
void SNVS_LP_SRTC_GetDefaultConfig(snvs_lp_srtc_config_t *config)
|
|
{
|
|
assert(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) | (base->LPSRTCLR >> 15U);
|
|
} while (tmp != seconds);
|
|
|
|
return seconds;
|
|
}
|
|
|
|
status_t SNVS_LP_SRTC_SetDatetime(SNVS_Type *base, const snvs_lp_srtc_datetime_t *datetime)
|
|
{
|
|
assert(datetime);
|
|
|
|
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)
|
|
{
|
|
SNVS_LP_SRTC_StartTimer(base);
|
|
}
|
|
|
|
return kStatus_Success;
|
|
}
|
|
|
|
void SNVS_LP_SRTC_GetDatetime(SNVS_Type *base, snvs_lp_srtc_datetime_t *datetime)
|
|
{
|
|
assert(datetime);
|
|
|
|
SNVS_LP_ConvertSecondsToDatetime(SNVS_LP_SRTC_GetSeconds(base), datetime);
|
|
}
|
|
|
|
status_t SNVS_LP_SRTC_SetAlarm(SNVS_Type *base, const snvs_lp_srtc_datetime_t *alarmTime)
|
|
{
|
|
assert(alarmTime);
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
/* Set alarm in seconds*/
|
|
base->LPTAR = alarmSeconds;
|
|
|
|
/* reenable SRTC alarm interrupt in case that it was enabled before */
|
|
base->LPCR = tmp;
|
|
|
|
return kStatus_Success;
|
|
}
|
|
|
|
void SNVS_LP_SRTC_GetAlarm(SNVS_Type *base, snvs_lp_srtc_datetime_t *datetime)
|
|
{
|
|
assert(datetime);
|
|
|
|
uint32_t alarmSeconds = 0U;
|
|
|
|
/* Get alarm in seconds */
|
|
alarmSeconds = base->LPTAR;
|
|
|
|
SNVS_LP_ConvertSecondsToDatetime(alarmSeconds, datetime);
|
|
}
|
|
|
|
uint32_t SNVS_LP_SRTC_GetStatusFlags(SNVS_Type *base)
|
|
{
|
|
uint32_t flags = 0U;
|
|
|
|
if (base->LPSR & SNVS_LPSR_LPTA_MASK)
|
|
{
|
|
flags |= kSNVS_SRTC_AlarmInterruptFlag;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
void SNVS_LP_SRTC_ClearStatusFlags(SNVS_Type *base, uint32_t mask)
|
|
{
|
|
if (mask & kSNVS_SRTC_AlarmInterruptFlag)
|
|
{
|
|
base->LPSR |= SNVS_LPSR_LPTA_MASK;
|
|
}
|
|
}
|
|
|
|
void SNVS_LP_SRTC_EnableInterrupts(SNVS_Type *base, uint32_t mask)
|
|
{
|
|
if (mask & kSNVS_SRTC_AlarmInterruptEnable)
|
|
{
|
|
base->LPCR |= SNVS_LPCR_LPTA_EN_MASK;
|
|
}
|
|
}
|
|
|
|
void SNVS_LP_SRTC_DisableInterrupts(SNVS_Type *base, uint32_t mask)
|
|
{
|
|
if (mask & kSNVS_SRTC_AlarmInterruptEnable)
|
|
{
|
|
base->LPCR &= ~SNVS_LPCR_LPTA_EN_MASK;
|
|
}
|
|
}
|
|
|
|
uint32_t SNVS_LP_SRTC_GetEnabledInterrupts(SNVS_Type *base)
|
|
{
|
|
uint32_t val = 0U;
|
|
|
|
if (base->LPCR & SNVS_LPCR_LPTA_EN_MASK)
|
|
{
|
|
val |= kSNVS_SRTC_AlarmInterruptFlag;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
void SNVS_LP_EnableExternalTamper(SNVS_Type *base,
|
|
snvs_lp_external_tamper_t pin,
|
|
snvs_lp_external_tamper_polarity_t polarity)
|
|
{
|
|
switch (pin)
|
|
{
|
|
case (kSNVS_ExternalTamper1):
|
|
base->LPTDCR = (base->LPTDCR & ~(1U << SNVS_LPTDCR_ET1P_SHIFT)) | (polarity << SNVS_LPTDCR_ET1P_SHIFT);
|
|
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 = (base->LPTDCR & ~(1U << SNVS_LPTDCR_ET2P_SHIFT)) | (polarity << SNVS_LPTDCR_ET2P_SHIFT);
|
|
base->LPTDCR |= SNVS_LPTDCR_ET2_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper3):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET3P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET3P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET3_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper4):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET4P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET4P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET4_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper5):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET5P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET5P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET5_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper6):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET6P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET6P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET6_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper7):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET7P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET7P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET7_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper8):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET8P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET8P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET8_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper9):
|
|
base->LPTDC2R = (base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET9P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET9P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET9_EN_MASK;
|
|
break;
|
|
case (kSNVS_ExternalTamper10):
|
|
base->LPTDC2R =
|
|
(base->LPTDC2R & ~(1U << SNVS_LPTDC2R_ET10P_SHIFT)) | (polarity << SNVS_LPTDC2R_ET10P_SHIFT);
|
|
base->LPTDC2R |= SNVS_LPTDC2R_ET10_EN_MASK;
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
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:
|
|
break;
|
|
}
|
|
}
|
|
|
|
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 = (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 = (base->LPSR & SNVS_LPSR_ET2D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper3):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET3D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper4):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET4D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper5):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET5D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper6):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET6D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper7):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET7D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper8):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET8D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper9):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET9D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
case (kSNVS_ExternalTamper10):
|
|
status = (base->LPTDSR & SNVS_LPTDSR_ET10D_MASK) ? kSNVS_TamperDetected : kSNVS_TamperNotDetected;
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
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:
|
|
break;
|
|
}
|
|
}
|