rtc, keeping time

2 files changed, 721 insertions, 0 deletions

diff --git a/drivers_nrf/rtc/nrf_drv_rtc.c b/drivers_nrf/rtc/nrf_drv_rtc.c
new file mode 100644
index 0000000..bac31ac
--- /dev/null
+++ b/drivers_nrf/rtc/nrf_drv_rtc.c
@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, 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.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(RTC)
+#define ENABLED_RTC_COUNT (RTC0_ENABLED+RTC1_ENABLED+RTC2_ENABLED)
+#if ENABLED_RTC_COUNT
+
+#include "nrf_drv_rtc.h"
+#include "nrf_rtc.h"
+#include "nrf_assert.h"
+#include "app_util_platform.h"
+
+#define NRF_LOG_MODULE_NAME "RTC"
+
+#if RTC_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       RTC_CONFIG_LOG_LEVEL
+#define NRF_LOG_INFO_COLOR  RTC_CONFIG_INFO_COLOR
+#define NRF_LOG_DEBUG_COLOR RTC_CONFIG_DEBUG_COLOR
+#define EVT_TO_STR(event)   (event == NRF_RTC_EVENT_TICK ? "NRF_RTC_EVENT_TICK" :               \
+                            (event == NRF_RTC_EVENT_OVERFLOW ? "NRF_RTC_EVENT_OVERFLOW" :       \
+                            (event == NRF_RTC_EVENT_COMPARE_0 ? "NRF_RTC_EVENT_COMPARE_0" :     \
+                            (event == NRF_RTC_EVENT_COMPARE_1 ? "NRF_RTC_EVENT_COMPARE_1" :     \
+                            (event == NRF_RTC_EVENT_COMPARE_2 ? "NRF_RTC_EVENT_COMPARE_2" :     \
+                            (event == NRF_RTC_EVENT_COMPARE_3 ? "NRF_RTC_EVENT_COMPARE_3" : "UNKNOWN EVENT")
+#else //RTC_CONFIG_LOG_ENABLED
+#define EVT_TO_STR(event)   ""
+#define NRF_LOG_LEVEL       0
+#endif //RTC_CONFIG_LOG_ENABLED
+#include "nrf_log.h"
+#include "nrf_log_ctrl.h"
+
+/**@brief RTC driver instance control block structure. */
+typedef struct
+{
+    nrf_drv_state_t state;        /**< Instance state. */
+    bool            reliable;     /**< Reliable mode flag. */
+    uint8_t         tick_latency; /**< Maximum length of interrupt handler in ticks (max 7.7 ms). */
+} nrf_drv_rtc_cb_t;
+
+// User callbacks local storage.
+static nrf_drv_rtc_handler_t m_handlers[ENABLED_RTC_COUNT];
+static nrf_drv_rtc_cb_t      m_cb[ENABLED_RTC_COUNT];
+
+ret_code_t nrf_drv_rtc_init(nrf_drv_rtc_t const * const p_instance,
+                            nrf_drv_rtc_config_t const * p_config,
+                            nrf_drv_rtc_handler_t handler)
+{
+    ASSERT(p_config);
+
+    ret_code_t err_code;
+
+    if (handler)
+    {
+        m_handlers[p_instance->instance_id] = handler;
+    }
+    else
+    {
+        err_code = NRF_ERROR_INVALID_PARAM;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+    if (m_cb[p_instance->instance_id].state != NRF_DRV_STATE_UNINITIALIZED)
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+    nrf_drv_common_irq_enable(p_instance->irq, p_config->interrupt_priority);
+    nrf_rtc_prescaler_set(p_instance->p_reg, p_config->prescaler);
+    m_cb[p_instance->instance_id].reliable     = p_config->reliable;
+    m_cb[p_instance->instance_id].tick_latency = p_config->tick_latency;
+    m_cb[p_instance->instance_id].state        = NRF_DRV_STATE_INITIALIZED;
+
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+void nrf_drv_rtc_uninit(nrf_drv_rtc_t const * const p_instance)
+{
+    uint32_t mask = NRF_RTC_INT_TICK_MASK     |
+                    NRF_RTC_INT_OVERFLOW_MASK |
+                    NRF_RTC_INT_COMPARE0_MASK |
+                    NRF_RTC_INT_COMPARE1_MASK |
+                    NRF_RTC_INT_COMPARE2_MASK |
+                    NRF_RTC_INT_COMPARE3_MASK;
+    ASSERT(m_cb[p_instance->instance_id].state != NRF_DRV_STATE_UNINITIALIZED);
+
+    nrf_drv_common_irq_disable(p_instance->irq);
+
+    nrf_rtc_task_trigger(p_instance->p_reg, NRF_RTC_TASK_STOP);
+    nrf_rtc_event_disable(p_instance->p_reg, mask);
+    nrf_rtc_int_disable(p_instance->p_reg, mask);
+
+    m_cb[p_instance->instance_id].state = NRF_DRV_STATE_UNINITIALIZED;
+    NRF_LOG_INFO("Uninitialized.\r\n");
+}
+
+void nrf_drv_rtc_enable(nrf_drv_rtc_t const * const p_instance)
+{
+    ASSERT(m_cb[p_instance->instance_id].state == NRF_DRV_STATE_INITIALIZED);
+
+    nrf_rtc_task_trigger(p_instance->p_reg, NRF_RTC_TASK_START);
+    m_cb[p_instance->instance_id].state = NRF_DRV_STATE_POWERED_ON;
+    NRF_LOG_INFO("Enabled.\r\n");
+}
+
+void nrf_drv_rtc_disable(nrf_drv_rtc_t const * const p_instance)
+{
+    ASSERT(m_cb[p_instance->instance_id].state != NRF_DRV_STATE_UNINITIALIZED);
+
+    nrf_rtc_task_trigger(p_instance->p_reg, NRF_RTC_TASK_STOP);
+    m_cb[p_instance->instance_id].state = NRF_DRV_STATE_INITIALIZED;
+    NRF_LOG_INFO("Disabled.\r\n");
+}
+
+ret_code_t nrf_drv_rtc_cc_disable(nrf_drv_rtc_t const * const p_instance, uint32_t channel)
+{
+    ASSERT(m_cb[p_instance->instance_id].state != NRF_DRV_STATE_UNINITIALIZED);
+    ASSERT(channel<p_instance->cc_channel_count);
+
+    ret_code_t err_code;
+    uint32_t int_mask = RTC_CHANNEL_INT_MASK(channel);
+    nrf_rtc_event_t event    = RTC_CHANNEL_EVENT_ADDR(channel);
+
+    nrf_rtc_event_disable(p_instance->p_reg,int_mask);
+    if (nrf_rtc_int_is_enabled(p_instance->p_reg,int_mask))
+    {
+        nrf_rtc_int_disable(p_instance->p_reg,int_mask);
+        if (nrf_rtc_event_pending(p_instance->p_reg,event))
+        {
+            nrf_rtc_event_clear(p_instance->p_reg,event);
+            err_code = NRF_ERROR_TIMEOUT;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+    }
+    NRF_LOG_INFO("RTC id: %d, channel disabled: %d.\r\n", p_instance->instance_id, channel);
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+ret_code_t nrf_drv_rtc_cc_set(nrf_drv_rtc_t const * const p_instance,
+                              uint32_t channel,
+                              uint32_t val,
+                              bool enable_irq)
+{
+    ASSERT(m_cb[p_instance->instance_id].state != NRF_DRV_STATE_UNINITIALIZED);
+    ASSERT(channel<p_instance->cc_channel_count);
+
+    ret_code_t err_code;
+    uint32_t int_mask = RTC_CHANNEL_INT_MASK(channel);
+    nrf_rtc_event_t event    = RTC_CHANNEL_EVENT_ADDR(channel);
+
+    nrf_rtc_event_disable(p_instance->p_reg, int_mask);
+    nrf_rtc_int_disable(p_instance->p_reg, int_mask);
+
+    val = RTC_WRAP(val);
+    if (m_cb[p_instance->instance_id].reliable)
+    {
+        nrf_rtc_cc_set(p_instance->p_reg,channel,val);
+        uint32_t cnt = nrf_rtc_counter_get(p_instance->p_reg);
+        int32_t diff = cnt - val;
+        if (cnt < val)
+        {
+            diff += RTC_COUNTER_COUNTER_Msk;
+        }
+        if (diff < m_cb[p_instance->instance_id].tick_latency)
+        {
+            err_code = NRF_ERROR_TIMEOUT;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+    }
+    else
+    {
+        nrf_rtc_cc_set(p_instance->p_reg,channel,val);
+    }
+
+    if (enable_irq)
+    {
+        nrf_rtc_event_clear(p_instance->p_reg,event);
+        nrf_rtc_int_enable(p_instance->p_reg, int_mask);
+    }
+    nrf_rtc_event_enable(p_instance->p_reg,int_mask);
+
+    NRF_LOG_INFO("RTC id: %d, channel enabled: %d, compare value: %d.\r\n", p_instance->instance_id, channel, val);
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+void nrf_drv_rtc_tick_enable(nrf_drv_rtc_t const * const p_instance, bool enable_irq)
+{
+    nrf_rtc_event_t event = NRF_RTC_EVENT_TICK;
+    uint32_t mask = NRF_RTC_INT_TICK_MASK;
+
+    nrf_rtc_event_clear(p_instance->p_reg, event);
+    nrf_rtc_event_enable(p_instance->p_reg, mask);
+    if (enable_irq)
+    {
+        nrf_rtc_int_enable(p_instance->p_reg, mask);
+    }
+    NRF_LOG_INFO("Tick events enabled.\r\n");
+}
+
+void nrf_drv_rtc_tick_disable(nrf_drv_rtc_t const * const p_instance)
+{
+    uint32_t mask = NRF_RTC_INT_TICK_MASK;
+
+    nrf_rtc_event_disable(p_instance->p_reg, mask);
+    nrf_rtc_int_disable(p_instance->p_reg, mask);
+    NRF_LOG_INFO("Tick events disabled.\r\n");
+}
+
+void nrf_drv_rtc_overflow_enable(nrf_drv_rtc_t const * const p_instance, bool enable_irq)
+{
+    nrf_rtc_event_t event = NRF_RTC_EVENT_OVERFLOW;
+    uint32_t mask = NRF_RTC_INT_OVERFLOW_MASK;
+
+    nrf_rtc_event_clear(p_instance->p_reg, event);
+    nrf_rtc_event_enable(p_instance->p_reg, mask);
+    if (enable_irq)
+    {
+        nrf_rtc_int_enable(p_instance->p_reg, mask);
+    }
+}
+void nrf_drv_rtc_overflow_disable(nrf_drv_rtc_t const * const p_instance)
+{
+    uint32_t mask = NRF_RTC_INT_OVERFLOW_MASK;
+    nrf_rtc_event_disable(p_instance->p_reg, mask);
+    nrf_rtc_int_disable(p_instance->p_reg, mask);
+}
+
+uint32_t nrf_drv_rtc_max_ticks_get(nrf_drv_rtc_t const * const p_instance)
+{
+    uint32_t ticks;
+    if (m_cb[p_instance->instance_id].reliable)
+    {
+        ticks = RTC_COUNTER_COUNTER_Msk - m_cb[p_instance->instance_id].tick_latency;
+    }
+    else
+    {
+        ticks = RTC_COUNTER_COUNTER_Msk;
+    }
+    return ticks;
+}
+
+/**@brief Generic function for handling RTC interrupt
+ *
+ * @param[in]  p_reg         Pointer to instance register structure.
+ * @param[in]  instance_id   Index of instance.
+ */
+__STATIC_INLINE void nrf_drv_rtc_int_handler(NRF_RTC_Type * p_reg,
+                                             uint32_t instance_id,
+                                             uint32_t channel_count)
+{
+    uint32_t i;
+    uint32_t int_mask = (uint32_t)NRF_RTC_INT_COMPARE0_MASK;
+    nrf_rtc_event_t event = NRF_RTC_EVENT_COMPARE_0;
+
+    for (i = 0; i < channel_count; i++)
+    {
+        if (nrf_rtc_int_is_enabled(p_reg,int_mask) && nrf_rtc_event_pending(p_reg,event))
+        {
+            nrf_rtc_event_disable(p_reg,int_mask);
+            nrf_rtc_int_disable(p_reg,int_mask);
+            nrf_rtc_event_clear(p_reg,event);
+            NRF_LOG_DEBUG("Event: %s, instance id: %d.\r\n",
+                         (uint32_t)EVT_TO_STR(event), (uint32_t)instance_id);
+            m_handlers[instance_id]((nrf_drv_rtc_int_type_t)i);
+        }
+        int_mask <<= 1;
+        event    = (nrf_rtc_event_t)((uint32_t)event + sizeof(uint32_t));
+    }
+    event = NRF_RTC_EVENT_TICK;
+    if (nrf_rtc_int_is_enabled(p_reg,NRF_RTC_INT_TICK_MASK) &&
+        nrf_rtc_event_pending(p_reg, event))
+    {
+        nrf_rtc_event_clear(p_reg, event);
+        NRF_LOG_DEBUG("Event: %s, instance id: %d.\r\n", (uint32_t)EVT_TO_STR(event), instance_id);
+        m_handlers[instance_id](NRF_DRV_RTC_INT_TICK);
+    }
+
+    event = NRF_RTC_EVENT_OVERFLOW;
+    if (nrf_rtc_int_is_enabled(p_reg,NRF_RTC_INT_OVERFLOW_MASK) &&
+        nrf_rtc_event_pending(p_reg, event))
+    {
+        nrf_rtc_event_clear(p_reg,event);
+        NRF_LOG_DEBUG("Event: %s, instance id: %d.\r\n", (uint32_t)EVT_TO_STR(event), instance_id);
+        m_handlers[instance_id](NRF_DRV_RTC_INT_OVERFLOW);
+    }
+}
+
+#if NRF_MODULE_ENABLED(RTC0)
+void RTC0_IRQHandler(void)
+{
+    nrf_drv_rtc_int_handler(NRF_RTC0,RTC0_INSTANCE_INDEX, NRF_RTC_CC_CHANNEL_COUNT(0));
+}
+#endif
+
+#if NRF_MODULE_ENABLED(RTC1)
+void RTC1_IRQHandler(void)
+{
+    nrf_drv_rtc_int_handler(NRF_RTC1,RTC1_INSTANCE_INDEX, NRF_RTC_CC_CHANNEL_COUNT(1));
+}
+#endif
+
+#if NRF_MODULE_ENABLED(RTC2)
+void RTC2_IRQHandler(void)
+{
+    nrf_drv_rtc_int_handler(NRF_RTC2,RTC2_INSTANCE_INDEX, NRF_RTC_CC_CHANNEL_COUNT(2));
+}
+#endif
+#endif //ENABLED_RTC_COUNT
+#endif //NRF_MODULE_ENABLED(RTC)
diff --git a/drivers_nrf/rtc/nrf_drv_rtc.h b/drivers_nrf/rtc/nrf_drv_rtc.h
new file mode 100644
index 0000000..be783e6
--- /dev/null
+++ b/drivers_nrf/rtc/nrf_drv_rtc.h
@@ -0,0 +1,365 @@
+/**
+ * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, 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.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 NRF_DRV_RTC_H
+#define NRF_DRV_RTC_H
+
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+#include "nrf_drv_common.h"
+#include "nrf_rtc.h"
+#include "sdk_errors.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup nrf_rtc RTC HAL and driver
+ * @ingroup nrf_drivers
+ * @brief Real timer counter (RTC) APIs.
+ * @details The RTC HAL provides basic APIs for accessing the registers of the real time counter (RTC).
+ * The RTC driver provides APIs on a higher level.
+ *
+ * @defgroup nrf_drv_rtc RTC driver
+ * @{
+ * @ingroup nrf_rtc
+ * @brief Real timer counter (RTC) driver.
+ */
+
+/**@brief Macro to convert microseconds into ticks. */
+#define RTC_US_TO_TICKS(us,freq) ((us * freq) / 1000000)
+
+/**
+ * @enum nrf_drv_rtc_int_type_t
+ * @brief RTC driver interrupt types.
+ */
+typedef enum
+{
+    NRF_DRV_RTC_INT_COMPARE0 = 0, /**< Interrupt from COMPARE0 event. */
+    NRF_DRV_RTC_INT_COMPARE1 = 1, /**< Interrupt from COMPARE1 event. */
+    NRF_DRV_RTC_INT_COMPARE2 = 2, /**< Interrupt from COMPARE2 event. */
+    NRF_DRV_RTC_INT_COMPARE3 = 3, /**< Interrupt from COMPARE3 event. */
+    NRF_DRV_RTC_INT_TICK     = 4, /**< Interrupt from TICK event. */
+    NRF_DRV_RTC_INT_OVERFLOW = 5  /**< Interrupt from OVERFLOW event. */
+} nrf_drv_rtc_int_type_t;
+
+/**@brief RTC driver instance  structure. */
+typedef struct
+{
+    NRF_RTC_Type  * p_reg;            /**< Pointer to instance register set. */
+    IRQn_Type       irq;              /**< Instance IRQ ID. */
+    uint8_t         instance_id;      /**< Instance index. */
+    uint8_t         cc_channel_count; /**< Number of capture/compare channels. */
+} nrf_drv_rtc_t;
+
+#define RTC0_INSTANCE_INDEX 0
+#define RTC1_INSTANCE_INDEX RTC0_INSTANCE_INDEX+RTC0_ENABLED
+#define RTC2_INSTANCE_INDEX RTC1_INSTANCE_INDEX+RTC1_ENABLED
+
+/**@brief Macro for creating RTC driver instance.*/
+#define NRF_DRV_RTC_INSTANCE(id)                           \
+{                                                          \
+    .p_reg            = CONCAT_2(NRF_RTC, id),             \
+    .irq              = CONCAT_3(RTC, id, _IRQn),          \
+    .instance_id      = CONCAT_3(RTC, id, _INSTANCE_INDEX),\
+    .cc_channel_count = NRF_RTC_CC_CHANNEL_COUNT(id),      \
+}
+
+/**@brief RTC driver instance configuration structure. */
+typedef struct
+{
+    uint16_t prescaler;          /**< Prescaler. */
+    uint8_t  interrupt_priority; /**< Interrupt priority. */
+    uint8_t  tick_latency;       /**< Maximum length of interrupt handler in ticks (max 7.7 ms). */
+    bool     reliable;           /**< Reliable mode flag. */
+} nrf_drv_rtc_config_t;
+
+/**@brief RTC instance default configuration. */
+#define NRF_DRV_RTC_DEFAULT_CONFIG                                                               \
+{                                                                                                \
+    .prescaler          = RTC_FREQ_TO_PRESCALER(RTC_DEFAULT_CONFIG_FREQUENCY),                   \
+    .interrupt_priority = RTC_DEFAULT_CONFIG_IRQ_PRIORITY,                                       \
+    .reliable           = RTC_DEFAULT_CONFIG_RELIABLE,                                           \
+    .tick_latency       = RTC_US_TO_TICKS(NRF_MAXIMUM_LATENCY_US, RTC_DEFAULT_CONFIG_FREQUENCY), \
+}
+
+/**@brief RTC driver instance handler type. */
+typedef void (*nrf_drv_rtc_handler_t)(nrf_drv_rtc_int_type_t int_type);
+
+/**@brief Function for initializing the RTC driver instance.
+ *
+ * After initialization, the instance is in power off state.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ * @param[in]  p_config           Initial configuration. Default configuration used if NULL.
+ * @param[in]  handler            User's event handler.
+ *
+ * @retval     NRF_SUCCESS               If successfully initialized.
+ * @retval     NRF_ERROR_INVALID_PARAM   If no handler was provided.
+ * @retval     NRF_ERROR_INVALID_STATE   If the instance is already initialized.
+ */
+ret_code_t nrf_drv_rtc_init(nrf_drv_rtc_t const * const p_instance,
+                            nrf_drv_rtc_config_t const * p_config,
+                            nrf_drv_rtc_handler_t handler);
+
+/**@brief Function for uninitializing the RTC driver instance.
+ *
+ * After uninitialization, the instance is in idle state. The hardware should return to the state
+ *       before initialization. The function asserts if the instance is in idle state.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+void nrf_drv_rtc_uninit(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for enabling the RTC driver instance.
+ *
+ * @note Function asserts if instance is enabled.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+void nrf_drv_rtc_enable(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for disabling the RTC driver instance.
+ *
+ * @note Function asserts if instance is disabled.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+void nrf_drv_rtc_disable(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for setting a compare channel.
+ *
+ * The function asserts if the instance is not initialized or if the channel parameter is
+ *       wrong. The function powers on the instance if the instance was in power off state.
+ *
+ * The driver is not entering a critical section when configuring RTC, which means that it can be
+ *       preempted for a certain amount of time. When the driver was preempted and the value to be set
+ *       is short in time, there is a risk that the driver sets a compare value that is
+ *       behind. If RTCn_CONFIG_RELIABLE is 1 for the given instance, the Reliable mode handles that case.
+ *       However, to detect if the requested value is behind, this mode makes the following assumptions:
+ *        -  The maximum preemption time in ticks (8 - bit value) is known and is less than 7.7 ms
+ *         (for prescaler = 0, RTC frequency 32 kHz).
+ *        -  The requested absolute compare value is not bigger than (0x00FFFFFF) - tick_latency. It is
+ *         the user's responsibility to ensure that.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ * @param[in]  channel            One of the instance's channels.
+ * @param[in]  val                Absolute value to be set in the compare register.
+ * @param[in]  enable_irq         True to enable the interrupt. False to disable the interrupt.
+ *
+ * @retval     NRF_SUCCESS         If the procedure was successful.
+ * @retval     NRF_ERROR_TIMEOUT   If the compare was not set because the request value is behind the current counter
+ *                                 value. This error can only be reported if RTCn_CONFIG_RELIABLE = 1.
+ */
+ret_code_t nrf_drv_rtc_cc_set(nrf_drv_rtc_t const * const p_instance,
+                              uint32_t channel,
+                              uint32_t val,
+                              bool enable_irq);
+
+/**@brief Function for disabling a channel.
+ *
+ * This function disables channel events and channel interrupts. The function asserts if the instance is not
+ *       initialized or if the channel parameter is wrong.
+ *
+ * @param[in]  p_instance          Pointer to the driver instance structure.
+ * @param[in]  channel             One of the instance's channels.
+ *
+ * @retval     NRF_SUCCESS         If the procedure was successful.
+ * @retval     NRF_ERROR_TIMEOUT   If an interrupt was pending on the requested channel.
+ */
+ret_code_t nrf_drv_rtc_cc_disable(nrf_drv_rtc_t const * const p_instance, uint32_t channel);
+
+/**@brief Function for enabling tick.
+ *
+ * This function enables the tick event and optionally the interrupt. The function asserts if the instance is not
+ *       powered on.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ * @param[in]  enable_irq         True to enable the interrupt. False to disable the interrupt.
+ */
+void nrf_drv_rtc_tick_enable(nrf_drv_rtc_t const * const p_instance, bool enable_irq);
+
+/**@brief Function for disabling tick.
+ *
+ * This function disables the tick event and interrupt.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+void nrf_drv_rtc_tick_disable(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for enabling overflow.
+ *
+ * This function enables the overflow event and optionally the interrupt. The function asserts if the instance is
+ *       not powered on.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ * @param[in]  enable_irq         True to enable the interrupt. False to disable the interrupt.
+ */
+void nrf_drv_rtc_overflow_enable(nrf_drv_rtc_t const * const p_instance, bool enable_irq);
+
+/**@brief Function for disabling overflow.
+ *
+ * This function disables the overflow event and interrupt.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+void nrf_drv_rtc_overflow_disable(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for getting the maximum relative ticks value that can be set in the compare channel.
+ *
+ * When a SoftDevice is used, it occupies the highest level interrupt, so that the application code can be
+ *       interrupted at any moment for a certain period of time. If Reliable mode is enabled, the provided
+ *       maximum latency is taken into account and the return value is smaller than the RTC counter
+ *       resolution. If Reliable mode is disabled, the return value equals the counter resolution.
+ *
+ * @param[in]  p_instance  Pointer to the driver instance structure.
+ *
+ * @retval     ticks         Maximum ticks value.
+ */
+uint32_t nrf_drv_rtc_max_ticks_get(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for disabling all instance interrupts.
+  *
+ * @param[in]  p_instance          Pointer to the driver instance structure.
+ * @param[in]  p_mask              Pointer to the location where the mask is filled.
+ */
+__STATIC_INLINE void nrf_drv_rtc_int_disable(nrf_drv_rtc_t const * const p_instance,
+                                             uint32_t * p_mask);
+
+/**@brief Function for enabling instance interrupts.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ * @param[in]  mask               Mask of interrupts to enable.
+ */
+__STATIC_INLINE void nrf_drv_rtc_int_enable(nrf_drv_rtc_t const * const p_instance, uint32_t mask);
+
+/**@brief Function for retrieving the current counter value.
+ *
+ * This function asserts if the instance is not powered on or if p_val is NULL.
+ *
+ * @param[in]  p_instance    Pointer to the driver instance structure.
+ *
+ * @retval     value         Counter value.
+ */
+__STATIC_INLINE uint32_t nrf_drv_rtc_counter_get(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for clearing the counter value.
+ *
+ * This function asserts if the instance is not powered on.
+ *
+ * @param[in]  p_instance         Pointer to the driver instance structure.
+ */
+__STATIC_INLINE void nrf_drv_rtc_counter_clear(nrf_drv_rtc_t const * const p_instance);
+
+/**@brief Function for returning a requested task address for the RTC driver instance.
+ *
+ * This function asserts if the output pointer is NULL. The task address can be used by the PPI module.
+ *
+ * @param[in]  p_instance         Pointer to the instance.
+ * @param[in]  task                One of the peripheral tasks.
+ *
+ * @retval     Address of task register.
+ */
+__STATIC_INLINE uint32_t nrf_drv_rtc_task_address_get(nrf_drv_rtc_t const * const p_instance,
+                                                      nrf_rtc_task_t task);
+
+/**@brief Function for returning a requested event address for the RTC driver instance.
+ *
+ * This function asserts if the output pointer is NULL. The event address can be used by the PPI module.
+ *
+ * @param[in]  p_instance          Pointer to the driver instance structure.
+ * @param[in]  event               One of the peripheral events.
+ *
+ * @retval     Address of event register.
+ */
+__STATIC_INLINE uint32_t nrf_drv_rtc_event_address_get(nrf_drv_rtc_t const * const p_instance,
+                                                       nrf_rtc_event_t event);
+#ifndef SUPPRESS_INLINE_IMPLEMENTATION
+
+__STATIC_INLINE void nrf_drv_rtc_int_disable(nrf_drv_rtc_t const * const p_instance,
+                                                 uint32_t * p_mask)
+{
+    *p_mask = nrf_rtc_int_get(p_instance->p_reg);
+    nrf_rtc_int_disable(p_instance->p_reg, NRF_RTC_INT_TICK_MASK |
+                                           NRF_RTC_INT_OVERFLOW_MASK |
+                                           NRF_RTC_INT_COMPARE0_MASK |
+                                           NRF_RTC_INT_COMPARE1_MASK |
+                                           NRF_RTC_INT_COMPARE2_MASK |
+                                           NRF_RTC_INT_COMPARE3_MASK);
+}
+
+__STATIC_INLINE void nrf_drv_rtc_int_enable(nrf_drv_rtc_t const * const p_instance, uint32_t mask)
+{
+    nrf_rtc_int_enable(p_instance->p_reg, mask);
+}
+
+__STATIC_INLINE uint32_t nrf_drv_rtc_counter_get(nrf_drv_rtc_t const * const p_instance)
+{
+    return nrf_rtc_counter_get(p_instance->p_reg);
+}
+
+__STATIC_INLINE void nrf_drv_rtc_counter_clear(nrf_drv_rtc_t const * const p_instance)
+{
+    nrf_rtc_task_trigger(p_instance->p_reg,NRF_RTC_TASK_CLEAR);
+}
+
+__STATIC_INLINE uint32_t nrf_drv_rtc_task_address_get(nrf_drv_rtc_t const * const p_instance,
+                                                      nrf_rtc_task_t task)
+{
+    return nrf_rtc_task_address_get(p_instance->p_reg, task);
+}
+
+__STATIC_INLINE uint32_t nrf_drv_rtc_event_address_get(nrf_drv_rtc_t const * const p_instance,
+                                                       nrf_rtc_event_t event)
+{
+    return nrf_rtc_event_address_get(p_instance->p_reg, event);
+}
+#endif /* SUPPRESS_INLINE_IMPLEMENTATION */
+
+/**
+ *@}
+ **/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NRF_DRV_RTC_H */