/* 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 Finite State Machine of nRF 802.15.4 radio driver.
 *
 */

#include "nrf_drv_radio802154_fsm.h"

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

#include "nrf_drv_radio802154.h"
#include "nrf_drv_radio802154_ack_pending_bit.h"
#include "nrf_drv_radio802154_config.h"
#include "nrf_drv_radio802154_const.h"
#include "nrf_drv_radio802154_debug.h"
#include "nrf_drv_radio802154_notification.h"
#include "nrf_drv_radio802154_pib.h"
#include "nrf_drv_radio802154_priority_drop.h"
#include "nrf_drv_radio802154_procedures_duration.h"
#include "nrf_drv_radio802154_rx_buffer.h"
#include "hal/nrf_radio.h"
#include "raal/nrf_raal_api.h"

/// Value set to SHORTS register when no shorts should be enabled.
#define SHORTS_IDLE         0
/// Value set to SHORTS register when receiver is waiting for incoming frame.
#define SHORTS_RX_INITIAL   (NRF_RADIO_SHORT_END_DISABLE_MASK | NRF_RADIO_SHORT_DISABLED_TXEN_MASK | \
                             NRF_RADIO_SHORT_FRAMESTART_BCSTART_MASK)
/// Value set to SHORTS register when receiver started receiving a frame.
#define SHORTS_RX_FOLLOWING (NRF_RADIO_SHORT_END_DISABLE_MASK | NRF_RADIO_SHORT_READY_START_MASK | \
                             NRF_RADIO_SHORT_FRAMESTART_BCSTART_MASK)
/// Value set to SHORTS register when received frame should be acknowledged.
#define SHORTS_TX_ACK       (NRF_RADIO_SHORT_END_DISABLE_MASK)
#if RADIO_SHORT_CCAIDLE_TXEN
/// Value set to SHORTS register during transmission of a frame
#define SHORTS_TX_FRAME     (NRF_RADIO_SHORT_END_DISABLE_MASK | NRF_RADIO_SHORT_READY_START_MASK | \
                             NRF_RADIO_SHORT_CCAIDLE_TXEN_MASK)
#else
/// Value set to SHORTS register during transmission of a frame
#define SHORTS_TX_FRAME     (NRF_RADIO_SHORT_END_DISABLE_MASK | NRF_RADIO_SHORT_READY_START_MASK)
#endif

/// Delay before sending ACK (12sym = 192uS)
#define TIFS_ACK_US         192
/// Delay before first check of received frame: 16 bits is MAC Frame Control field.
#define BCC_INIT            (2 * 8)
/// Delay before second check of received frame if destination address is short.
#define BCC_SHORT_ADDR      ((DEST_ADDR_OFFSET + SHORT_ADDRESS_SIZE) * 8)
/// Delay before second check of received frame if destination address is extended.
#define BCC_EXTENDED_ADDR   ((DEST_ADDR_OFFSET + EXTENDED_ADDRESS_SIZE) * 8)

/// Duration of single iteration of Energy Detection procedure
#define ED_ITER_DURATION   128U
/// Overhead of hardware preparation for ED procedure (aTurnaroundTime) [number of iterations]
#define ED_ITERS_OVERHEAD  2U

#define CRC_LENGTH      2         ///< Length of CRC in 802.15.4 frames [bytes]
#define CRC_POLYNOMIAL  0x011021  ///< Polynomial used for CRC calculation in 802.15.4 frames

#define MHMU_MASK               0xff000700  ///< Mask of known bytes in ACK packet
#define MHMU_PATTERN            0x00000200  ///< Values of known bytes in ACK packet
#define MHMU_PATTERN_DSN_OFFSET 24          ///< Offset of DSN in MHMU_PATTER [bits]

/** Get LQI of given received packet. If CRC is calculated by hardware LQI is included instead of CRC
 *  in the frame. Length is stored in byte with index 0; CRC is 2 last bytes.
 */
#define RX_FRAME_LQI(psdu)  ((psdu)[(psdu)[0] - 1])

#if RADIO_RX_BUFFERS > 1
/// Pointer to currently used receive buffer.
static rx_buffer_t * mp_current_rx_buffer;
#else
/// If there is only one buffer use const pointer to the receive buffer.
static rx_buffer_t * const mp_current_rx_buffer = &nrf_drv_radio802154_rx_buffers[0];
#endif

#if defined ( __GNUC__ )

/// Ack frame buffer (EasyDMA cannot address whole RAM. Place buffer in the special section.)
static uint8_t m_ack_psdu[ACK_LENGTH + 1]
                __attribute__ ((section ("nrf_radio_buffer.m_ack_psdu")));

#elif defined ( __ICCARM__ )

#pragma location="NRF_RADIO_BUFFER"
static uint8_t m_ack_psdu[ACK_LENGTH + 1];

#endif

static const uint8_t * mp_tx_data;      ///< Pointer to data to transmit.
static uint32_t        m_ed_time_left;  ///< Remaining time of current energy detection procedure [us].
static uint8_t         m_ed_result;     ///< Result of current energy detection procedure.

static volatile radio_state_t m_state = RADIO_STATE_SLEEP;  ///< State of the radio driver

typedef struct
{
    bool prevent_ack :1;  ///< If frame being received is not destined to this node (promiscuous mode).
} nrf_radio802154_flags_t;
static nrf_radio802154_flags_t m_flags;  ///< Flags used to store current driver state.

static volatile uint8_t m_mutex;  ///< Mutex preventing race condition.


/***************************************************************************************************
 * @section Mutex
 **************************************************************************************************/

/// Lock mutex to prevent race conditions.
static bool mutex_lock(void)
{
    do
    {
        volatile uint8_t mutex_value = __LDREXB(&m_mutex);

        if (mutex_value)
        {
            return false;
        }
    }
    while (__STREXB(1, &m_mutex));

    __DMB();

    // Driver may be in WAITING_TIMESLOT state if timeslot ended during mutex locking.
    assert(m_state == RADIO_STATE_WAITING_RX_FRAME ||
           m_state == RADIO_STATE_SLEEP ||
           m_state == RADIO_STATE_WAITING_TIMESLOT);

    nrf_drv_radio802154_log(EVENT_MUTEX_LOCK, 0);

    return true;
}

/// Unlock mutex.
static void mutex_unlock(void)
{
    assert(m_state == RADIO_STATE_SLEEP ||
           m_state == RADIO_STATE_WAITING_RX_FRAME);

    nrf_drv_radio802154_log(EVENT_MUTEX_UNLOCK, 0);

    __DMB();
    m_mutex = 0;
}


/***************************************************************************************************
 * @section FSM common operations
 **************************************************************************************************/

/** Set driver state.
 *
 * @param[in]  state  Driver state to set.
 */
