David Fletcher / Mbed 2 deprecated cc3100_Test_websock_Camera_CM4F

Port of TI's CC3100 Websock camera demo. Using FreeRTOS, mbedTLS, also parts of Arducam for cams ov5642 and 0v2640. Can also use MT9D111. Work in progress. Be warned some parts maybe a bit flacky. This is for Seeed Arch max only, for an M3, see the demo for CM3 using the 0v5642 aducam mini.

Dependencies:   mbed

simplelink/cc3100_driver.cpp@18:3f1b52616d00, 2015-09-03 (annotated)

Committer:
dflet
Date:
Thu Sep 03 20:10:39 2015 +0000
Revision:
18:3f1b52616d00
Parent:
16:7e5aab2fabba
Child:
19:3dd3e7f30f8b
Some debug removed still have some random  failures with SPI?? MT9D111 cam still not working.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dflet 0:50cedd586816 1 /*
dflet 0:50cedd586816 2 * driver.c - CC31xx/CC32xx Host Driver Implementation
dflet 0:50cedd586816 3 *
dflet 0:50cedd586816 4 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
dflet 0:50cedd586816 5 *
dflet 0:50cedd586816 6 *
dflet 0:50cedd586816 7 * Redistribution and use in source and binary forms, with or without
dflet 0:50cedd586816 8 * modification, are permitted provided that the following conditions
dflet 0:50cedd586816 9 * are met:
dflet 0:50cedd586816 10 *
dflet 0:50cedd586816 11 * Redistributions of source code must retain the above copyright
dflet 0:50cedd586816 12 * notice, this list of conditions and the following disclaimer.
dflet 0:50cedd586816 13 *
dflet 0:50cedd586816 14 * Redistributions in binary form must reproduce the above copyright
dflet 0:50cedd586816 15 * notice, this list of conditions and the following disclaimer in the
dflet 0:50cedd586816 16 * documentation and/or other materials provided with the
dflet 0:50cedd586816 17 * distribution.
dflet 0:50cedd586816 18 *
dflet 0:50cedd586816 19 * Neither the name of Texas Instruments Incorporated nor the names of
dflet 0:50cedd586816 20 * its contributors may be used to endorse or promote products derived
dflet 0:50cedd586816 21 * from this software without specific prior written permission.
dflet 0:50cedd586816 22 *
dflet 0:50cedd586816 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
dflet 0:50cedd586816 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
dflet 0:50cedd586816 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
dflet 0:50cedd586816 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
dflet 0:50cedd586816 27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
dflet 0:50cedd586816 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
dflet 0:50cedd586816 29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
dflet 0:50cedd586816 30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
dflet 0:50cedd586816 31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
dflet 0:50cedd586816 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
dflet 0:50cedd586816 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
dflet 0:50cedd586816 34 *
dflet 0:50cedd586816 35 */
dflet 0:50cedd586816 36
dflet 0:50cedd586816 37 /*****************************************************************************/
dflet 0:50cedd586816 38 /* Include files */
dflet 0:50cedd586816 39 /*****************************************************************************/
dflet 0:50cedd586816 40 #include "cc3100_simplelink.h"
dflet 0:50cedd586816 41 #include "cc3100_protocol.h"
dflet 0:50cedd586816 42 #include "cc3100_driver.h"
dflet 0:50cedd586816 43
dflet 0:50cedd586816 44 #include "fPtr_func.h"
dflet 0:50cedd586816 45 #include "cli_uart.h"
dflet 0:50cedd586816 46
dflet 0:50cedd586816 47 #if (defined (SL_PLATFORM_MULTI_THREADED)) || (defined (SL_PLATFORM_EXTERNAL_SPAWN))
dflet 0:50cedd586816 48 #include "osi.h"
dflet 0:50cedd586816 49 #endif
dflet 0:50cedd586816 50
dflet 0:50cedd586816 51 /*****************************************************************************/
dflet 0:50cedd586816 52 /* Macro declarations */
dflet 0:50cedd586816 53 /*****************************************************************************/
dflet 0:50cedd586816 54
dflet 0:50cedd586816 55 namespace mbed_cc3100 {
dflet 0:50cedd586816 56
dflet 0:50cedd586816 57 #ifndef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 58 typedef struct {
dflet 0:50cedd586816 59 uint32_t Align;
dflet 0:50cedd586816 60 _SlDriverCb_t DriverCB;
dflet 0:50cedd586816 61 uint8_t AsyncRespBuf[SL_ASYNC_MAX_MSG_LEN];
dflet 0:50cedd586816 62 } _SlStatMem_t;
dflet 0:50cedd586816 63
dflet 0:50cedd586816 64 _SlStatMem_t g_StatMem;
dflet 0:50cedd586816 65 #endif
dflet 0:50cedd586816 66
dflet 0:50cedd586816 67
dflet 0:50cedd586816 68 _SlDriverCb_t* g_pCB = NULL;
dflet 0:50cedd586816 69
dflet 0:50cedd586816 70 uint8_t gFirstCmdMode = 0;
dflet 0:50cedd586816 71
dflet 0:50cedd586816 72 const _SlSyncPattern_t g_H2NSyncPattern = H2N_SYNC_PATTERN;
dflet 0:50cedd586816 73 const _SlSyncPattern_t g_H2NCnysPattern = H2N_CNYS_PATTERN;
dflet 0:50cedd586816 74 volatile uint8_t RxIrqCnt;
dflet 0:50cedd586816 75
dflet 0:50cedd586816 76 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 77 const _SlActionLookup_t _SlActionLookupTable[] = {
dflet 0:50cedd586816 78 {ACCEPT_ID, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE, (_SlSpawnEntryFunc_t) &_sl_HandleAsync_Accept},
dflet 0:50cedd586816 79 {CONNECT_ID, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Connect},
dflet 0:50cedd586816 80 {SELECT_ID, SL_OPCODE_SOCKET_SELECTASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Select},
dflet 0:50cedd586816 81 {GETHOSYBYNAME_ID, SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_DnsGetHostByName},
dflet 0:50cedd586816 82 {GETHOSYBYSERVICE_ID, SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_DnsGetHostByService},
dflet 0:50cedd586816 83 {PING_ID, SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE, (_SlSpawnEntryFunc_t) &_sl_HandleAsync_PingResponse},
dflet 0:50cedd586816 84 {START_STOP_ID, SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE,(_SlSpawnEntryFunc_t) &_sl_HandleAsync_Stop}
dflet 0:50cedd586816 85
dflet 0:50cedd586816 86 };
dflet 0:50cedd586816 87 #else
dflet 0:50cedd586816 88 const _SlActionLookup_t _SlActionLookupTable[] =
dflet 0:50cedd586816 89 {
dflet 0:50cedd586816 90 {CONNECT_ID, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE,(_SlSpawnEntryFunc_t)_sl_HandleAsync_Connect},
dflet 0:50cedd586816 91 {GETHOSYBYNAME_ID, SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE,(_SlSpawnEntryFunc_t)_sl_HandleAsync_DnsGetHostByName},
dflet 0:50cedd586816 92 {START_STOP_ID, SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE,(_SlSpawnEntryFunc_t)_sl_HandleAsync_Stop}
dflet 0:50cedd586816 93 };
dflet 0:50cedd586816 94 #endif
dflet 0:50cedd586816 95
dflet 0:50cedd586816 96 typedef struct
dflet 0:50cedd586816 97 {
dflet 0:50cedd586816 98 uint16_t opcode;
dflet 0:50cedd586816 99 uint8_t event;
dflet 0:50cedd586816 100 } OpcodeKeyVal_t;
dflet 0:50cedd586816 101
dflet 0:50cedd586816 102 /* The table translates opcode to user's event type */
dflet 0:50cedd586816 103 const OpcodeKeyVal_t OpcodeTranslateTable[] =
dflet 0:50cedd586816 104 {
dflet 0:50cedd586816 105 {SL_OPCODE_WLAN_SMART_CONFIG_START_ASYNC_RESPONSE, SL_WLAN_SMART_CONFIG_COMPLETE_EVENT},
dflet 0:50cedd586816 106 {SL_OPCODE_WLAN_SMART_CONFIG_STOP_ASYNC_RESPONSE,SL_WLAN_SMART_CONFIG_STOP_EVENT},
dflet 0:50cedd586816 107 {SL_OPCODE_WLAN_STA_CONNECTED, SL_WLAN_STA_CONNECTED_EVENT},
dflet 0:50cedd586816 108 {SL_OPCODE_WLAN_STA_DISCONNECTED,SL_WLAN_STA_DISCONNECTED_EVENT},
dflet 0:50cedd586816 109 {SL_OPCODE_WLAN_P2P_DEV_FOUND,SL_WLAN_P2P_DEV_FOUND_EVENT},
dflet 0:50cedd586816 110 {SL_OPCODE_WLAN_P2P_NEG_REQ_RECEIVED, SL_WLAN_P2P_NEG_REQ_RECEIVED_EVENT},
dflet 0:50cedd586816 111 {SL_OPCODE_WLAN_CONNECTION_FAILED, SL_WLAN_CONNECTION_FAILED_EVENT},
dflet 0:50cedd586816 112 {SL_OPCODE_WLAN_WLANASYNCCONNECTEDRESPONSE, SL_WLAN_CONNECT_EVENT},
dflet 0:50cedd586816 113 {SL_OPCODE_WLAN_WLANASYNCDISCONNECTEDRESPONSE, SL_WLAN_DISCONNECT_EVENT},
dflet 0:50cedd586816 114 {SL_OPCODE_NETAPP_IPACQUIRED, SL_NETAPP_IPV4_IPACQUIRED_EVENT},
dflet 0:50cedd586816 115 {SL_OPCODE_NETAPP_IPACQUIRED_V6, SL_NETAPP_IPV6_IPACQUIRED_EVENT},
dflet 0:50cedd586816 116 {SL_OPCODE_NETAPP_IP_LEASED, SL_NETAPP_IP_LEASED_EVENT},
dflet 0:50cedd586816 117 {SL_OPCODE_NETAPP_IP_RELEASED, SL_NETAPP_IP_RELEASED_EVENT},
dflet 0:50cedd586816 118 {SL_OPCODE_SOCKET_TXFAILEDASYNCRESPONSE, SL_SOCKET_TX_FAILED_EVENT},
dflet 0:50cedd586816 119 {SL_OPCODE_SOCKET_SOCKETASYNCEVENT, SL_SOCKET_ASYNC_EVENT}
dflet 0:50cedd586816 120 };
dflet 0:50cedd586816 121
dflet 0:50cedd586816 122 /*
dflet 0:50cedd586816 123
dflet 0:50cedd586816 124 #define SL_OPCODE_SILO_DEVICE ( 0x0 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 125 #define SL_OPCODE_SILO_WLAN ( 0x1 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 126 #define SL_OPCODE_SILO_SOCKET ( 0x2 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 127 #define SL_OPCODE_SILO_NETAPP ( 0x3 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 128 #define SL_OPCODE_SILO_NVMEM ( 0x4 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 129 #define SL_OPCODE_SILO_NETCFG ( 0x5 << SL_OPCODE_SILO_OFFSET )
dflet 0:50cedd586816 130
dflet 0:50cedd586816 131
dflet 0:50cedd586816 132 */
dflet 0:50cedd586816 133
dflet 0:50cedd586816 134 /* The Lookup table below holds the event handlers to be called according to the incoming
dflet 0:50cedd586816 135 RX message SILO type */
dflet 0:50cedd586816 136 const _SlSpawnEntryFunc_t RxMsgClassLUT[] = {
dflet 0:50cedd586816 137 (_SlSpawnEntryFunc_t)_SlDrvDeviceEventHandler, /* SL_OPCODE_SILO_DEVICE */
dflet 0:50cedd586816 138 #if defined(sl_WlanEvtHdlr) || defined(EXT_LIB_REGISTERED_WLAN_EVENTS)
dflet 0:50cedd586816 139 (_SlSpawnEntryFunc_t)_SlDrvHandleWlanEvents, /* SL_OPCODE_SILO_WLAN */
dflet 0:50cedd586816 140 #else
dflet 0:50cedd586816 141 NULL,
dflet 0:50cedd586816 142 #endif
dflet 0:50cedd586816 143 #if defined (sl_SockEvtHdlr) || defined(EXT_LIB_REGISTERED_SOCK_EVENTS)
dflet 0:50cedd586816 144 (_SlSpawnEntryFunc_t)_SlDrvHandleSockEvents, /* SL_OPCODE_SILO_SOCKET */
dflet 0:50cedd586816 145 #else
dflet 0:50cedd586816 146 NULL,
dflet 0:50cedd586816 147 #endif
dflet 0:50cedd586816 148
dflet 0:50cedd586816 149 #if defined(sl_NetAppEvtHdlr) || defined(EXT_LIB_REGISTERED_NETAPP_EVENTS)
dflet 0:50cedd586816 150 (_SlSpawnEntryFunc_t)_SlDrvHandleNetAppEvents, /* SL_OPCODE_SILO_NETAPP */
dflet 0:50cedd586816 151 #else
dflet 0:50cedd586816 152 NULL,
dflet 0:50cedd586816 153 #endif
dflet 0:50cedd586816 154 NULL, /* SL_OPCODE_SILO_NVMEM */
dflet 0:50cedd586816 155 NULL, /* SL_OPCODE_SILO_NETCFG */
dflet 0:50cedd586816 156 NULL,
dflet 0:50cedd586816 157 NULL
dflet 0:50cedd586816 158 };
dflet 0:50cedd586816 159
dflet 0:50cedd586816 160 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 161 cc3100_driver::cc3100_driver(cc3100_spi &spi, cc3100_nonos &nonos, cc3100_netapp &netapp, cc3100_flowcont &flowcont)
dflet 0:50cedd586816 162 : _spi(spi), _nonos(nonos), _netapp(netapp), _flowcont(flowcont)
dflet 0:50cedd586816 163 {
dflet 0:50cedd586816 164 }
dflet 0:50cedd586816 165 #else
dflet 0:50cedd586816 166
dflet 0:50cedd586816 167 cc3100_driver::cc3100_driver(cc3100_spi &spi, cc3100_netapp &netapp, cc3100_flowcont &flowcont)
dflet 0:50cedd586816 168 : _spi(spi), _netapp(netapp), _flowcont(flowcont)
dflet 0:50cedd586816 169 {
dflet 0:50cedd586816 170 }
dflet 0:50cedd586816 171 #endif
dflet 0:50cedd586816 172
dflet 0:50cedd586816 173 cc3100_driver::~cc3100_driver()
dflet 0:50cedd586816 174 {
dflet 0:50cedd586816 175
dflet 0:50cedd586816 176 }
dflet 0:50cedd586816 177
dflet 0:50cedd586816 178 /*****************************************************************************/
dflet 0:50cedd586816 179 /* Variables */
dflet 0:50cedd586816 180 /*****************************************************************************/
dflet 0:50cedd586816 181
dflet 0:50cedd586816 182 /********************************************************************************/
dflet 0:50cedd586816 183
dflet 0:50cedd586816 184 uint8_t cc3100_driver::_SlDrvProtectAsyncRespSetting(uint8_t *pAsyncRsp, uint8_t ActionID, uint8_t SocketID)
dflet 0:50cedd586816 185 {
dflet 0:50cedd586816 186 uint8_t ObjIdx;
dflet 0:50cedd586816 187
dflet 0:50cedd586816 188
dflet 0:50cedd586816 189 /* Use Obj to issue the command, if not available try later */
dflet 0:50cedd586816 190 ObjIdx = _SlDrvWaitForPoolObj(ActionID, SocketID);
dflet 0:50cedd586816 191
dflet 0:50cedd586816 192 if (MAX_CONCURRENT_ACTIONS != ObjIdx)
dflet 0:50cedd586816 193 {
dflet 0:50cedd586816 194 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 195 g_pCB->ObjPool[ObjIdx].pRespArgs = pAsyncRsp;
dflet 0:50cedd586816 196 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 197 }
dflet 0:50cedd586816 198
dflet 0:50cedd586816 199 return ObjIdx;
dflet 0:50cedd586816 200 }
dflet 0:50cedd586816 201
dflet 0:50cedd586816 202
dflet 0:50cedd586816 203 /*****************************************************************************/
dflet 0:50cedd586816 204 /* Internal functions */
dflet 0:50cedd586816 205 /*****************************************************************************/
dflet 0:50cedd586816 206 bool cc3100_driver::_SL_PENDING_RX_MSG(pDriver* pDriverCB){
dflet 0:50cedd586816 207
dflet 0:50cedd586816 208 if(RxIrqCnt != (pDriverCB)->RxDoneCnt){
dflet 0:50cedd586816 209 return TRUE;
dflet 0:50cedd586816 210 }else{
dflet 0:50cedd586816 211 return FALSE;
dflet 0:50cedd586816 212 }
dflet 0:50cedd586816 213 }
dflet 0:50cedd586816 214
dflet 0:50cedd586816 215 /*****************************************************************************
dflet 0:50cedd586816 216 _SlDrvDriverCBInit - init Driver Control Block
dflet 0:50cedd586816 217 *****************************************************************************/
dflet 0:50cedd586816 218 void cc3100_driver::_SlDrvDriverCBInit(void)
dflet 0:50cedd586816 219 {
dflet 0:50cedd586816 220
dflet 0:50cedd586816 221 uint8_t Idx = 0;
dflet 0:50cedd586816 222
dflet 0:50cedd586816 223 #ifdef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 224
dflet 0:50cedd586816 225 g_pCB = sl_Malloc(sizeof(_SlDriverCb_t));
dflet 0:50cedd586816 226 #else
dflet 0:50cedd586816 227 g_pCB = &(g_StatMem.DriverCB);
dflet 0:50cedd586816 228 #endif
dflet 0:50cedd586816 229
dflet 0:50cedd586816 230 MALLOC_OK_CHECK(g_pCB);
dflet 0:50cedd586816 231 _SlDrvMemZero(g_pCB, sizeof(_SlDriverCb_t));
dflet 0:50cedd586816 232 RxIrqCnt = 0;
dflet 0:50cedd586816 233 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 234 OSI_RET_OK_CHECK( _nonos.sl_SyncObjCreate(&g_pCB->CmdSyncObj, "CmdSyncObj") );
dflet 0:50cedd586816 235 _nonos.sl_SyncObjClear(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 236 OSI_RET_OK_CHECK( _nonos.sl_LockObjCreate(&g_pCB->GlobalLockObj, "GlobalLockObj") );
dflet 0:50cedd586816 237 OSI_RET_OK_CHECK( _nonos.sl_LockObjCreate(&g_pCB->ProtectionLockObj, "ProtectionLockObj") );
dflet 0:50cedd586816 238 #else
dflet 0:50cedd586816 239 OSI_RET_OK_CHECK( sl_SyncObjCreate(&g_pCB->CmdSyncObj, "CmdSyncObj") );
dflet 0:50cedd586816 240 sl_SyncObjClear(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 241 OSI_RET_OK_CHECK( sl_LockObjCreate(&g_pCB->GlobalLockObj, "GlobalLockObj") );
dflet 0:50cedd586816 242 OSI_RET_OK_CHECK( sl_LockObjCreate(&g_pCB->ProtectionLockObj, "ProtectionLockObj") );
dflet 0:50cedd586816 243 #endif
dflet 0:50cedd586816 244 /* Init Drv object */
dflet 0:50cedd586816 245 _SlDrvMemZero(&g_pCB->ObjPool[0], MAX_CONCURRENT_ACTIONS*sizeof(_SlPoolObj_t));
dflet 0:50cedd586816 246
dflet 0:50cedd586816 247 /* place all Obj in the free list*/
dflet 0:50cedd586816 248 g_pCB->FreePoolIdx = 0;
dflet 0:50cedd586816 249
dflet 0:50cedd586816 250 for (Idx = 0 ; Idx < MAX_CONCURRENT_ACTIONS ; Idx++)
dflet 0:50cedd586816 251 {
dflet 0:50cedd586816 252 g_pCB->ObjPool[Idx].NextIndex = Idx + 1;
dflet 0:50cedd586816 253 g_pCB->ObjPool[Idx].AdditionalData = SL_MAX_SOCKETS;
dflet 0:50cedd586816 254 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 255 OSI_RET_OK_CHECK( _nonos.sl_SyncObjCreate(&g_pCB->ObjPool[Idx].SyncObj, "SyncObj"));
dflet 0:50cedd586816 256 _nonos.sl_SyncObjClear(&g_pCB->ObjPool[Idx].SyncObj);
dflet 0:50cedd586816 257 #else
dflet 0:50cedd586816 258 OSI_RET_OK_CHECK( sl_SyncObjCreate(&g_pCB->ObjPool[Idx].SyncObj, "SyncObj"));
dflet 0:50cedd586816 259 sl_SyncObjClear(&g_pCB->ObjPool[Idx].SyncObj);
dflet 0:50cedd586816 260 #endif
dflet 0:50cedd586816 261 }
dflet 0:50cedd586816 262
dflet 0:50cedd586816 263 g_pCB->ActivePoolIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 264 g_pCB->PendingPoolIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 265
dflet 0:50cedd586816 266 /* Flow control init */
dflet 0:50cedd586816 267 g_pCB->FlowContCB.TxPoolCnt = FLOW_CONT_MIN;
dflet 0:50cedd586816 268 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 269 OSI_RET_OK_CHECK(_nonos.sl_LockObjCreate(&g_pCB->FlowContCB.TxLockObj, "TxLockObj"));
dflet 0:50cedd586816 270 OSI_RET_OK_CHECK(_nonos.sl_SyncObjCreate(&g_pCB->FlowContCB.TxSyncObj, "TxSyncObj"));
dflet 0:50cedd586816 271 #else
dflet 0:50cedd586816 272 OSI_RET_OK_CHECK(sl_LockObjCreate(&g_pCB->FlowContCB.TxLockObj, "TxLockObj"));
dflet 0:50cedd586816 273 OSI_RET_OK_CHECK(sl_SyncObjCreate(&g_pCB->FlowContCB.TxSyncObj, "TxSyncObj"));
dflet 0:50cedd586816 274 #endif
dflet 0:50cedd586816 275 gFirstCmdMode = 0;
dflet 0:50cedd586816 276 }
dflet 0:50cedd586816 277
dflet 0:50cedd586816 278 /*****************************************************************************
dflet 0:50cedd586816 279 _SlDrvDriverCBDeinit - De init Driver Control Block
dflet 0:50cedd586816 280 *****************************************************************************/
dflet 0:50cedd586816 281 void cc3100_driver::_SlDrvDriverCBDeinit()
dflet 0:50cedd586816 282 {
dflet 0:50cedd586816 283 uint8_t Idx = 0;
dflet 0:50cedd586816 284
dflet 0:50cedd586816 285 /* Flow control de-init */
dflet 0:50cedd586816 286 g_pCB->FlowContCB.TxPoolCnt = 0;
dflet 0:50cedd586816 287 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 288 OSI_RET_OK_CHECK(_nonos.sl_LockObjDelete(&g_pCB->FlowContCB.TxLockObj));
dflet 0:50cedd586816 289 OSI_RET_OK_CHECK(_nonos.sl_SyncObjDelete(&g_pCB->FlowContCB.TxSyncObj));
dflet 0:50cedd586816 290
dflet 0:50cedd586816 291 OSI_RET_OK_CHECK( _nonos.sl_SyncObjDelete(&g_pCB->CmdSyncObj) );
dflet 0:50cedd586816 292 OSI_RET_OK_CHECK( _nonos.sl_LockObjDelete(&g_pCB->GlobalLockObj) );
dflet 0:50cedd586816 293 OSI_RET_OK_CHECK( _nonos.sl_LockObjDelete(&g_pCB->ProtectionLockObj) );
dflet 0:50cedd586816 294 #else
dflet 0:50cedd586816 295 OSI_RET_OK_CHECK(sl_LockObjDelete(&g_pCB->FlowContCB.TxLockObj));
dflet 0:50cedd586816 296 OSI_RET_OK_CHECK(sl_SyncObjDelete(&g_pCB->FlowContCB.TxSyncObj));
dflet 0:50cedd586816 297
dflet 0:50cedd586816 298 OSI_RET_OK_CHECK( sl_SyncObjDelete(&g_pCB->CmdSyncObj) );
dflet 0:50cedd586816 299 OSI_RET_OK_CHECK( sl_LockObjDelete(&g_pCB->GlobalLockObj) );
dflet 0:50cedd586816 300 OSI_RET_OK_CHECK( sl_LockObjDelete(&g_pCB->ProtectionLockObj) );
dflet 0:50cedd586816 301 #endif
dflet 0:50cedd586816 302
dflet 0:50cedd586816 303 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 304 for (Idx = 0; Idx < MAX_CONCURRENT_ACTIONS; Idx++)
dflet 0:50cedd586816 305 #endif
dflet 0:50cedd586816 306
dflet 0:50cedd586816 307 g_pCB->FreePoolIdx = 0;
dflet 0:50cedd586816 308 g_pCB->PendingPoolIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 309 g_pCB->ActivePoolIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 310
dflet 0:50cedd586816 311 #ifdef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 312 sl_Free(g_pCB);
dflet 0:50cedd586816 313 #else
dflet 0:50cedd586816 314 g_pCB = NULL;
dflet 0:50cedd586816 315 #endif
dflet 0:50cedd586816 316
dflet 0:50cedd586816 317 g_pCB = NULL;
dflet 0:50cedd586816 318 }
dflet 0:50cedd586816 319
dflet 0:50cedd586816 320 /*****************************************************************************
dflet 0:50cedd586816 321 _SlDrvRxIrqHandler - Interrupt handler
dflet 0:50cedd586816 322 *****************************************************************************/
dflet 0:50cedd586816 323
dflet 0:50cedd586816 324 void cc3100_driver::_SlDrvRxIrqHandler(void *pValue)
dflet 0:50cedd586816 325 {
dflet 0:50cedd586816 326
dflet 0:50cedd586816 327 int32_t rv = 0;
dflet 0:50cedd586816 328 _spi.MaskIntHdlr();
dflet 0:50cedd586816 329
dflet 0:50cedd586816 330 RxIrqCnt++;
dflet 0:50cedd586816 331
dflet 0:50cedd586816 332 if (TRUE == g_pCB->IsCmdRespWaited) {
dflet 0:50cedd586816 333 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 334 OSI_RET_OK_CHECK( _nonos.sl_SyncObjSignalFromIRQ(&g_pCB->CmdSyncObj) );
dflet 0:50cedd586816 335 #else
dflet 0:50cedd586816 336 OSI_RET_OK_CHECK( sl_SyncObjSignalFromIRQ(&g_pCB->CmdSyncObj) );
dflet 0:50cedd586816 337 #endif
dflet 0:50cedd586816 338 } else {
dflet 0:50cedd586816 339 #if (defined (SL_PLATFORM_MULTI_THREADED)) || (defined (SL_PLATFORM_EXTERNAL_SPAWN))
dflet 0:50cedd586816 340 rv = sl_Spawn((_SlSpawnEntryFunc_t)_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 341
dflet 0:50cedd586816 342 if(rv <0){
dflet 0:50cedd586816 343 Uart_Write((uint8_t*)"\n\r OSI_OPERATION_FAILED \n\r");
dflet 0:50cedd586816 344 }
dflet 0:50cedd586816 345 #else
dflet 0:50cedd586816 346 _nonos._SlNonOsSpawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 347 #endif
dflet 0:50cedd586816 348 //#ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 349 // _nonos._SlNonOsSpawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 350 //#else
dflet 0:50cedd586816 351 // sl_Spawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 352 //#endif
dflet 0:50cedd586816 353 }
dflet 0:50cedd586816 354 }
dflet 0:50cedd586816 355
dflet 0:50cedd586816 356 /*****************************************************************************
dflet 0:50cedd586816 357 _SlDrvCmdOp
dflet 0:50cedd586816 358 *****************************************************************************/
dflet 0:50cedd586816 359 _SlReturnVal_t cc3100_driver::_SlDrvCmdOp(_SlCmdCtrl_t *pCmdCtrl,void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
dflet 0:50cedd586816 360 {
dflet 0:50cedd586816 361 _SlReturnVal_t RetVal;
dflet 0:50cedd586816 362
dflet 0:50cedd586816 363 _SlDrvObjLockWaitForever(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 364 g_pCB->IsCmdRespWaited = TRUE;
dflet 0:50cedd586816 365 SL_TRACE0(DBG_MSG, MSG_312, "_SlDrvCmdOp: call _SlDrvMsgWrite");
dflet 0:50cedd586816 366
dflet 0:50cedd586816 367 /* send the message */
dflet 0:50cedd586816 368 RetVal = _SlDrvMsgWrite(pCmdCtrl, pCmdExt, (uint8_t*)pTxRxDescBuff);
dflet 0:50cedd586816 369
dflet 0:50cedd586816 370 if(SL_OS_RET_CODE_OK == RetVal) {
dflet 0:50cedd586816 371
dflet 0:50cedd586816 372 #ifndef SL_IF_TYPE_UART
dflet 0:50cedd586816 373 /* Waiting for SPI to stabilize after first command */
dflet 0:50cedd586816 374 if( 0 == gFirstCmdMode ) {
dflet 0:50cedd586816 375 gFirstCmdMode = 1;
dflet 0:50cedd586816 376 wait_ms(2);
dflet 0:50cedd586816 377 }
dflet 0:50cedd586816 378 #endif
dflet 0:50cedd586816 379
dflet 0:50cedd586816 380 /* wait for respond */
dflet 0:50cedd586816 381 RetVal = _SlDrvMsgReadCmdCtx(); /* will free global lock */
dflet 0:50cedd586816 382 SL_TRACE0(DBG_MSG, MSG_314, "_SlDrvCmdOp: exited _SlDrvMsgReadCmdCtx");
dflet 0:50cedd586816 383 } else
dflet 0:50cedd586816 384 {
dflet 0:50cedd586816 385 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 386 }
dflet 0:50cedd586816 387 return RetVal;
dflet 0:50cedd586816 388 }
dflet 0:50cedd586816 389
dflet 0:50cedd586816 390 /*****************************************************************************
dflet 0:50cedd586816 391 _SlDrvDataReadOp
dflet 0:50cedd586816 392 *****************************************************************************/
dflet 0:50cedd586816 393 _SlReturnVal_t cc3100_driver::_SlDrvDataReadOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl, void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
dflet 0:50cedd586816 394 {
dflet 0:50cedd586816 395 _SlReturnVal_t RetVal;
dflet 0:50cedd586816 396 uint8_t ObjIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 397 _SlArgsData_t pArgsData;
dflet 0:50cedd586816 398
dflet 0:50cedd586816 399 /* Validate input arguments */
dflet 0:50cedd586816 400 VERIFY_PROTOCOL(NULL != pCmdExt->pRxPayload);
dflet 0:50cedd586816 401
dflet 0:50cedd586816 402 /* If zero bytes is requested, return error. */
dflet 0:50cedd586816 403 /* This allows us not to fill remote socket's IP address in return arguments */
dflet 0:50cedd586816 404 VERIFY_PROTOCOL(0 != pCmdExt->RxPayloadLen);
dflet 0:50cedd586816 405
dflet 0:50cedd586816 406 /* Validate socket */
dflet 0:50cedd586816 407 if((Sd & BSD_SOCKET_ID_MASK) >= SL_MAX_SOCKETS) {
dflet 0:50cedd586816 408 return SL_EBADF;
dflet 0:50cedd586816 409 }
dflet 0:50cedd586816 410
dflet 0:50cedd586816 411 /*Use Obj to issue the command, if not available try later*/
dflet 0:50cedd586816 412 ObjIdx = (uint8_t)_SlDrvWaitForPoolObj(RECV_ID, Sd & BSD_SOCKET_ID_MASK);
dflet 0:50cedd586816 413
dflet 0:50cedd586816 414 if (MAX_CONCURRENT_ACTIONS == ObjIdx) {
dflet 0:50cedd586816 415 return SL_POOL_IS_EMPTY;
dflet 0:50cedd586816 416 }
dflet 0:50cedd586816 417
dflet 0:50cedd586816 418 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 419
dflet 0:50cedd586816 420 pArgsData.pData = pCmdExt->pRxPayload;
dflet 0:50cedd586816 421 pArgsData.pArgs = (uint8_t *)pTxRxDescBuff;
dflet 0:50cedd586816 422 g_pCB->ObjPool[ObjIdx].pRespArgs = (uint8_t *)&pArgsData;
dflet 0:50cedd586816 423 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 424
dflet 0:50cedd586816 425 /* Do Flow Control check/update for DataWrite operation */
dflet 0:50cedd586816 426 _SlDrvObjLockWaitForever(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 427
dflet 0:50cedd586816 428 /* Clear SyncObj for the case it was signalled before TxPoolCnt */
dflet 0:50cedd586816 429 /* dropped below '1' (last Data buffer was taken) */
dflet 0:50cedd586816 430 /* OSI_RET_OK_CHECK( sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj) ); */
dflet 0:50cedd586816 431 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 432 _nonos.sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 433 #else
dflet 0:50cedd586816 434 sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 435 #endif
dflet 0:50cedd586816 436 if(g_pCB->FlowContCB.TxPoolCnt <= FLOW_CONT_MIN) {
dflet 0:50cedd586816 437
dflet 0:50cedd586816 438 /* If TxPoolCnt was increased by other thread at this moment,
dflet 0:50cedd586816 439 TxSyncObj won't wait here */
dflet 0:50cedd586816 440 _SlDrvSyncObjWaitForever(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 441
dflet 0:50cedd586816 442 }
dflet 0:50cedd586816 443
dflet 0:50cedd586816 444 _SlDrvObjLockWaitForever(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 445
dflet 0:50cedd586816 446 VERIFY_PROTOCOL(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN);
dflet 0:50cedd586816 447 g_pCB->FlowContCB.TxPoolCnt--;
dflet 0:50cedd586816 448
dflet 0:50cedd586816 449 _SlDrvObjUnLock(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 450
dflet 0:50cedd586816 451 /* send the message */
dflet 0:50cedd586816 452 RetVal = _SlDrvMsgWrite(pCmdCtrl, pCmdExt, (uint8_t *)pTxRxDescBuff);
dflet 0:50cedd586816 453
dflet 0:50cedd586816 454 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 455
dflet 0:50cedd586816 456 if(SL_OS_RET_CODE_OK == RetVal) {
dflet 0:50cedd586816 457 /* Wait for response message. Will be signaled by _SlDrvMsgRead. */
dflet 0:50cedd586816 458 _SlDrvSyncObjWaitForever(&g_pCB->ObjPool[ObjIdx].SyncObj);
dflet 0:50cedd586816 459 }
dflet 0:50cedd586816 460
dflet 0:50cedd586816 461 _SlDrvReleasePoolObj(ObjIdx);
dflet 0:50cedd586816 462 return RetVal;
dflet 0:50cedd586816 463 }
dflet 0:50cedd586816 464
dflet 0:50cedd586816 465 /* ******************************************************************************/
dflet 0:50cedd586816 466 /* _SlDrvDataWriteOp */
dflet 0:50cedd586816 467 /* ******************************************************************************/
dflet 0:50cedd586816 468 _SlReturnVal_t cc3100_driver::_SlDrvDataWriteOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl, void* pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
dflet 0:50cedd586816 469 {
dflet 0:50cedd586816 470 _SlReturnVal_t RetVal = SL_EAGAIN; /* initiated as SL_EAGAIN for the non blocking mode */
dflet 0:50cedd586816 471 while( 1 ) {
dflet 0:50cedd586816 472 /* Do Flow Control check/update for DataWrite operation */
dflet 0:50cedd586816 473 _SlDrvObjLockWaitForever(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 474
dflet 0:50cedd586816 475 /* Clear SyncObj for the case it was signalled before TxPoolCnt */
dflet 0:50cedd586816 476 /* dropped below '1' (last Data buffer was taken) */
dflet 0:50cedd586816 477 /* OSI_RET_OK_CHECK( sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj) ); */
dflet 0:50cedd586816 478 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 479 _nonos.sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 480 #else
dflet 0:50cedd586816 481 sl_SyncObjClear(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 482 #endif
dflet 0:50cedd586816 483 /* we have indication that the last send has failed - socket is no longer valid for operations */
dflet 0:50cedd586816 484 if(g_pCB->SocketTXFailure & (1<<(Sd & BSD_SOCKET_ID_MASK))) {
dflet 0:50cedd586816 485 _SlDrvObjUnLock(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 486 return SL_SOC_ERROR;
dflet 0:50cedd586816 487 }
dflet 0:50cedd586816 488
dflet 0:50cedd586816 489 if(g_pCB->FlowContCB.TxPoolCnt <= FLOW_CONT_MIN + 1) {
dflet 0:50cedd586816 490 /* we have indication that this socket is set as blocking and we try to */
dflet 0:50cedd586816 491 /* unblock it - return an error */
dflet 0:50cedd586816 492 if( g_pCB->SocketNonBlocking & (1<< (Sd & BSD_SOCKET_ID_MASK)))
dflet 0:50cedd586816 493 {
dflet 0:50cedd586816 494 _SlDrvObjUnLock(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 495 return RetVal;
dflet 0:50cedd586816 496 }
dflet 0:50cedd586816 497 /* If TxPoolCnt was increased by other thread at this moment, */
dflet 0:50cedd586816 498 /* TxSyncObj won't wait here */
dflet 0:50cedd586816 499 _SlDrvSyncObjWaitForever(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 500 }
dflet 0:50cedd586816 501
dflet 0:50cedd586816 502 if(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN + 1 ) {
dflet 0:50cedd586816 503 break;
dflet 0:50cedd586816 504 }
dflet 0:50cedd586816 505 else
dflet 0:50cedd586816 506 {
dflet 0:50cedd586816 507 _SlDrvObjUnLock(&g_pCB->FlowContCB.TxLockObj);
dflet 0:50cedd586816 508 }
dflet 0:50cedd586816 509 }
dflet 0:50cedd586816 510
dflet 0:50cedd586816 511 _SlDrvObjLockWaitForever(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 512
dflet 0:50cedd586816 513
dflet 0:50cedd586816 514 VERIFY_PROTOCOL(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN + 1 );
dflet 0:50cedd586816 515 g_pCB->FlowContCB.TxPoolCnt--;
dflet 0:50cedd586816 516
dflet 0:50cedd586816 517 _SlDrvObjUnLock(&g_pCB->FlowContCB.TxLockObj);
dflet 18:3f1b52616d00 518
dflet 0:50cedd586816 519 /* send the message */
dflet 0:50cedd586816 520 RetVal = _SlDrvMsgWrite(pCmdCtrl, pCmdExt, (uint8_t*)pTxRxDescBuff);
dflet 18:3f1b52616d00 521
dflet 0:50cedd586816 522 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 523
dflet 0:50cedd586816 524 return RetVal;
dflet 0:50cedd586816 525 }
dflet 0:50cedd586816 526
dflet 0:50cedd586816 527 /* ******************************************************************************/
dflet 0:50cedd586816 528 /* _SlDrvMsgWrite */
dflet 0:50cedd586816 529 /* ******************************************************************************/
dflet 0:50cedd586816 530 _SlReturnVal_t cc3100_driver::_SlDrvMsgWrite(_SlCmdCtrl_t *pCmdCtrl, _SlCmdExt_t *pCmdExt, uint8_t *pTxRxDescBuff)
dflet 0:50cedd586816 531 {
dflet 0:50cedd586816 532 //printf("_SlDrvMsgWrite\r\n");
dflet 0:50cedd586816 533 uint8_t sendRxPayload = FALSE;
dflet 0:50cedd586816 534 VERIFY_PROTOCOL(NULL != pCmdCtrl);
dflet 0:50cedd586816 535
dflet 0:50cedd586816 536 g_pCB->FunctionParams.pCmdCtrl = pCmdCtrl;
dflet 0:50cedd586816 537 g_pCB->FunctionParams.pTxRxDescBuff = pTxRxDescBuff;
dflet 0:50cedd586816 538 g_pCB->FunctionParams.pCmdExt = pCmdExt;
dflet 0:50cedd586816 539
dflet 0:50cedd586816 540 g_pCB->TempProtocolHeader.Opcode = pCmdCtrl->Opcode;
dflet 0:50cedd586816 541 g_pCB->TempProtocolHeader.Len = _SL_PROTOCOL_CALC_LEN(pCmdCtrl, pCmdExt);
dflet 0:50cedd586816 542
dflet 0:50cedd586816 543 if (pCmdExt && pCmdExt->RxPayloadLen < 0 && pCmdExt->TxPayloadLen)
dflet 0:50cedd586816 544 {
dflet 0:50cedd586816 545 pCmdExt->RxPayloadLen = pCmdExt->RxPayloadLen * (-1); /* change sign */
dflet 0:50cedd586816 546 sendRxPayload = TRUE;
dflet 0:50cedd586816 547 g_pCB->TempProtocolHeader.Len = g_pCB->TempProtocolHeader.Len + pCmdExt->RxPayloadLen;
dflet 0:50cedd586816 548 }
dflet 0:50cedd586816 549
dflet 0:50cedd586816 550 #ifdef SL_START_WRITE_STAT
dflet 0:50cedd586816 551 sl_IfStartWriteSequence(g_pCB->FD);
dflet 0:50cedd586816 552 #endif
dflet 0:50cedd586816 553
dflet 0:50cedd586816 554 #ifdef SL_IF_TYPE_UART
dflet 0:50cedd586816 555 /* Write long sync pattern */
dflet 0:50cedd586816 556 _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NSyncPattern.Long, 2*SYNC_PATTERN_LEN);
dflet 0:50cedd586816 557 #else
dflet 0:50cedd586816 558 /* Write short sync pattern */
dflet 0:50cedd586816 559 _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NSyncPattern.Short, SYNC_PATTERN_LEN);
dflet 0:50cedd586816 560 #endif
dflet 0:50cedd586816 561 /* Header */
dflet 0:50cedd586816 562 _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_pCB->TempProtocolHeader, _SL_CMD_HDR_SIZE);
dflet 0:50cedd586816 563
dflet 0:50cedd586816 564 /* Descriptors */
dflet 0:50cedd586816 565 if (pTxRxDescBuff && pCmdCtrl->TxDescLen > 0)
dflet 0:50cedd586816 566 {
dflet 0:50cedd586816 567 _spi.spi_Write(g_pCB->FD, pTxRxDescBuff,
dflet 0:50cedd586816 568 _SL_PROTOCOL_ALIGN_SIZE(pCmdCtrl->TxDescLen));
dflet 0:50cedd586816 569 }
dflet 0:50cedd586816 570
dflet 0:50cedd586816 571 /* A special mode where Rx payload and Rx length are used as Tx as well */
dflet 0:50cedd586816 572 /* This mode requires no Rx payload on the response and currently used by fs_Close and sl_Send on */
dflet 0:50cedd586816 573 /* transceiver mode */
dflet 0:50cedd586816 574 if (sendRxPayload == TRUE )
dflet 0:50cedd586816 575 {
dflet 0:50cedd586816 576 _spi.spi_Write(g_pCB->FD, pCmdExt->pRxPayload, _SL_PROTOCOL_ALIGN_SIZE(pCmdExt->RxPayloadLen));
dflet 0:50cedd586816 577 }
dflet 0:50cedd586816 578
dflet 0:50cedd586816 579 /* Payload */
dflet 0:50cedd586816 580 if (pCmdExt && pCmdExt->TxPayloadLen > 0)
dflet 0:50cedd586816 581 {
dflet 0:50cedd586816 582 /* If the message has payload, it is mandatory that the message's arguments are protocol aligned. */
dflet 0:50cedd586816 583 /* Otherwise the aligning of arguments will create a gap between arguments and payload. */
dflet 0:50cedd586816 584 VERIFY_PROTOCOL(_SL_IS_PROTOCOL_ALIGNED_SIZE(pCmdCtrl->TxDescLen));
dflet 0:50cedd586816 585
dflet 0:50cedd586816 586 _spi.spi_Write(g_pCB->FD, pCmdExt->pTxPayload, _SL_PROTOCOL_ALIGN_SIZE(pCmdExt->TxPayloadLen));
dflet 0:50cedd586816 587 }
dflet 0:50cedd586816 588
dflet 0:50cedd586816 589 _SL_DBG_CNT_INC(MsgCnt.Write);
dflet 0:50cedd586816 590
dflet 0:50cedd586816 591 #ifdef SL_START_WRITE_STAT
dflet 0:50cedd586816 592 sl_IfEndWriteSequence(g_pCB->FD);
dflet 0:50cedd586816 593 #endif
dflet 0:50cedd586816 594
dflet 0:50cedd586816 595 return SL_OS_RET_CODE_OK;
dflet 0:50cedd586816 596 }
dflet 0:50cedd586816 597
dflet 0:50cedd586816 598 /* ******************************************************************************/
dflet 0:50cedd586816 599 /* _SlDrvMsgRead */
dflet 0:50cedd586816 600 /* ******************************************************************************/
dflet 0:50cedd586816 601 _SlReturnVal_t cc3100_driver::_SlDrvMsgRead(void)
dflet 0:50cedd586816 602 {
dflet 0:50cedd586816 603 /* alignment for small memory models */
dflet 0:50cedd586816 604 union {
dflet 0:50cedd586816 605 uint8_t TempBuf[_SL_RESP_HDR_SIZE];
dflet 0:50cedd586816 606 uint32_t DummyBuf[2];
dflet 0:50cedd586816 607 } uBuf;
dflet 0:50cedd586816 608 uint8_t TailBuffer[4];
dflet 0:50cedd586816 609 uint16_t LengthToCopy;
dflet 0:50cedd586816 610 uint16_t AlignedLengthRecv;
dflet 0:50cedd586816 611 uint8_t AlignSize;
dflet 0:50cedd586816 612 uint8_t *pAsyncBuf = NULL;
dflet 0:50cedd586816 613 uint16_t OpCode;
dflet 0:50cedd586816 614 uint16_t RespPayloadLen;
dflet 0:50cedd586816 615 uint8_t sd = SL_MAX_SOCKETS;
dflet 0:50cedd586816 616 _SlRxMsgClass_e RxMsgClass;
dflet 0:50cedd586816 617
dflet 0:50cedd586816 618
dflet 0:50cedd586816 619 /* save params in global CB */
dflet 0:50cedd586816 620 g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;
dflet 0:50cedd586816 621 g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler= NULL;
dflet 0:50cedd586816 622
dflet 0:50cedd586816 623
dflet 0:50cedd586816 624 VERIFY_RET_OK(_SlDrvRxHdrRead((uint8_t*)(uBuf.TempBuf), &AlignSize));
dflet 0:50cedd586816 625 OpCode = OPCODE(uBuf.TempBuf);
dflet 0:50cedd586816 626 RespPayloadLen = RSP_PAYLOAD_LEN(uBuf.TempBuf);
dflet 0:50cedd586816 627
dflet 0:50cedd586816 628
dflet 0:50cedd586816 629 /* 'Init Compelete' message bears no valid FlowControl info */
dflet 0:50cedd586816 630 if(SL_OPCODE_DEVICE_INITCOMPLETE != OpCode) {
dflet 0:50cedd586816 631 g_pCB->FlowContCB.TxPoolCnt = ((_SlResponseHeader_t *)uBuf.TempBuf)->TxPoolCnt;
dflet 0:50cedd586816 632 g_pCB->SocketNonBlocking = ((_SlResponseHeader_t *)uBuf.TempBuf)->SocketNonBlocking;
dflet 0:50cedd586816 633 g_pCB->SocketTXFailure = ((_SlResponseHeader_t *)uBuf.TempBuf)->SocketTXFailure;
dflet 0:50cedd586816 634
dflet 0:50cedd586816 635 if(g_pCB->FlowContCB.TxPoolCnt > FLOW_CONT_MIN) {
dflet 0:50cedd586816 636 _SlDrvSyncObjSignal(&g_pCB->FlowContCB.TxSyncObj);
dflet 0:50cedd586816 637 }
dflet 0:50cedd586816 638 }
dflet 16:7e5aab2fabba 639
dflet 0:50cedd586816 640 /* Find the RX messaage class and set its async event handler */
dflet 0:50cedd586816 641 _SlDrvClassifyRxMsg(OpCode);
dflet 0:50cedd586816 642 RxMsgClass = g_pCB->FunctionParams.AsyncExt.RxMsgClass;
dflet 0:50cedd586816 643
dflet 0:50cedd586816 644
dflet 0:50cedd586816 645 switch(RxMsgClass)
dflet 0:50cedd586816 646 {
dflet 0:50cedd586816 647 case ASYNC_EVT_CLASS:
dflet 0:50cedd586816 648
dflet 0:50cedd586816 649 VERIFY_PROTOCOL(NULL == pAsyncBuf);
dflet 0:50cedd586816 650
dflet 0:50cedd586816 651 #ifdef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 652 g_pCB->FunctionParams.AsyncExt.pAsyncBuf = sl_Malloc(SL_ASYNC_MAX_MSG_LEN);
dflet 0:50cedd586816 653 #else
dflet 0:50cedd586816 654 g_pCB->FunctionParams.AsyncExt.pAsyncBuf = g_StatMem.AsyncRespBuf;
dflet 0:50cedd586816 655 #endif
dflet 0:50cedd586816 656 /* set the local pointer to the allocated one */
dflet 0:50cedd586816 657 pAsyncBuf = g_pCB->FunctionParams.AsyncExt.pAsyncBuf;
dflet 0:50cedd586816 658
dflet 0:50cedd586816 659 /* clear the async buffer */
dflet 0:50cedd586816 660 _SlDrvMemZero(pAsyncBuf, SL_ASYNC_MAX_MSG_LEN);
dflet 0:50cedd586816 661
dflet 0:50cedd586816 662 MALLOC_OK_CHECK(pAsyncBuf);
dflet 0:50cedd586816 663
dflet 0:50cedd586816 664 memcpy(pAsyncBuf, uBuf.TempBuf, _SL_RESP_HDR_SIZE);
dflet 0:50cedd586816 665 if (_SL_PROTOCOL_ALIGN_SIZE(RespPayloadLen) <= SL_ASYNC_MAX_PAYLOAD_LEN)
dflet 0:50cedd586816 666 {
dflet 0:50cedd586816 667 AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(RespPayloadLen);
dflet 0:50cedd586816 668 }
dflet 0:50cedd586816 669 else
dflet 0:50cedd586816 670 {
dflet 0:50cedd586816 671 AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(SL_ASYNC_MAX_PAYLOAD_LEN);
dflet 0:50cedd586816 672 }
dflet 0:50cedd586816 673 if (RespPayloadLen > 0)
dflet 0:50cedd586816 674 {
dflet 0:50cedd586816 675 _spi.spi_Read(g_pCB->FD, pAsyncBuf + _SL_RESP_HDR_SIZE, AlignedLengthRecv);
dflet 0:50cedd586816 676 }
dflet 0:50cedd586816 677 /* In case ASYNC RX buffer length is smaller then the received data length, dump the rest */
dflet 0:50cedd586816 678 if ((_SL_PROTOCOL_ALIGN_SIZE(RespPayloadLen) > SL_ASYNC_MAX_PAYLOAD_LEN))
dflet 0:50cedd586816 679 {
dflet 0:50cedd586816 680 AlignedLengthRecv = _SL_PROTOCOL_ALIGN_SIZE(RespPayloadLen) - SL_ASYNC_MAX_PAYLOAD_LEN;
dflet 0:50cedd586816 681 while (AlignedLengthRecv > 0)
dflet 0:50cedd586816 682 {
dflet 0:50cedd586816 683 _spi.spi_Read(g_pCB->FD,TailBuffer,4);
dflet 0:50cedd586816 684 AlignedLengthRecv = AlignedLengthRecv - 4;
dflet 0:50cedd586816 685 }
dflet 0:50cedd586816 686 }
dflet 0:50cedd586816 687
dflet 0:50cedd586816 688 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 689
dflet 0:50cedd586816 690 if (
dflet 0:50cedd586816 691 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 692 (SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE == OpCode) || (SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE_V6 == OpCode) ||
dflet 0:50cedd586816 693 #endif
dflet 0:50cedd586816 694 (SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE == OpCode)
dflet 0:50cedd586816 695 )
dflet 0:50cedd586816 696 {
dflet 0:50cedd586816 697 /* go over the active list if exist to find obj waiting for this Async event */
dflet 0:50cedd586816 698 sd = ((((_SocketResponse_t *)(pAsyncBuf + _SL_RESP_HDR_SIZE))->sd) & BSD_SOCKET_ID_MASK);
dflet 0:50cedd586816 699 }
dflet 0:50cedd586816 700 _SlFindAndSetActiveObj(OpCode, sd);
dflet 0:50cedd586816 701 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 702
dflet 0:50cedd586816 703 break;
dflet 0:50cedd586816 704 case RECV_RESP_CLASS:
dflet 0:50cedd586816 705 {
dflet 0:50cedd586816 706 uint8_t ExpArgSize; /* Expected size of Recv/Recvfrom arguments */
dflet 0:50cedd586816 707
dflet 0:50cedd586816 708 switch(OpCode)
dflet 0:50cedd586816 709 {
dflet 0:50cedd586816 710 case SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE:
dflet 0:50cedd586816 711 ExpArgSize = RECVFROM_IPV4_ARGS_SIZE;
dflet 0:50cedd586816 712 break;
dflet 0:50cedd586816 713 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 714 case SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6:
dflet 0:50cedd586816 715 ExpArgSize = RECVFROM_IPV6_ARGS_SIZE;
dflet 0:50cedd586816 716 break;
dflet 0:50cedd586816 717 #endif
dflet 0:50cedd586816 718 default:
dflet 0:50cedd586816 719 /* SL_OPCODE_SOCKET_RECVASYNCRESPONSE: */
dflet 0:50cedd586816 720 ExpArgSize = RECV_ARGS_SIZE;
dflet 0:50cedd586816 721 }
dflet 0:50cedd586816 722
dflet 0:50cedd586816 723 /* Read first 4 bytes of Recv/Recvfrom response to get SocketId and actual */
dflet 0:50cedd586816 724 /* response data length */
dflet 0:50cedd586816 725 _spi.spi_Read(g_pCB->FD, &uBuf.TempBuf[4], RECV_ARGS_SIZE);
dflet 0:50cedd586816 726
dflet 0:50cedd586816 727 /* Validate Socket ID and Received Length value. */
dflet 0:50cedd586816 728 VERIFY_PROTOCOL((SD(&uBuf.TempBuf[4])& BSD_SOCKET_ID_MASK) < SL_MAX_SOCKETS);
dflet 0:50cedd586816 729
dflet 0:50cedd586816 730 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 731
dflet 0:50cedd586816 732 /* go over the active list if exist to find obj waiting for this Async event */
dflet 0:50cedd586816 733 VERIFY_RET_OK(_SlFindAndSetActiveObj(OpCode,SD(&uBuf.TempBuf[4]) & BSD_SOCKET_ID_MASK));
dflet 0:50cedd586816 734
dflet 0:50cedd586816 735 /* Verify data is waited on this socket. The pArgs should have been set by _SlDrvDataReadOp(). */
dflet 0:50cedd586816 736 VERIFY_SOCKET_CB(NULL != ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pData))->pArgs);
dflet 0:50cedd586816 737
dflet 0:50cedd586816 738 memcpy( ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pArgs, &uBuf.TempBuf[4], RECV_ARGS_SIZE);
dflet 0:50cedd586816 739
dflet 0:50cedd586816 740 if(ExpArgSize > RECV_ARGS_SIZE)
dflet 0:50cedd586816 741 {
dflet 0:50cedd586816 742 _spi.spi_Read(g_pCB->FD,
dflet 0:50cedd586816 743 ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pArgs + RECV_ARGS_SIZE,
dflet 0:50cedd586816 744 ExpArgSize - RECV_ARGS_SIZE);
dflet 0:50cedd586816 745 }
dflet 0:50cedd586816 746
dflet 0:50cedd586816 747 /* Here g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pData contains requested(expected) Recv/Recvfrom DataSize. */
dflet 0:50cedd586816 748 /* Overwrite requested DataSize with actual one. */
dflet 0:50cedd586816 749 /* If error is received, this information will be read from arguments. */
dflet 0:50cedd586816 750 if(ACT_DATA_SIZE(&uBuf.TempBuf[4]) > 0)
dflet 0:50cedd586816 751 {
dflet 0:50cedd586816 752 VERIFY_SOCKET_CB(NULL != ((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData);
dflet 0:50cedd586816 753
dflet 0:50cedd586816 754 /* Read 4 bytes aligned from interface */
dflet 0:50cedd586816 755 /* therefore check the requested length and read only */
dflet 0:50cedd586816 756 /* 4 bytes aligned data. The rest unaligned (if any) will be read */
dflet 0:50cedd586816 757 /* and copied to a TailBuffer */
dflet 0:50cedd586816 758 LengthToCopy = ACT_DATA_SIZE(&uBuf.TempBuf[4]) & (3);
dflet 0:50cedd586816 759 AlignedLengthRecv = ACT_DATA_SIZE(&uBuf.TempBuf[4]) & (~3);
dflet 0:50cedd586816 760 if( AlignedLengthRecv >= 4)
dflet 0:50cedd586816 761 {
dflet 0:50cedd586816 762 _spi.spi_Read(g_pCB->FD,((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData,AlignedLengthRecv );
dflet 0:50cedd586816 763 }
dflet 0:50cedd586816 764 /* copy the unaligned part, if any */
dflet 0:50cedd586816 765 if( LengthToCopy > 0)
dflet 0:50cedd586816 766 {
dflet 0:50cedd586816 767 _spi.spi_Read(g_pCB->FD,TailBuffer,4);
dflet 0:50cedd586816 768 /* copy TailBuffer unaligned part (1/2/3 bytes) */
dflet 0:50cedd586816 769 memcpy(((_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->pData + AlignedLengthRecv,TailBuffer,LengthToCopy);
dflet 0:50cedd586816 770 }
dflet 0:50cedd586816 771 }
dflet 0:50cedd586816 772 _SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
dflet 0:50cedd586816 773 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 774 }
dflet 0:50cedd586816 775 break;
dflet 0:50cedd586816 776
dflet 0:50cedd586816 777 case CMD_RESP_CLASS:
dflet 0:50cedd586816 778
dflet 0:50cedd586816 779 /* Some commands pass a maximum arguments size. */
dflet 0:50cedd586816 780 /* In this case Driver will send extra dummy patterns to NWP if */
dflet 0:50cedd586816 781 /* the response message is smaller than maximum. */
dflet 0:50cedd586816 782 /* When RxDescLen is not exact, using RxPayloadLen is forbidden! */
dflet 0:50cedd586816 783 /* If such case cannot be avoided - parse message here to detect */
dflet 0:50cedd586816 784 /* arguments/payload border. */
dflet 0:50cedd586816 785 _spi.spi_Read(g_pCB->FD, g_pCB->FunctionParams.pTxRxDescBuff, _SL_PROTOCOL_ALIGN_SIZE(g_pCB->FunctionParams.pCmdCtrl->RxDescLen));
dflet 0:50cedd586816 786
dflet 0:50cedd586816 787 if((NULL != g_pCB->FunctionParams.pCmdExt) && (0 != g_pCB->FunctionParams.pCmdExt->RxPayloadLen)) {
dflet 0:50cedd586816 788 /* Actual size of command's response payload: <msg_payload_len> - <rsp_args_len> */
dflet 0:50cedd586816 789 int16_t ActDataSize = RSP_PAYLOAD_LEN(uBuf.TempBuf) - g_pCB->FunctionParams.pCmdCtrl->RxDescLen;
dflet 0:50cedd586816 790
dflet 0:50cedd586816 791 g_pCB->FunctionParams.pCmdExt->ActualRxPayloadLen = ActDataSize;
dflet 0:50cedd586816 792
dflet 0:50cedd586816 793 /* Check that the space prepared by user for the response data is sufficient. */
dflet 0:50cedd586816 794 if(ActDataSize <= 0) {
dflet 0:50cedd586816 795 g_pCB->FunctionParams.pCmdExt->RxPayloadLen = 0;
dflet 0:50cedd586816 796 } else {
dflet 0:50cedd586816 797 /* In case the user supplied Rx buffer length which is smaller then the received data length, copy according to user length */
dflet 0:50cedd586816 798 if (ActDataSize > g_pCB->FunctionParams.pCmdExt->RxPayloadLen) {
dflet 0:50cedd586816 799 LengthToCopy = g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (3);
dflet 0:50cedd586816 800 AlignedLengthRecv = g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (~3);
dflet 0:50cedd586816 801 } else {
dflet 0:50cedd586816 802 LengthToCopy = ActDataSize & (3);
dflet 0:50cedd586816 803 AlignedLengthRecv = ActDataSize & (~3);
dflet 0:50cedd586816 804 }
dflet 0:50cedd586816 805 /* Read 4 bytes aligned from interface */
dflet 0:50cedd586816 806 /* therefore check the requested length and read only */
dflet 0:50cedd586816 807 /* 4 bytes aligned data. The rest unaligned (if any) will be read */
dflet 0:50cedd586816 808 /* and copied to a TailBuffer */
dflet 0:50cedd586816 809
dflet 0:50cedd586816 810 if( AlignedLengthRecv >= 4) {
dflet 0:50cedd586816 811 _spi.spi_Read(g_pCB->FD,
dflet 0:50cedd586816 812 g_pCB->FunctionParams.pCmdExt->pRxPayload,
dflet 0:50cedd586816 813 AlignedLengthRecv );
dflet 0:50cedd586816 814
dflet 0:50cedd586816 815 }
dflet 0:50cedd586816 816 /* copy the unaligned part, if any */
dflet 0:50cedd586816 817 if( LengthToCopy > 0) {
dflet 0:50cedd586816 818 _spi.spi_Read(g_pCB->FD,TailBuffer,4);
dflet 0:50cedd586816 819 /* copy TailBuffer unaligned part (1/2/3 bytes) */
dflet 0:50cedd586816 820 memcpy(g_pCB->FunctionParams.pCmdExt->pRxPayload + AlignedLengthRecv,
dflet 0:50cedd586816 821 TailBuffer,
dflet 0:50cedd586816 822 LengthToCopy);
dflet 0:50cedd586816 823 ActDataSize = ActDataSize-4;
dflet 0:50cedd586816 824 }
dflet 0:50cedd586816 825 /* In case the user supplied Rx buffer length which is smaller then the received data length, dump the rest */
dflet 0:50cedd586816 826 if (ActDataSize > g_pCB->FunctionParams.pCmdExt->RxPayloadLen) {
dflet 0:50cedd586816 827 /* calculate the rest of the data size to dump */
dflet 0:50cedd586816 828 AlignedLengthRecv = ActDataSize - (g_pCB->FunctionParams.pCmdExt->RxPayloadLen & (~3));
dflet 0:50cedd586816 829 while( AlignedLengthRecv > 0) {
dflet 0:50cedd586816 830 _spi.spi_Read(g_pCB->FD,TailBuffer, 4 );
dflet 0:50cedd586816 831 AlignedLengthRecv = AlignedLengthRecv - 4;
dflet 0:50cedd586816 832 }
dflet 0:50cedd586816 833 }
dflet 0:50cedd586816 834 }
dflet 0:50cedd586816 835 }
dflet 0:50cedd586816 836 break;
dflet 0:50cedd586816 837
dflet 0:50cedd586816 838 default:
dflet 0:50cedd586816 839 /* DUMMY_MSG_CLASS: Flow control message has no payload. */
dflet 0:50cedd586816 840 break;
dflet 0:50cedd586816 841 }
dflet 0:50cedd586816 842
dflet 0:50cedd586816 843 if(AlignSize > 0) {
dflet 0:50cedd586816 844 _spi.spi_Read(g_pCB->FD, uBuf.TempBuf, AlignSize);
dflet 0:50cedd586816 845 }
dflet 0:50cedd586816 846
dflet 0:50cedd586816 847 _SL_DBG_CNT_INC(MsgCnt.Read);
dflet 0:50cedd586816 848
dflet 0:50cedd586816 849 /* Unmask Interrupt call */
dflet 0:50cedd586816 850 _spi.UnMaskIntHdlr();
dflet 0:50cedd586816 851
dflet 0:50cedd586816 852 return SL_OS_RET_CODE_OK;
dflet 0:50cedd586816 853 }
dflet 0:50cedd586816 854
dflet 0:50cedd586816 855 /* ******************************************************************************/
dflet 0:50cedd586816 856 /* _SlAsyncEventGenericHandler */
dflet 0:50cedd586816 857 /* ******************************************************************************/
dflet 0:50cedd586816 858 void cc3100_driver::_SlAsyncEventGenericHandler(void)
dflet 0:50cedd586816 859 {
dflet 0:50cedd586816 860 uint32_t SlAsyncEvent = 0;
dflet 0:50cedd586816 861 uint8_t OpcodeFound = FALSE;
dflet 0:50cedd586816 862 uint8_t i;
dflet 0:50cedd586816 863
dflet 0:50cedd586816 864 uint32_t* pEventLocation = NULL; /* This pointer will override the async buffer with the translated event type */
dflet 0:50cedd586816 865 _SlResponseHeader_t *pHdr = (_SlResponseHeader_t *)g_pCB->FunctionParams.AsyncExt.pAsyncBuf;
dflet 0:50cedd586816 866
dflet 0:50cedd586816 867
dflet 0:50cedd586816 868 /* if no async event registered nothing to do..*/
dflet 0:50cedd586816 869 if (g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler == NULL)
dflet 0:50cedd586816 870 return;
dflet 0:50cedd586816 871
dflet 0:50cedd586816 872 /* Iterate through all the opcode in the table */
dflet 0:50cedd586816 873 for (i=0; i< (sizeof(OpcodeTranslateTable) / sizeof(OpcodeKeyVal_t)); i++)
dflet 0:50cedd586816 874 {
dflet 0:50cedd586816 875 if (OpcodeTranslateTable[i].opcode == pHdr->GenHeader.Opcode)
dflet 0:50cedd586816 876 {
dflet 0:50cedd586816 877 SlAsyncEvent = OpcodeTranslateTable[i].event;
dflet 0:50cedd586816 878 OpcodeFound = TRUE;
dflet 0:50cedd586816 879 break;
dflet 0:50cedd586816 880 }
dflet 0:50cedd586816 881 }
dflet 0:50cedd586816 882
dflet 0:50cedd586816 883 /* No Async event found in the table */
dflet 0:50cedd586816 884 if (OpcodeFound == FALSE)
dflet 0:50cedd586816 885 {
dflet 0:50cedd586816 886 /* This case handles all the async events handlers of the DEVICE & SOCK Silos which are handled internally.
dflet 0:50cedd586816 887 For these cases we send the async even buffer as is */
dflet 0:50cedd586816 888 g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
dflet 0:50cedd586816 889 }
dflet 0:50cedd586816 890 else
dflet 0:50cedd586816 891 {
dflet 0:50cedd586816 892 /* calculate the event type location to be filled in the async buffer */
dflet 0:50cedd586816 893 pEventLocation = (uint32_t*)(g_pCB->FunctionParams.AsyncExt.pAsyncBuf + sizeof (_SlResponseHeader_t) - sizeof(SlAsyncEvent) );
dflet 0:50cedd586816 894
dflet 0:50cedd586816 895 /* Override the async buffer (before the data starts ) with our event type */
dflet 0:50cedd586816 896 *pEventLocation = SlAsyncEvent;
dflet 0:50cedd586816 897
dflet 0:50cedd586816 898 /* call the event handler registered by the user with our async buffer which now holds
dflet 0:50cedd586816 899 the User's event type and its related data */
dflet 0:50cedd586816 900 g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler(pEventLocation);
dflet 0:50cedd586816 901 }
dflet 0:50cedd586816 902
dflet 0:50cedd586816 903 }
dflet 0:50cedd586816 904
dflet 0:50cedd586816 905
dflet 0:50cedd586816 906 /* ******************************************************************************/
dflet 0:50cedd586816 907 /* _SlDrvMsgReadCmdCtx */
dflet 0:50cedd586816 908 /* ******************************************************************************/
dflet 0:50cedd586816 909 _SlReturnVal_t cc3100_driver::_SlDrvMsgReadCmdCtx(void)
dflet 0:50cedd586816 910 {
dflet 0:50cedd586816 911 /* after command response is received and isCmdRespWaited */
dflet 0:50cedd586816 912 /* flag is set FALSE, it is necessary to read out all */
dflet 0:50cedd586816 913 /* Async messages in Commands context, because ssiDma_IsrHandleSignalFromSlave */
dflet 0:50cedd586816 914 /* could have dispatched some Async messages to g_NwpIf.CmdSyncObj */
dflet 0:50cedd586816 915 /* after command response but before this response has been processed */
dflet 0:50cedd586816 916 /* by spi_singleRead and isCmdRespWaited was set FALSE. */
dflet 0:50cedd586816 917
dflet 0:50cedd586816 918 while (TRUE == g_pCB->IsCmdRespWaited) {
dflet 0:50cedd586816 919
dflet 0:50cedd586816 920 if(_SL_PENDING_RX_MSG(g_pCB)) {
dflet 0:50cedd586816 921
dflet 0:50cedd586816 922 VERIFY_RET_OK(_SlDrvMsgRead());
dflet 0:50cedd586816 923 g_pCB->RxDoneCnt++;
dflet 16:7e5aab2fabba 924
dflet 0:50cedd586816 925 if (CMD_RESP_CLASS == g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
dflet 0:50cedd586816 926 g_pCB->IsCmdRespWaited = FALSE;
dflet 0:50cedd586816 927
dflet 0:50cedd586816 928 /* In case CmdResp has been read without waiting on CmdSyncObj - that */
dflet 0:50cedd586816 929 /* Sync object. That to prevent old signal to be processed. */
dflet 0:50cedd586816 930 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 931 _nonos.sl_SyncObjClear(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 932 #else
dflet 0:50cedd586816 933 sl_SyncObjClear(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 934 #endif
dflet 0:50cedd586816 935 } else if (ASYNC_EVT_CLASS == g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
dflet 0:50cedd586816 936 /* If Async event has been read in CmdResp context, check whether */
dflet 0:50cedd586816 937 /* there is a handler for this event. If there is, spawn specific */
dflet 0:50cedd586816 938 /* handler. Otherwise free the event's buffer. */
dflet 0:50cedd586816 939 /* This way there will be no "dry shots" from CmdResp context to */
dflet 0:50cedd586816 940 /* temporary context, i.e less waste of CPU and faster buffer */
dflet 0:50cedd586816 941 /* release. */
dflet 0:50cedd586816 942 _SlAsyncEventGenericHandler();
dflet 16:7e5aab2fabba 943
dflet 0:50cedd586816 944 #ifdef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 945 sl_Free(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
dflet 0:50cedd586816 946 #else
dflet 0:50cedd586816 947 g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;
dflet 0:50cedd586816 948 #endif
dflet 0:50cedd586816 949 }
dflet 0:50cedd586816 950 } else {
dflet 0:50cedd586816 951 /* CmdSyncObj will be signaled by IRQ */
dflet 0:50cedd586816 952 _SlDrvSyncObjWaitForever(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 953 }
dflet 0:50cedd586816 954 }
dflet 0:50cedd586816 955
dflet 0:50cedd586816 956 /* If there are more pending Rx Msgs after CmdResp is received, */
dflet 0:50cedd586816 957 /* that means that these are Async, Dummy or Read Data Msgs. */
dflet 0:50cedd586816 958 /* Spawn _SlDrvMsgReadSpawnCtx to trigger reading these messages from */
dflet 0:50cedd586816 959 /* Temporary context. */
dflet 0:50cedd586816 960 /* sl_Spawn is activated, using a different context */
dflet 0:50cedd586816 961 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 962
dflet 0:50cedd586816 963 if(_SL_PENDING_RX_MSG(g_pCB)) {
dflet 0:50cedd586816 964 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 965 _nonos._SlNonOsSpawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 966 #else
dflet 0:50cedd586816 967 sl_Spawn((_SlSpawnEntryFunc_t)&_SlDrvMsgReadSpawnCtx, NULL, 0);
dflet 0:50cedd586816 968 #endif
dflet 0:50cedd586816 969 }
dflet 0:50cedd586816 970
dflet 0:50cedd586816 971 return SL_OS_RET_CODE_OK;
dflet 0:50cedd586816 972 }
dflet 0:50cedd586816 973
dflet 0:50cedd586816 974 /* ******************************************************************************/
dflet 0:50cedd586816 975 /* _SlDrvMsgReadSpawnCtx */
dflet 0:50cedd586816 976 /* ******************************************************************************/
dflet 0:50cedd586816 977 /*
dflet 0:50cedd586816 978 _SlReturnVal_t cc3100_driver::_SlDrvMsgReadSpawnCtx_(void *pValue)
dflet 0:50cedd586816 979 {
dflet 0:50cedd586816 980
dflet 0:50cedd586816 981 #ifdef SL_POLLING_MODE_USED
dflet 0:50cedd586816 982 int16_t retCode = OSI_OK;
dflet 0:50cedd586816 983 // for polling based systems
dflet 0:50cedd586816 984 do {
dflet 0:50cedd586816 985 retCode = sl_LockObjLock(&g_pCB->GlobalLockObj, 0);
dflet 0:50cedd586816 986 if ( OSI_OK != retCode ) {
dflet 0:50cedd586816 987 if (TRUE == g_pCB->IsCmdRespWaited) {
dflet 0:50cedd586816 988 _SlDrvSyncObjSignal(&g_pCB->CmdSyncObj);
dflet 0:50cedd586816 989 return SL_RET_CODE_OK;
dflet 0:50cedd586816 990 }
dflet 0:50cedd586816 991 }
dflet 0:50cedd586816 992
dflet 0:50cedd586816 993 } while (OSI_OK != retCode);
dflet 0:50cedd586816 994
dflet 0:50cedd586816 995 #else
dflet 0:50cedd586816 996 _SlDrvObjLockWaitForever(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 997 #endif
dflet 0:50cedd586816 998
dflet 0:50cedd586816 999 // Messages might have been read by CmdResp context. Therefore after
dflet 0:50cedd586816 1000 // getting LockObj, check again where the Pending Rx Msg is still present.
dflet 0:50cedd586816 1001 if(FALSE == (_SL_PENDING_RX_MSG(g_pCB))) {
dflet 0:50cedd586816 1002 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 1003 return SL_RET_CODE_OK;
dflet 0:50cedd586816 1004 }
dflet 0:50cedd586816 1005
dflet 0:50cedd586816 1006 VERIFY_RET_OK(_SlDrvMsgRead());
dflet 0:50cedd586816 1007
dflet 0:50cedd586816 1008 g_pCB->RxDoneCnt++;
dflet 0:50cedd586816 1009
dflet 0:50cedd586816 1010 switch(g_pCB->FunctionParams.AsyncExt.RxMsgClass) {
dflet 0:50cedd586816 1011 case ASYNC_EVT_CLASS:
dflet 0:50cedd586816 1012 // If got here and protected by LockObj a message is waiting
dflet 0:50cedd586816 1013 // to be read
dflet 0:50cedd586816 1014 VERIFY_PROTOCOL(NULL != g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
dflet 0:50cedd586816 1015
dflet 0:50cedd586816 1016 _SlAsyncEventGenericHandler();
dflet 0:50cedd586816 1017
dflet 0:50cedd586816 1018 #ifdef SL_MEMORY_MGMT_DYNAMIC
dflet 0:50cedd586816 1019 sl_Free(g_pCB->FunctionParams.AsyncExt.pAsyncBuf);
dflet 0:50cedd586816 1020 #else
dflet 0:50cedd586816 1021 g_pCB->FunctionParams.AsyncExt.pAsyncBuf = NULL;
dflet 0:50cedd586816 1022 #endif
dflet 0:50cedd586816 1023 break;
dflet 0:50cedd586816 1024 case DUMMY_MSG_CLASS:
dflet 0:50cedd586816 1025 case RECV_RESP_CLASS:
dflet 0:50cedd586816 1026 // These types are legal in this context. Do nothing
dflet 0:50cedd586816 1027 break;
dflet 0:50cedd586816 1028 case CMD_RESP_CLASS:
dflet 0:50cedd586816 1029 // Command response is illegal in this context.
dflet 0:50cedd586816 1030 // No 'break' here: Assert!
dflet 0:50cedd586816 1031 default:
dflet 0:50cedd586816 1032 VERIFY_PROTOCOL(0);
dflet 0:50cedd586816 1033 }
dflet 0:50cedd586816 1034
dflet 0:50cedd586816 1035 _SlDrvObjUnLock(&g_pCB->GlobalLockObj);
dflet 0:50cedd586816 1036
dflet 0:50cedd586816 1037 return(SL_RET_CODE_OK);
dflet 0:50cedd586816 1038 }
dflet 0:50cedd586816 1039 */
dflet 0:50cedd586816 1040 /* ******************************************************************************/
dflet 0:50cedd586816 1041 /* _SlDrvClassifyRxMsg */
dflet 0:50cedd586816 1042 /* ******************************************************************************/
dflet 0:50cedd586816 1043 void cc3100_driver::_SlDrvClassifyRxMsg(_SlOpcode_t Opcode)
dflet 0:50cedd586816 1044 {
dflet 0:50cedd586816 1045 _SlSpawnEntryFunc_t AsyncEvtHandler = NULL;
dflet 0:50cedd586816 1046 _SlRxMsgClass_e RxMsgClass = CMD_RESP_CLASS;
dflet 0:50cedd586816 1047 uint8_t Silo;
dflet 0:50cedd586816 1048
dflet 0:50cedd586816 1049
dflet 0:50cedd586816 1050 if (0 == (SL_OPCODE_SYNC & Opcode))
dflet 0:50cedd586816 1051 { /* Async event has received */
dflet 0:50cedd586816 1052
dflet 0:50cedd586816 1053 if (SL_OPCODE_DEVICE_DEVICEASYNCDUMMY == Opcode)
dflet 0:50cedd586816 1054 {
dflet 0:50cedd586816 1055 RxMsgClass = DUMMY_MSG_CLASS;
dflet 0:50cedd586816 1056 }
dflet 0:50cedd586816 1057 else if ( (SL_OPCODE_SOCKET_RECVASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE == Opcode)
dflet 0:50cedd586816 1058 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1059 || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6 == Opcode)
dflet 0:50cedd586816 1060 #endif
dflet 0:50cedd586816 1061 )
dflet 0:50cedd586816 1062 {
dflet 0:50cedd586816 1063 RxMsgClass = RECV_RESP_CLASS;
dflet 0:50cedd586816 1064 }
dflet 0:50cedd586816 1065 else
dflet 0:50cedd586816 1066 {
dflet 0:50cedd586816 1067 /* This is Async Event class message */
dflet 0:50cedd586816 1068 RxMsgClass = ASYNC_EVT_CLASS;
dflet 0:50cedd586816 1069
dflet 0:50cedd586816 1070 /* Despite the fact that 4 bits are allocated in the SILO field, we actually have only 6 SILOs
dflet 0:50cedd586816 1071 So we can use the 8 options of SILO in look up table */
dflet 0:50cedd586816 1072 Silo = ((Opcode >> SL_OPCODE_SILO_OFFSET) & 0x7);
dflet 0:50cedd586816 1073
dflet 0:50cedd586816 1074 VERIFY_PROTOCOL(Silo < (sizeof(RxMsgClassLUT)/sizeof(_SlSpawnEntryFunc_t)));
dflet 0:50cedd586816 1075
dflet 0:50cedd586816 1076 /* Set the async event hander according to the LUT */
dflet 0:50cedd586816 1077 AsyncEvtHandler = RxMsgClassLUT[Silo];
dflet 0:50cedd586816 1078
dflet 0:50cedd586816 1079 if ((SL_OPCODE_NETAPP_HTTPGETTOKENVALUE == Opcode) || (SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE == Opcode))
dflet 0:50cedd586816 1080 {
dflet 0:50cedd586816 1081 AsyncEvtHandler = _SlDrvNetAppEventHandler;
dflet 0:50cedd586816 1082 }
dflet 0:50cedd586816 1083 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1084 else if (SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE == Opcode)
dflet 0:50cedd586816 1085 {
dflet 0:50cedd586816 1086 AsyncEvtHandler = (_SlSpawnEntryFunc_t)_sl_HandleAsync_PingResponse;
dflet 0:50cedd586816 1087 }
dflet 0:50cedd586816 1088 #endif
dflet 0:50cedd586816 1089 }
dflet 0:50cedd586816 1090 }
dflet 0:50cedd586816 1091
dflet 0:50cedd586816 1092 g_pCB->FunctionParams.AsyncExt.RxMsgClass = RxMsgClass;
dflet 0:50cedd586816 1093 g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = AsyncEvtHandler;
dflet 0:50cedd586816 1094
dflet 0:50cedd586816 1095 }
dflet 0:50cedd586816 1096
dflet 0:50cedd586816 1097 /* ******************************************************************************/
dflet 0:50cedd586816 1098 /* _SlDrvRxHdrRead */
dflet 0:50cedd586816 1099 /* ******************************************************************************/
dflet 0:50cedd586816 1100 _SlReturnVal_t cc3100_driver::_SlDrvRxHdrRead(uint8_t *pBuf, uint8_t *pAlignSize)
dflet 0:50cedd586816 1101 {
dflet 0:50cedd586816 1102 uint32_t SyncCnt = 0;
dflet 16:7e5aab2fabba 1103 uint8_t ShiftIdx;
dflet 0:50cedd586816 1104
dflet 0:50cedd586816 1105 #ifndef SL_IF_TYPE_UART
dflet 0:50cedd586816 1106 /* 1. Write CNYS pattern to NWP when working in SPI mode only */
dflet 0:50cedd586816 1107 _spi.spi_Write(g_pCB->FD, (uint8_t *)&g_H2NCnysPattern.Short, SYNC_PATTERN_LEN);
dflet 0:50cedd586816 1108 #endif
dflet 16:7e5aab2fabba 1109
dflet 0:50cedd586816 1110 /* 2. Read 4 bytes (protocol aligned) */
dflet 0:50cedd586816 1111 _spi.spi_Read(g_pCB->FD, &pBuf[0], 4);
dflet 0:50cedd586816 1112 _SL_DBG_SYNC_LOG(SyncCnt,pBuf);
dflet 16:7e5aab2fabba 1113
dflet 0:50cedd586816 1114 /* Wait for SYNC_PATTERN_LEN from the device */
dflet 0:50cedd586816 1115 while ( ! N2H_SYNC_PATTERN_MATCH(pBuf, g_pCB->TxSeqNum) ) {
dflet 0:50cedd586816 1116 /* 3. Debug limit of scan */
dflet 16:7e5aab2fabba 1117 if(SyncCnt >= SL_SYNC_SCAN_THRESHOLD){
dflet 16:7e5aab2fabba 1118 printf("SPI Sync pattern match fault\n\r");
dflet 16:7e5aab2fabba 1119 }
dflet 0:50cedd586816 1120 VERIFY_PROTOCOL(SyncCnt < SL_SYNC_SCAN_THRESHOLD);
dflet 0:50cedd586816 1121
dflet 0:50cedd586816 1122 /* 4. Read next 4 bytes to Low 4 bytes of buffer */
dflet 0:50cedd586816 1123 if(0 == (SyncCnt % (uint32_t)SYNC_PATTERN_LEN)) {
dflet 0:50cedd586816 1124 _spi.spi_Read(g_pCB->FD, &pBuf[4], 4);
dflet 0:50cedd586816 1125 _SL_DBG_SYNC_LOG(SyncCnt,pBuf);
dflet 0:50cedd586816 1126 }
dflet 0:50cedd586816 1127
dflet 0:50cedd586816 1128 /* 5. Shift Buffer Up for checking if the sync is shifted */
dflet 0:50cedd586816 1129 for(ShiftIdx = 0; ShiftIdx< 7; ShiftIdx++)
dflet 0:50cedd586816 1130 {
dflet 0:50cedd586816 1131 pBuf[ShiftIdx] = pBuf[ShiftIdx+1];
dflet 0:50cedd586816 1132 }
dflet 0:50cedd586816 1133 pBuf[7] = 0;
dflet 0:50cedd586816 1134
dflet 0:50cedd586816 1135 SyncCnt++;
dflet 0:50cedd586816 1136 }
dflet 0:50cedd586816 1137
dflet 0:50cedd586816 1138 /* 5. Sync pattern found. If needed, complete number of read bytes to multiple of 4 (protocol align) */
dflet 0:50cedd586816 1139 SyncCnt %= SYNC_PATTERN_LEN;
dflet 0:50cedd586816 1140
dflet 0:50cedd586816 1141 if(SyncCnt > 0) {
dflet 0:50cedd586816 1142 *(uint32_t *)&pBuf[0] = *(uint32_t *)&pBuf[4];
dflet 0:50cedd586816 1143 _spi.spi_Read(g_pCB->FD, &pBuf[SYNC_PATTERN_LEN - SyncCnt], (uint16_t)SyncCnt);
dflet 0:50cedd586816 1144 } else {
dflet 0:50cedd586816 1145 _spi.spi_Read(g_pCB->FD, &pBuf[0], 4);
dflet 0:50cedd586816 1146 }
dflet 0:50cedd586816 1147
dflet 0:50cedd586816 1148 /* 6. Scan for Double pattern. */
dflet 0:50cedd586816 1149 while ( N2H_SYNC_PATTERN_MATCH(pBuf, g_pCB->TxSeqNum) ) {
dflet 0:50cedd586816 1150 _SL_DBG_CNT_INC(Work.DoubleSyncPattern);
dflet 0:50cedd586816 1151 _spi.spi_Read(g_pCB->FD, &pBuf[0], SYNC_PATTERN_LEN);
dflet 0:50cedd586816 1152 }
dflet 0:50cedd586816 1153 g_pCB->TxSeqNum++;
dflet 0:50cedd586816 1154
dflet 0:50cedd586816 1155 /* 7. Here we've read Generic Header (4 bytes). Read the Resp Specific header (4 more bytes). */
dflet 0:50cedd586816 1156 _spi.spi_Read(g_pCB->FD, &pBuf[SYNC_PATTERN_LEN], _SL_RESP_SPEC_HDR_SIZE);
dflet 0:50cedd586816 1157
dflet 0:50cedd586816 1158 /* 8. Here we've read the entire Resp Header. */
dflet 0:50cedd586816 1159 /* Return number bytes needed to be sent after read for NWP Rx 4-byte alignment (protocol alignment) */
dflet 0:50cedd586816 1160 *pAlignSize = (uint8_t)((SyncCnt > 0) ? (SYNC_PATTERN_LEN - SyncCnt) : 0);
dflet 0:50cedd586816 1161
dflet 0:50cedd586816 1162 return SL_RET_CODE_OK;
dflet 0:50cedd586816 1163 }
dflet 0:50cedd586816 1164
dflet 0:50cedd586816 1165 /* ***************************************************************************** */
dflet 0:50cedd586816 1166 /* _SlDrvBasicCmd */
dflet 0:50cedd586816 1167 /* ***************************************************************************** */
dflet 0:50cedd586816 1168 typedef union {
dflet 0:50cedd586816 1169 _BasicResponse_t Rsp;
dflet 0:50cedd586816 1170 } _SlBasicCmdMsg_u;
dflet 0:50cedd586816 1171
dflet 0:50cedd586816 1172 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1173 int16_t cc3100_driver::_SlDrvBasicCmd(_SlOpcode_t Opcode)
dflet 0:50cedd586816 1174 {
dflet 0:50cedd586816 1175 _SlBasicCmdMsg_u Msg = {0};
dflet 0:50cedd586816 1176 _SlCmdCtrl_t CmdCtrl;
dflet 0:50cedd586816 1177
dflet 0:50cedd586816 1178 CmdCtrl.Opcode = Opcode;
dflet 0:50cedd586816 1179 CmdCtrl.TxDescLen = 0;
dflet 0:50cedd586816 1180 CmdCtrl.RxDescLen = sizeof(_BasicResponse_t);
dflet 0:50cedd586816 1181
dflet 0:50cedd586816 1182
dflet 0:50cedd586816 1183 VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
dflet 0:50cedd586816 1184
dflet 0:50cedd586816 1185 return (int16_t)Msg.Rsp.status;
dflet 0:50cedd586816 1186 }
dflet 0:50cedd586816 1187
dflet 0:50cedd586816 1188 /*****************************************************************************
dflet 0:50cedd586816 1189 _SlDrvCmdSend
dflet 0:50cedd586816 1190 Send SL command without waiting for command response
dflet 0:50cedd586816 1191 This function is unprotected and the caller should make
dflet 0:50cedd586816 1192 sure global lock is active
dflet 0:50cedd586816 1193 *****************************************************************************/
dflet 0:50cedd586816 1194 _SlReturnVal_t cc3100_driver::_SlDrvCmdSend(_SlCmdCtrl_t *pCmdCtrl, void *pTxRxDescBuff, _SlCmdExt_t *pCmdExt)
dflet 0:50cedd586816 1195 {
dflet 0:50cedd586816 1196 _SlReturnVal_t RetVal;
dflet 0:50cedd586816 1197 uint8_t IsCmdRespWaitedOriginalVal;
dflet 0:50cedd586816 1198
dflet 0:50cedd586816 1199 _SlFunctionParams_t originalFuncParms;
dflet 0:50cedd586816 1200
dflet 0:50cedd586816 1201 /* save the current RespWait flag before clearing it */
dflet 0:50cedd586816 1202 IsCmdRespWaitedOriginalVal = g_pCB->IsCmdRespWaited;
dflet 0:50cedd586816 1203
dflet 0:50cedd586816 1204 /* save the current command parameters */
dflet 0:50cedd586816 1205 memcpy(&originalFuncParms, &g_pCB->FunctionParams, sizeof(_SlFunctionParams_t));
dflet 0:50cedd586816 1206
dflet 0:50cedd586816 1207 g_pCB->IsCmdRespWaited = FALSE;
dflet 0:50cedd586816 1208
dflet 0:50cedd586816 1209 SL_TRACE0(DBG_MSG, MSG_312, "_SlDrvCmdSend: call _SlDrvMsgWrite");
dflet 0:50cedd586816 1210
dflet 0:50cedd586816 1211 /* send the message */
dflet 0:50cedd586816 1212 RetVal = _SlDrvMsgWrite(pCmdCtrl, pCmdExt, (uint8_t*)pTxRxDescBuff);
dflet 0:50cedd586816 1213
dflet 0:50cedd586816 1214 /* restore the original RespWait flag */
dflet 0:50cedd586816 1215 g_pCB->IsCmdRespWaited = IsCmdRespWaitedOriginalVal;
dflet 0:50cedd586816 1216
dflet 0:50cedd586816 1217 /* restore the original command parameters */
dflet 0:50cedd586816 1218 memcpy(&g_pCB->FunctionParams, &originalFuncParms, sizeof(_SlFunctionParams_t));
dflet 0:50cedd586816 1219
dflet 0:50cedd586816 1220 return RetVal;
dflet 0:50cedd586816 1221
dflet 0:50cedd586816 1222
dflet 0:50cedd586816 1223 }
dflet 0:50cedd586816 1224 #endif
dflet 0:50cedd586816 1225
dflet 0:50cedd586816 1226 /* ***************************************************************************** */
dflet 0:50cedd586816 1227 /* _SlDrvWaitForPoolObj */
dflet 0:50cedd586816 1228 /* ***************************************************************************** */
dflet 0:50cedd586816 1229 uint8_t cc3100_driver::_SlDrvWaitForPoolObj(uint8_t ActionID, uint8_t SocketID)
dflet 0:50cedd586816 1230 {
dflet 0:50cedd586816 1231 uint8_t CurrObjIndex = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 1232
dflet 0:50cedd586816 1233 /* Get free object */
dflet 0:50cedd586816 1234 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 1235 if (MAX_CONCURRENT_ACTIONS > g_pCB->FreePoolIdx) {
dflet 0:50cedd586816 1236 /* save the current obj index */
dflet 0:50cedd586816 1237 CurrObjIndex = g_pCB->FreePoolIdx;
dflet 0:50cedd586816 1238 /* set the new free index */
dflet 0:50cedd586816 1239 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1240 if (MAX_CONCURRENT_ACTIONS > g_pCB->ObjPool[CurrObjIndex].NextIndex) {
dflet 0:50cedd586816 1241 g_pCB->FreePoolIdx = g_pCB->ObjPool[CurrObjIndex].NextIndex;
dflet 0:50cedd586816 1242 }
dflet 0:50cedd586816 1243 else
dflet 0:50cedd586816 1244 #endif
dflet 0:50cedd586816 1245 {
dflet 0:50cedd586816 1246 /* No further free actions available */
dflet 0:50cedd586816 1247 g_pCB->FreePoolIdx = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 1248 }
dflet 0:50cedd586816 1249 } else {
dflet 0:50cedd586816 1250 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 1251 return CurrObjIndex;
dflet 0:50cedd586816 1252 }
dflet 0:50cedd586816 1253 g_pCB->ObjPool[CurrObjIndex].ActionID = (uint8_t)ActionID;
dflet 0:50cedd586816 1254 if (SL_MAX_SOCKETS > SocketID) {
dflet 0:50cedd586816 1255 g_pCB->ObjPool[CurrObjIndex].AdditionalData = SocketID;
dflet 0:50cedd586816 1256 }
dflet 0:50cedd586816 1257 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1258 /*In case this action is socket related, SocketID bit will be on
dflet 0:50cedd586816 1259 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 */
dflet 0:50cedd586816 1260 while ( ( (SL_MAX_SOCKETS > SocketID) && (g_pCB->ActiveActionsBitmap & (1<<SocketID)) ) ||
dflet 0:50cedd586816 1261 ( (g_pCB->ActiveActionsBitmap & (1<<ActionID)) && (SL_MAX_SOCKETS == SocketID) ) )
dflet 0:50cedd586816 1262 {
dflet 0:50cedd586816 1263 /* action in progress - move to pending list */
dflet 0:50cedd586816 1264 g_pCB->ObjPool[CurrObjIndex].NextIndex = g_pCB->PendingPoolIdx;
dflet 0:50cedd586816 1265 g_pCB->PendingPoolIdx = CurrObjIndex;
dflet 0:50cedd586816 1266 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 1267
dflet 0:50cedd586816 1268 /* wait for action to be free */
dflet 0:50cedd586816 1269 _SlDrvSyncObjWaitForever(&g_pCB->ObjPool[CurrObjIndex].SyncObj);
dflet 0:50cedd586816 1270
dflet 0:50cedd586816 1271 /* set params and move to active (remove from pending list at _SlDrvReleasePoolObj) */
dflet 0:50cedd586816 1272 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 1273 }
dflet 0:50cedd586816 1274 #endif
dflet 0:50cedd586816 1275 /* mark as active. Set socket as active if action is on socket, otherwise mark action as active */
dflet 0:50cedd586816 1276 if (SL_MAX_SOCKETS > SocketID) {
dflet 0:50cedd586816 1277 g_pCB->ActiveActionsBitmap |= (1<<SocketID);
dflet 0:50cedd586816 1278 } else {
dflet 0:50cedd586816 1279 g_pCB->ActiveActionsBitmap |= (1<<ActionID);
dflet 0:50cedd586816 1280 }
dflet 0:50cedd586816 1281 /* move to active list */
dflet 0:50cedd586816 1282 g_pCB->ObjPool[CurrObjIndex].NextIndex = g_pCB->ActivePoolIdx;
dflet 0:50cedd586816 1283 g_pCB->ActivePoolIdx = CurrObjIndex;
dflet 0:50cedd586816 1284 /* unlock */
dflet 0:50cedd586816 1285 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 1286 return CurrObjIndex;
dflet 0:50cedd586816 1287 }
dflet 0:50cedd586816 1288
dflet 0:50cedd586816 1289 /* ******************************************************************************/
dflet 0:50cedd586816 1290 /* _SlDrvReleasePoolObj */
dflet 0:50cedd586816 1291 /* ******************************************************************************/
dflet 0:50cedd586816 1292 void cc3100_driver::_SlDrvReleasePoolObj(uint8_t ObjIdx)
dflet 0:50cedd586816 1293 {
dflet 0:50cedd586816 1294 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1295 uint8_t PendingIndex;
dflet 0:50cedd586816 1296 #endif
dflet 0:50cedd586816 1297
dflet 0:50cedd586816 1298 _SlDrvProtectionObjLockWaitForever();
dflet 0:50cedd586816 1299
dflet 0:50cedd586816 1300 /* In Tiny mode, there is only one object pool so no pending actions are available */
dflet 0:50cedd586816 1301 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1302 /* go over the pending list and release other pending action if needed */
dflet 0:50cedd586816 1303 PendingIndex = g_pCB->PendingPoolIdx;
dflet 0:50cedd586816 1304
dflet 0:50cedd586816 1305 while(MAX_CONCURRENT_ACTIONS > PendingIndex)
dflet 0:50cedd586816 1306 {
dflet 0:50cedd586816 1307 /* In case this action is socket related, SocketID is in use, otherwise will be set to SL_MAX_SOCKETS */
dflet 0:50cedd586816 1308 if ( (g_pCB->ObjPool[PendingIndex].ActionID == g_pCB->ObjPool[ObjIdx].ActionID) &&
dflet 0:50cedd586816 1309 ( (SL_MAX_SOCKETS == (g_pCB->ObjPool[PendingIndex].AdditionalData & BSD_SOCKET_ID_MASK)) ||
dflet 0:50cedd586816 1310 ((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) ))) )
dflet 0:50cedd586816 1311 {
dflet 0:50cedd586816 1312 /* remove from pending list */
dflet 0:50cedd586816 1313 _SlRemoveFromList(&g_pCB->PendingPoolIdx, PendingIndex);
dflet 0:50cedd586816 1314 _SlDrvSyncObjSignal(&g_pCB->ObjPool[PendingIndex].SyncObj);
dflet 0:50cedd586816 1315 break;
dflet 0:50cedd586816 1316 }
dflet 0:50cedd586816 1317 PendingIndex = g_pCB->ObjPool[PendingIndex].NextIndex;
dflet 0:50cedd586816 1318 }
dflet 0:50cedd586816 1319 #endif
dflet 0:50cedd586816 1320
dflet 0:50cedd586816 1321 if (SL_MAX_SOCKETS > (g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK))
dflet 0:50cedd586816 1322 {
dflet 0:50cedd586816 1323 /* unset socketID */
dflet 0:50cedd586816 1324 g_pCB->ActiveActionsBitmap &= ~(1<<(g_pCB->ObjPool[ObjIdx].AdditionalData & BSD_SOCKET_ID_MASK));
dflet 0:50cedd586816 1325 }
dflet 0:50cedd586816 1326 else
dflet 0:50cedd586816 1327 {
dflet 0:50cedd586816 1328 /* unset actionID */
dflet 0:50cedd586816 1329 g_pCB->ActiveActionsBitmap &= ~(1<<g_pCB->ObjPool[ObjIdx].ActionID);
dflet 0:50cedd586816 1330 }
dflet 0:50cedd586816 1331
dflet 0:50cedd586816 1332 /* delete old data */
dflet 0:50cedd586816 1333 g_pCB->ObjPool[ObjIdx].pRespArgs = NULL;
dflet 0:50cedd586816 1334 g_pCB->ObjPool[ObjIdx].ActionID = 0;
dflet 0:50cedd586816 1335 g_pCB->ObjPool[ObjIdx].AdditionalData = SL_MAX_SOCKETS;
dflet 0:50cedd586816 1336
dflet 0:50cedd586816 1337 /* remove from active list */
dflet 0:50cedd586816 1338 _SlRemoveFromList(&g_pCB->ActivePoolIdx, ObjIdx);
dflet 0:50cedd586816 1339 /* move to free list */
dflet 0:50cedd586816 1340 g_pCB->ObjPool[ObjIdx].NextIndex = g_pCB->FreePoolIdx;
dflet 0:50cedd586816 1341 g_pCB->FreePoolIdx = ObjIdx;
dflet 0:50cedd586816 1342
dflet 0:50cedd586816 1343 _SlDrvProtectionObjUnLock();
dflet 0:50cedd586816 1344 }
dflet 0:50cedd586816 1345
dflet 0:50cedd586816 1346 /* ******************************************************************************/
dflet 0:50cedd586816 1347 /* _SlRemoveFromList */
dflet 0:50cedd586816 1348 /* ******************************************************************************/
dflet 0:50cedd586816 1349 void cc3100_driver::_SlRemoveFromList(uint8_t *ListIndex, uint8_t ItemIndex)
dflet 0:50cedd586816 1350 {
dflet 0:50cedd586816 1351 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1352 uint8_t Idx;
dflet 0:50cedd586816 1353 #endif
dflet 0:50cedd586816 1354
dflet 0:50cedd586816 1355 if (MAX_CONCURRENT_ACTIONS == g_pCB->ObjPool[*ListIndex].NextIndex)
dflet 0:50cedd586816 1356 {
dflet 0:50cedd586816 1357 *ListIndex = MAX_CONCURRENT_ACTIONS;
dflet 0:50cedd586816 1358 }
dflet 0:50cedd586816 1359 /* As MAX_CONCURRENT_ACTIONS is equal to 1 in Tiny mode */
dflet 0:50cedd586816 1360 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1361 /* need to remove the first item in the list and therefore update the global which holds this index */
dflet 0:50cedd586816 1362 else if (*ListIndex == ItemIndex)
dflet 0:50cedd586816 1363 {
dflet 0:50cedd586816 1364 *ListIndex = g_pCB->ObjPool[ItemIndex].NextIndex;
dflet 0:50cedd586816 1365 }
dflet 0:50cedd586816 1366 else
dflet 0:50cedd586816 1367 {
dflet 0:50cedd586816 1368 Idx = *ListIndex;
dflet 0:50cedd586816 1369
dflet 0:50cedd586816 1370 while(MAX_CONCURRENT_ACTIONS > Idx)
dflet 0:50cedd586816 1371 {
dflet 0:50cedd586816 1372 /* remove from list */
dflet 0:50cedd586816 1373 if (g_pCB->ObjPool[Idx].NextIndex == ItemIndex)
dflet 0:50cedd586816 1374 {
dflet 0:50cedd586816 1375 g_pCB->ObjPool[Idx].NextIndex = g_pCB->ObjPool[ItemIndex].NextIndex;
dflet 0:50cedd586816 1376 break;
dflet 0:50cedd586816 1377 }
dflet 0:50cedd586816 1378
dflet 0:50cedd586816 1379 Idx = g_pCB->ObjPool[Idx].NextIndex;
dflet 0:50cedd586816 1380 }
dflet 0:50cedd586816 1381 }
dflet 0:50cedd586816 1382 #endif
dflet 0:50cedd586816 1383 }
dflet 0:50cedd586816 1384
dflet 0:50cedd586816 1385 /* ******************************************************************************/
dflet 0:50cedd586816 1386 /* _SlFindAndSetActiveObj */
dflet 0:50cedd586816 1387 /* ******************************************************************************/
dflet 0:50cedd586816 1388 _SlReturnVal_t cc3100_driver::_SlFindAndSetActiveObj(_SlOpcode_t Opcode, uint8_t Sd)
dflet 0:50cedd586816 1389 {
dflet 0:50cedd586816 1390 uint8_t ActiveIndex;
dflet 0:50cedd586816 1391
dflet 0:50cedd586816 1392 ActiveIndex = g_pCB->ActivePoolIdx;
dflet 0:50cedd586816 1393 /* go over the active list if exist to find obj waiting for this Async event */
dflet 0:50cedd586816 1394 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1395 while (MAX_CONCURRENT_ACTIONS > ActiveIndex){
dflet 0:50cedd586816 1396 #else
dflet 0:50cedd586816 1397 /* Only one Active action is availabe in tiny mode, so we can replace the loop with if condition */
dflet 0:50cedd586816 1398 if (MAX_CONCURRENT_ACTIONS > ActiveIndex)
dflet 0:50cedd586816 1399 #endif
dflet 0:50cedd586816 1400 /* unset the Ipv4\IPv6 bit in the opcode if family bit was set */
dflet 0:50cedd586816 1401 if (g_pCB->ObjPool[ActiveIndex].AdditionalData & SL_NETAPP_FAMILY_MASK) {
dflet 0:50cedd586816 1402 Opcode &= ~SL_OPCODE_IPV6;
dflet 0:50cedd586816 1403 }
dflet 0:50cedd586816 1404
dflet 0:50cedd586816 1405 if ((g_pCB->ObjPool[ActiveIndex].ActionID == RECV_ID) && (Sd == g_pCB->ObjPool[ActiveIndex].AdditionalData) &&
dflet 0:50cedd586816 1406 ( (SL_OPCODE_SOCKET_RECVASYNCRESPONSE == Opcode) || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE == Opcode)
dflet 0:50cedd586816 1407 #ifndef SL_TINY_EXT
dflet 0:50cedd586816 1408 || (SL_OPCODE_SOCKET_RECVFROMASYNCRESPONSE_V6 == Opcode)
dflet 0:50cedd586816 1409 #endif
dflet 0:50cedd586816 1410 )
dflet 0:50cedd586816 1411
dflet 0:50cedd586816 1412 )
dflet 0:50cedd586816 1413 {
dflet 0:50cedd586816 1414 g_pCB->FunctionParams.AsyncExt.ActionIndex = ActiveIndex;
dflet 0:50cedd586816 1415 return SL_RET_CODE_OK;
dflet 0:50cedd586816 1416 }
dflet 0:50cedd586816 1417 /* In case this action is socket related, SocketID is in use, otherwise will be set to SL_MAX_SOCKETS */
dflet 0:50cedd586816 1418 if ( (_SlActionLookupTable[ g_pCB->ObjPool[ActiveIndex].ActionID - MAX_SOCKET_ENUM_IDX].ActionAsyncOpcode == Opcode) &&
dflet 0:50cedd586816 1419 ( ((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)) ) ) {
dflet 0:50cedd586816 1420 /* set handler */
dflet 0:50cedd586816 1421 g_pCB->FunctionParams.AsyncExt.AsyncEvtHandler = _SlActionLookupTable[ g_pCB->ObjPool[ActiveIndex].ActionID - MAX_SOCKET_ENUM_IDX].AsyncEventHandler;
dflet 0:50cedd586816 1422 g_pCB->FunctionParams.AsyncExt.ActionIndex = ActiveIndex;
dflet 0:50cedd586816 1423 return SL_RET_CODE_OK;
dflet 0:50cedd586816 1424 }
dflet 0:50cedd586816 1425 ActiveIndex = g_pCB->ObjPool[ActiveIndex].NextIndex;
dflet 0:50cedd586816 1426 }
dflet 0:50cedd586816 1427
dflet 0:50cedd586816 1428 return SL_RET_CODE_SELF_ERROR;
dflet 0:50cedd586816 1429
dflet 0:50cedd586816 1430 }
dflet 0:50cedd586816 1431
dflet 0:50cedd586816 1432 /* Wrappers for the object functions */
dflet 0:50cedd586816 1433
dflet 0:50cedd586816 1434 void cc3100_driver::_SlDrvSyncObjWaitForever(_SlSyncObj_t *pSyncObj)
dflet 0:50cedd586816 1435 {
dflet 0:50cedd586816 1436 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1437 OSI_RET_OK_CHECK(_nonos.sl_SyncObjWait(pSyncObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1438 #else
dflet 0:50cedd586816 1439 OSI_RET_OK_CHECK(sl_SyncObjWait(pSyncObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1440 #endif
dflet 0:50cedd586816 1441 }
dflet 0:50cedd586816 1442
dflet 0:50cedd586816 1443 void cc3100_driver::_SlDrvSyncObjSignal(_SlSyncObj_t *pSyncObj)
dflet 0:50cedd586816 1444 {
dflet 0:50cedd586816 1445 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1446 OSI_RET_OK_CHECK(_nonos.sl_SyncObjSignal(pSyncObj));
dflet 0:50cedd586816 1447 #else
dflet 0:50cedd586816 1448 OSI_RET_OK_CHECK(sl_SyncObjSignal(pSyncObj));
dflet 0:50cedd586816 1449 #endif
dflet 0:50cedd586816 1450 }
dflet 0:50cedd586816 1451
dflet 0:50cedd586816 1452 void cc3100_driver::_SlDrvObjLockWaitForever(_SlLockObj_t *pLockObj)
dflet 0:50cedd586816 1453 {
dflet 0:50cedd586816 1454 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1455 OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(pLockObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1456 #else
dflet 0:50cedd586816 1457 OSI_RET_OK_CHECK(sl_LockObjLock(pLockObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1458 #endif
dflet 0:50cedd586816 1459 }
dflet 0:50cedd586816 1460
dflet 0:50cedd586816 1461 void cc3100_driver::_SlDrvProtectionObjLockWaitForever()
dflet 0:50cedd586816 1462 {
dflet 0:50cedd586816 1463 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1464 OSI_RET_OK_CHECK(_nonos.sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1465 #else
dflet 0:50cedd586816 1466 OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
dflet 0:50cedd586816 1467 #endif
dflet 0:50cedd586816 1468 }
dflet 0:50cedd586816 1469
dflet 0:50cedd586816 1470 void cc3100_driver::_SlDrvObjUnLock(_SlLockObj_t *pLockObj)
dflet 0:50cedd586816 1471 {
dflet 0:50cedd586816 1472 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1473 OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(pLockObj));
dflet 0:50cedd586816 1474 #else
dflet 0:50cedd586816 1475 OSI_RET_OK_CHECK(sl_LockObjUnlock(pLockObj));
dflet 0:50cedd586816 1476 #endif
dflet 0:50cedd586816 1477 }
dflet 0:50cedd586816 1478
dflet 0:50cedd586816 1479 void cc3100_driver::_SlDrvProtectionObjUnLock()
dflet 0:50cedd586816 1480 {
dflet 0:50cedd586816 1481 #ifndef SL_PLATFORM_MULTI_THREADED
dflet 0:50cedd586816 1482 OSI_RET_OK_CHECK(_nonos.sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
dflet 0:50cedd586816 1483 #else
dflet 0:50cedd586816 1484 OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
dflet 0:50cedd586816 1485 #endif
dflet 0:50cedd586816 1486 }
dflet 0:50cedd586816 1487
dflet 0:50cedd586816 1488
dflet 0:50cedd586816 1489 void cc3100_driver::_SlDrvMemZero(void* Addr, uint16_t size)
dflet 0:50cedd586816 1490 {
dflet 0:50cedd586816 1491 memset(Addr, 0, size);
dflet 0:50cedd586816 1492 }
dflet 0:50cedd586816 1493
dflet 0:50cedd586816 1494
dflet 0:50cedd586816 1495 void cc3100_driver::_SlDrvResetCmdExt(_SlCmdExt_t* pCmdExt)
dflet 0:50cedd586816 1496 {
dflet 0:50cedd586816 1497 _SlDrvMemZero(pCmdExt, sizeof (_SlCmdExt_t));
dflet 0:50cedd586816 1498 }
dflet 0:50cedd586816 1499
dflet 0:50cedd586816 1500 }//namespace mbed_cc3100
dflet 0:50cedd586816 1501
dflet 0:50cedd586816 1502