Staging: epl: run Lindent on all user/*.h files

+69 -84

drivers/staging/epl/user/EplCfgMau.h

··· 86 86 #define EPL_CFGMA_MAX_TIMEOUT 3 87 87 88 88 //callbackfunction, called if configuration is finished 89 - typedef void (PUBLIC* tfpEplCfgMaCb) (unsigned int uiNodeId_p, 90 - tEplKernel Errorstate_p); 89 + typedef void (PUBLIC * tfpEplCfgMaCb) (unsigned int uiNodeId_p, 90 + tEplKernel Errorstate_p); 91 91 92 92 //State for configuartion manager Statemachine 93 - typedef enum 94 - { 95 - // general states 96 - kEplCfgMaIdle = 0x0000, // Configurationsprocess 97 - // is idle 98 - kEplCfgMaWaitForSdocEvent = 0x0001, // wait until the last 99 - // SDOC is finisched 100 - kEplCfgMaSkipMappingSub0 = 0x0002, // write Sub0 of mapping 101 - // parameter with 0 93 + typedef enum { 94 + // general states 95 + kEplCfgMaIdle = 0x0000, // Configurationsprocess 96 + // is idle 97 + kEplCfgMaWaitForSdocEvent = 0x0001, // wait until the last 98 + // SDOC is finisched 99 + kEplCfgMaSkipMappingSub0 = 0x0002, // write Sub0 of mapping 100 + // parameter with 0 102 101 103 - kEplCfgMaFinished = 0x0004 // configuartion is finished 104 - 102 + kEplCfgMaFinished = 0x0004 // configuartion is finished 105 103 } tEplCfgState; 106 104 107 - typedef enum 108 - { 109 - kEplCfgMaDcfTypSystecSeg = 0x00, 110 - kEplCfgMaDcfTypConDcf = 0x01, 111 - kEplCfgMaDcfTypDcf = 0x02, // not supported 112 - kEplCfgMaDcfTypXdc = 0x03 // not supported 105 + typedef enum { 106 + kEplCfgMaDcfTypSystecSeg = 0x00, 107 + kEplCfgMaDcfTypConDcf = 0x01, 108 + kEplCfgMaDcfTypDcf = 0x02, // not supported 109 + kEplCfgMaDcfTypXdc = 0x03 // not supported 110 + } tEplCfgMaDcfTyp; 113 111 114 - 115 - }tEplCfgMaDcfTyp; 116 - 117 - typedef enum 118 - { 119 - kEplCfgMaCommon = 0, // all other index 120 - kEplCfgMaPdoComm = 1, // communication index 121 - kEplCfgMaPdoMapp = 2, // mapping index 122 - kEplCfgMaPdoCommAfterMapp = 3, // write PDO Cob-Id after mapping subindex 0(set PDO valid) 112 + typedef enum { 113 + kEplCfgMaCommon = 0, // all other index 114 + kEplCfgMaPdoComm = 1, // communication index 115 + kEplCfgMaPdoMapp = 2, // mapping index 116 + kEplCfgMaPdoCommAfterMapp = 3, // write PDO Cob-Id after mapping subindex 0(set PDO valid) 123 117 124 118 } tEplCfgMaIndexType; 125 119 126 - 127 120 //bitcoded answer about the last sdo transfer saved in m_SdocState 128 121 // also used to singal start of the State Maschine 129 - typedef enum 130 - { 131 - kEplCfgMaSdocBusy = 0x00, // SDOC activ 132 - kEplCfgMaSdocReady = 0x01, // SDOC finished 133 - kEplCfgMaSdocTimeout = 0x02, // SDOC Timeout 134 - kEplCfgMaSdocAbortReceived = 0x04, // SDOC Abort, see Abortcode 135 - kEplCfgMaSdocStart = 0x08 // start State Mschine 136 - }tEplSdocState; 122 + typedef enum { 123 + kEplCfgMaSdocBusy = 0x00, // SDOC activ 124 + kEplCfgMaSdocReady = 0x01, // SDOC finished 125 + kEplCfgMaSdocTimeout = 0x02, // SDOC Timeout 126 + kEplCfgMaSdocAbortReceived = 0x04, // SDOC Abort, see Abortcode 127 + kEplCfgMaSdocStart = 0x08 // start State Mschine 128 + } tEplSdocState; 137 129 138 130 //internal structure (instancetable for modul configuration manager) 139 - typedef struct 140 - { 141 - tEplCfgState m_CfgState; // state of the configuration state maschine 142 - tEplSdoComConHdl m_SdoComConHdl; // handle for sdo connection 143 - DWORD m_dwLastAbortCode; 144 - unsigned int m_uiLastIndex; // last index of configuration, to compair with actual index 145 - BYTE* m_pbConcise; // Ptr to concise DCF 146 - BYTE* m_pbActualIndex; // Ptr to actual index in the DCF segment 147 - tfpEplCfgMaCb m_pfnCfgMaCb; // Ptr to CfgMa Callback, is call if configuration finished 148 - tEplKernel m_EplKernelError; // errorcode 149 - DWORD m_dwNumValueCopy; // numeric values are copied in this variable 150 - unsigned int m_uiPdoNodeId; // buffer for PDO node id 151 - BYTE m_bNrOfMappedObject; // number of mapped objects 152 - unsigned int m_uiNodeId; // Epl node addresse 153 - tEplSdocState m_SdocState; // bitcoded state of the SDO transfer 154 - unsigned int m_uiLastSubIndex; // last subindex of configuration 155 - BOOL m_fOneTranferOk; // atleased one transfer was successful 156 - BYTE m_bEventFlag; // for Eventsignaling to the State Maschine 157 - DWORD m_dwCntObjectInDcf; // number of Objects in DCF 158 - tEplCfgMaIndexType m_SkipCfg; // TRUE if a adsitional Configurationprocess 159 - // have to insert e.g. PDO-mapping 160 - WORD m_wTimeOutCnt; // Timeout Counter, break configuration is 161 - // m_wTimeOutCnt == CFGMA_MAX_TIMEOUT 131 + typedef struct { 132 + tEplCfgState m_CfgState; // state of the configuration state maschine 133 + tEplSdoComConHdl m_SdoComConHdl; // handle for sdo connection 134 + DWORD m_dwLastAbortCode; 135 + unsigned int m_uiLastIndex; // last index of configuration, to compair with actual index 136 + BYTE *m_pbConcise; // Ptr to concise DCF 137 + BYTE *m_pbActualIndex; // Ptr to actual index in the DCF segment 138 + tfpEplCfgMaCb m_pfnCfgMaCb; // Ptr to CfgMa Callback, is call if configuration finished 139 + tEplKernel m_EplKernelError; // errorcode 140 + DWORD m_dwNumValueCopy; // numeric values are copied in this variable 141 + unsigned int m_uiPdoNodeId; // buffer for PDO node id 142 + BYTE m_bNrOfMappedObject; // number of mapped objects 143 + unsigned int m_uiNodeId; // Epl node addresse 144 + tEplSdocState m_SdocState; // bitcoded state of the SDO transfer 145 + unsigned int m_uiLastSubIndex; // last subindex of configuration 146 + BOOL m_fOneTranferOk; // atleased one transfer was successful 147 + BYTE m_bEventFlag; // for Eventsignaling to the State Maschine 148 + DWORD m_dwCntObjectInDcf; // number of Objects in DCF 149 + tEplCfgMaIndexType m_SkipCfg; // TRUE if a adsitional Configurationprocess 150 + // have to insert e.g. PDO-mapping 151 + WORD m_wTimeOutCnt; // Timeout Counter, break configuration is 152 + // m_wTimeOutCnt == CFGMA_MAX_TIMEOUT 162 153 163 154 } tEplCfgMaNode; 164 155 ··· 204 213 // 205 214 // Returns: tCopKernel = error code 206 215 //--------------------------------------------------------------------------- 207 - tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p, 208 - BYTE* pbConcise_p, 209 - tfpEplCfgMaCb fpCfgMaCb_p, 210 - tEplObdSize SizeOfConcise_p, 211 - tEplCfgMaDcfTyp DcfType_p); 212 - 216 + tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p, 217 + BYTE * pbConcise_p, 218 + tfpEplCfgMaCb fpCfgMaCb_p, 219 + tEplObdSize SizeOfConcise_p, 220 + tEplCfgMaDcfTyp DcfType_p); 213 221 214 222 //--------------------------------------------------------------------------- 215 223 // Function: CfgMaStartConfigurationNode() ··· 223 233 // Returns: tCopKernel = error code 224 234 //--------------------------------------------------------------------------- 225 235 tEplKernel PUBLIC EplCfgMaStartConfigNode(unsigned int uiNodeId_p, 226 - tfpEplCfgMaCb fpCfgMaCb_p, 227 - tEplCfgMaDcfTyp DcfType_p); 228 - 236 + tfpEplCfgMaCb fpCfgMaCb_p, 237 + tEplCfgMaDcfTyp DcfType_p); 229 238 230 239 //--------------------------------------------------------------------------- 231 240 // Function: EplCfgMaStartConfigNodeDcf() ··· 240 251 // 241 252 // Returns: tCopKernel = error code 242 253 //--------------------------------------------------------------------------- 243 - tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p, 244 - BYTE* pbConcise_p, 245 - tfpEplCfgMaCb fpCfgMaCb_p, 246 - tEplObdSize SizeOfConcise_p, 247 - tEplCfgMaDcfTyp DcfType_p); 254 + tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p, 255 + BYTE * pbConcise_p, 256 + tfpEplCfgMaCb fpCfgMaCb_p, 257 + tEplObdSize SizeOfConcise_p, 258 + tEplCfgMaDcfTyp DcfType_p); 248 259 249 260 //--------------------------------------------------------------------------- 250 261 // Function: EplCfgMaLinkDcf() ··· 258 269 // 259 270 // Returns: tCopKernel = error code 260 271 //--------------------------------------------------------------------------- 261 - tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p, 262 - BYTE* pbConcise_p, 263 - tEplObdSize SizeOfConcise_p, 264 - tEplCfgMaDcfTyp DcfType_p); 272 + tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p, 273 + BYTE * pbConcise_p, 274 + tEplObdSize SizeOfConcise_p, 275 + tEplCfgMaDcfTyp DcfType_p); 265 276 266 277 //--------------------------------------------------------------------------- 267 278 // Function: EplCfgMaCheckDcf() ··· 274 285 // 275 286 // Returns: tCopKernel = error code 276 287 //--------------------------------------------------------------------------- 277 - tEplKernel PUBLIC EplCfgMaCheckDcf(unsigned int uiNodeId_p, 278 - tEplCfgMaDcfTyp DcfType_p); 279 - 280 - 281 - 282 - 288 + tEplKernel PUBLIC EplCfgMaCheckDcf(unsigned int uiNodeId_p, 289 + tEplCfgMaDcfTyp DcfType_p); 283 290 284 291 #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_CFGMA)) != 0) 285 292

+7 -7

drivers/staging/epl/user/EplDllu.h

··· 66 66 67 67 2006/06/20 d.k.: start of the implementation, version 1.00 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #ifndef _EPL_DLLU_H_ ··· 81 82 // typedef 82 83 //--------------------------------------------------------------------------- 83 84 84 - typedef tEplKernel (PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); 85 + typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); 85 86 86 87 //--------------------------------------------------------------------------- 87 88 // function prototypes ··· 93 94 94 95 tEplKernel EplDlluDelInstance(void); 95 96 96 - tEplKernel EplDlluRegAsndService(tEplDllAsndServiceId ServiceId_p, tEplDlluCbAsnd pfnDlluCbAsnd_p, tEplDllAsndFilter Filter_p); 97 + tEplKernel EplDlluRegAsndService(tEplDllAsndServiceId ServiceId_p, 98 + tEplDlluCbAsnd pfnDlluCbAsnd_p, 99 + tEplDllAsndFilter Filter_p); 97 100 98 - tEplKernel EplDlluAsyncSend(tEplFrameInfo * pFrameInfo_p, tEplDllAsyncReqPriority Priority_p); 101 + tEplKernel EplDlluAsyncSend(tEplFrameInfo * pFrameInfo_p, 102 + tEplDllAsyncReqPriority Priority_p); 99 103 100 104 // processes asynch frames 101 105 tEplKernel EplDlluProcess(tEplFrameInfo * pFrameInfo_p); 102 106 103 107 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0) 104 108 105 - #endif // #ifndef _EPL_DLLU_H_ 106 - 107 - 109 + #endif // #ifndef _EPL_DLLU_H_

+8 -11

drivers/staging/epl/user/EplDlluCal.h

··· 66 66 67 67 2006/06/20 d.k.: start of the implementation, version 1.00 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #ifndef _EPL_DLLUCAL_H_ ··· 82 83 // typedef 83 84 //--------------------------------------------------------------------------- 84 85 85 - typedef tEplKernel (PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); 86 + typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); 86 87 87 88 //--------------------------------------------------------------------------- 88 89 // function prototypes ··· 93 94 tEplKernel EplDlluCalDelInstance(void); 94 95 95 96 tEplKernel EplDlluCalRegAsndService(tEplDllAsndServiceId ServiceId_p, 96 - tEplDlluCbAsnd pfnDlluCbAsnd_p, 97 - tEplDllAsndFilter Filter_p); 97 + tEplDlluCbAsnd pfnDlluCbAsnd_p, 98 + tEplDllAsndFilter Filter_p); 98 99 99 - tEplKernel EplDlluCalAsyncSend(tEplFrameInfo * pFrameInfo, tEplDllAsyncReqPriority Priority_p); 100 + tEplKernel EplDlluCalAsyncSend(tEplFrameInfo * pFrameInfo, 101 + tEplDllAsyncReqPriority Priority_p); 100 102 101 103 tEplKernel EplDlluCalProcess(tEplEvent * pEvent_p); 102 - 103 104 104 105 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) 105 106 ··· 109 110 110 111 tEplKernel EplDlluCalSoftDeleteNode(unsigned int uiNodeId_p); 111 112 112 - tEplKernel EplDlluCalIssueRequest(tEplDllReqServiceId Service_p, unsigned int uiNodeId_p, BYTE bSoaFlag1_p); 113 + tEplKernel EplDlluCalIssueRequest(tEplDllReqServiceId Service_p, 114 + unsigned int uiNodeId_p, BYTE bSoaFlag1_p); 113 115 114 116 #endif 115 117 116 - 117 - #endif // #ifndef _EPL_DLLUCAL_H_ 118 - 119 - 118 + #endif // #ifndef _EPL_DLLUCAL_H_

+5 -12

drivers/staging/epl/user/EplEventu.h

··· 66 66 67 67 2006/06/12 d.k.: start of the implementation, version 1.00 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #ifndef _EPL_EVENTU_H_ 73 72 #define _EPL_EVENTU_H_ 74 73 75 74 #include "../EplEvent.h" 76 - 77 75 78 76 //--------------------------------------------------------------------------- 79 77 // const defines ··· 81 83 // typedef 82 84 //--------------------------------------------------------------------------- 83 85 84 - 85 86 //--------------------------------------------------------------------------- 86 87 // function prototypes 87 88 //--------------------------------------------------------------------------- ··· 88 91 tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p); 89 92 90 93 // add instance 91 - tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb pfnApiProcessEventCb_p); 94 + tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb 95 + pfnApiProcessEventCb_p); 92 96 93 97 // delete instance 94 98 tEplKernel PUBLIC EplEventuDelInstance(void); ··· 102 104 103 105 // post errorevents from userspace 104 106 tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p, 105 - tEplKernel EplError_p, 106 - unsigned int uiArgSize_p, 107 - void* pArg_p); 107 + tEplKernel EplError_p, 108 + unsigned int uiArgSize_p, void *pArg_p); 108 109 109 - 110 - 111 - #endif // #ifndef _EPL_EVENTU_H_ 112 - 113 - 110 + #endif // #ifndef _EPL_EVENTU_H_

+10 -15

drivers/staging/epl/user/EplIdentu.h

··· 66 66 67 67 2006/11/15 d.k.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplDll.h" ··· 73 74 #ifndef _EPLIDENTU_H_ 74 75 #define _EPLIDENTU_H_ 75 76 76 - 77 77 //--------------------------------------------------------------------------- 78 78 // const defines 79 79 //--------------------------------------------------------------------------- 80 - 81 80 82 81 //--------------------------------------------------------------------------- 83 82 // typedef 84 83 //--------------------------------------------------------------------------- 85 84 86 - typedef tEplKernel (PUBLIC * tEplIdentuCbResponse) ( 87 - unsigned int uiNodeId_p, 88 - tEplIdentResponse* pIdentResponse_p); 85 + typedef tEplKernel(PUBLIC * tEplIdentuCbResponse) (unsigned int uiNodeId_p, 86 + tEplIdentResponse * 87 + pIdentResponse_p); 89 88 90 89 //--------------------------------------------------------------------------- 91 90 // function prototypes ··· 97 100 98 101 tEplKernel PUBLIC EplIdentuReset(void); 99 102 100 - tEplKernel PUBLIC EplIdentuGetIdentResponse( 101 - unsigned int uiNodeId_p, 102 - tEplIdentResponse** ppIdentResponse_p); 103 + tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p, 104 + tEplIdentResponse ** 105 + ppIdentResponse_p); 103 106 104 - tEplKernel PUBLIC EplIdentuRequestIdentResponse( 105 - unsigned int uiNodeId_p, 106 - tEplIdentuCbResponse pfnCbResponse_p); 107 + tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p, 108 + tEplIdentuCbResponse 109 + pfnCbResponse_p); 107 110 108 - #endif // #ifndef _EPLIDENTU_H_ 109 - 110 - 111 + #endif // #ifndef _EPLIDENTU_H_

+8 -15

drivers/staging/epl/user/EplLedu.h

··· 66 66 67 67 2008/11/17 d.k.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplLed.h" ··· 75 76 #ifndef _EPLLEDU_H_ 76 77 #define _EPLLEDU_H_ 77 78 78 - 79 79 //--------------------------------------------------------------------------- 80 80 // const defines 81 81 //--------------------------------------------------------------------------- 82 - 83 82 84 83 //--------------------------------------------------------------------------- 85 84 // typedef 86 85 //--------------------------------------------------------------------------- 87 86 88 - 89 - typedef tEplKernel (PUBLIC * tEplLeduStateChangeCallback) ( 90 - tEplLedType LedType_p, BOOL fOn_p); 91 - 87 + typedef tEplKernel(PUBLIC * tEplLeduStateChangeCallback) (tEplLedType LedType_p, 88 + BOOL fOn_p); 92 89 93 90 //--------------------------------------------------------------------------- 94 91 // function prototypes ··· 94 99 95 100 tEplKernel PUBLIC EplLeduInit(tEplLeduStateChangeCallback pfnCbStateChange_p); 96 101 97 - tEplKernel PUBLIC EplLeduAddInstance(tEplLeduStateChangeCallback pfnCbStateChange_p); 102 + tEplKernel PUBLIC EplLeduAddInstance(tEplLeduStateChangeCallback 103 + pfnCbStateChange_p); 98 104 99 105 tEplKernel PUBLIC EplLeduDelInstance(void); 100 106 101 - tEplKernel PUBLIC EplLeduCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p); 107 + tEplKernel PUBLIC EplLeduCbNmtStateChange(tEplEventNmtStateChange 108 + NmtStateChange_p); 102 109 103 - tEplKernel PUBLIC EplLeduProcessEvent( 104 - tEplEvent* pEplEvent_p); 105 - 110 + tEplKernel PUBLIC EplLeduProcessEvent(tEplEvent * pEplEvent_p); 106 111 107 112 #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) 108 113 109 - #endif // #ifndef _EPLLEDU_H_ 110 - 111 - 114 + #endif // #ifndef _EPLLEDU_H_

+7 -11

drivers/staging/epl/user/EplNmtCnu.h

··· 66 66 67 67 2006/06/09 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "EplNmtu.h" ··· 75 76 #ifndef _EPLNMTCNU_H_ 76 77 #define _EPLNMTCNU_H_ 77 78 78 - 79 79 //--------------------------------------------------------------------------- 80 80 // const defines 81 81 //--------------------------------------------------------------------------- 82 82 83 - 84 83 //--------------------------------------------------------------------------- 85 84 // typedef 86 85 //--------------------------------------------------------------------------- 87 - 88 86 89 87 //--------------------------------------------------------------------------- 90 88 // function prototypes ··· 95 99 96 100 EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance(void); 97 101 98 - EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest (unsigned int uiNodeId_p, 99 - tEplNmtCommand NmtCommand_p); 102 + EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p, 103 + tEplNmtCommand 104 + NmtCommand_p); 100 105 101 - EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuRegisterCheckEventCb( 102 - tEplNmtuCheckEventCallback pfnEplNmtCheckEventCb_p); 106 + EPLDLLEXPORT tEplKernel PUBLIC 107 + EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback 108 + pfnEplNmtCheckEventCb_p); 103 109 104 110 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0) 105 111 106 - #endif // #ifndef _EPLNMTCNU_H_ 107 - 108 - 112 + #endif // #ifndef _EPLNMTCNU_H_

+23 -28

drivers/staging/epl/user/EplNmtMnu.h

··· 66 66 67 67 2006/06/09 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "EplNmtu.h" ··· 73 74 #ifndef _EPLNMTMNU_H_ 74 75 #define _EPLNMTMNU_H_ 75 76 76 - 77 77 //--------------------------------------------------------------------------- 78 78 // const defines 79 79 //--------------------------------------------------------------------------- 80 - 81 80 82 81 //--------------------------------------------------------------------------- 83 82 // typedef 84 83 //--------------------------------------------------------------------------- 85 84 86 - typedef tEplKernel (PUBLIC * tEplNmtMnuCbNodeEvent) ( 87 - unsigned int uiNodeId_p, 88 - tEplNmtNodeEvent NodeEvent_p, 89 - tEplNmtState NmtState_p, 90 - WORD wErrorCode_p, 91 - BOOL fMandatory_p); 85 + typedef tEplKernel(PUBLIC * tEplNmtMnuCbNodeEvent) (unsigned int uiNodeId_p, 86 + tEplNmtNodeEvent 87 + NodeEvent_p, 88 + tEplNmtState NmtState_p, 89 + WORD wErrorCode_p, 90 + BOOL fMandatory_p); 92 91 93 - 94 - typedef tEplKernel (PUBLIC * tEplNmtMnuCbBootEvent) ( 95 - tEplNmtBootEvent BootEvent_p, 96 - tEplNmtState NmtState_p, 97 - WORD wErrorCode_p); 98 - 92 + typedef tEplKernel(PUBLIC * 93 + tEplNmtMnuCbBootEvent) (tEplNmtBootEvent BootEvent_p, 94 + tEplNmtState NmtState_p, 95 + WORD wErrorCode_p); 99 96 100 97 //--------------------------------------------------------------------------- 101 98 // function prototypes ··· 100 105 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) 101 106 102 107 tEplKernel EplNmtMnuInit(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p, 103 - tEplNmtMnuCbBootEvent pfnCbBootEvent_p); 108 + tEplNmtMnuCbBootEvent pfnCbBootEvent_p); 104 109 105 110 tEplKernel EplNmtMnuAddInstance(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p, 106 - tEplNmtMnuCbBootEvent pfnCbBootEvent_p); 111 + tEplNmtMnuCbBootEvent pfnCbBootEvent_p); 107 112 108 113 tEplKernel EplNmtMnuDelInstance(void); 109 114 110 - EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent( 111 - tEplEvent* pEvent_p); 115 + EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p); 112 116 113 117 tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p, 114 - tEplNmtCommand NmtCommand_p); 118 + tEplNmtCommand NmtCommand_p); 115 119 116 120 tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p, 117 - tEplNmtNodeCommand NodeCommand_p); 121 + tEplNmtNodeCommand NodeCommand_p); 118 122 119 - tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p); 123 + tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange 124 + NmtStateChange_p); 120 125 121 126 tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p); 122 127 123 - tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int* puiMandatorySlaveCount_p, 124 - unsigned int* puiSignalSlaveCount_p, 125 - WORD* pwFlags_p); 128 + tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int 129 + *puiMandatorySlaveCount_p, 130 + unsigned int 131 + *puiSignalSlaveCount_p, 132 + WORD * pwFlags_p); 126 133 127 134 #endif 128 135 129 - #endif // #ifndef _EPLNMTMNU_H_ 130 - 131 - 136 + #endif // #ifndef _EPLNMTMNU_H_

+46 -52

drivers/staging/epl/user/EplNmtu.h

··· 66 66 67 67 2006/06/09 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplNmt.h" ··· 74 75 #ifndef _EPLNMTU_H_ 75 76 #define _EPLNMTU_H_ 76 77 77 - 78 78 //--------------------------------------------------------------------------- 79 79 // const defines 80 80 //--------------------------------------------------------------------------- 81 - 82 81 83 82 //--------------------------------------------------------------------------- 84 83 // typedef 85 84 //--------------------------------------------------------------------------- 86 85 // nmt commands 87 - typedef enum 88 - { 89 - // requestable ASnd ServiceIds 0x01..0x1F 90 - kEplNmtCmdIdentResponse = 0x01, 91 - kEplNmtCmdStatusResponse = 0x02, 92 - // plain NMT state commands 0x20..0x3F 93 - kEplNmtCmdStartNode = 0x21, 94 - kEplNmtCmdStopNode = 0x22, 95 - kEplNmtCmdEnterPreOperational2 = 0x23, 96 - kEplNmtCmdEnableReadyToOperate = 0x24, 97 - kEplNmtCmdResetNode = 0x28, 98 - kEplNmtCmdResetCommunication = 0x29, 99 - kEplNmtCmdResetConfiguration = 0x2A, 100 - kEplNmtCmdSwReset = 0x2B, 101 - // extended NMT state commands 0x40..0x5F 102 - kEplNmtCmdStartNodeEx = 0x41, 103 - kEplNmtCmdStopNodeEx = 0x42, 104 - kEplNmtCmdEnterPreOperational2Ex = 0x43, 105 - kEplNmtCmdEnableReadyToOperateEx = 0x44, 106 - kEplNmtCmdResetNodeEx = 0x48, 107 - kEplNmtCmdResetCommunicationEx = 0x49, 108 - kEplNmtCmdResetConfigurationEx = 0x4A, 109 - kEplNmtCmdSwResetEx = 0x4B, 110 - // NMT managing commands 0x60..0x7F 111 - kEplNmtCmdNetHostNameSet = 0x62, 112 - kEplNmtCmdFlushArpEntry = 0x63, 113 - // NMT info services 0x80..0xBF 114 - kEplNmtCmdPublishConfiguredCN = 0x80, 115 - kEplNmtCmdPublishActiveCN = 0x90, 116 - kEplNmtCmdPublishPreOperational1 = 0x91, 117 - kEplNmtCmdPublishPreOperational2 = 0x92, 118 - kEplNmtCmdPublishReadyToOperate = 0x93, 119 - kEplNmtCmdPublishOperational = 0x94, 120 - kEplNmtCmdPublishStopped = 0x95, 121 - kEplNmtCmdPublishEmergencyNew = 0xA0, 122 - kEplNmtCmdPublishTime = 0xB0, 86 + typedef enum { 87 + // requestable ASnd ServiceIds 0x01..0x1F 88 + kEplNmtCmdIdentResponse = 0x01, 89 + kEplNmtCmdStatusResponse = 0x02, 90 + // plain NMT state commands 0x20..0x3F 91 + kEplNmtCmdStartNode = 0x21, 92 + kEplNmtCmdStopNode = 0x22, 93 + kEplNmtCmdEnterPreOperational2 = 0x23, 94 + kEplNmtCmdEnableReadyToOperate = 0x24, 95 + kEplNmtCmdResetNode = 0x28, 96 + kEplNmtCmdResetCommunication = 0x29, 97 + kEplNmtCmdResetConfiguration = 0x2A, 98 + kEplNmtCmdSwReset = 0x2B, 99 + // extended NMT state commands 0x40..0x5F 100 + kEplNmtCmdStartNodeEx = 0x41, 101 + kEplNmtCmdStopNodeEx = 0x42, 102 + kEplNmtCmdEnterPreOperational2Ex = 0x43, 103 + kEplNmtCmdEnableReadyToOperateEx = 0x44, 104 + kEplNmtCmdResetNodeEx = 0x48, 105 + kEplNmtCmdResetCommunicationEx = 0x49, 106 + kEplNmtCmdResetConfigurationEx = 0x4A, 107 + kEplNmtCmdSwResetEx = 0x4B, 108 + // NMT managing commands 0x60..0x7F 109 + kEplNmtCmdNetHostNameSet = 0x62, 110 + kEplNmtCmdFlushArpEntry = 0x63, 111 + // NMT info services 0x80..0xBF 112 + kEplNmtCmdPublishConfiguredCN = 0x80, 113 + kEplNmtCmdPublishActiveCN = 0x90, 114 + kEplNmtCmdPublishPreOperational1 = 0x91, 115 + kEplNmtCmdPublishPreOperational2 = 0x92, 116 + kEplNmtCmdPublishReadyToOperate = 0x93, 117 + kEplNmtCmdPublishOperational = 0x94, 118 + kEplNmtCmdPublishStopped = 0x95, 119 + kEplNmtCmdPublishEmergencyNew = 0xA0, 120 + kEplNmtCmdPublishTime = 0xB0, 123 121 124 - kEplNmtCmdInvalidService = 0xFF 125 - 122 + kEplNmtCmdInvalidService = 0xFF 126 123 } tEplNmtCommand; 127 124 128 - typedef tEplKernel (PUBLIC * tEplNmtuStateChangeCallback) ( 129 - tEplEventNmtStateChange NmtStateChange_p); 125 + typedef tEplKernel(PUBLIC * 126 + tEplNmtuStateChangeCallback) (tEplEventNmtStateChange 127 + NmtStateChange_p); 130 128 131 - typedef tEplKernel (PUBLIC * tEplNmtuCheckEventCallback) ( 132 - tEplNmtEvent NmtEvent_p); 129 + typedef tEplKernel(PUBLIC * 130 + tEplNmtuCheckEventCallback) (tEplNmtEvent NmtEvent_p); 133 131 134 132 //--------------------------------------------------------------------------- 135 133 // function prototypes ··· 144 148 145 149 EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState(void); 146 150 147 - EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent( 148 - tEplEvent* pEplEvent_p); 151 + EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p); 149 152 150 - EPLDLLEXPORT tEplKernel PUBLIC EplNmtuRegisterStateChangeCb( 151 - tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p); 153 + EPLDLLEXPORT tEplKernel PUBLIC 154 + EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback 155 + pfnEplNmtStateChangeCb_p); 152 156 153 157 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) 154 158 155 - #endif // #ifndef _EPLNMTU_H_ 156 - 157 - 159 + #endif // #ifndef _EPLNMTU_H_

+1 -7

drivers/staging/epl/user/EplNmtuCal.h

··· 67 67 68 68 2006/06/16 -k.t.: start of the implementation 69 69 70 - 71 70 ****************************************************************************/ 72 71 73 72 #include "EplNmtu.h" ··· 75 76 #ifndef _EPLNMTUCAL_H_ 76 77 #define _EPLNMTUCAL_H_ 77 78 78 - 79 79 //--------------------------------------------------------------------------- 80 80 // const defines 81 81 //--------------------------------------------------------------------------- 82 82 83 - 84 83 //--------------------------------------------------------------------------- 85 84 // typedef 86 85 //--------------------------------------------------------------------------- 87 - 88 86 89 87 //--------------------------------------------------------------------------- 90 88 // function prototypes 91 89 //--------------------------------------------------------------------------- 92 90 EPLDLLEXPORT tEplNmtState PUBLIC EplNmtkCalGetNmtState(void); 93 91 94 - #endif // #ifndef _EPLNMTUCAL_H_ 95 - 96 - 92 + #endif // #ifndef _EPLNMTUCAL_H_