static inline void state_set(radio_state_t state)
{
    m_state = state;

    nrf_drv_radio802154_log(EVENT_SET_STATE, (uint32_t)state);
}

/// Common procedure when the driver enters SLEEP state.
static inline void sleep_start(void)
{
    state_set(RADIO_STATE_SLEEP);
    nrf_drv_radio802154_priority_drop_timeslot_exit();
    mutex_unlock();
}

/// Start receiver to wait for frames.
static inline void rx_start(void)
{
    nrf_radio_packet_ptr_set(mp_current_rx_buffer->psdu);
    nrf_radio_task_trigger(NRF_RADIO_TASK_START);
}

/// Start receiver to wait for frame that can be acknowledged.
static inline void rx_frame_start(void)
{
    rx_start();

    // Just after starting receiving to receive buffer set packet pointer to ACK frame that can be
    // sent automatically.
    nrf_radio_packet_ptr_set(m_ack_psdu);
}

/** Get result of last RSSI measurement.
 *
 * @returns  Result of last RSSI measurement [dBm].
 */
static inline int8_t rssi_last_measurement_get(void)
{
    return -((int8_t)nrf_radio_rssi_sample_get());
}

/// Notify MAC layer that a frame was received.
static inline void received_frame_notify(void)
{
    mp_current_rx_buffer->free = false;
    nrf_drv_radio802154_notify_received(mp_current_rx_buffer->psdu,                // data
                                        rssi_last_measurement_get(),               // rssi
                                        RX_FRAME_LQI(mp_current_rx_buffer->psdu)); // lqi
}

/** Set currently used rx buffer to given address.
 *
 * @param[in]  p_rx_buffer  Pointer to receive buffer that should be used now.
 */
static inline void rx_buffer_in_use_set(rx_buffer_t * p_rx_buffer)
{
#if RADIO_RX_BUFFERS > 1
    mp_current_rx_buffer = p_rx_buffer;
#else
    (void) p_rx_buffer;
#endif
}


/***************************************************************************************************
 * @section Radio parameters calculators
 **************************************************************************************************/

/** Set radio channel
 *
 *  @param[in]  channel  Channel number to set (11-26).
 */
static void channel_set(uint8_t channel)
{
    assert(channel >= 11 && channel <= 26);

    nrf_radio_frequency_set(5 + (5 * (channel - 11)));
}

/** Get radio channel.
 *
 * @returns  Currently set channel number.
 */
static uint8_t channel_get(void)
{
    return ((nrf_radio_frequency_get() - 5) / 5) + 11;
}

/** Set transmit power.
 *
 * @param[in]  dbm  Transmit power to set [dbm].
 */
static void tx_power_set(int8_t dbm)
{
    const int8_t allowed_values[] = {-40, -20, -16, -12, -8, -4, 0, 2, 3, 4, 5, 6, 7, 8, 9};
    const int8_t highest_value    = allowed_values[(sizeof(allowed_values) / sizeof(allowed_values[0])) - 1];
    if (dbm > highest_value)
    {
        dbm = highest_value;
    }
    else
    {
        for (uint32_t i = 0; i < sizeof(allowed_values) / sizeof(allowed_values[0]); i++)
        {
            if (dbm <= allowed_values[i])
            {
                dbm = allowed_values[i];
                break;
            }
        }
    }

    nrf_radio_tx_power_set(dbm);
}


/***************************************************************************************************
 * @section Shorts management
 **************************************************************************************************/

/// Disable peripheral shorts.
static inline void shorts_disable(void)
{
    nrf_radio_shorts_set(SHORTS_IDLE);
    nrf_radio_ifs_set(0);
}

/// Enable peripheral shorts used during data frame transmission.
static inline void shorts_tx_frame_set(void)
{
    nrf_radio_shorts_set(SHORTS_TX_FRAME);
}

/// Enable peripheral shorts used in receive state to enable automatic ACK procedure.
static inline void shorts_rx_initial_set(void)
{
    nrf_radio_ifs_set(TIFS_ACK_US);
    nrf_radio_bcc_set(BCC_INIT);

    nrf_radio_shorts_set(SHORTS_RX_INITIAL);
}

/// Enable peripheral shorts used during automatic ACK transmission.
static inline void shorts_rx_following_set(void)
{
    nrf_radio_shorts_set(SHORTS_RX_FOLLOWING);
}

/// Disable peripheral shorts used during automatic ACK transmission when ACK is being transmitted
static inline void shorts_tx_ack_set(void)
{
    // If ACK is sent END_DISABLE short should persist to disable transmitter automatically.
    nrf_radio_shorts_set(SHORTS_TX_ACK);
    nrf_radio_ifs_set(0);
}


/***************************************************************************************************
 * @section ACK transmission management
 **************************************************************************************************/

/// Set valid sequence number in ACK frame.
static inline void ack_prepare(void)
{
    // Copy sequence number from received frame to ACK frame.
    m_ack_psdu[DSN_OFFSET] = mp_current_rx_buffer->psdu[DSN_OFFSET];
}

/// Set pending bit in ACK frame.
static inline void ack_pending_bit_set(void)
{
    m_ack_psdu[FRAME_PENDING_OFFSET] = ACK_HEADER_WITH_PENDING;

    if (!nrf_drv_radio802154_ack_pending_bit_should_be_set(mp_current_rx_buffer->psdu))
    {
        m_ack_psdu[FRAME_PENDING_OFFSET] = ACK_HEADER_WITHOUT_PENDING;
    }
}

/** Check if ACK is requested in given frame.
 *
 * @param[in]  p_frame  Pointer to a frame to check.
 *
 * @retval  true   ACK is requested in given frame.
 * @retval  false  ACK is not requested in given frame.
 */
static inline bool ack_is_requested(const uint8_t * p_frame)
{
    return (p_frame[ACK_REQUEST_OFFSET] & ACK_REQUEST_BIT) ? true : false;
}

/** Abort automatic ACK procedure.
 *
 * @param[in]  state_to_set  Driver state that shall be set after the procedure is aborted.
 */
static void auto_ack_abort(radio_state_t state_to_set)
{
    nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_AUTO_ACK_ABORT);

    shorts_disable();

    switch (nrf_radio_state_get())
    {
        case NRF_RADIO_STATE_RX:     // When stopping before whole frame received.
        case NRF_RADIO_STATE_RX_RU:  // When transmission is initialized during receiver ramp up.
        case NRF_RADIO_STATE_RX_IDLE:
        case NRF_RADIO_STATE_TX_RU:
        case NRF_RADIO_STATE_TX_IDLE:
        case NRF_RADIO_STATE_TX:
            nrf_radio_event_clear(NRF_RADIO_EVENT_DISABLED); // Clear disabled event that was set by short.
            state_set(state_to_set);
            nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
            break;

        case NRF_RADIO_STATE_RX_DISABLE:
        case NRF_RADIO_STATE_DISABLED:
            // Do not trigger DISABLE task in those states to prevent double DISABLED events.
            state_set(state_to_set);
            break;

        default:
            assert(false);
    }

    nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_AUTO_ACK_ABORT);
}

