David Fletcher / Mbed 2 deprecated cc3100_Test_websock_Camera_CM4F

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.

Dependencies:   mbed

simplelink/cc3100_driver.cpp@19:3dd3e7f30f8b, 2015-09-10 (annotated)

Committer:
dflet
Date:
Thu Sep 10 17:56:09 2015 +0000
Revision:
19:3dd3e7f30f8b
Parent:
18:3f1b52616d00 
Solved part of the problem with spi, looks like there is maybe a fault with the Seeed Arch Max, fault or by design i don't know, program seems to work fine on an STMF32407I (Waveshare) baord.

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