+37 -41

drivers/staging/epl/user/EplObdu.h

··· 66 66 67 67 2006/06/19 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplObd.h" ··· 73 74 #ifndef _EPLOBDU_H_ 74 75 #define _EPLOBDU_H_ 75 76 76 - 77 77 //--------------------------------------------------------------------------- 78 78 // const defines 79 79 //--------------------------------------------------------------------------- 80 80 81 - 82 81 //--------------------------------------------------------------------------- 83 82 // typedef 84 83 //--------------------------------------------------------------------------- 85 - 86 84 87 85 //--------------------------------------------------------------------------- 88 86 // function prototypes ··· 91 95 #error "EPL OBDu module enabled, but OBD_USE_KERNEL == TRUE" 92 96 #endif 93 97 94 - EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry (unsigned int uiIndex_p, 95 - unsigned int uiSubIndex_p, 96 - void * pSrcData_p, 97 - tEplObdSize Size_p); 98 + EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p, 99 + unsigned int uiSubIndex_p, 100 + void *pSrcData_p, 101 + tEplObdSize Size_p); 98 102 99 103 // --------------------------------------------------------------------- 100 - EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry (unsigned int uiIndex_p, 101 - unsigned int uiSubIndex_p, 102 - void * pDstData_p, 103 - tEplObdSize *pSize_p); 104 + EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p, 105 + unsigned int uiSubIndex_p, 106 + void *pDstData_p, 107 + tEplObdSize * pSize_p); 104 108 105 109 // --------------------------------------------------------------------- 106 - EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart (tEplObdPart ObdPart_p, 107 - tEplObdDir Direction_p); 110 + EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p, 111 + tEplObdDir Direction_p); 108 112 109 113 // --------------------------------------------------------------------- 110 - EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar (tEplVarParam MEM* pVarParam_p); 114 + EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p); 111 115 112 116 // --------------------------------------------------------------------- 113 - EPLDLLEXPORT void* PUBLIC EplObduGetObjectDataPtr (unsigned int uiIndex_p, 114 - unsigned int uiSubIndex_p); 117 + EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p, 118 + unsigned int uiSubIndex_p); 115 119 // --------------------------------------------------------------------- 116 - EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd ( 117 - tEplObdEntryPtr pUserOd_p); 120 + EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p); 118 121 119 122 // --------------------------------------------------------------------- 120 - EPLDLLEXPORT void PUBLIC EplObduInitVarEntry (tEplObdVarEntry MEM* pVarEntry_p, 121 - BYTE bType_p, 122 - tEplObdSize ObdSize_p); 123 + EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p, 124 + BYTE bType_p, 125 + tEplObdSize ObdSize_p); 123 126 124 127 // --------------------------------------------------------------------- 125 128 EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p, 126 - unsigned int uiSubIndex_p); 129 + unsigned int uiSubIndex_p); 127 130 128 131 // --------------------------------------------------------------------- 129 132 EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId(void); 130 133 131 134 // --------------------------------------------------------------------- 132 135 EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p, 133 - tEplObdNodeIdType NodeIdType_p); 136 + tEplObdNodeIdType NodeIdType_p); 134 137 // --------------------------------------------------------------------- 135 138 EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p, 136 - unsigned int uiSubIndex_p, 137 - tEplObdAccess* pAccessTyp_p); 139 + unsigned int uiSubIndex_p, 140 + tEplObdAccess * 141 + pAccessTyp_p); 138 142 // --------------------------------------------------------------------- 139 - EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe (unsigned int uiIndex_p, 140 - unsigned int uiSubIndex_p, 141 - void * pDstData_p, 142 - tEplObdSize * pSize_p); 143 + EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p, 144 + unsigned int uiSubIndex_p, 145 + void *pDstData_p, 146 + tEplObdSize * pSize_p); 143 147 // --------------------------------------------------------------------- 144 - EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe (unsigned int uiIndex_p, 145 - unsigned int uiSubIndex_p, 146 - void * pSrcData_p, 147 - tEplObdSize Size_p); 148 + EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p, 149 + unsigned int 150 + uiSubIndex_p, 151 + void *pSrcData_p, 152 + tEplObdSize Size_p); 148 153 149 154 // --------------------------------------------------------------------- 150 - EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry (EPL_MCO_DECL_INSTANCE_PTR_ 151 - unsigned int uiIndex_p, 152 - unsigned int uiSubindex_p, 153 - tEplObdVarEntry MEM** ppVarEntry_p); 155 + EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ 156 + unsigned int uiIndex_p, 157 + unsigned int uiSubindex_p, 158 + tEplObdVarEntry MEM ** 159 + ppVarEntry_p); 154 160 155 161 #elif EPL_OBD_USE_KERNEL != FALSE 156 162 #include "../kernel/EplObdk.h" ··· 189 191 190 192 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) 191 193 192 - #endif // #ifndef _EPLOBDU_H_ 193 - 194 - 194 + #endif // #ifndef _EPLOBDU_H_

