/*
 *  Copyright (c) 2017, The OpenThread Authors.
 *  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 the copyright holder 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 OpenThread platform abstraction for radio communication.
 *
 */

/* Openthread configuration */
#include OPENTHREAD_PROJECT_CORE_CONFIG_FILE

/* memcpy */
#include "string.h"

/* uMac, MMAC, Radio */
#include "MMAC.h"
#include "MicroSpecific_arm_sdk2.h"
#include "radio.h"

/* Openthread general */
#include <utils/code_utils.h>
#include <openthread/platform/alarm-milli.h>
#include <openthread/platform/diag.h>
#include <openthread/platform/radio.h>

#if USE_RTOS
#include "openthread-system.h"
#endif

extern void BOARD_LedDongleToggle(void);

/* Defines */
#define BIT_SET(arg, posn) ((arg) |= (1ULL << (posn)))
#define BIT_CLR(arg, posn) ((arg) &= ~(1ULL << (posn)))
#define BIT_TST(arg, posn) (!!((arg) & (1ULL << (posn))))

#define ALL_FFs_BYTE (0xFF)

#define K32W_RADIO_MIN_TX_POWER_DBM (-30)
#define K32W_RADIO_MAX_TX_POWER_DBM (15)
#define K32W_RADIO_RX_SENSITIVITY_DBM (-100)
#define K32W_RADIO_DEFAULT_CHANNEL (11)

#define US_PER_SYMBOL (16) /* Duration of a single symbol in [us] */
#define SYMBOLS_TO_US(symbols) ((symbols)*US_PER_SYMBOL)
#define US_TO_MILI_DIVIDER (1000)

#define MAX_FP_ADDRS (10)   /* max number of frame pending children */
#define K32W_RX_BUFFERS (8) /* max number of RX buffers */

/* check IEEE Std. 802.15.4 - 2015: Table 8-81 - MAC sublayer constants */
#define MAC_TX_ATTEMPTS (4)
#define MAC_TX_CSMA_MIN_BE (3)
#define MAC_TX_CSMA_MAX_BE (5)
#define MAC_TX_CSMA_MAX_BACKOFFS (4)

/* Structures */
typedef struct
{
    uint16_t macAddress;
    uint16_t panId;
} fpNeighShortAddr;

typedef struct
{
    uint32_t u32L;
    uint32_t u32H;
} extMacAddr;

typedef struct
{
    extMacAddr extAddr;
    uint16_t   panId;
} fpNeighExtAddr;

typedef struct
{
    tsRxFrameFormat *buffer[K32W_RX_BUFFERS];
    uint8_t          head;
    uint8_t          tail;
    bool             isFull;
} rxRingBuffer;

typedef enum
{
    kFcfSize             = sizeof(uint16_t),
    kDsnSize             = sizeof(uint8_t),
    kSecurityControlSize = sizeof(uint8_t),
    kFrameCounterSize    = sizeof(uint32_t),
    kKeyIndexSize        = sizeof(uint8_t),

    kMacFcfLowOffset = 0, /* Offset of FCF first byte inside Mac Hdr */
    kMacFrameDataReq = 4,

    kFcfTypeBeacon       = 0,
    kFcfTypeMacData      = 1,
    kFcfTypeAck          = 2,
    kFcfTypeMacCommand   = 3,
    kFcfMacFrameTypeMask = 7 << 0,

    kFcfAckRequest        = 1 << 5,
    kFcfPanidCompression  = 1 << 6,
    kFcfSeqNbSuppresssion = 1 << 8,
    kFcfDstAddrNone       = 0 << 10,
    kFcfDstAddrShort      = 2 << 10,
    kFcfDstAddrExt        = 3 << 10,
    kFcfDstAddrMask       = 3 << 10,
    kFcfSrcAddrNone       = 0 << 14,
    kFcfSrcAddrShort      = 2 << 14,
    kFcfSrcAddrExt        = 3 << 14,
    kFcfSrcAddrMask       = 3 << 14,

    kSecLevelMask            = 7 << 0,
    kFrameCounterSuppression = 1 << 5,

    kKeyIdMode0    = 0 << 3,
    kKeyIdMode1    = 1 << 3,
    kKeyIdMode2    = 2 << 3,
    kKeyIdMode3    = 3 << 3,
    kKeyIdModeMask = 3 << 3,

    kKeySourceSizeMode0 = 0,
    kKeySourceSizeMode1 = 0,
    kKeySourceSizeMode2 = 4,
    kKeySourceSizeMode3 = 8,
} macHdr;

typedef enum
{
    macToOtFrame, /* RX */
    otToMacFrame, /* TX */
} frameConversionType;

/* Private functions declaration */
static void             K32WISR(uint32_t u32IntBitmap);
static void             K32WProcessMacHeader(tsRxFrameFormat *aRxFrame);
static void             K32WProcessRxFrames(otInstance *aInstance);
static void             K32WProcessTxFrame(otInstance *aInstance);
static bool             K32WCheckIfFpRequired(tsRxFrameFormat *aRxFrame);
static bool_t           K32WIsDataReq(tsRxFrameFormat *aRxFrame);
static otError          K32WFrameConversion(tsRxFrameFormat *   aMacFormatFrame,
                                            otRadioFrame *      aOtFrame,
                                            frameConversionType convType);
static void             K32WCopy(uint8_t *aFieldValue, uint8_t **aPsdu, uint8_t copySize, frameConversionType convType);
static void             K32WResetRxRingBuffer(rxRingBuffer *aRxRing);
static void             K32WPushRxRingBuffer(rxRingBuffer *aRxRing, tsRxFrameFormat *aRxFrame);
static tsRxFrameFormat *K32WPopRxRingBuffer(rxRingBuffer *aRxRing);
static bool             K32WIsEmptyRxRingBuffer(rxRingBuffer *aRxRing);
static tsRxFrameFormat *K32WGetFrame(tsRxFrameFormat *aRxFrame, uint8_t *aRxFrameIndex);
static void             K32WEnableReceive(bool_t isNewFrameNeeded);
static void             K32WRestartRx(void);

