File content as of revision 0:e89ba455dbcf:

/*
* driver.c - CC31xx/CC32xx Host Driver Implementation
*
* Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
*
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*    Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
*    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.
*
*    Neither the name of Texas Instruments Incorporated 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
*  OWNER 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.
*
*/

/*****************************************************************************/
/* Include files                                                             */
/*****************************************************************************/
#include "cc3100_simplelink.h"
#include "cc3100_protocol.h"
#include "cc3100_driver.h"

#include "fPtr_func.h"

//#include "cc3100_device.h"

/*****************************************************************************/
/* Macro declarations                                                        */
/*****************************************************************************/

namespace mbed_cc3100 {

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
typedef struct {
    uint32_t      Align;
    _SlDriverCb_t DriverCB;
    uint8_t AsyncRespBuf[SL_ASYNC_MAX_MSG_LEN];
} _SlStatMem_t;

_SlStatMem_t g_StatMem;
#endif


_SlDriverCb_t* g_pCB = NULL;

uint8_t gFirstCmdMode = 0;

const _SlSyncPattern_t g_H2NSyncPattern = H2N_SYNC_PATTERN;
const _SlSyncPattern_t g_H2NCnysPattern = H2N_CNYS_PATTERN;
const _SlActionLookup_t _SlActionLookupTable[7] = {
    {ACCEPT_ID, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE, (_SlSpawnEntryFunc_t) &_sl_HandleAsync_Accept},
    {CONNECT_ID, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Connect},
    {SELECT_ID, SL_OPCODE_SOCKET_SELECTASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Select},
    {GETHOSYBYNAME_ID, SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_DnsGetHostByName},
    {GETHOSYBYSERVICE_ID, SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_DnsGetHostByService},
    {PING_ID, SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE, (_SlSpawnEntryFunc_t) &_sl_HandleAsync_PingResponse},
    {START_STOP_ID, SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Stop}

};

cc3100_driver::cc3100_driver(cc3100_nonos &nonos, cc3100_netapp &netapp, cc3100_flowcont &flowcont, cc3100_spi &spi)
    :  _nonos(nonos),_netapp(netapp), _flowcont(flowcont), _spi(spi)
{

}

cc3100_driver::~cc3100_driver()
{

}

/*****************************************************************************/
/* Variables                                                                 */
/*****************************************************************************/

/********************************************************************************/

/*****************************************************************************/
/* Internal functions                                                        */
/*****************************************************************************/
bool cc3100_driver::_SL_PENDING_RX_MSG(pDriver* pDriverCB){
	
	if((pDriverCB)->RxIrqCnt != (pDriverCB)->RxDoneCnt){
	    return TRUE;
 	}else{
	    return FALSE;
	}
}

/*****************************************************************************
_SlDrvDriverCBInit - init Driver Control Block
*****************************************************************************/
void cc3100_driver::_SlDrvDriverCBInit(void)
{
    
    uint8_t Idx;

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
    g_pCB = &(g_StatMem.DriverCB);
#else
    g_pCB = sl_Malloc(sizeof(_SlDriverCb_t));
#endif
   
    MALLOC_OK_CHECK(g_pCB);
    memset((g_pCB), 0, sizeof(_SlDriverCb_t));
    
    OSI_RET_OK_CHECK( _nonos.sl_SyncObjCreate(&g_pCB->CmdSyncObj, "CmdSyncObj") );
    _nonos.sl_SyncObjClear(&g_pCB->CmdSyncObj);
    
    OSI_RET_OK_CHECK( _nonos.sl_LockObjCreate(&g_pCB->GlobalLockObj, "GlobalLockObj") );

    OSI_RET_OK_CHECK( _nonos.sl_LockObjCreate(&g_pCB->ProtectionLockObj, "ProtectionLockObj") );
    
    _SlDrvObjInit();
    for (Idx = 0; Idx < MAX_CONCURRENT_ACTIONS; Idx++) {
        OSI_RET_OK_CHECK( _nonos.sl_SyncObjCreate(&g_pCB->ObjPool[Idx].SyncObj, "SyncObj") );
        _nonos.sl_SyncObjClear(&g_pCB->ObjPool[Idx].SyncObj);
    }
    _flowcont._SlDrvFlowContInit();
    gFirstCmdMode = 0;
}

/*****************************************************************************
_SlDrvDriverCBDeinit - De init Driver Control Block
*****************************************************************************/
void cc3100_driver::_SlDrvDriverCBDeinit()
{
    uint8_t        Idx;
    _flowcont._SlDrvFlowContDeinit();

    OSI_RET_OK_CHECK( _nonos.sl_SyncObjDelete(&g_pCB->CmdSyncObj, 0) );

    OSI_RET_OK_CHECK( _nonos.sl_LockObjDelete(&g_pCB->GlobalLockObj, 0) );

    OSI_RET_OK_CHECK( _nonos.sl_LockObjDelete(&g_pCB->ProtectionLockObj, 0) );
    for (Idx = 0; Idx < MAX_CONCURRENT_ACTIONS; Idx++) {
        OSI_RET_OK_CHECK( _nonos.sl_SyncObjDelete(&g_pCB->ObjPool[Idx].SyncObj, 0) );
    }

    _SlDrvObjDeInit();

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
    g_pCB = NULL;
#else
    sl_Free(g_pCB);
#endif

    g_pCB = NULL;
}

/*****************************************************************************
_SlDrvRxIrqHandler - Interrupt handler
*****************************************************************************/

void cc3100_driver::_SlDrvRxIrqHandler(void *pValue)
{
    
    
    _spi.MaskIntHdlr();
    g_pCB->RxIrqCnt++;
    if (TRUE == g_pCB->IsCmdRespWaited) {
        OSI_RET_OK_CHECK( _nonos.sl_SyncObjSignalFromIRQ(&g_pCB->CmdSyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE) );
    } else {
        _nonos._SlNonOsSpawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
    }
}

/*****************************************************************************
_SlDrvCmdOp
*****************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvCmdOp(_SlCmdCtrl_t *pCmdCtrl,void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
{
    
    _SlReturnVal_t RetVal;
    
    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));
    
    g_pCB->IsCmdRespWaited = TRUE;
    //SL_TRACE0(DBG_MSG, MSG_312, "_SlDrvCmdOp: call _SlDrvMsgWrite");
    /* send the message */
    g_pCB->FunctionParams.pCmdCtrl = pCmdCtrl;
    g_pCB->FunctionParams.pTxRxDescBuff = (uint8_t*)pTxRxDescBuff;
    g_pCB->FunctionParams.pCmdExt = pCmdExt;
    
    RetVal = _SlDrvMsgWrite();
    
    if(SL_OS_RET_CODE_OK == RetVal) {

#ifndef SL_IF_TYPE_UART
        /* Waiting for SPI to stabilize after first command */
        if( 0 == gFirstCmdMode ) {           
            gFirstCmdMode = 1;
            wait_ms(2);
        }
#endif
        
        /* wait for respond */
        RetVal = _SlDrvMsgReadCmdCtx(); /* will free global lock */
        //SL_TRACE0(DBG_MSG, MSG_314, "_SlDrvCmdOp: exited _SlDrvMsgReadCmdCtx");
        
    } else {
        OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
    }
    return RetVal;
}

/*****************************************************************************
_SlDrvCmdSend
Send SL command without waiting for command response
This function is unprotected and the caller should make
sure global lock is active
*****************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvCmdSend(_SlCmdCtrl_t *pCmdCtrl, void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
{
    _SlReturnVal_t RetVal;

    g_pCB->IsCmdRespWaited = FALSE;

    SL_TRACE0(DBG_MSG, MSG_312, "_SlDrvCmdSend: call _SlDrvMsgWrite");
    /*  send the message */
    g_pCB->FunctionParams.pCmdCtrl = pCmdCtrl;
    g_pCB->FunctionParams.pTxRxDescBuff = (uint8_t*)pTxRxDescBuff;
    g_pCB->FunctionParams.pCmdExt = pCmdExt;

    RetVal = _SlDrvMsgWrite();

    return RetVal;
}

