/*
 *  Copyright (c) 2016, 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
 * @brief
 *  This file implements the logging function required for the OpenThread library.
 */

#include "precomp.h"
#include "radio.tmh"

void 
LogMac(
    _In_ PCSTR szDir,
    _In_ PMS_FILTER pFilter,
    ULONG frameLength,
    _In_reads_bytes_(frameLength) PUCHAR frame
    );

const char MacSend[] = "MAC_SEND";
const char MacRecv[] = "MAC_RECV";

#define LogMacSend(pFilter, frameLength, frame) LogMac(MacSend, pFilter, frameLength, frame)
#define LogMacRecv(pFilter, frameLength, frame) LogMac(MacRecv, pFilter, frameLength, frame)

void 
otPlatReset(
    _In_ otInstance *otCtx
    )
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    LogFuncEntry(DRIVER_DEFAULT);

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! resetting...", &pFilter->InterfaceGuid);

    // Indicate to the miniport
    (void)otLwfCmdResetDevice(pFilter, TRUE);

    // Finalize previous OpenThread instance
    otLwfReleaseInstance(pFilter);

    // Reset radio layer
    pFilter->otRadioState = OT_RADIO_STATE_DISABLED;
    pFilter->otCurrentListenChannel = 0xFF;
    pFilter->otPromiscuous = false;
    pFilter->otPendingMacOffloadEnabled = FALSE;

    // Reinitialize the OpenThread library
    pFilter->otCachedRole = OT_DEVICE_ROLE_DISABLED;
    pFilter->otCtx = otInstanceInit(pFilter->otInstanceBuffer + sizeof(PMS_FILTER), &pFilter->otInstanceSize);
    ASSERT(pFilter->otCtx);

    // Make sure our helper function returns the right pointer for the filter, given the openthread instance
    NT_ASSERT(otCtxToFilter(pFilter->otCtx) == pFilter);

    // Disable Icmp (ping) handling
    otIcmp6SetEchoEnabled(pFilter->otCtx, FALSE);

    // Register callbacks with OpenThread
    otSetStateChangedCallback(pFilter->otCtx, otLwfStateChangedCallback, pFilter);
    otIp6SetReceiveCallback(pFilter->otCtx, otLwfReceiveIp6DatagramCallback, pFilter);

    // Query the current addresses from TCPIP and cache them
    (void)otLwfInitializeAddresses(pFilter);

    // Initialze media connect state to disconnected
    otLwfIndicateLinkState(pFilter, MediaConnectStateDisconnected);

    LogFuncExit(DRIVER_DEFAULT);
}

otPlatResetReason 
otPlatGetResetReason(
    _In_ otInstance *otCtx
    )
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    return pFilter->cmdResetReason;
}

VOID 
otLwfRadioGetFactoryAddress(
    _In_ PMS_FILTER pFilter
    )
{
    NTSTATUS status;
    PVOID SpinelBuffer = NULL;
    uint8_t *hwAddress = NULL;

    RtlZeroMemory(&pFilter->otFactoryAddress, sizeof(pFilter->otFactoryAddress));

    // Query the MP for the address
    status =
        otLwfCmdGetProp(
            pFilter,
            &SpinelBuffer,
            SPINEL_PROP_HWADDR,
            SPINEL_DATATYPE_EUI64_S,
            &hwAddress
        );
    if (!NT_SUCCESS(status) || hwAddress == NULL)
    {
        LogError(DRIVER_DEFAULT, "Get SPINEL_PROP_HWADDR failed, %!STATUS!", status);
        return;
    }

    NT_ASSERT(SpinelBuffer);
    memcpy(&pFilter->otFactoryAddress, hwAddress, sizeof(pFilter->otFactoryAddress));
    FILTER_FREE_MEM(SpinelBuffer);

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! cached factory Extended Mac Address: %llX", &pFilter->InterfaceGuid, pFilter->otFactoryAddress);
}