/* Private variables declaration */
static otRadioState sState = OT_RADIO_STATE_DISABLED;
static otInstance * sInstance;    /* Saved OT Instance */
static int8_t       sTxPwrLevel;  /* Default power is 0 dBm */
static uint8_t      sChannel = 0; /* Default channel - must be invalid so it
                                     updates the first time it is set */
static bool_t    sIsFpEnabled;    /* Frame Pending enabled? */
static uint16_t  sPanId;          /* PAN ID currently in use */
static uint16_t  sShortAddress;
static tsExtAddr sExtAddress;
static uint64_t  sCustomExtAddr = 0;

static fpNeighShortAddr sFpShortAddr[MAX_FP_ADDRS]; /* Frame Pending short addresses array */
static uint16_t         sFpShortAddrMask;           /* Mask - sFpShortAddr valid entries */

static fpNeighExtAddr sFpExtAddr[MAX_FP_ADDRS]; /* Frame Pending extended addresses array */
static uint16_t       sFpExtAddrMask;           /* Mask - sFpExtAddr is valid */

static rxRingBuffer     sRxRing;                       /* Receive Ring Buffer */
static tsRxFrameFormat  sRxFrame[K32W_RX_BUFFERS];     /* RX Buffers */
static tsRxFrameFormat *sRxFrameInProcess;             /* RX Frame currently in processing */
static bool_t           sIsRxDisabled;                 /* TRUE if RX was disabled due to no RX bufs */
static uint8_t          sRxFrameIndex;                 /* Index tracking the sRxFrame array */
static teRxOption       sRxOpt = E_MMAC_RX_START_NOW | /* RX Options */
                           E_MMAC_RX_ALIGN_NORMAL | E_MMAC_RX_USE_AUTO_ACK | E_MMAC_RX_NO_MALFORMED |
                           E_MMAC_RX_NO_FCS_ERROR | E_MMAC_RX_ADDRESS_MATCH;

tsRxFrameFormat         sTxMacFrame;                      /* TX Frame */
static tsRxFrameFormat  sRxAckFrame;                      /* Frame used for keeping the ACK */
static otRadioFrame     sRxOtFrame;                       /* Used for TX/RX frame conversion */
static uint8            sRxData[OT_RADIO_FRAME_MAX_SIZE]; /* mPsdu buffer for sRxOtFrame */
static tsRxFrameFormat *pLastRxFrame;

static bool         sRadioInitForLp    = FALSE;
static bool         sPromiscuousEnable = FALSE;
static bool         sTxDone;                          /* TRUE if a TX frame was sent into the air */
static otError      sTxStatus;                        /* Status of the latest TX operation */
static otRadioFrame sTxOtFrame;                       /* OT TX Frame to be send */
static uint8_t      sTxData[OT_RADIO_FRAME_MAX_SIZE]; /* mPsdu buffer for sTxOtFrame */

/* Stub functions for controlling low power mode */
WEAK void App_AllowDeviceToSleep();
WEAK void App_DisallowDeviceToSleep();
/* Stub functions for controlling LEDs on OT RCP USB dongle */
WEAK void BOARD_LedDongleToggle();

/**
 * Stub function used for controlling low power mode
 *
 */
WEAK void App_AllowDeviceToSleep()
{
}

/**
 * Stub function used for controlling low power mode
 *
 */
WEAK void App_DisallowDeviceToSleep()
{
}

/**
 * Stub functions for controlling LEDs on OT RCP USB dongle
 *
 */
WEAK void BOARD_LedDongleToggle()
{
}

void App_SetCustomEui64(uint8_t *aIeeeEui64)
{
    memcpy((uint8_t *)&sCustomExtAddr, aIeeeEui64, sizeof(sCustomExtAddr));
}

void K32WRadioInit(void)
{
    /* RX initialization */
    memset(sRxFrame, 0, sizeof(tsRxFrameFormat) * K32W_RX_BUFFERS);
    sRxFrameIndex = 0;

    /* TX initialization */
    sTxOtFrame.mPsdu = sTxData;
    sRxOtFrame.mPsdu = sRxData;
}

void K32WRadioProcess(otInstance *aInstance)
{
    K32WProcessRxFrames(aInstance);
    K32WProcessTxFrame(aInstance);
}

otRadioState otPlatRadioGetState(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return sState;
}

void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64)
{
    OT_UNUSED_VARIABLE(aInstance);

    if (0 == sCustomExtAddr)
    {
        tsExtAddr euiAddr;
        vMMAC_GetMacAddress(&euiAddr);

        memcpy(aIeeeEui64, &euiAddr.u32L, sizeof(uint32_t));
        memcpy(aIeeeEui64 + sizeof(uint32_t), &euiAddr.u32H, sizeof(uint32_t));
    }
    else
    {
        memcpy(aIeeeEui64, (uint8_t *)&sCustomExtAddr, sizeof(sCustomExtAddr));
    }
}

void otPlatRadioSetPanId(otInstance *aInstance, uint16_t aPanId)
{
    OT_UNUSED_VARIABLE(aInstance);

    sPanId = aPanId;
    vMMAC_SetRxPanId(aPanId);
}

