nrfx: drivers: grtc: Add function dedicated for nrf_grtc_timer

Add functions that improves performance of nrf_grtc_timer:
- Channel allocation with callback. Previously callback is written on every CC val
setting which is redundant
- Function for setting CCADD register
- Function for setting CC register

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

nrfx/drivers/include/nrfx_grtc.h

@@ -52,10 +52,9 @@ extern "C" {
  * @brief GRTC driver instance compare handler type.
  *
  * @param[in] id        Channel ID.
- * @param[in] cc_value  Compare value.
  * @param[in] p_context User context.
  */
-typedef void (*nrfx_grtc_cc_handler_t)(int32_t id, uint64_t cc_value, void * p_context);
+typedef void (*nrfx_grtc_cc_handler_t)(int32_t id, void * p_context);
 
 #if NRFY_GRTC_HAS_EXTENDED || defined(__NRFX_DOXYGEN__)
 /**
@@ -158,6 +157,7 @@ nrfx_err_t nrfx_grtc_sleep_configuration_get(nrfx_grtc_sleep_config_t * p_sleep_
  * @brief Function for allocating the GRTC capture/compare channel.
  *
  * @note Function is thread safe as it uses @ref nrfx_flag32_alloc.
+ * @note This function marks the specified @p channel as used.
  * @note Routines that allocate and free the GRTC channels are independent
  *       from the rest of the driver. In particular, the driver does not need
  *       to be initialized when this function is called.
@@ -169,6 +169,25 @@ nrfx_err_t nrfx_grtc_sleep_configuration_get(nrfx_grtc_sleep_config_t * p_sleep_
  */
 nrfx_err_t nrfx_grtc_channel_alloc(uint8_t * p_channel);
 
+/**
+ * @brief Function for allocating the GRTC capture/compare channel for callback
+ *
+ * Function gets callback which shall be used for that channel. Since channel will
+ * be used with callback, interrupt is enabled for that channel.
+ *
+ * @note Function is thread safe as it uses @ref nrfx_flag32_alloc.
+ *
+ * @param[out] p_channel Pointer to the capture/compare channel.
+ * @param[in]  handler   User handler called when channel expires.
+ * @param[in]  p_context Context passed to the callback.
+ *
+ * @retval NRFX_SUCCESS      Allocation was successful.
+ * @retval NRFX_ERROR_NO_MEM No resource available.
+ */
+nrfx_err_t nrfx_grtc_channel_cb_alloc(uint8_t * p_channel,
+                                      nrfx_grtc_cc_handler_t handler,
+                                      void *p_context);
+
 /**
  * @brief Function for freeing the GRTC capture/compare channel.
  *
@@ -281,22 +300,27 @@ void nrfx_grtc_syscountervalid_int_disable(void);
  * @brief Function for starting the 1 MHz SYSCOUNTER.
  *
  * @note This function automatically allocates and marks as used the special-purpose main
- *       capture/compare channel. It is available only for GRTC manager.
+ *       capture/compare channel. Interrupt for that channel is enabled.
+ *       It is available only for GRTC manager.
  *
  * @note Use auxiliary structure of type @ref nrfx_grtc_channel_t when working with SYSCOUNTER.
  *
  * @param[in]  busy_wait         True if wait for synchronization operation is to be performed,
  *                               false otherwise.
  * @param[out] p_main_cc_channel Pointer to the main capture/compare channel.
+ * @param[in]  handler           Handler.
+ * @param[in]  p_context         User context passed to the callback.
  *
  * @retval NRFX_SUCCESS       Starting was successful.
  * @retval NRFX_ERROR_NO_MEM  No resource available to allocate main channel.
  * @retval NRFX_ERROR_ALREADY The GRTC is already running.
  * @retval NRFX_ERROR_TIMEOUT The SYSCOUNTER failed to start due to a timeout.
  */
 
-nrfx_err_t nrfx_grtc_syscounter_start(bool busy_wait, uint8_t * p_main_cc_channel);
-
+nrfx_err_t nrfx_grtc_syscounter_start(bool busy_wait,
+                                      uint8_t * p_main_cc_channel,
+                                      nrfx_grtc_cc_handler_t handler,
+                                      void *p_context);
 /**
  * @brief Function for performing an action for the GRTC.
  *
@@ -359,6 +383,22 @@ nrfx_err_t nrfx_grtc_syscounter_cc_absolute_set(nrfx_grtc_channel_t * p_chan_dat
                                                 uint64_t              val,
                                                 bool                  enable_irq);
 
+/**
+ * @brief Function for setting the absolute compare value for the SYSCOUNTER.
+ *
+ * Function must be called with interrupts locked. If %p safe_setting is true then
+ * it means that previous CC for that channel did not yet expired and it
+ * was set to a value earlier than %p val so there is a chance that it will
+ * expire during setting the new value. In that case compare event may be misinterpreted.
+ * Slower but safe procedure is used in that case. If %p safe_setting is false then
+ * function just sets new CC value.
+ *
+ * @param[in] channel     Channel.
+ * @param[in] val         Absolute value to be set in the compare register.
+ * @param[in] safe_setting Use safe procedure if true or just set CC to a new value if false.
+ */
+void nrfx_grtc_syscounter_cc_abs_set(uint8_t channel, uint64_t val, bool safe_setting);
+
 /**
  * @brief Function for setting the relative compare value for the SYSCOUNTER.
  *
@@ -379,6 +419,22 @@ nrfx_err_t nrfx_grtc_syscounter_cc_relative_set(nrfx_grtc_channel_t *
                                                 bool                              enable_irq,
                                                 nrfx_grtc_cc_relative_reference_t reference);
 
+/**
+ * @brief Function for setting the relative compare value for the SYSCOUNTER.
+ *
+ * Function just sets CCADD value and does not attempt to enable or disable the interrupt.
+ * It assumes that expected channel configuration is done prior to that call.
+ * Function assumes that previously used CC value has already expired so new value
+ * can be safely set without a risk of spurious CC expiration.
+ *
+ * @param[in] channel     Channel.
+ * @param[in] val         Relative value to be set in the CCADD register.
+ * @param[in] reference   Reference. Current counter value or current CC value.
+ */
+void nrfx_grtc_syscounter_cc_rel_set(uint8_t channel,
+                                     uint32_t val,
+                                     nrfx_grtc_cc_relative_reference_t reference);
+
 /**
  * @brief Function for disabling the SYSCOUNTER compare interrupt.
  *
@@ -539,6 +595,15 @@ NRFX_STATIC_INLINE bool nrfx_grtc_sys_counter_cc_enable_check(uint8_t channel);
  */
 NRFX_STATIC_INLINE bool nrfx_grtc_syscounter_compare_event_check(uint8_t channel);
 
+/**
+ * @brief Function for retrieving CC value.
+ *
+ * @param[in] channel Compare channel.
+ *
+ * @return Value read from CC register.
+ */
+NRFX_STATIC_INLINE uint64_t nrfx_grtc_sys_counter_cc_get(uint8_t channel);
+
 #if NRF_GRTC_HAS_RTCOUNTER || defined(__NRFX_DOXYGEN__)
 /**
  * @brief Function for reading the GRTC RTCOUNTER value.
@@ -590,6 +655,11 @@ NRFX_STATIC_INLINE bool nrfx_grtc_syscounter_compare_event_check(uint8_t channel
     return nrfy_grtc_sys_counter_compare_event_check(NRF_GRTC, channel);
 }
 
+NRFX_STATIC_INLINE uint64_t nrfx_grtc_sys_counter_cc_get(uint8_t channel)
+{
+    return nrfy_grtc_sys_counter_cc_get(NRF_GRTC, channel);
+}
+
 #if NRF_GRTC_HAS_RTCOUNTER
 NRFX_STATIC_INLINE uint64_t nrfx_grtc_rtcounter_get(void)
 {

nrfx/drivers/src/nrfx_grtc.c

@@ -306,6 +306,24 @@ nrfx_err_t nrfx_grtc_syscounter_get(uint64_t * p_counter)
     return err_code;
 }
 
+nrfx_err_t nrfx_grtc_channel_cb_alloc(uint8_t * p_channel,
+                                      nrfx_grtc_cc_handler_t handler,
+                                      void *p_context)
+{
+    nrfx_err_t err_code = nrfx_flag32_alloc(&m_cb.available_channels, p_channel);
+    if (err_code != NRFX_SUCCESS) {
+        return err_code;
+    }
+    uint8_t ch_data_idx = get_ch_data_index_for_channel(*p_channel);
+
+    m_cb.channel_data[ch_data_idx].handler = handler;
+    m_cb.channel_data[ch_data_idx].p_context = p_context;
+    m_cb.channel_data[ch_data_idx].channel = *p_channel;
+    nrfy_grtc_int_enable(NRF_GRTC, GRTC_CHANNEL_TO_BITMASK(*p_channel));
+
+    return err_code;
+}
+
 nrfx_err_t nrfx_grtc_channel_alloc(uint8_t * p_channel)
 {
     NRFX_ASSERT(p_channel);
@@ -532,7 +550,10 @@ nrfx_err_t nrfx_grtc_rtcounter_cc_absolute_set(nrfx_grtc_rtcounter_handler_data_
 #endif // NRF_GRTC_HAS_RTCOUNTER
 
 #if NRFY_GRTC_HAS_EXTENDED
-nrfx_err_t nrfx_grtc_syscounter_start(bool busy_wait, uint8_t * p_main_cc_channel)
+nrfx_err_t nrfx_grtc_syscounter_start(bool busy_wait,
+                                      uint8_t * p_main_cc_channel,
+                                      nrfx_grtc_cc_handler_t handler,
+                                      void *p_context)
 {
     NRFX_ASSERT(m_cb.state == NRFX_DRV_STATE_INITIALIZED);
     NRFX_ASSERT(p_main_cc_channel);
@@ -551,6 +572,9 @@ nrfx_err_t nrfx_grtc_syscounter_start(bool busy_wait, uint8_t * p_main_cc_channe
     }
 
     *p_main_cc_channel       = MAIN_GRTC_CC_CHANNEL;
+    m_cb.channel_data[0].handler = handler;
+    m_cb.channel_data[0].p_context = p_context;
+    nrfy_grtc_int_enable(NRF_GRTC, GRTC_CHANNEL_TO_BITMASK(*p_main_cc_channel));
     m_cb.available_channels &= ~GRTC_CHANNEL_TO_BITMASK(MAIN_GRTC_CC_CHANNEL);
     channel_used_mark(MAIN_GRTC_CC_CHANNEL);
     NRFX_LOG_INFO("GRTC channel %u allocated.", m_cb.channel_data[0].channel);
@@ -732,6 +756,28 @@ nrfx_err_t nrfx_grtc_syscounter_cc_disable(uint8_t channel)
     return err_code;
 }
 
+void nrfx_grtc_syscounter_cc_abs_set(uint8_t channel, uint64_t val, bool safe_setting)
+{
+    if (safe_setting)
+    {
+        nrfy_grtc_sys_counter_cc_set(NRF_GRTC, channel, val);
+        if (nrfy_grtc_sys_counter_compare_event_check(NRF_GRTC, channel))
+        {
+            uint64_t now;
+
+            nrfx_grtc_syscounter_get(&now);
+            if (val > now)
+            {
+                nrfy_grtc_sys_counter_compare_event_clear(NRF_GRTC, channel);
+            }
+        }
+    }
+    else
+    {
+        nrfy_grtc_sys_counter_cc_set(NRF_GRTC, channel, val);
+    }
+}
+
 nrfx_err_t nrfx_grtc_syscounter_cc_absolute_set(nrfx_grtc_channel_t * p_chan_data,
                                                 uint64_t              val,
                                                 bool                  enable_irq)
@@ -764,6 +810,16 @@ nrfx_err_t nrfx_grtc_syscounter_cc_absolute_set(nrfx_grtc_channel_t * p_chan_dat
     return err_code;
 }
 
+void nrfx_grtc_syscounter_cc_rel_set(uint8_t channel,
+                                     uint32_t val,
+                                     nrfx_grtc_cc_relative_reference_t reference)
+{
+    nrfy_grtc_sys_counter_cc_add_set(NRF_GRTC,
+                                     channel,
+                                     val,
+                                     (nrf_grtc_cc_add_reference_t)reference);
+}
+
 nrfx_err_t nrfx_grtc_syscounter_cc_relative_set(nrfx_grtc_channel_t *             p_chan_data,
                                                 uint32_t                          val,
                                                 bool                              enable_irq,