dl_rtc_common.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  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.
 *
 * *  Neither the name of Texas Instruments Incorporated 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 SHALL THE COPYRIGHT OWNER 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 TfHEORY 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.
 */
/*!****************************************************************************
 *  @file       dl_rtc_common.h
 *  @brief      Real Time Clock A (RTC Common) Peripheral Interface
 *  @defgroup   Common Real Time Clock (RTC_Common)
 *
 *  @anchor ti_devices_msp_dl_rtc_common_Overview
 *  # Overview
 *  The RTC Common Driver Library allows full configuration of the MSPM0 RTC Common module.
 *  The real-time clock (RTC Common) module provides clock counters with calendar mode,
 *  a flexible programmable alarm, offset calibration, and a provision for
 *  temperature compensation. The module also provides a separate time stamp calendar
 *  capable of capturing a time stamp event upon loss of VDD or detection of a tamper event
 *  on a tamper I/O pin.
 *
 *  <hr>
 ******************************************************************************
 */
#ifndef ti_dl_dl_rtc_common__include
#define ti_dl_dl_rtc_common__include

#include <stdbool.h>
#include <stdint.h>

#include <ti/devices/msp/msp.h>
#include <ti/driverlib/dl_common.h>

#if defined __MSPM0_HAS_RTC_A__ || defined __MSPM0_HAS_RTC_B__ || \
    defined __MSPM0_HAS_RTC__ || defined(DOXYGEN__INCLUDE)

