David Fletcher / Mbed 2 deprecated cc3100_test

TI's CC3100 host driver and demo. Experimental and a work in progress.

Dependencies:   mbed

simplelink/cc3100_driver.cpp@2:a3e52cf86086, 2014-11-19 (annotated)

Committer:
dflet
Date:
Wed Nov 19 23:04:04 2014 +0000
Revision:
2:a3e52cf86086
Parent:
0:bbe98578d4c0 
Added more boards!

Who changed what in which revision?

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