void otPlatRadioSetExtendedAddress(otInstance *aInstance, const otExtAddress *aExtAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    if (aExtAddress)
    {
        memcpy(&sExtAddress.u32L, aExtAddress->m8, sizeof(uint32_t));
        memcpy(&sExtAddress.u32H, aExtAddress->m8 + sizeof(uint32_t), sizeof(uint32_t));
        vMMAC_SetRxExtendedAddr(&sExtAddress);
    }
}

void otPlatRadioSetShortAddress(otInstance *aInstance, uint16_t aShortAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    sShortAddress = aShortAddress;
    vMMAC_SetRxShortAddr(aShortAddress);
}

otError otPlatRadioEnable(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    K32WResetRxRingBuffer(&sRxRing);
    sRxFrameIndex = 0;
    vMMAC_Enable();
    vMMAC_EnableInterrupts(K32WISR);
    vMMAC_ConfigureInterruptSources(E_MMAC_INT_TX_COMPLETE | E_MMAC_INT_RX_HEADER | E_MMAC_INT_RX_COMPLETE);
    vMMAC_ConfigureRadio();
    vMMAC_SetTxParameters(MAC_TX_ATTEMPTS, MAC_TX_CSMA_MIN_BE, MAC_TX_CSMA_MAX_BE, MAC_TX_CSMA_MAX_BACKOFFS);

    if (sRadioInitForLp)
    {
        /* Re-set modem settings after low power exit */
        vMMAC_SetChannelAndPower(sChannel, sTxPwrLevel);
        vMMAC_SetRxExtendedAddr(&sExtAddress);
        vMMAC_SetRxPanId(sPanId);
        vMMAC_SetRxShortAddr(sShortAddress);
    }

    sTxOtFrame.mLength = 0;
    sRxOtFrame.mLength = 0;

    sInstance = aInstance;
    sState    = OT_RADIO_STATE_SLEEP;

    return OT_ERROR_NONE;
}

otError otPlatRadioDisable(otInstance *aInstance)
{
    otError error = OT_ERROR_INVALID_STATE;

    otEXPECT(otPlatRadioIsEnabled(aInstance));

    K32WResetRxRingBuffer(&sRxRing);
    sRxFrameIndex = 0;
    vMMAC_Disable();
    sState = OT_RADIO_STATE_DISABLED;
    error  = OT_ERROR_NONE;

exit:
    return error;
}

bool otPlatRadioIsEnabled(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return sState != OT_RADIO_STATE_DISABLED;
}

otError otPlatRadioSleep(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);
    otError status = OT_ERROR_NONE;

    otEXPECT_ACTION(((sState != OT_RADIO_STATE_TRANSMIT) && (sState != OT_RADIO_STATE_DISABLED)),
                    status = OT_ERROR_INVALID_STATE);

    /* The radio has been init and configuration should be restored in otPlatRadioEnable when
       exiting low power */
    sRadioInitForLp = TRUE;

    sState = OT_RADIO_STATE_SLEEP;
    vMMAC_RadioToOffAndWait();
    App_AllowDeviceToSleep();

exit:
    return status;
}

otError otPlatRadioReceive(otInstance *aInstance, uint8_t aChannel)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError      error            = OT_ERROR_NONE;
    bool_t       isNewFrameNeeded = TRUE;
    otRadioState tempState        = sState;

    otEXPECT_ACTION(((sState != OT_RADIO_STATE_TRANSMIT) && (sState != OT_RADIO_STATE_DISABLED)),
                    error = OT_ERROR_INVALID_STATE);

    App_DisallowDeviceToSleep();

    /* Check if the channel needs to be changed */
    if (sChannel != aChannel)
    {
        sChannel = aChannel;

        /* The state is set to sleep to prevent a lockup caused by an RX interrup firing during
         * the radio off command called inside set channel and power */
        sState = OT_RADIO_STATE_SLEEP;
        vMMAC_SetChannelAndPower(sChannel, sTxPwrLevel);
        sState = tempState;
    }

    if (OT_RADIO_STATE_RECEIVE != sState)
    {
        sState = OT_RADIO_STATE_RECEIVE;
    }
    else
    {
        /* this might happen when the channel is switched
         * in the middle of a receive operation */
        isNewFrameNeeded = FALSE;
    }
    K32WEnableReceive(isNewFrameNeeded);

exit:
    return error;
}

void otPlatRadioEnableSrcMatch(otInstance *aInstance, bool aEnable)
{
    OT_UNUSED_VARIABLE(aInstance);

    sIsFpEnabled = aEnable;
}

otError otPlatRadioAddSrcMatchShortEntry(otInstance *aInstance, const uint16_t aShortAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError error = OT_ERROR_NO_BUFS;
    uint8_t idx   = 0;

    for (; idx < MAX_FP_ADDRS; idx++)
    {
        if (!BIT_TST(sFpShortAddrMask, idx))
        {
            sFpShortAddr[idx].panId      = sPanId;
            sFpShortAddr[idx].macAddress = aShortAddress;
            BIT_SET(sFpShortAddrMask, idx);
            error = OT_ERROR_NONE;
            break;
        }
    }

    return error;
}

otError otPlatRadioAddSrcMatchExtEntry(otInstance *aInstance, const otExtAddress *aExtAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError error = OT_ERROR_NO_BUFS;
    uint8_t idx   = 0;

    for (; idx < MAX_FP_ADDRS; idx++)
    {
        if (!BIT_TST(sFpExtAddrMask, idx))
        {
            sFpExtAddr[idx].panId = sPanId;
            memcpy(&sFpExtAddr[idx].extAddr.u32L, aExtAddress->m8, sizeof(uint32_t));
            memcpy(&sFpExtAddr[idx].extAddr.u32H, aExtAddress->m8 + sizeof(uint32_t), sizeof(uint32_t));
            BIT_SET(sFpExtAddrMask, idx);
            error = OT_ERROR_NONE;
            break;
        }
    }

    return error;
}

