541 lines
14 KiB
C
541 lines
14 KiB
C
/* Copyright Statement:
|
|
*
|
|
* This software/firmware and related documentation ("AutoChips Software") are
|
|
* protected under relevant copyright laws. The information contained herein is
|
|
* confidential and proprietary to AutoChips Inc. and/or its licensors. Without
|
|
* the prior written permission of AutoChips inc. and/or its licensors, any
|
|
* reproduction, modification, use or disclosure of AutoChips Software, and
|
|
* information contained herein, in whole or in part, shall be strictly
|
|
* prohibited.
|
|
*
|
|
* AutoChips Inc. (C) 2021. All rights reserved.
|
|
*
|
|
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
|
|
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("AUTOCHIPS SOFTWARE")
|
|
* RECEIVED FROM AUTOCHIPS AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
|
|
* ON AN "AS-IS" BASIS ONLY. AUTOCHIPS EXPRESSLY DISCLAIMS ANY AND ALL
|
|
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
|
|
* NONINFRINGEMENT. NEITHER DOES AUTOCHIPS PROVIDE ANY WARRANTY WHATSOEVER WITH
|
|
* RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
|
|
* INCORPORATED IN, OR SUPPLIED WITH THE AUTOCHIPS SOFTWARE, AND RECEIVER AGREES
|
|
* TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
|
|
* RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
|
|
* OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN AUTOCHIPS
|
|
* SOFTWARE. AUTOCHIPS SHALL ALSO NOT BE RESPONSIBLE FOR ANY AUTOCHIPS SOFTWARE
|
|
* RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
|
|
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND AUTOCHIPS'S
|
|
* ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE AUTOCHIPS SOFTWARE
|
|
* RELEASED HEREUNDER WILL BE, AT AUTOCHIPS'S OPTION, TO REVISE OR REPLACE THE
|
|
* AUTOCHIPS SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
|
|
* CHARGE PAID BY RECEIVER TO AUTOCHIPS FOR SUCH AUTOCHIPS SOFTWARE AT ISSUE.
|
|
*/
|
|
|
|
/*!
|
|
* @file rtc_hw.h
|
|
*
|
|
* @brief RTC access register inline function definition.
|
|
*
|
|
*/
|
|
|
|
#ifndef RTC_HW_H
|
|
#define RTC_HW_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
/* =========================================== Includes =========================================== */
|
|
#include "rtc_drv.h"
|
|
|
|
/* ============================================ Define ============================================ */
|
|
|
|
/* =========================================== Typedef ============================================ */
|
|
|
|
/* ========================================== Variables =========================================== */
|
|
|
|
/* ==================================== Functions declaration ===================================== */
|
|
/*!
|
|
* @brief Enable RTC counter.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: the counter is already enabled
|
|
*/
|
|
status_t RTC_Enable(RTC_Type * const base);
|
|
|
|
/*!
|
|
* @brief Disable RTC counter.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: if the counter is not disabled
|
|
*/
|
|
status_t RTC_Disable(RTC_Type * const base);
|
|
|
|
/*!
|
|
* @brief Set RTC time counter value.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @param[in] timeCnt: 32-bit RTC time counter value
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: if setting value error because timer is enabled
|
|
*/
|
|
status_t RTC_SetTimeCntRegister(RTC_Type * const base, uint32_t timeCnt);
|
|
|
|
/*!
|
|
* @brief Set RTC prescaler value.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @param[in] psrValue: 32-bit RTC prescaler value
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: if setting value error because timer is enabled
|
|
*/
|
|
status_t RTC_SetPrescaler(RTC_Type * const base, uint32_t psrValue);
|
|
|
|
/*!
|
|
* @brief Configure RTC lock register.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @param[in] registerType: RTC lock register type
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: if lock register is locked, and lock setting cannot be modified.
|
|
*/
|
|
status_t RTC_ConfigureLockRegister(RTC_Type * const base, rtc_lock_register_select_t registerType);
|
|
|
|
/*!
|
|
* @brief Get RTC lock register status.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @param[in] reg: RTC lock register type
|
|
* @return True if the register is locked, false if not
|
|
*/
|
|
bool RTC_IsRegisterLocked(const RTC_Type * const base, rtc_lock_register_select_t reg);
|
|
|
|
/*!
|
|
* @brief Configure the RTC clkout pin.
|
|
*
|
|
* @param[in] base: The RTC base pointer
|
|
* @param[in] config: RTC clkout pin configuration
|
|
* @return the result of operation
|
|
* - STATUS_SUCCESS: operation was successful
|
|
* - STATUS_ERROR: if control register is locked, and cannot enable RTC clkout function
|
|
*/
|
|
status_t RTC_ConfigureClockOut(RTC_Type * const base, rtc_clk_out_config_t config);
|
|
|
|
/* ===================================== Functions definition ===================================== */
|
|
/*!
|
|
* @brief Get RTC control register.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return control register value
|
|
*/
|
|
static inline uint32_t RTC_GetCtrlReg(const RTC_Type * const base)
|
|
{
|
|
return (base->CTRL);
|
|
}
|
|
|
|
/*!
|
|
* @brief Set RTC Time alarm value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetTimeAlarmReg(RTC_Type * const base, uint32_t alarmCnt)
|
|
{
|
|
base->TAR = alarmCnt;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC prescaler value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return RTC prescaler value
|
|
*/
|
|
static inline uint32_t RTC_GetPrescaler(const RTC_Type * const base)
|
|
{
|
|
return (base->PSR);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC time counter value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return RTC time counter value
|
|
*/
|
|
static inline uint32_t RTC_GetTimeCntReg(const RTC_Type * const base)
|
|
{
|
|
return (base->TC);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC prescaler value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return RTC cnt value
|
|
*/
|
|
static inline uint32_t RTC_GetPrescalerCnt(const RTC_Type * const base)
|
|
{
|
|
return (base->PSC);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC Time alarm value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return RTC Time alarm value
|
|
*/
|
|
static inline uint32_t RTC_GetTimeAlarmReg(const RTC_Type * const base)
|
|
{
|
|
return (base->TAR);
|
|
}
|
|
|
|
/*!
|
|
* @brief Select RTC Clk Source.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] clksrc: RTC clk source
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetClksrc(RTC_Type * const base, rtc_clksource_select_t clksrc)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
/* PRQA S 4532,4533,5209,1821 ++ */
|
|
tmp &= ~RTC_CTRL_CLKSEL_Msk;
|
|
tmp |= ((int)clksrc << RTC_CTRL_CLKSEL_Pos);
|
|
/* PRQA S 4532,4533,5209,1821 -- */
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable/disable RTC invalid interrupt.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC invalid interrupt
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetTIIE(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_TIIE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_TIIE_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable/disable RTC prescaler counter overflow interrupt.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC prescaler counter overflow interrupt
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetPOIE(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_POIE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_POIE_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable/disable RTC time counter overflow interrupt.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC time counter overflow interrupt
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetTOIE(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_TOIE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_TOIE_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable/disable RTC time alarm interrupt.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC time alarm interrupt
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetTAIE(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_TAIE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_TAIE_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable/disable RTC output.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC output
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetRTCOutput(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_COE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_COE_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Set RTC update mode of the register when locked.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable RTC update
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetUpdateMode(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->CTRL;
|
|
|
|
tmp &= ~RTC_CTRL_UPM_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_CTRL_UPM_Msk;
|
|
}
|
|
base->CTRL = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC update mode of the register when locked.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return update mode value
|
|
*/
|
|
static inline uint32_t RTC_GetUpdateMode(const RTC_Type * const base)
|
|
{
|
|
return (base->CTRL & RTC_CTRL_UPM_Msk);
|
|
}
|
|
|
|
/*!
|
|
* @brief Trigger RTC a software reset.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SoftwareReset(RTC_Type * const base)
|
|
{
|
|
base->CTRL |= RTC_CTRL_SWR_Msk;
|
|
base->CTRL &= ~RTC_CTRL_SWR_Msk;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC status register value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return RTC status register value
|
|
*/
|
|
static inline uint32_t RTC_GetStatusReg(const RTC_Type * const base)
|
|
{
|
|
return (base->SR);
|
|
}
|
|
|
|
/*!
|
|
* @brief Enable or disable RTC counter.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @param[in] enable: Enable/disable rtc counter
|
|
* @return None
|
|
*/
|
|
static inline void RTC_SetTimeCounterEnable(RTC_Type * const base, bool enable)
|
|
{
|
|
uint32_t tmp = base->SR & ~(RTC_SR_POF_Msk);
|
|
|
|
tmp &= ~RTC_SR_TCE_Msk;
|
|
if (true == enable)
|
|
{
|
|
tmp |= RTC_SR_TCE_Msk;
|
|
}
|
|
base->SR = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get RTC counter enable value.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return State of the counter enable bit
|
|
* - true if the counter is enabled
|
|
* - false if the counter is disabled
|
|
*/
|
|
static inline bool RTC_GetTimeCounterEnable(const RTC_Type * const base)
|
|
{
|
|
return (((base->SR & RTC_SR_TCE_Msk) >> RTC_SR_TCE_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get rtc time alarm flag.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return rtc time alarm flag
|
|
*/
|
|
static inline bool RTC_GetTAF(const RTC_Type * const base)
|
|
{
|
|
return (((base->SR & RTC_SR_TAF_Msk) >> RTC_SR_TAF_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get rtc time counter overflow flag.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return rtc time counter overflow flag
|
|
*/
|
|
static inline bool RTC_GetTOF(const RTC_Type * const base)
|
|
{
|
|
return (((base->SR & RTC_SR_TOF_Msk) >> RTC_SR_TOF_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get rtc prescaler time counter overflow flag.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return rtc time prescaler counter overflow flag
|
|
*/
|
|
static inline bool RTC_GetPOF(const RTC_Type * const base)
|
|
{
|
|
return (((base->SR & RTC_SR_POF_Msk) >> RTC_SR_POF_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Clear rtc time prescaler counter overflow flag.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_ClearPOF(RTC_Type * const base)
|
|
{
|
|
uint32_t tmp = base->SR;
|
|
|
|
tmp |= RTC_SR_POF_Msk;
|
|
base->SR = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get rtc time invalid flag.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return rtc time invalid flag
|
|
*/
|
|
static inline bool RTC_GetTIF(const RTC_Type * const base)
|
|
{
|
|
return (((base->SR & RTC_SR_TIF_Msk) >> RTC_SR_TIF_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Lock the lock register.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_LockLR(RTC_Type * const base)
|
|
{
|
|
uint32_t tmp = base->LR;
|
|
|
|
tmp |= RTC_LR_LRL_Msk;
|
|
base->LR = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the lock register lock state.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return The status of lock state
|
|
* - true: register is locked
|
|
* - false: register is not locked
|
|
*/
|
|
static inline bool RTC_GetLRL(const RTC_Type * const base)
|
|
{
|
|
return (((base->LR & RTC_LR_LRL_Msk) >> RTC_LR_LRL_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Lock the status register.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_LockSR(RTC_Type * const base)
|
|
{
|
|
uint32_t tmp = base->LR;
|
|
|
|
tmp |= RTC_LR_SRL_Msk;
|
|
base->LR = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the status register lock state.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return The status of lock state
|
|
* - true: register is locked
|
|
* - false: register is not locked
|
|
*/
|
|
static inline bool RTC_GetSRL(const RTC_Type * const base)
|
|
{
|
|
return (((base->LR & RTC_LR_SRL_Msk) >> RTC_LR_SRL_Pos) != 0U);
|
|
}
|
|
|
|
/*!
|
|
* @brief Lock the control register.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return None
|
|
*/
|
|
static inline void RTC_LockCTRL(RTC_Type * const base)
|
|
{
|
|
uint32_t tmp = base->LR;
|
|
|
|
tmp |= RTC_LR_CRL_Msk;
|
|
base->LR = tmp;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the control register lock state.
|
|
*
|
|
* @param[in] base: RTC base pointer
|
|
* @return The status of lock state
|
|
* - true: register is locked
|
|
* - false: register is not locked
|
|
*/
|
|
static inline bool RTC_GetCRL(const RTC_Type * const base)
|
|
{
|
|
return (((base->LR & RTC_LR_CRL_Msk) >> RTC_LR_CRL_Pos) != 0U);
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* RTC_HW_H */
|
|
|
|
/* ============================================= EOF ============================================== */
|