driver.h

00001 /*
00002  * driver.h - CC31xx/CC32xx Host Driver Implementation
00003  *
00004  * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/ 
00005  * 
00006  * 
00007  *  Redistribution and use in source and binary forms, with or without 
00008  *  modification, are permitted provided that the following conditions 
00009  *  are met:
00010  *
00011  *    Redistributions of source code must retain the above copyright 
00012  *    notice, this list of conditions and the following disclaimer.
00013  *
00014  *    Redistributions in binary form must reproduce the above copyright
00015  *    notice, this list of conditions and the following disclaimer in the 
00016  *    documentation and/or other materials provided with the   
00017  *    distribution.
00018  *
00019  *    Neither the name of Texas Instruments Incorporated nor the names of
00020  *    its contributors may be used to endorse or promote products derived
00021  *    from this software without specific prior written permission.
00022  *
00023  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
00024  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
00025  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00026  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
00027  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
00028  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
00029  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00030  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00031  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
00032  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
00033  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034  *
00035 */
00036  
00037 #ifndef __DRIVER_INT_H__
00038 #define __DRIVER_INT_H__
00039 
00040 #define TIMEOUT_STATE_EXPIRY      (0)
00041 #define TIMEOUT_ONE_MORE_SHOT     (1)
00042 #define TIMEOUT_STATE_INIT_VAL    (2)
00043 
00044 
00045 /* Timeouts for the sync objects  */
00046 #ifndef SL_DRIVER_TIMEOUT_SHORT
00047 #define SL_DRIVER_TIMEOUT_SHORT        (1000) /* msec units */
00048 #endif
00049 #ifndef SL_DRIVER_TIMEOUT_LONG
00050 #define SL_DRIVER_TIMEOUT_LONG         (65535) /* msec units */
00051 #endif
00052 
00053 #define INIT_COMPLETE_TIMEOUT          SL_DRIVER_TIMEOUT_LONG
00054 #define STOP_DEVICE_TIMEOUT            SL_DRIVER_TIMEOUT_LONG
00055 #ifndef SYNC_PATTERN_TIMEOUT_IN_MSEC
00056 #define SYNC_PATTERN_TIMEOUT_IN_MSEC   (50) /* the sync patttern timeout in milliseconds units */
00057 #endif
00058 /*****************************************************************************/
00059 /* Macro declarations                                                        */
00060 /*****************************************************************************/
00061 
00062 #ifndef CPU_FREQ_IN_MHZ
00063  #define CPU_FREQ_IN_MHZ         (200)
00064 #endif
00065 #define USEC_DELAY              (50)
00066 
00067 #define SL_DRV_PROTECTION_OBJ_UNLOCK()       (void)_SlDrvProtectionObjUnLock();
00068 #define SL_DRV_PROTECTION_OBJ_LOCK_FOREVER() (void)_SlDrvProtectionObjLockWaitForever();
00069 #define SL_DRV_OBJ_UNLOCK(pObj)              (void)_SlDrvObjUnLock(pObj);
00070 #define SL_DRV_OBJ_LOCK_FOREVER(pObj)        (void)_SlDrvObjLockWaitForever(pObj);
00071 #define SL_DRV_SYNC_OBJ_SIGNAL(pObj)         (void)_SlDrvSyncObjSignal(pObj);
00072 #define SL_DRV_SYNC_OBJ_CLEAR(pObj)          (void)sl_SyncObjWait(pObj,SL_OS_NO_WAIT);
00073 
00074 
00075 #ifdef SL_TINY_EXT
00076 #define SL_DRV_SYNC_OBJ_WAIT_FOREVER(SyncObj) (void)_SlDrvSyncObjWaitForever(SyncObj);
00077 #define SL_DRV_LOCK_GLOBAL_LOCK_FOREVER()     (void)_SlDrvObjGlobalLockWaitForever();
00078 #define SL_DRV_LOCK_GLOBAL_UNLOCK()           (void)_SlDrvGlobalObjUnLock();
00079 #else
00080 #define SL_DRV_SYNC_OBJ_WAIT_FOREVER(SyncObj) { \
00081 if (SL_API_ABORTED == _SlDrvSyncObjWaitForever(SyncObj)) \
00082 { \
00083     return SL_API_ABORTED; \
00084 } \
00085 }
00086 
00087 #define SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(SyncObj, timeoutVal, apiIdx) { \
00088 if (SL_API_ABORTED == _SlDrvSyncObjWaitTimeout(SyncObj, timeoutVal, apiIdx)) \
00089 { \
00090     return SL_API_ABORTED; \
00091 } \
00092 }
00093 #define SL_DRV_LOCK_GLOBAL_LOCK_FOREVER() { \
00094 _SlReturnVal_t retVal;                     \
00095                                            \
00096 retVal = _SlDrvObjGlobalLockWaitForever(); \
00097 if (retVal)         \
00098 {                   \
00099     return retVal;  \
00100 }                   \
00101 }
00102 
00103 #define SL_DRV_LOCK_GLOBAL_UNLOCK() { \
00104 _SlReturnVal_t retVal;                \
00105                                       \
00106 retVal = _SlDrvGlobalObjUnLock();    \
00107 if (retVal)         \
00108 {                   \
00109     return retVal;  \
00110 }                   \
00111 }
00112 #endif
00113 
00114 
00115 /*****************************************************************************/
00116 /* Structure/Enum declarations                                               */
00117 /*****************************************************************************/
00118 
00119 typedef struct
00120 {
00121     _u32  TSPrev;
00122     _u32  TSCurr;
00123     _u32  DeltaTicks;
00124     _u32  DeltaTicksReminder;
00125     _i32  Total10MSecUnits;
00126 } _SlTimeoutParams_t;
00127 
00128 typedef struct
00129 {
00130     _u8 *pAsyncMsgBuff;
00131     _u8  bInCmdContext;
00132 } DeviceEventInfo_t;
00133 
00134 typedef struct
00135 {
00136     _SlOpcode_t      Opcode;
00137     _SlArgSize_t     TxDescLen;
00138     _SlArgSize_t     RxDescLen;
00139 }_SlCmdCtrl_t;
00140 
00141 typedef struct
00142 {
00143     _u16  TxPayloadLen;
00144     _i16  RxPayloadLen;
00145     _i16  ActualRxPayloadLen;
00146     _u8   *pTxPayload;
00147     _u8   *pRxPayload;
00148 }_SlCmdExt_t;
00149 
00150 
00151 typedef struct _SlArgsData_t
00152 {
00153     _u8  *pArgs;
00154     _u8    *pData;
00155 } _SlArgsData_t;
00156 
00157 
00158 typedef struct _SlPoolObj_t
00159 {
00160     _SlSyncObj_t          SyncObj;
00161      _u8                *pRespArgs;
00162     _u8               ActionID; 
00163     _u8               AdditionalData; /* use for socketID and one bit which indicate supprt IPV6 or not (1=support, 0 otherwise) */
00164     _u8               NextIndex;  
00165 
00166 } _SlPoolObj_t;
00167 
00168 
00169 typedef enum
00170 {
00171     SOCKET_0,
00172     SOCKET_1,
00173     SOCKET_2,
00174     SOCKET_3,
00175     SOCKET_4,
00176     SOCKET_5,
00177     SOCKET_6,
00178     SOCKET_7,
00179     MAX_SOCKET_ENUM_IDX,
00180 #ifndef SL_TINY_EXT    
00181     ACCEPT_ID = MAX_SOCKET_ENUM_IDX,
00182     CONNECT_ID,
00183 #else
00184     CONNECT_ID = MAX_SOCKET_ENUM_IDX,
00185 #endif
00186 #ifndef SL_TINY_EXT    
00187     SELECT_ID,
00188 #endif
00189     GETHOSYBYNAME_ID,
00190 #ifndef SL_TINY_EXT    
00191     GETHOSYBYSERVICE_ID,
00192     PING_ID,
00193 #endif  
00194     START_STOP_ID,
00195     RECV_ID
00196 }_SlActionID_e;
00197 
00198 typedef struct _SlActionLookup_t
00199 {
00200     _u8                     ActionID;
00201     _u16                    ActionAsyncOpcode;
00202     _SlSpawnEntryFunc_t     AsyncEventHandler; 
00203 
00204 } _SlActionLookup_t;
00205 
00206 
00207 typedef struct
00208 {
00209     _u8             TxPoolCnt;
00210     _SlLockObj_t    TxLockObj;
00211     _SlSyncObj_t    TxSyncObj;
00212 }_SlFlowContCB_t;
00213 
00214 typedef enum
00215 {
00216     RECV_RESP_CLASS,
00217     CMD_RESP_CLASS,
00218     ASYNC_EVT_CLASS,
00219     DUMMY_MSG_CLASS
00220 }_SlRxMsgClass_e;
00221 
00222 typedef struct
00223 {
00224     _u8                     *pAsyncBuf;         /* place to write pointer to buffer with CmdResp's Header + Arguments */
00225     _u8                     ActionIndex; 
00226     _SlSpawnEntryFunc_t     AsyncEvtHandler;    /* place to write pointer to AsyncEvent handler (calc-ed by Opcode)   */
00227     _SlRxMsgClass_e         RxMsgClass;         /* type of Rx message                                                 */
00228 } AsyncExt_t;
00229 
00230 typedef _u8 _SlSd_t;
00231 
00232 typedef struct
00233 {
00234     _SlCmdCtrl_t         *pCmdCtrl;
00235     _u8                  *pTxRxDescBuff;
00236     _SlCmdExt_t          *pCmdExt;
00237     AsyncExt_t            AsyncExt;
00238 }_SlFunctionParams_t;
00239 
00240 
00241 typedef struct
00242 {
00243     _SlFd_t                          FD;
00244     _SlLockObj_t                     GlobalLockObj;
00245     _SlCommandHeader_t               TempProtocolHeader;
00246     P_INIT_CALLBACK                  pInitCallback;
00247 
00248     _SlPoolObj_t                    ObjPool[MAX_CONCURRENT_ACTIONS];
00249     _u8                     FreePoolIdx;
00250     _u8                     PendingPoolIdx;
00251     _u8                     ActivePoolIdx;
00252     _u32                    ActiveActionsBitmap;
00253     _SlLockObj_t                    ProtectionLockObj;
00254 
00255     _SlSyncObj_t                     CmdSyncObj;  
00256     _u8                     IsCmdRespWaited;
00257     _SlFlowContCB_t          FlowContCB;
00258     _u8                     TxSeqNum;
00259     _u8                     RxDoneCnt;
00260     _u8                     SocketNonBlocking;
00261     _u8                     SocketTXFailure;
00262     /* for stack reduction the parameters are globals */
00263     _SlFunctionParams_t              FunctionParams;
00264 
00265     _u8 ActionIndex;
00266 }_SlDriverCb_t;
00267 
00268 extern _volatile _u8     RxIrqCnt;
00269 
00270 #ifndef SL_TINY_EXT
00271 extern _volatile _u8     g_bDeviceRestartIsRequired;
00272 #endif
00273 
00274 extern _SlDriverCb_t* g_pCB;
00275 extern P_SL_DEV_PING_CALLBACK  pPingCallBackFunc;
00276 
00277 /*****************************************************************************/
00278 /* Function prototypes                                                       */
00279 /*****************************************************************************/
00280 
00281 extern _SlReturnVal_t _SlDrvDriverCBInit(void);
00282 extern _SlReturnVal_t _SlDrvDriverCBDeinit(void);
00283 extern _SlReturnVal_t _SlDrvRxIrqHandler(void *pValue);
00284 extern _SlReturnVal_t  _SlDrvCmdOp(_SlCmdCtrl_t *pCmdCtrl , void* pTxRxDescBuff , _SlCmdExt_t* pCmdExt);
00285 extern _SlReturnVal_t  _SlDrvCmdSend(_SlCmdCtrl_t *pCmdCtrl , void* pTxRxDescBuff , _SlCmdExt_t* pCmdExt);
00286 extern _SlReturnVal_t  _SlDrvDataReadOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl , void* pTxRxDescBuff , _SlCmdExt_t* pCmdExt);
00287 extern _SlReturnVal_t  _SlDrvDataWriteOp(_SlSd_t Sd, _SlCmdCtrl_t *pCmdCtrl , void* pTxRxDescBuff , _SlCmdExt_t* pCmdExt);
00288 extern _SlReturnVal_t _sl_HandleAsync_InitComplete(void *pVoidBuf); 
00289 extern _SlReturnVal_t _sl_HandleAsync_Connect(void *pVoidBuf);
00290 extern _SlReturnVal_t _SlDrvGlobalObjUnLock(void);
00291 extern _SlReturnVal_t _SlDrvMsgReadSpawnCtx(void *pValue);
00292 
00293 
00294 #ifndef SL_TINY_EXT
00295 extern _i16  _SlDrvBasicCmd(_SlOpcode_t Opcode);
00296 extern _SlReturnVal_t _sl_HandleAsync_Accept(void *pVoidBuf);
00297 extern _SlReturnVal_t _sl_HandleAsync_DnsGetHostByService(void *pVoidBuf);
00298 extern _SlReturnVal_t _sl_HandleAsync_Select(void *pVoidBuf);
00299 #ifdef sl_GetTimestamp
00300 extern void _SlDrvStartMeasureTimeout(_SlTimeoutParams_t *pTimeoutInfo, _u32 TimeoutInMsec);
00301 extern _u8 _SlDrvIsTimeoutExpired(_SlTimeoutParams_t *pTimeoutInfo);
00302 #endif
00303 
00304 #endif
00305 extern _SlReturnVal_t _sl_HandleAsync_DnsGetHostByName(void *pVoidBuf);
00306 extern _SlReturnVal_t _sl_HandleAsync_DnsGetHostByAddr(void *pVoidBuf);
00307 extern _SlReturnVal_t _sl_HandleAsync_PingResponse(void *pVoidBuf);
00308 extern _SlReturnVal_t _SlDrvNetAppEventHandler(void* pArgs);
00309 
00310 #if defined(sl_HttpServerCallback) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS)
00311 extern void _SlDrvDispatchHttpServerEvents(SlHttpServerEvent_t *slHttpServerEvent, SlHttpServerResponse_t *slHttpServerResponse);
00312 #endif
00313 
00314 extern void _sl_HandleAsync_Stop(void *pVoidBuf);
00315 extern _u8 _SlDrvWaitForPoolObj(_u8 ActionID, _u8 SocketID);
00316 extern void _SlDrvReleasePoolObj(_u8 pObj);
00317 extern _u16 _SlDrvAlignSize(_u16 msgLen); 
00318 extern _u8  _SlDrvProtectAsyncRespSetting(_u8 *pAsyncRsp, _SlActionID_e ActionID, _u8 SocketID);
00319 
00320 
00321 
00322 extern _SlReturnVal_t _SlDrvDeviceEventHandler(void* pEventInfo);
00323 extern _SlReturnVal_t  _SlDrvSyncObjWaitForever(_SlSyncObj_t *pSyncObj);
00324 extern _SlReturnVal_t  _SlDrvObjLockWaitForever(_SlLockObj_t *pLockObj);
00325 extern _SlReturnVal_t  _SlDrvSyncObjWaitTimeout(_SlSyncObj_t *pSyncObj,
00326                                         _u32 timeoutVal,
00327                                         SlDriverAPIWithTimeout_e apiIdx);
00328 
00329 extern _SlReturnVal_t  _SlDrvSyncObjSignal(_SlSyncObj_t *pSyncObj);
00330 extern _SlReturnVal_t  _SlDrvObjLock(_SlLockObj_t *pLockObj, _SlTime_t Timeout);
00331 extern _SlReturnVal_t  _SlDrvProtectionObjLockWaitForever(void);
00332 extern _SlReturnVal_t  _SlDrvObjUnLock(_SlLockObj_t *pLockObj);
00333 extern _SlReturnVal_t  _SlDrvProtectionObjUnLock(void);
00334 
00335 extern void  _SlDrvMemZero(void* Addr, _u16 size);
00336 extern void  _SlDrvResetCmdExt(_SlCmdExt_t* pCmdExt);
00337 
00338 #ifndef SL_TINY_EXT
00339 extern void _SlDriverHandleError(SlDeviceDriverError_e eError, _u32 info1, _u32 info2);
00340 #endif
00341 
00342 #define _SL_PROTOCOL_ALIGN_SIZE(msgLen)             (((msgLen)+3) & (~3))
00343 #define _SL_IS_PROTOCOL_ALIGNED_SIZE(msgLen)        (!((msgLen) & 3))
00344 
00345 
00346 #define _SL_PROTOCOL_CALC_LEN(pCmdCtrl,pCmdExt)     ((pCmdExt) ? \
00347                                                      (_SL_PROTOCOL_ALIGN_SIZE(pCmdCtrl->TxDescLen) + _SL_PROTOCOL_ALIGN_SIZE(pCmdExt->TxPayloadLen)) : \
00348                                                      (_SL_PROTOCOL_ALIGN_SIZE(pCmdCtrl->TxDescLen)))
00349 #endif /* __DRIVER_INT_H__ */