#ifdef __cplusplus
extern "C" {
#endif

/* clang-format off */

#define DL_RTC_COMMON_INTERRUPT_CALENDAR_ALARM1          (RTC_CPU_INT_IMASK_RTCA1_SET)

#define DL_RTC_COMMON_INTERRUPT_CALENDAR_ALARM2          (RTC_CPU_INT_IMASK_RTCA2_SET)

#define DL_RTC_COMMON_INTERRUPT_PRESCALER0               (RTC_CPU_INT_IMASK_RT0PS_SET)

#define DL_RTC_COMMON_INTERRUPT_PRESCALER1               (RTC_CPU_INT_IMASK_RT1PS_SET)

#ifdef __MSPM0_HAS_RTC_B__

#define DL_RTC_COMMON_INTERRUPT_PRESCALER2                (RTC_CPU_INT_IMASK_RT2PS_SET)
#endif

#define DL_RTC_COMMON_INTERRUPT_INTERVAL_ALARM           (RTC_CPU_INT_IMASK_RTCTEV_SET)

#define DL_RTC_COMMON_INTERRUPT_READY                    (RTC_CPU_INT_IMASK_RTCRDY_SET)

#ifdef __MSPM0_HAS_RTC_A__

#define DL_RTC_COMMON_INTERRUPT_TSEVT                    (RTC_CPU_INT_IMASK_TSEVT_SET)
#endif

#define DL_RTC_COMMON_EVENT_CALENDAR_ALARM1              (RTC_GEN_EVENT_IMASK_RTCA1_SET)

#define DL_RTC_COMMON_EVENT_CALENDAR_ALARM2              (RTC_GEN_EVENT_IMASK_RTCA2_SET)

#define DL_RTC_COMMON_EVENT_PRESCALER0                   (RTC_GEN_EVENT_IMASK_RT0PS_SET)

#define DL_RTC_COMMON_EVENT_PRESCALER1                   (RTC_GEN_EVENT_IMASK_RT1PS_SET)

#ifdef __MSPM0_HAS_RTC_B__

#define DL_RTC_COMMON_EVENT_PRESCALER2                   (RTC_GEN_EVENT_IMASK_RT2PS_SET)
#endif

#define DL_RTC_COMMON_EVENT_INTERVAL_ALARM               (RTC_GEN_EVENT_IMASK_RTCTEV_SET)

#define DL_RTC_COMMON_EVENT_READY                        (RTC_GEN_EVENT_IMASK_RTCRDY_SET)

#ifdef __MSPM0_HAS_RTC_A__

#define DL_RTC_COMMON_EVENT_TSEVT                        (RTC_GEN_EVENT_IMASK_TSEVT_SET)
#endif

#ifdef __MSPM0_HAS_RTC_A__

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_0       (RTC_TSSTAT_TSTIOEVT0_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_1       (RTC_TSSTAT_TSTIOEVT1_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_2       (RTC_TSSTAT_TSTIOEVT2_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_3       (RTC_TSSTAT_TSTIOEVT3_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_4       (RTC_TSSTAT_TSTIOEV4_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_5       (RTC_TSSTAT_TSTIOEVT5_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_6       (RTC_TSSTAT_TSTIOEVT6_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_7       (RTC_TSSTAT_TSTIOEVT7_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_8       (RTC_TSSTAT_TSTIOEV8_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_9       (RTC_TSSTAT_TSTIOEVT9_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_10      (RTC_TSSTAT_TSTIOEVT10_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_11      (RTC_TSSTAT_TSTIOEVT11_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_12      (RTC_TSSTAT_TSTIOEVT12_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_13      (RTC_TSSTAT_TSTIOEVT13_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_14      (RTC_TSSTAT_TSTIOEVT14_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_15      (RTC_TSSTAT_TSTIOEVT15_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_VDD_LOSS    (RTC_TSSTAT_TSVDDEVT_SET)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_0      (RTC_TSCTL_TSTIOEN0_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_1      (RTC_TSCTL_TSTIOEN1_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_2      (RTC_TSCTL_TSTIOEN2_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_3      (RTC_TSCTL_TSTIOEN3_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_4      (RTC_TSCTL_TSTIOEN4_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_5      (RTC_TSCTL_TSTIOEN5_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_6      (RTC_TSCTL_TSTIOEN6_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_7      (RTC_TSCTL_TSTIOEN8_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_8      (RTC_TSCTL_TSTIOEN8_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_9      (RTC_TSCTL_TSTIOEN9_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_10     (RTC_TSCTL_TSTIOEN10_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_11     (RTC_TSCTL_TSTIOEN11_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_12     (RTC_TSCTL_TSTIOEN12_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_13     (RTC_TSCTL_TSTIOEN13_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_14     (RTC_TSCTL_TSTIOEN14_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_15     (RTC_TSCTL_TSTIOEN15_ENABLE)

#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_VDD_LOSS   (RTC_TSCTL_TSVDDEN_ENABLE)

#endif

typedef enum {
    DL_RTC_COMMON_STATUS_READY = RTC_STA_RTCRDY_READY,
    DL_RTC_COMMON_STATUS_NOT_READY = RTC_STA_RTCRDY_NOT_READY
} DL_RTC_COMMON_STATUS;

typedef enum {
    DL_RTC_COMMON_COMPENSATION_STATUS_READY = RTC_STA_RTCTCRDY_READY,
    DL_RTC_COMMON_COMPENSATION_STATUS_NOT_READY = RTC_STA_RTCTCRDY_NOT_READY
} DL_RTC_COMMON_COMPENSATION_STATUS;

typedef enum {
    DL_RTC_COMMON_COMPENSATION_WRITE_RESULT_OK = RTC_STA_RTCTCOK_OK,
    DL_RTC_COMMON_COMPENSATION_WRITE_RESULT_NOT_OK = RTC_STA_RTCTCOK_NOT_OK
} DL_RTC_COMMON_COMPENSATION_WRITE_RESULT;

typedef enum {
    DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN_DOWN = RTC_CAL_RTCOCALS_DOWN,
    DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN_UP = RTC_CAL_RTCOCALS_UP
} DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN;

typedef enum {
    #ifdef __MSPM0_HAS_RTC__

    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_OFF = RTC_CAL_RTCCALFX_OFF,
    #endif
    #ifdef __MSPM0_HAS_RTC_A__

    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_32_KHZ = LFSS_CAL_RTCCALFX_F32KHZ,
    #endif

    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_512 = RTC_CAL_RTCCALFX_F512HZ,
    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_256 = RTC_CAL_RTCCALFX_F256HZ,
    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_1 = RTC_CAL_RTCCALFX_F1HZ
} DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY;

typedef enum {
    DL_RTC_COMMON_TEMP_CALIBRATION_DOWN1PPM = RTC_TCMP_RTCTCMPS_DOWN,
    DL_RTC_COMMON_TEMP_CALIBRATION_UP1PPM = RTC_TCMP_RTCTCMPS_UP
} DL_RTC_COMMON_TEMP_CALIBRATION;

typedef enum {
    DL_RTC_COMMON_FORMAT_BINARY = RTC_CTL_RTCBCD_BINARY,
    DL_RTC_COMMON_FORMAT_BCD = RTC_CTL_RTCBCD_BCD
} DL_RTC_COMMON_FORMAT;

typedef enum {
    DL_RTC_COMMON_INTERVAL_ALARM_MINUTECHANGE = RTC_CTL_RTCTEVTX_MINUTE,
    DL_RTC_COMMON_INTERVAL_ALARM_HOURCHANGE = RTC_CTL_RTCTEVTX_HOUR,
    DL_RTC_COMMON_INTERVAL_ALARM_NOON = RTC_CTL_RTCTEVTX_NOON,
    DL_RTC_COMMON_INTERVAL_ALARM_MIDNIGHT = RTC_CTL_RTCTEVTX_MIDNIGHT
} DL_RTC_COMMON_INTERVAL_ALARM;

typedef enum {
    DL_RTC_COMMON_PRESCALER0_DIVIDE_8 = RTC_PSCTL_RT0IP_DIV8,
    DL_RTC_COMMON_PRESCALER0_DIVIDE_16 = RTC_PSCTL_RT0IP_DIV16,
    DL_RTC_COMMON_PRESCALER0_DIVIDE_32 = RTC_PSCTL_RT0IP_DIV32,
    DL_RTC_COMMON_PRESCALER0_DIVIDE_64 = RTC_PSCTL_RT0IP_DIV64,
    DL_RTC_COMMON_PRESCALER0_DIVIDE_128 = RTC_PSCTL_RT0IP_DIV128,
    DL_RTC_COMMON_PRESCALER0_DIVIDE_256 = RTC_PSCTL_RT0IP_DIV256
} DL_RTC_COMMON_PRESCALER0_DIVIDE;

typedef enum {
    DL_RTC_COMMON_PRESCALER1_DIVIDE_2 = RTC_PSCTL_RT1IP_DIV2,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_4 = RTC_PSCTL_RT1IP_DIV4,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_8 = RTC_PSCTL_RT1IP_DIV8,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_16 = RTC_PSCTL_RT1IP_DIV16,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_32 = RTC_PSCTL_RT1IP_DIV32,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_64 = RTC_PSCTL_RT1IP_DIV64,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_128 = RTC_PSCTL_RT1IP_DIV128,
    DL_RTC_COMMON_PRESCALER1_DIVIDE_256 = RTC_PSCTL_RT1IP_DIV256
} DL_RTC_COMMON_PRESCALER1_DIVIDE;

typedef enum {
    DL_RTC_COMMON_PRESCALER2_4_SEC = RTC_EXTPSCTL_RT2PS_INT4S,
    DL_RTC_COMMON_PRESCALER2_8_SEC = RTC_EXTPSCTL_RT2PS_INT8S,
    DL_RTC_COMMON_PRESCALER2_16_SEC = RTC_EXTPSCTL_RT2PS_INT16S
} DL_RTC_COMMON_PRESCALER2_DIVIDE;

typedef enum {
    DL_RTC_COMMON_IIDX_ALARM1 = RTC_CPU_INT_IIDX_STAT_RTCA1,
    DL_RTC_COMMON_IIDX_ALARM2 = RTC_CPU_INT_IIDX_STAT_RTCA2,
    DL_RTC_COMMON_IIDX_PRESCALER0 = RTC_CPU_INT_IIDX_STAT_RT0PS,
    DL_RTC_COMMON_IIDX_PRESCALER1 = RTC_CPU_INT_IIDX_STAT_RT1PS,
    DL_RTC_COMMON_IIDX_PRESCALER2 = RTC_CPU_INT_IIDX_STAT_RT2PS,
    DL_RTC_COMMON_IIDX_INTERVAL_TIMER = RTC_CPU_INT_IIDX_STAT_RTCTEV,
    DL_RTC_COMMON_IIDX_READY = RTC_CPU_INT_IIDX_STAT_RTCRDY,
    #ifdef __MSPM0_HAS_RTC_A__
    DL_RTC_COMMON_IIDX_TSEVT = RTC_CPU_INT_IIDX_STAT_TSEVT,
    DL_RTC_COMMON_IIDX_TAMPER_IO_0 = RTC_CPU_INT_IIDX_STAT_TIO0,
    DL_RTC_COMMON_IIDX_TAMPER_IO_1 = RTC_CPU_INT_IIDX_STAT_TIO1,
    DL_RTC_COMMON_IIDX_TAMPER_IO_2 = RTC_CPU_INT_IIDX_STAT_TIO2,
    DL_RTC_COMMON_IIDX_TAMPER_IO_3 = RTC_CPU_INT_IIDX_STAT_TIO3,
    DL_RTC_COMMON_IIDX_TAMPER_IO_4 = RTC_CPU_INT_IIDX_STAT_TIO4,
    DL_RTC_COMMON_IIDX_TAMPER_IO_5 = RTC_CPU_INT_IIDX_STAT_TIO5,
    DL_RTC_COMMON_IIDX_TAMPER_IO_6 = RTC_CPU_INT_IIDX_STAT_TIO6,
    DL_RTC_COMMON_IIDX_TAMPER_IO_7 = RTC_CPU_INT_IIDX_STAT_TIO7,
    DL_RTC_COMMON_IIDX_TAMPER_IO_8 = RTC_CPU_INT_IIDX_STAT_TIO8,
    DL_RTC_COMMON_IIDX_TAMPER_IO_9 = RTC_CPU_INT_IIDX_STAT_TIO9,
    DL_RTC_COMMON_IIDX_TAMPER_IO_10 = RTC_CPU_INT_IIDX_STAT_TIO10,
    DL_RTC_COMMON_IIDX_TAMPER_IO_11 = RTC_CPU_INT_IIDX_STAT_TIO11,
    DL_RTC_COMMON_IIDX_TAMPER_IO_12 = RTC_CPU_INT_IIDX_STAT_TIO12,
    DL_RTC_COMMON_IIDX_TAMPER_IO_13 = RTC_CPU_INT_IIDX_STAT_TIO13,
    DL_RTC_COMMON_IIDX_TAMPER_IO_14 = RTC_CPU_INT_IIDX_STAT_TIO14,
    DL_RTC_COMMON_IIDX_TAMPER_IO_15 = RTC_CPU_INT_IIDX_STAT_TIO15,
    #endif
} DL_RTC_COMMON_IIDX;

#ifdef __MSPM0_HAS_RTC_A__

typedef enum {
    DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE_FIRST = RTC_TSCTL_TSCAPTURE_FIRST,
    DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE_LAST = RTC_TSCTL_TSCAPTURE_LAST,
} DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE;
#endif

/* clang-format on */

typedef struct {
    uint8_t minutes;
    uint8_t hours;
    uint8_t dayOfWeek;
    uint8_t dayOfMonth;
} DL_RTC_Common_CalendarAlarm;

typedef struct {
    uint8_t seconds;
    uint8_t minutes;
    uint8_t hours;
    uint8_t dayOfWeek;
    uint8_t dayOfMonth;
    uint8_t month;
    uint16_t year;
} DL_RTC_Common_Calendar;

__STATIC_INLINE bool DL_RTC_Common_isClockSourceLFCLK(
    const RTC_Regs *rtc_common)
{
    return ((rtc_common->CLKSEL & RTC_CLKSEL_LFCLK_SEL_MASK) ==
            RTC_CLKSEL_LFCLK_SEL_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableClockControl(RTC_Regs *rtc_common)
{
    rtc_common->CLKCTL = RTC_CLKCTL_MODCLKEN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableClockControl(RTC_Regs *rtc_common)
{
    rtc_common->CLKCTL = RTC_CLKCTL_MODCLKEN_DISABLE;
}

__STATIC_INLINE void DL_RTC_Common_enablePower(RTC_Regs *rtc_common)
{
    rtc_common->GPRCM.PWREN =
        (RTC_PWREN_KEY_UNLOCK_W | RTC_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_RTC_Common_disablePower(RTC_Regs *rtc_common)
{
    rtc_common->GPRCM.PWREN =
        (RTC_PWREN_KEY_UNLOCK_W | RTC_PWREN_ENABLE_DISABLE);
}

__STATIC_INLINE bool DL_RTC_Common_isPowerEnabled(const RTC_Regs *rtc_common)
{
    return ((rtc_common->GPRCM.PWREN & RTC_PWREN_ENABLE_MASK) ==
            RTC_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_RTC_Common_reset(RTC_Regs *rtc_common)
{
    rtc_common->GPRCM.RSTCTL =
        (RTC_RSTCTL_KEY_UNLOCK_W | RTC_RSTCTL_RESETSTKYCLR_CLR |
            RTC_RSTCTL_RESETASSERT_ASSERT);
}

__STATIC_INLINE bool DL_RTC_Common_isReset(const RTC_Regs *rtc_common)
{
    return ((rtc_common->GPRCM.STAT & RTC_STAT_RESETSTKY_MASK) ==
            RTC_STAT_RESETSTKY_RESET);
}

__STATIC_INLINE void DL_RTC_Common_enableDebugInterrupts(RTC_Regs *rtc_common)
{
    rtc_common->DBGCTL |= RTC_DBGCTL_DBGINT_ON;
}

__STATIC_INLINE void DL_RTC_Common_disableDebugInterrupts(RTC_Regs *rtc_common)
{
    rtc_common->DBGCTL &= ~(RTC_DBGCTL_DBGINT_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableDebugMode(RTC_Regs *rtc_common)
{
    rtc_common->DBGCTL |= RTC_DBGCTL_DBGRUN_RUN;
}

__STATIC_INLINE void DL_RTC_Common_disableDebugMode(RTC_Regs *rtc_common)
{
    rtc_common->DBGCTL &= ~(RTC_DBGCTL_DBGRUN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setClockFormat(
    RTC_Regs *rtc_common, DL_RTC_COMMON_FORMAT formatSelect)
{
    rtc_common->CTL |= (uint32_t) formatSelect;
}

__STATIC_INLINE DL_RTC_COMMON_FORMAT DL_RTC_Common_getClockFormat(
    const RTC_Regs *rtc_common)
{
    uint32_t format = (rtc_common->CTL & RTC_CTL_RTCBCD_MASK);

    return (DL_RTC_COMMON_FORMAT)(format);
}

__STATIC_INLINE void DL_RTC_Common_setIntervalAlarm(
    RTC_Regs *rtc_common, DL_RTC_COMMON_INTERVAL_ALARM alarmEvent)
{
    DL_Common_updateReg(
        &rtc_common->CTL, (uint32_t) alarmEvent, RTC_CTL_RTCTEVTX_MASK);
}

__STATIC_INLINE DL_RTC_COMMON_INTERVAL_ALARM DL_RTC_Common_getIntervalAlarm(
    const RTC_Regs *rtc_common)
{
    uint32_t alarm = (rtc_common->CTL & RTC_CTL_RTCTEVTX_MASK);

    return (DL_RTC_COMMON_INTERVAL_ALARM)(alarm);
}

__STATIC_INLINE bool DL_RTC_Common_isSafeToRead(const RTC_Regs *rtc_common)
{
    return ((rtc_common->STA & RTC_STA_RTCRDY_MASK) == RTC_STA_RTCRDY_READY);
}

__STATIC_INLINE bool DL_RTC_Common_isReadyToCalibrate(
    const RTC_Regs *rtc_common)
{
    return (
        (rtc_common->STA & RTC_STA_RTCTCRDY_MASK) == RTC_STA_RTCTCRDY_READY);
}

__STATIC_INLINE bool DL_RTC_Common_isCalibrationWriteResultOK(
    const RTC_Regs *rtc_common)
{
    return ((rtc_common->STA & RTC_STA_RTCTCOK_MASK) == RTC_STA_RTCTCOK_OK);
}

__STATIC_INLINE void DL_RTC_Common_setOffsetCalibrationFrequency(
    RTC_Regs *rtc_common,
    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY offsetFrequency)
{
    DL_Common_updateReg(
        &rtc_common->CAL, (uint32_t) offsetFrequency, RTC_CAL_RTCCALFX_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setOffsetCalibrationAdjValue(
    RTC_Regs *rtc_common, DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN offsetSign,
    uint8_t offsetValue)
{
    DL_Common_updateReg(&rtc_common->CAL,
        ((uint32_t) offsetSign | (uint32_t) offsetValue),
        (RTC_CAL_RTCOCALX_MASK | RTC_CAL_RTCOCALS_MASK));
}

__STATIC_INLINE void DL_RTC_Common_setOffsetCalibration(RTC_Regs *rtc_common,
    DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY offsetFrequency,
    DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN offsetSign, uint8_t offsetValue)
{
    rtc_common->CAL = (offsetValue & RTC_CAL_RTCOCALX_MASK) |
                      (uint32_t) offsetFrequency | (uint32_t) offsetSign;
}

__STATIC_INLINE DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY
DL_RTC_Common_getOffsetCalibrationFrequency(const RTC_Regs *rtc_common)
{
    uint32_t freq = (rtc_common->CAL & RTC_CAL_RTCCALFX_MASK);

    return (DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY)(freq);
}

__STATIC_INLINE DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN
DL_RTC_Common_getOffsetCalibrationSign(const RTC_Regs *rtc_common)
{
    uint32_t sign = (rtc_common->CAL & RTC_CAL_RTCOCALS_MASK);

    return (DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN)(sign);
}

__STATIC_INLINE void DL_RTC_Common_setTemperatureCompensation(
    RTC_Regs *rtc_common, DL_RTC_COMMON_TEMP_CALIBRATION offsetDirection,
    uint32_t offsetValue)
{
    rtc_common->TCMP =
        (offsetValue & RTC_TCMP_RTCTCMPX_MASK) | (uint32_t) offsetDirection;
}

__STATIC_INLINE uint32_t DL_RTC_Common_getTemperatureCompensation(
    const RTC_Regs *rtc_common)
{
    return (rtc_common->TCMP);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarSecondsBCD(
    RTC_Regs *rtc_common, uint8_t seconds)
{
    rtc_common->SEC = ((uint32_t) seconds << RTC_SEC_SECLOWBCD_OFS) &
                      (RTC_SEC_SECLOWBCD_MASK | RTC_SEC_SECHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarSecondsBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->SEC &
                         (RTC_SEC_SECLOWBCD_MASK | RTC_SEC_SECHIGHBCD_MASK)) >>
                     RTC_SEC_SECLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarMinutesBCD(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->MIN = ((uint32_t) minutes << RTC_MIN_MINLOWBCD_OFS) &
                      (RTC_MIN_MINLOWBCD_MASK | RTC_MIN_MINHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMinutesBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->MIN &
                         (RTC_MIN_MINLOWBCD_MASK | RTC_MIN_MINHIGHBCD_MASK)) >>
                     RTC_MIN_MINLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarHoursBCD(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->HOUR = ((uint32_t) hours << RTC_HOUR_HOURLOWBCD_OFS) &
                       (RTC_HOUR_HOURLOWBCD_MASK | RTC_HOUR_HOURHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarHoursBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->HOUR & (RTC_HOUR_HOURLOWBCD_MASK |
                                             RTC_HOUR_HOURHIGHBCD_MASK)) >>
                     RTC_HOUR_HOURLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfWeekBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->DAY, day, RTC_DAY_DOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfWeekBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->DAY & RTC_DAY_DOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfMonthBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->DAY,
        (uint32_t) day << RTC_DAY_DOMLOWBCD_OFS,
        (RTC_DAY_DOMLOWBCD_MASK | RTC_DAY_DOMHIGHBCD_MASK));
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->DAY &
                         (RTC_DAY_DOMLOWBCD_MASK | RTC_DAY_DOMHIGHBCD_MASK)) >>
                     RTC_DAY_DOMLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarMonthBCD(
    RTC_Regs *rtc_common, uint8_t month)
{
    rtc_common->MON = ((uint32_t) month << RTC_MON_MONLOWBCD_OFS) &
                      (RTC_MON_MONLOWBCD_MASK | RTC_MON_MONHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->MON &
                         (RTC_MON_MONLOWBCD_MASK | RTC_MON_MONHIGHBCD_MASK)) >>
                     RTC_MON_MONLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarYearBCD(
    RTC_Regs *rtc_common, uint16_t year)
{
    rtc_common->YEAR =
        ((uint32_t) year << RTC_YEAR_YEARLOWESTBCD_OFS) &
        (RTC_YEAR_YEARLOWESTBCD_MASK | RTC_YEAR_DECADEBCD_MASK |
            RTC_YEAR_CENTLOWBCD_MASK | RTC_YEAR_CENTHIGHBCD_MASK);
}

__STATIC_INLINE uint16_t DL_RTC_Common_getCalendarYearBCD(
    const RTC_Regs *rtc_common)
{
    return (uint16_t)(
        (rtc_common->YEAR &
            (RTC_YEAR_YEARLOWESTBCD_MASK | RTC_YEAR_DECADEBCD_MASK |
                RTC_YEAR_CENTLOWBCD_MASK | RTC_YEAR_CENTHIGHBCD_MASK)) >>
        RTC_YEAR_YEARLOWESTBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1MinutesBCD(RTC_Regs *rtc_common)
{
    rtc_common->A1MIN |= RTC_A1MIN_AMINAEBCD_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1MinutesBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A1MIN &= ~(RTC_A1MIN_AMINAEBCD_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1MinutesBCD(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->A1MIN =
        ((uint32_t) minutes << RTC_A1MIN_AMINLOWBCD_OFS) &
        (RTC_A1MIN_AMINLOWBCD_MASK | RTC_A1MIN_AMINHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1MinutesBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->A1MIN & (RTC_A1MIN_AMINLOWBCD_MASK |
                                              RTC_A1MIN_AMINHIGHBCD_MASK)) >>
                     RTC_A1MIN_AMINLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1HoursBCD(RTC_Regs *rtc_common)
{
    rtc_common->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1HoursBCD(RTC_Regs *rtc_common)
{
    rtc_common->A1HOUR &= ~(RTC_A1HOUR_AHOURAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1HoursBCD(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->A1HOUR =
        ((uint32_t) hours << RTC_A1HOUR_AHOURLOWBCD_OFS) &
        (RTC_A1HOUR_AHOURLOWBCD_MASK | RTC_A1HOUR_AHOURHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1HoursBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->A1HOUR &
            (RTC_A1HOUR_AHOURLOWBCD_MASK | RTC_A1HOUR_AHOURHIGHBCD_MASK)) >>
        RTC_A1HOUR_AHOURLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfWeekBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfWeekBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY &= ~(RTC_A1DAY_ADOWAE_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfWeekBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A1DAY, day, RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfWeekBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->DAY & RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfMonthBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY |= RTC_A1DAY_ADOMAEBCD_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfMonthBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY &= ~(RTC_A1DAY_ADOMAEBCD_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfMonthBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A1DAY,
        (uint32_t) day << RTC_A1DAY_ADOMLOWBCD_OFS,
        (RTC_A1DAY_ADOMLOWBCD_MASK | RTC_A1DAY_ADOMHIGHBCD_MASK));
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->A1DAY & (RTC_A1DAY_ADOMLOWBCD_MASK |
                                              RTC_A1DAY_ADOMHIGHBCD_MASK)) >>
                     RTC_A1DAY_ADOMLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2MinutesBCD(RTC_Regs *rtc_common)
{
    rtc_common->A2MIN |= RTC_A2MIN_AMINAEBCD_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2MinutesBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A2MIN &= ~(RTC_A2MIN_AMINAEBCD_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2MinutesBCD(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->A2MIN =
        ((uint32_t) minutes << RTC_A2MIN_AMINLOWBCD_OFS) &
        (RTC_A2MIN_AMINLOWBCD_MASK | RTC_A2MIN_AMINHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2MinutesBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->A2MIN & (RTC_A2MIN_AMINLOWBCD_MASK |
                                              RTC_A2MIN_AMINHIGHBCD_MASK)) >>
                     RTC_A2MIN_AMINLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2HoursBCD(RTC_Regs *rtc_common)
{
    rtc_common->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2HoursBCD(RTC_Regs *rtc_common)
{
    rtc_common->A2HOUR &= ~(RTC_A2HOUR_AHOURAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2HoursBCD(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->A2HOUR =
        ((uint32_t) hours << RTC_A2HOUR_AHOURLOWBCD_OFS) &
        (RTC_A2HOUR_AHOURLOWBCD_MASK | RTC_A2HOUR_AHOURHIGHBCD_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2HoursBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->A2HOUR &
            (RTC_A2HOUR_AHOURLOWBCD_MASK | RTC_A2HOUR_AHOURHIGHBCD_MASK)) >>
        RTC_A2HOUR_AHOURLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfWeekBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfWeekBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY &= ~(RTC_A2DAY_ADOWAE_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfWeekBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A2DAY, day, RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfWeekBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->DAY & RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfMonthBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY |= RTC_A2DAY_ADOMAEBCD_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfMonthBCD(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY &= ~(RTC_A2DAY_ADOMAEBCD_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfMonthBCD(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A2DAY,
        (uint32_t) day << RTC_A2DAY_ADOMLOWBCD_OFS,
        (RTC_A2DAY_ADOMLOWBCD_MASK | RTC_A2DAY_ADOMHIGHBCD_MASK));
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->A2DAY & (RTC_A2DAY_ADOMLOWBCD_MASK |
                                              RTC_A2DAY_ADOMHIGHBCD_MASK)) >>
                     RTC_A2DAY_ADOMLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarSecondsBinary(
    RTC_Regs *rtc_common, uint8_t seconds)
{
    rtc_common->SEC = (seconds & RTC_SEC_SECBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarSecondsBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->SEC & RTC_SEC_SECBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarMinutesBinary(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->MIN = (minutes & RTC_MIN_MINBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMinutesBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->MIN & RTC_MIN_MINBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarHoursBinary(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->HOUR = (hours & RTC_HOUR_HOURBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarHoursBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->HOUR & RTC_HOUR_HOURBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfWeekBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->DAY, day, RTC_DAY_DOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfWeekBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->DAY & RTC_DAY_DOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfMonthBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->DAY, (uint32_t) day << RTC_DAY_DOMBIN_OFS,
        RTC_DAY_DOMBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->DAY & RTC_DAY_DOMBIN_MASK) >> RTC_DAY_DOMBIN_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarMonthBinary(
    RTC_Regs *rtc_common, uint8_t month)
{
    rtc_common->MON = (month & RTC_MON_MONBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->MON & RTC_MON_MONBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setCalendarYearBinary(
    RTC_Regs *rtc_common, uint16_t year)
{
    rtc_common->YEAR = ((uint32_t) year & (RTC_YEAR_YEARLOWBIN_MASK |
                                              RTC_YEAR_YEARHIGHBIN_MASK));
}

__STATIC_INLINE uint16_t DL_RTC_Common_getCalendarYearBinary(
    const RTC_Regs *rtc_common)
{
    return (uint16_t)(rtc_common->YEAR &
                      (RTC_YEAR_YEARLOWBIN_MASK | RTC_YEAR_YEARHIGHBIN_MASK));
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1MinutesBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1MIN |= RTC_A1MIN_AMINAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1MinutesBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1MIN &= ~(RTC_A1MIN_AMINAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1MinutesBinary(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->A1MIN = (minutes & RTC_A1MIN_AMINBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1MinutesBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A1MIN & RTC_A1MIN_AMINBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1HoursBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1HoursBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1HOUR &= ~(RTC_A1HOUR_AHOURAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1HoursBinary(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->A1HOUR = (hours & RTC_A1HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1HoursBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A1HOUR & RTC_A1HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfWeekBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfWeekBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY &= ~(RTC_A1DAY_ADOWAE_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfWeekBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A1DAY, day, RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfWeekBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A1DAY & RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfMonthBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY |= RTC_A1DAY_ADOMAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfMonthBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A1DAY &= ~(RTC_A1DAY_ADOMAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfMonthBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A1DAY,
        (uint32_t) day << RTC_A1DAY_ADOMBIN_OFS, RTC_A1DAY_ADOMBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->A1DAY & RTC_A1DAY_ADOMBIN_MASK) >> RTC_A1DAY_ADOMBIN_OFS);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2MinutesBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2MIN |= RTC_A2MIN_AMINAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2MinutesBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2MIN &= ~(RTC_A2MIN_AMINAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2MinutesBinary(
    RTC_Regs *rtc_common, uint8_t minutes)
{
    rtc_common->A2MIN = (minutes & RTC_A2MIN_AMINBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2MinutesBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A2MIN & RTC_A2MIN_AMINBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2HoursBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2HoursBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2HOUR &= ~(RTC_A2HOUR_AHOURAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2HoursBinary(
    RTC_Regs *rtc_common, uint8_t hours)
{
    rtc_common->A2HOUR = (hours & RTC_A2HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2HoursBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A2HOUR & RTC_A2HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfWeekBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfWeekBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY &= ~(RTC_A2DAY_ADOWAE_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfWeekBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A2DAY, day, RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfWeekBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->A2DAY & RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfMonthBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY |= RTC_A2DAY_ADOMAEBIN_ENABLE;
}

__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfMonthBinary(
    RTC_Regs *rtc_common)
{
    rtc_common->A2DAY &= ~(RTC_A2DAY_ADOMAEBIN_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfMonthBinary(
    RTC_Regs *rtc_common, uint8_t day)
{
    DL_Common_updateReg(&rtc_common->A2DAY,
        (uint32_t) day << RTC_A2DAY_ADOMBIN_OFS, RTC_A2DAY_ADOMBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->A2DAY & RTC_A2DAY_ADOMBIN_MASK) >> RTC_A2DAY_ADOMBIN_OFS);
}

__STATIC_INLINE void DL_RTC_Common_setPrescalerEvents(RTC_Regs *rtc_common,
    DL_RTC_COMMON_PRESCALER0_DIVIDE prescaler0Divider,
    DL_RTC_COMMON_PRESCALER1_DIVIDE prescaler1Divider,
    DL_RTC_COMMON_PRESCALER2_DIVIDE prescaler2Divider)
{
    rtc_common->PSCTL =
        (((uint32_t) prescaler0Divider & RTC_PSCTL_RT0IP_MASK) |
            ((uint32_t) prescaler1Divider & RTC_PSCTL_RT1IP_MASK));
    rtc_common->EXTPSCTL =
        ((uint32_t) prescaler2Divider & RTC_EXTPSCTL_RT2PS_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm0(
    RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER0_DIVIDE prescaler0Divider)
{
    DL_Common_updateReg(&rtc_common->PSCTL, (uint32_t) prescaler0Divider,
        RTC_PSCTL_RT0IP_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm1(
    RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER1_DIVIDE prescaler1Divider)
{
    DL_Common_updateReg(&rtc_common->PSCTL, (uint32_t) prescaler1Divider,
        RTC_PSCTL_RT1IP_MASK);
}

__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm2(
    RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER2_DIVIDE prescaler2Divider)
{
    DL_Common_updateReg(&rtc_common->EXTPSCTL, (uint32_t) prescaler2Divider,
        RTC_EXTPSCTL_RT2PS_MASK);
}

__STATIC_INLINE DL_RTC_COMMON_PRESCALER0_DIVIDE DL_RTC_Common_getPrescaler0(
    const RTC_Regs *rtc_common)
{
    uint32_t prescaler = (rtc_common->PSCTL & RTC_PSCTL_RT0IP_MASK);

    return (DL_RTC_COMMON_PRESCALER0_DIVIDE)(prescaler);
}

__STATIC_INLINE DL_RTC_COMMON_PRESCALER1_DIVIDE DL_RTC_Common_getPrescaler1(
    const RTC_Regs *rtc_common)
{
    uint32_t prescaler = (rtc_common->PSCTL & RTC_PSCTL_RT1IP_MASK);

    return (DL_RTC_COMMON_PRESCALER1_DIVIDE)(prescaler);
}

__STATIC_INLINE DL_RTC_COMMON_PRESCALER2_DIVIDE DL_RTC_Common_getPrescaler2(
    const RTC_Regs *rtc_common)
{
    uint32_t prescaler = (rtc_common->EXTPSCTL & RTC_EXTPSCTL_RT2PS_MASK);

    return (DL_RTC_COMMON_PRESCALER2_DIVIDE)(prescaler);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampSecondsBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->TSSEC & (RTC_TSSEC_SECLOWBCD_MASK |
                                              RTC_TSSEC_SECHIGHBCD_MASK)) >>
                     RTC_TSSEC_SECLOWBCD_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMinutesBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->TSMIN & (RTC_TSMIN_MINLOWBCD_MASK |
                                              RTC_TSMIN_MINHIGHBCD_MASK)) >>
                     RTC_TSMIN_MINLOWBCD_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampHoursBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->TSHOUR & (RTC_TSHOUR_HOURLOWBCD_MASK |
                                               RTC_TSHOUR_HOURHIGHBCD_MASK)) >>
                     RTC_TSHOUR_HOURLOWBCD_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfWeekBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSDAY & RTC_TSDAY_DOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->TSDAY & (RTC_TSDAY_DOMLOWBCD_MASK |
                                              RTC_TSDAY_DOMHIGHBCD_MASK)) >>
                     RTC_TSDAY_DOMLOWBCD_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMonthBCD(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)((rtc_common->TSMON & (RTC_TSMON_MONLOWBCD_MASK |
                                              RTC_TSMON_MONHIGHBCD_MASK)) >>
                     RTC_TSMON_MONLOWBCD_OFS);
}

__STATIC_INLINE uint16_t DL_RTC_Common_getTimeStampYearBCD(
    const RTC_Regs *rtc_common)
{
    return (uint16_t)(
        (rtc_common->TSYEAR &
            (RTC_TSYEAR_YERARLOWESTBCD_MASK | RTC_TSYEAR_DECADEBCD_MASK |
                RTC_TSYEAR_CENTLOWBCD_MASK | RTC_TSYEAR_CENTHIGHBCD_MASK)) >>
        RTC_TSYEAR_YERARLOWESTBCD_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampSecondsBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSSEC & RTC_TSSEC_SECBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMinutesBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSMIN & RTC_TSMIN_MINBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampHoursBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSHOUR & RTC_TSHOUR_HOURBIN_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfWeekBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSDAY & RTC_TSDAY_DOW_MASK);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(
        (rtc_common->TSDAY & RTC_TSDAY_DOMBIN_MASK) >> RTC_TSDAY_DOMBIN_OFS);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMonthBinary(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->TSMON & RTC_TSMON_MONBIN_MASK);
}

__STATIC_INLINE uint16_t DL_RTC_Common_getTimeStampYearBinary(
    const RTC_Regs *rtc_common)
{
    return (uint16_t)(rtc_common->TSYEAR & (RTC_TSYEAR_YEARLOWBIN_MASK |
                                               RTC_TSYEAR_YEARHIGHBIN_MASK));
}

__STATIC_INLINE void DL_RTC_Common_enableInterrupt(
    RTC_Regs *rtc_common, uint32_t interruptMask)
{
    rtc_common->CPU_INT.IMASK |= interruptMask;
}

__STATIC_INLINE void DL_RTC_Common_disableInterrupt(
    RTC_Regs *rtc_common, uint32_t interruptMask)
{
    rtc_common->CPU_INT.IMASK &= ~(interruptMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledInterrupts(
    const RTC_Regs *rtc_common, uint32_t interruptMask)
{
    return (rtc_common->CPU_INT.IMASK & interruptMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledInterruptStatus(
    const RTC_Regs *rtc_common, uint32_t interruptMask)
{
    return (rtc_common->CPU_INT.MIS & interruptMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getRawInterruptStatus(
    const RTC_Regs *rtc_common, uint32_t interruptMask)
{
    return (rtc_common->CPU_INT.RIS & interruptMask);
}

__STATIC_INLINE DL_RTC_COMMON_IIDX DL_RTC_Common_getPendingInterrupt(
    const RTC_Regs *rtc_common)
{
    return (DL_RTC_COMMON_IIDX)(rtc_common->CPU_INT.IIDX);
}

__STATIC_INLINE void DL_RTC_Common_clearInterruptStatus(
    RTC_Regs *rtc_common, uint32_t interruptMask)
{
    rtc_common->CPU_INT.ICLR = interruptMask;
}

__STATIC_INLINE void DL_RTC_Common_enableEvent(
    RTC_Regs *rtc_common, uint32_t eventMask)
{
    rtc_common->GEN_EVENT.IMASK |= (eventMask);
}

__STATIC_INLINE void DL_RTC_Common_disableEvent(
    RTC_Regs *rtc_common, uint32_t eventMask)
{
    rtc_common->GEN_EVENT.IMASK &= ~(eventMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledEvents(
    const RTC_Regs *rtc_common, uint32_t eventMask)
{
    return ((rtc_common->GEN_EVENT.IMASK) & (eventMask));
}

__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledEventStatus(
    const RTC_Regs *rtc_common, uint32_t eventMask)
{
    return ((rtc_common->GEN_EVENT.MIS) & eventMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getRawEventsStatus(
    const RTC_Regs *rtc_common, uint32_t eventMask)
{
    return ((rtc_common->GEN_EVENT.RIS) & eventMask);
}

__STATIC_INLINE void DL_RTC_Common_clearEventsStatus(
    RTC_Regs *rtc_common, uint32_t eventMask)
{
    rtc_common->GEN_EVENT.ICLR |= (eventMask);
}

__STATIC_INLINE void DL_RTC_Common_setPublisherChanID(
    RTC_Regs *rtc_common, uint8_t chanID)
{
    rtc_common->FPUB_0 = (chanID & RTC_FPUB_0_CHANID_MAXIMUM);
}

__STATIC_INLINE uint8_t DL_RTC_Common_getPublisherChanID(
    const RTC_Regs *rtc_common)
{
    return (uint8_t)(rtc_common->FPUB_0 & RTC_FPUB_0_CHANID_MAXIMUM);
}

#ifdef __MSPM0_HAS_RTC_A__

__STATIC_INLINE uint32_t DL_RTC_Common_getTimeStampEventCause(
    const RTC_Regs *rtc_common, uint32_t tsEventMask)
{
    return (rtc_common->TSSTAT & tsEventMask);
}
#endif

void DL_RTC_Common_initCalendar(RTC_Regs *rtc_common,
    DL_RTC_Common_Calendar calendarTime, DL_RTC_COMMON_FORMAT formatSelect);

DL_RTC_Common_Calendar DL_RTC_Common_getCalendarTime(
    const RTC_Regs *rtc_common);

void DL_RTC_Common_setCalendarAlarm1(
    RTC_Regs *rtc_common, DL_RTC_Common_CalendarAlarm alarmTime);

DL_RTC_Common_CalendarAlarm DL_RTC_Common_getCalendarAlarm1(
    const RTC_Regs *rtc_common);

void DL_RTC_Common_enableCalendarAlarm1(RTC_Regs *rtc_common);

void DL_RTC_Common_disableCalendarAlarm1(RTC_Regs *rtc_common);

void DL_RTC_Common_setCalendarAlarm2(
    RTC_Regs *rtc_common, DL_RTC_Common_CalendarAlarm alarmTime);

DL_RTC_Common_CalendarAlarm DL_RTC_Common_getCalendarAlarm2(
    const RTC_Regs *rtc_common);

void DL_RTC_Common_enableCalendarAlarm2(RTC_Regs *rtc_common);

void DL_RTC_Common_disableCalendarAlarm2(RTC_Regs *rtc_common);

#ifdef __MSPM0_HAS_RTC_A__

__STATIC_INLINE void DL_RTC_Common_setTimeStampEventSource(
    RTC_Regs *rtc_common, uint32_t sourceMask)
{
    rtc_common->TSCTL |= (RTC_TSCTL_KEY_UNLOCK_W | sourceMask);
}

__STATIC_INLINE uint32_t DL_RTC_Common_getTimeStampEventSource(
    const RTC_Regs *rtc_common, uint32_t sourceMask)
{
    return (rtc_common->TSCTL & sourceMask);
}

__STATIC_INLINE void DL_RTC_Common_setTimeStampEventCapture(
    RTC_Regs *rtc_common, DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE capture)
{
    DL_Common_updateReg(&rtc_common->TSCTL,
        (RTC_TSCTL_KEY_UNLOCK_W | (uint32_t) capture),
        (RTC_TSCTL_TSCAPTURE_MASK | RTC_TSCTL_KEY_MASK));
}

__STATIC_INLINE DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE
DL_RTC_Common_getTimeStampEventCapture(const RTC_Regs *rtc_common)
{
    uint32_t capture = (rtc_common->TSCTL & RTC_TSCTL_TSCAPTURE_MASK);

    return (DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE)(capture);
}

__STATIC_INLINE void DL_RTC_Common_clearTimeStamp(RTC_Regs *rtc_common)
{
    rtc_common->TSCLR = (RTC_TSCLR_KEY_UNLOCK_W | RTC_TSCLR_CLR_CLR);
}

__STATIC_INLINE void DL_RTC_Common_enableWriteProtect(RTC_Regs *rtc_common)
{
    rtc_common->RTCLOCK = (RTC_RTCLOCK_PROTECT_SET | RTC_RTCLOCK_KEY_UNLOCK_W);
}

__STATIC_INLINE bool DL_RTC_Common_isWriteProtectEnabled(
    const RTC_Regs *rtc_common)
{
    return ((rtc_common->RTCLOCK & RTC_RTCLOCK_PROTECT_MASK) ==
            RTC_RTCLOCK_PROTECT_SET);
}

__STATIC_INLINE void DL_RTC_Common_disableWriteProtect(RTC_Regs *rtc_common)
{
    rtc_common->RTCLOCK = (RTC_RTCLOCK_PROTECT_CLR | RTC_RTCLOCK_KEY_UNLOCK_W);
}
#endif

#ifdef __cplusplus
}
#endif

#endif /* __MSPM0_HAS_RTC_A__ || __MSPM0_HAS_RTC_B__ || __MSPM0_HAS_RTC__ */

#endif /* ti_dl_dl_rtc_common__include */