+43 -43

drivers/staging/epl/user/EplObduCal.h

··· 67 67 68 68 2006/06/19 k.t.: start of the implementation 69 69 70 - 71 70 ****************************************************************************/ 72 71 73 72 #include "../EplObd.h" ··· 74 75 #ifndef _EPLOBDUCAL_H_ 75 76 #define _EPLOBDUCAL_H_ 76 77 77 - 78 78 //--------------------------------------------------------------------------- 79 79 // const defines 80 80 //--------------------------------------------------------------------------- 81 - 82 81 83 82 //--------------------------------------------------------------------------- 84 83 // typedef 85 84 //--------------------------------------------------------------------------- 86 85 87 - 88 86 //--------------------------------------------------------------------------- 89 87 // function prototypes 90 88 //--------------------------------------------------------------------------- 91 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry ( 92 - unsigned int uiIndex_p, 93 - unsigned int uiSubIndex_p, 94 - void * pSrcData_p, 95 - tEplObdSize Size_p); 89 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p, 90 + unsigned int uiSubIndex_p, 91 + void *pSrcData_p, 92 + tEplObdSize Size_p); 96 93 //--------------------------------------------------------------------------- 97 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry ( 98 - unsigned int uiIndex_p, 99 - unsigned int uiSubIndex_p, 100 - void * pDstData_p, 101 - tEplObdSize *pSize_p); 94 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p, 95 + unsigned int uiSubIndex_p, 96 + void *pDstData_p, 97 + tEplObdSize * pSize_p); 102 98 //--------------------------------------------------------------------------- 103 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart ( 104 - tEplObdPart ObdPart_p, 105 - tEplObdDir Direction_p); 99 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p, 100 + tEplObdDir Direction_p); 106 101 //--------------------------------------------------------------------------- 107 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar (tEplVarParam MEM* pVarParam_p); 102 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM * 103 + pVarParam_p); 108 104 //--------------------------------------------------------------------------- 109 - EPLDLLEXPORT void* PUBLIC EplObduCalGetObjectDataPtr ( unsigned int uiIndex_p, 110 - unsigned int uiSubIndex_p); 105 + EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p, 106 + unsigned int uiSubIndex_p); 111 107 //--------------------------------------------------------------------------- 112 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd (tEplObdEntryPtr pUserOd_p); 108 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr 109 + pUserOd_p); 113 110 //--------------------------------------------------------------------------- 114 - EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry (tEplObdVarEntry MEM* pVarEntry_p, 115 - BYTE bType_p, tEplObdSize ObdSize_p); 111 + EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM * 112 + pVarEntry_p, BYTE bType_p, 113 + tEplObdSize ObdSize_p); 116 114 //--------------------------------------------------------------------------- 117 115 EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p, 118 - unsigned int uiSubIndex_p); 116 + unsigned int 117 + uiSubIndex_p); 119 118 //--------------------------------------------------------------------------- 120 119 EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId(void); 121 120 //--------------------------------------------------------------------------- 122 121 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p, 123 - tEplObdNodeIdType NodeIdType_p); 122 + tEplObdNodeIdType 123 + NodeIdType_p); 124 124 //--------------------------------------------------------------------------- 125 125 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p, 126 - unsigned int uiSubIndex_p, 127 - tEplObdAccess* pAccessTyp_p); 126 + unsigned int 127 + uiSubIndex_p, 128 + tEplObdAccess * 129 + pAccessTyp_p); 128 130 //--------------------------------------------------------------------------- 129 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe (unsigned int uiIndex_p, 130 - unsigned int uiSubIndex_p, 131 - void * pDstData_p, 132 - tEplObdSize * pSize_p); 131 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p, 132 + unsigned int 133 + uiSubIndex_p, 134 + void *pDstData_p, 135 + tEplObdSize * pSize_p); 133 136 //--------------------------------------------------------------------------- 134 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe (unsigned int uiIndex_p, 135 - unsigned int uiSubIndex_p, 136 - void * pSrcData_p, 137 - tEplObdSize Size_p); 137 + EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int 138 + uiIndex_p, 139 + unsigned int 140 + uiSubIndex_p, 141 + void *pSrcData_p, 142 + tEplObdSize Size_p); 138 143 //--------------------------------------------------------------------------- 139 - EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSearchVarEntry (EPL_MCO_DECL_INSTANCE_PTR_ 140 - unsigned int uiIndex_p, 141 - unsigned int uiSubindex_p, 142 - tEplObdVarEntry MEM** ppVarEntry_p); 144 + EPLDLLEXPORT tEplKernel PUBLIC 145 + EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, 146 + unsigned int uiSubindex_p, 147 + tEplObdVarEntry MEM ** ppVarEntry_p); 143 148 144 - 145 - #endif // #ifndef _EPLOBDUCAL_H_ 146 - 147 - 149 + #endif // #ifndef _EPLOBDUCAL_H_