/***************************************************************************************************
 * @section ACK receiving management
 **************************************************************************************************/

/// Enable hardware ACK matching accelerator.
static inline void ack_matching_enable(void)
{
    nrf_radio_event_clear(NRF_RADIO_EVENT_MHRMATCH);
    nrf_radio_mhmu_search_pattern_set(MHMU_PATTERN |
                                      ((uint32_t) mp_tx_data[DSN_OFFSET] <<
                                       MHMU_PATTERN_DSN_OFFSET));
}

/// Disable hardware ACK matching accelerator.
static inline void ack_matching_disable(void)
{
    nrf_radio_mhmu_search_pattern_set(0);
    nrf_radio_event_clear(NRF_RADIO_EVENT_MHRMATCH);
}

/** Check if hardware ACK matching accelerator matched ACK pattern in received frame.
 *
 * @retval  true   ACK matching accelerator matched ACK pattern.
 * @retval  false  ACK matching accelerator did not match ACK pattern.
 */
static inline bool ack_is_matched(void)
{
    return (nrf_radio_event_get(NRF_RADIO_EVENT_MHRMATCH)) &&
            (nrf_radio_crc_status_get() == NRF_RADIO_CRC_STATUS_OK);
}

/// Start receiver to receive data after receiving of ACK frame.
static inline void frame_rx_start_after_ack_rx(void)
{
    ack_matching_disable();
    state_set(RADIO_STATE_WAITING_RX_FRAME);
    nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE); // Errata [110]
}

/***************************************************************************************************
 * @section RADIO peripheral management
 **************************************************************************************************/

/// Initialize radio peripheral
static void nrf_radio_init(void)
{
    nrf_radio_mode_set(NRF_RADIO_MODE_IEEE802154_250KBIT);
    nrf_radio_config_length_field_length_set(8);
    nrf_radio_config_preamble_length_set(NRF_RADIO_PREAMBLE_LENGTH_32BIT_ZERO);
    nrf_radio_config_crc_included_set(true);
    nrf_radio_config_max_length_set(MAX_PACKET_SIZE);

    // Configure CRC
    nrf_radio_crc_length_set(CRC_LENGTH);
    nrf_radio_crc_includes_address_set(NRF_RADIO_CRC_INCLUDES_ADDR_IEEE802154);
    nrf_radio_crc_polynominal_set(CRC_POLYNOMIAL);

    // Configure CCA
    nrf_radio_cca_mode_set(RADIO_CCA_MODE);
    nrf_radio_cca_ed_threshold_set(RADIO_CCA_ED_THRESHOLD);
    nrf_radio_cca_corr_threshold_set(RADIO_CCA_CORR_THRESHOLD);
    nrf_radio_cca_corr_counter_set(RADIO_CCA_CORR_LIMIT);

    // Configure MAC Header Match Unit
    nrf_radio_mhmu_search_pattern_set(0);
    nrf_radio_mhmu_pattern_mask_set(MHMU_MASK);

    nrf_radio_int_enable(NRF_RADIO_INT_FRAMESTART_MASK);
    nrf_radio_int_enable(NRF_RADIO_INT_END_MASK);
    nrf_radio_int_enable(NRF_RADIO_INT_DISABLED_MASK);
#if !RADIO_SHORT_CCAIDLE_TXEN
    nrf_radio_int_enable(NRF_RADIO_INT_CCAIDLE_MASK);
#endif
    nrf_radio_int_enable(NRF_RADIO_INT_CCABUSY_MASK);
    nrf_radio_int_enable(NRF_RADIO_INT_READY_MASK);
    nrf_radio_int_enable(NRF_RADIO_INT_BCMATCH_MASK);
    nrf_radio_int_enable(NRF_RADIO_INT_EDEND_MASK);
}

/// Reset radio peripheral
static void nrf_radio_reset(void)
{
    nrf_radio_power_set(false);
    nrf_radio_power_set(true);

    nrf_drv_radio802154_log(EVENT_RADIO_RESET, 0);
}

/// Initialize interrupts for radio peripheral
static void irq_init(void)
{
    NVIC_SetPriority(RADIO_IRQn, RADIO_IRQ_PRIORITY);
    NVIC_ClearPendingIRQ(RADIO_IRQn);
    NVIC_EnableIRQ(RADIO_IRQn);
}

/// Deinitialize interrupts for radio peripheral
static void irq_deinit(void)
{
    NVIC_DisableIRQ(RADIO_IRQn);
    NVIC_ClearPendingIRQ(RADIO_IRQn);
    NVIC_SetPriority(RADIO_IRQn, 0);

    __DSB();
    __ISB();
}


/***************************************************************************************************
 * @section Energy detection management
 **************************************************************************************************/

/** Setup next iteration of energy detection procedure.
 *
 *  Energy detection procedure is performed in iterations to make sure it is performed for requested
 *  time regardless radio arbitration.
 *
 *  @param[in]  Remaining time of energy detection procedure [us].
 *
 *  @retval  true   Next iteration of energy detection procedure will be performed now.
 *  @retval  false  Next iteration of energy detection procedure will not be performed now due to
 *                  ending timeslot.
 */
static inline bool ed_iter_setup(uint32_t time_us)
{
    uint32_t us_left_in_timeslot = nrf_raal_timeslot_us_left_get();
    uint32_t next_ed_iters       = us_left_in_timeslot / ED_ITER_DURATION;

    if (next_ed_iters > ED_ITERS_OVERHEAD)
    {
        next_ed_iters -= ED_ITERS_OVERHEAD;

        if ((time_us / ED_ITER_DURATION) < next_ed_iters)
        {
            m_ed_time_left = 0;
            next_ed_iters  = time_us / ED_ITER_DURATION;
        }
        else
        {
            m_ed_time_left = time_us - (next_ed_iters * ED_ITER_DURATION);
            next_ed_iters--; // Time of ED procedure is (next_ed_iters + 1) * 128us
        }

        nrf_radio_ed_loop_count_set(next_ed_iters);

        return true;
    }
    else
    {
        irq_deinit();
        nrf_radio_reset();

        m_ed_time_left = time_us;

        return false;
    }
}


/***************************************************************************************************
 * @section RAAL notification handlers
 **************************************************************************************************/