/*****************************************************************************
_SlDrvDataReadOp
*****************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvDataReadOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl, void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
{
    _SlReturnVal_t RetVal;
    uint8_t ObjIdx = MAX_CONCURRENT_ACTIONS;
    _SlArgsData_t pArgsData;

    /* Validate input arguments */
    VERIFY_PROTOCOL(NULL != pCmdExt->pRxPayload);

    /* If zero bytes is requested, return error. */
    /*  This allows us not to fill remote socket's IP address in return arguments */
    VERIFY_PROTOCOL(0 != pCmdExt->RxPayloadLen);

    /* Validate socket */
    if((Sd & BSD_SOCKET_ID_MASK) >= SL_MAX_SOCKETS) {
        return SL_EBADF;
    }

    /*Use Obj to issue the command, if not available try later*/
    ObjIdx = (uint8_t)_SlDrvWaitForPoolObj(RECV_ID, Sd & BSD_SOCKET_ID_MASK);

    if (MAX_CONCURRENT_ACTIONS == ObjIdx) {
        return SL_POOL_IS_EMPTY;
    }

    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));

    pArgsData.pData = pCmdExt->pRxPayload;
    pArgsData.pArgs =  (uint8_t *)pTxRxDescBuff;
    g_pCB->ObjPool[ObjIdx].pRespArgs =  (uint8_t *)&pArgsData;
    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));


    /* Do Flow Control check/update for DataWrite operation */
    OSI_RET_OK_CHECK( _nonos.sl_LockObjLock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER) );

    /* Clear SyncObj for the case it was signalled before TxPoolCnt */
    /* dropped below '1' (last Data buffer was taken)  */
    /* OSI_RET_OK_CHECK( sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj) ); */
    _nonos.sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);

    if(g_pCB->FlowContCB.TxPoolCnt <= FLOW_CONT_MIN) {

        /* If TxPoolCnt was increased by other thread at this moment,
        TxSyncObj won't wait here */
        OSI_RET_OK_CHECK( _nonos.sl_SyncObjWait(&g_pCB->FlowContCB.TxSyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE, NON_OS_SYNC_OBJ_CLEAR_VALUE, SL_OS_WAIT_FOREVER) );
    }

    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));

    VERIFY_PROTOCOL(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN);
    g_pCB->FlowContCB.TxPoolCnt--;

    OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );

    /* send the message */
    g_pCB->TempProtocolHeader.Opcode 	= pCmdCtrl->Opcode;
    g_pCB->TempProtocolHeader.Len	= _SL_PROTOCOL_CALC_LEN(pCmdCtrl,pCmdExt);
    g_pCB->FunctionParams.pCmdCtrl      = pCmdCtrl;
    g_pCB->FunctionParams.pTxRxDescBuff = (uint8_t *)pTxRxDescBuff;
    g_pCB->FunctionParams.pCmdExt       = pCmdExt;
    RetVal =  _SlDrvMsgWrite();

    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));

    if(SL_OS_RET_CODE_OK == RetVal) {
        /* Wait for response message. Will be signalled by _SlDrvMsgRead. */
        OSI_RET_OK_CHECK(_nonos.sl_SyncObjWait(&g_pCB->ObjPool[ObjIdx].SyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE, NON_OS_SYNC_OBJ_CLEAR_VALUE, SL_OS_WAIT_FOREVER));
    }

    _SlDrvReleasePoolObj(ObjIdx);
    return RetVal;
}

/* ******************************************************************************/
/*   _SlDrvDataWriteOp                                                          */
/* ******************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvDataWriteOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl, void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
{
    printf("Debug _SlDrvDataWriteOp\r\n");
    _SlReturnVal_t  RetVal = SL_EAGAIN; /*  initiated as SL_EAGAIN for the non blocking mode */
    while( 1 ) {
        /*  Do Flow Control check/update for DataWrite operation */        
        OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));
        /*  Clear SyncObj for the case it was signalled before TxPoolCnt */
        /*  dropped below '1' (last Data buffer was taken) */
        /* OSI_RET_OK_CHECK( sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj) ); */
        _nonos.sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);
        /*  we have indication that the last send has failed - socket is no longer valid for operations  */
        if(g_pCB->SocketTXFailure & (1<<(Sd & BSD_SOCKET_ID_MASK))) {
            OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );
            return SL_SOC_ERROR;
        }
        //printf("Debug _SlDrvDataWriteOp 3\r\n");
        if(g_pCB->FlowContCB.TxPoolCnt <= FLOW_CONT_MIN + 1) {
            /*  we have indication that this socket is set as blocking and we try to  */
            /*  unblock it - return an error */
            if( g_pCB->SocketNonBlocking >> (Sd & BSD_SOCKET_ID_MASK) ) {
                OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );
                return RetVal;
            }
            /*  If TxPoolCnt was increased by other thread at this moment, */
            /*  TxSyncObj won't wait here */
            OSI_RET_OK_CHECK( _nonos.sl_SyncObjWait(&g_pCB->FlowContCB.TxSyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE, NON_OS_SYNC_OBJ_CLEAR_VALUE, SL_OS_WAIT_FOREVER) );
        }

        if(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN + 1 ) {
            break;
        } else {
            OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );
        }
    }
    OSI_RET_OK_CHECK( _nonos.sl_LockObjLock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER) );

    VERIFY_PROTOCOL(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN + 1 );
    g_pCB->FlowContCB.TxPoolCnt--;

    OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->FlowContCB.TxLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );
    
    /*  send the message */
    g_pCB->TempProtocolHeader.Opcode 	= pCmdCtrl->Opcode;
    g_pCB->TempProtocolHeader.Len	= _SL_PROTOCOL_CALC_LEN(pCmdCtrl,pCmdExt);

    g_pCB->FunctionParams.pCmdCtrl = pCmdCtrl;
    g_pCB->FunctionParams.pTxRxDescBuff = (unsigned char*)pTxRxDescBuff;
    g_pCB->FunctionParams.pCmdExt = pCmdExt;
    
    RetVal =  _SlDrvMsgWrite();
    
    OSI_RET_OK_CHECK( _nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE) );

    return RetVal;
}

/* ******************************************************************************/
/*  _SlDrvMsgWrite */
/* ******************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvMsgWrite(void)
{
    
    VERIFY_PROTOCOL(NULL != g_pCB->FunctionParams.pCmdCtrl);

    g_pCB->TempProtocolHeader.Opcode 	= g_pCB->FunctionParams.pCmdCtrl->Opcode;
    g_pCB->TempProtocolHeader.Len	= _SL_PROTOCOL_CALC_LEN(g_pCB->FunctionParams.pCmdCtrl,
                                      g_pCB->FunctionParams.pCmdExt);
    /*  */
    if (g_pCB->RelayFlagsViaRxPayload == TRUE) {
        g_pCB->TempProtocolHeader.Len = g_pCB->TempProtocolHeader.Len + g_pCB->FunctionParams.pCmdExt->RxPayloadLen;
    }

#ifdef SL_START_WRITE_STAT
    sl_IfStartWriteSequence(g_pCB->FD);
#endif

#ifdef SL_IF_TYPE_UART
    /*  Write long sync pattern */
    _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NSyncPattern.Long, 2*SYNC_PATTERN_LEN);
#else
    /*  Write short sync pattern */
    _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NSyncPattern.Short, SYNC_PATTERN_LEN);