+2 -8

drivers/staging/epl/user/EplPdou.h

··· 65 65 66 66 2006/05/22 d.k.: start of the implementation, version 1.00 67 67 68 - 69 68 ****************************************************************************/ 70 69 71 70 #ifndef _EPL_PDOU_H_ ··· 72 73 73 74 #include "../EplPdo.h" 74 75 75 - 76 76 //--------------------------------------------------------------------------- 77 77 // const defines 78 78 //--------------------------------------------------------------------------- 79 79 80 - 81 80 //--------------------------------------------------------------------------- 82 81 // typedef 83 82 //--------------------------------------------------------------------------- 84 - 85 83 86 84 //--------------------------------------------------------------------------- 87 85 // function prototypes ··· 89 93 tEplKernel EplPdouDelInstance(void); 90 94 91 95 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOU)) != 0) 92 - tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM* pParam_p); 96 + tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p); 93 97 #else 94 98 #define EplPdouCbObdAccess NULL 95 99 #endif ··· 105 109 tEplPdoMapping * pMapping_p, BYTE * pbMaxEntries_p); 106 110 */ 107 111 108 - #endif // #ifndef _EPL_PDOU_H_ 109 - 110 - 112 + #endif // #ifndef _EPL_PDOU_H_

+6 -12

drivers/staging/epl/user/EplSdoAsndu.h