VOID 
otLwfRadioInit(
    _In_ PMS_FILTER pFilter
    )
{
    LogFuncEntry(DRIVER_DEFAULT);

    NT_ASSERT(pFilter->DeviceStatus == OTLWF_DEVICE_STATUS_RADIO_MODE);

    // Initialize the OpenThread radio capability flags
    pFilter->otRadioCapabilities = 0;
    if ((pFilter->DeviceCapabilities & OTLWF_DEVICE_CAP_RADIO_ACK_TIMEOUT) != 0)
        pFilter->otRadioCapabilities |= OT_RADIO_CAPS_ACK_TIMEOUT;
    if ((pFilter->DeviceCapabilities & OTLWF_DEVICE_CAP_RADIO_MAC_RETRY_AND_COLLISION_AVOIDANCE) != 0)
        pFilter->otRadioCapabilities |= OT_RADIO_CAPS_TRANSMIT_RETRIES;
    if ((pFilter->DeviceCapabilities & OTLWF_DEVICE_CAP_RADIO_ENERGY_SCAN) != 0)
        pFilter->otRadioCapabilities |= OT_RADIO_CAPS_ENERGY_SCAN;

    pFilter->otRadioState = OT_RADIO_STATE_DISABLED;
    pFilter->otCurrentListenChannel = 0xFF;
    pFilter->otPromiscuous = false;

    pFilter->otReceiveFrame.mPsdu = pFilter->otReceiveMessage;
    pFilter->otTransmitFrame.mPsdu = pFilter->otTransmitMessage;
    
    pFilter->otPendingMacOffloadEnabled = FALSE;

    // Cache the factory address
    otLwfRadioGetFactoryAddress(pFilter);
    
    LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_DISABLED.", pFilter);
    
    LogFuncExit(DRIVER_DEFAULT);
}

void otPlatRadioGetIeeeEui64(otInstance *otCtx, uint8_t *aIeeeEui64)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    memcpy(aIeeeEui64, &pFilter->otFactoryAddress, sizeof(ULONGLONG));
}

void otPlatRadioSetPanId(_In_ otInstance *otCtx, uint16_t panid)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! set PanID: %X", &pFilter->InterfaceGuid, panid);

    pFilter->otPanID = panid;

    if (pFilter->otRadioState != OT_RADIO_STATE_DISABLED &&
        pFilter->otPanID != 0xFFFF)
    {
        // Indicate to the miniport
        status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_MAC_15_4_PANID,
                SPINEL_DATATYPE_UINT16_S,
                panid
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_15_4_PANID failed, %!STATUS!", status);
        }
    }
}

void otPlatRadioSetExtendedAddress(_In_ otInstance *otCtx, uint8_t *address)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;
    spinel_eui64_t extAddr;

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! set Extended Mac Address: %llX", &pFilter->InterfaceGuid, *(ULONGLONG*)address);

    pFilter->otExtendedAddress = *(ULONGLONG*)address;

    for (size_t i = 0; i < OT_EXT_ADDRESS_SIZE; i++)
    {
        extAddr.bytes[i] = address[7 - i];
    }

    // Indicate to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_15_4_LADDR,
            SPINEL_DATATYPE_EUI64_S,
            &extAddr
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_15_4_LADDR failed, %!STATUS!", status);
    }
}

void otPlatRadioSetShortAddress(_In_ otInstance *otCtx, uint16_t address)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! set Short Mac Address: %X", &pFilter->InterfaceGuid, address);

    pFilter->otShortAddress = address;

    if (pFilter->otRadioState != OT_RADIO_STATE_DISABLED)
    {
        // Indicate to the miniport
        status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_MAC_15_4_SADDR,
                SPINEL_DATATYPE_UINT16_S,
                address
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_15_4_SADDR failed, %!STATUS!", status);
        }
    }
}

void otPlatRadioSetPromiscuous(_In_ otInstance *otCtx, bool aEnable)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    pFilter->otPromiscuous = (BOOLEAN)aEnable;

    // Indicate to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_PROMISCUOUS_MODE,
            SPINEL_DATATYPE_UINT8_S,
            aEnable != 0 ? SPINEL_MAC_PROMISCUOUS_MODE_NETWORK : SPINEL_MAC_PROMISCUOUS_MODE_OFF
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_PROMISCUOUS_MODE failed, %!STATUS!", status);
    }
}

bool otPlatRadioIsEnabled(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    return pFilter->otRadioState != OT_RADIO_STATE_DISABLED;
}