#endif

    /*  Header */
    _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_pCB->TempProtocolHeader, _SL_CMD_HDR_SIZE);

    /*  Descriptors */
    if (g_pCB->FunctionParams.pTxRxDescBuff && g_pCB->FunctionParams.pCmdCtrl->TxDescLen > 0) {
        _spi.spi_Write(g_pCB->FD, g_pCB->FunctionParams.pTxRxDescBuff,
                           _SL_PROTOCOL_ALIGN_SIZE(g_pCB->FunctionParams.pCmdCtrl->TxDescLen));
    }

    /*  A special mode where Rx payload and Rx length are used as Tx as well */
    /*  This mode requires no Rx payload on the response and currently used by fs_Close and sl_Send on */
    /*  transceiver mode */
    if (g_pCB->RelayFlagsViaRxPayload == TRUE ) {
        g_pCB->RelayFlagsViaRxPayload = FALSE;
        _spi.spi_Write(g_pCB->FD, g_pCB->FunctionParams.pCmdExt->pRxPayload,
                           _SL_PROTOCOL_ALIGN_SIZE(g_pCB->FunctionParams.pCmdExt->RxPayloadLen));
    }

    /*  Payload */
    if (g_pCB->FunctionParams.pCmdExt && g_pCB->FunctionParams.pCmdExt->TxPayloadLen > 0) {
        /*  If the message has payload, it is mandatory that the message's arguments are protocol aligned. */
        /*  Otherwise the aligning of arguments will create a gap between arguments and payload. */
        VERIFY_PROTOCOL(_SL_IS_PROTOCOL_ALIGNED_SIZE(g_pCB->FunctionParams.pCmdCtrl->TxDescLen));

        _spi.spi_Write(g_pCB->FD, g_pCB->FunctionParams.pCmdExt->pTxPayload,
                           _SL_PROTOCOL_ALIGN_SIZE(g_pCB->FunctionParams.pCmdExt->TxPayloadLen));
    }


    _SL_DBG_CNT_INC(MsgCnt.Write);

#ifdef SL_START_WRITE_STAT
    sl_IfEndWriteSequence(g_pCB->FD);
#endif

    return SL_OS_RET_CODE_OK;
}

/* ******************************************************************************/
/*  _SlDrvMsgRead  */
/* ******************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvMsgRead(void)
{
    /*  alignment for small memory models */
    union {
        uint8_t   TempBuf[_SL_RESP_HDR_SIZE];
        uint32_t  DummyBuf[2];
    } uBuf;

    uint8_t  TailBuffer[4];
    uint16_t LengthToCopy;
    uint16_t AlignedLengthRecv;
    uint8_t  AlignSize;
    
    VERIFY_RET_OK(_SlDrvRxHdrRead((uint8_t*)(uBuf.TempBuf), &AlignSize));

    /* 'Init Compelete' message bears no valid FlowControl info */
    if(SL_OPCODE_DEVICE_INITCOMPLETE != OPCODE(uBuf.TempBuf)) {
        g_pCB->FlowContCB.TxPoolCnt = ((_SlResponseHeader_t *)uBuf.TempBuf)->TxPoolCnt;
        g_pCB->SocketNonBlocking = ((_SlResponseHeader_t *)uBuf.TempBuf)->SocketNonBlocking;
        g_pCB->SocketTXFailure = ((_SlResponseHeader_t *)uBuf.TempBuf)->SocketTXFailure;

        if(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN) {
            OSI_RET_OK_CHECK(_nonos.sl_SyncObjSignal(&g_pCB->FlowContCB.TxSyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE));
        }
    }

    _SlDrvClassifyRxMsg(OPCODE(uBuf.TempBuf));

    switch(g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
        case ASYNC_EVT_CLASS:

            VERIFY_PROTOCOL(NULL == g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
            g_pCB->FunctionParams.AsyncExt.pAsyncBuf = g_StatMem.AsyncRespBuf;
#else
            g_pCB->FunctionParams.AsyncExt.pAsyncBuf = sl_Malloc(SL_ASYNC_MAX_MSG_LEN);
#endif
            MALLOC_OK_CHECK(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

            memcpy(g_pCB->FunctionParams.AsyncExt.pAsyncBuf, uBuf.TempBuf, _SL_RESP_HDR_SIZE);

            /*  This is an Async message. Read the rest of it. */
            if (_SL_PROTOCOL_ALIGN_SIZE(RSP_PAYLOAD_LEN(uBuf.TempBuf)) <= SL_ASYNC_MAX_PAYLOAD_LEN) {
                AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(RSP_PAYLOAD_LEN(uBuf.TempBuf));
            } else {
                AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(SL_ASYNC_MAX_PAYLOAD_LEN);
            }

            if (RSP_PAYLOAD_LEN(uBuf.TempBuf) > 0) {
                _spi.spi_Read(g_pCB->FD, g_pCB->FunctionParams.AsyncExt.pAsyncBuf + _SL_RESP_HDR_SIZE, AlignedLengthRecv);
            }
            /* In case ASYNC RX buffer length is smaller then the received data length, dump the rest */
            if ((_SL_PROTOCOL_ALIGN_SIZE(RSP_PAYLOAD_LEN(uBuf.TempBuf)) > SL_ASYNC_MAX_PAYLOAD_LEN)) {
                AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(RSP_PAYLOAD_LEN(uBuf.TempBuf)) - SL_ASYNC_MAX_PAYLOAD_LEN;
                while (AlignedLengthRecv > 0) {
                    _spi.spi_Read(g_pCB->FD,TailBuffer,4);
                    AlignedLengthRecv = AlignedLengthRecv - 4;
                }
            }
            OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));

            if ((SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE == OPCODE(uBuf.TempBuf)) || (SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE_V6 == OPCODE(uBuf.TempBuf)) || (SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE == OPCODE(uBuf.TempBuf))) {
                /* go over the active list if exist to find obj waiting for this Async event */
                _SlFindAndSetActiveObj(OPCODE(uBuf.TempBuf),(((_SocketResponse_t *)(g_pCB->FunctionParams.AsyncExt.pAsyncBuf + _SL_RESP_HDR_SIZE))->sd) & BSD_SOCKET_ID_MASK);
            } else {
                _SlFindAndSetActiveObj(OPCODE(uBuf.TempBuf),SL_MAX_SOCKETS);
            }
            OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));

            break;

        case RECV_RESP_CLASS: {
            uint8_t   ExpArgSize; /*  Expected size of Recv/Recvfrom arguments */

            switch(OPCODE(uBuf.TempBuf)) {
                case SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE:
                    ExpArgSize = RECVFROM_IPV4_ARGS_SIZE;
                    break;
                case SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6:
                    ExpArgSize = RECVFROM_IPV6_ARGS_SIZE;
                    break;
                default:
                    /* SL_OPCODE_SOCKET_RECVASYNCRESPONSE: */
                    ExpArgSize = RECV_ARGS_SIZE;
            }

            /*  Read first 4 bytes of Recv/Recvfrom response to get SocketId and actual  */
            /*  response data length */
            _spi.spi_Read(g_pCB->FD, &uBuf.TempBuf[4], RECV_ARGS_SIZE);

            /*  Validate Socket ID and Received Length value.  */
            VERIFY_PROTOCOL((SD(&uBuf.TempBuf[4])& BSD_SOCKET_ID_MASK) < SL_MAX_SOCKETS);

            OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));

            /* go over the active list if exist to find obj waiting for this Async event */
            VERIFY_RET_OK(_SlFindAndSetActiveObj(OPCODE(uBuf.TempBuf),SD(&uBuf.TempBuf[4]) & BSD_SOCKET_ID_MASK));

            /*  Verify data is waited on this socket. The pArgs should have been set by _SlDrvDataReadOp(). */
            VERIFY_SOCKET_CB(NULL !=  ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pData))->pArgs);

            memcpy( ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pArgs, &uBuf.TempBuf[4], RECV_ARGS_SIZE);

            if(ExpArgSize > RECV_ARGS_SIZE) {
                _spi.spi_Read(g_pCB->FD,
                                  ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pArgs + RECV_ARGS_SIZE,
                                  ExpArgSize - RECV_ARGS_SIZE);
            }

            /*  Here g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pData contains requested(expected) Recv/Recvfrom DataSize. */
            /*  Overwrite requested DataSize with actual one. */
            /*  If error is received, this information will be read from arguments. */
            if(ACT_DATA_SIZE(&uBuf.TempBuf[4]) > 0) {
                VERIFY_SOCKET_CB(NULL != ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData);

                /*  Read 4 bytes aligned from interface */
                /*  therefore check the requested length and read only  */
                /*  4 bytes aligned data. The rest unaligned (if any) will be read */
                /*  and copied to a TailBuffer  */
                LengthToCopy = ACT_DATA_SIZE(&uBuf.TempBuf[4]) & (3);
                AlignedLengthRecv = ACT_DATA_SIZE(&uBuf.TempBuf[4]) & (~3);
                if( AlignedLengthRecv >= 4) {
                    _spi.spi_Read(g_pCB->FD,((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData,AlignedLengthRecv );
                }
                /*  copy the unaligned part, if any */
                if( LengthToCopy > 0) {
                    _spi.spi_Read(g_pCB->FD,TailBuffer,4);
                    /*  copy TailBuffer unaligned part (1/2/3 bytes) */
                    memcpy(((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData + AlignedLengthRecv,TailBuffer,LengthToCopy);
                }
            }
            OSI_RET_OK_CHECK(_nonos.sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE));
            OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
        }
        break;

        case CMD_RESP_CLASS:

            /*  Some commands pass a maximum arguments size. */
            /*  In this case Driver will send extra dummy patterns to NWP if */
            /*  the response message is smaller than maximum. */
            /*  When RxDescLen is not exact, using RxPayloadLen is forbidden! */
            /*  If such case cannot be avoided - parse message here to detect */
            /*  arguments/payload border. */
            _spi.spi_Read(g_pCB->FD, g_pCB->FunctionParams.pTxRxDescBuff, _SL_PROTOCOL_ALIGN_SIZE(g_pCB->FunctionParams.pCmdCtrl->RxDescLen));

            if((NULL != g_pCB->FunctionParams.pCmdExt) && (0 != g_pCB->FunctionParams.pCmdExt->RxPayloadLen)) {
                /*  Actual size of command's response payload: <msg_payload_len> - <rsp_args_len> */
                int16_t    ActDataSize = RSP_PAYLOAD_LEN(uBuf.TempBuf) - g_pCB->FunctionParams.pCmdCtrl->RxDescLen;

                g_pCB->FunctionParams.pCmdExt->ActualRxPayloadLen = ActDataSize;

                /* Check that the space prepared by user for the response data is sufficient. */
                if(ActDataSize <= 0) {
                    g_pCB->FunctionParams.pCmdExt->RxPayloadLen = 0;
                } else {
                    /* In case the user supplied Rx buffer length which is smaller then the received data length, copy according to user length */
                    if (ActDataSize > g_pCB->FunctionParams.pCmdExt->RxPayloadLen) {
                        LengthToCopy = g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (3);
                        AlignedLengthRecv = g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (~3);
                    } else {
                        LengthToCopy = ActDataSize & (3);
                        AlignedLengthRecv = ActDataSize & (~3);
                    }
                    /*  Read 4 bytes aligned from interface */
                    /*  therefore check the requested length and read only  */
                    /*  4 bytes aligned data. The rest unaligned (if any) will be read */
                    /*  and copied to a TailBuffer  */

                    if( AlignedLengthRecv >= 4) {
                        _spi.spi_Read(g_pCB->FD,
                                          g_pCB->FunctionParams.pCmdExt->pRxPayload,
                                          AlignedLengthRecv );

                    }
                    /*  copy the unaligned part, if any */
                    if( LengthToCopy > 0) {
                        _spi.spi_Read(g_pCB->FD,TailBuffer,4);
                        /*  copy TailBuffer unaligned part (1/2/3 bytes) */
                        memcpy(g_pCB->FunctionParams.pCmdExt->pRxPayload + AlignedLengthRecv,
                                  TailBuffer,
                                  LengthToCopy);
                        ActDataSize = ActDataSize-4;
                    }
                    /* In case the user supplied Rx buffer length which is smaller then the received data length, dump the rest */
                    if (ActDataSize > g_pCB->FunctionParams.pCmdExt->RxPayloadLen) {
                        /* calculate the rest of the data size to dump */
                        AlignedLengthRecv = ActDataSize - (g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (~3));
                        while( AlignedLengthRecv > 0) {
                            _spi.spi_Read(g_pCB->FD,TailBuffer, 4 );
                            AlignedLengthRecv = AlignedLengthRecv - 4;
                        }
                    }
                }
            }
            break;

        default:
            /*  DUMMY_MSG_CLASS: Flow control message has no payload. */
            break;
    }

    if(AlignSize > 0) {
        _spi.spi_Read(g_pCB->FD, uBuf.TempBuf, AlignSize);
    }

    _SL_DBG_CNT_INC(MsgCnt.Read);

    /*  Unmask Interrupt call */
    _spi.UnMaskIntHdlr();
    
    return SL_OS_RET_CODE_OK;
}

