dl_rtc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, 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 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.
 */
/*!****************************************************************************
 *  @file       dl_rtc.h
 *  @brief      Real Time Clock (RTC) Peripheral Interface
 *  @defgroup   RTC Real Time Clock (RTC)
 *
 *  @anchor ti_devices_msp_dl_rtc_Overview
 *  # Overview
 *  The RTC Driver Library allows full configuration of the MSPM0 RTC module.
 *  The real-time clock (RTC) module provides clock counters with calendar mode,
 *  a flexible programmable alarm, offset calibration, and a provision for
 *  temperature compensation.
 *
 *  <hr>
 ******************************************************************************
 */
#ifndef ti_dl_dl_rtc__include
#define ti_dl_dl_rtc__include

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

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

#ifdef __MSPM0_HAS_RTC__

#ifdef __cplusplus
extern "C" {
#endif

/* clang-format off */

#define DL_RTC_INTERRUPT_CALENDAR_ALARM1        (RTC_CPU_INT_IMASK_RTCA1_SET)

#define DL_RTC_INTERRUPT_CALENDAR_ALARM2        (RTC_CPU_INT_IMASK_RTCA2_SET)

#define DL_RTC_INTERRUPT_PRESCALER0             (RTC_CPU_INT_IMASK_RT0PS_SET)

#define DL_RTC_INTERRUPT_PRESCALER1             (RTC_CPU_INT_IMASK_RT1PS_SET)

#define DL_RTC_INTERRUPT_INTERVAL_ALARM        (RTC_CPU_INT_IMASK_RTCTEV_SET)

#define DL_RTC_INTERRUPT_READY                 (RTC_CPU_INT_IMASK_RTCRDY_SET)

#define DL_RTC_EVENT_CALENDAR_ALARM1            (RTC_GEN_EVENT_IMASK_RTCA1_SET)

#define DL_RTC_EVENT_CALENDAR_ALARM2            (RTC_GEN_EVENT_IMASK_RTCA2_SET)

#define DL_RTC_EVENT_PRESCALER0                 (RTC_GEN_EVENT_IMASK_RT0PS_SET)

#define DL_RTC_EVENT_PRESCALER1                 (RTC_GEN_EVENT_IMASK_RT1PS_SET)

#define DL_RTC_EVENT_INTERVAL_ALARM            (RTC_GEN_EVENT_IMASK_RTCTEV_SET)

#define DL_RTC_EVENT_READY                     (RTC_GEN_EVENT_IMASK_RTCRDY_SET)


typedef enum {
    DL_RTC_STATUS_READY = RTC_STA_RTCRDY_READY,
    DL_RTC_STATUS_NOT_READY = RTC_STA_RTCRDY_NOT_READY
} DL_RTC_STATUS;

typedef enum {
    DL_RTC_COMPENSATION_STATUS_READY = RTC_STA_RTCTCRDY_READY,
    DL_RTC_COMPENSATION_STATUS_NOT_READY = RTC_STA_RTCTCRDY_NOT_READY
} DL_RTC_COMPENSATION_STATUS;

typedef enum {
    DL_RTC_COMPENSATION_WRITE_RESULT_OK = RTC_STA_RTCTCOK_OK,
    DL_RTC_COMPENSATION_WRITE_RESULT_NOT_OK = RTC_STA_RTCTCOK_NOT_OK
} DL_RTC_COMPENSATION_WRITE_RESULT;

typedef enum {
    DL_RTC_OFFSET_CALIBRATION_SIGN_DOWN = RTC_CAL_RTCOCALS_DOWN,
    DL_RTC_OFFSET_CALIBRATION_SIGN_UP = RTC_CAL_RTCOCALS_UP
} DL_RTC_OFFSET_CALIBRATION_SIGN;

typedef enum {
    DL_RTC_OFFSET_CALIBRATION_FREQUENCY_OFF = RTC_CAL_RTCCALFX_OFF,
    DL_RTC_OFFSET_CALIBRATION_FREQUENCY_512 = RTC_CAL_RTCCALFX_F512HZ,
    DL_RTC_OFFSET_CALIBRATION_FREQUENCY_256 = RTC_CAL_RTCCALFX_F256HZ,
    DL_RTC_OFFSET_CALIBRATION_FREQUENCY_1 = RTC_CAL_RTCCALFX_F1HZ
} DL_RTC_OFFSET_CALIBRATION_FREQUENCY;

typedef enum {
    DL_RTC_TEMP_CALIBRATION_DOWN1PPM = RTC_TCMP_RTCTCMPS_DOWN,
    DL_RTC_TEMP_CALIBRATION_UP1PPM = RTC_TCMP_RTCTCMPS_UP
} DL_RTC_TEMP_CALIBRATION;

typedef enum {
    DL_RTC_FORMAT_BINARY = RTC_CTL_RTCBCD_BINARY,
    DL_RTC_FORMAT_BCD = RTC_CTL_RTCBCD_BCD
} DL_RTC_FORMAT;

typedef enum {
    DL_RTC_INTERVAL_ALARM_MINUTECHANGE = RTC_CTL_RTCTEVTX_MINUTE,
    DL_RTC_INTERVAL_ALARM_HOURCHANGE = RTC_CTL_RTCTEVTX_HOUR,
    DL_RTC_INTERVAL_ALARM_NOON = RTC_CTL_RTCTEVTX_NOON,
    DL_RTC_INTERVAL_ALARM_MIDNIGHT = RTC_CTL_RTCTEVTX_MIDNIGHT
} DL_RTC_INTERVAL_ALARM;

typedef enum {
    DL_RTC_PRESCALER0_DIVIDE_8 = RTC_PSCTL_RT0IP_DIV8,
    DL_RTC_PRESCALER0_DIVIDE_16 = RTC_PSCTL_RT0IP_DIV16,
    DL_RTC_PRESCALER0_DIVIDE_32 = RTC_PSCTL_RT0IP_DIV32,
    DL_RTC_PRESCALER0_DIVIDE_64 = RTC_PSCTL_RT0IP_DIV64,
    DL_RTC_PRESCALER0_DIVIDE_128 = RTC_PSCTL_RT0IP_DIV128,
    DL_RTC_PRESCALER0_DIVIDE_256 = RTC_PSCTL_RT0IP_DIV256
} DL_RTC_PRESCALER0_DIVIDE;

typedef enum {
    DL_RTC_PRESCALER1_DIVIDE_2 = RTC_PSCTL_RT1IP_DIV2,
    DL_RTC_PRESCALER1_DIVIDE_4 = RTC_PSCTL_RT1IP_DIV4,
    DL_RTC_PRESCALER1_DIVIDE_8 = RTC_PSCTL_RT1IP_DIV8,
    DL_RTC_PRESCALER1_DIVIDE_16 = RTC_PSCTL_RT1IP_DIV16,
    DL_RTC_PRESCALER1_DIVIDE_32 = RTC_PSCTL_RT1IP_DIV32,
    DL_RTC_PRESCALER1_DIVIDE_64 = RTC_PSCTL_RT1IP_DIV64,
    DL_RTC_PRESCALER1_DIVIDE_128 = RTC_PSCTL_RT1IP_DIV128,
    DL_RTC_PRESCALER1_DIVIDE_256 = RTC_PSCTL_RT1IP_DIV256
} DL_RTC_PRESCALER1_DIVIDE;

typedef enum {
    DL_RTC_IIDX_ALARM1 = RTC_CPU_INT_IIDX_STAT_RTCA1,
    DL_RTC_IIDX_ALARM2 = RTC_CPU_INT_IIDX_STAT_RTCA2,
    DL_RTC_IIDX_PRESCALER0 = RTC_CPU_INT_IIDX_STAT_RT0PS,
    DL_RTC_IIDX_PRESCALER1 = RTC_CPU_INT_IIDX_STAT_RT1PS,
    DL_RTC_IIDX_INTERVAL_TIMER = RTC_CPU_INT_IIDX_STAT_RTCTEV,
    DL_RTC_IIDX_READY = RTC_CPU_INT_IIDX_STAT_RTCRDY
} DL_RTC_IIDX;

/* clang-format on */

typedef struct {
    uint8_t minutes;
    uint8_t hours;
    uint8_t dayOfWeek;
    uint8_t dayOfMonth;
} DL_RTC_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_Calendar;

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

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

__STATIC_INLINE bool DL_RTC_isPowerEnabled(RTC_Regs *rtc)
{
    return (
        (rtc->GPRCM.PWREN & RTC_PWREN_ENABLE_MASK) == RTC_PWREN_ENABLE_ENABLE);
}

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

__STATIC_INLINE bool DL_RTC_isReset(RTC_Regs *rtc)
{
    return ((rtc->GPRCM.STAT & RTC_STAT_RESETSTKY_MASK) ==
            RTC_STAT_RESETSTKY_RESET);
}

__STATIC_INLINE void DL_RTC_enableClockControl(RTC_Regs *rtc)
{
    rtc->CLKCTL = RTC_CLKCTL_MODCLKEN_ENABLE;
}

__STATIC_INLINE void DL_RTC_disableClockControl(RTC_Regs *rtc)
{
    rtc->CLKCTL = RTC_CLKCTL_MODCLKEN_DISABLE;
}

__STATIC_INLINE void DL_RTC_enableDebugInterrupts(RTC_Regs *rtc)
{
    rtc->DBGCTL |= RTC_DBGCTL_DBGINT_ON;
}

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

__STATIC_INLINE void DL_RTC_enableDebugMode(RTC_Regs *rtc)
{
    rtc->DBGCTL |= RTC_DBGCTL_DBGRUN_RUN;
}

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

__STATIC_INLINE void DL_RTC_setClockFormat(
    RTC_Regs *rtc, DL_RTC_FORMAT formatSelect)
{
    rtc->CTL |= (uint32_t) formatSelect;
}

__STATIC_INLINE DL_RTC_FORMAT DL_RTC_getClockFormat(RTC_Regs *rtc)
{
    uint32_t format = (rtc->CTL & RTC_CTL_RTCBCD_MASK);

    return (DL_RTC_FORMAT)(format);
}

__STATIC_INLINE void DL_RTC_setIntervalAlarm(
    RTC_Regs *rtc, DL_RTC_INTERVAL_ALARM alarmEvent)
{
    DL_Common_updateReg(
        &rtc->CTL, (uint32_t) alarmEvent, RTC_CTL_RTCTEVTX_MASK);
}

__STATIC_INLINE DL_RTC_INTERVAL_ALARM DL_RTC_getIntervalAlarm(RTC_Regs *rtc)
{
    uint32_t alarm = (rtc->CTL & RTC_CTL_RTCTEVTX_MASK);

    return (DL_RTC_INTERVAL_ALARM)(alarm);
}

__STATIC_INLINE bool DL_RTC_isSafetoRead(RTC_Regs *rtc)
{
    return ((rtc->STA & RTC_STA_RTCRDY_MASK) == RTC_STA_RTCRDY_READY);
}

__STATIC_INLINE bool DL_RTC_isReadyToCalibrate(RTC_Regs *rtc)
{
    return ((rtc->STA & RTC_STA_RTCTCRDY_MASK) == RTC_STA_RTCTCRDY_READY);
}

__STATIC_INLINE bool DL_RTC_isCalibrationWriteResultOK(RTC_Regs *rtc)
{
    return ((rtc->STA & RTC_STA_RTCTCOK_MASK) == RTC_STA_RTCTCOK_OK);
}

__STATIC_INLINE void DL_RTC_setOffsetCalibrationFrequency(
    RTC_Regs *rtc, DL_RTC_OFFSET_CALIBRATION_FREQUENCY offsetFrequency)
{
    DL_Common_updateReg(
        &rtc->CAL, (uint32_t) offsetFrequency, RTC_CAL_RTCCALFX_MASK);
}

__STATIC_INLINE void DL_RTC_setOffsetCalibrationAdjValue(RTC_Regs *rtc,
    DL_RTC_OFFSET_CALIBRATION_SIGN offsetSign, uint8_t offsetValue)
{
    DL_Common_updateReg(&rtc->CAL,
        ((uint32_t) offsetSign | (uint32_t) offsetValue),
        (RTC_CAL_RTCOCALX_MASK | RTC_CAL_RTCOCALS_MASK));
}

__STATIC_INLINE void DL_RTC_setOffsetCalibration(RTC_Regs *rtc,
    DL_RTC_OFFSET_CALIBRATION_FREQUENCY offsetFrequency,
    DL_RTC_OFFSET_CALIBRATION_SIGN offsetSign, uint8_t offsetValue)
{
    rtc->CAL = (offsetValue & RTC_CAL_RTCOCALX_MASK) |
               (uint32_t) offsetFrequency | (uint32_t) offsetSign;
}

__STATIC_INLINE DL_RTC_OFFSET_CALIBRATION_FREQUENCY
DL_RTC_getOffsetCalibrationFrequency(RTC_Regs *rtc)
{
    uint32_t freq = (rtc->CAL & RTC_CAL_RTCCALFX_MASK);

    return (DL_RTC_OFFSET_CALIBRATION_FREQUENCY)(freq);
}

__STATIC_INLINE DL_RTC_OFFSET_CALIBRATION_SIGN DL_RTC_getOffsetCalibrationSign(
    RTC_Regs *rtc)
{
    uint32_t sign = (rtc->CAL & RTC_CAL_RTCOCALS_MASK);

    return (DL_RTC_OFFSET_CALIBRATION_SIGN)(sign);
}

__STATIC_INLINE uint32_t DL_RTC_getOffsetCalibrationValue(RTC_Regs *rtc)
{
    return (rtc->CAL & RTC_CAL_RTCOCALX_MASK);
}

__STATIC_INLINE void DL_RTC_setTemperatureCompensation(RTC_Regs *rtc,
    DL_RTC_TEMP_CALIBRATION offsetDirection, uint32_t offsetValue)
{
    rtc->TCMP =
        (offsetValue & RTC_TCMP_RTCTCMPX_MASK) | (uint32_t) offsetDirection;
}

__STATIC_INLINE uint32_t DL_RTC_getTemperatureCompensation(RTC_Regs *rtc)
{
    return (rtc->TCMP);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarSecondsBCD(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->SEC & (RTC_SEC_SECLOWBCD_MASK | RTC_SEC_SECHIGHBCD_MASK)) >>
        RTC_SEC_SECLOWBCD_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarMinutesBCD(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->MIN & (RTC_MIN_MINLOWBCD_MASK | RTC_MIN_MINHIGHBCD_MASK)) >>
        RTC_MIN_MINLOWBCD_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarHoursBCD(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->HOUR & (RTC_HOUR_HOURLOWBCD_MASK | RTC_HOUR_HOURHIGHBCD_MASK)) >>
        RTC_HOUR_HOURLOWBCD_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarDayOfWeekBCD(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->DAY & RTC_DAY_DOW_MASK);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarDayOfMonthBCD(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->DAY & (RTC_DAY_DOMLOWBCD_MASK | RTC_DAY_DOMHIGHBCD_MASK)) >>
        RTC_DAY_DOMLOWBCD_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarMonthBCD(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->MON & (RTC_MON_MONLOWBCD_MASK | RTC_MON_MONHIGHBCD_MASK)) >>
        RTC_MON_MONLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_setCalendarYearBCD(RTC_Regs *rtc, uint16_t year)
{
    rtc->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_getCalendarYearBCD(RTC_Regs *rtc)
{
    return (uint16_t)(
        (rtc->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_enableAlarm1MinutesBCD(RTC_Regs *rtc)
{
    rtc->A1MIN |= RTC_A1MIN_AMINAEBCD_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1MinutesBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A1MIN & (RTC_A1MIN_AMINLOWBCD_MASK |
                                       RTC_A1MIN_AMINHIGHBCD_MASK)) >>
                     RTC_A1MIN_AMINLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm1HoursBCD(RTC_Regs *rtc)
{
    rtc->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1HoursBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A1HOUR & (RTC_A1HOUR_AHOURLOWBCD_MASK |
                                        RTC_A1HOUR_AHOURHIGHBCD_MASK)) >>
                     RTC_A1HOUR_AHOURLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm1DayOfWeekBCD(RTC_Regs *rtc)
{
    rtc->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1DayOfWeekBCD(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->DAY & RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm1DayOfMonthBCD(RTC_Regs *rtc)
{
    rtc->A1DAY |= RTC_A1DAY_ADOMAEBCD_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1DayOfMonthBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A1DAY & (RTC_A1DAY_ADOMLOWBCD_MASK |
                                       RTC_A1DAY_ADOMHIGHBCD_MASK)) >>
                     RTC_A1DAY_ADOMLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm2MinutesBCD(RTC_Regs *rtc)
{
    rtc->A2MIN |= RTC_A2MIN_AMINAEBCD_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2MinutesBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A2MIN & (RTC_A2MIN_AMINLOWBCD_MASK |
                                       RTC_A2MIN_AMINHIGHBCD_MASK)) >>
                     RTC_A2MIN_AMINLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm2HoursBCD(RTC_Regs *rtc)
{
    rtc->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2HoursBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A2HOUR & (RTC_A2HOUR_AHOURLOWBCD_MASK |
                                        RTC_A2HOUR_AHOURHIGHBCD_MASK)) >>
                     RTC_A2HOUR_AHOURLOWBCD_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm2DayOfWeekBCD(RTC_Regs *rtc)
{
    rtc->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2DayOfWeekBCD(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->DAY & RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm2DayOfMonthBCD(RTC_Regs *rtc)
{
    rtc->A2DAY |= RTC_A2DAY_ADOMAEBCD_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2DayOfMonthBCD(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->A2DAY & (RTC_A2DAY_ADOMLOWBCD_MASK |
                                       RTC_A2DAY_ADOMHIGHBCD_MASK)) >>
                     RTC_A2DAY_ADOMLOWBCD_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarSecondsBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->SEC & RTC_SEC_SECBIN_MASK);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarMinutesBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->MIN & RTC_MIN_MINBIN_MASK);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarHoursBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->HOUR & RTC_HOUR_HOURBIN_MASK);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarDayOfWeekBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->DAY & RTC_DAY_DOW_MASK);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarDayOfMonthBinary(RTC_Regs *rtc)
{
    return (uint8_t)((rtc->DAY & RTC_DAY_DOMBIN_MASK) >> RTC_DAY_DOMBIN_OFS);
}

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

__STATIC_INLINE uint8_t DL_RTC_getCalendarMonthBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->MON & RTC_MON_MONBIN_MASK);
}

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

__STATIC_INLINE uint16_t DL_RTC_getCalendarYearBinary(RTC_Regs *rtc)
{
    return (uint16_t)(
        rtc->YEAR & (RTC_YEAR_YEARLOWBIN_MASK | RTC_YEAR_YEARHIGHBIN_MASK));
}

__STATIC_INLINE void DL_RTC_enableAlarm1MinutesBinary(RTC_Regs *rtc)
{
    rtc->A1MIN |= RTC_A1MIN_AMINAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1MinutesBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A1MIN & RTC_A1MIN_AMINBIN_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm1HoursBinary(RTC_Regs *rtc)
{
    rtc->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1HoursBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A1HOUR & RTC_A1HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm1DayOfWeekBinary(RTC_Regs *rtc)
{
    rtc->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1DayOfWeekBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A1DAY & RTC_A1DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm1DayOfMonthBinary(RTC_Regs *rtc)
{
    rtc->A1DAY |= RTC_A1DAY_ADOMAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm1DayOfMonthBinary(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->A1DAY & RTC_A1DAY_ADOMBIN_MASK) >> RTC_A1DAY_ADOMBIN_OFS);
}

__STATIC_INLINE void DL_RTC_enableAlarm2MinutesBinary(RTC_Regs *rtc)
{
    rtc->A2MIN |= RTC_A2MIN_AMINAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2MinutesBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A2MIN & RTC_A2MIN_AMINBIN_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm2HoursBinary(RTC_Regs *rtc)
{
    rtc->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2HoursBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A2HOUR & RTC_A2HOUR_AHOURBIN_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm2DayOfWeekBinary(RTC_Regs *rtc)
{
    rtc->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2DayOfWeekBinary(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->A2DAY & RTC_A2DAY_ADOW_MASK);
}

__STATIC_INLINE void DL_RTC_enableAlarm2DayOfMonthBinary(RTC_Regs *rtc)
{
    rtc->A2DAY |= RTC_A2DAY_ADOMAEBIN_ENABLE;
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getAlarm2DayOfMonthBinary(RTC_Regs *rtc)
{
    return (uint8_t)(
        (rtc->A2DAY & RTC_A2DAY_ADOMBIN_MASK) >> RTC_A2DAY_ADOMBIN_OFS);
}

__STATIC_INLINE void DL_RTC_setPrescalerEvents(RTC_Regs *rtc,
    DL_RTC_PRESCALER0_DIVIDE prescaler0Divider,
    DL_RTC_PRESCALER1_DIVIDE prescaler1Divider)
{
    rtc->PSCTL = (((uint32_t) prescaler0Divider & RTC_PSCTL_RT0IP_MASK) |
                  ((uint32_t) prescaler1Divider & RTC_PSCTL_RT1IP_MASK));
}

__STATIC_INLINE void DL_RTC_setPeriodicAlarm0(
    RTC_Regs *rtc, DL_RTC_PRESCALER0_DIVIDE prescaler0Divider)
{
    DL_Common_updateReg(
        &rtc->PSCTL, (uint32_t) prescaler0Divider, RTC_PSCTL_RT0IP_MASK);
}

__STATIC_INLINE void DL_RTC_setPeriodicAlarm1(
    RTC_Regs *rtc, DL_RTC_PRESCALER1_DIVIDE prescaler1Divider)
{
    DL_Common_updateReg(
        &rtc->PSCTL, (uint32_t) prescaler1Divider, RTC_PSCTL_RT1IP_MASK);
}

__STATIC_INLINE DL_RTC_PRESCALER0_DIVIDE DL_RTC_getPrescaler0(RTC_Regs *rtc)
{
    uint32_t prescaler = (rtc->PSCTL & RTC_PSCTL_RT0IP_MASK);

    return (DL_RTC_PRESCALER0_DIVIDE)(prescaler);
}

__STATIC_INLINE DL_RTC_PRESCALER1_DIVIDE DL_RTC_getPrescaler1(RTC_Regs *rtc)
{
    uint32_t prescaler = (rtc->PSCTL & RTC_PSCTL_RT1IP_MASK);

    return (DL_RTC_PRESCALER1_DIVIDE)(prescaler);
}

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

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

__STATIC_INLINE uint32_t DL_RTC_getEnabledInterrupts(
    RTC_Regs *rtc, uint32_t interruptMask)
{
    return (rtc->CPU_INT.IMASK & interruptMask);
}

__STATIC_INLINE uint32_t DL_RTC_getEnabledInterruptStatus(
    RTC_Regs *rtc, uint32_t interruptMask)
{
    return (rtc->CPU_INT.MIS & interruptMask);
}

__STATIC_INLINE uint32_t DL_RTC_getRawInterruptStatus(
    RTC_Regs *rtc, uint32_t interruptMask)
{
    return (rtc->CPU_INT.RIS & interruptMask);
}

__STATIC_INLINE DL_RTC_IIDX DL_RTC_getPendingInterrupt(RTC_Regs *rtc)
{
    return (DL_RTC_IIDX)(rtc->CPU_INT.IIDX);
}

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

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

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

__STATIC_INLINE uint32_t DL_RTC_getEnabledEvents(
    RTC_Regs *rtc, uint32_t eventMask)
{
    return ((rtc->GEN_EVENT.IMASK) & (eventMask));
}

__STATIC_INLINE uint32_t DL_RTC_getEnabledEventStatus(
    RTC_Regs *rtc, uint32_t eventMask)
{
    return ((rtc->GEN_EVENT.MIS) & eventMask);
}

__STATIC_INLINE uint32_t DL_RTC_getRawEventsStatus(
    RTC_Regs *rtc, uint32_t eventMask)
{
    return ((rtc->GEN_EVENT.RIS) & eventMask);
}

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

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

__STATIC_INLINE uint8_t DL_RTC_getPublisherChanID(RTC_Regs *rtc)
{
    return (uint8_t)(rtc->FPUB_0 & RTC_FPUB_0_CHANID_MAXIMUM);
}

extern void DL_RTC_initCalendar(
    RTC_Regs *rtc, DL_RTC_Calendar calendarTime, DL_RTC_FORMAT formatSelect);

extern DL_RTC_Calendar DL_RTC_getCalendarTime(RTC_Regs *rtc);

extern void DL_RTC_setCalendarAlarm1(
    RTC_Regs *rtc, DL_RTC_CalendarAlarm alarmTime);

extern DL_RTC_CalendarAlarm DL_RTC_getCalendarAlarm1(RTC_Regs *rtc);

extern void DL_RTC_enableCalendarAlarm1(RTC_Regs *rtc);

extern void DL_RTC_disableCalendarAlarm1(RTC_Regs *rtc);

extern void DL_RTC_setCalendarAlarm2(
    RTC_Regs *rtc, DL_RTC_CalendarAlarm alarmTime);

extern DL_RTC_CalendarAlarm DL_RTC_getCalendarAlarm2(RTC_Regs *rtc);

extern void DL_RTC_enableCalendarAlarm2(RTC_Regs *rtc);

extern void DL_RTC_disableCalendarAlarm2(RTC_Regs *rtc);

#ifdef __cplusplus
}
#endif
#endif /* __MSPM0_HAS_RTC__ */

#endif /* ti_dl_dl_rtc__include */