otError otPlatRadioClearSrcMatchShortEntry(otInstance *aInstance, const uint16_t aShortAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError error = OT_ERROR_NO_ADDRESS;
    uint8_t idx   = 0;

    for (; idx < MAX_FP_ADDRS; idx++)
    {
        if (BIT_TST(sFpShortAddrMask, idx) && (sFpShortAddr[idx].macAddress == aShortAddress))
        {
            BIT_CLR(sFpShortAddrMask, idx);
            error = OT_ERROR_NONE;
            break;
        }
    }

    return error;
}

otError otPlatRadioClearSrcMatchExtEntry(otInstance *aInstance, const otExtAddress *aExtAddress)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError error = OT_ERROR_NO_ADDRESS;
    uint8_t idx   = 0;

    for (; idx < MAX_FP_ADDRS; idx++)
    {
        if (BIT_TST(sFpExtAddrMask, idx) && !memcmp(&sFpExtAddr[idx].extAddr.u32L, aExtAddress->m8, sizeof(uint32_t)) &&
            !memcmp(&sFpExtAddr[idx].extAddr.u32H, aExtAddress->m8 + sizeof(uint32_t), sizeof(uint32_t)))
        {
            BIT_CLR(sFpExtAddrMask, idx);
            error = OT_ERROR_NONE;
            break;
        }
    }

    return error;
}

void otPlatRadioClearSrcMatchShortEntries(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    sFpShortAddrMask = 0;
}

void otPlatRadioClearSrcMatchExtEntries(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    sFpExtAddrMask = 0;
}

otRadioFrame *otPlatRadioGetTransmitBuffer(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return &sTxOtFrame;
}

otError otPlatRadioTransmit(otInstance *aInstance, otRadioFrame *aFrame)
{
    otError    error    = OT_ERROR_NONE;
    teTxOption eOptions = E_MMAC_TX_START_NOW | E_MMAC_TX_USE_AUTO_ACK;

    otEXPECT_ACTION(OT_RADIO_STATE_RECEIVE == sState, error = OT_ERROR_INVALID_STATE);

    /* go to TX state */
    sState    = OT_RADIO_STATE_TRANSMIT;
    sTxStatus = OT_ERROR_NONE;

    /* set tx channel */
    if (sChannel != aFrame->mChannel)
    {
        vMMAC_SetChannelAndPower(aFrame->mChannel, sTxPwrLevel);
    }

    if (aFrame->mInfo.mTxInfo.mCsmaCaEnabled)
    {
        eOptions |= E_MMAC_TX_USE_CCA;
    }

    K32WFrameConversion(&sTxMacFrame, aFrame, otToMacFrame);

    /* stop rx is handled by uMac tx function */
    vMMAC_StartMacTransmit(&sTxMacFrame.sFrameBody, eOptions);

    /* Set RX buffer pointer for ACK */
    vMMAC_SetRxFrame(&sRxAckFrame);

    otPlatRadioTxStarted(aInstance, aFrame);

exit:
    return error;
}

int8_t otPlatRadioGetRssi(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    int8_t  rssidBm       = 127;
    int16_t rssiValSigned = 0;
    bool_t  stateChanged  = FALSE;

    /* in RCP designs, the RSSI function is called while the radio is in
     * OT_RADIO_STATE_RECEIVE. Turn off the radio before reading RSSI,
     * otherwise we may end up waiting until a packet is received
     * (in i16Radio_GetRSSI, while loop)
     */

    if (sState == OT_RADIO_STATE_RECEIVE)
    {
        sState = OT_RADIO_STATE_SLEEP;
        vMMAC_RadioToOffAndWait();
        stateChanged = TRUE;
    }

    rssiValSigned = i16Radio_GetRSSI(0, FALSE, NULL);

    if (stateChanged)
    {
        sState = OT_RADIO_STATE_RECEIVE;
        K32WEnableReceive(TRUE);
    }

    rssiValSigned = i16Radio_BoundRssiValue(rssiValSigned);

    /* RSSI reported by radio is in 1/4 dBm step,
     * meaning values are 4 times larger than real dBm value.
     */
    rssidBm = (int8_t)(rssiValSigned >> 2);

    return rssidBm;
}

otRadioCaps otPlatRadioGetCaps(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return OT_RADIO_CAPS_ACK_TIMEOUT | OT_RADIO_CAPS_TRANSMIT_RETRIES | OT_RADIO_CAPS_CSMA_BACKOFF;
}

bool otPlatRadioGetPromiscuous(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return sPromiscuousEnable;
}

void otPlatRadioSetPromiscuous(otInstance *aInstance, bool aEnable)
{
    OT_UNUSED_VARIABLE(aInstance);

    if (sPromiscuousEnable != aEnable)
    {
        sPromiscuousEnable = aEnable;

        if (aEnable)
        {
            sRxOpt &= ~E_MMAC_RX_ADDRESS_MATCH;
        }
        else
        {
            sRxOpt |= E_MMAC_RX_ADDRESS_MATCH;
        }
    }
}

otError otPlatRadioEnergyScan(otInstance *aInstance, uint8_t aScanChannel, uint16_t aScanDuration)
{
    OT_UNUSED_VARIABLE(aInstance);

    otError status = OT_ERROR_NOT_IMPLEMENTED;

    return status;
}

otError otPlatRadioGetTransmitPower(otInstance *aInstance, int8_t *aPower)
{
    otError error = OT_ERROR_NONE;
    otEXPECT_ACTION(aPower != NULL, error = OT_ERROR_INVALID_ARGS);

    *aPower = i8Radio_GetTxPowerLevel_dBm();
    return OT_ERROR_NONE;

exit:
    return error;
}