··· 66 66 67 67 2006/07/07 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplSdo.h" ··· 74 75 #ifndef _EPLSDOASNDU_H_ 75 76 #define _EPLSDOASNDU_H_ 76 77 77 - 78 78 //--------------------------------------------------------------------------- 79 79 // const defines 80 80 //--------------------------------------------------------------------------- 81 81 82 - 83 82 //--------------------------------------------------------------------------- 84 83 // typedef 85 84 //--------------------------------------------------------------------------- 86 - 87 85 88 86 //--------------------------------------------------------------------------- 89 87 // function prototypes ··· 93 97 94 98 tEplKernel PUBLIC EplSdoAsnduDelInstance(void); 95 99 96 - tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl* pSdoConHandle_p, 97 - unsigned int uiTargetNodeId_p); 100 + tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p, 101 + unsigned int uiTargetNodeId_p); 98 102 99 - tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p, 100 - tEplFrame * pSrcData_p, 101 - DWORD dwDataSize_p); 103 + tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p, 104 + tEplFrame * pSrcData_p, 105 + DWORD dwDataSize_p); 102 106 103 107 tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p); 104 108 105 109 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0) 106 110 107 - #endif // #ifndef _EPLSDOASNDU_H_ 108 - 109 - 111 + #endif // #ifndef _EPLSDOASNDU_H_

