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 _i16 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);
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 _i16 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);
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)
372 if (!SL_IS_RESTART_REQUIRED)
374 SL_DRV_OBJ_LOCK_FOREVER(&GlobalLockObj);
376 sl_IfRegIntHdlr(NULL, NULL);
378 RetVal = sl_IfClose(g_pCB->FD);
380 (void)_SlDrvDriverCBDeinit();
383 SL_UNSET_DEVICE_STOP_IN_PROGRESS;
386 SL_UNSET_DEVICE_STARTED;
388 if (!SL_IS_RESTART_REQUIRED)
390 SL_DRV_OBJ_UNLOCK(&GlobalLockObj);
393 SL_UNSET_RESTART_REQUIRED;
407 }_SlEventMaskSetMsg_u;
410 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskSet) 414 SL_OPCODE_DEVICE_EVENTMASKSET,
422 _SlEventMaskSetMsg_u Msg;
426 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
428 Msg.Cmd.Group = EventClass;
431 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskSetCmdCtrl, &Msg, NULL));
433 return (_i16)Msg.Rsp.status;
444 }_SlEventMaskGetMsg_u;
448 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskGet) 452 SL_OPCODE_DEVICE_EVENTMASKGET,
460 _SlEventMaskGetMsg_u Msg;
464 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
466 Msg.Cmd.Group = EventClass;
468 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskGetCmdCtrl, &Msg, NULL));
470 *pMask = Msg.Rsp.Mask;
472 return SL_RET_CODE_OK;
490 #if _SL_INCLUDE_FUNC(sl_DeviceGet) 494 SL_OPCODE_DEVICE_DEVICEGET,
499 _i16
sl_DeviceGet(
const _u8 DeviceGetId, _u8 *pOption,_u16 *pConfigLen, _u8 *pValues)
501 _SlDeviceMsgGet_u Msg;
506 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
508 if (*pConfigLen == 0)
516 _SlDrvResetCmdExt(&CmdExt);
517 CmdExt.RxPayloadLen = (_i16)*pConfigLen;
518 CmdExt.pRxPayload = (_u8 *)pValues;
520 Msg.Cmd.DeviceSetId = DeviceGetId;
522 Msg.Cmd.Option = (_u16)*pOption;
524 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceGetCmdCtrl, &Msg, &CmdExt));
528 *pOption = (_u8)Msg.Rsp.Option;
531 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
533 *pConfigLen = (_u16)CmdExt.RxPayloadLen;
539 *pConfigLen = (_u16)CmdExt.ActualRxPayloadLen;
542 return (_i16)Msg.Rsp.Status;
546 return SL_RET_CODE_INVALID_INPUT;
562 #if _SL_INCLUDE_FUNC(sl_DeviceSet) 566 SL_OPCODE_DEVICE_DEVICESET,
571 _i16
sl_DeviceSet(
const _u8 DeviceSetId ,
const _u8 Option,
const _u16 ConfigLen,
const _u8 *pValues)
573 _SlDeviceMsgSet_u Msg;
578 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
580 _SlDrvResetCmdExt(&CmdExt);
582 CmdExt.TxPayload1Len = (ConfigLen+3) & (~3);
583 CmdExt.pTxPayload1 = (_u8 *)pValues;
585 Msg.Cmd.DeviceSetId = DeviceSetId;
586 Msg.Cmd.ConfigLen = ConfigLen;
587 Msg.Cmd.Option = Option;
589 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceSetCmdCtrl, &Msg, &CmdExt));
591 return (_i16)Msg.Rsp.status;
599 _SlReturnVal_t _SlDeviceEventHandler(
void* pEventInfo)
606 _SlDrvMemZero(&DeviceEvent,
sizeof(DeviceEvent));
608 switch(pHdr->GenHeader.Opcode)
610 case SL_OPCODE_DEVICE_INITCOMPLETE:
611 _SlDeviceHandleAsync_InitComplete(pHdr);
613 case SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE:
614 _SlDeviceHandleAsync_Stop(pHdr);
616 case SL_OPCODE_DEVICE_RESET_REQUEST_ASYNC_EVENT:
620 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 621 if (pResetRequestData->Caller == SL_DEVICE_RESET_REQUEST_CALLER_PROVISIONING_EXTERNAL_CONFIGURATION)
624 DeviceEvent.Id = SL_DEVICE_EVENT_RESET_REQUEST;
625 DeviceEvent.Data.ResetRequest.Status = 0;
626 DeviceEvent.Data.ResetRequest.Caller = pResetRequestData->Caller;
627 _SlDrvHandleGeneralEvents(&DeviceEvent);
632 if (!_SlDrvIsApiInProgress() && SL_IS_PROVISIONING_IN_PROGRESS)
634 if (pResetRequestData->SessionNumber != DeviceCB.ResetRequestSessionNumber)
637 DeviceCB.ResetRequestSessionNumber = pResetRequestData->SessionNumber;
640 _SlDeviceHandleResetRequestInternally();
646 case SL_OPCODE_DEVICE_ABORT:
649 if (pInfo->bInCmdContext == TRUE)
651 SL_DRV_LOCK_GLOBAL_UNLOCK(TRUE);
654 _SlDrvHandleFatalError(SL_DEVICE_EVENT_FATAL_DEVICE_ABORT,
655 *((_u32*)pMsgArgs - 1),
660 case SL_OPCODE_DEVICE_DEVICE_ASYNC_GENERAL_ERROR:
662 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 664 DeviceEvent.Id = SL_DEVICE_EVENT_ERROR;
665 DeviceEvent.Data.Error.Code = pMsgArgs->status;
666 DeviceEvent.Data.Error.Source = (SlDeviceSource_e)pMsgArgs->sender;
667 _SlDrvHandleGeneralEvents(&DeviceEvent);
672 case SL_OPCODE_DEVICE_FLOW_CTRL_ASYNC_EVENT:
673 _SlFlowContSet((
void *)pHdr);
676 SL_ERROR_TRACE2(MSG_306,
"ASSERT: _SlDeviceEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
679 return SL_OS_RET_CODE_OK;
683 void _SlDeviceResetRequestInitCompletedCB(_u32 Status,
SlDeviceInitInfo_t *DeviceInitInfo)
689 void _SlDeviceHandleResetRequestInternally(
void)
691 _u8 irqCountLast = RxIrqCnt;
692 #if (defined(slcb_GetTimestamp)) 695 _SlDrvStartMeasureTimeout(&TimeoutInfo, 2*RESET_REQUEST_STOP_TIMEOUT);
700 sl_Stop(RESET_REQUEST_STOP_TIMEOUT);
706 #if (defined(slcb_GetTimestamp)) 707 if (_SlDrvIsTimeoutExpired(&TimeoutInfo))
713 while((RxIrqCnt - irqCountLast) < 2);
716 sl_Start(DeviceCB.pIfHdl, DeviceCB.pDevName ,_SlDeviceResetRequestInitCompletedCB);
728 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
729 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
731 SL_DRV_PROTECTION_OBJ_UNLOCK();
732 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
739 SL_SET_DEVICE_STAT_IN_PROGRESS;
740 SL_DRV_PROTECTION_OBJ_UNLOCK();
743 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
744 return _SlDrvBasicCmd(SL_OPCODE_WLAN_STARTRXSTATCOMMAND);
752 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
754 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
756 SL_DRV_PROTECTION_OBJ_UNLOCK();
757 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
761 SL_DRV_PROTECTION_OBJ_UNLOCK();
762 if(SL_DEVICE_STAT_WLAN_RX == ConfigId )
770 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
773 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, buffer, NULL));
778 _u8 configOpt = ConfigId;
779 RetVal =
sl_DeviceGet(SL_DEVICE_GENERAL,&configOpt,&length,(_u8* )buffer);
788 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
789 if(SL_IS_WLAN_RX_STAT_IN_PROGRESS)
791 SL_DRV_PROTECTION_OBJ_UNLOCK();
792 return SL_RET_CODE_WLAN_RX_STAT_IN_PROGRESS;
796 SL_UNSET_DEVICE_STAT_IN_PROGRESS;
797 SL_DRV_PROTECTION_OBJ_UNLOCK();
800 VERIFY_API_ALLOWED(SL_OPCODE_SILO_WLAN);
802 return _SlDrvBasicCmd(SL_OPCODE_WLAN_STOPRXSTATCOMMAND);
810 #ifdef SL_IF_TYPE_UART 815 }_SlUartSetModeMsg_u;
818 #if _SL_INCLUDE_FUNC(sl_DeviceUartSetMode) 823 SL_OPCODE_DEVICE_SETUARTMODECOMMAND,
830 _SlUartSetModeMsg_u Msg;
831 _u32 magicCode = (_u32)0xFFFFFFFF;
833 Msg.Cmd.BaudRate = pUartParams->BaudRate;
834 Msg.Cmd.FlowControlEnable = pUartParams->FlowControlEnable;
837 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlUartSetModeCmdCtrl, &Msg, NULL));
840 if (SL_RET_CODE_OK == Msg.Rsp.status)
845 sl_IfClose(g_pCB->FD);
848 sl_IfOpen((
void * )pUartParams, SL_IF_UART_REOPEN_FLAGS);
850 sl_IfUnMaskIntHdlr();
853 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
855 magicCode = UART_SET_MODE_MAGIC_CODE;
856 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
862 sl_IfRead(g_pCB->FD, (_u8* )&magicCode, 4);
865 if (UART_SET_MODE_MAGIC_CODE != magicCode)
871 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.