third_party/NordicSemiconductor/drivers/radio/raal/softdevice/nrf_raal_softdevice.c - nest-guard/1.0/openthread - Git at Google

 /* Copyright (c) 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 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.
  *
  * 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 EVENT SHALL THE COPYRIGHT HOLDER 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
  *   This file implements the nrf 802.15.4 radio arbiter for softdevice.
  *
  * This arbiter should be used when 802.15.4 works concurrently with SoftDevice's radio stack.
  *
  */

 #include "nrf_raal_softdevice.h"

 #include <assert.h>
 #include <stdbool.h>
 #include <string.h>

 #include <nrf_raal_api.h>
 #include <nrf_drv_radio802154_debug.h>
 #include <nrf_drv_clock.h>
 #include <softdevice.h>

 /**@brief Enable Request and End on timeslot safety interrupt. */
 #define ENABLE_REQUEST_AND_END_ON_TIMESLOT_END 0

 /**@brief Maximum jitter relative to the start time of START and TIMER0 (safety margin) events . */
 #define TIMER_TO_SIGNAL_JITTER_US NRF_RADIO_START_JITTER_US + 6

 /**@brief Timer compare channel definitions. */
 #define TIMER_CC_EXTEND           0
 #define TIMER_CC_EXTEND_INTENSET  TIMER_INTENSET_COMPARE0_Msk
 #define TIMER_CC_EXTEND_INTENCLR  TIMER_INTENCLR_COMPARE0_Pos

 #define TIMER_CC_MARGIN           1
 #define TIMER_CC_MARGIN_INTENSET  TIMER_INTENSET_COMPARE1_Msk
 #define TIMER_CC_MARGIN_INTENCLR  TIMER_INTENCLR_COMPARE1_Pos

 #define TIMER_CC_CAPTURE          2

 /**@brief Defines number of microseconds in one second. */
 #define US_PER_S                  1000000

 /**@brief Ceil division helper */
 #define DIVIDE_AND_CEIL(A, B) (((A) + (B) - 1) / (B))

 /**@brief Defines pending events. */
 typedef enum
 {
     PENDING_EVENT_NONE = 0,
     PENDING_EVENT_STARTED,
     PENDING_EVENT_ENDED
 } pending_events_t;

 /**@brief Request parameters. */
 static nrf_radio_request_t m_request;

 /**@brief Return parameter for SD radio signal handler. */
 static nrf_radio_signal_callback_return_param_t m_ret_param;

 /**@brief Current configuration of the RAAL. */
 static nrf_raal_softdevice_cfg_t m_config;

 /**@brief Current timeslot length. */
 static uint16_t m_timeslot_length;

 /**@brief Defines if RAAL is in continous mode. */
 static volatile bool m_continuous = false;

 /**@brief Defines if RAAL is currently in a timeslot. */
 static volatile bool m_in_timeslot = false;

 /**@brief Current iteration process number. */
 static volatile uint16_t m_alloc_iters;

 /**@brief Defines if module has been initialized. */
 static bool m_initialize = false;

 /**@breif Defines if Radio Driver entered critical section. */
 static volatile bool m_in_critical_section = false;

 /**@brief Defines current pending event. */
 static volatile pending_events_t m_pending_event = PENDING_EVENT_NONE;

 /**@brief Defines RTC0 counter value on timeslot begin. */
 static uint32_t m_start_rtc_ticks = 0;

 /**@brief External Interrupt from RADIO. */
 extern void RADIO_IRQHandler(void);

 /**@brief Initialize timeslot internal variables. */
 static inline void timeslot_data_init(void)
 {
     m_alloc_iters     = 0;
     m_timeslot_length = m_config.timeslot_length;
 }

 /**@brief Get actual time. */
 static inline uint32_t timer_time_get(void)
 {
     NRF_TIMER0->TASKS_CAPTURE[TIMER_CC_CAPTURE] = 1;
     return NRF_TIMER0->CC[TIMER_CC_CAPTURE];
 }

 /**@brief Check if margin is already reached. */
 static inline bool timer_is_margin_reached(void)
 {
     return NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN];
 }

 /**@brief Enter timeslot critical section. */
 static inline void timeslot_critical_section_enter(void)
 {
     NVIC_DisableIRQ(TIMER0_IRQn);
     __DSB();
     __ISB();
 }

 /**@brief Exit timeslot critical section. */
 static inline void timeslot_critical_section_exit(void)
 {
     NVIC_EnableIRQ(TIMER0_IRQn);
 }

 static inline void timeslot_started_notify(void)
 {
     if (m_in_timeslot && m_continuous)
     {
         nrf_raal_timeslot_started();
     }
 }

 static inline void timeslot_ended_notify(void)
 {
     if (!m_in_timeslot && m_continuous)
     {
         nrf_raal_timeslot_ended();
     }
 }

 /**@brief Calculate maximal crystal drift. */
 static inline uint32_t rtc_drift_calculate(uint32_t timeslot_length)
 {
     return DIVIDE_AND_CEIL(((uint64_t)timeslot_length * m_config.lf_clk_accuracy_ppm), US_PER_S);
 }

 /**@brief Prepare earliest timeslot request. */
 static void timeslot_request_prepare(void)
 {
     memset(&m_request, 0, sizeof(m_request));
     m_request.request_type               = NRF_RADIO_REQ_TYPE_EARLIEST;
     m_request.params.earliest.hfclk      = NRF_RADIO_HFCLK_CFG_NO_GUARANTEE;
     m_request.params.earliest.priority   = NRF_RADIO_PRIORITY_NORMAL;
     m_request.params.earliest.length_us  = m_timeslot_length;
     m_request.params.earliest.timeout_us = m_config.timeslot_timeout;
 }

 /**@brief Request earliest timeslot. */
 static void timeslot_request(void)
 {
     assert(!m_in_timeslot);

     timeslot_request_prepare();
     sd_radio_request(&m_request);
 }

 /**@brief Set timer on timeslot started. */
 static void timer_start(void)
 {
     NRF_TIMER0->TASKS_STOP          = 1;
     NRF_TIMER0->TASKS_CLEAR         = 1;
     NRF_TIMER0->BITMODE             = TIMER_BITMODE_BITMODE_32Bit;
     NRF_TIMER0->INTENSET            = TIMER_CC_MARGIN_INTENSET;
     NRF_TIMER0->CC[TIMER_CC_EXTEND] = 0;
     NRF_TIMER0->CC[TIMER_CC_MARGIN] = m_timeslot_length - m_config.timeslot_safe_margin;
     NRF_TIMER0->TASKS_START         = 1;

     NVIC_EnableIRQ(TIMER0_IRQn);
 }

 /**@brief Reset timer. */
 static void timer_reset(void)
 {
     NRF_TIMER0->TASKS_STOP                      = 1;
     NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND] = 0;
     NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN] = 0;
     NVIC_ClearPendingIRQ(TIMER0_IRQn);
 }

 /**@brief Set timer on extend event. */
 static void timer_extend(void)
 {
     NVIC_ClearPendingIRQ(TIMER0_IRQn);

     NRF_TIMER0->INTENSET             = TIMER_CC_MARGIN_INTENSET;
     NRF_TIMER0->CC[TIMER_CC_MARGIN] += m_timeslot_length;

     if (!m_alloc_iters)
     {
         NRF_TIMER0->INTENSET             = TIMER_CC_EXTEND_INTENSET;
         NRF_TIMER0->CC[TIMER_CC_EXTEND] += m_timeslot_length;
     }
 }

 /**@brief Eliminate timers jitters. */
 static void timer_jitter_adjust(void)
 {
     // Adjust TIMER0 and RTC0 clocks drifts.
     uint32_t timer_ticks = timer_time_get();
     uint64_t rtc_ticks   = NRF_RTC0->COUNTER;

     if (rtc_ticks > m_start_rtc_ticks)
     {
         rtc_ticks -= m_start_rtc_ticks;
     }
     else
     {
         // Overflow detected.
         rtc_ticks = RTC_COUNTER_COUNTER_Msk - m_start_rtc_ticks + rtc_ticks;
     }

     // Adjust RTC0 ticks to TIMER0 resolution. RTC0 works with 32768kHz so first
     // multiply with 10^6 (microseconds) and divide by 32768Hz (2^15) to get microseconds.
     rtc_ticks = DIVIDE_AND_CEIL((rtc_ticks * US_PER_S), 32768);

     // Check if we are still in time.
     uint32_t cc_margin = NRF_TIMER0->CC[TIMER_CC_MARGIN];
     assert(cc_margin > rtc_ticks + rtc_drift_calculate(cc_margin));

     if (rtc_ticks > timer_ticks)
     {
         NRF_TIMER0->CC[TIMER_CC_MARGIN] -= (rtc_ticks - timer_ticks);
     }
     else
     {
         NRF_TIMER0->CC[TIMER_CC_MARGIN] += (timer_ticks - rtc_ticks);
     }

     // Add safety drift time.
     NRF_TIMER0->CC[TIMER_CC_MARGIN] -= rtc_drift_calculate(2 * m_config.timeslot_length) +
                                        TIMER_TO_SIGNAL_JITTER_US;
 }

 /**@brief Decrease timeslot length. */
 static void timeslot_decrease_length(void)
 {
     m_alloc_iters++;
     m_timeslot_length = m_timeslot_length >> 1;
 }

 /**@brief Extend timeslot. */
 static void timeslot_extend(void)
 {
     if (m_alloc_iters < m_config.timeslot_alloc_iters)
     {
         timeslot_decrease_length();

         // Try to extend right after start.
         m_ret_param.callback_action         = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
         m_ret_param.params.extend.length_us = m_timeslot_length;

         nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);
     }
     else
     {
         timer_jitter_adjust();
     }
 }

 static void timer_irq_handle(void)
 {
     // Safe margin exceeded.
     if (NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN])
     {
         nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_MARGIN);

         m_in_timeslot = false;

         if (m_in_critical_section)
         {
             assert(m_pending_event != PENDING_EVENT_ENDED);

             if (m_pending_event == PENDING_EVENT_STARTED)
             {
                 m_pending_event = PENDING_EVENT_NONE;
             }
             else
             {
                 m_pending_event = PENDING_EVENT_ENDED;
             }
         }
         else
         {
             timeslot_ended_notify();
         }

         // Ignore any other events.
         timer_reset();

 #if (ENABLE_REQUEST_AND_END_ON_TIMESLOT_END == 1)
         timeslot_data_init();
         timeslot_request_prepare();
         m_ret_param.callback_action       = NRF_RADIO_SIGNAL_CALLBACK_ACTION_REQUEST_AND_END;
         m_ret_param.params.request.p_next = &m_request;
 #else
         // Return and wait for NRF_EVT_RADIO_SESSION_IDLE event.
         m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
 #endif

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_MARGIN);
     }

     // Extension margin exceeded.
     else if (NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND])
     {
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXTEND);

         NRF_TIMER0->INTENCLR = (1 << TIMER_CC_EXTEND_INTENCLR);
         NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND] = 0;

         if (m_continuous &&
             NRF_TIMER0->CC[TIMER_CC_EXTEND] + m_config.timeslot_length < m_config.timeslot_max_length)
         {
             nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);

             m_ret_param.callback_action         = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
             m_ret_param.params.extend.length_us = m_config.timeslot_length;
         }
         else
         {
             timer_jitter_adjust();

             m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
         }

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXTEND);
     }
     else
     {
         // Should not happen.
         assert(false);
     }
 }

 /**@brief Signal handler. */
 static nrf_radio_signal_callback_return_param_t *signal_handler(uint8_t signal_type)
 {
     nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_HANDLER);

     // Default response.
     m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;

     if (!m_continuous)
     {
         nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_ENDED);

         m_pending_event             = PENDING_EVENT_NONE;
         m_in_timeslot               = false;

         // TODO: Change to NRF_RADIO_SIGNAL_CALLBACK_ACTION_END (KRKNWK-937)
         m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
         timer_reset();

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_ENDED);
         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_HANDLER);
         return &m_ret_param;
     }

     switch (signal_type)
     {
     case NRF_RADIO_CALLBACK_SIGNAL_TYPE_START: /**< This signal indicates the start of the radio timeslot. */
     {
         nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_ACTIVE);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_START);

         // Ensure HFCLK is running before start is issued.
         assert(NRF_CLOCK->HFCLKSTAT == (CLOCK_HFCLKSTAT_SRC_Msk | CLOCK_HFCLKSTAT_STATE_Msk));

         m_start_rtc_ticks = NRF_RTC0->COUNTER;
         m_in_timeslot     = true;
         m_alloc_iters     = 0;
         m_timeslot_length = m_timeslot_length;

         timer_start();

         if (m_in_critical_section)
         {
             assert(m_pending_event != PENDING_EVENT_STARTED);

             if (m_pending_event == PENDING_EVENT_ENDED)
             {
                 m_pending_event = PENDING_EVENT_NONE;
             }
             else
             {
                 m_pending_event = PENDING_EVENT_STARTED;
             }
         }
         else
         {
             timeslot_started_notify();
         }

         // Try to extend right after start.
         m_ret_param.callback_action         = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
         m_ret_param.params.extend.length_us = m_timeslot_length;

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_START);
         nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);
         break;
     }

     case NRF_RADIO_CALLBACK_SIGNAL_TYPE_TIMER0: /**< This signal indicates the NRF_TIMER0 interrupt. */
         timer_irq_handle();
         break;

     case NRF_RADIO_CALLBACK_SIGNAL_TYPE_RADIO: /**< This signal indicates the NRF_RADIO interrupt. */
         nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_RADIO_IRQ);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_RADIO);

         if (m_in_timeslot)
         {
             if (!timer_is_margin_reached())
             {
                 RADIO_IRQHandler();
             }
             else
             {
                 //  Handle margin exceeded event.
                 timer_irq_handle();
             }
         }

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_RADIO);
         nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_RADIO_IRQ);
         break;

     case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_FAILED: /**< This signal indicates extend action failed. */
         nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_EXTEND_REQ);
         nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_FAILED);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXCEED_FAIL);

         timeslot_extend();

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXCEED_FAIL);
         break;

     case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_SUCCEEDED: /**< This signal indicates extend action succeeded. */
         nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_EXTEND_REQ);
         nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXCEED_SUCCESS);

         timer_extend();

         if (m_alloc_iters != 0)
         {
             timeslot_extend();
         }

         nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXCEED_SUCCESS);
         break;

     default:
         break;
     }

     nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_HANDLER);

     return &m_ret_param;
 }

 void nrf_raal_softdevice_soc_evt_handler(uint32_t evt_id)
 {
     switch (evt_id)
     {
     case NRF_EVT_HFCLKSTARTED:
         if (m_continuous)
         {
             timeslot_request();
         }

         break;

     case NRF_EVT_RADIO_BLOCKED:
     case NRF_EVT_RADIO_CANCELED:
     {
         nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_BLOCKED);

         assert(!m_in_timeslot);

         if (m_continuous)
         {
             if (m_alloc_iters < m_config.timeslot_alloc_iters)
             {
                 timeslot_decrease_length();
             }

             timeslot_request();
         }

         break;
     }

     case NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN:
         assert(false);
         break;

     case NRF_EVT_RADIO_SESSION_IDLE:
         if (m_continuous)
         {
             nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_SESSION_IDLE);

             timeslot_data_init();
             timeslot_request();
         }

         break;

     case NRF_EVT_RADIO_SESSION_CLOSED:
         break;

     default:
         break;
     }
 }

 void nrf_raal_softdevice_config(const nrf_raal_softdevice_cfg_t * p_cfg)
 {
     assert(m_initialize);
     assert(!m_continuous);
     assert(p_cfg);

     m_config = *p_cfg;
 }

 void nrf_raal_init(void)
 {
     assert(!m_initialize);

     m_continuous = false;
     m_in_timeslot = false;

     m_config.lf_clk_accuracy_ppm  = NRF_RAAL_DEFAULT_LF_CLK_ACCURACY_PPM;
     m_config.timeslot_length      = NRF_RAAL_TIMESLOT_DEFAULT_LENGTH;
     m_config.timeslot_alloc_iters = NRF_RAAL_TIMESLOT_DEFAULT_ALLOC_ITERS;
     m_config.timeslot_safe_margin = NRF_RAAL_TIMESLOT_DEFAULT_SAFE_MARGIN;
     m_config.timeslot_max_length  = NRF_RAAL_TIMESLOT_DEFAULT_MAX_LENGTH;
     m_config.timeslot_timeout     = NRF_RAAL_TIMESLOT_DEFAULT_TIMEOUT;

     assert(sd_radio_session_open(signal_handler) == NRF_SUCCESS);

     m_initialize = true;
 }

 void nrf_raal_uninit(void)
 {
     assert(m_initialize);
     assert(sd_radio_session_close() == NRF_SUCCESS);

     m_continuous  = false;
     m_in_timeslot = false;

     nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
 }

 void nrf_raal_continuous_mode_enter(void)
 {
     nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CONTINUOUS_ENTER);

     assert(m_initialize);
     assert(!m_continuous);

     m_alloc_iters     = 0;
     m_timeslot_length = m_config.timeslot_length;
     m_continuous      = true;

     nrf_drv_clock_hfclk_request(NULL);

     if (NRF_CLOCK->HFCLKSTAT == (CLOCK_HFCLKSTAT_SRC_Msk | CLOCK_HFCLKSTAT_STATE_Msk))
     {
         timeslot_request();
     }

     nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CONTINUOUS_ENTER);
 }

 void nrf_raal_continuous_mode_exit(void)
 {
     nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CONTINUOUS_EXIT);

     assert(m_initialize);
     assert(m_continuous);

     m_continuous = false;

     // Emulate signal interrupt to inform SD about end of m_continuous mode.
     if (m_in_timeslot)
     {
         NVIC_SetPendingIRQ(TIMER0_IRQn);
     }

     nrf_drv_clock_hfclk_release();

     nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CONTINUOUS_EXIT);
 }

 bool nrf_raal_timeslot_request(uint32_t length_us)
 {
     if (!m_continuous || !m_in_timeslot)
     {
         return false;
     }

     return timer_time_get() + length_us < NRF_TIMER0->CC[TIMER_CC_MARGIN];
 }

 uint32_t nrf_raal_timeslot_us_left_get(void)
 {
     if (!m_continuous || !m_in_timeslot)
     {
         return 0;
     }

     return NRF_TIMER0->CC[TIMER_CC_MARGIN] - timer_time_get();
 }

 void nrf_raal_critical_section_enter(void)
 {
     nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CRIT_SECT_ENTER);

     assert(!m_in_critical_section);
     m_in_critical_section = true;

     nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CRIT_SECT_ENTER);
 }

 void nrf_raal_critical_section_exit(void)
 {
     nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CRIT_SECT_EXIT);

     timeslot_critical_section_enter();

     assert(m_in_critical_section);
     m_in_critical_section = false;

     switch (m_pending_event)
     {
     case PENDING_EVENT_STARTED:
         timeslot_started_notify();
         break;

     case PENDING_EVENT_ENDED:
         timeslot_ended_notify();
         break;

     default:
         break;
     }

     m_pending_event = PENDING_EVENT_NONE;

     timeslot_critical_section_exit();

     nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CRIT_SECT_EXIT);
 }
	/* Copyright (c) 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 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.
	*
	* 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 EVENT SHALL THE COPYRIGHT HOLDER 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
	* This file implements the nrf 802.15.4 radio arbiter for softdevice.
	*
	* This arbiter should be used when 802.15.4 works concurrently with SoftDevice's radio stack.
	*
	*/

	#include "nrf_raal_softdevice.h"

	#include <assert.h>
	#include <stdbool.h>
	#include <string.h>

	#include <nrf_raal_api.h>
	#include <nrf_drv_radio802154_debug.h>
	#include <nrf_drv_clock.h>
	#include <softdevice.h>

	/*@brief Enable Request and End on timeslot safety interrupt. /
	#define ENABLE_REQUEST_AND_END_ON_TIMESLOT_END 0

	/*@brief Maximum jitter relative to the start time of START and TIMER0 (safety margin) events . /
	#define TIMER_TO_SIGNAL_JITTER_US NRF_RADIO_START_JITTER_US + 6

	/*@brief Timer compare channel definitions. /
	#define TIMER_CC_EXTEND 0
	#define TIMER_CC_EXTEND_INTENSET TIMER_INTENSET_COMPARE0_Msk
	#define TIMER_CC_EXTEND_INTENCLR TIMER_INTENCLR_COMPARE0_Pos

	#define TIMER_CC_MARGIN 1
	#define TIMER_CC_MARGIN_INTENSET TIMER_INTENSET_COMPARE1_Msk
	#define TIMER_CC_MARGIN_INTENCLR TIMER_INTENCLR_COMPARE1_Pos

	#define TIMER_CC_CAPTURE 2

	/*@brief Defines number of microseconds in one second. /
	#define US_PER_S 1000000

	/*@brief Ceil division helper /
	#define DIVIDE_AND_CEIL(A, B) (((A) + (B) - 1) / (B))

	/*@brief Defines pending events. /
	typedef enum
	{
	PENDING_EVENT_NONE = 0,
	PENDING_EVENT_STARTED,
	PENDING_EVENT_ENDED
	} pending_events_t;

	/*@brief Request parameters. /
	static nrf_radio_request_t m_request;

	/*@brief Return parameter for SD radio signal handler. /
	static nrf_radio_signal_callback_return_param_t m_ret_param;

	/*@brief Current configuration of the RAAL. /
	static nrf_raal_softdevice_cfg_t m_config;

	/*@brief Current timeslot length. /
	static uint16_t m_timeslot_length;

	/*@brief Defines if RAAL is in continous mode. /
	static volatile bool m_continuous = false;

	/*@brief Defines if RAAL is currently in a timeslot. /
	static volatile bool m_in_timeslot = false;

	/*@brief Current iteration process number. /
	static volatile uint16_t m_alloc_iters;

	/*@brief Defines if module has been initialized. /
	static bool m_initialize = false;

	/*@breif Defines if Radio Driver entered critical section. /
	static volatile bool m_in_critical_section = false;

	/*@brief Defines current pending event. /
	static volatile pending_events_t m_pending_event = PENDING_EVENT_NONE;

	/*@brief Defines RTC0 counter value on timeslot begin. /
	static uint32_t m_start_rtc_ticks = 0;

	/*@brief External Interrupt from RADIO. /
	extern void RADIO_IRQHandler(void);

	/*@brief Initialize timeslot internal variables. /
	static inline void timeslot_data_init(void)
	{
	m_alloc_iters = 0;
	m_timeslot_length = m_config.timeslot_length;
	}

	/*@brief Get actual time. /
	static inline uint32_t timer_time_get(void)
	{
	NRF_TIMER0->TASKS_CAPTURE[TIMER_CC_CAPTURE] = 1;
	return NRF_TIMER0->CC[TIMER_CC_CAPTURE];
	}

	/*@brief Check if margin is already reached. /
	static inline bool timer_is_margin_reached(void)
	{
	return NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN];
	}

	/*@brief Enter timeslot critical section. /
	static inline void timeslot_critical_section_enter(void)
	{
	NVIC_DisableIRQ(TIMER0_IRQn);
	__DSB();
	__ISB();
	}

	/*@brief Exit timeslot critical section. /
	static inline void timeslot_critical_section_exit(void)
	{
	NVIC_EnableIRQ(TIMER0_IRQn);
	}

	static inline void timeslot_started_notify(void)
	{
	if (m_in_timeslot && m_continuous)
	{
	nrf_raal_timeslot_started();
	}
	}

	static inline void timeslot_ended_notify(void)
	{
	if (!m_in_timeslot && m_continuous)
	{
	nrf_raal_timeslot_ended();
	}
	}

	/*@brief Calculate maximal crystal drift. /
	static inline uint32_t rtc_drift_calculate(uint32_t timeslot_length)
	{
	return DIVIDE_AND_CEIL(((uint64_t)timeslot_length * m_config.lf_clk_accuracy_ppm), US_PER_S);
	}

	/*@brief Prepare earliest timeslot request. /
	static void timeslot_request_prepare(void)
	{
	memset(&m_request, 0, sizeof(m_request));
	m_request.request_type = NRF_RADIO_REQ_TYPE_EARLIEST;
	m_request.params.earliest.hfclk = NRF_RADIO_HFCLK_CFG_NO_GUARANTEE;
	m_request.params.earliest.priority = NRF_RADIO_PRIORITY_NORMAL;
	m_request.params.earliest.length_us = m_timeslot_length;
	m_request.params.earliest.timeout_us = m_config.timeslot_timeout;
	}

	/*@brief Request earliest timeslot. /
	static void timeslot_request(void)
	{
	assert(!m_in_timeslot);

	timeslot_request_prepare();
	sd_radio_request(&m_request);
	}

	/*@brief Set timer on timeslot started. /
	static void timer_start(void)
	{
	NRF_TIMER0->TASKS_STOP = 1;
	NRF_TIMER0->TASKS_CLEAR = 1;
	NRF_TIMER0->BITMODE = TIMER_BITMODE_BITMODE_32Bit;
	NRF_TIMER0->INTENSET = TIMER_CC_MARGIN_INTENSET;
	NRF_TIMER0->CC[TIMER_CC_EXTEND] = 0;
	NRF_TIMER0->CC[TIMER_CC_MARGIN] = m_timeslot_length - m_config.timeslot_safe_margin;
	NRF_TIMER0->TASKS_START = 1;

	NVIC_EnableIRQ(TIMER0_IRQn);
	}

	/*@brief Reset timer. /
	static void timer_reset(void)
	{
	NRF_TIMER0->TASKS_STOP = 1;
	NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND] = 0;
	NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN] = 0;
	NVIC_ClearPendingIRQ(TIMER0_IRQn);
	}

	/*@brief Set timer on extend event. /
	static void timer_extend(void)
	{
	NVIC_ClearPendingIRQ(TIMER0_IRQn);

	NRF_TIMER0->INTENSET = TIMER_CC_MARGIN_INTENSET;
	NRF_TIMER0->CC[TIMER_CC_MARGIN] += m_timeslot_length;

	if (!m_alloc_iters)
	{
	NRF_TIMER0->INTENSET = TIMER_CC_EXTEND_INTENSET;
	NRF_TIMER0->CC[TIMER_CC_EXTEND] += m_timeslot_length;
	}
	}

	/*@brief Eliminate timers jitters. /
	static void timer_jitter_adjust(void)
	{
	// Adjust TIMER0 and RTC0 clocks drifts.
	uint32_t timer_ticks = timer_time_get();
	uint64_t rtc_ticks = NRF_RTC0->COUNTER;

	if (rtc_ticks > m_start_rtc_ticks)
	{
	rtc_ticks -= m_start_rtc_ticks;
	}
	else
	{
	// Overflow detected.
	rtc_ticks = RTC_COUNTER_COUNTER_Msk - m_start_rtc_ticks + rtc_ticks;
	}

	// Adjust RTC0 ticks to TIMER0 resolution. RTC0 works with 32768kHz so first
	// multiply with 10^6 (microseconds) and divide by 32768Hz (2^15) to get microseconds.
	rtc_ticks = DIVIDE_AND_CEIL((rtc_ticks * US_PER_S), 32768);

	// Check if we are still in time.
	uint32_t cc_margin = NRF_TIMER0->CC[TIMER_CC_MARGIN];
	assert(cc_margin > rtc_ticks + rtc_drift_calculate(cc_margin));

	if (rtc_ticks > timer_ticks)
	{
	NRF_TIMER0->CC[TIMER_CC_MARGIN] -= (rtc_ticks - timer_ticks);
	}
	else
	{
	NRF_TIMER0->CC[TIMER_CC_MARGIN] += (timer_ticks - rtc_ticks);
	}

	// Add safety drift time.
	NRF_TIMER0->CC[TIMER_CC_MARGIN] -= rtc_drift_calculate(2 * m_config.timeslot_length) +
	TIMER_TO_SIGNAL_JITTER_US;
	}

	/*@brief Decrease timeslot length. /
	static void timeslot_decrease_length(void)
	{
	m_alloc_iters++;
	m_timeslot_length = m_timeslot_length >> 1;
	}

	/*@brief Extend timeslot. /
	static void timeslot_extend(void)
	{
	if (m_alloc_iters < m_config.timeslot_alloc_iters)
	{
	timeslot_decrease_length();

	// Try to extend right after start.
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
	m_ret_param.params.extend.length_us = m_timeslot_length;

	nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);
	}
	else
	{
	timer_jitter_adjust();
	}
	}

	static void timer_irq_handle(void)
	{
	// Safe margin exceeded.
	if (NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_MARGIN])
	{
	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_MARGIN);

	m_in_timeslot = false;

	if (m_in_critical_section)
	{
	assert(m_pending_event != PENDING_EVENT_ENDED);

	if (m_pending_event == PENDING_EVENT_STARTED)
	{
	m_pending_event = PENDING_EVENT_NONE;
	}
	else
	{
	m_pending_event = PENDING_EVENT_ENDED;
	}
	}
	else
	{
	timeslot_ended_notify();
	}

	// Ignore any other events.
	timer_reset();

	#if (ENABLE_REQUEST_AND_END_ON_TIMESLOT_END == 1)
	timeslot_data_init();
	timeslot_request_prepare();
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_REQUEST_AND_END;
	m_ret_param.params.request.p_next = &m_request;
	#else
	// Return and wait for NRF_EVT_RADIO_SESSION_IDLE event.
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
	#endif

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_MARGIN);
	}

	// Extension margin exceeded.
	else if (NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND])
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXTEND);

	NRF_TIMER0->INTENCLR = (1 << TIMER_CC_EXTEND_INTENCLR);
	NRF_TIMER0->EVENTS_COMPARE[TIMER_CC_EXTEND] = 0;

	if (m_continuous &&
	NRF_TIMER0->CC[TIMER_CC_EXTEND] + m_config.timeslot_length < m_config.timeslot_max_length)
	{
	nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);

	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
	m_ret_param.params.extend.length_us = m_config.timeslot_length;
	}
	else
	{
	timer_jitter_adjust();

	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
	}

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXTEND);
	}
	else
	{
	// Should not happen.
	assert(false);
	}
	}

	/*@brief Signal handler. /
	static nrf_radio_signal_callback_return_param_t *signal_handler(uint8_t signal_type)
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_HANDLER);

	// Default response.
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;

	if (!m_continuous)
	{
	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_ENDED);

	m_pending_event = PENDING_EVENT_NONE;
	m_in_timeslot = false;

	// TODO: Change to NRF_RADIO_SIGNAL_CALLBACK_ACTION_END (KRKNWK-937)
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
	timer_reset();

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_ENDED);
	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_HANDLER);
	return &m_ret_param;
	}

	switch (signal_type)
	{
	case NRF_RADIO_CALLBACK_SIGNAL_TYPE_START: /*< This signal indicates the start of the radio timeslot. /
	{
	nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_ACTIVE);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_START);

	// Ensure HFCLK is running before start is issued.
	assert(NRF_CLOCK->HFCLKSTAT == (CLOCK_HFCLKSTAT_SRC_Msk \| CLOCK_HFCLKSTAT_STATE_Msk));

	m_start_rtc_ticks = NRF_RTC0->COUNTER;
	m_in_timeslot = true;
	m_alloc_iters = 0;
	m_timeslot_length = m_timeslot_length;

	timer_start();

	if (m_in_critical_section)
	{
	assert(m_pending_event != PENDING_EVENT_STARTED);

	if (m_pending_event == PENDING_EVENT_ENDED)
	{
	m_pending_event = PENDING_EVENT_NONE;
	}
	else
	{
	m_pending_event = PENDING_EVENT_STARTED;
	}
	}
	else
	{
	timeslot_started_notify();
	}

	// Try to extend right after start.
	m_ret_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
	m_ret_param.params.extend.length_us = m_timeslot_length;

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_START);
	nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_EXTEND_REQ);
	break;
	}

	case NRF_RADIO_CALLBACK_SIGNAL_TYPE_TIMER0: /*< This signal indicates the NRF_TIMER0 interrupt. /
	timer_irq_handle();
	break;

	case NRF_RADIO_CALLBACK_SIGNAL_TYPE_RADIO: /*< This signal indicates the NRF_RADIO interrupt. /
	nrf_drv_radio802154_pin_set(PIN_DBG_TIMESLOT_RADIO_IRQ);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_RADIO);

	if (m_in_timeslot)
	{
	if (!timer_is_margin_reached())
	{
	RADIO_IRQHandler();
	}
	else
	{
	// Handle margin exceeded event.
	timer_irq_handle();
	}
	}

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_RADIO);
	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_RADIO_IRQ);
	break;

	case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_FAILED: /*< This signal indicates extend action failed. /
	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_EXTEND_REQ);
	nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_FAILED);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXCEED_FAIL);

	timeslot_extend();

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXCEED_FAIL);
	break;

	case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_SUCCEEDED: /*< This signal indicates extend action succeeded. /
	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_EXTEND_REQ);
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_SIG_EVENT_EXCEED_SUCCESS);

	timer_extend();

	if (m_alloc_iters != 0)
	{
	timeslot_extend();
	}

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_EVENT_EXCEED_SUCCESS);
	break;

	default:
	break;
	}

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_SIG_HANDLER);

	return &m_ret_param;
	}

	void nrf_raal_softdevice_soc_evt_handler(uint32_t evt_id)
	{
	switch (evt_id)
	{
	case NRF_EVT_HFCLKSTARTED:
	if (m_continuous)
	{
	timeslot_request();
	}

	break;

	case NRF_EVT_RADIO_BLOCKED:
	case NRF_EVT_RADIO_CANCELED:
	{
	nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_BLOCKED);

	assert(!m_in_timeslot);

	if (m_continuous)
	{
	if (m_alloc_iters < m_config.timeslot_alloc_iters)
	{
	timeslot_decrease_length();
	}

	timeslot_request();
	}

	break;
	}

	case NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN:
	assert(false);
	break;

	case NRF_EVT_RADIO_SESSION_IDLE:
	if (m_continuous)
	{
	nrf_drv_radio802154_pin_tgl(PIN_DBG_TIMESLOT_SESSION_IDLE);

	timeslot_data_init();
	timeslot_request();
	}

	break;

	case NRF_EVT_RADIO_SESSION_CLOSED:
	break;

	default:
	break;
	}
	}

	void nrf_raal_softdevice_config(const nrf_raal_softdevice_cfg_t * p_cfg)
	{
	assert(m_initialize);
	assert(!m_continuous);
	assert(p_cfg);

	m_config = *p_cfg;
	}

	void nrf_raal_init(void)
	{
	assert(!m_initialize);

	m_continuous = false;
	m_in_timeslot = false;

	m_config.lf_clk_accuracy_ppm = NRF_RAAL_DEFAULT_LF_CLK_ACCURACY_PPM;
	m_config.timeslot_length = NRF_RAAL_TIMESLOT_DEFAULT_LENGTH;
	m_config.timeslot_alloc_iters = NRF_RAAL_TIMESLOT_DEFAULT_ALLOC_ITERS;
	m_config.timeslot_safe_margin = NRF_RAAL_TIMESLOT_DEFAULT_SAFE_MARGIN;
	m_config.timeslot_max_length = NRF_RAAL_TIMESLOT_DEFAULT_MAX_LENGTH;
	m_config.timeslot_timeout = NRF_RAAL_TIMESLOT_DEFAULT_TIMEOUT;

	assert(sd_radio_session_open(signal_handler) == NRF_SUCCESS);

	m_initialize = true;
	}

	void nrf_raal_uninit(void)
	{
	assert(m_initialize);
	assert(sd_radio_session_close() == NRF_SUCCESS);

	m_continuous = false;
	m_in_timeslot = false;

	nrf_drv_radio802154_pin_clr(PIN_DBG_TIMESLOT_ACTIVE);
	}

	void nrf_raal_continuous_mode_enter(void)
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CONTINUOUS_ENTER);

	assert(m_initialize);
	assert(!m_continuous);

	m_alloc_iters = 0;
	m_timeslot_length = m_config.timeslot_length;
	m_continuous = true;

	nrf_drv_clock_hfclk_request(NULL);

	if (NRF_CLOCK->HFCLKSTAT == (CLOCK_HFCLKSTAT_SRC_Msk \| CLOCK_HFCLKSTAT_STATE_Msk))
	{
	timeslot_request();
	}

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CONTINUOUS_ENTER);
	}

	void nrf_raal_continuous_mode_exit(void)
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CONTINUOUS_EXIT);

	assert(m_initialize);
	assert(m_continuous);

	m_continuous = false;

	// Emulate signal interrupt to inform SD about end of m_continuous mode.
	if (m_in_timeslot)
	{
	NVIC_SetPendingIRQ(TIMER0_IRQn);
	}

	nrf_drv_clock_hfclk_release();

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CONTINUOUS_EXIT);
	}

	bool nrf_raal_timeslot_request(uint32_t length_us)
	{
	if (!m_continuous \|\| !m_in_timeslot)
	{
	return false;
	}

	return timer_time_get() + length_us < NRF_TIMER0->CC[TIMER_CC_MARGIN];
	}

	uint32_t nrf_raal_timeslot_us_left_get(void)
	{
	if (!m_continuous \|\| !m_in_timeslot)
	{
	return 0;
	}

	return NRF_TIMER0->CC[TIMER_CC_MARGIN] - timer_time_get();
	}

	void nrf_raal_critical_section_enter(void)
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CRIT_SECT_ENTER);

	assert(!m_in_critical_section);
	m_in_critical_section = true;

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CRIT_SECT_ENTER);
	}

	void nrf_raal_critical_section_exit(void)
	{
	nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_RAAL_CRIT_SECT_EXIT);

	timeslot_critical_section_enter();

	assert(m_in_critical_section);
	m_in_critical_section = false;

	switch (m_pending_event)
	{
	case PENDING_EVENT_STARTED:
	timeslot_started_notify();
	break;

	case PENDING_EVENT_ENDED:
	timeslot_ended_notify();
	break;

	default:
	break;
	}

	m_pending_event = PENDING_EVENT_NONE;

	timeslot_critical_section_exit();

	nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_RAAL_CRIT_SECT_EXIT);
	}