620 lines
24 KiB
C
620 lines
24 KiB
C
/*
|
|
* Copyright (c) 2016, 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.
|
|
*/
|
|
|
|
#ifndef _FSL_SRC_H_
|
|
#define _FSL_SRC_H_
|
|
|
|
#include "fsl_common.h"
|
|
|
|
/*!
|
|
* @addtogroup src
|
|
* @{
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
|
|
/*! @name Driver version */
|
|
/*@{*/
|
|
/*! @brief SRC driver version 2.0.0. */
|
|
#define FSL_SRC_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))
|
|
/*@}*/
|
|
|
|
/*!
|
|
* @brief SRC reset status flags.
|
|
*/
|
|
enum _src_reset_status_flags
|
|
{
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_RESET_OUT) && FSL_FEATURE_SRC_HAS_SRSR_RESET_OUT)
|
|
kSRC_ResetOutputEnableFlag = SRC_SRSR_RESET_OUT_MASK, /*!< This bit indicates if RESET status is
|
|
driven out on PTE0 pin. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_RESET_OUT */
|
|
#if !(defined(FSL_FEATURE_SRC_HAS_NO_SRSR_WBI) && FSL_FEATURE_SRC_HAS_NO_SRSR_WBI)
|
|
kSRC_WarmBootIndicationFlag = SRC_SRSR_WBI_MASK, /*!< WARM boot indication shows that WARM boot
|
|
was initiated by software. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_NO_SRSR_WBI */
|
|
kSRC_TemperatureSensorResetFlag = SRC_SRSR_TSR_MASK, /*!< Indicates whether the reset was the
|
|
result of software reset from on-chip
|
|
Temperature Sensor. Temperature Sensor
|
|
Interrupt need be served before this
|
|
bit can be cleaned.*/
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_WDOG3_RST_B) && FSL_FEATURE_SRC_HAS_SRSR_WDOG3_RST_B)
|
|
kSRC_Wdog3ResetFlag = SRC_SRSR_WDOG3_RST_B_MASK, /*!< IC Watchdog3 Time-out reset. Indicates
|
|
whether the reset was the result of the
|
|
watchdog3 time-out event. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_WDOG3_RST_B */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_SW) && FSL_FEATURE_SRC_HAS_SRSR_SW)
|
|
kSRC_SoftwareResetFlag = SRC_SRSR_SW_MASK, /*!< Indicates a reset has been caused by software
|
|
setting of SYSRESETREQ bit in Application
|
|
Interrupt and Reset Control Register in the
|
|
ARM core. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_SW */
|
|
kSRC_JTAGSoftwareResetFlag = SRC_SRSR_SJC_MASK, /*!< Indicates whether the reset was the result of
|
|
setting SJC_GPCCR bit 31. */
|
|
kSRC_JTAGGeneratedResetFlag = SRC_SRSR_JTAG_MASK, /*!< Indicates a reset has been caused by JTAG
|
|
selection of certain IR codes: EXTEST or
|
|
HIGHZ. */
|
|
kSRC_WatchdogResetFlag = SRC_SRSR_WDOG_MASK, /*!< Indicates a reset has been caused by the
|
|
watchdog timer timing out. This reset source
|
|
can be blocked by disabling the watchdog. */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_IPP_USER_RESET_B) && FSL_FEATURE_SRC_HAS_SRSR_IPP_USER_RESET_B)
|
|
kSRC_IppUserResetFlag = SRC_SRSR_IPP_USER_RESET_B_MASK, /*!< Indicates whether the reset was the
|
|
result of the ipp_user_reset_b
|
|
qualified reset. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_IPP_USER_RESET_B */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_SNVS) && FSL_FEATURE_SRC_HAS_SRSR_SNVS)
|
|
kSRC_SNVSFailResetFlag = SRC_SRSR_SNVS_MASK, /*!< SNVS hardware failure will always cause a cold
|
|
reset. This flag indicates whether the reset
|
|
is a result of SNVS hardware failure. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_SNVS */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_CSU_RESET_B) && FSL_FEATURE_SRC_HAS_SRSR_CSU_RESET_B)
|
|
kSRC_CsuResetFlag = SRC_SRSR_CSU_RESET_B_MASK, /*!< Indicates whether the reset was the result
|
|
of the csu_reset_b input. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_CSU_RESET_B */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_LOCKUP) && FSL_FEATURE_SRC_HAS_SRSR_LOCKUP)
|
|
kSRC_CoreLockupResetFlag = SRC_SRSR_LOCKUP_MASK, /*!< Indicates a reset has been caused by the
|
|
ARM core indication of a LOCKUP event. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_LOCKUP */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_POR) && FSL_FEATURE_SRC_HAS_SRSR_POR)
|
|
kSRC_PowerOnResetFlag = SRC_SRSR_POR_MASK, /*!< Indicates a reset has been caused by the
|
|
power-on detection logic. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_POR */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_LOCKUP_SYSRESETREQ) && FSL_FEATURE_SRC_HAS_SRSR_LOCKUP_SYSRESETREQ)
|
|
kSRC_LockupSysResetFlag = SRC_SRSR_LOCKUP_SYSRESETREQ_MASK, /*!< Indicates a reset has been caused by CPU lockup or software
|
|
setting of SYSRESETREQ bit in Application Interrupt and
|
|
Reset Control Register of the ARM core. */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_LOCKUP_SYSRESETREQ */
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SRSR_IPP_RESET_B) && FSL_FEATURE_SRC_HAS_SRSR_IPP_RESET_B)
|
|
kSRC_IppResetPinFlag = SRC_SRSR_IPP_RESET_B_MASK, /*!< Indicates whether reset was the result of
|
|
ipp_reset_b pin (Power-up sequence). */
|
|
#endif /* FSL_FEATURE_SRC_HAS_SRSR_IPP_RESET_B */
|
|
};
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SISR) && FSL_FEATURE_SRC_HAS_SISR)
|
|
/*!
|
|
* @brief SRC interrupt status flag.
|
|
*/
|
|
enum _src_status_flags
|
|
{
|
|
kSRC_Core0WdogResetReqFlag =
|
|
SRC_SISR_CORE0_WDOG_RST_REQ_MASK, /*!< WDOG reset request from core0. Read-only status bit. */
|
|
};
|
|
#endif /* FSL_FEATURE_SRC_HAS_SISR */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH) && FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH)
|
|
/*!
|
|
* @brief Selection of SoC mix power reset stretch.
|
|
*
|
|
* This type defines the SoC mix (Audio, ENET, uSDHC, EIM, QSPI, OCRAM, MMDC, etc) power up reset
|
|
* stretch mix reset width with the optional count of cycles
|
|
*/
|
|
typedef enum _src_mix_reset_stretch_cycles
|
|
{
|
|
kSRC_MixResetStretchCycleAlt0 = 0U, /*!< mix reset width is 1 x 88 ipg_cycle cycles. */
|
|
kSRC_MixResetStretchCycleAlt1 = 1U, /*!< mix reset width is 2 x 88 ipg_cycle cycles. */
|
|
kSRC_MixResetStretchCycleAlt2 = 2U, /*!< mix reset width is 3 x 88 ipg_cycle cycles. */
|
|
kSRC_MixResetStretchCycleAlt3 = 3U, /*!< mix reset width is 4 x 88 ipg_cycle cycles. */
|
|
} src_mix_reset_stretch_cycles_t;
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN) && FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN)
|
|
/*!
|
|
* @brief Selection of WDOG3 reset option.
|
|
*/
|
|
typedef enum _src_wdog3_reset_option
|
|
{
|
|
kSRC_Wdog3ResetOptionAlt0 = 0U, /*!< Wdog3_rst_b asserts M4 reset (default). */
|
|
kSRC_Wdog3ResetOptionAlt1 = 1U, /*!< Wdog3_rst_b asserts global reset. */
|
|
} src_wdog3_reset_option_t;
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN */
|
|
|
|
/*!
|
|
* @brief Selection of WARM reset bypass count.
|
|
*
|
|
* This type defines the 32KHz clock cycles to count before bypassing the MMDC acknowledge for WARM
|
|
* reset. If the MMDC acknowledge is not asserted before this counter is elapsed, a COLD reset will
|
|
* be initiated.
|
|
*/
|
|
typedef enum _src_warm_reset_bypass_count
|
|
{
|
|
kSRC_WarmResetWaitAlways = 0U, /*!< System will wait until MMDC acknowledge is asserted. */
|
|
kSRC_WarmResetWaitClk16 = 1U, /*!< Wait 16 32KHz clock cycles before switching the reset. */
|
|
kSRC_WarmResetWaitClk32 = 2U, /*!< Wait 32 32KHz clock cycles before switching the reset. */
|
|
kSRC_WarmResetWaitClk64 = 3U, /*!< Wait 64 32KHz clock cycles before switching the reset. */
|
|
} src_warm_reset_bypass_count_t;
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* API
|
|
******************************************************************************/
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_MASK_WDOG3_RST) && FSL_FEATURE_SRC_HAS_SCR_MASK_WDOG3_RST)
|
|
/*!
|
|
* @brief Enable the WDOG3 reset.
|
|
*
|
|
* The WDOG3 reset is enabled by default.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableWDOG3Reset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MASK_WDOG3_RST_MASK) | SRC_SCR_MASK_WDOG3_RST(0xA);
|
|
}
|
|
else
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MASK_WDOG3_RST_MASK) | SRC_SCR_MASK_WDOG3_RST(0x5);
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_MASK_WDOG3_RST */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH) && FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH)
|
|
/*!
|
|
* @brief Set the mix power up reset stretch mix reset width.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param option Setting option, see to #src_mix_reset_stretch_cycles_t.
|
|
*/
|
|
static inline void SRC_SetMixResetStretchCycles(SRC_Type *base, src_mix_reset_stretch_cycles_t option)
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MIX_RST_STRCH_MASK) | SRC_SCR_MIX_RST_STRCH(option);
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_MIX_RST_STRCH */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_DBG_RST_MSK_PG) && FSL_FEATURE_SRC_HAS_SCR_DBG_RST_MSK_PG)
|
|
/*!
|
|
* @brief Debug reset would be asserted after power gating event.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableCoreDebugResetAfterPowerGate(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->SCR &= ~SRC_SCR_DBG_RST_MSK_PG_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->SCR |= SRC_SCR_DBG_RST_MSK_PG_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_DBG_RST_MSK_PG */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN) && FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN)
|
|
/*!
|
|
* @brief Set the Wdog3_rst_b option.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param option Setting option, see to #src_wdog3_reset_option_t.
|
|
*/
|
|
static inline void SRC_SetWdog3ResetOption(SRC_Type *base, src_wdog3_reset_option_t option)
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_WDOG3_RST_OPTN_MASK) | SRC_SCR_WDOG3_RST_OPTN(option);
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_WDOG3_RST_OPTN */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_CORES_DBG_RST) && FSL_FEATURE_SRC_HAS_SCR_CORES_DBG_RST)
|
|
/*!
|
|
* @brief Software reset for debug of arm platform only.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline void SRC_DoSoftwareResetARMCoreDebug(SRC_Type *base)
|
|
{
|
|
base->SCR |= SRC_SCR_CORES_DBG_RST_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Check if the software reset for debug of arm platform only is done.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline bool SRC_GetSoftwareResetARMCoreDebugDone(SRC_Type *base)
|
|
{
|
|
return (0U == (base->SCR & SRC_SCR_CORES_DBG_RST_MASK));
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_CORES_DBG_RST */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_MTSR) && FSL_FEATURE_SRC_HAS_SCR_MTSR)
|
|
/*!
|
|
* @brief Enable the temperature sensor reset.
|
|
*
|
|
* The temperature sersor reset is enabled by default. When the sensor reset happens, an flag bit
|
|
* would be asserted. This flag bit can be cleared only by the hardware reset.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableTemperatureSensorReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable) /* Temperature sensor reset is not masked. (default) */
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MTSR_MASK) | SRC_SCR_MTSR(0x2);
|
|
}
|
|
else /* The on-chip temperature sensor interrupt will not create a reset to the chip. */
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MTSR_MASK) | SRC_SCR_MTSR(0x5);
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_MTSR */
|
|
|
|
#if (defined(FSL_FEATURE_SCR_HAS_SCR_CORE0_DBG_RST) && FSL_FEATURE_SCR_HAS_SCR_CORE0_DBG_RST)
|
|
/*!
|
|
* @brief Do assert the core0 debug reset.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline void SRC_DoAssertCore0DebugReset(SRC_Type *base)
|
|
{
|
|
base->SCR |= SRC_SCR_CORE0_DBG_RST_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Check if the core0 debug reset is done.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline bool SRC_GetAssertCore0DebugResetDone(SRC_Type *base)
|
|
{
|
|
return (0U == (base->SCR & SRC_SCR_CORE0_DBG_RST_MASK));
|
|
}
|
|
#endif /* FSL_FEATURE_SCR_HAS_SCR_CORE0_DBG_RST */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_CORE0_RST) && FSL_FEATURE_SRC_HAS_SCR_CORE0_RST)
|
|
/*!
|
|
* @brief Do software reset the ARM core0 only.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline void SRC_DoSoftwareResetARMCore0(SRC_Type *base)
|
|
{
|
|
base->SCR |= SRC_SCR_CORE0_RST_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Check if the software for ARM core0 is done.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return If the reset is done.
|
|
*/
|
|
static inline bool SRC_GetSoftwareResetARMCore0Done(SRC_Type *base)
|
|
{
|
|
return (0U == (base->SCR & SRC_SCR_CORE0_RST_MASK));
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_CORE0_RST */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_SWRC) && FSL_FEATURE_SRC_HAS_SCR_SWRC)
|
|
/*!
|
|
* @brief Do software reset for ARM core.
|
|
*
|
|
* This function can be used to assert the ARM core reset. Once it is called, the reset process will
|
|
* begin. After the reset process is finished, the command bit would be self cleared.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
*/
|
|
static inline void SRC_DoSoftwareResetARMCore(SRC_Type *base)
|
|
{
|
|
base->SCR |= SRC_SCR_SWRC_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Check if the software for ARM core is done.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return If the reset is done.
|
|
*/
|
|
static inline bool SRC_GetSoftwareResetARMCoreDone(SRC_Type *base)
|
|
{
|
|
return (0U == (base->SCR & SRC_SCR_SWRC_MASK));
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_SWRC */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_EIM_RST) && FSL_FEATURE_SRC_HAS_SCR_EIM_RST)
|
|
/*!
|
|
* @brief Assert the EIM reset.
|
|
*
|
|
* EIM reset is needed in order to reconfigure the EIM chip select.
|
|
* The software reset bit must de-asserted since this is not self-refresh.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Make the assertion or not.
|
|
*/
|
|
static inline void SRC_AssertEIMReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->SCR |= SRC_SCR_EIM_RST_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->SCR &= ~SRC_SCR_EIM_RST_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_EIM_RST */
|
|
|
|
/*!
|
|
* @brief Enable the WDOG Reset in SRC.
|
|
*
|
|
* WDOG Reset is enabled in SRC by default. If the WDOG event to SRC is masked, it would not create
|
|
* a reset to the chip. During the time the WDOG event is masked, when the WDOG event flag is
|
|
* asserted, it would remain asserted regardless of servicing the WDOG module. The only way to clear
|
|
* that bit is the hardware reset.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableWDOGReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable) /* WDOG Reset is not masked in SRC (default). */
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MWDR_MASK) | SRC_SCR_MWDR(0xA);
|
|
}
|
|
else /* WDOG Reset is masked in SRC. */
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_MWDR_MASK) | SRC_SCR_MWDR(0x5);
|
|
}
|
|
}
|
|
|
|
#if !(defined(FSL_FEATURE_SRC_HAS_NO_SCR_WRBC) && FSL_FEATURE_SRC_HAS_NO_SCR_WRBC)
|
|
/*!
|
|
* @brief Set the delay count of waiting MMDC's acknowledge.
|
|
*
|
|
* This function would define the 32KHz clock cycles to count before bypassing the MMDC acknowledge
|
|
* for WARM reset. If the MMDC acknowledge is not asserted before this counter is elapsed, a COLD
|
|
* reset will be initiated.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param option The option of setting mode, see to #src_warm_reset_bypass_count_t.
|
|
*/
|
|
static inline void SRC_SetWarmResetBypassCount(SRC_Type *base, src_warm_reset_bypass_count_t option)
|
|
{
|
|
base->SCR = (base->SCR & ~SRC_SCR_WRBC_MASK) | SRC_SCR_WRBC(option);
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_NO_SCR_WRBC */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_LOCKUP_RST) && FSL_FEATURE_SRC_HAS_SCR_LOCKUP_RST)
|
|
/*!
|
|
* @brief Enable the lockup reset.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableLockupReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable) /* Enable lockup reset. */
|
|
{
|
|
base->SCR |= SRC_SCR_LOCKUP_RST_MASK;
|
|
}
|
|
else /* Disable lockup reset. */
|
|
{
|
|
base->SCR &= ~SRC_SCR_LOCKUP_RST_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_LOCKUP_RST */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SCR_LUEN) && FSL_FEATURE_SRC_HAS_SCR_LUEN)
|
|
/*!
|
|
* @brief Enable the core lockup reset.
|
|
*
|
|
* When enable the core luckup reset, the system would be reset when core luckup event happens.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the reset or not.
|
|
*/
|
|
static inline void SRC_EnableCoreLockupReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable) /* Core lockup will cause system reset. */
|
|
{
|
|
base->SCR |= SRC_SCR_LUEN_MASK;
|
|
}
|
|
else /* Core lockup will not cause system reset. */
|
|
{
|
|
base->SCR &= ~SRC_SCR_LUEN_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SCR_LUEN */
|
|
|
|
#if !(defined(FSL_FEATURE_SRC_HAS_NO_SCR_WRE) && FSL_FEATURE_SRC_HAS_NO_SCR_WRE)
|
|
/*!
|
|
* @brief Enable the WARM reset.
|
|
*
|
|
* Only when the WARM reset is enabled, the WARM reset requests would be served by WARM reset.
|
|
* Otherwise, all the WARM reset sources would generate COLD reset.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Enable the WARM reset or not.
|
|
*/
|
|
static inline void SRC_EnableWarmReset(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->SCR |= SRC_SCR_WRE_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->SCR &= ~SRC_SCR_WRE_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_NO_SCR_WRE */
|
|
|
|
#if (defined(FSL_FEATURE_SRC_HAS_SISR) && FSL_FEATURE_SRC_HAS_SISR)
|
|
/*!
|
|
* @brief Get interrupt status flags.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return Mask value of status flags. See to $_src_status_flags.
|
|
*/
|
|
static inline uint32_t SRC_GetStatusFlags(SRC_Type *base)
|
|
{
|
|
return base->SISR;
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_SISR */
|
|
|
|
/*!
|
|
* @brief Get the boot mode register 1 value.
|
|
*
|
|
* The Boot Mode register contains bits that reflect the status of BOOT_CFGx pins of the chip.
|
|
* See to chip-specific document for detail information about value.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return status of BOOT_CFGx pins of the chip.
|
|
*/
|
|
static inline uint32_t SRC_GetBootModeWord1(SRC_Type *base)
|
|
{
|
|
return base->SBMR1;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the boot mode register 2 value.
|
|
*
|
|
* The Boot Mode register contains bits that reflect the status of BOOT_MODEx Pins and fuse values
|
|
* that controls boot of the chip. See to chip-specific document for detail information about value.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return status of BOOT_MODEx Pins and fuse values that controls boot of the chip.
|
|
*/
|
|
static inline uint32_t SRC_GetBootModeWord2(SRC_Type *base)
|
|
{
|
|
return base->SBMR2;
|
|
}
|
|
|
|
#if !(defined(FSL_FEATURE_SRC_HAS_NO_SRSR_WBI) && FSL_FEATURE_SRC_HAS_NO_SRSR_WBI)
|
|
/*!
|
|
* @brief Set the warm boot indication flag.
|
|
*
|
|
* WARM boot indication shows that WARM boot was initiated by software. This indicates to the
|
|
* software that it saved the needed information in the memory before initiating the WARM reset.
|
|
* In this case, software will set this bit to '1', before initiating the WARM reset. The warm_boot
|
|
* bit should be used as indication only after a warm_reset sequence. Software should clear this bit
|
|
* after warm_reset to indicate that the next warm_reset is not performed with warm_boot.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param enable Assert the flag or not.
|
|
*/
|
|
static inline void SRC_SetWarmBootIndication(SRC_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->SRSR = (base->SRSR & ~SRC_SRSR_W1C_BITS_MASK) | SRC_SRSR_WBI_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->SRSR = (base->SRSR & ~SRC_SRSR_W1C_BITS_MASK) & ~SRC_SRSR_WBI_MASK;
|
|
}
|
|
}
|
|
#endif /* FSL_FEATURE_SRC_HAS_NO_SRSR_WBI */
|
|
|
|
/*!
|
|
* @brief Get the status flags of SRC.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @return Mask value of status flags, see to #_src_reset_status_flags.
|
|
*/
|
|
static inline uint32_t SRC_GetResetStatusFlags(SRC_Type *base)
|
|
{
|
|
return base->SRSR;
|
|
}
|
|
|
|
/*!
|
|
* @brief Clear the status flags of SRC.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param Mask value of status flags to be cleared, see to #_src_reset_status_flags.
|
|
*/
|
|
void SRC_ClearResetStatusFlags(SRC_Type *base, uint32_t flags);
|
|
|
|
/*!
|
|
* @brief Set value to general purpose registers.
|
|
*
|
|
* General purpose registers (GPRx) would hold the value during reset process. Wakeup function could
|
|
* be kept in these register. For example, the GPR1 holds the entry function for waking-up from
|
|
* Partial SLEEP mode while the GPR2 holds the argument. Other GPRx register would store the
|
|
* arbitray values.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param index The index of GPRx register array. Note index 0 reponses the GPR1 register.
|
|
* @param value Setting value for GPRx register.
|
|
*/
|
|
static inline void SRC_SetGeneralPurposeRegister(SRC_Type *base, uint32_t index, uint32_t value)
|
|
{
|
|
assert(index < SRC_GPR_COUNT);
|
|
|
|
base->GPR[index] = value;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the value from general purpose registers.
|
|
*
|
|
* @param base SRC peripheral base address.
|
|
* @param index The index of GPRx register array. Note index 0 reponses the GPR1 register.
|
|
* @return The setting value for GPRx register.
|
|
*/
|
|
static inline uint32_t SRC_GetGeneralPurposeRegister(SRC_Type *base, uint32_t index)
|
|
{
|
|
assert(index < SRC_GPR_COUNT);
|
|
|
|
return base->GPR[index];
|
|
}
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
/*!
|
|
* @}
|
|
*/
|
|
#endif /* _FSL_SRC_H_ */
|