+10 -22

drivers/staging/epl/user/EplSdoAsySequ.h

··· 66 66 67 67 2006/06/26 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplSdo.h" ··· 77 78 #ifndef _EPLSDOASYSEQU_H_ 78 79 #define _EPLSDOASYSEQU_H_ 79 80 80 - 81 81 //--------------------------------------------------------------------------- 82 82 // const defines 83 83 //--------------------------------------------------------------------------- 84 - 85 84 86 85 //--------------------------------------------------------------------------- 87 86 // typedef 88 87 //--------------------------------------------------------------------------- 89 88 90 - 91 89 //--------------------------------------------------------------------------- 92 90 // function prototypes 93 91 //--------------------------------------------------------------------------- 94 92 tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p, 95 - tEplSdoComConCb fpSdoComConCb_p); 93 + tEplSdoComConCb fpSdoComConCb_p); 96 94 97 - tEplKernel PUBLIC EplSdoAsySeqAddInstance (tEplSdoComReceiveCb fpSdoComCb_p, 98 - tEplSdoComConCb fpSdoComConCb_p); 95 + tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p, 96 + tEplSdoComConCb fpSdoComConCb_p); 99 97 100 98 tEplKernel PUBLIC EplSdoAsySeqDelInstance(void); 101 99 102 - tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl* pSdoSeqConHdl_p, 103 - unsigned int uiNodeId_p, 104 - tEplSdoType SdoType); 100 + tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p, 101 + unsigned int uiNodeId_p, 102 + tEplSdoType SdoType); 105 103 106 104 tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p, 107 - unsigned int uiDataSize_p, 108 - tEplFrame* pData_p ); 105 + unsigned int uiDataSize_p, 106 + tEplFrame * pData_p); 109 107 110 - tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent* pEvent_p); 108 + tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p); 111 109 112 110 tEplKernel PUBLIC EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p); 113 111 114 - 115 - 116 - 117 - 118 - 119 - 120 - #endif // #ifndef _EPLSDOASYSEQU_H_ 121 - 122 - 112 + #endif // #ifndef _EPLSDOASYSEQU_H_