void nrf_raal_timeslot_started(void)
{
    nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_TIMESLOT_STARTED);

    nrf_radio_reset();
    nrf_radio_init();
    irq_init();

    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

    channel_set(nrf_drv_radio802154_pib_channel_get());

    switch (m_state)
    {
        case RADIO_STATE_WAITING_TIMESLOT:
            state_set(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
            break;

        case RADIO_STATE_ED:
            if (ed_iter_setup(m_ed_time_left))
            {
                nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
            }

            break;

        default:
            assert(false);
    }

    nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_TIMESLOT_STARTED);
}

void nrf_raal_timeslot_ended(void)
{
    nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_TIMESLOT_ENDED);

    irq_deinit();
    nrf_radio_reset();

    switch (m_state)
    {
        case RADIO_STATE_CCA:
        case RADIO_STATE_TX_FRAME:
        case RADIO_STATE_RX_ACK:
            nrf_drv_radio802154_notify_busy_channel();
            break;

        default:
            break;
    }

    switch (m_state)
    {
        case RADIO_STATE_DISABLING:
            sleep_start();
            break;

        case RADIO_STATE_SLEEP:
        case RADIO_STATE_WAITING_TIMESLOT:
        case RADIO_STATE_ED:
            // Intentionally empty.
            break;

        case RADIO_STATE_WAITING_RX_FRAME:
        case RADIO_STATE_RX_HEADER:
        case RADIO_STATE_RX_FRAME:
        case RADIO_STATE_TX_ACK:
        case RADIO_STATE_CCA:
        case RADIO_STATE_TX_FRAME:
        case RADIO_STATE_RX_ACK:
            mutex_lock();
            state_set(RADIO_STATE_WAITING_TIMESLOT);
            break;
    }

    nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_TIMESLOT_ENDED);
}


/***************************************************************************************************
 * @section RADIO interrupt handler
 **************************************************************************************************/

/// This event is handled when the radio starts receiving a frame.
static inline void irq_framestart_state_waiting_rx_frame(void)
{
    if (mutex_lock())
    {
        state_set(RADIO_STATE_RX_HEADER);
        assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);

        if ((mp_current_rx_buffer->psdu[0] < ACK_LENGTH) ||
            (mp_current_rx_buffer->psdu[0] > MAX_PACKET_SIZE))
        {
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);
            nrf_radio_event_clear(NRF_RADIO_EVENT_END);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
        }
        else
        {
            nrf_radio_task_trigger(NRF_RADIO_TASK_RSSISTART);

            nrf_drv_radio802154_rx_started();
        }
    }

    switch (nrf_radio_state_get())
    {
        case NRF_RADIO_STATE_RX:

        // If the received frame was short the radio could have changed it's state.
        case NRF_RADIO_STATE_RX_IDLE:

        // The radio could have changed state to one of the following due to enabled shorts.
        case NRF_RADIO_STATE_RX_DISABLE:
        case NRF_RADIO_STATE_DISABLED:
        case NRF_RADIO_STATE_TX_RU:
            break;

        // If something had stopped the CPU too long. Try to recover radio state.
        case NRF_RADIO_STATE_TX_IDLE:
        case NRF_RADIO_STATE_TX_DISABLE:
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);
            nrf_radio_event_clear(NRF_RADIO_EVENT_END);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
            break;

        default:
            assert(false);
    }
}

/// This event is handled when the radio starts receiving an ACK frame.
static inline void irq_framestart_state_rx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

    if ((mp_current_rx_buffer->psdu[0] < ACK_LENGTH) ||
        (mp_current_rx_buffer->psdu[0] > MAX_PACKET_SIZE))
    {
        nrf_drv_radio802154_notify_busy_channel();

        frame_rx_start_after_ack_rx();
        nrf_radio_event_clear(NRF_RADIO_EVENT_END); // In case frame ended before task DISABLE
    }
    else
    {
        nrf_radio_task_trigger(NRF_RADIO_TASK_RSSISTART);
    }
}

/// This event is handled when the radio starts transmitting a requested frame.
static inline void irq_framestart_state_tx_frame(void)
{
    nrf_drv_radio802154_tx_started();
}

/// This event is handled when MHR is received
static inline void irq_bcmatch_mhr(void)
{
    // Verify if time slot for receiving is available.
    if (nrf_raal_timeslot_request(nrf_drv_radio802154_rx_duration_get(
            mp_current_rx_buffer->psdu[0],
            ack_is_requested(mp_current_rx_buffer->psdu))))
    {
        // Check Frame Control field.
        switch (mp_current_rx_buffer->psdu[FRAME_TYPE_OFFSET] & FRAME_TYPE_MASK)
        {
            case FRAME_TYPE_BEACON:
                // Beacon is broadcast frame.
                m_flags.prevent_ack = false;
                state_set(RADIO_STATE_RX_FRAME);
                break;

            case FRAME_TYPE_DATA:
            case FRAME_TYPE_COMMAND:

                // For data or command check destination address.
                switch (mp_current_rx_buffer->psdu[DEST_ADDR_TYPE_OFFSET] &
                        DEST_ADDR_TYPE_MASK)
                {
                    case DEST_ADDR_TYPE_SHORT:
                        nrf_radio_bcc_set(BCC_SHORT_ADDR);
                        break;

                    case DEST_ADDR_TYPE_EXTENDED:
                        nrf_radio_bcc_set(BCC_EXTENDED_ADDR);
                        break;

                    default:
                        auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
                        nrf_radio_event_clear(NRF_RADIO_EVENT_END);
                        nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
                }

                break;

            default:

                // For ACK and other types: in promiscuous mode accept it as broadcast;
                // in normal mode drop the frame.
                if (nrf_drv_radio802154_pib_promiscuous_get())
                {
                    m_flags.prevent_ack = true;
                    state_set(RADIO_STATE_RX_FRAME);
                }
                else
                {
                    auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_END);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
                }
        }
    }
    else
    {
        irq_deinit();
        nrf_radio_reset();

        state_set(RADIO_STATE_WAITING_TIMESLOT);
    }
}

/// This event is generated when destination address fields are received.
static inline void irq_bcmatch_address(void)
{
    if (nrf_drv_radio802154_pib_dest_addr_matches(mp_current_rx_buffer->psdu))
    {
        m_flags.prevent_ack = false;
        state_set(RADIO_STATE_RX_FRAME);
    }
    else
    {
        if (nrf_drv_radio802154_pib_promiscuous_get())
        {
            m_flags.prevent_ack = true;
            state_set(RADIO_STATE_RX_FRAME);
        }
        else
        {
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_END);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
        }
    }
}

/** This event is generated twice during frame reception:
 *  when MHR is received and when destination address fields are received.
 */