otError otPlatRadioSetTransmitPower(otInstance *aInstance, int8_t aPower)
{
    OT_UNUSED_VARIABLE(aInstance);
    otRadioState tempState = sState;
    sState                 = OT_RADIO_STATE_SLEEP;

    /* trim the values to the radio capabilities */
    if (aPower < K32W_RADIO_MIN_TX_POWER_DBM)
    {
        aPower = K32W_RADIO_MIN_TX_POWER_DBM;
    }
    else if (aPower > K32W_RADIO_MAX_TX_POWER_DBM)
    {
        aPower = K32W_RADIO_MAX_TX_POWER_DBM;
    }

    /* save for later use */
    sTxPwrLevel = aPower;

    /* The state is set to sleep to prevent a lockup caused by an RX interrup firing during
     * the radio off command called inside set channel and power */
    if (0 != sChannel)
    {
        vMMAC_SetChannelAndPower(sChannel, aPower);
    }
    else
    {
        /* if the channel has not yet been initialized use K32W_RADIO_DEFAULT_CHANNEL as default */
        vMMAC_SetChannelAndPower(K32W_RADIO_DEFAULT_CHANNEL, aPower);
    }
    sState = tempState;

    return OT_ERROR_NONE;
}

otError otPlatRadioGetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t *aThreshold)
{
    OT_UNUSED_VARIABLE(aInstance);
    OT_UNUSED_VARIABLE(aThreshold);

    return OT_ERROR_NOT_IMPLEMENTED;
}

otError otPlatRadioSetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t aThreshold)
{
    OT_UNUSED_VARIABLE(aInstance);
    OT_UNUSED_VARIABLE(aThreshold);

    return OT_ERROR_NOT_IMPLEMENTED;
}

int8_t otPlatRadioGetReceiveSensitivity(otInstance *aInstance)
{
    OT_UNUSED_VARIABLE(aInstance);

    return K32W_RADIO_RX_SENSITIVITY_DBM;
}

/**
 * Interrupt service routine (e.g.: TX/RX/MAC HDR received)
 *
 * @param[in] u32IntBitmap  Bitmap telling which interrupt fired
 *
 */
static void K32WISR(uint32_t u32IntBitmap)
{
    tsRxFrameFormat *pRxFrame = NULL;

    switch (sState)
    {
    case OT_RADIO_STATE_RECEIVE:

        /* no rx errors */
        if (0 == u32MMAC_GetRxErrors())
        {
            if (u32IntBitmap & E_MMAC_INT_RX_HEADER)
            {
                /* go back one index from current frame index */
                pRxFrame = &sRxFrame[(sRxFrameIndex + K32W_RX_BUFFERS - 1) % K32W_RX_BUFFERS];

                /* FP processing first */
                K32WProcessMacHeader(pRxFrame);

                /* RX interrupt fired so it's safe to consume the frame */
                K32WPushRxRingBuffer(&sRxRing, pRxFrame);

                if (0 == (pRxFrame->sFrameBody.u16FCF & kFcfAckRequest))
                {
                    K32WEnableReceive(TRUE);
                }
            }
            else if (u32IntBitmap & E_MMAC_INT_RX_COMPLETE)
            {
                K32WEnableReceive(TRUE);
            }
        }
        else
        {
            /* restart RX and keep same buffer as data received contains errors */
            K32WEnableReceive(FALSE);
        }

        BOARD_LedDongleToggle();
        break;
    case OT_RADIO_STATE_TRANSMIT:

        if (u32IntBitmap & E_MMAC_INT_TX_COMPLETE)
        {
            uint32_t txErrors = u32MMAC_GetTxErrors();
            sTxDone           = TRUE;

            if (txErrors & E_MMAC_TXSTAT_CCA_BUSY)
            {
                sTxStatus = OT_ERROR_CHANNEL_ACCESS_FAILURE;
            }
            else if (txErrors & E_MMAC_TXSTAT_NO_ACK)
            {
                sTxStatus = OT_ERROR_NO_ACK;
            }
            else if (txErrors & E_MMAC_TXSTAT_ABORTED)
            {
                sTxStatus = OT_ERROR_ABORT;
            }
            else if ((txErrors & E_MMAC_TXSTAT_TXPCTO) || (txErrors & E_MMAC_TXSTAT_TXTO))
            {
                /* The JN518x/K32W0x1 has a TXTO timeout that we are using to catch and cope with the curious
                hang-up issue */
                vMMAC_AbortRadio();

                /* Describe failure as a CCA failure for onward processing */
                sTxStatus = OT_ERROR_CHANNEL_ACCESS_FAILURE;
            }

            /* go to RX and restore channel */
            if (sChannel != sTxOtFrame.mChannel)
            {
                vMMAC_SetChannelAndPower(sChannel, sTxPwrLevel);
            }

            BOARD_LedDongleToggle();
            sState = OT_RADIO_STATE_RECEIVE;
            K32WEnableReceive(TRUE);
        }
        break;

    default:
        break;
    }

#if USE_RTOS
    otSysEventSignalPending();
#endif
}
/**
 * Process the MAC Header of the latest received packet
 * We are in interrupt context - we need to compute the FP
 * while the hardware generates the ACK.
 *
 * @param[in] aRxFrame     Pointer to the latest received MAC packet
 *
 */
