David Fletcher
/
cc3100_Test_Demo
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Diff: simplelink/cc3100_driver.cpp
- Revision:
- 5:d3b320ebd469
- Parent:
- 4:5af740da0a59
- Child:
- 6:778b081f6a13
--- a/simplelink/cc3100_driver.cpp Mon Feb 23 21:10:13 2015 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1350 +0,0 @@
-/*
-* 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)
-{
- _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;
- }
-
- 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);
- }
- }
- } 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
-
-