static inline void irq_bcmatch_state_rx_header(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);

    switch (nrf_radio_state_get())
    {
        case NRF_RADIO_STATE_RX:
        case NRF_RADIO_STATE_RX_IDLE:
        case NRF_RADIO_STATE_RX_DISABLE:
        case NRF_RADIO_STATE_DISABLED:
        case NRF_RADIO_STATE_TX_RU:      // A lot of states due to shorts.

            switch (nrf_radio_bcc_get())
            {
                case BCC_INIT: // Received MHR
                    irq_bcmatch_mhr();
                    break;

                case BCC_SHORT_ADDR:     // Received short destination address
                case BCC_EXTENDED_ADDR:  // Received extended destination address
                    // Check destination address during second match.
                    irq_bcmatch_address();
                    break;

                default:
                    assert(false);
            }

            break;

        case NRF_RADIO_STATE_TX_IDLE:
            // Something had stopped the CPU too long. Start receiving again.
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_END);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
            break;

        default:
            assert(false);
    }
}

/** This event is generated when radio receives invalid frame with length set to 0 or started
 *  receiving a frame after other procedure locked mutex.
 */
static inline void irq_end_state_waiting_rx_frame(void)
{
    // Radio state is not asserted here. It can be a lot of states due to shorts.
    if (mp_current_rx_buffer->psdu[0] == 0)
    {
        // If length of the frame is 0 there was no FRAMESTART event. Lock mutex now and abort sending ACK.
        if (mutex_lock())
        {
            assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
        }
    }
    else
    {
        // Do nothing. Whoever took mutex shall stop sending ACK.
    }
}

/// This event is generated if frame being received is shorter than expected MAC header length.
static inline void irq_end_state_rx_header(void)
{
    // Frame ended before header was received.
    auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
}

/// This event is generated when radio peripheral ends receiving of a complete frame.
static inline void irq_end_state_rx_frame(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);

    switch (nrf_radio_state_get())
    {
        case NRF_RADIO_STATE_RX_IDLE:
        case NRF_RADIO_STATE_RX_DISABLE:
        case NRF_RADIO_STATE_DISABLED:
        case NRF_RADIO_STATE_TX_RU:

            if (nrf_radio_crc_status_get() == NRF_RADIO_CRC_STATUS_OK)
            {
                if ((!ack_is_requested(mp_current_rx_buffer->psdu)) ||
                    (!nrf_drv_radio802154_pib_auto_ack_get()) ||
                    m_flags.prevent_ack)
                {
                    auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
                    received_frame_notify();
                }
                else
                {
                    ack_prepare();
                    state_set(RADIO_STATE_TX_ACK);
                }
            }
            else
            {
                auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
                nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
            }

            break;

        case NRF_RADIO_STATE_TX_IDLE:
            // CPU was hold too long.
            auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
            break;

        default:
            assert(false);
    }
}

/// This event is generated when the radio ends transmission of ACK frame.
static inline void irq_end_state_tx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_TX_ACK);
    shorts_disable();

    received_frame_notify();

    state_set(RADIO_STATE_WAITING_RX_FRAME);
    // Receiver is enabled by shorts.
}

/** This event may occur at the beginning of transmission procedure (the procedure already has
 *  disabled shorts).
 */
static inline void irq_end_state_cca(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
}

/// This event is generated when the radio ends transmission of a frame.
static inline void irq_end_state_tx_frame(void)
{
    shorts_disable();
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

    if (!ack_is_requested(mp_tx_data))
    {
        nrf_drv_radio802154_notify_transmitted(NULL, 0, 0);

        state_set(RADIO_STATE_WAITING_RX_FRAME);
    }
    else
    {
        state_set(RADIO_STATE_RX_ACK);

        ack_matching_enable();
    }

    // Task DISABLE is triggered by shorts.
}

/// This event is generated when the radio ends receiving of ACK frame.
static inline void irq_end_state_rx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);

    if (ack_is_matched())
    {
        mp_current_rx_buffer->free = false;
        nrf_drv_radio802154_notify_transmitted(mp_current_rx_buffer->psdu,                // psdu
                                               rssi_last_measurement_get(),               // rssi
                                               RX_FRAME_LQI(mp_current_rx_buffer->psdu)); // lqi
    }
    else
    {
        nrf_drv_radio802154_notify_busy_channel();
    }

    frame_rx_start_after_ack_rx();
}

/// This event is generated when radio peripheral disables in order to enter sleep state.
static inline void irq_disabled_state_disabling(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED);
    sleep_start();
}

/** This event is generated when the driver enters receive state.
 *
 *  The radio is now disabled and the driver starts enabling receiver.
 */
static inline void irq_disabled_state_waiting_rx_frame(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

    while (nrf_radio_state_get() == NRF_RADIO_STATE_TX_DISABLE)
    {
        // This event can be handled in TXDISABLE state due to double DISABLE event (IC-15879).
        // This busy loop waits to the end of this state.
    }

    assert(nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED);

    nrf_radio_task_trigger(NRF_RADIO_TASK_RXEN);
    mutex_unlock();

    rx_buffer_in_use_set(nrf_drv_radio802154_rx_buffer_free_find());
    tx_power_set(nrf_drv_radio802154_pib_tx_power_get());

    // Clear this event after RXEN task in case event is triggered just before.
    nrf_radio_event_clear(NRF_RADIO_EVENT_DISABLED);
}

/** This event is generated in case both END and DISABLED events are notified between
 *  checking if END event was notified and checking if DISABLED event was notified.
 *
 *  In this invalid and rare case just drop received frame.
 */
static inline void irq_disabled_state_rx_frame(void)
{
    assert(nrf_radio_event_get(NRF_RADIO_EVENT_END));
    assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);

    auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
    nrf_radio_event_clear(NRF_RADIO_EVENT_END);
    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
}

/** This event is generated during automatic ACK transmission.
 *
 *  Receiver is disabled and transmitter is being enabled by shorts.
 */
static inline void irq_disabled_state_tx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_RX_INITIAL);

    shorts_rx_following_set();
    ack_pending_bit_set();

    // IC-15879
    nrf_radio_event_clear(NRF_RADIO_EVENT_DISABLED);

    if (nrf_radio_state_get() == NRF_RADIO_STATE_TX_IDLE)
    {
        // CPU was hold too long.
        auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
        nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
    }
}

/** This event is generated before CCA procedure starts.
 *
 *  The radio is disabled and the drivers enables receiver in order to start CCA procedure.
 */
static inline void irq_disabled_state_cca(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED);
    nrf_radio_task_trigger(NRF_RADIO_TASK_RXEN);
}

/** This event is generated before transmission of a frame starts.
 *
 *  The radio is disabled and enabling transmitter is requested by shorts or by the driver.
 */
static inline void irq_disabled_state_tx_frame(void)
{
    if (nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED)
    {
        shorts_tx_frame_set();
        nrf_radio_task_trigger(NRF_RADIO_TASK_TXEN);
    }

    assert(nrf_radio_shorts_get() == SHORTS_TX_FRAME);
}