static void K32WProcessMacHeader(tsRxFrameFormat *aRxFrame)
{
    /* check if frame pending processing is required */
    if (aRxFrame && sIsFpEnabled)
    {
        /* Intra-PAN bit set? */
        if ((kFcfPanidCompression & aRxFrame->sFrameBody.u16FCF) &&
            (kFcfDstAddrNone != (aRxFrame->sFrameBody.u16FCF & kFcfDstAddrMask)))
        {
            /* Read destination PAN ID into source PAN ID: they are the same */
            aRxFrame->sFrameBody.u16SrcPAN = aRxFrame->sFrameBody.u16DestPAN;
        }

        if (K32WIsDataReq(aRxFrame))
        {
            vMMAC_SetTxPend(K32WCheckIfFpRequired(aRxFrame));
        }
        else
        {
            /* Make sure this is set to 0 when we are not dealing with a data request */
            aRxFrame->sFrameBody.u16Unused = 0;
        }
    }
}

/**
 * Check if aRxFrame is a MAC Data Request Command
 *
 * @param[in] aRxFrame     Pointer to the latest received MAC packet
 *
 * @return TRUE 	aRxFrame is a MAC Data Request Frame
 * @return FALSE	aRxFrame is not a MAC Data Request Frame
 */
static bool_t K32WIsDataReq(tsRxFrameFormat *aRxFrame)
{
    bool_t  isDataReq = FALSE;
    uint8_t offset    = 0;

    if (kFcfTypeMacCommand == (aRxFrame->sFrameBody.u16FCF & kFcfMacFrameTypeMask))
    {
        uint8_t secControlField = aRxFrame->sFrameBody.uPayload.au8Byte[0];

        if (secControlField & kSecLevelMask)
        {
            offset += kSecurityControlSize;
        }

        if (!(secControlField & kFrameCounterSuppression))
        {
            offset += kFrameCounterSize;
        }

        switch (secControlField & kKeyIdModeMask)
        {
        case kKeyIdMode0:
            offset += kKeySourceSizeMode0;
            break;

        case kKeyIdMode1:
            offset += kKeySourceSizeMode1 + kKeyIndexSize;
            break;

        case kKeyIdMode2:
            offset += kKeySourceSizeMode2 + kKeyIndexSize;
            break;

        case kKeyIdMode3:
            offset += kKeySourceSizeMode3 + kKeyIndexSize;
            break;
        }

        if (kMacFrameDataReq == aRxFrame->sFrameBody.uPayload.au8Byte[offset])
        {
            isDataReq = TRUE;
        }
    }

    return isDataReq;
}

/**
 * Check if Frame Pending was requested by aPsRxFrame
 * We are in interrupt context.
 *
 * @param[in] aRxFrame  Pointer to a Data Request Frame
 *
 * @return    TRUE 	    Frame Pending bit should be set in the reply
 * @return    FALSE	    Frame Pending bit shouldn't be set in the reply
 *
 */
static bool K32WCheckIfFpRequired(tsRxFrameFormat *aRxFrame)
{
    bool     isFpRequired = FALSE;
    uint16_t panId        = aRxFrame->sFrameBody.u16SrcPAN;
    uint8_t  idx          = 0;

    if (kFcfSrcAddrShort == (aRxFrame->sFrameBody.u16FCF & kFcfSrcAddrMask))
    {
        uint16_t shortAddr = aRxFrame->sFrameBody.uSrcAddr.u16Short;

        for (idx = 0; idx < MAX_FP_ADDRS; idx++)
        {
            if (BIT_TST(sFpShortAddrMask, idx) && (sFpShortAddr[idx].macAddress == shortAddr) &&
                sFpShortAddr[idx].panId == panId)
            {
                isFpRequired = TRUE;
                break;
            }
        }
    }
    else
    {
        for (idx = 0; idx < MAX_FP_ADDRS; idx++)
        {
            if (BIT_TST(sFpExtAddrMask, idx) &&
                (sFpExtAddr[idx].extAddr.u32L == aRxFrame->sFrameBody.uSrcAddr.sExt.u32L) &&
                (sFpExtAddr[idx].extAddr.u32H == aRxFrame->sFrameBody.uSrcAddr.sExt.u32H) &&
                sFpExtAddr[idx].panId == panId)
            {
                isFpRequired = TRUE;
                break;
            }
        }
    }
    /* use the unsued filed to store if the frame was ack'ed with FP and report this back to OT stack */
    aRxFrame->sFrameBody.u16Unused = isFpRequired;

    return isFpRequired;
}

/**
 * Process RX frames in process context and call the upper layer call-backs
 *
 * @param[in] aInstance  Pointer to OT instance
 */
static void K32WProcessRxFrames(otInstance *aInstance)
{
    tsRxFrameFormat *pRxMacFormatFrame = NULL;
    uint32_t         savedInterrupts;

    while ((pRxMacFormatFrame = K32WPopRxRingBuffer(&sRxRing)) != NULL)
    {
        if (OT_ERROR_NONE == K32WFrameConversion(pRxMacFormatFrame, &sRxOtFrame, macToOtFrame))
        {
            otPlatRadioReceiveDone(aInstance, &sRxOtFrame, OT_ERROR_NONE);
        }
        else
        {
            otPlatRadioReceiveDone(aInstance, NULL, OT_ERROR_ABORT);
        }
        memset(pRxMacFormatFrame, 0, sizeof(tsRxFrameFormat));

        MICRO_DISABLE_AND_SAVE_INTERRUPTS(savedInterrupts);
        sRxFrameInProcess = NULL;
        if (sIsRxDisabled)
        {
            K32WEnableReceive(TRUE);
        }
        MICRO_RESTORE_INTERRUPTS(savedInterrupts);
    }
}

/**
 * Process TX frame in process context and call the upper layer call-backs
 *
 * @param[in] aInstance  Pointer to OT instance
 */