+9 -18

drivers/staging/epl/user/EplSdoComu.h

··· 66 66 67 67 2006/06/26 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplSdo.h" ··· 77 78 #ifndef _EPLSDOCOMU_H_ 78 79 #define _EPLSDOCOMU_H_ 79 80 80 - 81 81 //--------------------------------------------------------------------------- 82 82 // const defines 83 83 //--------------------------------------------------------------------------- 84 84 85 - 86 85 //--------------------------------------------------------------------------- 87 86 // typedef 88 87 //--------------------------------------------------------------------------- 89 - 90 88 91 89 //--------------------------------------------------------------------------- 92 90 // function prototypes ··· 96 100 97 101 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) 98 102 99 - tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl* pSdoComConHdl_p, 100 - unsigned int uiTargetNodeId_p, 101 - tEplSdoType ProtType_p); 103 + tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p, 104 + unsigned int uiTargetNodeId_p, 105 + tEplSdoType ProtType_p); 102 106 103 - tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex* pSdoComTransParam_p); 107 + tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex * 108 + pSdoComTransParam_p); 104 109 105 - tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p); 110 + tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p); 106 111 107 112 tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p, 108 - tEplSdoComFinished* pSdoComFinished_p); 113 + tEplSdoComFinished * pSdoComFinished_p); 109 114 110 115 tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p, 111 - DWORD dwAbortCode_p); 116 + DWORD dwAbortCode_p); 112 117 113 118 #endif 114 119 ··· 123 126 124 127 */ 125 128 126 - 127 - 128 - 129 - 130 - #endif // #ifndef _EPLSDOCOMU_H_ 131 - 132 - 129 + #endif // #ifndef _EPLSDOCOMU_H_