/** This event is generated when radio is disabled after transmission of a frame with ACK request.
 *
 *  The driver enables receiver to receive ACK frame.
 */
static inline void irq_disabled_state_rx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED);
    nrf_radio_task_trigger(NRF_RADIO_TASK_RXEN);

    if (mp_current_rx_buffer == NULL || (!mp_current_rx_buffer->free))
    {
        rx_buffer_in_use_set(nrf_drv_radio802154_rx_buffer_free_find());
    }
}

/** This event is generated before energy detection procedure.
 *
 *  The radio is disabled and the driver enables receiver in order to start energy detection
 *  procedure.
 */
static inline void irq_disabled_state_ed(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_DISABLED);
    nrf_radio_task_trigger(NRF_RADIO_TASK_RXEN);
}

/** This event is generated when receiver is ready to start receiving a frame.
 *
 *  Driver checks if buffer for a frame is available and starts receiver.
 */
static inline void irq_ready_state_waiting_rx_frame(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);

    if ((mp_current_rx_buffer != NULL) && (mp_current_rx_buffer->free))
    {
        if (mutex_lock())
        {
            shorts_rx_initial_set();
            rx_frame_start();

            mutex_unlock();
        }
    }
}

/** This event is generated when transmitter is ready to transmit ACK frame.
 *
 *  Transmission is started by shorts. The driver sets shorts to gracefully end transmission of ACK.
 */
static inline void irq_ready_state_tx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_RX_FOLLOWING);
    shorts_tx_ack_set();
}

/** This event is generated when receiver is ready to start CCA procedure.
 *
 *  The driver prepares for transmission and starts CCA procedure.
 */
static inline void irq_ready_state_cca(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);

    state_set(RADIO_STATE_TX_FRAME);

    shorts_tx_frame_set();
    nrf_radio_task_trigger(NRF_RADIO_TASK_CCASTART);
}

/** This event is generated when transmitter is ready to transmit a frame.
 *
 *  Transmission is started by shorts.
 */
static inline void irq_ready_state_tx_frame(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_TX_FRAME);
}

/// This event is generated when receiver is ready to receive an ACK frame.
static inline void irq_ready_state_rx_ack(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);

    if (mp_current_rx_buffer == NULL || (!mp_current_rx_buffer->free))
    {
        nrf_drv_radio802154_notify_busy_channel();
        frame_rx_start_after_ack_rx();
    }
    else
    {
        rx_start();
    }
}

/// This event is generated when receiver is ready to start energy detection procedure.
static inline void irq_ready_state_ed(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);
    nrf_radio_task_trigger(NRF_RADIO_TASK_EDSTART);
}

#if !RADIO_SHORT_CCAIDLE_TXEN
/// This event is generated when CCA reports that channel is idle.
static inline void irq_ccaidle(void)
{
    assert(m_state == RADIO_STATE_TX_FRAME);
    assert(nrf_radio_shorts_get() == SHORTS_TX_FRAME);

    nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
}
#endif // RADIO_SHORT_CCAIDLE_TXEN

/// This event is generated when CCA reports busy channel prior to transmission.
static inline void irq_ccabusy_state_tx_frame(void)
{
    assert(nrf_radio_shorts_get() == SHORTS_TX_FRAME);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);

    shorts_disable();

    nrf_drv_radio802154_notify_busy_channel();

    state_set(RADIO_STATE_WAITING_RX_FRAME);
    nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
}

/// This event is generated when energy detection procedure ends.
static inline void irq_edend(void)
{
    assert(m_state == RADIO_STATE_ED);
    assert(nrf_radio_state_get() == NRF_RADIO_STATE_RX_IDLE);
    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

    uint32_t result = nrf_radio_ed_sample_get();
    m_ed_result     = result > m_ed_result ? result : m_ed_result;

    if (m_ed_time_left)
    {
        if (ed_iter_setup(m_ed_time_left))
        {
            nrf_radio_task_trigger(NRF_RADIO_TASK_EDSTART);
        }
    }
    else
    {
        nrf_drv_radio802154_notify_energy_detected(m_ed_result);

        state_set(RADIO_STATE_WAITING_RX_FRAME);
        nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
    }
}

/// Handler of radio interrupts.
void RADIO_IRQHandler(void)
{
    nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_IRQ_HANDLER);

    if (nrf_radio_event_get(NRF_RADIO_EVENT_FRAMESTART))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_FRAMESTART);
        nrf_radio_event_clear(NRF_RADIO_EVENT_FRAMESTART);

        switch (m_state)
        {
            case RADIO_STATE_WAITING_RX_FRAME:
                irq_framestart_state_waiting_rx_frame();
                break;

            case RADIO_STATE_RX_ACK:
                irq_framestart_state_rx_ack();
                break;

            case RADIO_STATE_TX_FRAME:
                irq_framestart_state_tx_frame();
                break;

            case RADIO_STATE_TX_ACK:
            case RADIO_STATE_CCA: // This could happen at the beginning of transmission procedure.
            case RADIO_STATE_WAITING_TIMESLOT:
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_FRAMESTART);
    }

    // Check MAC frame header.
    if (nrf_radio_event_get(NRF_RADIO_EVENT_BCMATCH))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_BCMATCH);
        nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);

        switch (m_state)
        {
            case RADIO_STATE_RX_HEADER:
                irq_bcmatch_state_rx_header();
                break;

            case RADIO_STATE_WAITING_RX_FRAME: // Didn't lock mutex - other procedure manages radio.
            case RADIO_STATE_WAITING_TIMESLOT: // Radio is out of timeslot now.
                assert(m_mutex);
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_BCMATCH);
    }

    if (nrf_radio_event_get(NRF_RADIO_EVENT_END))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_END);
        nrf_radio_event_clear(NRF_RADIO_EVENT_END);

        switch (m_state)
        {
            case RADIO_STATE_WAITING_RX_FRAME:
                irq_end_state_waiting_rx_frame();
                break;

            case RADIO_STATE_RX_HEADER:
                irq_end_state_rx_header();
                break;

            case RADIO_STATE_RX_FRAME:
                irq_end_state_rx_frame();
                break;

            case RADIO_STATE_TX_ACK:
                irq_end_state_tx_ack();
                break;

            case RADIO_STATE_CCA: // This could happen at the beginning of transmission procedure
                                  // (the procedure already has disabled shorts).
                irq_end_state_cca();
                break;

            case RADIO_STATE_TX_FRAME:
                irq_end_state_tx_frame();
                break;

            case RADIO_STATE_RX_ACK: // Ended receiving of ACK.
                irq_end_state_rx_ack();
                break;

            case RADIO_STATE_WAITING_TIMESLOT:
                // Exit as soon as possible when waiting for timeslot.
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_END);
    }

    if (nrf_radio_event_get(NRF_RADIO_EVENT_DISABLED))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_DISABLED);
        nrf_radio_event_clear(NRF_RADIO_EVENT_DISABLED);

        switch (m_state)
        {
            case RADIO_STATE_DISABLING:
                irq_disabled_state_disabling();
                break;

            case RADIO_STATE_WAITING_RX_FRAME:
                irq_disabled_state_waiting_rx_frame();
                break;

            case RADIO_STATE_RX_HEADER:
            case RADIO_STATE_RX_FRAME:
                irq_disabled_state_rx_frame();
                break;

            case RADIO_STATE_TX_ACK:
                irq_disabled_state_tx_ack();
                break;

            case RADIO_STATE_CCA:
                irq_disabled_state_cca();
                break;

            case RADIO_STATE_TX_FRAME:
                irq_disabled_state_tx_frame();
                break;

            case RADIO_STATE_RX_ACK:
                irq_disabled_state_rx_ack();
                break;

            case RADIO_STATE_ED:
                irq_disabled_state_ed();
                break;

            case RADIO_STATE_WAITING_TIMESLOT:
                // Exit as soon as possible when waiting for timeslot.
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_DISABLED);
    }

    if (nrf_radio_event_get(NRF_RADIO_EVENT_READY))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_READY);
        nrf_radio_event_clear(NRF_RADIO_EVENT_READY);

        switch (m_state)
        {
            case RADIO_STATE_WAITING_RX_FRAME:
                irq_ready_state_waiting_rx_frame();
                break;

            case RADIO_STATE_TX_ACK:
                irq_ready_state_tx_ack();
                break;

            case RADIO_STATE_CCA:
                irq_ready_state_cca();
                break;

            case RADIO_STATE_TX_FRAME:
                irq_ready_state_tx_frame();
                break;

            case RADIO_STATE_RX_ACK:
                irq_ready_state_rx_ack();
                break;

            case RADIO_STATE_ED:
                irq_ready_state_ed();
                break;

            case RADIO_STATE_WAITING_TIMESLOT:
                // Exit as soon as possible when waiting for timeslot.
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_READY);
    }