static void K32WProcessTxFrame(otInstance *aInstance)
{
    if (sTxDone)
    {
        sTxDone = FALSE;
        if ((sTxOtFrame.mPsdu[kMacFcfLowOffset] & kFcfAckRequest) && (OT_ERROR_NONE == sTxStatus))
        {
            K32WFrameConversion(&sRxAckFrame, &sRxOtFrame, macToOtFrame);
            otPlatRadioTxDone(aInstance, &sTxOtFrame, &sRxOtFrame, sTxStatus);
        }
        else
        {
            otPlatRadioTxDone(aInstance, &sTxOtFrame, NULL, sTxStatus);
        }
    }
}

/**
 * aMacFormatFrame <-> aOtFrame bidirectional conversion
 *
 * @param[in] aMacFrameFormat  Pointer to a MAC Format frame
 * @param[in] aOtFrame         Pointer to OpenThread Frame
 * @param[in] convType         Conversion direction
 *
 * @return    OT_ERROR_NONE      No conversion error
 * @return    OT_ERROR_PARSE     Conversion failed due to parsing error
 */
static otError K32WFrameConversion(tsRxFrameFormat *   aMacFormatFrame,
                                   otRadioFrame *      aOtFrame,
                                   frameConversionType convType)
{
    tsMacFrame *pMacFrame         = &aMacFormatFrame->sFrameBody;
    uint8_t *   pSavedStartRxPSDU = aOtFrame->mPsdu;
    uint8_t *   pPsdu             = aOtFrame->mPsdu;
    uint16_t    aFcf              = 0;
    otError     error             = OT_ERROR_NONE;

    /* frame control field */
    K32WCopy((uint8_t *)&pMacFrame->u16FCF, &pPsdu, kFcfSize, convType);
    aFcf = pMacFrame->u16FCF;

    /* sequence number */
    if (0 == (aFcf & kFcfSeqNbSuppresssion))
    {
        K32WCopy(&pMacFrame->u8SequenceNum, &pPsdu, kDsnSize, convType);
    }

    /* destination Pan Id + address */
    switch (aFcf & kFcfDstAddrMask)
    {
    case kFcfDstAddrNone:
        break;

    case kFcfDstAddrShort:
        K32WCopy((uint8_t *)&pMacFrame->u16DestPAN, &pPsdu, sizeof(otPanId), convType);
        K32WCopy((uint8_t *)&pMacFrame->uDestAddr.u16Short, &pPsdu, sizeof(otShortAddress), convType);
        break;

    case kFcfDstAddrExt:
        K32WCopy((uint8_t *)&pMacFrame->u16DestPAN, &pPsdu, sizeof(otPanId), convType);
        K32WCopy((uint8_t *)&pMacFrame->uDestAddr.sExt.u32L, &pPsdu, sizeof(uint32_t), convType);
        K32WCopy((uint8_t *)&pMacFrame->uDestAddr.sExt.u32H, &pPsdu, sizeof(uint32_t), convType);
        break;

    default:
        error = OT_ERROR_PARSE;
        otEXPECT(false);
    }

    /* Source Pan Id */
    if ((aFcf & kFcfSrcAddrMask) != kFcfSrcAddrNone && (aFcf & kFcfPanidCompression) == 0)
    {
        K32WCopy((uint8_t *)&pMacFrame->u16SrcPAN, &pPsdu, sizeof(otPanId), convType);
    }

    /* Source Address */
    switch (aFcf & kFcfSrcAddrMask)
    {
    case kFcfSrcAddrNone:
        break;

    case kFcfSrcAddrShort:
        K32WCopy((uint8_t *)&pMacFrame->uSrcAddr.u16Short, &pPsdu, sizeof(otShortAddress), convType);
        break;

    case kFcfSrcAddrExt:
        K32WCopy((uint8_t *)&pMacFrame->uSrcAddr.sExt.u32L, &pPsdu, sizeof(uint32_t), convType);
        K32WCopy((uint8_t *)&pMacFrame->uSrcAddr.sExt.u32H, &pPsdu, sizeof(uint32_t), convType);
        break;

    default:
        error = OT_ERROR_PARSE;
        otEXPECT(false);
    }

    if (convType == otToMacFrame)
    {
        pMacFrame->u8PayloadLength = aOtFrame->mLength - (pPsdu - pSavedStartRxPSDU) - kFcfSize;
    }
    else
    {
        aOtFrame->mInfo.mRxInfo.mAckedWithFramePending = (bool)aMacFormatFrame->sFrameBody.u16Unused;
        aOtFrame->mInfo.mRxInfo.mLqi                   = aMacFormatFrame->u8LinkQuality;
        aOtFrame->mInfo.mRxInfo.mRssi                  = i8Radio_GetLastPacketRSSI();
        aOtFrame->mChannel                             = sChannel;
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
#error Time sync requires the timestamp of SFD rather than that of rx done!
#else
        if (otPlatRadioGetPromiscuous(sInstance))
#endif
        {
            aOtFrame->mInfo.mRxInfo.mTimestamp = otPlatAlarmMilliGetNow() * 1000;
        }

        aOtFrame->mLength = pPsdu + (pMacFrame->u8PayloadLength) - pSavedStartRxPSDU + sizeof(pMacFrame->u16FCS);
    }
    K32WCopy((uint8_t *)&pMacFrame->uPayload, &pPsdu, pMacFrame->u8PayloadLength, convType);

exit:
    return error;
}

/**
 * Helper function for aMacFrame <-> aOtFrame bidirectional conversion
 * Copies from/to PSDU to/from specific field
 *
 * @param[in] aFieldValue     Pointer to field Value which needs to be copied/filled
 * @param[in] aPsdu           Pointer to PSDU part which needs to be copied/filled
 * @param[in] copySize        Bytes copied
 * @param[in] convType        Conversion Type
 *
 * @return    OT_ERROR_NONE      No conversion error
 * @return    OT_ERROR_PARSE     Conversion failed due to parsing error
 */
