40 #include <ti/drivers/net/wifi/simplelink.h> 41 #include <ti/drivers/net/wifi/source/protocol.h> 42 #include <ti/drivers/net/wifi/source/driver.h> 43 #include <ti/drivers/net/wifi/source/flowcont.h> 49 static _i16 _SlDeviceGetStartResponseConvert(_i32 Status);
50 void _SlDeviceHandleResetRequestInternally(
void);
51 void _SlDeviceResetRequestInitCompletedCB(_u32 Status,
SlDeviceInitInfo_t *DeviceInitInfo);
53 #define RESET_REQUEST_STOP_TIMEOUT (300) 55 #ifndef SL_IF_OPEN_FLAGS 56 #define SL_IF_OPEN_FLAGS (0x0) 59 #ifndef SL_IF_UART_REOPEN_FLAGS 60 #define SL_IF_UART_REOPEN_FLAGS (0x1) 67 _u32 ResetRequestSessionNumber;
70 _SlDeviceCb_t DeviceCB;
72 static const _i16 StartResponseLUT[16] =
76 SL_ERROR_ROLE_STA_ERR,
80 SL_ERROR_ROLE_P2P_ERR,
82 SL_ERROR_FS_CORRUPTED_ERR,
83 SL_ERROR_FS_ALERT_ERR,
84 SL_ERROR_RESTORE_IMAGE_COMPLETE,
85 SL_ERROR_INCOMPLETE_PROGRAMMING,
87 SL_ERROR_ROLE_TAG_ERR,
92 static _i16 _SlDeviceGetStartResponseConvert(_i32 Status)
94 return StartResponseLUT[Status & 0xF];
104 #if _SL_INCLUDE_FUNC(sl_Task) 108 return (
void*)_SlTaskEntry();
118 #if _SL_INCLUDE_FUNC(sl_Start) 119 _i16
sl_Start(
const void* pIfHdl, _i8* pDevName,
const P_INIT_CALLBACK pInitCallBack)
121 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
129 VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
130 if (SL_IS_DEVICE_STARTED)
132 return SL_RET_CODE_DEV_ALREADY_STARTED;
135 #ifdef sl_DeviceEnablePreamble 136 sl_DeviceEnablePreamble();
140 (void)_SlDrvDriverCBInit();
145 g_pCB->FD = sl_IfOpen((
void *)pDevName, SL_IF_OPEN_FLAGS);
149 g_pCB->FD = (_SlFd_t)pIfHdl;
152 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8 *)&AsyncRsp, START_STOP_ID, SL_MAX_SOCKETS);
154 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
156 return SL_POOL_IS_EMPTY;
159 if( g_pCB->FD >= (_SlFd_t)0)
163 DeviceCB.pIfHdl = pIfHdl;
164 DeviceCB.pDevName = pDevName;
167 SL_SET_DEVICE_START_IN_PROGRESS;
171 sl_IfRegIntHdlr((SL_P_EVENT_HANDLER)_SlDrvRxIrqHandler, NULL);
173 g_pCB->pInitCallback = pInitCallBack;
176 if (NULL == pInitCallBack)
178 ret = _SlDrvWaitForInternalAsyncEvent(ObjIdx, INIT_COMPLETE_TIMEOUT, SL_OPCODE_DEVICE_INITCOMPLETE);
180 SL_UNSET_DEVICE_START_IN_PROGRESS;
182 SL_SET_DEVICE_STARTED;
185 _SlDrvReleasePoolObj(g_pCB->FunctionParams.AsyncExt.ActionIndex);
192 return _SlDeviceGetStartResponseConvert(AsyncRsp.Status);
197 return SL_RET_CODE_OK;
200 return SL_BAD_INTERFACE;
208 _SlReturnVal_t _SlDeviceHandleAsync_InitComplete(
void *pVoidBuf)
213 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
215 if(g_pCB->pInitCallback)
217 DeviceInitInfo.ChipId = pMsgArgs->ChipId;
218 DeviceInitInfo.MoreData = pMsgArgs->MoreData;
219 g_pCB->pInitCallback(_SlDeviceGetStartResponseConvert(pMsgArgs->Status), &DeviceInitInfo);
223 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
InitComplete_t));
224 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
227 SL_DRV_PROTECTION_OBJ_UNLOCK();
228 if(g_pCB->pInitCallback)
230 SL_SET_DEVICE_STARTED;
231 SL_UNSET_DEVICE_START_IN_PROGRESS;
232 _SlDrvReleasePoolObj(g_pCB->FunctionParams.AsyncExt.ActionIndex);
235 return SL_OS_RET_CODE_OK;
243 void _SlDeviceHandleAsync_Stop(
void *pVoidBuf)
247 VERIFY_SOCKET_CB(NULL != g_pCB->StopCB.pAsyncRsp);
249 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
251 if (g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs != NULL)
253 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
_BasicResponse_t));
254 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
257 SL_DRV_PROTECTION_OBJ_UNLOCK();
274 SL_OPCODE_DEVICE_STOP_COMMAND,
279 #if _SL_INCLUDE_FUNC(sl_Stop) 285 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
286 _u8 ReleasePoolObject = FALSE;
287 _u8 IsProvInProgress = FALSE;
294 if( (Timeout != 0) && (SL_IS_DEVICE_STARTED)
295 && (!SL_IS_RESTART_REQUIRED))
301 Msg.Cmd.Timeout = Timeout;
303 IsProvInProgress = SL_IS_PROVISIONING_IN_PROGRESS;
306 if (!IsProvInProgress)
308 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8 *)&AsyncRsp, START_STOP_ID, SL_MAX_SOCKETS);
309 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
311 return SL_POOL_IS_EMPTY;
314 ReleasePoolObject = TRUE;
318 SL_SET_DEVICE_STOP_IN_PROGRESS;
320 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlStopCmdCtrl, &Msg, NULL));
324 if((SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status) && (!(IsProvInProgress)))
327 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, STOP_DEVICE_TIMEOUT, SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE);
329 Msg.Rsp.status = AsyncRsp.status;
330 RetVal = Msg.Rsp.status;
334 if (ReleasePoolObject == TRUE)
336 _SlDrvReleasePoolObj(ObjIdx);
346 WAIT_NWP_SHUTDOWN_READY;
350 if ((!SL_IS_DEVICE_STARTED)
351 && (!SL_IS_RESTART_REQUIRED))
354 return SL_RET_CODE_DEV_NOT_STARTED;
357 SL_SET_DEVICE_STOP_IN_PROGRESS;
360 _SlDrvReleaseAllActivePendingPoolObj();
362 #ifdef SL_PLATFORM_MULTI_THREADED 364 while (g_pCB->NumOfDeletedSyncObj < MAX_CONCURRENT_ACTIONS)
371 SL_DRV_OBJ_LOCK_FOREVER(&GlobalLockObj);
373 sl_IfRegIntHdlr(NULL, NULL);
375 RetVal = sl_IfClose(g_pCB->FD);
377 (void)_SlDrvDriverCBDeinit();
380 SL_UNSET_DEVICE_STOP_IN_PROGRESS;
383 SL_UNSET_DEVICE_STARTED;
385 SL_DRV_OBJ_UNLOCK(&GlobalLockObj);
399 }_SlEventMaskSetMsg_u;
402 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskSet) 406 SL_OPCODE_DEVICE_EVENTMASKSET,
414 _SlEventMaskSetMsg_u Msg;
418 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
420 Msg.Cmd.Group = EventClass;
423 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskSetCmdCtrl, &Msg, NULL));
425 return (_i16)Msg.Rsp.status;
436 }_SlEventMaskGetMsg_u;
440 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskGet) 444 SL_OPCODE_DEVICE_EVENTMASKGET,
452 _SlEventMaskGetMsg_u Msg;
456 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
458 Msg.Cmd.Group = EventClass;
460 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskGetCmdCtrl, &Msg, NULL));
462 *pMask = Msg.Rsp.Mask;
464 return SL_RET_CODE_OK;
482 #if _SL_INCLUDE_FUNC(sl_DeviceGet) 486 SL_OPCODE_DEVICE_DEVICEGET,
491 _i16
sl_DeviceGet(
const _u8 DeviceGetId, _u8 *pOption,_u16 *pConfigLen, _u8 *pValues)
493 _SlDeviceMsgGet_u Msg;
498 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
500 if (*pConfigLen == 0)
508 _SlDrvResetCmdExt(&CmdExt);
509 CmdExt.RxPayloadLen = (_i16)*pConfigLen;
510 CmdExt.pRxPayload = (_u8 *)pValues;
512 Msg.Cmd.DeviceSetId = DeviceGetId;
514 Msg.Cmd.Option = (_u16)*pOption;
516 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceGetCmdCtrl, &Msg, &CmdExt));
520 *pOption = (_u8)Msg.Rsp.Option;
523 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
525 *pConfigLen = (_u16)CmdExt.RxPayloadLen;
531 *pConfigLen = (_u16)CmdExt.ActualRxPayloadLen;
534 return (_i16)Msg.Rsp.Status;
538 return SL_RET_CODE_INVALID_INPUT;
554 #if _SL_INCLUDE_FUNC(sl_DeviceSet) 558 SL_OPCODE_DEVICE_DEVICESET,
563 _i16
sl_DeviceSet(
const _u8 DeviceSetId ,
const _u8 Option,
const _u16 ConfigLen,
const _u8 *pValues)
565 _SlDeviceMsgSet_u Msg;
570 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
572 _SlDrvResetCmdExt(&CmdExt);
574 CmdExt.TxPayload1Len = (ConfigLen+3) & (~3);
575 CmdExt.pTxPayload1 = (_u8 *)pValues;
577 Msg.Cmd.DeviceSetId = DeviceSetId;
578 Msg.Cmd.ConfigLen = ConfigLen;
579 Msg.Cmd.Option = Option;
581 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceSetCmdCtrl, &Msg, &CmdExt));
583 return (_i16)Msg.Rsp.status;
591 _SlReturnVal_t _SlDeviceEventHandler(
void* pEventInfo)
598 _SlDrvMemZero(&DeviceEvent,
sizeof(DeviceEvent));
600 switch(pHdr->GenHeader.Opcode)
602 case SL_OPCODE_DEVICE_INITCOMPLETE:
603 _SlDeviceHandleAsync_InitComplete(pHdr);
605 case SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE:
606 _SlDeviceHandleAsync_Stop(pHdr);
608 case SL_OPCODE_DEVICE_RESET_REQUEST_ASYNC_EVENT:
612 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 613 if (pResetRequestData->Caller == SL_DEVICE_RESET_REQUEST_CALLER_PROVISIONING_EXTERNAL_CONFIGURATION)
616 DeviceEvent.Id = SL_DEVICE_EVENT_RESET_REQUEST;
617 DeviceEvent.Data.ResetRequest.Status = 0;
618 DeviceEvent.Data.ResetRequest.Caller = pResetRequestData->Caller;
619 _SlDrvHandleGeneralEvents(&DeviceEvent);
624 if (!_SlDrvIsApiInProgress() && SL_IS_PROVISIONING_IN_PROGRESS)
626 if (pResetRequestData->SessionNumber != DeviceCB.ResetRequestSessionNumber)
629 DeviceCB.ResetRequestSessionNumber = pResetRequestData->SessionNumber;
632 _SlDeviceHandleResetRequestInternally();
638 case SL_OPCODE_DEVICE_ABORT:
641 if (pInfo->bInCmdContext == TRUE)
643 SL_DRV_LOCK_GLOBAL_UNLOCK(TRUE);
646 _SlDrvHandleFatalError(SL_DEVICE_EVENT_FATAL_DEVICE_ABORT,
647 *((_u32*)pMsgArgs - 1),
652 case SL_OPCODE_DEVICE_DEVICE_ASYNC_GENERAL_ERROR:
654 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 656 DeviceEvent.Id = SL_DEVICE_EVENT_ERROR;
657 DeviceEvent.Data.Error.Code = pMsgArgs->status;
658 DeviceEvent.Data.Error.Source = (SlDeviceSource_e)pMsgArgs->sender;
659 _SlDrvHandleGeneralEvents(&DeviceEvent);
664 case SL_OPCODE_DEVICE_FLOW_CTRL_ASYNC_EVENT:
665 _SlFlowContSet((
void *)pHdr);
668 SL_ERROR_TRACE2(MSG_306,
"ASSERT: _SlDeviceEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
671 return SL_OS_RET_CODE_OK;
675 void _SlDeviceResetRequestInitCompletedCB(_u32 Status,
SlDeviceInitInfo_t *DeviceInitInfo)
681 void _SlDeviceHandleResetRequestInternally(
void)
683 _u8 irqCountLast = RxIrqCnt;
684 #if (defined(slcb_GetTimestamp)) 687 _SlDrvStartMeasureTimeout(&TimeoutInfo, 2*RESET_REQUEST_STOP_TIMEOUT);
692 sl_Stop(RESET_REQUEST_STOP_TIMEOUT);
698 #if (defined(slcb_GetTimestamp)) 699 if (_SlDrvIsTimeoutExpired(&TimeoutInfo))
705 while((RxIrqCnt - irqCountLast) < 2);
708 sl_Start(DeviceCB.pIfHdl, DeviceCB.pDevName ,_SlDeviceResetRequestInitCompletedCB);
720 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
721 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
723 SL_DRV_PROTECTION_OBJ_UNLOCK();
724 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
731 SL_SET_DEVICE_STAT_IN_PROGRESS;
732 SL_DRV_PROTECTION_OBJ_UNLOCK();
735 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
736 return _SlDrvBasicCmd(SL_OPCODE_WLAN_STARTRXSTATCOMMAND);
744 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
746 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
748 SL_DRV_PROTECTION_OBJ_UNLOCK();
749 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
753 SL_DRV_PROTECTION_OBJ_UNLOCK();
754 if(SL_DEVICE_STAT_WLAN_RX == ConfigId )
762 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
765 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, buffer, NULL));
770 _u8 configOpt = ConfigId;
771 RetVal =
sl_DeviceGet(SL_DEVICE_GENERAL,&configOpt,&length,(_u8* )buffer);
780 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
781 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
783 SL_DRV_PROTECTION_OBJ_UNLOCK();
784 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
788 SL_UNSET_DEVICE_STAT_IN_PROGRESS;
789 SL_DRV_PROTECTION_OBJ_UNLOCK();
792 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
794 return _SlDrvBasicCmd(SL_OPCODE_WLAN_STOPRXSTATCOMMAND);
802 #ifdef SL_IF_TYPE_UART 807 }_SlUartSetModeMsg_u;
810 #if _SL_INCLUDE_FUNC(sl_DeviceUartSetMode) 815 SL_OPCODE_DEVICE_SETUARTMODECOMMAND,
822 _SlUartSetModeMsg_u Msg;
823 _u32 magicCode = (_u32)0xFFFFFFFF;
825 Msg.Cmd.BaudRate = pUartParams->BaudRate;
826 Msg.Cmd.FlowControlEnable = pUartParams->FlowControlEnable;
829 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlUartSetModeCmdCtrl, &Msg, NULL));
832 if (SL_RET_CODE_OK == Msg.Rsp.status)
837 sl_IfClose(g_pCB->FD);
840 sl_IfOpen((
void * )pUartParams, SL_IF_UART_REOPEN_FLAGS);
842 sl_IfUnMaskIntHdlr();
845 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
847 magicCode = UART_SET_MODE_MAGIC_CODE;
848 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
854 sl_IfRead(g_pCB->FD, (_u8* )&magicCode, 4);
857 if (UART_SET_MODE_MAGIC_CODE != magicCode)
863 return (_i16)Msg.Rsp.status;
_i16 sl_DeviceStatStop(const _u32 Flags)
Stop collecting Device statistic, (if previous called sl_DeviceStatStart)
_i16 sl_DeviceEventMaskSet(const _u8 EventClass, const _u32 Mask)
Set asynchronous event mask.
_i16 sl_DeviceGet(const _u8 DeviceGetId, _u8 *pOption, _u16 *pConfigLen, _u8 *pValues)
Internal function for getting device configurations.
void * sl_Task(void *pEntry)
The SimpleLink task entry.
_i16 sl_DeviceSet(const _u8 DeviceSetId, const _u8 Option, const _u16 ConfigLen, const _u8 *pValues)
Setting device configurations.
_i16 sl_Stop(const _u16 Timeout)
Stop the SimpleLink device.
_i16 sl_DeviceEventMaskGet(const _u8 EventClass, _u32 *pMask)
Get current event mask of the device.
_i16 sl_DeviceStatStart(const _u32 Flags)
Start collecting Device statistics (including RX statistics), for unlimited time. ...
_i16 sl_DeviceUartSetMode(const SlDeviceUartIfParams_t *pUartParams)
Setting the internal uart mode.
_i16 sl_Start(const void *pIfHdl, _i8 *pDevName, const P_INIT_CALLBACK pInitCallBack)
Start the SimpleLink device.
_i16 sl_DeviceStatGet(const _u16 ConfigId, _u16 length, void *buffer)
Getting DEVICE statistics.