+8 -13

drivers/staging/epl/user/EplSdoUdpu.h

··· 66 66 67 67 2006/06/26 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 - 72 70 73 71 #include "../EplSdo.h" 74 72 ··· 77 79 // const defines 78 80 //--------------------------------------------------------------------------- 79 81 80 - 81 82 //--------------------------------------------------------------------------- 82 83 // typedef 83 84 //--------------------------------------------------------------------------- 84 - 85 85 86 86 //--------------------------------------------------------------------------- 87 87 // function prototypes ··· 92 96 93 97 tEplKernel PUBLIC EplSdoUdpuDelInstance(void); 94 98 95 - tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p, unsigned int uiPort_p); 99 + tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p, 100 + unsigned int uiPort_p); 96 101 97 - tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl* pSdoConHandle_p, 98 - unsigned int uiTargetNodeId_p); 102 + tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p, 103 + unsigned int uiTargetNodeId_p); 99 104 100 - tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p, 101 - tEplFrame * pSrcData_p, 102 - DWORD dwDataSize_p); 105 + tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p, 106 + tEplFrame * pSrcData_p, 107 + DWORD dwDataSize_p); 103 108 104 109 tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p); 105 110 106 111 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0) 107 112 108 - #endif // #ifndef _EPLSDOUDPU_H_ 109 - 110 - 113 + #endif // #ifndef _EPLSDOUDPU_H_

+7 -12

drivers/staging/epl/user/EplStatusu.h

··· 66 66 67 67 2006/11/15 d.k.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplDll.h" ··· 73 74 #ifndef _EPLSTATUSU_H_ 74 75 #define _EPLSTATUSU_H_ 75 76 76 - 77 77 //--------------------------------------------------------------------------- 78 78 // const defines 79 79 //--------------------------------------------------------------------------- 80 - 81 80 82 81 //--------------------------------------------------------------------------- 83 82 // typedef 84 83 //--------------------------------------------------------------------------- 85 84 86 - typedef tEplKernel (PUBLIC * tEplStatusuCbResponse) ( 87 - unsigned int uiNodeId_p, 88 - tEplStatusResponse* pStatusResponse_p); 85 + typedef tEplKernel(PUBLIC * tEplStatusuCbResponse) (unsigned int uiNodeId_p, 86 + tEplStatusResponse * 87 + pStatusResponse_p); 89 88 90 89 //--------------------------------------------------------------------------- 91 90 // function prototypes ··· 97 100 98 101 tEplKernel PUBLIC EplStatusuReset(void); 99 102 100 - tEplKernel PUBLIC EplStatusuRequestStatusResponse( 101 - unsigned int uiNodeId_p, 102 - tEplStatusuCbResponse pfnCbResponse_p); 103 + tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p, 104 + tEplStatusuCbResponse 105 + pfnCbResponse_p); 103 106 104 - #endif // #ifndef _EPLSTATUSU_H_ 105 - 106 - 107 + #endif // #ifndef _EPLSTATUSU_H_

+8 -14

drivers/staging/epl/user/EplTimeru.h

··· 66 66 67 67 2006/07/06 k.t.: start of the implementation 68 68 69 - 70 69 ****************************************************************************/ 71 70 72 71 #include "../EplTimer.h" ··· 74 75 #ifndef _EPLTIMERU_H_ 75 76 #define _EPLTIMERU_H_ 76 77 77 - 78 78 //--------------------------------------------------------------------------- 79 79 // const defines 80 80 //--------------------------------------------------------------------------- 81 81 82 - 83 82 //--------------------------------------------------------------------------- 84 83 // typedef 85 84 //--------------------------------------------------------------------------- 86 - 87 85 88 86 //--------------------------------------------------------------------------- 89 87 // function prototypes ··· 92 96 93 97 tEplKernel PUBLIC EplTimeruDelInstance(void); 94 98 95 - tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl* pTimerHdl_p, 96 - unsigned long ulTime_p, 97 - tEplTimerArg Argument_p); 99 + tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p, 100 + unsigned long ulTime_p, 101 + tEplTimerArg Argument_p); 98 102 99 - tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl* pTimerHdl_p, 100 - unsigned long ulTime_p, 101 - tEplTimerArg Argument_p); 103 + tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p, 104 + unsigned long ulTime_p, 105 + tEplTimerArg Argument_p); 102 106 103 - tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl* pTimerHdl_p); 107 + tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p); 104 108 105 109 BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p); 106 110 107 - #endif // #ifndef _EPLTIMERU_H_ 108 - 109 - 111 + #endif // #ifndef _EPLTIMERU_H_