otError otPlatRadioEnable(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    NT_ASSERT(pFilter->otRadioState <= OT_RADIO_STATE_SLEEP);
    if (pFilter->otRadioState > OT_RADIO_STATE_SLEEP) return OT_ERROR_BUSY;

    pFilter->otRadioState = OT_RADIO_STATE_SLEEP;

    // Indicate to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_PHY_ENABLED,
            SPINEL_DATATYPE_BOOL_S,
            TRUE
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_PHY_ENABLED (true) failed, %!STATUS!", status);
    }

    LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_SLEEP.", pFilter);

    if (pFilter->otPanID != 0xFFFF)
    {
        // Indicate PANID to the miniport
        status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_MAC_15_4_PANID,
                SPINEL_DATATYPE_UINT16_S,
                pFilter->otPanID
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_15_4_PANID failed, %!STATUS!", status);
        }
    }

    // Indicate Short address to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_15_4_SADDR,
            SPINEL_DATATYPE_UINT16_S,
            pFilter->otShortAddress
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_15_4_SADDR failed, %!STATUS!", status);
    }

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

otError otPlatRadioDisable(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    // First make sure we are in the Sleep state if we weren't already
    if (pFilter->otRadioState > OT_RADIO_STATE_SLEEP)
    {
        (void)otPlatRadioSleep(otCtx);
    }

    pFilter->otRadioState = OT_RADIO_STATE_DISABLED;

    // Indicate to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_PHY_ENABLED,
            SPINEL_DATATYPE_BOOL_S,
            FALSE
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_PHY_ENABLED (false) failed, %!STATUS!", status);
    }

    LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_DISABLED.", pFilter);

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

otError otPlatRadioSleep(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // If we were in the transmit state, cancel the transmit
    if (pFilter->otRadioState == OT_RADIO_STATE_TRANSMIT)
    {
        pFilter->otLastTransmitError = OT_ERROR_ABORT;
        otLwfRadioTransmitFrameDone(pFilter);
    }

    if (pFilter->otRadioState != OT_RADIO_STATE_SLEEP)
    {
        pFilter->otRadioState = OT_RADIO_STATE_SLEEP;
        LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_SLEEP.", pFilter);

        // Indicate to the miniport
        NTSTATUS status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_MAC_RAW_STREAM_ENABLED,
                SPINEL_DATATYPE_BOOL_S,
                FALSE
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_RAW_STREAM_ENABLED (false) failed, %!STATUS!", status);
        }
    }

    return OT_ERROR_NONE;
}

otError otPlatRadioReceive(_In_ otInstance *otCtx, uint8_t aChannel)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    
    NT_ASSERT(pFilter->otRadioState != OT_RADIO_STATE_DISABLED);
    if (pFilter->otRadioState == OT_RADIO_STATE_DISABLED) return OT_ERROR_BUSY;
    
    LogFuncEntryMsg(DRIVER_DATA_PATH, "Filter: %p", pFilter);

    // Update current channel if different
    if (pFilter->otCurrentListenChannel != aChannel)
    {
        NTSTATUS status;

        NT_ASSERT(aChannel >= 11 && aChannel <= 26);

        LogInfo(DRIVER_DEFAULT, "Filter %p new Listen Channel = %u.", pFilter, aChannel);
        pFilter->otCurrentListenChannel = aChannel;

        // Indicate to the miniport
        status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_PHY_CHAN,
                SPINEL_DATATYPE_UINT8_S,
                aChannel
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_PHY_CHAN failed, %!STATUS!", status);
        }
    }

    // Only transition to the receive state if we were sleeping; otherwise we
    // are already in receive or transmit state.
    if (pFilter->otRadioState == OT_RADIO_STATE_SLEEP)
    {
        pFilter->otRadioState = OT_RADIO_STATE_RECEIVE;
        LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_RECEIVE.", pFilter);

        NTSTATUS status =
            otLwfCmdSetProp(
                pFilter,
                SPINEL_PROP_MAC_RAW_STREAM_ENABLED,
                SPINEL_DATATYPE_BOOL_S,
                TRUE
            );
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_RAW_STREAM_ENABLED (true) failed, %!STATUS!", status);
        }

        // Set the event to indicate we can process NBLs
        KeSetEvent(&pFilter->EventWorkerThreadProcessNBLs, 0, FALSE);
    }
    
    LogFuncExit(DRIVER_DATA_PATH);

    return OT_ERROR_NONE;
}