/* ******************************************************************************/
/*  _SlAsyncEventGenericHandler */
/* ******************************************************************************/
void cc3100_driver::_SlAsyncEventGenericHandler(void)
{
    _SlResponseHeader_t      *pHdr = (_SlResponseHeader_t *)g_pCB->FunctionParams.AsyncExt.pAsyncBuf;
    SlWlanEvent_t            wlanEvent;
    SlNetAppEvent_t          netAppEvent;
    SlSockEvent_t            sockAppEvent;
     
    if (NULL != g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler) {
        switch(pHdr->GenHeader.Opcode) {
    
            case  SL_OPCODE_WLAN_P2P_DEV_FOUND: {
                slPeerInfoAsyncResponse_t* pResp = (slPeerInfoAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                wlanEvent.Event = SL_WLAN_P2P_DEV_FOUND_EVENT;
                memcpy(wlanEvent.EventData.P2PModeDevFound.mac,pResp->mac, 6);
                memcpy(wlanEvent.EventData.P2PModeDevFound.go_peer_device_name,pResp->go_peer_device_name,pResp->go_peer_device_name_len);
                wlanEvent.EventData.P2PModeDevFound.go_peer_device_name_len = pResp->go_peer_device_name_len;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
                break;
            }

            case SL_OPCODE_WLAN_P2P_NEG_REQ_RECEIVED: {
                slPeerInfoAsyncResponse_t* pResp = (slPeerInfoAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

                wlanEvent.Event = SL_WLAN_P2P_NEG_REQ_RECEIVED_EVENT;
                memcpy(wlanEvent.EventData.P2PModeNegReqReceived.mac,pResp->mac, 6);
                memcpy(wlanEvent.EventData.P2PModeNegReqReceived.go_peer_device_name,pResp->go_peer_device_name,pResp->go_peer_device_name_len);
                wlanEvent.EventData.P2PModeNegReqReceived.go_peer_device_name_len = pResp->go_peer_device_name_len;
                wlanEvent.EventData.P2PModeNegReqReceived.wps_dev_password_id = pResp->wps_dev_password_id;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
                break;
            }
            case SL_OPCODE_WLAN_CONNECTION_FAILED: {
                slWlanConnFailureAsyncResponse_t* pResp = (slWlanConnFailureAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

                wlanEvent.Event = SL_WLAN_CONNECTION_FAILED_EVENT;
                wlanEvent.EventData.P2PModewlanConnectionFailure.status = pResp->status;

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
                break;
            }

            case SL_OPCODE_WLAN_WLANASYNCCONNECTEDRESPONSE: {
                slWlanConnectAsyncResponse_t *pWlanResp = (slWlanConnectAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                memset(&wlanEvent.EventData.STAandP2PModeWlanConnected,0,sizeof(slWlanConnectAsyncResponse_t));
                wlanEvent.Event = SL_WLAN_CONNECT_EVENT;
                wlanEvent.EventData.STAandP2PModeWlanConnected.connection_type = pWlanResp->connection_type;
                memcpy(wlanEvent.EventData.STAandP2PModeWlanConnected.bssid, pWlanResp->bssid, 6);
                memcpy(wlanEvent.EventData.STAandP2PModeWlanConnected.go_peer_device_name,pWlanResp->go_peer_device_name,pWlanResp->go_peer_device_name_len);
                memcpy(wlanEvent.EventData.STAandP2PModeWlanConnected.ssid_name, pWlanResp->ssid_name, pWlanResp->ssid_len);
                wlanEvent.EventData.STAandP2PModeWlanConnected.ssid_len = pWlanResp->ssid_len;
                wlanEvent.EventData.STAandP2PModeWlanConnected.go_peer_device_name_len = pWlanResp->go_peer_device_name_len;

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
                break;
            }
            case SL_OPCODE_WLAN_WLANASYNCDISCONNECTEDRESPONSE: {
                slWlanConnectAsyncResponse_t *pWlanResp = (slWlanConnectAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                memset(&wlanEvent.EventData.STAandP2PModeDisconnected,0,sizeof(slWlanConnectAsyncResponse_t));
                wlanEvent.Event = SL_WLAN_DISCONNECT_EVENT;
                wlanEvent.EventData.STAandP2PModeDisconnected.connection_type = pWlanResp->connection_type;
                memcpy(wlanEvent.EventData.STAandP2PModeDisconnected.bssid, pWlanResp->bssid, 6);
                memcpy(wlanEvent.EventData.STAandP2PModeDisconnected.go_peer_device_name,pWlanResp->go_peer_device_name,pWlanResp->go_peer_device_name_len);
                memcpy(wlanEvent.EventData.STAandP2PModeDisconnected.ssid_name, pWlanResp->ssid_name, pWlanResp->ssid_len);
                wlanEvent.EventData.STAandP2PModeDisconnected.ssid_len = pWlanResp->ssid_len;
                wlanEvent.EventData.STAandP2PModeDisconnected.reason_code = pWlanResp->reason_code;
                wlanEvent.EventData.STAandP2PModeDisconnected.go_peer_device_name_len = pWlanResp->go_peer_device_name_len;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
                break;
            }
            case SL_OPCODE_NETAPP_IPACQUIRED: {
                SlIpV4AcquiredAsync_t *pIpV4 = (SlIpV4AcquiredAsync_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                netAppEvent.Event = SL_NETAPP_IPV4_IPACQUIRED_EVENT;
                netAppEvent.EventData.ipAcquiredV4.ip = pIpV4->ip;
                netAppEvent.EventData.ipAcquiredV4.gateway = pIpV4->gateway;
                netAppEvent.EventData.ipAcquiredV4.dns = pIpV4->dns;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler((SlNetAppEvent_t*)&netAppEvent);
                
            }
            break;
            case SL_OPCODE_NETAPP_IPACQUIRED_V6: {
                SlIpV6AcquiredAsync_t *pIpV6 = (SlIpV6AcquiredAsync_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                netAppEvent.Event =  SL_NETAPP_IPV6_IPACQUIRED_EVENT;
                memcpy((void *)&netAppEvent.EventData.ipAcquiredV6.ip[0],(void *)&pIpV6->ip[0],sizeof(pIpV6->ip[0])*4);
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&netAppEvent);
               
            }
            break;

            case SL_OPCODE_NETAPP_IP_LEASED: {
                SlIpLeasedAsync_t *pIpV4 = (SlIpLeasedAsync_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                netAppEvent.Event = SL_NETAPP_IP_LEASED_EVENT;
                netAppEvent.EventData.ipLeased.ip_address = pIpV4->ip_address;
                netAppEvent.EventData.ipLeased.lease_time = pIpV4->lease_time;
                memcpy(netAppEvent.EventData.ipLeased.mac, pIpV4->mac, 6);

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&netAppEvent);
            }
            break;

            case SL_OPCODE_NETAPP_IP_RELEASED: {
                SlIpReleasedAsync_t *pIpV4 = (SlIpReleasedAsync_t *)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                netAppEvent.Event = SL_NETAPP_IP_RELEASED_EVENT;
                netAppEvent.EventData.ipReleased.ip_address = pIpV4->ip_address;
                netAppEvent.EventData.ipReleased.reason = pIpV4->reason;
                memcpy(netAppEvent.EventData.ipReleased.mac, pIpV4->mac, 6);

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&netAppEvent);
            }
            break;

            case SL_OPCODE_SOCKET_TXFAILEDASYNCRESPONSE: {
                SlSockEventData_t *txfailparams = (SlSockEventData_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                sockAppEvent.Event =  SL_SOCKET_TX_FAILED_EVENT;
                memcpy((void *)&sockAppEvent.EventData,(void *)txfailparams,sizeof(SlSockEventData_t));
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&sockAppEvent);
                
            }
            break;

            case SL_OPCODE_SOCKET_SOCKETASYNCEVENT: {
                SlSockEventData_t *socketAsyncEvent = (SlSockEventData_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                sockAppEvent.Event =  SL_SOCKET_ASYNC_EVENT;
                sockAppEvent.EventData.socketAsyncEvent.sd = socketAsyncEvent->socketAsyncEvent.sd;
                sockAppEvent.EventData.socketAsyncEvent.type = socketAsyncEvent->socketAsyncEvent.type; /* one of the possible types of socket */
                sockAppEvent.EventData.socketAsyncEvent.val = socketAsyncEvent->socketAsyncEvent.val;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&sockAppEvent);
                
            }
            break;

            case SL_OPCODE_WLAN_SMART_CONFIG_START_ASYNC_RESPONSE: {
                slSmartConfigStartAsyncResponse_t *pResp = (slSmartConfigStartAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

                wlanEvent.Event = SL_WLAN_SMART_CONFIG_COMPLETE_EVENT;
                wlanEvent.EventData.smartConfigStartResponse.status = pResp->status;
                wlanEvent.EventData.smartConfigStartResponse.ssid_len = pResp->ssid_len;
                wlanEvent.EventData.smartConfigStartResponse.private_token_len = pResp->private_token_len;

                memset(wlanEvent.EventData.smartConfigStartResponse.ssid, 0x00, sizeof(wlanEvent.EventData.smartConfigStartResponse.ssid));
                memcpy(wlanEvent.EventData.smartConfigStartResponse.ssid, pResp->ssid, pResp->ssid_len);
                /* if private data exist */
                if (pResp->private_token_len) {
                    memset(wlanEvent.EventData.smartConfigStartResponse.private_token, 0x00, sizeof(wlanEvent.EventData.smartConfigStartResponse.private_token));
                    memcpy(wlanEvent.EventData.smartConfigStartResponse.private_token, pResp->private_token, pResp->private_token_len);
                }

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
            }
            break;

            case SL_OPCODE_WLAN_SMART_CONFIG_STOP_ASYNC_RESPONSE: {
                slSmartConfigStopAsyncResponse_t *pResp = (slSmartConfigStopAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

                wlanEvent.Event = SL_WLAN_SMART_CONFIG_STOP_EVENT;
                wlanEvent.EventData.smartConfigStopResponse.status = pResp->status;

                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
                
            }
            break;

            case SL_OPCODE_WLAN_STA_CONNECTED: {
                slPeerInfoAsyncResponse_t* pResp = (slPeerInfoAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                memset(&wlanEvent.EventData.APModeStaConnected,0,sizeof(slPeerInfoAsyncResponse_t));
                wlanEvent.Event = SL_WLAN_STA_CONNECTED_EVENT;
                memcpy(wlanEvent.EventData.APModeStaConnected.mac,pResp->mac, 6);
                memcpy(wlanEvent.EventData.APModeStaConnected.go_peer_device_name,pResp->go_peer_device_name,pResp->go_peer_device_name_len);
                wlanEvent.EventData.APModeStaConnected.go_peer_device_name_len = pResp->go_peer_device_name_len;

                memcpy(wlanEvent.EventData.APModeStaConnected.own_ssid,pResp->own_ssid,pResp->own_ssid_len);
                wlanEvent.EventData.APModeStaConnected.own_ssid_len = pResp->own_ssid_len;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
    
            }
            break;

            case SL_OPCODE_WLAN_STA_DISCONNECTED: {
                slPeerInfoAsyncResponse_t* pResp = (slPeerInfoAsyncResponse_t*)_SL_RESP_ARGS_START(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
                memset(&wlanEvent.EventData.APModestaDisconnected,0,sizeof(slPeerInfoAsyncResponse_t));
                wlanEvent.Event = SL_WLAN_STA_DISCONNECTED_EVENT;
                memcpy(wlanEvent.EventData.APModestaDisconnected.mac,pResp->mac, 6);
                memcpy(wlanEvent.EventData.APModestaDisconnected.go_peer_device_name,pResp->go_peer_device_name,pResp->go_peer_device_name_len);
                wlanEvent.EventData.APModestaDisconnected.go_peer_device_name_len = pResp->go_peer_device_name_len;
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(&wlanEvent);
            }
            break;

            case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE: {
                _sl_HandleAsync_PingResponse((void *)g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
            }
            break;


            default:
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(g_pCB->FunctionParams.AsyncExt.pAsyncBuf); 
                break;
        }
    }
}


/* ******************************************************************************/
/*  _SlDrvMsgReadCmdCtx  */
/* ******************************************************************************/
_SlReturnVal_t cc3100_driver::_SlDrvMsgReadCmdCtx(void)
{

    /*  after command response is received and isCmdRespWaited */
    /*  flag is set FALSE, it is necessary to read out all */
    /*  Async messages in Commands context, because ssiDma_IsrHandleSignalFromSlave */
    /*  could have dispatched some Async messages to g_NwpIf.CmdSyncObj */
    /*  after command response but before this response has been processed */
    /*  by spi_singleRead and isCmdRespWaited was set FALSE. */
    
    while (TRUE == g_pCB->IsCmdRespWaited) {
        
        if(_SL_PENDING_RX_MSG(g_pCB)) {
           
            g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;/*  buffer must be allocated by _SlDrvMsgRead */
            
            g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = NULL;
           
            g_pCB->FunctionParams.AsyncExt.RxMsgClass = (_SlRxMsgClass_e)(-1);/* init to illegal value and verify it's overwritten with the valid one */
            
            VERIFY_RET_OK(_SlDrvMsgRead());
            g_pCB->RxDoneCnt++;
           
            if (CMD_RESP_CLASS == g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
                g_pCB->IsCmdRespWaited = FALSE;

                /*  In case CmdResp has been read without  waiting on CmdSyncObj -  that */
                /*  Sync object. That to prevent old signal to be processed. */
                _nonos.sl_SyncObjClear(&g_pCB->CmdSyncObj);
            } else if (ASYNC_EVT_CLASS == g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
                /*  If Async event has been read in CmdResp context, check whether */
                /*  there is a handler for this event. If there is, spawn specific */
                /*  handler. Otherwise free the event's buffer. */
                /*  This way there will be no "dry shots" from CmdResp context to */
                /*  temporary context, i.e less waste of CPU and faster buffer */
                /*  release. */
                _SlAsyncEventGenericHandler();

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
                
                g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;
#else
                free(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
#endif
            }
        } else {
            /* CmdSyncObj will be signaled by IRQ */
            OSI_RET_OK_CHECK(_nonos.sl_SyncObjWait(&g_pCB->CmdSyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE, NON_OS_SYNC_OBJ_CLEAR_VALUE, SL_OS_WAIT_FOREVER));
        }
    }
    
    /*  If there are more pending Rx Msgs after CmdResp is received, */
    /*  that means that these are Async, Dummy or Read Data Msgs. */
    /*  Spawn _SlDrvMsgReadSpawnCtx to trigger reading these messages from */
    /*  Temporary context. */
    /* sl_Spawn is activated, using a different context */
    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
    
    if(_SL_PENDING_RX_MSG(g_pCB)) {
      _nonos._SlNonOsSpawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
    }
    
    return SL_OS_RET_CODE_OK;
}

/* ******************************************************************************/
/*  _SlDrvMsgReadSpawnCtx                                                       */
/* ******************************************************************************/

_SlReturnVal_t cc3100_driver::_SlDrvMsgReadSpawnCtx_(void *pValue)
{
	
#ifdef SL_POLLING_MODE_USED
    int16_t retCode = OSI_OK;
    //  for polling based systems 
    do {
        retCode = sl_LockObjLock(&g_pCB->GlobalLockObj, 0);
        if ( OSI_OK != retCode ) {
            if (TRUE == g_pCB->IsCmdRespWaited) {
                OSI_RET_OK_CHECK( sl_SyncObjSignal(&g_pCB->CmdSyncObj) );
                return SL_RET_CODE_OK;
            }
        }

    } while (OSI_OK != retCode);

#else
    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER) );
#endif

    g_pCB->FunctionParams.AsyncExt.pAsyncBuf       = NULL;//  buffer must be allocated by _SlDrvMsgRead 
    g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = NULL;
    g_pCB->FunctionParams.AsyncExt.RxMsgClass      = CMD_RESP_CLASS;// init to illegal value and verify it's overwritten with the valid one 

    //  Messages might have been read by CmdResp context. Therefore after 
    //  getting LockObj, check again where the Pending Rx Msg is still present. 
    if(FALSE == (_SL_PENDING_RX_MSG(g_pCB))) {
        OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
        return SL_RET_CODE_OK;
    }

    VERIFY_RET_OK(_SlDrvMsgRead());

    g_pCB->RxDoneCnt++;

    switch(g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
        case ASYNC_EVT_CLASS:
            //  If got here and protected by LockObj a message is waiting  
            //  to be read 
            VERIFY_PROTOCOL(NULL != g_pCB->FunctionParams.AsyncExt.pAsyncBuf);

            _SlAsyncEventGenericHandler();

#if (SL_MEMORY_MGMT == SL_MEMORY_MGMT_STATIC)
            g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;
#else
            sl_Free(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
#endif
            break;
        case DUMMY_MSG_CLASS:
        case RECV_RESP_CLASS:
            // These types are legal in this context. Do nothing 
            break;
        case CMD_RESP_CLASS:
            // Command response is illegal in this context. 
            // No 'break' here: Assert! 
        default:
            VERIFY_PROTOCOL(0);
    }

    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->GlobalLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));

    return(SL_RET_CODE_OK);
}

/* ******************************************************************************/
/*  _SlDrvClassifyRxMsg */
/* ******************************************************************************/
void cc3100_driver::_SlDrvClassifyRxMsg(_SlOpcode_t Opcode)
{
    g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = NULL;


    /* Async event has received */
    if (0 == (SL_OPCODE_SYNC & Opcode)) {
        if (SL_OPCODE_DEVICE_DEVICEASYNCDUMMY == Opcode) {
            g_pCB->FunctionParams.AsyncExt.RxMsgClass = DUMMY_MSG_CLASS;
        } else if ( (SL_OPCODE_SOCKET_RECVASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6 == Opcode) ) {
            g_pCB->FunctionParams.AsyncExt.RxMsgClass = RECV_RESP_CLASS;
        } else {
            g_pCB->FunctionParams.AsyncExt.RxMsgClass = ASYNC_EVT_CLASS;

            /* set silo handler */
            if (SL_OPCODE_SILO_DEVICE == (Opcode & SL_OPCODE_SILO_MASK)) {
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = (_SlSpawnEntryFunc_t)&_SlDrvDeviceEventHandler;
            } else if (SL_OPCODE_SILO_WLAN == (Opcode & SL_OPCODE_SILO_MASK)) {
#ifdef sl_WlanEvtHdlr
                
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = (_SlSpawnEntryFunc_t)&sl_WlanEvtHdlr;
#endif
            } else if (SL_OPCODE_SILO_SOCKET == (Opcode & SL_OPCODE_SILO_MASK)) {

#ifdef sl_SockEvtHdlr
                
                g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = (_SlSpawnEntryFunc_t)&sl_SockEvtHdlr;
#endif
            } else if (SL_OPCODE_SILO_NETAPP == (Opcode & SL_OPCODE_SILO_MASK)) {

                if ((SL_OPCODE_NETAPP_HTTPGETTOKENVALUE == Opcode) || (SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE == Opcode)) {
                    g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = (_SlSpawnEntryFunc_t)&_SlDrvNetAppEventHandler;
                }
#ifdef sl_NetAppEvtHdlr
                else {
                    g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = (_SlSpawnEntryFunc_t)&sl_NetAppEvtHdlr;
                }
#endif
            }
            /* 			else if (SL_OPCODE_SILO_NVMEM == (Opcode & SL_OPCODE_SILO_MASK))   */
            /* 			{ */
            /* 			} */
            /* 			else if (SL_OPCODE_SILO_NETCFG == (Opcode & SL_OPCODE_SILO_MASK))   */
            /* 			{ */
            /* 			} */
            else {
                //SL_ERROR_TRACE2(MSG_311, "ASSERT: _SlDrvClassifyRxMsg : invalid opcode = 0x%x = %i", Opcode, Opcode);
                printf("ASSERT: _SlDrvClassifyRxMsg : invalid opcode = 0x%x = %i", Opcode, Opcode);
            }
        }
    } else {
        /* These may be Command responses only */
        g_pCB->FunctionParams.AsyncExt.RxMsgClass = CMD_RESP_CLASS;
    }
}

/* ******************************************************************************/
/*  _SlDrvShiftDWord */
/* ******************************************************************************/
void cc3100_driver::_SlDrvShiftDWord(uint8_t *pBuf)
{
    uint8_t       ShiftIdx;
    for(ShiftIdx = 0; ShiftIdx< 7; ShiftIdx++) {
        pBuf[ShiftIdx] = pBuf[ShiftIdx+1];
    }
    pBuf[7] = 0;
}

/* ******************************************************************************/
/*  _SlDrvRxHdrRead  */
/* ******************************************************************************/
_SlReturnVal_t  cc3100_driver::_SlDrvRxHdrRead(uint8_t *pBuf, uint8_t *pAlignSize)
{
    uint32_t       SyncCnt  = 0;
    
#ifndef SL_IF_TYPE_UART
    /*  1. Write CNYS pattern to NWP when working in SPI mode only  */
    _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NCnysPattern.Short, SYNC_PATTERN_LEN);
#endif

    /*  2. Read 4 bytes (protocol aligned) */
    _spi.spi_Read(g_pCB->FD, &pBuf[0], 4);
    _SL_DBG_SYNC_LOG(SyncCnt,pBuf);

    /* Wait for SYNC_PATTERN_LEN from the device */
    while ( ! N2H_SYNC_PATTERN_MATCH(pBuf, g_pCB->TxSeqNum) ) {
        /*  3. Debug limit of scan */
        VERIFY_PROTOCOL(SyncCnt < SL_SYNC_SCAN_THRESHOLD);

        /*  4. Read next 4 bytes to Low 4 bytes of buffer */
        if(0 == (SyncCnt % (uint32_t)SYNC_PATTERN_LEN)) {
            _spi.spi_Read(g_pCB->FD, &pBuf[4], 4);
            _SL_DBG_SYNC_LOG(SyncCnt,pBuf);
        }

        /*  5. Shift Buffer Up for checking if the sync is shifted */
        _SlDrvShiftDWord(pBuf);

        SyncCnt++;
    }

    /*  5. Sync pattern found. If needed, complete number of read bytes to multiple of 4 (protocol align) */
    SyncCnt %= SYNC_PATTERN_LEN;

    if(SyncCnt > 0) {
        *(uint32_t *)&pBuf[0] = *(uint32_t *)&pBuf[4];
        _spi.spi_Read(g_pCB->FD, &pBuf[SYNC_PATTERN_LEN - SyncCnt], (uint16_t)SyncCnt);
    } else {
        _spi.spi_Read(g_pCB->FD, &pBuf[0], 4);
    }

    /*  6. Scan for Double pattern. */
    while ( N2H_SYNC_PATTERN_MATCH(pBuf, g_pCB->TxSeqNum) ) {
        _SL_DBG_CNT_INC(Work.DoubleSyncPattern);
        _spi.spi_Read(g_pCB->FD, &pBuf[0], SYNC_PATTERN_LEN);
    }
    g_pCB->TxSeqNum++;

    /*  7. Here we've read Generic Header (4 bytes). Read the Resp Specific header (4 more bytes). */
    _spi.spi_Read(g_pCB->FD, &pBuf[SYNC_PATTERN_LEN], _SL_RESP_SPEC_HDR_SIZE);

    /*  8. Here we've read the entire Resp Header. */
    /*     Return number bytes needed to be sent after read for NWP Rx 4-byte alignment (protocol alignment) */
    *pAlignSize = (uint8_t)((SyncCnt > 0) ? (SYNC_PATTERN_LEN - SyncCnt) : 0);

    return SL_RET_CODE_OK;
}

/* ***************************************************************************** */
/*  _SlDrvBasicCmd */
/* ***************************************************************************** */
typedef union {
    _BasicResponse_t	Rsp;
} _SlBasicCmdMsg_u;

int16_t cc3100_driver::_SlDrvBasicCmd(_SlOpcode_t Opcode)
{
    _SlBasicCmdMsg_u       Msg = {0};
    _SlCmdCtrl_t           CmdCtrl;

    CmdCtrl.Opcode = Opcode;
    CmdCtrl.TxDescLen = 0;
    CmdCtrl.RxDescLen = sizeof(_BasicResponse_t);


    VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));

    return (int16_t)Msg.Rsp.status;
}

/* ***************************************************************************** */
/*  _SlDrvWaitForPoolObj */
/* ***************************************************************************** */
int16_t cc3100_driver::_SlDrvWaitForPoolObj(uint32_t ActionID, uint8_t SocketID)
{
    uint8_t CurrObjIndex = MAX_CONCURRENT_ACTIONS;

    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));
    
    /* Get free object  */
    if (MAX_CONCURRENT_ACTIONS > g_pCB->FreePoolIdx) {
        /* save the current obj index */
        CurrObjIndex = g_pCB->FreePoolIdx;
        /* set the new free index */
        if (MAX_CONCURRENT_ACTIONS > g_pCB->ObjPool[CurrObjIndex].NextIndex) {
            g_pCB->FreePoolIdx = g_pCB->ObjPool[CurrObjIndex].NextIndex;
        } else {
            /* No further free actions available */
            g_pCB->FreePoolIdx = MAX_CONCURRENT_ACTIONS;
        }
    } else {
        OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
        return CurrObjIndex;
    }
    g_pCB->ObjPool[CurrObjIndex].ActionID = (uint8_t)ActionID;
    if (SL_MAX_SOCKETS > SocketID) {
        g_pCB->ObjPool[CurrObjIndex].AdditionalData = SocketID;
    }
    /*In case this action is socket related, SocketID bit will be on
    In case SocketID is set to SL_MAX_SOCKETS, the socket is not relevant to the action. In that case ActionID bit will be on */
    while ( ( (SL_MAX_SOCKETS > SocketID) && (g_pCB->ActiveActionsBitmap & (1<<SocketID)) ) || ( (g_pCB->ActiveActionsBitmap & (1<<ActionID)) && (SL_MAX_SOCKETS == SocketID) ) ) {
        //action in progress - move to pending list
        g_pCB->ObjPool[CurrObjIndex].NextIndex = g_pCB->PendingPoolIdx;
        g_pCB->PendingPoolIdx = CurrObjIndex;
        OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
        //wait for action to be free
        OSI_RET_OK_CHECK(_nonos.sl_SyncObjWait(&g_pCB->ObjPool[CurrObjIndex].SyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE, NON_OS_SYNC_OBJ_CLEAR_VALUE, SL_OS_WAIT_FOREVER));
        //set params and move to active (remove from pending list at _SlDrvReleasePoolObj)
        OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));
    }
    /*mark as active. Set socket as active if action is on socket, otherwise mark action as active*/
    if (SL_MAX_SOCKETS > SocketID) {
        g_pCB->ActiveActionsBitmap |= (1<<SocketID);
    } else {
        g_pCB->ActiveActionsBitmap |= (1<<ActionID);
    }
    /* move to active list  */
    g_pCB->ObjPool[CurrObjIndex].NextIndex = g_pCB->ActivePoolIdx;
    g_pCB->ActivePoolIdx = CurrObjIndex;
    /* unlock */
    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
    return CurrObjIndex;
}

/* ******************************************************************************/
/*  _SlDrvReleasePoolObj */
/* ******************************************************************************/
void cc3100_driver::_SlDrvReleasePoolObj(uint8_t ObjIdx)
{
    uint8_t PendingIndex;

    OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE, NON_OS_LOCK_OBJ_LOCK_VALUE, SL_OS_WAIT_FOREVER));

    /* go over the pending list and release other pending action if needed */
    PendingIndex = g_pCB->PendingPoolIdx;
    while(MAX_CONCURRENT_ACTIONS > PendingIndex) {
        /* In case this action is socket related, SocketID is in use, otherwise will be set to SL_MAX_SOCKETS */
        if ( (g_pCB->ObjPool[PendingIndex].ActionID == g_pCB->ObjPool[ObjIdx].ActionID) &&
                ( (SL_MAX_SOCKETS == (g_pCB->ObjPool[PendingIndex].AdditionalData & BSD_SOCKET_ID_MASK)) ||
                  ((SL_MAX_SOCKETS > (g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK)) && ( (g_pCB->ObjPool[PendingIndex].AdditionalData & BSD_SOCKET_ID_MASK) == (g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK) ))) ) {
            /* remove from pending list */
            _SlRemoveFromList(&g_pCB->PendingPoolIdx, PendingIndex);
            OSI_RET_OK_CHECK(_nonos.sl_SyncObjSignal(&g_pCB->ObjPool[PendingIndex].SyncObj, NON_OS_SYNC_OBJ_SIGNAL_VALUE));
            break;
        }
        PendingIndex = g_pCB->ObjPool[PendingIndex].NextIndex;
    }

    if (SL_MAX_SOCKETS > (g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK)) {
        /* unset socketID  */
        g_pCB->ActiveActionsBitmap &= ~(1<<(g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK));
    } else {
        /* unset actionID  */
        g_pCB->ActiveActionsBitmap &= ~(1<<g_pCB->ObjPool[ObjIdx].ActionID);
    }

    /* delete old data */
    g_pCB->ObjPool[ObjIdx].pRespArgs = NULL;
    g_pCB->ObjPool[ObjIdx].ActionID = 0;
    g_pCB->ObjPool[ObjIdx].AdditionalData = SL_MAX_SOCKETS;

    /* remove from active list */
    _SlRemoveFromList(&g_pCB->ActivePoolIdx, ObjIdx);
    /* move to free list */
    g_pCB->ObjPool[ObjIdx].NextIndex = g_pCB->FreePoolIdx;
    g_pCB->FreePoolIdx = ObjIdx;

    OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj, NON_OS_LOCK_OBJ_UNLOCK_VALUE));
}