static void K32WCopy(uint8_t *aFieldValue, uint8_t **aPsdu, uint8_t copySize, frameConversionType convType)
{
    if (convType == macToOtFrame)
    {
        memcpy(*aPsdu, aFieldValue, copySize);
    }
    else
    {
        memcpy(aFieldValue, *aPsdu, copySize);
    }

    (*aPsdu) += copySize;
}

/**
 * Function used to init/reset an RX Ring Buffer
 *
 * @param[in] aRxRing         Pointer to an RX Ring Buffer
 */
static void K32WResetRxRingBuffer(rxRingBuffer *aRxRing)
{
    aRxRing->head   = 0;
    aRxRing->tail   = 0;
    aRxRing->isFull = FALSE;
}

/**
 * Function used to push the address of a received frame to the RX Ring buffer.
 * In case the ring buffer is full, the oldest address is overwritten.
 *
 * @param[in] aRxRing             Pointer to the RX Ring Buffer
 * @param[in] rxFrame             The address for a received frame
 */
static void K32WPushRxRingBuffer(rxRingBuffer *aRxRing, tsRxFrameFormat *aRxFrame)
{
    aRxRing->buffer[aRxRing->head] = aRxFrame;
    if (aRxRing->isFull)
    {
        aRxRing->tail = (aRxRing->tail + 1) % K32W_RX_BUFFERS;
    }

    aRxRing->head   = (aRxRing->head + 1) % K32W_RX_BUFFERS;
    aRxRing->isFull = (aRxRing->head == aRxRing->tail);
}

/**
 * Function used to pop the address of a received frame from the RX Ring buffer
 * Process Context: the consumer will pop frames with the interrupts disabled
 *                  to make sure the interrupt context(ISR) doesn't push in
 *                  the middle of a pop.
 *
 * @param[in] aRxRing           Pointer to the RX Ring Buffer
 *
 * @return    tsRxFrameFormat   Pointer to a received frame
 * @return    NULL              In case the RX Ring buffer is empty
 */
static tsRxFrameFormat *K32WPopRxRingBuffer(rxRingBuffer *aRxRing)
{
    tsRxFrameFormat *rxFrame = NULL;
    uint32_t         savedInterrupts;

    MICRO_DISABLE_AND_SAVE_INTERRUPTS(savedInterrupts);
    if (!K32WIsEmptyRxRingBuffer(aRxRing))
    {
        rxFrame         = aRxRing->buffer[aRxRing->tail];
        aRxRing->isFull = FALSE;
        aRxRing->tail   = (aRxRing->tail + 1) % K32W_RX_BUFFERS;
    }
    MICRO_RESTORE_INTERRUPTS(savedInterrupts);

    return rxFrame;
}

/**
 * Function used to check if an RX Ring buffer is empty
 *
 * @param[in] aRxRing           Pointer to the RX Ring Buffer
 *
 * @return    TRUE              RX Ring Buffer is not empty
 * @return    FALSE             RX Ring Buffer is empty
 */
static bool K32WIsEmptyRxRingBuffer(rxRingBuffer *aRxRing)
{
    return (!aRxRing->isFull && (aRxRing->head == aRxRing->tail));
}

/**
 * Function used to get the next frame from aRxFrame pointed by aRxFrameIndex.
 *
 * This is the address where the BBC should DMA a received frame. Once the
 * reception is complete (the RX interrupt fires) this address is added to the
 * ring buffer and the frame can be consumed by the process context.
 *
 * @param[in] aRxFrame            Pointer to an array of tsRxFrameFormat
 * @param[in] aRxFrameIndex       Pointer to the current index in aRxFrame array
 *
 * @return    tsRxFrameFormat     Pointer to a tsRxFrameFormat
 */
static tsRxFrameFormat *K32WGetFrame(tsRxFrameFormat *aRxFrame, uint8_t *aRxFrameIndex)
{
    tsRxFrameFormat *frame = NULL;

    frame = &aRxFrame[*aRxFrameIndex];
    if (frame != sRxFrameInProcess)
    {
        *aRxFrameIndex = (*aRxFrameIndex + 1) % K32W_RX_BUFFERS;
    }
    else
    {
        /* this can happen only if the RX buffer is full and the
         * process context is interrupted right in the middle of
         * starting to process a frame. In this case, wait for
         * the process context to finish the processing then
         * re-enable RX
         */

        sIsRxDisabled = TRUE;
        frame         = NULL;
    }

    return frame;
}

/**
 * Function used to enable the receiving of a frame
 *
 * @param[in] isNewFrameNeeded FALSE in case the current RX buffer can be
 *                             used for a new RX operation.
 *
 */
static void K32WEnableReceive(bool_t isNewFrameNeeded)
{
    tsRxFrameFormat *pRxFrame = NULL;

    if (isNewFrameNeeded)
    {
        if ((pRxFrame = K32WGetFrame(sRxFrame, &sRxFrameIndex)) != NULL)
        {
            pLastRxFrame = pRxFrame;
            vMMAC_StartMacReceive(&pRxFrame->sFrameBody, sRxOpt);
        }
    }
    else
    {
        vMMAC_StartMacReceive(&pLastRxFrame->sFrameBody, sRxOpt);
    }
}

/**
 * Function used for MMAC-RX Restart
 *
 */
static void K32WRestartRx(void)
{
    vMMAC_SetRxProm(((uint32)sRxOpt >> 8) & ALL_FFs_BYTE);
    vMMAC_RxCtlUpdate(((uint32)sRxOpt) & ALL_FFs_BYTE);
}