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;
128 VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
129 if (SL_IS_DEVICE_STARTED)
131 return SL_RET_CODE_DEV_ALREADY_STARTED;
134 #ifdef sl_DeviceEnablePreamble 135 sl_DeviceEnablePreamble();
139 (void)_SlDrvDriverCBInit();
144 g_pCB->FD = sl_IfOpen((
void *)pDevName, SL_IF_OPEN_FLAGS);
148 g_pCB->FD = (_SlFd_t)pIfHdl;
151 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8 *)&AsyncRsp, START_STOP_ID, SL_MAX_SOCKETS);
153 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
155 return SL_POOL_IS_EMPTY;
158 if( g_pCB->FD >= (_SlFd_t)0)
162 DeviceCB.pIfHdl = pIfHdl;
163 DeviceCB.pDevName = pDevName;
166 SL_SET_DEVICE_START_IN_PROGRESS;
170 sl_IfRegIntHdlr((SL_P_EVENT_HANDLER)_SlDrvRxIrqHandler, NULL);
172 g_pCB->pInitCallback = pInitCallBack;
175 if (NULL == pInitCallBack)
178 VERIFY_RET_OK(_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);
186 return _SlDeviceGetStartResponseConvert(AsyncRsp.Status);
190 return SL_RET_CODE_OK;
193 return SL_BAD_INTERFACE;
201 _SlReturnVal_t _SlDeviceHandleAsync_InitComplete(
void *pVoidBuf)
206 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
208 if(g_pCB->pInitCallback)
210 DeviceInitInfo.ChipId = pMsgArgs->ChipId;
211 DeviceInitInfo.MoreData = pMsgArgs->MoreData;
212 g_pCB->pInitCallback(_SlDeviceGetStartResponseConvert(pMsgArgs->Status), &DeviceInitInfo);
216 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
InitComplete_t));
217 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
220 SL_DRV_PROTECTION_OBJ_UNLOCK();
221 if(g_pCB->pInitCallback)
223 SL_SET_DEVICE_STARTED;
224 SL_UNSET_DEVICE_START_IN_PROGRESS;
225 _SlDrvReleasePoolObj(g_pCB->FunctionParams.AsyncExt.ActionIndex);
228 return SL_OS_RET_CODE_OK;
236 void _SlDeviceHandleAsync_Stop(
void *pVoidBuf)
240 VERIFY_SOCKET_CB(NULL != g_pCB->StopCB.pAsyncRsp);
242 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
244 if (g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs != NULL)
246 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
_BasicResponse_t));
247 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
250 SL_DRV_PROTECTION_OBJ_UNLOCK();
267 SL_OPCODE_DEVICE_STOP_COMMAND,
272 #if _SL_INCLUDE_FUNC(sl_Stop) 278 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
279 _u8 ReleasePoolObject = FALSE;
280 _u8 IsProvInProgress = FALSE;
287 if( (Timeout != 0) && (SL_IS_DEVICE_STARTED)
288 && (!SL_IS_RESTART_REQUIRED))
294 Msg.Cmd.Timeout = Timeout;
296 IsProvInProgress = SL_IS_PROVISIONING_IN_PROGRESS;
299 if (!IsProvInProgress)
301 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8 *)&AsyncRsp, START_STOP_ID, SL_MAX_SOCKETS);
302 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
304 return SL_POOL_IS_EMPTY;
307 ReleasePoolObject = TRUE;
311 SL_SET_DEVICE_STOP_IN_PROGRESS;
313 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlStopCmdCtrl, &Msg, NULL));
316 if((SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status) && (!(IsProvInProgress)))
319 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, STOP_DEVICE_TIMEOUT, SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE));
320 Msg.Rsp.status = AsyncRsp.status;
321 RetVal = Msg.Rsp.status;
325 if (ReleasePoolObject == TRUE)
327 _SlDrvReleasePoolObj(ObjIdx);
333 WAIT_NWP_SHUTDOWN_READY;
337 if ((!SL_IS_DEVICE_STARTED)
338 && (!SL_IS_RESTART_REQUIRED))
341 return SL_RET_CODE_DEV_NOT_STARTED;
344 SL_SET_DEVICE_STOP_IN_PROGRESS;
347 _SlDrvReleaseAllActivePendingPoolObj();
349 #ifdef SL_PLATFORM_MULTI_THREADED 351 while (g_pCB->NumOfDeletedSyncObj < MAX_CONCURRENT_ACTIONS)
358 SL_DRV_LOCK_GLOBAL_LOCK_FOREVER(GLOBAL_LOCK_FLAGS_NONE);
360 sl_IfRegIntHdlr(NULL, NULL);
362 RetVal = sl_IfClose(g_pCB->FD);
364 (void)_SlDrvDriverCBDeinit();
367 SL_UNSET_DEVICE_STOP_IN_PROGRESS;
370 SL_UNSET_DEVICE_STARTED;
372 SL_DRV_LOCK_GLOBAL_UNLOCK(FALSE);
386 }_SlEventMaskSetMsg_u;
389 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskSet) 393 SL_OPCODE_DEVICE_EVENTMASKSET,
401 _SlEventMaskSetMsg_u Msg;
405 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
407 Msg.Cmd.Group = EventClass;
410 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskSetCmdCtrl, &Msg, NULL));
412 return (_i16)Msg.Rsp.status;
423 }_SlEventMaskGetMsg_u;
427 #if _SL_INCLUDE_FUNC(sl_DeviceEventMaskGet) 431 SL_OPCODE_DEVICE_EVENTMASKGET,
439 _SlEventMaskGetMsg_u Msg;
443 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
445 Msg.Cmd.Group = EventClass;
447 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlEventMaskGetCmdCtrl, &Msg, NULL));
449 *pMask = Msg.Rsp.Mask;
451 return SL_RET_CODE_OK;
469 #if _SL_INCLUDE_FUNC(sl_DeviceGet) 473 SL_OPCODE_DEVICE_DEVICEGET,
478 _i16
sl_DeviceGet(
const _u8 DeviceGetId, _u8 *pOption,_u16 *pConfigLen, _u8 *pValues)
480 _SlDeviceMsgGet_u Msg;
485 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
487 if (*pConfigLen == 0)
495 _SlDrvResetCmdExt(&CmdExt);
496 CmdExt.RxPayloadLen = (_i16)*pConfigLen;
497 CmdExt.pRxPayload = (_u8 *)pValues;
499 Msg.Cmd.DeviceSetId = DeviceGetId;
501 Msg.Cmd.Option = (_u16)*pOption;
503 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceGetCmdCtrl, &Msg, &CmdExt));
507 *pOption = (_u8)Msg.Rsp.Option;
510 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
512 *pConfigLen = (_u16)CmdExt.RxPayloadLen;
518 *pConfigLen = (_u16)CmdExt.ActualRxPayloadLen;
521 return (_i16)Msg.Rsp.Status;
525 return SL_RET_CODE_INVALID_INPUT;
541 #if _SL_INCLUDE_FUNC(sl_DeviceSet) 545 SL_OPCODE_DEVICE_DEVICESET,
550 _i16
sl_DeviceSet(
const _u8 DeviceSetId ,
const _u8 Option,
const _u16 ConfigLen,
const _u8 *pValues)
552 _SlDeviceMsgSet_u Msg;
557 VERIFY_API_ALLOWED(SL_OPCODE_SILO_DEVICE);
559 _SlDrvResetCmdExt(&CmdExt);
561 CmdExt.TxPayload1Len = (ConfigLen+3) & (~3);
562 CmdExt.pTxPayload1 = (_u8 *)pValues;
564 Msg.Cmd.DeviceSetId = DeviceSetId;
565 Msg.Cmd.ConfigLen = ConfigLen;
566 Msg.Cmd.Option = Option;
568 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlDeviceSetCmdCtrl, &Msg, &CmdExt));
570 return (_i16)Msg.Rsp.status;
578 _SlReturnVal_t _SlDeviceEventHandler(
void* pEventInfo)
585 _SlDrvMemZero(&DeviceEvent,
sizeof(DeviceEvent));
587 switch(pHdr->GenHeader.Opcode)
589 case SL_OPCODE_DEVICE_INITCOMPLETE:
590 _SlDeviceHandleAsync_InitComplete(pHdr);
592 case SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE:
593 _SlDeviceHandleAsync_Stop(pHdr);
595 case SL_OPCODE_DEVICE_RESET_REQUEST_ASYNC_EVENT:
599 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 600 if (pResetRequestData->Caller == SL_DEVICE_RESET_REQUEST_CALLER_PROVISIONING_EXTERNAL_CONFIGURATION)
603 DeviceEvent.Id = SL_DEVICE_EVENT_RESET_REQUEST;
604 DeviceEvent.Data.ResetRequest.Status = 0;
605 DeviceEvent.Data.ResetRequest.Caller = pResetRequestData->Caller;
606 _SlDrvHandleGeneralEvents(&DeviceEvent);
611 if (!_SlDrvIsApiInProgress() && SL_IS_PROVISIONING_IN_PROGRESS)
613 if (pResetRequestData->SessionNumber != DeviceCB.ResetRequestSessionNumber)
616 DeviceCB.ResetRequestSessionNumber = pResetRequestData->SessionNumber;
619 _SlDeviceHandleResetRequestInternally();
625 case SL_OPCODE_DEVICE_ABORT:
628 if (pInfo->bInCmdContext == TRUE)
630 SL_DRV_LOCK_GLOBAL_UNLOCK(TRUE);
633 _SlDrvHandleFatalError(SL_DEVICE_EVENT_FATAL_DEVICE_ABORT,
634 *((_u32*)pMsgArgs - 1),
639 case SL_OPCODE_DEVICE_DEVICE_ASYNC_GENERAL_ERROR:
641 #if defined(slcb_DeviceGeneralEvtHdlr) || defined (EXT_LIB_REGISTERED_GENERAL_EVENTS) 643 DeviceEvent.Id = SL_DEVICE_EVENT_ERROR;
644 DeviceEvent.Data.Error.Code = pMsgArgs->status;
645 DeviceEvent.Data.Error.Source = (SlDeviceSource_e)pMsgArgs->sender;
646 _SlDrvHandleGeneralEvents(&DeviceEvent);
651 case SL_OPCODE_DEVICE_FLOW_CTRL_ASYNC_EVENT:
652 _SlFlowContSet((
void *)pHdr);
655 SL_ERROR_TRACE2(MSG_306,
"ASSERT: _SlDeviceEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
658 return SL_OS_RET_CODE_OK;
662 void _SlDeviceResetRequestInitCompletedCB(_u32 Status,
SlDeviceInitInfo_t *DeviceInitInfo)
668 void _SlDeviceHandleResetRequestInternally(
void)
670 _u8 irqCountLast = RxIrqCnt;
671 #if (defined(slcb_GetTimestamp)) 674 _SlDrvStartMeasureTimeout(&TimeoutInfo, 2*RESET_REQUEST_STOP_TIMEOUT);
679 sl_Stop(RESET_REQUEST_STOP_TIMEOUT);
685 #if (defined(slcb_GetTimestamp)) 686 if (_SlDrvIsTimeoutExpired(&TimeoutInfo))
692 while((RxIrqCnt - irqCountLast) < 2);
695 sl_Start(DeviceCB.pIfHdl, DeviceCB.pDevName ,_SlDeviceResetRequestInitCompletedCB);
703 #ifdef SL_IF_TYPE_UART 708 }_SlUartSetModeMsg_u;
711 #if _SL_INCLUDE_FUNC(sl_DeviceUartSetMode) 716 SL_OPCODE_DEVICE_SETUARTMODECOMMAND,
723 _SlUartSetModeMsg_u Msg;
724 _u32 magicCode = (_u32)0xFFFFFFFF;
726 Msg.Cmd.BaudRate = pUartParams->BaudRate;
727 Msg.Cmd.FlowControlEnable = pUartParams->FlowControlEnable;
730 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlUartSetModeCmdCtrl, &Msg, NULL));
733 if (SL_RET_CODE_OK == Msg.Rsp.status)
738 sl_IfClose(g_pCB->FD);
741 sl_IfOpen((
void * )pUartParams, SL_IF_UART_REOPEN_FLAGS);
743 sl_IfUnMaskIntHdlr();
746 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
748 magicCode = UART_SET_MODE_MAGIC_CODE;
749 sl_IfWrite(g_pCB->FD, (_u8* )&magicCode, 4);
755 sl_IfRead(g_pCB->FD, (_u8* )&magicCode, 4);
758 if (UART_SET_MODE_MAGIC_CODE != magicCode)
764 return (_i16)Msg.Rsp.status;
_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_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.