otRadioFrame *otPlatRadioGetTransmitBuffer(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    return &pFilter->otTransmitFrame;
}

int8_t otPlatRadioGetRssi(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    UNREFERENCED_PARAMETER(pFilter);
    return 0;
}

otRadioCaps otPlatRadioGetCaps(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    return otCtxToFilter(otCtx)->otRadioCapabilities;
}

bool otPlatRadioGetPromiscuous(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    return pFilter->otPromiscuous;
}

VOID 
otLwfRadioReceiveFrame(
    _In_ PMS_FILTER pFilter,
    _In_ otError errorCode
    )
{    
    NT_ASSERT(pFilter->otReceiveFrame.mChannel >= 11 && pFilter->otReceiveFrame.mChannel <= 26);

    LogFuncEntryMsg(DRIVER_DATA_PATH, "Filter: %p", pFilter);

    LogMacRecv(pFilter, pFilter->otReceiveFrame.mLength, pFilter->otReceiveFrame.mPsdu);

    if (pFilter->otRadioState > OT_RADIO_STATE_DISABLED)
    {
        otPlatRadioReceiveDone(pFilter->otCtx, &pFilter->otReceiveFrame, errorCode);
    }
    else
    {
        LogVerbose(DRIVER_DATA_PATH, "Mac frame dropped.");
    }
    
    LogFuncExit(DRIVER_DATA_PATH);
}

otError otPlatRadioTransmit(_In_ otInstance *otCtx, _In_ otRadioFrame *aFrame)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    otError error = OT_ERROR_BUSY;

    UNREFERENCED_PARAMETER(aFrame);

    LogFuncEntryMsg(DRIVER_DATA_PATH, "Filter: %p", pFilter);

    NT_ASSERT(pFilter->otRadioState == OT_RADIO_STATE_RECEIVE);
    if (pFilter->otRadioState == OT_RADIO_STATE_RECEIVE)
    {
        error = OT_ERROR_NONE;
        pFilter->otRadioState = OT_RADIO_STATE_TRANSMIT;
    
        LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_TRANSMIT.", pFilter);
    }

    LogFuncExitMsg(DRIVER_DATA_PATH, "%u", error);

    return error;
}

VOID otLwfRadioTransmitFrame(_In_ PMS_FILTER pFilter)
{
    NT_ASSERT(pFilter->otRadioState == OT_RADIO_STATE_TRANSMIT);

    LogMacSend(pFilter, pFilter->otTransmitFrame.mLength, pFilter->otTransmitFrame.mPsdu);

    LogFuncEntryMsg(DRIVER_DATA_PATH, "Filter: %p", pFilter);

    otLwfCmdSendMacFrameAsync(pFilter, &pFilter->otTransmitFrame);

    LogFuncExit(DRIVER_DATA_PATH);
}

VOID 
otLwfRadioTransmitFrameDone(
    _In_ PMS_FILTER pFilter
    )
{
    LogFuncEntryMsg(DRIVER_DATA_PATH, "Filter: %p", pFilter);

    if (pFilter->otRadioState == OT_RADIO_STATE_TRANSMIT)
    {
        pFilter->SendPending = FALSE;

        // Now that we are completing a send, fall back to receive state and set the event
        pFilter->otRadioState = OT_RADIO_STATE_RECEIVE;
        LogInfo(DRIVER_DEFAULT, "Filter %p RadioState = OT_RADIO_STATE_RECEIVE.", pFilter);
        KeSetEvent(&pFilter->EventWorkerThreadProcessNBLs, 0, FALSE);

        if (pFilter->otLastTransmitError != OT_ERROR_NONE &&
            pFilter->otLastTransmitError != OT_ERROR_CHANNEL_ACCESS_FAILURE &&
            pFilter->otLastTransmitError != OT_ERROR_NO_ACK)
        {
            pFilter->otLastTransmitError = OT_ERROR_ABORT;
        }

        if (((pFilter->otTransmitFrame.mPsdu[0] & IEEE802154_ACK_REQUEST) == 0) ||
            pFilter->otLastTransmitError != OT_ERROR_NONE)
        {
            otPlatRadioTxDone(pFilter->otCtx, &pFilter->otTransmitFrame, NULL, pFilter->otLastTransmitError);
        }
        else
        {
            otPlatRadioTxDone(pFilter->otCtx, &pFilter->otTransmitFrame, &pFilter->otReceiveFrame, pFilter->otLastTransmitError);
        }
    }

    LogFuncExit(DRIVER_DATA_PATH);
}