/* ******************************************************************************/
/*  _SlDrvObjInit */
/* ******************************************************************************/
void cc3100_driver::_SlDrvObjInit(void)
{
    uint8_t Idx;

    memset(&g_pCB->ObjPool[0],0,MAX_CONCURRENT_ACTIONS*sizeof(_SlPoolObj_t));
    /* place all Obj in the free list */
    g_pCB->FreePoolIdx = 0;
    for (Idx = 0 ; Idx < MAX_CONCURRENT_ACTIONS ; Idx++) {
        g_pCB->ObjPool[Idx].NextIndex = Idx + 1;
        g_pCB->ObjPool[Idx].AdditionalData = SL_MAX_SOCKETS;
    }

    g_pCB->ActivePoolIdx = MAX_CONCURRENT_ACTIONS;
    g_pCB->PendingPoolIdx = MAX_CONCURRENT_ACTIONS;

}

/* ******************************************************************************/
/*  _SlDrvObjDeInit  */
/* ******************************************************************************/
void cc3100_driver::_SlDrvObjDeInit(void)
{
    g_pCB->FreePoolIdx = 0;
    g_pCB->PendingPoolIdx = MAX_CONCURRENT_ACTIONS;
    g_pCB->ActivePoolIdx = MAX_CONCURRENT_ACTIONS;

}