#if !RADIO_SHORT_CCAIDLE_TXEN
    if (nrf_radio_event_get(NRF_RADIO_EVENT_CCAIDLE))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_CCAIDLE);
        nrf_radio_event_clear(NRF_RADIO_EVENT_CCAIDLE);

        irq_ccaidle();

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_CCAIDLE);
    }
#endif

    if (nrf_radio_event_get(NRF_RADIO_EVENT_CCABUSY))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_CCABUSY);
        nrf_radio_event_clear(NRF_RADIO_EVENT_CCABUSY);

        switch (m_state)
        {
            case RADIO_STATE_TX_FRAME:
                irq_ccabusy_state_tx_frame();
                break;

            case RADIO_STATE_WAITING_TIMESLOT:
                // Exit as soon as possible when waiting for timeslot.
                break;

            default:
                assert(false);
        }

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_CCABUSY);
    }

    if (nrf_radio_event_get(NRF_RADIO_EVENT_EDEND))
    {
        nrf_drv_radio802154_log(EVENT_TRACE_ENTER, FUNCTION_EVENT_EDEND);
        nrf_radio_event_clear(NRF_RADIO_EVENT_EDEND);

        irq_edend();

        nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_EVENT_EDEND);
    }

    nrf_drv_radio802154_log(EVENT_TRACE_EXIT, FUNCTION_IRQ_HANDLER);
}


/***************************************************************************************************
 * @section FSM transition request sub-procedures
 **************************************************************************************************/

/** Abort transmission procedure.
 *
 *  This function is called when MAC layer requests transition from transmit to receive state.
 */
static inline void tx_procedure_abort(void)
{
    shorts_disable();

    assert(nrf_radio_shorts_get() == SHORTS_IDLE);
    assert(m_mutex);

    state_set(RADIO_STATE_WAITING_RX_FRAME);

    switch (nrf_radio_state_get())
    {
        case NRF_RADIO_STATE_TX_DISABLE:
        case NRF_RADIO_STATE_RX_DISABLE:
            // Do not enabled receiver. It will be enabled in DISABLED handler.
            break;

        default:
            nrf_radio_event_clear(NRF_RADIO_EVENT_DISABLED);
            nrf_radio_task_trigger(NRF_RADIO_TASK_DISABLE);
    }

    nrf_radio_mhmu_search_pattern_set(0);
    nrf_radio_event_clear(NRF_RADIO_EVENT_MHRMATCH);

    // Clear events that could have happened in critical section due to receiving frame.
    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
    nrf_radio_event_clear(NRF_RADIO_EVENT_FRAMESTART);
    nrf_radio_event_clear(NRF_RADIO_EVENT_END);
}


/***************************************************************************************************
 * @section API functions
 **************************************************************************************************/

void nrf_drv_radio802154_fsm_init(void)
{
    const uint8_t ack_psdu[] = {0x05, ACK_HEADER_WITH_PENDING, 0x00, 0x00, 0x00, 0x00};
    memcpy(m_ack_psdu, ack_psdu, sizeof(ack_psdu));

}

void nrf_drv_radio802154_fsm_deinit(void)
{
    if (m_state != RADIO_STATE_WAITING_TIMESLOT &&
        m_state != RADIO_STATE_SLEEP)
    {
        nrf_radio_reset();
    }

    irq_deinit();
}

radio_state_t nrf_drv_radio802154_fsm_state_get(void)
{
    return m_state;
}

bool nrf_drv_radio802154_fsm_sleep(void)
{
    bool result = false;

    switch (m_state)
    {
        case RADIO_STATE_WAITING_TIMESLOT:
            assert(m_mutex);

            sleep_start();
            result = true;
            break;

        case RADIO_STATE_WAITING_RX_FRAME:
            if (mutex_lock())
            {
                auto_ack_abort(RADIO_STATE_DISABLING);

                assert(nrf_radio_shorts_get() == SHORTS_IDLE);

                // Clear events that could have happened in critical section due to receiving frame
                // or RX ramp up.
                nrf_radio_event_clear(NRF_RADIO_EVENT_FRAMESTART);
                nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);
                nrf_radio_event_clear(NRF_RADIO_EVENT_END);
                nrf_radio_event_clear(NRF_RADIO_EVENT_READY);

                result = true;
            }

            break;

        case RADIO_STATE_RX_HEADER:
        case RADIO_STATE_RX_FRAME:
        case RADIO_STATE_TX_ACK:
            break;

        default:
            assert(false); // This should not happen.
    }

    return result;
}