void otPlatRadioEnableSrcMatch(_In_ otInstance *otCtx, bool aEnable)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Ignore if we are already in the correct state
    if (aEnable == pFilter->otPendingMacOffloadEnabled) return;

    // Cache the new value
    pFilter->otPendingMacOffloadEnabled = aEnable ? TRUE : FALSE;

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_ENABLED,
            SPINEL_DATATYPE_BOOL_S,
            (aEnable ? TRUE : FALSE)
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SRC_MATCH_ENABLED failed, %!STATUS!", status);
    }
}

otError otPlatRadioAddSrcMatchShortEntry(_In_ otInstance *otCtx, const uint16_t aShortAddress)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdInsertProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES,
            SPINEL_DATATYPE_UINT16_S,
            aShortAddress
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Insert SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES failed, %!STATUS!", status);
    }

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

otError otPlatRadioAddSrcMatchExtEntry(_In_ otInstance *otCtx, const uint8_t *aExtAddress)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdInsertProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES,
            SPINEL_DATATYPE_EUI64_S,
            aExtAddress
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Insert SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES failed, %!STATUS!", status);
    }

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

otError otPlatRadioClearSrcMatchShortEntry(_In_ otInstance *otCtx, const uint16_t aShortAddress)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdRemoveProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES,
            SPINEL_DATATYPE_UINT16_S,
            aShortAddress
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Remove SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES failed, %!STATUS!", status);
    }

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

otError otPlatRadioClearSrcMatchExtEntry(_In_ otInstance *otCtx, const uint8_t *aExtAddress)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdRemoveProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES,
            SPINEL_DATATYPE_EUI64_S,
            aExtAddress
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Remove SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES failed, %!STATUS!", status);
    }

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

void otPlatRadioClearSrcMatchShortEntries(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES,
            NULL
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES failed, %!STATUS!", status);
    }
}

void otPlatRadioClearSrcMatchExtEntries(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    // Indicate to the miniport
    NTSTATUS status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES,
            NULL
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES failed, %!STATUS!", status);
    }
}

otError otPlatRadioEnergyScan(_In_ otInstance *otCtx, uint8_t aScanChannel, uint16_t aScanDuration)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);

    NTSTATUS status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SCAN_MASK,
            SPINEL_DATATYPE_UINT8_S,
            aScanChannel
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SCAN_MASK failed, %!STATUS!", status);
        goto error;
    }

    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SCAN_PERIOD,
            SPINEL_DATATYPE_UINT16_S,
            aScanDuration
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SCAN_PERIOD failed, %!STATUS!", status);
        goto error;
    }

    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_MAC_SCAN_STATE,
            SPINEL_DATATYPE_UINT8_S,
            SPINEL_SCAN_STATE_ENERGY
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_MAC_SCAN_STATE failed, %!STATUS!", status);
        goto error;
    }

error:

    return NT_SUCCESS(status) ? OT_ERROR_NONE : OT_ERROR_FAILED;
}

void otPlatRadioSetDefaultTxPower(_In_ otInstance *otCtx, int8_t aPower)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;

    // Indicate to the miniport
    status =
        otLwfCmdSetProp(
            pFilter,
            SPINEL_PROP_PHY_TX_POWER,
            SPINEL_DATATYPE_INT8_S,
            aPower
        );
    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Set SPINEL_PROP_PHY_TX_POWER failed, %!STATUS!", status);
    }
}