/* ******************************************************************************/
/* _SlRemoveFromList  */
/* ******************************************************************************/
void cc3100_driver::_SlRemoveFromList(uint8_t *ListIndex, uint8_t ItemIndex)
{
    uint8_t Idx;
    /* only one item in the list */
    if (MAX_CONCURRENT_ACTIONS == g_pCB->ObjPool[*ListIndex].NextIndex) {
        *ListIndex = MAX_CONCURRENT_ACTIONS;
    }
    /* need to remove the first item in the list and therefore update the global which holds this index */
    else if (*ListIndex == ItemIndex) {
        *ListIndex = g_pCB->ObjPool[ItemIndex].NextIndex;
    } else {
        Idx = *ListIndex;
        while(MAX_CONCURRENT_ACTIONS > Idx) {
            /* remove from list */
            if (g_pCB->ObjPool[Idx].NextIndex == ItemIndex) {
                g_pCB->ObjPool[Idx].NextIndex = g_pCB->ObjPool[ItemIndex].NextIndex;
                break;
            }
            Idx = g_pCB->ObjPool[Idx].NextIndex;
        }
    }
}

/* ******************************************************************************/
/*  _SlFindAndSetActiveObj                                                     */
/* ******************************************************************************/
_SlReturnVal_t cc3100_driver::_SlFindAndSetActiveObj(_SlOpcode_t  Opcode, uint8_t Sd)
{
    uint8_t ActiveIndex;

    ActiveIndex = g_pCB->ActivePoolIdx;
    /* go over the active list if exist to find obj waiting for this Async event */
    while (MAX_CONCURRENT_ACTIONS > ActiveIndex) {
        /* unset the Ipv4\IPv6 bit in the opcode if family bit was set  */
        if (g_pCB->ObjPool[ActiveIndex].AdditionalData & SL_NETAPP_FAMILY_MASK) {
            Opcode &= ~SL_OPCODE_IPV6;
        }

        if ((g_pCB->ObjPool[ActiveIndex].ActionID == RECV_ID) && (Sd == g_pCB->ObjPool[ActiveIndex].AdditionalData) &&
                ( (SL_OPCODE_SOCKET_RECVASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6 == Opcode) ) ) {
            g_pCB->FunctionParams.AsyncExt.ActionIndex = ActiveIndex;
            return SL_RET_CODE_OK;
        }
        /* In case this action is socket related, SocketID is in use, otherwise will be set to SL_MAX_SOCKETS */
        if ( (_SlActionLookupTable[ g_pCB->ObjPool[ActiveIndex].ActionID - MAX_SOCKET_ENUM_IDX].ActionAsyncOpcode == Opcode) &&
                ( ((Sd == (g_pCB->ObjPool[ActiveIndex].AdditionalData & BSD_SOCKET_ID_MASK) ) && (SL_MAX_SOCKETS > Sd)) || (SL_MAX_SOCKETS == (g_pCB->ObjPool[ActiveIndex].AdditionalData & BSD_SOCKET_ID_MASK)) ) ) {
            /* set handler */
            g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = _SlActionLookupTable[ g_pCB->ObjPool[ActiveIndex].ActionID - MAX_SOCKET_ENUM_IDX].AsyncEventHandler;
            g_pCB->FunctionParams.AsyncExt.ActionIndex = ActiveIndex;
            return SL_RET_CODE_OK;
        }
        ActiveIndex = g_pCB->ObjPool[ActiveIndex].NextIndex;
    }

    return SL_RET_CODE_SELF_ERROR;
}

}//namespace mbed_cc3100