bool nrf_drv_radio802154_fsm_receive(uint8_t channel)
{
    bool result = false;

    switch (m_state)
    {
        case RADIO_STATE_WAITING_RX_FRAME:
        case RADIO_STATE_RX_HEADER:
        case RADIO_STATE_RX_FRAME:
        case RADIO_STATE_TX_ACK:
            result = true;

            if (channel_get() != channel)
            {
                channel_set(channel);
                nrf_drv_radio802154_pib_channel_set(channel);
                if (mutex_lock())
                {
                    auto_ack_abort(RADIO_STATE_WAITING_RX_FRAME);
                }
            }

            break;

        case RADIO_STATE_DISABLING:
            channel_set(channel);
            nrf_drv_radio802154_pib_channel_set(channel);
            state_set(RADIO_STATE_WAITING_RX_FRAME);
            result = true;
            // TASK DISABLE was already triggered. Wait for event DISABLED.
            break;

        case RADIO_STATE_SLEEP:
            assert(mutex_lock());

            state_set(RADIO_STATE_WAITING_TIMESLOT);
            nrf_drv_radio802154_pib_channel_set(channel);

            nrf_raal_continuous_mode_enter();

            result = true;
            break;

        case RADIO_STATE_CCA:
        case RADIO_STATE_TX_FRAME:
        case RADIO_STATE_RX_ACK:
            tx_procedure_abort();
            result = true;
            break;

        case RADIO_STATE_ED:
            // Ignore receive function during energy detection procedure.
            break;

        case RADIO_STATE_WAITING_TIMESLOT:
            // Ignore receive function in WAITING_TIMESLOT state - the radio will receive when time
            // slot starts.
            result = true;
            break;

        default:
            assert(false);
    }

    return result;
}

bool nrf_drv_radio802154_fsm_transmit(const uint8_t * p_data, uint8_t channel, int8_t power, bool cca)
{
    bool result = false;
    mp_tx_data  = p_data;

    if (mutex_lock())
    {
        if (nrf_raal_timeslot_request(nrf_drv_radio802154_tx_duration_get(p_data[0],
                                                                          ack_is_requested(p_data))))
        {
            assert(m_state == RADIO_STATE_WAITING_RX_FRAME);

            channel_set(channel);

            auto_ack_abort(cca ? RADIO_STATE_CCA : RADIO_STATE_TX_FRAME);

            tx_power_set(power);
            nrf_radio_packet_ptr_set(p_data);

            // Clear events that could have happened in critical section due to receiving frame or RX ramp up.
            nrf_radio_event_clear(NRF_RADIO_EVENT_FRAMESTART);
            nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);
            nrf_radio_event_clear(NRF_RADIO_EVENT_END);
            nrf_radio_event_clear(NRF_RADIO_EVENT_READY);

            // Check 2nd time in case this procedure was interrupted.
            if (nrf_raal_timeslot_request(
                    nrf_drv_radio802154_tx_duration_get(p_data[0], ack_is_requested(p_data))))
            {
                result = true;
            }
            else
            {
                irq_deinit();
                nrf_radio_reset();

                state_set(RADIO_STATE_WAITING_TIMESLOT);
            }
        }
        else
        {
            mutex_unlock();
        }
    }

    return result;
}

bool nrf_drv_radio802154_fsm_energy_detection(uint8_t tx_channel, uint32_t time_us)
{
    bool     result    = false;

    switch (m_state)
    {
        case RADIO_STATE_SLEEP:
            if (mutex_lock())
            {
                state_set(RADIO_STATE_ED);
                nrf_drv_radio802154_pib_channel_set(tx_channel);
                m_ed_time_left = time_us;
                m_ed_result    = 0;

                nrf_raal_continuous_mode_enter();

                result = true;
            }

            break;

        case RADIO_STATE_WAITING_RX_FRAME:
            if (mutex_lock())
            {
                m_ed_result = 0;

                if (ed_iter_setup(time_us))
                {
                    nrf_drv_radio802154_pib_channel_set(tx_channel);
                    channel_set(tx_channel);

                    auto_ack_abort(RADIO_STATE_ED);

                    assert(nrf_radio_shorts_get() == SHORTS_IDLE);

                    // Clear events that could have happened in critical section due to receiving
                    // frame or RX ramp up.
                    nrf_radio_event_clear(NRF_RADIO_EVENT_FRAMESTART);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_BCMATCH);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_END);
                    nrf_radio_event_clear(NRF_RADIO_EVENT_READY);
                }
                else
                {
                    state_set(RADIO_STATE_ED);
                }

                result = true;
            }

            break;

        case RADIO_STATE_DISABLING:
        case RADIO_STATE_RX_HEADER:
        case RADIO_STATE_RX_FRAME:
        case RADIO_STATE_TX_ACK:
        case RADIO_STATE_WAITING_TIMESLOT:
            break;

        default:
            assert(false); // This should not happen.
    }

    return result;
}

void nrf_drv_radio802154_fsm_notify_buffer_free(rx_buffer_t * p_buffer)
{
    p_buffer->free = true;

    switch (m_state)
    {
        case RADIO_STATE_WAITING_RX_FRAME:

            switch (nrf_radio_state_get())
            {
                case NRF_RADIO_STATE_RX_DISABLE: // This one could happen after receive of broadcast frame.
                case NRF_RADIO_STATE_TX_DISABLE: // This one could happen due to stopping ACK.
                case NRF_RADIO_STATE_DISABLED:   // This one could happen during stopping ACK.
                case NRF_RADIO_STATE_RX_RU:      // This one could happen during enabling receiver (after sending ACK).
                case NRF_RADIO_STATE_RX:         // This one could happen if any other buffer is in use.
                case NRF_RADIO_STATE_TX_RU:      // This one could happen if received a short frame.
                case NRF_RADIO_STATE_TX_IDLE:    // This one could happen if received a short frame.
                    break;

                case NRF_RADIO_STATE_RX_IDLE:
                    // Mutex to make sure Radio State did not change between IRQ and this process.
                    // Check shorts to make sure RX_IDLE state is due to occupied buffers - not
                    // during END/DISABLE short.
                    // If API call changed Radio state leave Radio as it is.
                    if (mutex_lock() && nrf_radio_shorts_get() == SHORTS_IDLE)
                    {
                        shorts_rx_initial_set();

                        rx_buffer_in_use_set(p_buffer);
                        rx_frame_start();

                        // Clear events that could have happened in critical section due to RX
                        // ramp up.
                        nrf_radio_event_clear(NRF_RADIO_EVENT_READY);

                        mutex_unlock();
                    }
                    break;

                default:
                    assert(false);
            }

            break;

        default:
            // Don't perform any action in any other state (receiver should not be started).
            break;
    }
}