int8_t otPlatRadioGetReceiveSensitivity(_In_ otInstance *otCtx)
{
    NT_ASSERT(otCtx);
    PMS_FILTER pFilter = otCtxToFilter(otCtx);
    NTSTATUS status;
    int8_t receiveSensitivity;

    status =
        otLwfCmdGetProp(
            pFilter,
            NULL,
            SPINEL_PROP_PHY_RX_SENSITIVITY,
            SPINEL_DATATYPE_INT8_S,
            &receiveSensitivity
        );

    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "Get SPINEL_PROP_PHY_RX_SENSITIVITY, failed, %!STATUS!", status);
        return -100;  // return default value -100dBm
    }

    return receiveSensitivity;
}

inline USHORT getDstShortAddress(const UCHAR *frame)
{
    return (((USHORT)frame[IEEE802154_DSTADDR_OFFSET + 1]) << 8) | frame[IEEE802154_DSTADDR_OFFSET];
}

inline USHORT getSrcShortAddress(ULONG frameLength, _In_reads_bytes_(frameLength) PUCHAR frame, ULONG offset)
{
    return (offset + 1 < frameLength) ? ((((USHORT)frame[offset + 1]) << 8) | frame[offset]) : 0;
}

inline ULONGLONG getDstExtAddress(const UCHAR *frame)
{
    return *(ULONGLONG*)(frame + IEEE802154_DSTADDR_OFFSET);
}

inline ULONGLONG getSrcExtAddress(ULONG frameLength, _In_reads_bytes_(frameLength) PUCHAR frame, ULONG offset)
{
    return (offset + 7 < frameLength) ? (*(ULONGLONG*)(frame + offset)) : 0;
}

void 
LogMac(
    _In_ PCSTR szDir,
    _In_ PMS_FILTER pFilter,
    ULONG frameLength,
    _In_reads_bytes_(frameLength) PUCHAR frame
    )
{
    if (frameLength < 6) return;

    NT_ASSERT(frame);

    UCHAR AckRequested = (frame[0] & IEEE802154_ACK_REQUEST) != 0 ? 1 : 0;
    UCHAR FramePending = (frame[0] & IEEE802154_FRAME_PENDING) != 0 ? 1 : 0;

    switch (frame[1] & (IEEE802154_DST_ADDR_MASK | IEEE802154_SRC_ADDR_MASK))
    {
    case IEEE802154_DST_ADDR_NONE | IEEE802154_SRC_ADDR_NONE:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: null => null (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_NONE | IEEE802154_SRC_ADDR_SHORT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %X => null (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcShortAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET), frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_NONE | IEEE802154_SRC_ADDR_EXT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %llX => null (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcExtAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET), frameLength, AckRequested, FramePending);
        break;
        
    case IEEE802154_DST_ADDR_SHORT | IEEE802154_SRC_ADDR_NONE:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: null => %X (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getDstShortAddress(frame), frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_SHORT | IEEE802154_SRC_ADDR_SHORT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %X => %X (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcShortAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET+2), getDstShortAddress(frame), frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_SHORT | IEEE802154_SRC_ADDR_EXT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %llX => %X (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcExtAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET+2), getDstShortAddress(frame), frameLength, AckRequested, FramePending);
        break;
        
    case IEEE802154_DST_ADDR_EXT | IEEE802154_SRC_ADDR_NONE:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: null => %llX (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getDstExtAddress(frame), frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_EXT | IEEE802154_SRC_ADDR_SHORT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %X => %llX (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcShortAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET+8), getDstExtAddress(frame), frameLength, AckRequested, FramePending);
        break;
    case IEEE802154_DST_ADDR_EXT | IEEE802154_SRC_ADDR_EXT:
        LogVerbose(DRIVER_DATA_PATH, "Filter: %p, %s: %llX => %llX (%u bytes, AckReq=%u, FramePending=%u)", 
            pFilter, szDir, getSrcExtAddress(frameLength, frame, IEEE802154_DSTADDR_OFFSET+8), getDstExtAddress(frame), frameLength, AckRequested, FramePending);
        break;
    }
    
#ifdef LOG_BUFFERS
    otLogBuffer(frame, frameLength);
#endif
}