?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HID: fix bus endianity in file2alias
[linux-2.6/mini2440.git] / drivers / staging / epl / EplDllk.c
blob9e22641055c61cd7066410603c73d74e99d198fa
1 /****************************************************************************
2
3 (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
4 www.systec-electronic.com
5
6 Project: openPOWERLINK
7
8 Description: source file for kernel DLL module
9
10 License:
11
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions
14 are met:
15
16 1. Redistributions of source code must retain the above copyright
17 notice, this list of conditions and the following disclaimer.
18
19 2. Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in the
21 documentation and/or other materials provided with the distribution.
22
23 3. Neither the name of SYSTEC electronic GmbH nor the names of its
24 contributors may be used to endorse or promote products derived
25 from this software without prior written permission. For written
26 permission, please contact info@systec-electronic.com.
27
28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
31 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
32 COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
33 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
34 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
35 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
36 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
38 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39 POSSIBILITY OF SUCH DAMAGE.
40
41 Severability Clause:
42
43 If a provision of this License is or becomes illegal, invalid or
44 unenforceable in any jurisdiction, that shall not affect:
45 1. the validity or enforceability in that jurisdiction of any other
46 provision of this License; or
47 2. the validity or enforceability in other jurisdictions of that or
48 any other provision of this License.
49
50 -------------------------------------------------------------------------
51
52 $RCSfile: EplDllk.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.21 $ $Date: 2008/11/13 17:13:09 $
57
58 $State: Exp $
59
60 Build Environment:
61 GCC V3.4
62
63 -------------------------------------------------------------------------
64
65 Revision History:
66
67 2006/06/12 d.k.: start of the implementation, version 1.00
68
69 ****************************************************************************/
70
71 #include "kernel/EplDllk.h"
72 #include "kernel/EplDllkCal.h"
73 #include "kernel/EplEventk.h"
74 #include "kernel/EplNmtk.h"
75 #include "edrv.h"
76 #include "Benchmark.h"
77
78 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
79 #include "kernel/EplPdok.h"
80 #endif
81
82 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
83 #include "kernel/VirtualEthernet.h"
84 #endif
85
86 //#if EPL_TIMER_USE_HIGHRES != FALSE
87 #include "kernel/EplTimerHighResk.h"
88 //#endif
89
90 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
91
92 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) == 0)
93 #error "EPL module DLLK needs EPL module NMTK!"
94 #endif
95
96 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) && (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
97 #error "EPL module DLLK: select only one of EPL_DLL_PRES_READY_AFTER_SOA and EPL_DLL_PRES_READY_AFTER_SOC."
98 #endif
99
100 #if ((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)) \
101 && (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) == 0)
102 #error "EPL module DLLK: currently, EPL_DLL_PRES_READY_AFTER_* is not supported if EPL_MODULE_NMT_MN is enabled."
103 #endif
104
105 #if (EDRV_FAST_TXFRAMES == FALSE) && \
106 ((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE))
107 #error "EPL module DLLK: EPL_DLL_PRES_READY_AFTER_* is enabled, but not EDRV_FAST_TXFRAMES."
108 #endif
109
110 /***************************************************************************/
111 /* */
112 /* */
113 /* G L O B A L D E F I N I T I O N S */
114 /* */
115 /* */
116 /***************************************************************************/
117
118 //---------------------------------------------------------------------------
119 // const defines
120 //---------------------------------------------------------------------------
121
122 // TracePoint support for realtime-debugging
123 #ifdef _DBG_TRACE_POINTS_
124 void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
125 void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
126 #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
127 #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
128 #else
129 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
130 #define TGT_DBG_POST_TRACE_VALUE(v)
131 #endif
132 #define EPL_DLLK_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
133 TGT_DBG_POST_TRACE_VALUE((kEplEventSinkDllk << 28) | (Event_p << 24) \
134 | (uiNodeId_p << 16) | wErrorCode_p)
135
136 /***************************************************************************/
137 /* */
138 /* */
139 /* C L A S S EplDllk */
140 /* */
141 /* */
142 /***************************************************************************/
143 //
144 // Description:
145 //
146 //
147 /***************************************************************************/
148
149 //=========================================================================//
150 // //
151 // P R I V A T E D E F I N I T I O N S //
152 // //
153 //=========================================================================//
154
155 //---------------------------------------------------------------------------
156 // const defines
157 //---------------------------------------------------------------------------
158
159 // defines for indexes of tEplDllInstance.m_pTxFrameInfo
160 #define EPL_DLLK_TXFRAME_IDENTRES 0 // IdentResponse on CN / MN
161 #define EPL_DLLK_TXFRAME_STATUSRES 1 // StatusResponse on CN / MN
162 #define EPL_DLLK_TXFRAME_NMTREQ 2 // NMT Request from FIFO on CN / MN
163 #define EPL_DLLK_TXFRAME_NONEPL 3 // non-EPL frame from FIFO on CN / MN
164 #define EPL_DLLK_TXFRAME_PRES 4 // PRes on CN / MN
165 #define EPL_DLLK_TXFRAME_SOC 5 // SoC on MN
166 #define EPL_DLLK_TXFRAME_SOA 6 // SoA on MN
167 #define EPL_DLLK_TXFRAME_PREQ 7 // PReq on MN
168 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
169 #define EPL_DLLK_TXFRAME_COUNT (7 + EPL_D_NMT_MaxCNNumber_U8 + 2) // on MN: 7 + MaxPReq of regular CNs + 1 Diag + 1 Router
170 #else
171 #define EPL_DLLK_TXFRAME_COUNT 5 // on CN: 5
172 #endif
173
174 #define EPL_DLLK_BUFLEN_EMPTY 0 // buffer is empty
175 #define EPL_DLLK_BUFLEN_FILLING 1 // just the buffer is being filled
176 #define EPL_DLLK_BUFLEN_MIN 60 // minimum ethernet frame length
177
178 //---------------------------------------------------------------------------
179 // local types
180 //---------------------------------------------------------------------------
181
182 typedef enum {
183 kEplDllGsInit = 0x00, // MN/CN: initialisation (< PreOp2)
184 kEplDllCsWaitPreq = 0x01, // CN: wait for PReq frame
185 kEplDllCsWaitSoc = 0x02, // CN: wait for SoC frame
186 kEplDllCsWaitSoa = 0x03, // CN: wait for SoA frame
187 kEplDllMsNonCyclic = 0x04, // MN: reduced EPL cycle (PreOp1)
188 kEplDllMsWaitSocTrig = 0x05, // MN: wait for SoC trigger (cycle timer)
189 kEplDllMsWaitPreqTrig = 0x06, // MN: wait for (first) PReq trigger (WaitSoCPReq_U32)
190 kEplDllMsWaitPres = 0x07, // MN: wait for PRes frame from CN
191 kEplDllMsWaitSoaTrig = 0x08, // MN: wait for SoA trigger (PRes transmitted)
192 kEplDllMsWaitAsndTrig = 0x09, // MN: wait for ASnd trigger (SoA transmitted)
193 kEplDllMsWaitAsnd = 0x0A, // MN: wait for ASnd frame if SoA contained invitation
194
195 } tEplDllState;
196
197 typedef struct {
198 BYTE m_be_abSrcMac[6];
199 tEdrvTxBuffer *m_pTxBuffer; // Buffers for Tx-Frames
200 unsigned int m_uiMaxTxFrames;
201 BYTE m_bFlag1; // Flag 1 with EN, EC for PRes, StatusRes
202 BYTE m_bMnFlag1; // Flag 1 with EA, ER from PReq, SoA of MN
203 BYTE m_bFlag2; // Flag 2 with PR and RS for PRes, StatusRes, IdentRes
204 tEplDllConfigParam m_DllConfigParam;
205 tEplDllIdentParam m_DllIdentParam;
206 tEplDllState m_DllState;
207 tEplDllkCbAsync m_pfnCbAsync;
208 tEplDllAsndFilter m_aAsndFilter[EPL_DLL_MAX_ASND_SERVICE_ID];
209
210 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
211 tEplDllkNodeInfo *m_pFirstNodeInfo;
212 tEplDllkNodeInfo *m_pCurNodeInfo;
213 tEplDllkNodeInfo m_aNodeInfo[EPL_NMT_MAX_NODE_ID];
214 tEplDllReqServiceId m_LastReqServiceId;
215 unsigned int m_uiLastTargetNodeId;
216 #endif
217
218 #if EPL_TIMER_USE_HIGHRES != FALSE
219 tEplTimerHdl m_TimerHdlCycle; // used for EPL cycle monitoring on CN and generation on MN
220 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
221 tEplTimerHdl m_TimerHdlResponse; // used for CN response monitoring
222 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
223 #endif
224
225 unsigned int m_uiCycleCount; // cycle counter (needed for multiplexed cycle support)
226 unsigned long long m_ullFrameTimeout; // frame timeout (cycle length + loss of frame tolerance)
227
228 } tEplDllkInstance;
229
230 //---------------------------------------------------------------------------
231 // local vars
232 //---------------------------------------------------------------------------
233
234 // if no dynamic memory allocation shall be used
235 // define structures statically
236 static tEplDllkInstance EplDllkInstance_g;
237
238 static tEdrvTxBuffer aEplDllkTxBuffer_l[EPL_DLLK_TXFRAME_COUNT];
239
240 //---------------------------------------------------------------------------
241 // local function prototypes
242 //---------------------------------------------------------------------------
243
244 // change DLL state on event
245 static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p,
246 tEplNmtState NmtState_p);
247
248 // called from EdrvInterruptHandler()
249 static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p);
250
251 // called from EdrvInterruptHandler()
252 static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p);
253
254 // check frame and set missing information
255 static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
256 unsigned int uiFrameSize_p);
257
258 // called by high resolution timer module to monitor EPL cycle as CN
259 #if EPL_TIMER_USE_HIGHRES != FALSE
260 static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p);
261 #endif
262
263 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
264 // MN: returns internal node info structure
265 static tEplDllkNodeInfo *EplDllkGetNodeInfo(unsigned int uiNodeId_p);
266
267 // transmit SoA
268 static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
269 tEplDllState * pDllStateProposed_p,
270 BOOL fEnableInvitation_p);
271
272 static tEplKernel EplDllkMnSendSoc(void);
273
274 static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
275 tEplDllState * pDllStateProposed_p);
276
277 static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
278 ReqServiceId_p,
279 unsigned int uiNodeId_p);
280
281 static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p);
282
283 static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg *
284 pEventArg_p);
285
286 #endif
287
288 //=========================================================================//
289 // //
290 // P U B L I C F U N C T I O N S //
291 // //
292 //=========================================================================//
293
294 //---------------------------------------------------------------------------
295 //
296 // Function: EplDllkAddInstance()
297 //
298 // Description: add and initialize new instance of EPL stack
299 //
300 // Parameters: pInitParam_p = initialisation parameters like MAC address
301 //
302 // Returns: tEplKernel = error code
303 //
304 //
305 // State:
306 //
307 //---------------------------------------------------------------------------
308
309 tEplKernel EplDllkAddInstance(tEplDllkInitParam * pInitParam_p)
310 {
311 tEplKernel Ret = kEplSuccessful;
312 unsigned int uiIndex;
313 tEdrvInitParam EdrvInitParam;
314
315 // reset instance structure
316 EPL_MEMSET(&EplDllkInstance_g, 0, sizeof(EplDllkInstance_g));
317
318 #if EPL_TIMER_USE_HIGHRES != FALSE
319 Ret = EplTimerHighReskInit();
320 if (Ret != kEplSuccessful) { // error occured while initializing high resolution timer module
321 goto Exit;
322 }
323 #endif
324
325 // if dynamic memory allocation available
326 // allocate instance structure
327 // allocate TPDO and RPDO table with default size
328
329 // initialize and link pointers in instance structure to frame tables
330 EplDllkInstance_g.m_pTxBuffer = aEplDllkTxBuffer_l;
331 EplDllkInstance_g.m_uiMaxTxFrames =
332 sizeof(aEplDllkTxBuffer_l) / sizeof(tEdrvTxBuffer);
333
334 // initialize state
335 EplDllkInstance_g.m_DllState = kEplDllGsInit;
336
337 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
338 // set up node info structure
339 for (uiIndex = 0; uiIndex < tabentries(EplDllkInstance_g.m_aNodeInfo);
340 uiIndex++) {
341 EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
342 EplDllkInstance_g.m_aNodeInfo[uiIndex].m_wPresPayloadLimit =
343 0xFFFF;
344 }
345 #endif
346
347 // initialize Edrv
348 EPL_MEMCPY(EdrvInitParam.m_abMyMacAddr, pInitParam_p->m_be_abSrcMac, 6);
349 EdrvInitParam.m_pfnRxHandler = EplDllkCbFrameReceived;
350 EdrvInitParam.m_pfnTxHandler = EplDllkCbFrameTransmitted;
351 Ret = EdrvInit(&EdrvInitParam);
352 if (Ret != kEplSuccessful) { // error occured while initializing ethernet driver
353 goto Exit;
354 }
355 // copy local MAC address from Ethernet driver back to local instance structure
356 // because Ethernet driver may have read it from controller EEPROM
357 EPL_MEMCPY(EplDllkInstance_g.m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr,
358 6);
359 EPL_MEMCPY(pInitParam_p->m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr, 6);
360
361 // initialize TxBuffer array
362 for (uiIndex = 0; uiIndex < EplDllkInstance_g.m_uiMaxTxFrames;
363 uiIndex++) {
364 EplDllkInstance_g.m_pTxBuffer[uiIndex].m_pbBuffer = NULL;
365 }
366
367 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
368 Ret = VEthAddInstance(pInitParam_p);
369 #endif
370
371 Exit:
372 return Ret;
373 }
374
375 //---------------------------------------------------------------------------
376 //
377 // Function: EplDllkDelInstance()
378 //
379 // Description: deletes an instance of EPL stack
380 //
381 // Parameters: (none)
382 //
383 // Returns: tEplKernel = error code
384 //
385 //
386 // State:
387 //
388 //---------------------------------------------------------------------------
389
390 tEplKernel EplDllkDelInstance(void)
391 {
392 tEplKernel Ret = kEplSuccessful;
393
394 // reset state
395 EplDllkInstance_g.m_DllState = kEplDllGsInit;
396
397 #if EPL_TIMER_USE_HIGHRES != FALSE
398 Ret = EplTimerHighReskDelInstance();
399 #endif
400
401 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
402 Ret = VEthDelInstance();
403 #endif
404
405 Ret = EdrvShutdown();
406 return Ret;
407 }
408
409 //---------------------------------------------------------------------------
410 //
411 // Function: EplDllkCreateTxFrame
412 //
413 // Description: creates the buffer for a Tx frame and registers it to the
414 // ethernet driver
415 //
416 // Parameters: puiHandle_p = OUT: handle to frame buffer
417 // ppFrame_p = OUT: pointer to pointer of EPL frame
418 // puiFrameSize_p = IN/OUT: pointer to size of frame
419 // returned size is always equal or larger than
420 // requested size, if that is not possible
421 // an error will be returned
422 // MsgType_p = EPL message type
423 // ServiceId_p = Service ID in case of ASnd frame, otherwise
424 // kEplDllAsndNotDefined
425 //
426 // Returns: tEplKernel = error code
427 //
428 //
429 // State:
430 //
431 //---------------------------------------------------------------------------
432
433 tEplKernel EplDllkCreateTxFrame(unsigned int *puiHandle_p,
434 tEplFrame ** ppFrame_p,
435 unsigned int *puiFrameSize_p,
436 tEplMsgType MsgType_p,
437 tEplDllAsndServiceId ServiceId_p)
438 {
439 tEplKernel Ret = kEplSuccessful;
440 tEplFrame *pTxFrame;
441 unsigned int uiHandle = EplDllkInstance_g.m_uiMaxTxFrames;
442 tEdrvTxBuffer *pTxBuffer = NULL;
443
444 if (MsgType_p == kEplMsgTypeAsnd) {
445 // search for fixed Tx buffers
446 if (ServiceId_p == kEplDllAsndIdentResponse) {
447 uiHandle = EPL_DLLK_TXFRAME_IDENTRES;
448 } else if (ServiceId_p == kEplDllAsndStatusResponse) {
449 uiHandle = EPL_DLLK_TXFRAME_STATUSRES;
450 } else if ((ServiceId_p == kEplDllAsndNmtRequest)
451 || (ServiceId_p == kEplDllAsndNmtCommand)) {
452 uiHandle = EPL_DLLK_TXFRAME_NMTREQ;
453 }
454
455 if (uiHandle >= EplDllkInstance_g.m_uiMaxTxFrames) { // look for free entry
456 uiHandle = EPL_DLLK_TXFRAME_PREQ;
457 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
458 for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames;
459 uiHandle++, pTxBuffer++) {
460 if (pTxBuffer->m_pbBuffer == NULL) { // free entry found
461 break;
462 }
463 }
464 }
465 } else if (MsgType_p == kEplMsgTypeNonEpl) {
466 uiHandle = EPL_DLLK_TXFRAME_NONEPL;
467 } else if (MsgType_p == kEplMsgTypePres) {
468 uiHandle = EPL_DLLK_TXFRAME_PRES;
469 } else if (MsgType_p == kEplMsgTypeSoc) {
470 uiHandle = EPL_DLLK_TXFRAME_SOC;
471 } else if (MsgType_p == kEplMsgTypeSoa) {
472 uiHandle = EPL_DLLK_TXFRAME_SOA;
473 } else { // look for free entry
474 uiHandle = EPL_DLLK_TXFRAME_PREQ;
475 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
476 for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames;
477 uiHandle++, pTxBuffer++) {
478 if (pTxBuffer->m_pbBuffer == NULL) { // free entry found
479 break;
480 }
481 }
482 if (pTxBuffer->m_pbBuffer != NULL) {
483 Ret = kEplEdrvNoFreeBufEntry;
484 goto Exit;
485 }
486 }
487
488 // test if requested entry is free
489 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
490 if (pTxBuffer->m_pbBuffer != NULL) { // entry is not free
491 Ret = kEplEdrvNoFreeBufEntry;
492 goto Exit;
493 }
494 // setup Tx buffer
495 pTxBuffer->m_EplMsgType = MsgType_p;
496 pTxBuffer->m_uiMaxBufferLen = *puiFrameSize_p;
497
498 Ret = EdrvAllocTxMsgBuffer(pTxBuffer);
499 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
500 goto Exit;
501 }
502 // because buffer size may be larger than requested
503 // memorize real length of frame
504 pTxBuffer->m_uiTxMsgLen = *puiFrameSize_p;
505
506 // fill whole frame with 0
507 EPL_MEMSET(pTxBuffer->m_pbBuffer, 0, pTxBuffer->m_uiMaxBufferLen);
508
509 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
510
511 if (MsgType_p != kEplMsgTypeNonEpl) { // fill out Frame only if it is an EPL frame
512 // ethertype
513 AmiSetWordToBe(&pTxFrame->m_be_wEtherType,
514 EPL_C_DLL_ETHERTYPE_EPL);
515 // source node ID
516 AmiSetByteToLe(&pTxFrame->m_le_bSrcNodeId,
517 (BYTE) EplDllkInstance_g.m_DllConfigParam.
518 m_uiNodeId);
519 // source MAC address
520 EPL_MEMCPY(&pTxFrame->m_be_abSrcMac[0],
521 &EplDllkInstance_g.m_be_abSrcMac[0], 6);
522 switch (MsgType_p) {
523 case kEplMsgTypeAsnd:
524 // destination MAC address
525 AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
526 EPL_C_DLL_MULTICAST_ASND);
527 // destination node ID
528 switch (ServiceId_p) {
529 case kEplDllAsndIdentResponse:
530 case kEplDllAsndStatusResponse:
531 { // IdentResponses and StatusResponses are Broadcast
532 AmiSetByteToLe(&pTxFrame->
533 m_le_bDstNodeId,
534 (BYTE)
535 EPL_C_ADR_BROADCAST);
536 break;
537 }
538
539 default:
540 break;
541 }
542 // ASnd Service ID
543 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_le_bServiceId,
544 ServiceId_p);
545 break;
546
547 case kEplMsgTypeSoc:
548 // destination MAC address
549 AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
550 EPL_C_DLL_MULTICAST_SOC);
551 // destination node ID
552 AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
553 (BYTE) EPL_C_ADR_BROADCAST);
554 // reset Flags
555 //AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag1, (BYTE) 0);
556 //AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag2, (BYTE) 0);
557 break;
558
559 case kEplMsgTypeSoa:
560 // destination MAC address
561 AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
562 EPL_C_DLL_MULTICAST_SOA);
563 // destination node ID
564 AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
565 (BYTE) EPL_C_ADR_BROADCAST);
566 // reset Flags
567 //AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag1, (BYTE) 0);
568 //AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag2, (BYTE) 0);
569 // EPL profile version
570 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bEplVersion,
571 (BYTE) EPL_SPEC_VERSION);
572 break;
573
574 case kEplMsgTypePres:
575 // destination MAC address
576 AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
577 EPL_C_DLL_MULTICAST_PRES);
578 // destination node ID
579 AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
580 (BYTE) EPL_C_ADR_BROADCAST);
581 // reset Flags
582 //AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, (BYTE) 0);
583 //AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, (BYTE) 0);
584 // PDO size
585 //AmiSetWordToLe(&pTxFrame->m_Data.m_Pres.m_le_wSize, 0);
586 break;
587
588 case kEplMsgTypePreq:
589 // reset Flags
590 //AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, (BYTE) 0);
591 //AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag2, (BYTE) 0);
592 // PDO size
593 //AmiSetWordToLe(&pTxFrame->m_Data.m_Preq.m_le_wSize, 0);
594 break;
595
596 default:
597 break;
598 }
599 // EPL message type
600 AmiSetByteToLe(&pTxFrame->m_le_bMessageType, (BYTE) MsgType_p);
601 }
602
603 *ppFrame_p = pTxFrame;
604 *puiFrameSize_p = pTxBuffer->m_uiMaxBufferLen;
605 *puiHandle_p = uiHandle;
606
607 Exit:
608 return Ret;
609 }
610
611 //---------------------------------------------------------------------------
612 //
613 // Function: EplDllkDeleteTxFrame
614 //
615 // Description: deletes the buffer for a Tx frame and frees it in the
616 // ethernet driver
617 //
618 // Parameters: uiHandle_p = IN: handle to frame buffer
619 //
620 // Returns: tEplKernel = error code
621 //
622 //
623 // State:
624 //
625 //---------------------------------------------------------------------------
626
627 tEplKernel EplDllkDeleteTxFrame(unsigned int uiHandle_p)
628 {
629 tEplKernel Ret = kEplSuccessful;
630 tEdrvTxBuffer *pTxBuffer = NULL;
631
632 if (uiHandle_p >= EplDllkInstance_g.m_uiMaxTxFrames) { // handle is not valid
633 Ret = kEplDllIllegalHdl;
634 goto Exit;
635 }
636
637 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle_p];
638
639 // mark buffer as free so that frame will not be send in future anymore
640 // $$$ d.k. What's up with running transmissions?
641 pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
642 pTxBuffer->m_pbBuffer = NULL;
643
644 // delete Tx buffer
645 Ret = EdrvReleaseTxMsgBuffer(pTxBuffer);
646 if (Ret != kEplSuccessful) { // error occured while releasing Tx frame
647 goto Exit;
648 }
649
650 Exit:
651 return Ret;
652 }
653
654 //---------------------------------------------------------------------------
655 //
656 // Function: EplDllkProcess
657 //
658 // Description: process the passed event
659 //
660 // Parameters: pEvent_p = event to be processed
661 //
662 // Returns: tEplKernel = error code
663 //
664 //
665 // State:
666 //
667 //---------------------------------------------------------------------------
668
669 tEplKernel EplDllkProcess(tEplEvent * pEvent_p)
670 {
671 tEplKernel Ret = kEplSuccessful;
672 tEplFrame *pTxFrame;
673 tEdrvTxBuffer *pTxBuffer;
674 unsigned int uiHandle;
675 unsigned int uiFrameSize;
676 BYTE abMulticastMac[6];
677 tEplDllAsyncReqPriority AsyncReqPriority;
678 unsigned int uiFrameCount;
679 tEplNmtState NmtState;
680 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
681 tEplFrameInfo FrameInfo;
682 #endif
683
684 switch (pEvent_p->m_EventType) {
685 case kEplEventTypeDllkCreate:
686 {
687 // $$$ reset ethernet driver
688
689 NmtState = *((tEplNmtState *) pEvent_p->m_pArg);
690
691 // initialize flags for PRes and StatusRes
692 EplDllkInstance_g.m_bFlag1 = EPL_FRAME_FLAG1_EC;
693 EplDllkInstance_g.m_bMnFlag1 = 0;
694 EplDllkInstance_g.m_bFlag2 = 0;
695
696 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
697 // initialize linked node list
698 EplDllkInstance_g.m_pFirstNodeInfo = NULL;
699 #endif
700
701 // register TxFrames in Edrv
702
703 // IdentResponse
704 uiFrameSize = EPL_C_DLL_MINSIZE_IDENTRES;
705 Ret =
706 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
707 &uiFrameSize, kEplMsgTypeAsnd,
708 kEplDllAsndIdentResponse);
709 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
710 goto Exit;
711 }
712 // EPL profile version
713 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
714 m_IdentResponse.m_le_bEplProfileVersion,
715 (BYTE) EPL_SPEC_VERSION);
716 // FeatureFlags
717 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
718 m_IdentResponse.m_le_dwFeatureFlags,
719 EplDllkInstance_g.m_DllConfigParam.
720 m_dwFeatureFlags);
721 // MTU
722 AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
723 m_IdentResponse.m_le_wMtu,
724 (WORD) EplDllkInstance_g.
725 m_DllConfigParam.m_uiAsyncMtu);
726 // PollInSize
727 AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
728 m_IdentResponse.m_le_wPollInSize,
729 (WORD) EplDllkInstance_g.
730 m_DllConfigParam.
731 m_uiPreqActPayloadLimit);
732 // PollOutSize
733 AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
734 m_IdentResponse.m_le_wPollOutSize,
735 (WORD) EplDllkInstance_g.
736 m_DllConfigParam.
737 m_uiPresActPayloadLimit);
738 // ResponseTime / PresMaxLatency
739 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
740 m_IdentResponse.m_le_dwResponseTime,
741 EplDllkInstance_g.m_DllConfigParam.
742 m_dwPresMaxLatency);
743 // DeviceType
744 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
745 m_IdentResponse.m_le_dwDeviceType,
746 EplDllkInstance_g.m_DllIdentParam.
747 m_dwDeviceType);
748 // VendorId
749 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
750 m_IdentResponse.m_le_dwVendorId,
751 EplDllkInstance_g.m_DllIdentParam.
752 m_dwVendorId);
753 // ProductCode
754 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
755 m_IdentResponse.m_le_dwProductCode,
756 EplDllkInstance_g.m_DllIdentParam.
757 m_dwProductCode);
758 // RevisionNumber
759 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
760 m_IdentResponse.m_le_dwRevisionNumber,
761 EplDllkInstance_g.m_DllIdentParam.
762 m_dwRevisionNumber);
763 // SerialNumber
764 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
765 m_IdentResponse.m_le_dwSerialNumber,
766 EplDllkInstance_g.m_DllIdentParam.
767 m_dwSerialNumber);
768 // VendorSpecificExt1
769 AmiSetQword64ToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
770 m_IdentResponse.
771 m_le_qwVendorSpecificExt1,
772 EplDllkInstance_g.m_DllIdentParam.
773 m_qwVendorSpecificExt1);
774 // VerifyConfigurationDate
775 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
776 m_IdentResponse.
777 m_le_dwVerifyConfigurationDate,
778 EplDllkInstance_g.m_DllIdentParam.
779 m_dwVerifyConfigurationDate);
780 // VerifyConfigurationTime
781 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
782 m_IdentResponse.
783 m_le_dwVerifyConfigurationTime,
784 EplDllkInstance_g.m_DllIdentParam.
785 m_dwVerifyConfigurationTime);
786 // ApplicationSwDate
787 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
788 m_IdentResponse.
789 m_le_dwApplicationSwDate,
790 EplDllkInstance_g.m_DllIdentParam.
791 m_dwApplicationSwDate);
792 // ApplicationSwTime
793 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
794 m_IdentResponse.
795 m_le_dwApplicationSwTime,
796 EplDllkInstance_g.m_DllIdentParam.
797 m_dwApplicationSwTime);
798 // IPAddress
799 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
800 m_IdentResponse.m_le_dwIpAddress,
801 EplDllkInstance_g.m_DllIdentParam.
802 m_dwIpAddress);
803 // SubnetMask
804 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
805 m_IdentResponse.m_le_dwSubnetMask,
806 EplDllkInstance_g.m_DllIdentParam.
807 m_dwSubnetMask);
808 // DefaultGateway
809 AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
810 m_IdentResponse.m_le_dwDefaultGateway,
811 EplDllkInstance_g.m_DllIdentParam.
812 m_dwDefaultGateway);
813 // HostName
814 EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.
815 m_IdentResponse.m_le_sHostname[0],
816 &EplDllkInstance_g.m_DllIdentParam.
817 m_sHostname[0],
818 sizeof(EplDllkInstance_g.m_DllIdentParam.
819 m_sHostname));
820 // VendorSpecificExt2
821 EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.
822 m_IdentResponse.m_le_abVendorSpecificExt2[0],
823 &EplDllkInstance_g.m_DllIdentParam.
824 m_abVendorSpecificExt2[0],
825 sizeof(EplDllkInstance_g.m_DllIdentParam.
826 m_abVendorSpecificExt2));
827
828 // StatusResponse
829 uiFrameSize = EPL_C_DLL_MINSIZE_STATUSRES;
830 Ret =
831 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
832 &uiFrameSize, kEplMsgTypeAsnd,
833 kEplDllAsndStatusResponse);
834 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
835 goto Exit;
836 }
837 // PRes $$$ maybe move this to PDO module
838 if ((EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly ==
839 FALSE)
840 && (EplDllkInstance_g.m_DllConfigParam.m_uiPresActPayloadLimit >= 36)) { // it is not configured as async-only CN,
841 // so take part in isochronous phase and register PRes frame
842 uiFrameSize =
843 EplDllkInstance_g.m_DllConfigParam.
844 m_uiPresActPayloadLimit + 24;
845 Ret =
846 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
847 &uiFrameSize,
848 kEplMsgTypePres,
849 kEplDllAsndNotDefined);
850 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
851 goto Exit;
852 }
853 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
854 // initially encode TPDO -> inform PDO module
855 FrameInfo.m_pFrame = pTxFrame;
856 FrameInfo.m_uiFrameSize = uiFrameSize;
857 Ret = EplPdokCbPdoTransmitted(&FrameInfo);
858 #endif
859 // reset cycle counter
860 EplDllkInstance_g.m_uiCycleCount = 0;
861 } else { // it is an async-only CN
862 // fool EplDllkChangeState() to think that PRes was not expected
863 EplDllkInstance_g.m_uiCycleCount = 1;
864 }
865
866 // NMT request
867 uiFrameSize = EPL_C_IP_MAX_MTU;
868 Ret =
869 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
870 &uiFrameSize, kEplMsgTypeAsnd,
871 kEplDllAsndNmtRequest);
872 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
873 goto Exit;
874 }
875 // mark Tx buffer as empty
876 EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen =
877 EPL_DLLK_BUFLEN_EMPTY;
878
879 // non-EPL frame
880 uiFrameSize = EPL_C_IP_MAX_MTU;
881 Ret =
882 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
883 &uiFrameSize,
884 kEplMsgTypeNonEpl,
885 kEplDllAsndNotDefined);
886 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
887 goto Exit;
888 }
889 // mark Tx buffer as empty
890 EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen =
891 EPL_DLLK_BUFLEN_EMPTY;
892
893 // register multicast MACs in ethernet driver
894 AmiSetQword48ToBe(&abMulticastMac[0],
895 EPL_C_DLL_MULTICAST_SOC);
896 Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
897 AmiSetQword48ToBe(&abMulticastMac[0],
898 EPL_C_DLL_MULTICAST_SOA);
899 Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
900 AmiSetQword48ToBe(&abMulticastMac[0],
901 EPL_C_DLL_MULTICAST_PRES);
902 Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
903 AmiSetQword48ToBe(&abMulticastMac[0],
904 EPL_C_DLL_MULTICAST_ASND);
905 Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
906
907 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
908 if (NmtState >= kEplNmtMsNotActive) { // local node is MN
909 unsigned int uiIndex;
910
911 // SoC
912 uiFrameSize = EPL_C_DLL_MINSIZE_SOC;
913 Ret =
914 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
915 &uiFrameSize,
916 kEplMsgTypeSoc,
917 kEplDllAsndNotDefined);
918 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
919 goto Exit;
920 }
921 // SoA
922 uiFrameSize = EPL_C_DLL_MINSIZE_SOA;
923 Ret =
924 EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
925 &uiFrameSize,
926 kEplMsgTypeSoa,
927 kEplDllAsndNotDefined);
928 if (Ret != kEplSuccessful) { // error occured while registering Tx frame
929 goto Exit;
930 }
931
932 for (uiIndex = 0;
933 uiIndex <
934 tabentries(EplDllkInstance_g.m_aNodeInfo);
935 uiIndex++) {
936 // EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
937 EplDllkInstance_g.m_aNodeInfo[uiIndex].
938 m_wPresPayloadLimit =
939 (WORD) EplDllkInstance_g.
940 m_DllConfigParam.
941 m_uiIsochrRxMaxPayload;
942 }
943
944 // calculate cycle length
945 EplDllkInstance_g.m_ullFrameTimeout = 1000LL
946 *
947 ((unsigned long long)EplDllkInstance_g.
948 m_DllConfigParam.m_dwCycleLen);
949 }
950 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
951
952 Ret = EplDllkCalAsyncClearBuffer();
953
954 break;
955 }
956
957 case kEplEventTypeDllkDestroy:
958 {
959 // destroy all data structures
960
961 NmtState = *((tEplNmtState *) pEvent_p->m_pArg);
962
963 // delete Tx frames
964 Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_IDENTRES);
965 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
966 goto Exit;
967 }
968
969 Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_STATUSRES);
970 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
971 goto Exit;
972 }
973
974 Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_PRES);
975 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
976 goto Exit;
977 }
978
979 Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NMTREQ);
980 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
981 goto Exit;
982 }
983
984 Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NONEPL);
985 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
986 goto Exit;
987 }
988 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
989 if (NmtState >= kEplNmtMsNotActive) { // local node was MN
990 unsigned int uiIndex;
991
992 Ret =
993 EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOC);
994 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
995 goto Exit;
996 }
997
998 Ret =
999 EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOA);
1000 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
1001 goto Exit;
1002 }
1003
1004 for (uiIndex = 0;
1005 uiIndex <
1006 tabentries(EplDllkInstance_g.m_aNodeInfo);
1007 uiIndex++) {
1008 if (EplDllkInstance_g.
1009 m_aNodeInfo[uiIndex].
1010 m_pPreqTxBuffer != NULL) {
1011 uiHandle =
1012 EplDllkInstance_g.
1013 m_aNodeInfo[uiIndex].
1014 m_pPreqTxBuffer -
1015 EplDllkInstance_g.
1016 m_pTxBuffer;
1017 EplDllkInstance_g.
1018 m_aNodeInfo[uiIndex].
1019 m_pPreqTxBuffer = NULL;
1020 Ret =
1021 EplDllkDeleteTxFrame
1022 (uiHandle);
1023 if (Ret != kEplSuccessful) { // error occured while deregistering Tx frame
1024 goto Exit;
1025 }
1026
1027 }
1028 EplDllkInstance_g.m_aNodeInfo[uiIndex].
1029 m_wPresPayloadLimit = 0xFFFF;
1030 }
1031 }
1032 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1033
1034 // deregister multicast MACs in ethernet driver
1035 AmiSetQword48ToBe(&abMulticastMac[0],
1036 EPL_C_DLL_MULTICAST_SOC);
1037 Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1038 AmiSetQword48ToBe(&abMulticastMac[0],
1039 EPL_C_DLL_MULTICAST_SOA);
1040 Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1041 AmiSetQword48ToBe(&abMulticastMac[0],
1042 EPL_C_DLL_MULTICAST_PRES);
1043 Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1044 AmiSetQword48ToBe(&abMulticastMac[0],
1045 EPL_C_DLL_MULTICAST_ASND);
1046 Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1047
1048 // delete timer
1049 #if EPL_TIMER_USE_HIGHRES != FALSE
1050 Ret =
1051 EplTimerHighReskDeleteTimer(&EplDllkInstance_g.
1052 m_TimerHdlCycle);
1053 #endif
1054
1055 break;
1056 }
1057
1058 case kEplEventTypeDllkFillTx:
1059 {
1060 // fill TxBuffer of specified priority with new frame if empty
1061
1062 pTxFrame = NULL;
1063 AsyncReqPriority =
1064 *((tEplDllAsyncReqPriority *) pEvent_p->m_pArg);
1065 switch (AsyncReqPriority) {
1066 case kEplDllAsyncReqPrioNmt: // NMT request priority
1067 {
1068 pTxBuffer =
1069 &EplDllkInstance_g.
1070 m_pTxBuffer
1071 [EPL_DLLK_TXFRAME_NMTREQ];
1072 if (pTxBuffer->m_pbBuffer != NULL) { // NmtRequest does exist
1073 // check if frame is empty and not being filled
1074 if (pTxBuffer->m_uiTxMsgLen ==
1075 EPL_DLLK_BUFLEN_EMPTY) {
1076 // mark Tx buffer as filling is in process
1077 pTxBuffer->
1078 m_uiTxMsgLen =
1079 EPL_DLLK_BUFLEN_FILLING;
1080 // set max buffer size as input parameter
1081 uiFrameSize =
1082 pTxBuffer->
1083 m_uiMaxBufferLen;
1084 // copy frame from shared loop buffer to Tx buffer
1085 Ret =
1086 EplDllkCalAsyncGetTxFrame
1087 (pTxBuffer->
1088 m_pbBuffer,
1089 &uiFrameSize,
1090 AsyncReqPriority);
1091 if (Ret ==
1092 kEplSuccessful) {
1093 pTxFrame =
1094 (tEplFrame
1095 *)
1096 pTxBuffer->
1097 m_pbBuffer;
1098 Ret =
1099 EplDllkCheckFrame
1100 (pTxFrame,
1101 uiFrameSize);
1102
1103 // set buffer valid
1104 pTxBuffer->
1105 m_uiTxMsgLen
1106 =
1107 uiFrameSize;
1108 } else if (Ret == kEplDllAsyncTxBufferEmpty) { // empty Tx buffer is not a real problem
1109 // so just ignore it
1110 Ret =
1111 kEplSuccessful;
1112 // mark Tx buffer as empty
1113 pTxBuffer->
1114 m_uiTxMsgLen
1115 =
1116 EPL_DLLK_BUFLEN_EMPTY;
1117 }
1118 }
1119 }
1120 break;
1121 }
1122
1123 default: // generic priority
1124 {
1125 pTxBuffer =
1126 &EplDllkInstance_g.
1127 m_pTxBuffer
1128 [EPL_DLLK_TXFRAME_NONEPL];
1129 if (pTxBuffer->m_pbBuffer != NULL) { // non-EPL frame does exist
1130 // check if frame is empty and not being filled
1131 if (pTxBuffer->m_uiTxMsgLen ==
1132 EPL_DLLK_BUFLEN_EMPTY) {
1133 // mark Tx buffer as filling is in process
1134 pTxBuffer->
1135 m_uiTxMsgLen =
1136 EPL_DLLK_BUFLEN_FILLING;
1137 // set max buffer size as input parameter
1138 uiFrameSize =
1139 pTxBuffer->
1140 m_uiMaxBufferLen;
1141 // copy frame from shared loop buffer to Tx buffer
1142 Ret =
1143 EplDllkCalAsyncGetTxFrame
1144 (pTxBuffer->
1145 m_pbBuffer,
1146 &uiFrameSize,
1147 AsyncReqPriority);
1148 if (Ret ==
1149 kEplSuccessful) {
1150 pTxFrame =
1151 (tEplFrame
1152 *)
1153 pTxBuffer->
1154 m_pbBuffer;
1155 Ret =
1156 EplDllkCheckFrame
1157 (pTxFrame,
1158 uiFrameSize);
1159
1160 // set buffer valid
1161 pTxBuffer->
1162 m_uiTxMsgLen
1163 =
1164 uiFrameSize;
1165 } else if (Ret == kEplDllAsyncTxBufferEmpty) { // empty Tx buffer is not a real problem
1166 // so just ignore it
1167 Ret =
1168 kEplSuccessful;
1169 // mark Tx buffer as empty
1170 pTxBuffer->
1171 m_uiTxMsgLen
1172 =
1173 EPL_DLLK_BUFLEN_EMPTY;
1174 }
1175 }
1176 }
1177 break;
1178 }
1179 }
1180
1181 NmtState = EplNmtkGetNmtState();
1182
1183 if ((NmtState == kEplNmtCsBasicEthernet) || (NmtState == kEplNmtMsBasicEthernet)) { // send frame immediately
1184 if (pTxFrame != NULL) { // frame is present
1185 // padding is done by Edrv or ethernet controller
1186 Ret = EdrvSendTxMsg(pTxBuffer);
1187 } else { // no frame moved to TxBuffer
1188 // check if TxBuffers contain unsent frames
1189 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) { // NMT request Tx buffer contains a frame
1190 Ret =
1191 EdrvSendTxMsg
1192 (&EplDllkInstance_g.
1193 m_pTxBuffer
1194 [EPL_DLLK_TXFRAME_NMTREQ]);
1195 } else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) { // non-EPL Tx buffer contains a frame
1196 Ret =
1197 EdrvSendTxMsg
1198 (&EplDllkInstance_g.
1199 m_pTxBuffer
1200 [EPL_DLLK_TXFRAME_NONEPL]);
1201 }
1202 if (Ret == kEplInvalidOperation) { // ignore error if caused by already active transmission
1203 Ret = kEplSuccessful;
1204 }
1205 }
1206 // reset PRes flag 2
1207 EplDllkInstance_g.m_bFlag2 = 0;
1208 } else {
1209 // update Flag 2 (PR, RS)
1210 Ret =
1211 EplDllkCalAsyncGetTxCount(&AsyncReqPriority,
1212 &uiFrameCount);
1213 if (AsyncReqPriority == kEplDllAsyncReqPrioNmt) { // non-empty FIFO with hightest priority is for NMT requests
1214 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) { // NMT request Tx buffer contains a frame
1215 // add one more frame
1216 uiFrameCount++;
1217 }
1218 } else { // non-empty FIFO with highest priority is for generic frames
1219 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) { // NMT request Tx buffer contains a frame
1220 // use NMT request FIFO, because of higher priority
1221 uiFrameCount = 1;
1222 AsyncReqPriority =
1223 kEplDllAsyncReqPrioNmt;
1224 } else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) { // non-EPL Tx buffer contains a frame
1225 // use NMT request FIFO, because of higher priority
1226 // add one more frame
1227 uiFrameCount++;
1228 }
1229 }
1230
1231 if (uiFrameCount > 7) { // limit frame request to send counter to 7
1232 uiFrameCount = 7;
1233 }
1234 if (uiFrameCount > 0) {
1235 EplDllkInstance_g.m_bFlag2 =
1236 (BYTE) (((AsyncReqPriority <<
1237 EPL_FRAME_FLAG2_PR_SHIFT)
1238 & EPL_FRAME_FLAG2_PR)
1239 | (uiFrameCount &
1240 EPL_FRAME_FLAG2_RS));
1241 } else {
1242 EplDllkInstance_g.m_bFlag2 = 0;
1243 }
1244 }
1245
1246 break;
1247 }
1248
1249 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1250 case kEplEventTypeDllkStartReducedCycle:
1251 {
1252 // start the reduced cycle by programming the cycle timer
1253 // it is issued by NMT MN module, when PreOp1 is entered
1254
1255 // clear the asynchronous queues
1256 Ret = EplDllkCalAsyncClearQueues();
1257
1258 // reset cycle counter (everytime a SoA is triggerd in PreOp1 the counter is incremented
1259 // and when it reaches EPL_C_DLL_PREOP1_START_CYCLES the SoA may contain invitations)
1260 EplDllkInstance_g.m_uiCycleCount = 0;
1261
1262 // remove any CN from isochronous phase
1263 while (EplDllkInstance_g.m_pFirstNodeInfo != NULL) {
1264 EplDllkDeleteNode(EplDllkInstance_g.
1265 m_pFirstNodeInfo->m_uiNodeId);
1266 }
1267
1268 // change state to NonCyclic,
1269 // hence EplDllkChangeState() will not ignore the next call
1270 EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
1271
1272 #if EPL_TIMER_USE_HIGHRES != FALSE
1273 if (EplDllkInstance_g.m_DllConfigParam.
1274 m_dwAsyncSlotTimeout != 0) {
1275 Ret =
1276 EplTimerHighReskModifyTimerNs
1277 (&EplDllkInstance_g.m_TimerHdlCycle,
1278 EplDllkInstance_g.m_DllConfigParam.
1279 m_dwAsyncSlotTimeout,
1280 EplDllkCbMnTimerCycle, 0L, FALSE);
1281 }
1282 #endif
1283
1284 break;
1285 }
1286 #endif
1287
1288 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
1289 case kEplEventTypeDllkPresReady:
1290 {
1291 // post PRes to transmit FIFO
1292
1293 NmtState = EplNmtkGetNmtState();
1294
1295 if (NmtState != kEplNmtCsBasicEthernet) {
1296 // Does PRes exist?
1297 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].m_pbBuffer != NULL) { // PRes does exist
1298 pTxFrame =
1299 (tEplFrame *) EplDllkInstance_g.
1300 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].
1301 m_pbBuffer;
1302 // update frame (NMT state, RD, RS, PR, MS, EN flags)
1303 if (NmtState < kEplNmtCsPreOperational2) { // NMT state is not PreOp2, ReadyToOp or Op
1304 // fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
1305 NmtState =
1306 kEplNmtCsPreOperational2;
1307 }
1308 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
1309 m_le_bNmtStatus,
1310 (BYTE) NmtState);
1311 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
1312 m_le_bFlag2,
1313 EplDllkInstance_g.
1314 m_bFlag2);
1315 if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
1316 // $$$ reset only RD flag; set other flags appropriately
1317 AmiSetByteToLe(&pTxFrame->
1318 m_Data.m_Pres.
1319 m_le_bFlag1, 0);
1320 }
1321 // $$$ make function that updates Pres, StatusRes
1322 // mark PRes frame as ready for transmission
1323 Ret =
1324 EdrvTxMsgReady(&EplDllkInstance_g.
1325 m_pTxBuffer
1326 [EPL_DLLK_TXFRAME_PRES]);
1327 }
1328 }
1329
1330 break;
1331 }
1332 #endif
1333 default:
1334 {
1335 ASSERTMSG(FALSE,
1336 "EplDllkProcess(): unhandled event type!\n");
1337 }
1338 }
1339
1340 Exit:
1341 return Ret;
1342 }
1343
1344 //---------------------------------------------------------------------------
1345 //
1346 // Function: EplDllkConfig
1347 //
1348 // Description: configure parameters of DLL
1349 //
1350 // Parameters: pDllConfigParam_p = configuration parameters
1351 //
1352 // Returns: tEplKernel = error code
1353 //
1354 //
1355 // State:
1356 //
1357 //---------------------------------------------------------------------------
1358
1359 tEplKernel EplDllkConfig(tEplDllConfigParam * pDllConfigParam_p)
1360 {
1361 tEplKernel Ret = kEplSuccessful;
1362
1363 // d.k. check of NMT state disabled, because CycleLen is programmed at run time by MN without reset of CN
1364 /*tEplNmtState NmtState;
1365
1366 NmtState = EplNmtkGetNmtState();
1367
1368 if (NmtState > kEplNmtGsResetConfiguration)
1369 { // only allowed in state DLL_GS_INIT
1370 Ret = kEplInvalidOperation;
1371 goto Exit;
1372 }
1373 */
1374 EPL_MEMCPY(&EplDllkInstance_g.m_DllConfigParam, pDllConfigParam_p,
1375 (pDllConfigParam_p->m_uiSizeOfStruct <
1376 sizeof(tEplDllConfigParam) ? pDllConfigParam_p->
1377 m_uiSizeOfStruct : sizeof(tEplDllConfigParam)));
1378
1379 if ((EplDllkInstance_g.m_DllConfigParam.m_dwCycleLen != 0)
1380 && (EplDllkInstance_g.m_DllConfigParam.m_dwLossOfFrameTolerance != 0)) { // monitor EPL cycle, calculate frame timeout
1381 EplDllkInstance_g.m_ullFrameTimeout = (1000LL
1382 *
1383 ((unsigned long long)
1384 EplDllkInstance_g.
1385 m_DllConfigParam.
1386 m_dwCycleLen))
1387 +
1388 ((unsigned long long)EplDllkInstance_g.m_DllConfigParam.
1389 m_dwLossOfFrameTolerance);
1390 } else {
1391 EplDllkInstance_g.m_ullFrameTimeout = 0LL;
1392 }
1393
1394 if (EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly != FALSE) { // it is configured as async-only CN
1395 // disable multiplexed cycle, that m_uiCycleCount will not be incremented spuriously on SoC
1396 EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt = 0;
1397 }
1398 //Exit:
1399 return Ret;
1400 }
1401
1402 //---------------------------------------------------------------------------
1403 //
1404 // Function: EplDllkSetIdentity
1405 //
1406 // Description: configure identity of local node for IdentResponse
1407 //
1408 // Parameters: pDllIdentParam_p = identity
1409 //
1410 // Returns: tEplKernel = error code
1411 //
1412 //
1413 // State:
1414 //
1415 //---------------------------------------------------------------------------
1416
1417 tEplKernel EplDllkSetIdentity(tEplDllIdentParam * pDllIdentParam_p)
1418 {
1419 tEplKernel Ret = kEplSuccessful;
1420
1421 EPL_MEMCPY(&EplDllkInstance_g.m_DllIdentParam, pDllIdentParam_p,
1422 (pDllIdentParam_p->m_uiSizeOfStruct <
1423 sizeof(tEplDllIdentParam) ? pDllIdentParam_p->
1424 m_uiSizeOfStruct : sizeof(tEplDllIdentParam)));
1425
1426 // $$$ if IdentResponse frame exists update it
1427
1428 return Ret;
1429 }
1430
1431 //---------------------------------------------------------------------------
1432 //
1433 // Function: EplDllkRegAsyncHandler
1434 //
1435 // Description: registers handler for non-EPL frames
1436 //
1437 // Parameters: pfnDllkCbAsync_p = pointer to callback function
1438 //
1439 // Returns: tEplKernel = error code
1440 //
1441 //
1442 // State:
1443 //
1444 //---------------------------------------------------------------------------
1445
1446 tEplKernel EplDllkRegAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
1447 {
1448 tEplKernel Ret = kEplSuccessful;
1449
1450 if (EplDllkInstance_g.m_pfnCbAsync == NULL) { // no handler registered yet
1451 EplDllkInstance_g.m_pfnCbAsync = pfnDllkCbAsync_p;
1452 } else { // handler already registered
1453 Ret = kEplDllCbAsyncRegistered;
1454 }
1455
1456 return Ret;
1457 }
1458
1459 //---------------------------------------------------------------------------
1460 //
1461 // Function: EplDllkDeregAsyncHandler
1462 //
1463 // Description: deregisters handler for non-EPL frames
1464 //
1465 // Parameters: pfnDllkCbAsync_p = pointer to callback function
1466 //
1467 // Returns: tEplKernel = error code
1468 //
1469 //
1470 // State:
1471 //
1472 //---------------------------------------------------------------------------
1473
1474 tEplKernel EplDllkDeregAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
1475 {
1476 tEplKernel Ret = kEplSuccessful;
1477
1478 if (EplDllkInstance_g.m_pfnCbAsync == pfnDllkCbAsync_p) { // same handler is registered
1479 // deregister it
1480 EplDllkInstance_g.m_pfnCbAsync = NULL;
1481 } else { // wrong handler or no handler registered
1482 Ret = kEplDllCbAsyncRegistered;
1483 }
1484
1485 return Ret;
1486 }
1487
1488 //---------------------------------------------------------------------------
1489 //
1490 // Function: EplDllkSetAsndServiceIdFilter()
1491 //
1492 // Description: sets the specified node ID filter for the specified
1493 // AsndServiceId. It registers C_DLL_MULTICAST_ASND in ethernet
1494 // driver if any AsndServiceId is open.
1495 //
1496 // Parameters: ServiceId_p = ASnd Service ID
1497 // Filter_p = node ID filter
1498 //
1499 // Returns: tEplKernel = error code
1500 //
1501 //
1502 // State:
1503 //
1504 //---------------------------------------------------------------------------
1505
1506 tEplKernel EplDllkSetAsndServiceIdFilter(tEplDllAsndServiceId ServiceId_p,
1507 tEplDllAsndFilter Filter_p)
1508 {
1509 tEplKernel Ret = kEplSuccessful;
1510
1511 if (ServiceId_p < tabentries(EplDllkInstance_g.m_aAsndFilter)) {
1512 EplDllkInstance_g.m_aAsndFilter[ServiceId_p] = Filter_p;
1513 }
1514
1515 return Ret;
1516 }
1517
1518 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1519
1520 //---------------------------------------------------------------------------
1521 //
1522 // Function: EplDllkSetFlag1OfNode()
1523 //
1524 // Description: sets Flag1 (for PReq and SoA) of the specified node ID.
1525 //
1526 // Parameters: uiNodeId_p = node ID
1527 // bSoaFlag1_p = flag1
1528 //
1529 // Returns: tEplKernel = error code
1530 //
1531 //
1532 // State:
1533 //
1534 //---------------------------------------------------------------------------
1535
1536 tEplKernel EplDllkSetFlag1OfNode(unsigned int uiNodeId_p, BYTE bSoaFlag1_p)
1537 {
1538 tEplKernel Ret = kEplSuccessful;
1539 tEplDllkNodeInfo *pNodeInfo;
1540
1541 pNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1542 if (pNodeInfo == NULL) { // no node info structure available
1543 Ret = kEplDllNoNodeInfo;
1544 goto Exit;
1545 }
1546 // store flag1 in internal node info structure
1547 pNodeInfo->m_bSoaFlag1 = bSoaFlag1_p;
1548
1549 Exit:
1550 return Ret;
1551 }
1552
1553 //---------------------------------------------------------------------------
1554 //
1555 // Function: EplDllkGetFirstNodeInfo()
1556 //
1557 // Description: returns first info structure of first node in isochronous phase.
1558 // It is only useful for ErrorHandlerk module.
1559 //
1560 // Parameters: ppNodeInfo_p = pointer to pointer of internal node info structure
1561 //
1562 // Returns: tEplKernel = error code
1563 //
1564 //
1565 // State:
1566 //
1567 //---------------------------------------------------------------------------
1568
1569 tEplKernel EplDllkGetFirstNodeInfo(tEplDllkNodeInfo ** ppNodeInfo_p)
1570 {
1571 tEplKernel Ret = kEplSuccessful;
1572
1573 *ppNodeInfo_p = EplDllkInstance_g.m_pFirstNodeInfo;
1574
1575 return Ret;
1576 }
1577
1578 //---------------------------------------------------------------------------
1579 //
1580 // Function: EplDllkAddNode()
1581 //
1582 // Description: adds the specified node to the isochronous phase.
1583 //
1584 // Parameters: pNodeInfo_p = pointer of node info structure
1585 //
1586 // Returns: tEplKernel = error code
1587 //
1588 //
1589 // State:
1590 //
1591 //---------------------------------------------------------------------------
1592
1593 tEplKernel EplDllkAddNode(tEplDllNodeInfo * pNodeInfo_p)
1594 {
1595 tEplKernel Ret = kEplSuccessful;
1596 tEplDllkNodeInfo *pIntNodeInfo;
1597 tEplDllkNodeInfo **ppIntNodeInfo;
1598 unsigned int uiHandle;
1599 tEplFrame *pFrame;
1600 unsigned int uiFrameSize;
1601
1602 pIntNodeInfo = EplDllkGetNodeInfo(pNodeInfo_p->m_uiNodeId);
1603 if (pIntNodeInfo == NULL) { // no node info structure available
1604 Ret = kEplDllNoNodeInfo;
1605 goto Exit;
1606 }
1607
1608 EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkAddNode,
1609 pNodeInfo_p->m_uiNodeId, 0);
1610
1611 // copy node configuration
1612 pIntNodeInfo->m_dwPresTimeout = pNodeInfo_p->m_dwPresTimeout;
1613 pIntNodeInfo->m_wPresPayloadLimit = pNodeInfo_p->m_wPresPayloadLimit;
1614
1615 // $$$ d.k.: actually add node only if MN. On CN it is sufficient to update the node configuration
1616 if (pNodeInfo_p->m_uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) { // we shall send PRes ourself
1617 // insert our node at the end of the list
1618 ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1619 while ((*ppIntNodeInfo != NULL)
1620 && ((*ppIntNodeInfo)->m_pNextNodeInfo != NULL)) {
1621 ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1622 }
1623 if (*ppIntNodeInfo != NULL) {
1624 if ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId) { // node was already added to list
1625 // $$$ d.k. maybe this should be an error
1626 goto Exit;
1627 } else { // add our node at the end of the list
1628 ppIntNodeInfo =
1629 &(*ppIntNodeInfo)->m_pNextNodeInfo;
1630 }
1631 }
1632 // set "PReq"-TxBuffer to PRes-TxBuffer
1633 pIntNodeInfo->m_pPreqTxBuffer =
1634 &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
1635 } else { // normal CN shall be added to isochronous phase
1636 // insert node into list in ascending order
1637 ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1638 while ((*ppIntNodeInfo != NULL)
1639 && ((*ppIntNodeInfo)->m_uiNodeId <
1640 pNodeInfo_p->m_uiNodeId)
1641 && ((*ppIntNodeInfo)->m_uiNodeId !=
1642 EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)) {
1643 ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1644 }
1645 if ((*ppIntNodeInfo != NULL) && ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId)) { // node was already added to list
1646 // $$$ d.k. maybe this should be an error
1647 goto Exit;
1648 }
1649 }
1650
1651 // initialize elements of internal node info structure
1652 pIntNodeInfo->m_bSoaFlag1 = 0;
1653 pIntNodeInfo->m_fSoftDelete = FALSE;
1654 pIntNodeInfo->m_NmtState = kEplNmtCsNotActive;
1655 if (pIntNodeInfo->m_pPreqTxBuffer == NULL) { // create TxBuffer entry
1656 uiFrameSize = pNodeInfo_p->m_wPreqPayloadLimit + 24;
1657 Ret =
1658 EplDllkCreateTxFrame(&uiHandle, &pFrame, &uiFrameSize,
1659 kEplMsgTypePreq,
1660 kEplDllAsndNotDefined);
1661 if (Ret != kEplSuccessful) {
1662 goto Exit;
1663 }
1664 pIntNodeInfo->m_pPreqTxBuffer =
1665 &EplDllkInstance_g.m_pTxBuffer[uiHandle];
1666 AmiSetByteToLe(&pFrame->m_le_bDstNodeId,
1667 (BYTE) pNodeInfo_p->m_uiNodeId);
1668
1669 // set up destination MAC address
1670 EPL_MEMCPY(pFrame->m_be_abDstMac, pIntNodeInfo->m_be_abMacAddr,
1671 6);
1672
1673 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
1674 {
1675 tEplFrameInfo FrameInfo;
1676
1677 // initially encode TPDO -> inform PDO module
1678 FrameInfo.m_pFrame = pFrame;
1679 FrameInfo.m_uiFrameSize = uiFrameSize;
1680 Ret = EplPdokCbPdoTransmitted(&FrameInfo);
1681 }
1682 #endif
1683 }
1684 pIntNodeInfo->m_ulDllErrorEvents = 0L;
1685 // add node to list
1686 pIntNodeInfo->m_pNextNodeInfo = *ppIntNodeInfo;
1687 *ppIntNodeInfo = pIntNodeInfo;
1688
1689 Exit:
1690 return Ret;
1691 }
1692
1693 //---------------------------------------------------------------------------
1694 //
1695 // Function: EplDllkDeleteNode()
1696 //
1697 // Description: removes the specified node from the isochronous phase.
1698 //
1699 // Parameters: uiNodeId_p = node ID
1700 //
1701 // Returns: tEplKernel = error code
1702 //
1703 //
1704 // State:
1705 //
1706 //---------------------------------------------------------------------------
1707
1708 tEplKernel EplDllkDeleteNode(unsigned int uiNodeId_p)
1709 {
1710 tEplKernel Ret = kEplSuccessful;
1711 tEplDllkNodeInfo *pIntNodeInfo;
1712 tEplDllkNodeInfo **ppIntNodeInfo;
1713 unsigned int uiHandle;
1714
1715 pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1716 if (pIntNodeInfo == NULL) { // no node info structure available
1717 Ret = kEplDllNoNodeInfo;
1718 goto Exit;
1719 }
1720
1721 EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkDelNode, uiNodeId_p, 0);
1722
1723 // search node in whole list
1724 ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1725 while ((*ppIntNodeInfo != NULL)
1726 && ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p)) {
1727 ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1728 }
1729 if ((*ppIntNodeInfo == NULL) || ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p)) { // node was not found in list
1730 // $$$ d.k. maybe this should be an error
1731 goto Exit;
1732 }
1733 // remove node from list
1734 *ppIntNodeInfo = pIntNodeInfo->m_pNextNodeInfo;
1735
1736 if ((pIntNodeInfo->m_pPreqTxBuffer != NULL)
1737 && (pIntNodeInfo->m_pPreqTxBuffer != &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES])) { // delete TxBuffer entry
1738 uiHandle =
1739 pIntNodeInfo->m_pPreqTxBuffer -
1740 EplDllkInstance_g.m_pTxBuffer;
1741 pIntNodeInfo->m_pPreqTxBuffer = NULL;
1742 Ret = EplDllkDeleteTxFrame(uiHandle);
1743 /* if (Ret != kEplSuccessful)
1744 {
1745 goto Exit;
1746 }*/
1747 }
1748
1749 Exit:
1750 return Ret;
1751 }
1752
1753 //---------------------------------------------------------------------------
1754 //
1755 // Function: EplDllkSoftDeleteNode()
1756 //
1757 // Description: removes the specified node not immediately from the isochronous phase.
1758 // Instead the will be removed after error (late/loss PRes) without
1759 // charging the error.
1760 //
1761 // Parameters: uiNodeId_p = node ID
1762 //
1763 // Returns: tEplKernel = error code
1764 //
1765 //
1766 // State:
1767 //
1768 //---------------------------------------------------------------------------
1769
1770 tEplKernel EplDllkSoftDeleteNode(unsigned int uiNodeId_p)
1771 {
1772 tEplKernel Ret = kEplSuccessful;
1773 tEplDllkNodeInfo *pIntNodeInfo;
1774
1775 pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1776 if (pIntNodeInfo == NULL) { // no node info structure available
1777 Ret = kEplDllNoNodeInfo;
1778 goto Exit;
1779 }
1780
1781 EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkSoftDelNode,
1782 uiNodeId_p, 0);
1783
1784 pIntNodeInfo->m_fSoftDelete = TRUE;
1785
1786 Exit:
1787 return Ret;
1788 }
1789
1790 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1791
1792 //=========================================================================//
1793 // //
1794 // P R I V A T E F U N C T I O N S //
1795 // //
1796 //=========================================================================//
1797
1798 //---------------------------------------------------------------------------
1799 //
1800 // Function: EplDllkChangeState
1801 //
1802 // Description: change DLL state on event and diagnose some communication errors
1803 //
1804 // Parameters: NmtEvent_p = DLL event (wrapped in NMT event)
1805 //
1806 // Returns: tEplKernel = error code
1807 //
1808 //
1809 // State:
1810 //
1811 //---------------------------------------------------------------------------
1812
1813 static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p,
1814 tEplNmtState NmtState_p)
1815 {
1816 tEplKernel Ret = kEplSuccessful;
1817 tEplEvent Event;
1818 tEplErrorHandlerkEvent DllEvent;
1819
1820 DllEvent.m_ulDllErrorEvents = 0;
1821 DllEvent.m_uiNodeId = 0;
1822 DllEvent.m_NmtState = NmtState_p;
1823
1824 switch (NmtState_p) {
1825 case kEplNmtGsOff:
1826 case kEplNmtGsInitialising:
1827 case kEplNmtGsResetApplication:
1828 case kEplNmtGsResetCommunication:
1829 case kEplNmtGsResetConfiguration:
1830 case kEplNmtCsBasicEthernet:
1831 // enter DLL_GS_INIT
1832 EplDllkInstance_g.m_DllState = kEplDllGsInit;
1833 break;
1834
1835 case kEplNmtCsNotActive:
1836 case kEplNmtCsPreOperational1:
1837 // reduced EPL cycle is active
1838 if (NmtEvent_p == kEplNmtEventDllCeSoc) { // SoC received
1839 // enter DLL_CS_WAIT_PREQ
1840 EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
1841 } else {
1842 // enter DLL_GS_INIT
1843 EplDllkInstance_g.m_DllState = kEplDllGsInit;
1844 }
1845 break;
1846
1847 case kEplNmtCsPreOperational2:
1848 case kEplNmtCsReadyToOperate:
1849 case kEplNmtCsOperational:
1850 // full EPL cycle is active
1851
1852 switch (EplDllkInstance_g.m_DllState) {
1853 case kEplDllCsWaitPreq:
1854 switch (NmtEvent_p) {
1855 // DLL_CT2
1856 case kEplNmtEventDllCePreq:
1857 // enter DLL_CS_WAIT_SOA
1858 DllEvent.m_ulDllErrorEvents |=
1859 EPL_DLL_ERR_CN_RECVD_PREQ;
1860 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
1861 break;
1862
1863 // DLL_CT8
1864 case kEplNmtEventDllCeFrameTimeout:
1865 if (NmtState_p == kEplNmtCsPreOperational2) { // ignore frame timeout in PreOp2,
1866 // because the previously configured cycle len
1867 // may be wrong.
1868 // 2008/10/15 d.k. If it would not be ignored,
1869 // we would go cyclically to PreOp1 and on next
1870 // SoC back to PreOp2.
1871 break;
1872 }
1873 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
1874 DllEvent.m_ulDllErrorEvents |=
1875 EPL_DLL_ERR_CN_LOSS_SOA |
1876 EPL_DLL_ERR_CN_LOSS_SOC;
1877
1878 // enter DLL_CS_WAIT_SOC
1879 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1880 break;
1881
1882 case kEplNmtEventDllCeSoa:
1883 // check if multiplexed and PReq should have been received in this cycle
1884 // and if >= NMT_CS_READY_TO_OPERATE
1885 if ((EplDllkInstance_g.m_uiCycleCount == 0)
1886 && (NmtState_p >= kEplNmtCsReadyToOperate)) { // report DLL_CEV_LOSS_OF_PREQ
1887 DllEvent.m_ulDllErrorEvents |=
1888 EPL_DLL_ERR_CN_LOSS_PREQ;
1889 }
1890 // enter DLL_CS_WAIT_SOC
1891 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1892 break;
1893
1894 // DLL_CT7
1895 case kEplNmtEventDllCeSoc:
1896 case kEplNmtEventDllCeAsnd:
1897 // report DLL_CEV_LOSS_SOA
1898 DllEvent.m_ulDllErrorEvents |=
1899 EPL_DLL_ERR_CN_LOSS_SOA;
1900
1901 case kEplNmtEventDllCePres:
1902 default:
1903 // remain in this state
1904 break;
1905 }
1906 break;
1907
1908 case kEplDllCsWaitSoc:
1909 switch (NmtEvent_p) {
1910 // DLL_CT1
1911 case kEplNmtEventDllCeSoc:
1912 // start of cycle and isochronous phase
1913 // enter DLL_CS_WAIT_PREQ
1914 EplDllkInstance_g.m_DllState =
1915 kEplDllCsWaitPreq;
1916 break;
1917
1918 // DLL_CT4
1919 // case kEplNmtEventDllCePres:
1920 case kEplNmtEventDllCeFrameTimeout:
1921 if (NmtState_p == kEplNmtCsPreOperational2) { // ignore frame timeout in PreOp2,
1922 // because the previously configured cycle len
1923 // may be wrong.
1924 // 2008/10/15 d.k. If it would not be ignored,
1925 // we would go cyclically to PreOp1 and on next
1926 // SoC back to PreOp2.
1927 break;
1928 }
1929 // fall through
1930
1931 case kEplNmtEventDllCePreq:
1932 case kEplNmtEventDllCeSoa:
1933 // report DLL_CEV_LOSS_SOC
1934 DllEvent.m_ulDllErrorEvents |=
1935 EPL_DLL_ERR_CN_LOSS_SOC;
1936
1937 case kEplNmtEventDllCeAsnd:
1938 default:
1939 // remain in this state
1940 break;
1941 }
1942 break;
1943
1944 case kEplDllCsWaitSoa:
1945 switch (NmtEvent_p) {
1946 case kEplNmtEventDllCeFrameTimeout:
1947 // DLL_CT3
1948 if (NmtState_p == kEplNmtCsPreOperational2) { // ignore frame timeout in PreOp2,
1949 // because the previously configured cycle len
1950 // may be wrong.
1951 // 2008/10/15 d.k. If it would not be ignored,
1952 // we would go cyclically to PreOp1 and on next
1953 // SoC back to PreOp2.
1954 break;
1955 }
1956 // fall through
1957
1958 case kEplNmtEventDllCePreq:
1959 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
1960 DllEvent.m_ulDllErrorEvents |=
1961 EPL_DLL_ERR_CN_LOSS_SOA |
1962 EPL_DLL_ERR_CN_LOSS_SOC;
1963
1964 case kEplNmtEventDllCeSoa:
1965 // enter DLL_CS_WAIT_SOC
1966 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1967 break;
1968
1969 // DLL_CT9
1970 case kEplNmtEventDllCeSoc:
1971 // report DLL_CEV_LOSS_SOA
1972 DllEvent.m_ulDllErrorEvents |=
1973 EPL_DLL_ERR_CN_LOSS_SOA;
1974
1975 // enter DLL_CS_WAIT_PREQ
1976 EplDllkInstance_g.m_DllState =
1977 kEplDllCsWaitPreq;
1978 break;
1979
1980 // DLL_CT10
1981 case kEplNmtEventDllCeAsnd:
1982 // report DLL_CEV_LOSS_SOA
1983 DllEvent.m_ulDllErrorEvents |=
1984 EPL_DLL_ERR_CN_LOSS_SOA;
1985
1986 case kEplNmtEventDllCePres:
1987 default:
1988 // remain in this state
1989 break;
1990 }
1991 break;
1992
1993 case kEplDllGsInit:
1994 // enter DLL_CS_WAIT_PREQ
1995 EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
1996 break;
1997
1998 default:
1999 break;
2000 }
2001 break;
2002
2003 case kEplNmtCsStopped:
2004 // full EPL cycle is active, but without PReq/PRes
2005
2006 switch (EplDllkInstance_g.m_DllState) {
2007 case kEplDllCsWaitPreq:
2008 switch (NmtEvent_p) {
2009 // DLL_CT2
2010 case kEplNmtEventDllCePreq:
2011 // enter DLL_CS_WAIT_SOA
2012 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2013 break;
2014
2015 // DLL_CT8
2016 case kEplNmtEventDllCeFrameTimeout:
2017 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
2018 DllEvent.m_ulDllErrorEvents |=
2019 EPL_DLL_ERR_CN_LOSS_SOA |
2020 EPL_DLL_ERR_CN_LOSS_SOC;
2021
2022 case kEplNmtEventDllCeSoa:
2023 // NMT_CS_STOPPED active
2024 // it is Ok if no PReq was received
2025
2026 // enter DLL_CS_WAIT_SOC
2027 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
2028 break;
2029
2030 // DLL_CT7
2031 case kEplNmtEventDllCeSoc:
2032 case kEplNmtEventDllCeAsnd:
2033 // report DLL_CEV_LOSS_SOA
2034 DllEvent.m_ulDllErrorEvents |=
2035 EPL_DLL_ERR_CN_LOSS_SOA;
2036
2037 case kEplNmtEventDllCePres:
2038 default:
2039 // remain in this state
2040 break;
2041 }
2042 break;
2043
2044 case kEplDllCsWaitSoc:
2045 switch (NmtEvent_p) {
2046 // DLL_CT1
2047 case kEplNmtEventDllCeSoc:
2048 // start of cycle and isochronous phase
2049 // enter DLL_CS_WAIT_SOA
2050 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2051 break;
2052
2053 // DLL_CT4
2054 // case kEplNmtEventDllCePres:
2055 case kEplNmtEventDllCePreq:
2056 case kEplNmtEventDllCeSoa:
2057 case kEplNmtEventDllCeFrameTimeout:
2058 // report DLL_CEV_LOSS_SOC
2059 DllEvent.m_ulDllErrorEvents |=
2060 EPL_DLL_ERR_CN_LOSS_SOC;
2061
2062 case kEplNmtEventDllCeAsnd:
2063 default:
2064 // remain in this state
2065 break;
2066 }
2067 break;
2068
2069 case kEplDllCsWaitSoa:
2070 switch (NmtEvent_p) {
2071 // DLL_CT3
2072 case kEplNmtEventDllCeFrameTimeout:
2073 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
2074 DllEvent.m_ulDllErrorEvents |=
2075 EPL_DLL_ERR_CN_LOSS_SOA |
2076 EPL_DLL_ERR_CN_LOSS_SOC;
2077
2078 case kEplNmtEventDllCeSoa:
2079 // enter DLL_CS_WAIT_SOC
2080 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
2081 break;
2082
2083 // DLL_CT9
2084 case kEplNmtEventDllCeSoc:
2085 // report DLL_CEV_LOSS_SOA
2086 DllEvent.m_ulDllErrorEvents |=
2087 EPL_DLL_ERR_CN_LOSS_SOA;
2088 // remain in DLL_CS_WAIT_SOA
2089 break;
2090
2091 // DLL_CT10
2092 case kEplNmtEventDllCeAsnd:
2093 // report DLL_CEV_LOSS_SOA
2094 DllEvent.m_ulDllErrorEvents |=
2095 EPL_DLL_ERR_CN_LOSS_SOA;
2096
2097 case kEplNmtEventDllCePreq:
2098 // NMT_CS_STOPPED active and we do not expect any PReq
2099 // so just ignore it
2100 case kEplNmtEventDllCePres:
2101 default:
2102 // remain in this state
2103 break;
2104 }
2105 break;
2106
2107 case kEplDllGsInit:
2108 default:
2109 // enter DLL_CS_WAIT_PREQ
2110 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2111 break;
2112 }
2113 break;
2114
2115 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2116 case kEplNmtMsNotActive:
2117 case kEplNmtMsBasicEthernet:
2118 break;
2119
2120 case kEplNmtMsPreOperational1:
2121 // reduced EPL cycle is active
2122 if (EplDllkInstance_g.m_DllState != kEplDllMsNonCyclic) { // stop cycle timer
2123 #if EPL_TIMER_USE_HIGHRES != FALSE
2124 Ret =
2125 EplTimerHighReskDeleteTimer(&EplDllkInstance_g.
2126 m_TimerHdlCycle);
2127 #endif
2128 EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
2129
2130 // stop further processing,
2131 // because it will be restarted by NMT MN module
2132 break;
2133 }
2134
2135 switch (NmtEvent_p) {
2136 case kEplNmtEventDllMeSocTrig:
2137 case kEplNmtEventDllCeAsnd:
2138 { // because of reduced EPL cycle SoA shall be triggered, not SoC
2139 tEplDllState DummyDllState;
2140
2141 Ret =
2142 EplDllkAsyncFrameNotReceived
2143 (EplDllkInstance_g.m_LastReqServiceId,
2144 EplDllkInstance_g.m_uiLastTargetNodeId);
2145
2146 // go ahead and send SoA
2147 Ret = EplDllkMnSendSoa(NmtState_p,
2148 &DummyDllState,
2149 (EplDllkInstance_g.
2150 m_uiCycleCount >=
2151 EPL_C_DLL_PREOP1_START_CYCLES));
2152 // increment cycle counter to detect if EPL_C_DLL_PREOP1_START_CYCLES empty cycles are elapsed
2153 EplDllkInstance_g.m_uiCycleCount++;
2154
2155 // reprogram timer
2156 #if EPL_TIMER_USE_HIGHRES != FALSE
2157 if (EplDllkInstance_g.m_DllConfigParam.
2158 m_dwAsyncSlotTimeout != 0) {
2159 Ret =
2160 EplTimerHighReskModifyTimerNs
2161 (&EplDllkInstance_g.m_TimerHdlCycle,
2162 EplDllkInstance_g.m_DllConfigParam.
2163 m_dwAsyncSlotTimeout,
2164 EplDllkCbMnTimerCycle, 0L, FALSE);
2165 }
2166 #endif
2167 break;
2168 }
2169
2170 default:
2171 break;
2172 }
2173 break;
2174
2175 case kEplNmtMsPreOperational2:
2176 case kEplNmtMsReadyToOperate:
2177 case kEplNmtMsOperational:
2178 // full EPL cycle is active
2179 switch (NmtEvent_p) {
2180 case kEplNmtEventDllMeSocTrig:
2181 {
2182 // update cycle counter
2183 if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0) { // multiplexed cycle active
2184 EplDllkInstance_g.m_uiCycleCount =
2185 (EplDllkInstance_g.m_uiCycleCount +
2186 1) %
2187 EplDllkInstance_g.m_DllConfigParam.
2188 m_uiMultiplCycleCnt;
2189 // $$$ check multiplexed cycle restart
2190 // -> toggle MC flag
2191 // -> change node linked list
2192 } else { // non-multiplexed cycle active
2193 // start with first node in isochronous phase
2194 EplDllkInstance_g.m_pCurNodeInfo = NULL;
2195 }
2196
2197 switch (EplDllkInstance_g.m_DllState) {
2198 case kEplDllMsNonCyclic:
2199 { // start continuous cycle timer
2200 #if EPL_TIMER_USE_HIGHRES != FALSE
2201 Ret =
2202 EplTimerHighReskModifyTimerNs
2203 (&EplDllkInstance_g.
2204 m_TimerHdlCycle,
2205 EplDllkInstance_g.
2206 m_ullFrameTimeout,
2207 EplDllkCbMnTimerCycle, 0L,
2208 TRUE);
2209 #endif
2210 // continue with sending SoC
2211 }
2212
2213 case kEplDllMsWaitAsnd:
2214 case kEplDllMsWaitSocTrig:
2215 { // if m_LastReqServiceId is still valid,
2216 // SoA was not correctly answered
2217 // and user part has to be informed
2218 Ret =
2219 EplDllkAsyncFrameNotReceived
2220 (EplDllkInstance_g.
2221 m_LastReqServiceId,
2222 EplDllkInstance_g.
2223 m_uiLastTargetNodeId);
2224
2225 // send SoC
2226 Ret = EplDllkMnSendSoc();
2227
2228 // new DLL state
2229 EplDllkInstance_g.m_DllState =
2230 kEplDllMsWaitPreqTrig;
2231
2232 // start WaitSoCPReq Timer
2233 #if EPL_TIMER_USE_HIGHRES != FALSE
2234 Ret =
2235 EplTimerHighReskModifyTimerNs
2236 (&EplDllkInstance_g.
2237 m_TimerHdlResponse,
2238 EplDllkInstance_g.
2239 m_DllConfigParam.
2240 m_dwWaitSocPreq,
2241 EplDllkCbMnTimerResponse,
2242 0L, FALSE);
2243 #endif
2244 break;
2245 }
2246
2247 default:
2248 { // wrong DLL state / cycle time exceeded
2249 DllEvent.m_ulDllErrorEvents |=
2250 EPL_DLL_ERR_MN_CYCTIMEEXCEED;
2251 EplDllkInstance_g.m_DllState =
2252 kEplDllMsWaitSocTrig;
2253 break;
2254 }
2255 }
2256
2257 break;
2258 }
2259
2260 case kEplNmtEventDllMePresTimeout:
2261 {
2262
2263 switch (EplDllkInstance_g.m_DllState) {
2264 case kEplDllMsWaitPres:
2265 { // PRes not received
2266
2267 if (EplDllkInstance_g.m_pCurNodeInfo->m_fSoftDelete == FALSE) { // normal isochronous CN
2268 DllEvent.
2269 m_ulDllErrorEvents
2270 |=
2271 EPL_DLL_ERR_MN_CN_LOSS_PRES;
2272 DllEvent.m_uiNodeId =
2273 EplDllkInstance_g.
2274 m_pCurNodeInfo->
2275 m_uiNodeId;
2276 } else { // CN shall be deleted softly
2277 Event.m_EventSink =
2278 kEplEventSinkDllkCal;
2279 Event.m_EventType =
2280 kEplEventTypeDllkSoftDelNode;
2281 // $$$ d.k. set Event.m_NetTime to current time
2282 Event.m_uiSize =
2283 sizeof(unsigned
2284 int);
2285 Event.m_pArg =
2286 &EplDllkInstance_g.
2287 m_pCurNodeInfo->
2288 m_uiNodeId;
2289 Ret =
2290 EplEventkPost
2291 (&Event);
2292 }
2293
2294 // continue with sending next PReq
2295 }
2296
2297 case kEplDllMsWaitPreqTrig:
2298 {
2299 // send next PReq
2300 Ret =
2301 EplDllkMnSendPreq
2302 (NmtState_p,
2303 &EplDllkInstance_g.
2304 m_DllState);
2305
2306 break;
2307 }
2308
2309 default:
2310 { // wrong DLL state
2311 break;
2312 }
2313 }
2314
2315 break;
2316 }
2317
2318 case kEplNmtEventDllCePres:
2319 {
2320
2321 switch (EplDllkInstance_g.m_DllState) {
2322 case kEplDllMsWaitPres:
2323 { // PRes received
2324 // send next PReq
2325 Ret =
2326 EplDllkMnSendPreq
2327 (NmtState_p,
2328 &EplDllkInstance_g.
2329 m_DllState);
2330
2331 break;
2332 }
2333
2334 default:
2335 { // wrong DLL state
2336 break;
2337 }
2338 }
2339
2340 break;
2341 }
2342
2343 case kEplNmtEventDllMeSoaTrig:
2344 {
2345
2346 switch (EplDllkInstance_g.m_DllState) {
2347 case kEplDllMsWaitSoaTrig:
2348 { // MN PRes sent
2349 // send SoA
2350 Ret =
2351 EplDllkMnSendSoa(NmtState_p,
2352 &EplDllkInstance_g.
2353 m_DllState,
2354 TRUE);
2355
2356 break;
2357 }
2358
2359 default:
2360 { // wrong DLL state
2361 break;
2362 }
2363 }
2364
2365 break;
2366 }
2367
2368 case kEplNmtEventDllCeAsnd:
2369 { // ASnd has been received, but it may be not the requested one
2370 /*
2371 // report if SoA was correctly answered
2372 Ret = EplDllkAsyncFrameNotReceived(EplDllkInstance_g.m_LastReqServiceId,
2373 EplDllkInstance_g.m_uiLastTargetNodeId);
2374 */
2375 if (EplDllkInstance_g.m_DllState ==
2376 kEplDllMsWaitAsnd) {
2377 EplDllkInstance_g.m_DllState =
2378 kEplDllMsWaitSocTrig;
2379 }
2380 break;
2381 }
2382
2383 default:
2384 break;
2385 }
2386 break;
2387 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2388
2389 default:
2390 break;
2391 }
2392
2393 if (DllEvent.m_ulDllErrorEvents != 0) { // error event set -> post it to error handler
2394 Event.m_EventSink = kEplEventSinkErrk;
2395 Event.m_EventType = kEplEventTypeDllError;
2396 // $$$ d.k. set Event.m_NetTime to current time
2397 Event.m_uiSize = sizeof(DllEvent);
2398 Event.m_pArg = &DllEvent;
2399 Ret = EplEventkPost(&Event);
2400 }
2401
2402 return Ret;
2403 }
2404
2405 //---------------------------------------------------------------------------
2406 //
2407 // Function: EplDllkCbFrameReceived()
2408 //
2409 // Description: called from EdrvInterruptHandler()
2410 //
2411 // Parameters: pRxBuffer_p = receive buffer structure
2412 //
2413 // Returns: (none)
2414 //
2415 //
2416 // State:
2417 //
2418 //---------------------------------------------------------------------------
2419
2420 static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p)
2421 {
2422 tEplKernel Ret = kEplSuccessful;
2423 tEplNmtState NmtState;
2424 tEplNmtEvent NmtEvent = kEplNmtEventNoEvent;
2425 tEplEvent Event;
2426 tEplFrame *pFrame;
2427 tEplFrame *pTxFrame;
2428 tEdrvTxBuffer *pTxBuffer = NULL;
2429 tEplFrameInfo FrameInfo;
2430 tEplMsgType MsgType;
2431 tEplDllReqServiceId ReqServiceId;
2432 unsigned int uiAsndServiceId;
2433 unsigned int uiNodeId;
2434 BYTE bFlag1;
2435
2436 BENCHMARK_MOD_02_SET(3);
2437 NmtState = EplNmtkGetNmtState();
2438
2439 if (NmtState <= kEplNmtGsResetConfiguration) {
2440 goto Exit;
2441 }
2442
2443 pFrame = (tEplFrame *) pRxBuffer_p->m_pbBuffer;
2444
2445 #if EDRV_EARLY_RX_INT != FALSE
2446 switch (pRxBuffer_p->m_BufferInFrame) {
2447 case kEdrvBufferFirstInFrame:
2448 {
2449 MsgType =
2450 (tEplMsgType) AmiGetByteFromLe(&pFrame->
2451 m_le_bMessageType);
2452 if (MsgType == kEplMsgTypePreq) {
2453 if (EplDllkInstance_g.m_DllState == kEplDllCsWaitPreq) { // PReq expected and actually received
2454 // d.k.: The condition above is sufficent, because EPL cycle is active
2455 // and no non-EPL frame shall be received in isochronous phase.
2456 // start transmission PRes
2457 // $$$ What if Tx buffer is invalid?
2458 pTxBuffer =
2459 &EplDllkInstance_g.
2460 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2461 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2462 Ret = EdrvTxMsgStart(pTxBuffer);
2463 #else
2464 pTxFrame =
2465 (tEplFrame *) pTxBuffer->m_pbBuffer;
2466 // update frame (NMT state, RD, RS, PR, MS, EN flags)
2467 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2468 m_le_bNmtStatus,
2469 (BYTE) NmtState);
2470 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2471 m_le_bFlag2,
2472 EplDllkInstance_g.
2473 m_bFlag2);
2474 if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2475 // $$$ reset only RD flag; set other flags appropriately
2476 AmiSetByteToLe(&pTxFrame->
2477 m_Data.m_Pres.
2478 m_le_bFlag1, 0);
2479 }
2480 // $$$ make function that updates Pres, StatusRes
2481 // send PRes frame
2482 Ret = EdrvSendTxMsg(pTxBuffer);
2483 #endif
2484 }
2485 }
2486 goto Exit;
2487 }
2488
2489 case kEdrvBufferMiddleInFrame:
2490 {
2491 goto Exit;
2492 }
2493
2494 case kEdrvBufferLastInFrame:
2495 {
2496 break;
2497 }
2498 }
2499 #endif
2500
2501 FrameInfo.m_pFrame = pFrame;
2502 FrameInfo.m_uiFrameSize = pRxBuffer_p->m_uiRxMsgLen;
2503 FrameInfo.m_NetTime.m_dwNanoSec = pRxBuffer_p->m_NetTime.m_dwNanoSec;
2504 FrameInfo.m_NetTime.m_dwSec = pRxBuffer_p->m_NetTime.m_dwSec;
2505
2506 if (AmiGetWordFromBe(&pFrame->m_be_wEtherType) != EPL_C_DLL_ETHERTYPE_EPL) { // non-EPL frame
2507 //TRACE2("EplDllkCbFrameReceived: pfnCbAsync=0x%p SrcMAC=0x%llx\n", EplDllkInstance_g.m_pfnCbAsync, AmiGetQword48FromBe(pFrame->m_be_abSrcMac));
2508 if (EplDllkInstance_g.m_pfnCbAsync != NULL) { // handler for async frames is registered
2509 EplDllkInstance_g.m_pfnCbAsync(&FrameInfo);
2510 }
2511
2512 goto Exit;
2513 }
2514
2515 MsgType = (tEplMsgType) AmiGetByteFromLe(&pFrame->m_le_bMessageType);
2516 switch (MsgType) {
2517 case kEplMsgTypePreq:
2518 {
2519 // PReq frame
2520 // d.k.: (we assume that this PReq frame is intended for us and don't check DstNodeId)
2521 if (AmiGetByteFromLe(&pFrame->m_le_bDstNodeId) != EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) { // this PReq is not intended for us
2522 goto Exit;
2523 }
2524 NmtEvent = kEplNmtEventDllCePreq;
2525
2526 if (NmtState >= kEplNmtMsNotActive) { // MN is active -> wrong msg type
2527 break;
2528 }
2529 #if EDRV_EARLY_RX_INT == FALSE
2530 if (NmtState >= kEplNmtCsPreOperational2) { // respond to and process PReq frames only in PreOp2, ReadyToOp and Op
2531 // Does PRes exist?
2532 pTxBuffer =
2533 &EplDllkInstance_g.
2534 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2535 if (pTxBuffer->m_pbBuffer != NULL) { // PRes does exist
2536 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2537 EdrvTxMsgStart(pTxBuffer);
2538 #else
2539 pTxFrame =
2540 (tEplFrame *) pTxBuffer->m_pbBuffer;
2541 // update frame (NMT state, RD, RS, PR, MS, EN flags)
2542 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2543 m_le_bNmtStatus,
2544 (BYTE) NmtState);
2545 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2546 m_le_bFlag2,
2547 EplDllkInstance_g.
2548 m_bFlag2);
2549 bFlag1 =
2550 AmiGetByteFromLe(&pFrame->m_Data.
2551 m_Preq.
2552 m_le_bFlag1);
2553 // save EA flag
2554 EplDllkInstance_g.m_bMnFlag1 =
2555 (EplDllkInstance_g.
2556 m_bMnFlag1 & ~EPL_FRAME_FLAG1_EA)
2557 | (bFlag1 & EPL_FRAME_FLAG1_EA);
2558 // preserve MS flag
2559 bFlag1 &= EPL_FRAME_FLAG1_MS;
2560 // add EN flag from Error signaling module
2561 bFlag1 |=
2562 EplDllkInstance_g.
2563 m_bFlag1 & EPL_FRAME_FLAG1_EN;
2564 if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2565 // reset only RD flag
2566 AmiSetByteToLe(&pTxFrame->
2567 m_Data.m_Pres.
2568 m_le_bFlag1,
2569 bFlag1);
2570 } else { // leave RD flag untouched
2571 AmiSetByteToLe(&pTxFrame->
2572 m_Data.m_Pres.
2573 m_le_bFlag1,
2574 (AmiGetByteFromLe
2575 (&pTxFrame->
2576 m_Data.m_Pres.
2577 m_le_bFlag1) &
2578 EPL_FRAME_FLAG1_RD)
2579 | bFlag1);
2580 }
2581 // $$$ update EPL_DLL_PRES_READY_AFTER_* code
2582 // send PRes frame
2583 Ret = EdrvSendTxMsg(pTxBuffer);
2584 if (Ret != kEplSuccessful) {
2585 goto Exit;
2586 }
2587 #endif
2588 }
2589 #endif
2590 // inform PDO module
2591 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
2592 if (NmtState >= kEplNmtCsReadyToOperate) { // inform PDO module only in ReadyToOp and Op
2593 if (NmtState != kEplNmtCsOperational) {
2594 // reset RD flag and all other flags, but that does not matter, because they were processed above
2595 AmiSetByteToLe(&pFrame->m_Data.
2596 m_Preq.
2597 m_le_bFlag1, 0);
2598 }
2599 // compares real frame size and PDO size
2600 if ((unsigned
2601 int)(AmiGetWordFromLe(&pFrame->
2602 m_Data.
2603 m_Preq.
2604 m_le_wSize) +
2605 24)
2606 > FrameInfo.m_uiFrameSize) { // format error
2607 tEplErrorHandlerkEvent DllEvent;
2608
2609 DllEvent.m_ulDllErrorEvents =
2610 EPL_DLL_ERR_INVALID_FORMAT;
2611 DllEvent.m_uiNodeId =
2612 AmiGetByteFromLe(&pFrame->
2613 m_le_bSrcNodeId);
2614 DllEvent.m_NmtState = NmtState;
2615 Event.m_EventSink =
2616 kEplEventSinkErrk;
2617 Event.m_EventType =
2618 kEplEventTypeDllError;
2619 Event.m_NetTime =
2620 FrameInfo.m_NetTime;
2621 Event.m_uiSize =
2622 sizeof(DllEvent);
2623 Event.m_pArg = &DllEvent;
2624 Ret = EplEventkPost(&Event);
2625 break;
2626 }
2627 // forward PReq frame as RPDO to PDO module
2628 Ret = EplPdokCbPdoReceived(&FrameInfo);
2629
2630 }
2631 #if (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2632 if (pTxBuffer->m_pbBuffer != NULL) { // PRes does exist
2633 // inform PDO module about PRes after PReq
2634 FrameInfo.m_pFrame =
2635 (tEplFrame *) pTxBuffer->m_pbBuffer;
2636 FrameInfo.m_uiFrameSize =
2637 pTxBuffer->m_uiMaxBufferLen;
2638 Ret =
2639 EplPdokCbPdoTransmitted(&FrameInfo);
2640 }
2641 #endif
2642 #endif
2643
2644 #if EDRV_EARLY_RX_INT == FALSE
2645 // $$$ inform emergency protocol handling (error signaling module) about flags
2646 }
2647 #endif
2648
2649 // reset cycle counter
2650 EplDllkInstance_g.m_uiCycleCount = 0;
2651
2652 break;
2653 }
2654
2655 case kEplMsgTypePres:
2656 {
2657 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2658 tEplDllkNodeInfo *pIntNodeInfo;
2659 tEplHeartbeatEvent HeartbeatEvent;
2660 #endif
2661
2662 // PRes frame
2663 NmtEvent = kEplNmtEventDllCePres;
2664
2665 uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
2666
2667 if ((NmtState >= kEplNmtCsPreOperational2)
2668 && (NmtState <= kEplNmtCsOperational)) { // process PRes frames only in PreOp2, ReadyToOp and Op of CN
2669
2670 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2671 pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId);
2672 if (pIntNodeInfo == NULL) { // no node info structure available
2673 Ret = kEplDllNoNodeInfo;
2674 goto Exit;
2675 }
2676 } else if (EplDllkInstance_g.m_DllState == kEplDllMsWaitPres) { // or process PRes frames in MsWaitPres
2677
2678 pIntNodeInfo = EplDllkInstance_g.m_pCurNodeInfo;
2679 if ((pIntNodeInfo == NULL) || (pIntNodeInfo->m_uiNodeId != uiNodeId)) { // ignore PRes, because it is from wrong CN
2680 // $$$ maybe post event to NmtMn module
2681 goto Exit;
2682 }
2683 // forward Flag2 to asynchronous scheduler
2684 bFlag1 =
2685 AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.
2686 m_Payload.m_StatusResponse.
2687 m_le_bFlag2);
2688 Ret =
2689 EplDllkCalAsyncSetPendingRequests(uiNodeId,
2690 ((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)), (bFlag1 & EPL_FRAME_FLAG2_RS));
2691
2692 #endif
2693 } else { // ignore PRes, because it was received in wrong NMT state
2694 // but execute EplDllkChangeState() and post event to NMT module
2695 break;
2696 }
2697
2698 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2699 { // check NMT state of CN
2700 HeartbeatEvent.m_wErrorCode = EPL_E_NO_ERROR;
2701 HeartbeatEvent.m_NmtState =
2702 (tEplNmtState) (AmiGetByteFromLe
2703 (&pFrame->m_Data.m_Pres.
2704 m_le_bNmtStatus) |
2705 EPL_NMT_TYPE_CS);
2706 if (pIntNodeInfo->m_NmtState != HeartbeatEvent.m_NmtState) { // NMT state of CN has changed -> post event to NmtMnu module
2707 if (pIntNodeInfo->m_fSoftDelete == FALSE) { // normal isochronous CN
2708 HeartbeatEvent.m_uiNodeId =
2709 uiNodeId;
2710 Event.m_EventSink =
2711 kEplEventSinkNmtMnu;
2712 Event.m_EventType =
2713 kEplEventTypeHeartbeat;
2714 Event.m_uiSize =
2715 sizeof(HeartbeatEvent);
2716 Event.m_pArg = &HeartbeatEvent;
2717 } else { // CN shall be deleted softly
2718 Event.m_EventSink =
2719 kEplEventSinkDllkCal;
2720 Event.m_EventType =
2721 kEplEventTypeDllkSoftDelNode;
2722 Event.m_uiSize =
2723 sizeof(unsigned int);
2724 Event.m_pArg =
2725 &pIntNodeInfo->m_uiNodeId;
2726 }
2727 Event.m_NetTime = FrameInfo.m_NetTime;
2728 Ret = EplEventkPost(&Event);
2729
2730 // save current NMT state of CN in internal node structure
2731 pIntNodeInfo->m_NmtState =
2732 HeartbeatEvent.m_NmtState;
2733 }
2734 }
2735 #endif
2736
2737 // inform PDO module
2738 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
2739 if ((NmtState != kEplNmtCsPreOperational2)
2740 && (NmtState != kEplNmtMsPreOperational2)) { // inform PDO module only in ReadyToOp and Op
2741 // compare real frame size and PDO size?
2742 if (((unsigned
2743 int)(AmiGetWordFromLe(&pFrame->m_Data.
2744 m_Pres.m_le_wSize) +
2745 24)
2746 > FrameInfo.m_uiFrameSize)
2747 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2748 ||
2749 (AmiGetWordFromLe
2750 (&pFrame->m_Data.m_Pres.m_le_wSize) >
2751 pIntNodeInfo->m_wPresPayloadLimit)
2752 #endif
2753 ) { // format error
2754 tEplErrorHandlerkEvent DllEvent;
2755
2756 DllEvent.m_ulDllErrorEvents =
2757 EPL_DLL_ERR_INVALID_FORMAT;
2758 DllEvent.m_uiNodeId = uiNodeId;
2759 DllEvent.m_NmtState = NmtState;
2760 Event.m_EventSink = kEplEventSinkErrk;
2761 Event.m_EventType =
2762 kEplEventTypeDllError;
2763 Event.m_NetTime = FrameInfo.m_NetTime;
2764 Event.m_uiSize = sizeof(DllEvent);
2765 Event.m_pArg = &DllEvent;
2766 Ret = EplEventkPost(&Event);
2767 break;
2768 }
2769 if ((NmtState != kEplNmtCsOperational)
2770 && (NmtState != kEplNmtMsOperational)) {
2771 // reset RD flag and all other flags, but that does not matter, because they were processed above
2772 AmiSetByteToLe(&pFrame->m_Data.m_Pres.
2773 m_le_bFlag1, 0);
2774 }
2775 Ret = EplPdokCbPdoReceived(&FrameInfo);
2776 }
2777 #endif
2778
2779 break;
2780 }
2781
2782 case kEplMsgTypeSoc:
2783 {
2784 // SoC frame
2785 NmtEvent = kEplNmtEventDllCeSoc;
2786
2787 if (NmtState >= kEplNmtMsNotActive) { // MN is active -> wrong msg type
2788 break;
2789 }
2790 #if EPL_DLL_PRES_READY_AFTER_SOC != FALSE
2791 // post PRes to transmit FIFO of the ethernet controller, but don't start
2792 // transmission over bus
2793 pTxBuffer =
2794 &EplDllkInstance_g.
2795 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2796 // Does PRes exist?
2797 if (pTxBuffer->m_pbBuffer != NULL) { // PRes does exist
2798 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
2799 // update frame (NMT state, RD, RS, PR, MS, EN flags)
2800 if (NmtState < kEplNmtCsPreOperational2) { // NMT state is not PreOp2, ReadyToOp or Op
2801 // fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
2802 NmtState = kEplNmtCsPreOperational2;
2803 }
2804 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2805 m_le_bNmtStatus,
2806 (BYTE) NmtState);
2807 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2808 m_le_bFlag2,
2809 EplDllkInstance_g.m_bFlag2);
2810 if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2811 // $$$ reset only RD flag; set other flags appropriately
2812 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2813 m_le_bFlag1, 0);
2814 }
2815 // $$$ make function that updates Pres, StatusRes
2816 // mark PRes frame as ready for transmission
2817 Ret = EdrvTxMsgReady(pTxBuffer);
2818 }
2819 #endif
2820
2821 if (NmtState >= kEplNmtCsPreOperational2) { // SoC frames only in PreOp2, ReadyToOp and Op
2822 // trigger synchronous task
2823 Event.m_EventSink = kEplEventSinkSync;
2824 Event.m_EventType = kEplEventTypeSync;
2825 Event.m_uiSize = 0;
2826 Ret = EplEventkPost(&Event);
2827
2828 // update cycle counter
2829 if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0) { // multiplexed cycle active
2830 EplDllkInstance_g.m_uiCycleCount =
2831 (EplDllkInstance_g.m_uiCycleCount +
2832 1) %
2833 EplDllkInstance_g.m_DllConfigParam.
2834 m_uiMultiplCycleCnt;
2835 }
2836 }
2837 // reprogram timer
2838 #if EPL_TIMER_USE_HIGHRES != FALSE
2839 if (EplDllkInstance_g.m_ullFrameTimeout != 0) {
2840 Ret =
2841 EplTimerHighReskModifyTimerNs
2842 (&EplDllkInstance_g.m_TimerHdlCycle,
2843 EplDllkInstance_g.m_ullFrameTimeout,
2844 EplDllkCbCnTimer, 0L, FALSE);
2845 }
2846 #endif
2847
2848 break;
2849 }
2850
2851 case kEplMsgTypeSoa:
2852 {
2853 // SoA frame
2854 NmtEvent = kEplNmtEventDllCeSoa;
2855
2856 if (NmtState >= kEplNmtMsNotActive) { // MN is active -> wrong msg type
2857 break;
2858 }
2859
2860 pTxFrame = NULL;
2861
2862 if ((NmtState & EPL_NMT_SUPERSTATE_MASK) != EPL_NMT_CS_EPLMODE) { // do not respond, if NMT state is < PreOp1 (i.e. not EPL_MODE)
2863 break;
2864 }
2865 // check TargetNodeId
2866 uiNodeId =
2867 AmiGetByteFromLe(&pFrame->m_Data.m_Soa.
2868 m_le_bReqServiceTarget);
2869 if (uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) { // local node is the target of the current request
2870
2871 // check ServiceId
2872 ReqServiceId =
2873 (tEplDllReqServiceId)
2874 AmiGetByteFromLe(&pFrame->m_Data.m_Soa.
2875 m_le_bReqServiceId);
2876 if (ReqServiceId == kEplDllReqServiceStatus) { // StatusRequest
2877 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL) { // StatusRes does exist
2878
2879 pTxFrame =
2880 (tEplFrame *)
2881 EplDllkInstance_g.
2882 m_pTxBuffer
2883 [EPL_DLLK_TXFRAME_STATUSRES].
2884 m_pbBuffer;
2885 // update StatusRes frame (NMT state, EN, EC, RS, PR flags)
2886 AmiSetByteToLe(&pTxFrame->
2887 m_Data.m_Asnd.
2888 m_Payload.
2889 m_StatusResponse.
2890 m_le_bNmtStatus,
2891 (BYTE) NmtState);
2892 AmiSetByteToLe(&pTxFrame->
2893 m_Data.m_Asnd.
2894 m_Payload.
2895 m_StatusResponse.
2896 m_le_bFlag1,
2897 EplDllkInstance_g.
2898 m_bFlag1);
2899 AmiSetByteToLe(&pTxFrame->
2900 m_Data.m_Asnd.
2901 m_Payload.
2902 m_StatusResponse.
2903 m_le_bFlag2,
2904 EplDllkInstance_g.
2905 m_bFlag2);
2906 // send StatusRes
2907 Ret =
2908 EdrvSendTxMsg
2909 (&EplDllkInstance_g.
2910 m_pTxBuffer
2911 [EPL_DLLK_TXFRAME_STATUSRES]);
2912 if (Ret != kEplSuccessful) {
2913 goto Exit;
2914 }
2915 TGT_DBG_SIGNAL_TRACE_POINT(8);
2916
2917 // update error signaling
2918 bFlag1 =
2919 AmiGetByteFromLe(&pFrame->
2920 m_Data.
2921 m_Soa.
2922 m_le_bFlag1);
2923 if (((bFlag1 ^ EplDllkInstance_g.m_bMnFlag1) & EPL_FRAME_FLAG1_ER) != 0) { // exception reset flag was changed by MN
2924 // assume same state for EC in next cycle (clear all other bits)
2925 if ((bFlag1 &
2926 EPL_FRAME_FLAG1_ER)
2927 != 0) {
2928 // set EC and reset rest
2929 EplDllkInstance_g.
2930 m_bFlag1 =
2931 EPL_FRAME_FLAG1_EC;
2932 } else {
2933 // reset complete flag 1 (including EC and EN)
2934 EplDllkInstance_g.
2935 m_bFlag1 =
2936 0;
2937 }
2938 }
2939 // save flag 1 from MN for Status request response cycle
2940 EplDllkInstance_g.m_bMnFlag1 =
2941 bFlag1;
2942 }
2943 } else if (ReqServiceId == kEplDllReqServiceIdent) { // IdentRequest
2944 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL) { // IdentRes does exist
2945 pTxFrame =
2946 (tEplFrame *)
2947 EplDllkInstance_g.
2948 m_pTxBuffer
2949 [EPL_DLLK_TXFRAME_IDENTRES].
2950 m_pbBuffer;
2951 // update IdentRes frame (NMT state, RS, PR flags)
2952 AmiSetByteToLe(&pTxFrame->
2953 m_Data.m_Asnd.
2954 m_Payload.
2955 m_IdentResponse.
2956 m_le_bNmtStatus,
2957 (BYTE) NmtState);
2958 AmiSetByteToLe(&pTxFrame->
2959 m_Data.m_Asnd.
2960 m_Payload.
2961 m_IdentResponse.
2962 m_le_bFlag2,
2963 EplDllkInstance_g.
2964 m_bFlag2);
2965 // send IdentRes
2966 Ret =
2967 EdrvSendTxMsg
2968 (&EplDllkInstance_g.
2969 m_pTxBuffer
2970 [EPL_DLLK_TXFRAME_IDENTRES]);
2971 if (Ret != kEplSuccessful) {
2972 goto Exit;
2973 }
2974 TGT_DBG_SIGNAL_TRACE_POINT(7);
2975 }
2976 } else if (ReqServiceId == kEplDllReqServiceNmtRequest) { // NmtRequest
2977 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL) { // NmtRequest does exist
2978 // check if frame is not empty and not being filled
2979 if (EplDllkInstance_g.
2980 m_pTxBuffer
2981 [EPL_DLLK_TXFRAME_NMTREQ].
2982 m_uiTxMsgLen >
2983 EPL_DLLK_BUFLEN_FILLING) {
2984 /*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
2985 { // pad frame
2986 EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
2987 } */
2988 // memorize transmission
2989 pTxFrame =
2990 (tEplFrame *) 1;
2991 // send NmtRequest
2992 Ret =
2993 EdrvSendTxMsg
2994 (&EplDllkInstance_g.
2995 m_pTxBuffer
2996 [EPL_DLLK_TXFRAME_NMTREQ]);
2997 if (Ret !=
2998 kEplSuccessful) {
2999 goto Exit;
3000 }
3001
3002 }
3003 }
3004
3005 } else if (ReqServiceId == kEplDllReqServiceUnspecified) { // unspecified invite
3006 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL) { // non-EPL frame does exist
3007 // check if frame is not empty and not being filled
3008 if (EplDllkInstance_g.
3009 m_pTxBuffer
3010 [EPL_DLLK_TXFRAME_NONEPL].
3011 m_uiTxMsgLen >
3012 EPL_DLLK_BUFLEN_FILLING) {
3013 /*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
3014 { // pad frame
3015 EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
3016 } */
3017 // memorize transmission
3018 pTxFrame =
3019 (tEplFrame *) 1;
3020 // send non-EPL frame
3021 Ret =
3022 EdrvSendTxMsg
3023 (&EplDllkInstance_g.
3024 m_pTxBuffer
3025 [EPL_DLLK_TXFRAME_NONEPL]);
3026 if (Ret !=
3027 kEplSuccessful) {
3028 goto Exit;
3029 }
3030
3031 }
3032 }
3033
3034 } else if (ReqServiceId == kEplDllReqServiceNo) { // no async service requested -> do nothing
3035 }
3036 }
3037 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3038 if (pTxFrame == NULL) { // signal process function readiness of PRes frame
3039 Event.m_EventSink = kEplEventSinkDllk;
3040 Event.m_EventType = kEplEventTypeDllkPresReady;
3041 Event.m_uiSize = 0;
3042 Event.m_pArg = NULL;
3043 Ret = EplEventkPost(&Event);
3044 }
3045 #endif
3046
3047 // inform PDO module
3048 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
3049 // Ret = EplPdokCbSoa(&FrameInfo);
3050 #endif
3051
3052 // $$$ put SrcNodeId, NMT state and NetTime as HeartbeatEvent into eventqueue
3053
3054 // $$$ inform emergency protocol handling about flags
3055 break;
3056 }
3057
3058 case kEplMsgTypeAsnd:
3059 {
3060 // ASnd frame
3061 NmtEvent = kEplNmtEventDllCeAsnd;
3062
3063 // ASnd service registered?
3064 uiAsndServiceId =
3065 (unsigned int)AmiGetByteFromLe(&pFrame->m_Data.
3066 m_Asnd.
3067 m_le_bServiceId);
3068
3069 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3070 if ((EplDllkInstance_g.m_DllState >= kEplDllMsNonCyclic)
3071 &&
3072 ((((tEplDllAsndServiceId) uiAsndServiceId) ==
3073 kEplDllAsndStatusResponse)
3074 || (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse))) { // StatusRes or IdentRes received
3075 uiNodeId =
3076 AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
3077 if ((EplDllkInstance_g.m_LastReqServiceId ==
3078 ((tEplDllReqServiceId) uiAsndServiceId))
3079 && (uiNodeId == EplDllkInstance_g.m_uiLastTargetNodeId)) { // mark request as responded
3080 EplDllkInstance_g.m_LastReqServiceId =
3081 kEplDllReqServiceNo;
3082 }
3083 if (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse) { // memorize MAC address of CN for PReq
3084 tEplDllkNodeInfo *pIntNodeInfo;
3085
3086 pIntNodeInfo =
3087 EplDllkGetNodeInfo(uiNodeId);
3088 if (pIntNodeInfo == NULL) { // no node info structure available
3089 Ret = kEplDllNoNodeInfo;
3090 } else {
3091 EPL_MEMCPY(pIntNodeInfo->
3092 m_be_abMacAddr,
3093 pFrame->
3094 m_be_abSrcMac, 6);
3095 }
3096 }
3097 // forward Flag2 to asynchronous scheduler
3098 bFlag1 =
3099 AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.
3100 m_Payload.m_StatusResponse.
3101 m_le_bFlag2);
3102 Ret =
3103 EplDllkCalAsyncSetPendingRequests(uiNodeId,
3104 ((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)), (bFlag1 & EPL_FRAME_FLAG2_RS));
3105 }
3106 #endif
3107
3108 if (uiAsndServiceId < EPL_DLL_MAX_ASND_SERVICE_ID) { // ASnd service ID is valid
3109 if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterAny) { // ASnd service ID is registered
3110 // forward frame via async receive FIFO to userspace
3111 Ret =
3112 EplDllkCalAsyncFrameReceived
3113 (&FrameInfo);
3114 } else if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterLocal) { // ASnd service ID is registered, but only local node ID or broadcasts
3115 // shall be forwarded
3116 uiNodeId =
3117 AmiGetByteFromLe(&pFrame->
3118 m_le_bDstNodeId);
3119 if ((uiNodeId ==
3120 EplDllkInstance_g.m_DllConfigParam.
3121 m_uiNodeId)
3122 || (uiNodeId == EPL_C_ADR_BROADCAST)) { // ASnd frame is intended for us
3123 // forward frame via async receive FIFO to userspace
3124 Ret =
3125 EplDllkCalAsyncFrameReceived
3126 (&FrameInfo);
3127 }
3128 }
3129 }
3130 break;
3131 }
3132
3133 default:
3134 {
3135 break;
3136 }
3137 }
3138
3139 if (NmtEvent != kEplNmtEventNoEvent) { // event for DLL and NMT state machine generated
3140 Ret = EplDllkChangeState(NmtEvent, NmtState);
3141 if (Ret != kEplSuccessful) {
3142 goto Exit;
3143 }
3144
3145 if ((NmtEvent != kEplNmtEventDllCeAsnd)
3146 && ((NmtState <= kEplNmtCsPreOperational1) || (NmtEvent != kEplNmtEventDllCePres))) { // NMT state machine is not interested in ASnd frames and PRes frames when not CsNotActive or CsPreOp1
3147 // inform NMT module
3148 Event.m_EventSink = kEplEventSinkNmtk;
3149 Event.m_EventType = kEplEventTypeNmtEvent;
3150 Event.m_uiSize = sizeof(NmtEvent);
3151 Event.m_pArg = &NmtEvent;
3152 Ret = EplEventkPost(&Event);
3153 }
3154 }
3155
3156 Exit:
3157 if (Ret != kEplSuccessful) {
3158 DWORD dwArg;
3159
3160 BENCHMARK_MOD_02_TOGGLE(9);
3161
3162 dwArg = EplDllkInstance_g.m_DllState | (NmtEvent << 8);
3163
3164 // Error event for API layer
3165 Ret = EplEventkPostError(kEplEventSourceDllk,
3166 Ret, sizeof(dwArg), &dwArg);
3167 }
3168 BENCHMARK_MOD_02_RESET(3);
3169 return;
3170 }
3171
3172 //---------------------------------------------------------------------------
3173 //
3174 // Function: EplDllkCbFrameTransmitted()
3175 //
3176 // Description: called from EdrvInterruptHandler().
3177 // It signals
3178 //
3179 // Parameters: pRxBuffer_p = receive buffer structure
3180 //
3181 // Returns: (none)
3182 //
3183 //
3184 // State:
3185 //
3186 //---------------------------------------------------------------------------
3187
3188 static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p)
3189 {
3190 tEplKernel Ret = kEplSuccessful;
3191 tEplEvent Event;
3192 tEplDllAsyncReqPriority Priority;
3193 tEplNmtState NmtState;
3194
3195 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3196 && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)
3197 tEplFrameInfo FrameInfo;
3198 #endif
3199
3200 NmtState = EplNmtkGetNmtState();
3201
3202 if (NmtState <= kEplNmtGsResetConfiguration) {
3203 goto Exit;
3204 }
3205
3206 if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NMTREQ) { // frame from NMT request FIFO sent
3207 // mark Tx-buffer as empty
3208 pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
3209
3210 // post event to DLL
3211 Priority = kEplDllAsyncReqPrioNmt;
3212 Event.m_EventSink = kEplEventSinkDllk;
3213 Event.m_EventType = kEplEventTypeDllkFillTx;
3214 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
3215 Event.m_pArg = &Priority;
3216 Event.m_uiSize = sizeof(Priority);
3217 Ret = EplEventkPost(&Event);
3218 } else if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NONEPL) { // frame from generic priority FIFO sent
3219 // mark Tx-buffer as empty
3220 pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
3221
3222 // post event to DLL
3223 Priority = kEplDllAsyncReqPrioGeneric;
3224 Event.m_EventSink = kEplEventSinkDllk;
3225 Event.m_EventType = kEplEventTypeDllkFillTx;
3226 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
3227 Event.m_pArg = &Priority;
3228 Event.m_uiSize = sizeof(Priority);
3229 Ret = EplEventkPost(&Event);
3230 }
3231 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3232 && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)) \
3233 || (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3234 else if ((pTxBuffer_p->m_EplMsgType == kEplMsgTypePreq)
3235 || (pTxBuffer_p->m_EplMsgType == kEplMsgTypePres)) { // PRes resp. PReq frame sent
3236
3237 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3238 && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE))
3239 {
3240 // inform PDO module
3241 FrameInfo.m_pFrame =
3242 (tEplFrame *) pTxBuffer_p->m_pbBuffer;
3243 FrameInfo.m_uiFrameSize = pTxBuffer_p->m_uiMaxBufferLen;
3244 Ret = EplPdokCbPdoTransmitted(&FrameInfo);
3245 }
3246 #endif
3247
3248 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3249 {
3250 // if own Pres on MN, trigger SoA
3251 if ((NmtState >= kEplNmtMsPreOperational2)
3252 && (pTxBuffer_p ==
3253 &EplDllkInstance_g.
3254 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES])) {
3255 Ret =
3256 EplDllkChangeState(kEplNmtEventDllMeSoaTrig,
3257 NmtState);
3258 }
3259 }
3260 #endif
3261
3262 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3263 goto Exit;
3264 #endif
3265 }
3266 #endif
3267 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3268 else if (pTxBuffer_p->m_EplMsgType == kEplMsgTypeSoa) { // SoA frame sent
3269 tEplNmtEvent NmtEvent = kEplNmtEventDllMeSoaSent;
3270
3271 // check if we are invited
3272 if (EplDllkInstance_g.m_uiLastTargetNodeId ==
3273 EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) {
3274 tEplFrame *pTxFrame;
3275
3276 if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceStatus) { // StatusRequest
3277 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL) { // StatusRes does exist
3278
3279 pTxFrame =
3280 (tEplFrame *) EplDllkInstance_g.
3281 m_pTxBuffer
3282 [EPL_DLLK_TXFRAME_STATUSRES].
3283 m_pbBuffer;
3284 // update StatusRes frame (NMT state, EN, EC, RS, PR flags)
3285 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3286 m_Payload.
3287 m_StatusResponse.
3288 m_le_bNmtStatus,
3289 (BYTE) NmtState);
3290 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3291 m_Payload.
3292 m_StatusResponse.
3293 m_le_bFlag1,
3294 EplDllkInstance_g.
3295 m_bFlag1);
3296 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3297 m_Payload.
3298 m_StatusResponse.
3299 m_le_bFlag2,
3300 EplDllkInstance_g.
3301 m_bFlag2);
3302 // send StatusRes
3303 Ret =
3304 EdrvSendTxMsg(&EplDllkInstance_g.
3305 m_pTxBuffer
3306 [EPL_DLLK_TXFRAME_STATUSRES]);
3307 if (Ret != kEplSuccessful) {
3308 goto Exit;
3309 }
3310 TGT_DBG_SIGNAL_TRACE_POINT(8);
3311
3312 }
3313 } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceIdent) { // IdentRequest
3314 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL) { // IdentRes does exist
3315 pTxFrame =
3316 (tEplFrame *) EplDllkInstance_g.
3317 m_pTxBuffer
3318 [EPL_DLLK_TXFRAME_IDENTRES].
3319 m_pbBuffer;
3320 // update IdentRes frame (NMT state, RS, PR flags)
3321 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3322 m_Payload.
3323 m_IdentResponse.
3324 m_le_bNmtStatus,
3325 (BYTE) NmtState);
3326 AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3327 m_Payload.
3328 m_IdentResponse.
3329 m_le_bFlag2,
3330 EplDllkInstance_g.
3331 m_bFlag2);
3332 // send IdentRes
3333 Ret =
3334 EdrvSendTxMsg(&EplDllkInstance_g.
3335 m_pTxBuffer
3336 [EPL_DLLK_TXFRAME_IDENTRES]);
3337 if (Ret != kEplSuccessful) {
3338 goto Exit;
3339 }
3340 TGT_DBG_SIGNAL_TRACE_POINT(7);
3341 }
3342 } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceNmtRequest) { // NmtRequest
3343 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL) { // NmtRequest does exist
3344 // check if frame is not empty and not being filled
3345 if (EplDllkInstance_g.
3346 m_pTxBuffer
3347 [EPL_DLLK_TXFRAME_NMTREQ].
3348 m_uiTxMsgLen >
3349 EPL_DLLK_BUFLEN_FILLING) {
3350 // check if this frame is a NMT command,
3351 // then forward this frame back to NmtMnu module,
3352 // because it needs the time, when this frame is
3353 // actually sent, to start the timer for monitoring
3354 // the NMT state change.
3355
3356 pTxFrame =
3357 (tEplFrame *)
3358 EplDllkInstance_g.
3359 m_pTxBuffer
3360 [EPL_DLLK_TXFRAME_NMTREQ].
3361 m_pbBuffer;
3362 if ((AmiGetByteFromLe
3363 (&pTxFrame->
3364 m_le_bMessageType)
3365 == (BYTE) kEplMsgTypeAsnd)
3366 &&
3367 (AmiGetByteFromLe
3368 (&pTxFrame->m_Data.m_Asnd.
3369 m_le_bServiceId)
3370 == (BYTE) kEplDllAsndNmtCommand)) { // post event directly to NmtMnu module
3371 Event.m_EventSink =
3372 kEplEventSinkNmtMnu;
3373 Event.m_EventType =
3374 kEplEventTypeNmtMnuNmtCmdSent;
3375 Event.m_uiSize =
3376 EplDllkInstance_g.
3377 m_pTxBuffer
3378 [EPL_DLLK_TXFRAME_NMTREQ].
3379 m_uiTxMsgLen;
3380 Event.m_pArg = pTxFrame;
3381 Ret =
3382 EplEventkPost
3383 (&Event);
3384
3385 }
3386 // send NmtRequest
3387 Ret =
3388 EdrvSendTxMsg
3389 (&EplDllkInstance_g.
3390 m_pTxBuffer
3391 [EPL_DLLK_TXFRAME_NMTREQ]);
3392 if (Ret != kEplSuccessful) {
3393 goto Exit;
3394 }
3395
3396 }
3397 }
3398
3399 } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceUnspecified) { // unspecified invite
3400 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL) { // non-EPL frame does exist
3401 // check if frame is not empty and not being filled
3402 if (EplDllkInstance_g.
3403 m_pTxBuffer
3404 [EPL_DLLK_TXFRAME_NONEPL].
3405 m_uiTxMsgLen >
3406 EPL_DLLK_BUFLEN_FILLING) {
3407 // send non-EPL frame
3408 Ret =
3409 EdrvSendTxMsg
3410 (&EplDllkInstance_g.
3411 m_pTxBuffer
3412 [EPL_DLLK_TXFRAME_NONEPL]);
3413 if (Ret != kEplSuccessful) {
3414 goto Exit;
3415 }
3416
3417 }
3418 }
3419 }
3420 // ASnd frame was sent, remove the request
3421 EplDllkInstance_g.m_LastReqServiceId =
3422 kEplDllReqServiceNo;
3423 }
3424 // forward event to ErrorHandler and PDO module
3425 Event.m_EventSink = kEplEventSinkNmtk;
3426 Event.m_EventType = kEplEventTypeNmtEvent;
3427 Event.m_uiSize = sizeof(NmtEvent);
3428 Event.m_pArg = &NmtEvent;
3429 Ret = EplEventkPost(&Event);
3430 if (Ret != kEplSuccessful) {
3431 goto Exit;
3432 }
3433 }
3434 #endif
3435
3436 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3437 else { // d.k.: Why that else? on CN it is entered on IdentRes and StatusRes
3438 goto Exit;
3439 }
3440
3441 // signal process function readiness of PRes frame
3442 Event.m_EventSink = kEplEventSinkDllk;
3443 Event.m_EventType = kEplEventTypeDllkPresReady;
3444 Event.m_uiSize = 0;
3445 Event.m_pArg = NULL;
3446 Ret = EplEventkPost(&Event);
3447
3448 #endif
3449
3450 Exit:
3451 if (Ret != kEplSuccessful) {
3452 DWORD dwArg;
3453
3454 BENCHMARK_MOD_02_TOGGLE(9);
3455
3456 dwArg =
3457 EplDllkInstance_g.m_DllState | (pTxBuffer_p->
3458 m_EplMsgType << 16);
3459
3460 // Error event for API layer
3461 Ret = EplEventkPostError(kEplEventSourceDllk,
3462 Ret, sizeof(dwArg), &dwArg);
3463 }
3464
3465 return;
3466 }
3467
3468 //---------------------------------------------------------------------------
3469 //
3470 // Function: EplDllkCheckFrame()
3471 //
3472 // Description: check frame and set missing information
3473 //
3474 // Parameters: pFrame_p = ethernet frame
3475 // uiFrameSize_p = size of frame
3476 //
3477 // Returns: tEplKernel = error code
3478 //
3479 //
3480 // State:
3481 //
3482 //---------------------------------------------------------------------------
3483
3484 static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
3485 unsigned int uiFrameSize_p)
3486 {
3487 tEplMsgType MsgType;
3488 WORD wEtherType;
3489
3490 // check frame
3491 if (pFrame_p != NULL) {
3492 // check SrcMAC
3493 if (AmiGetQword48FromBe(pFrame_p->m_be_abSrcMac) == 0) {
3494 // source MAC address
3495 EPL_MEMCPY(&pFrame_p->m_be_abSrcMac[0],
3496 &EplDllkInstance_g.m_be_abSrcMac[0], 6);
3497 }
3498 // check ethertype
3499 wEtherType = AmiGetWordFromBe(&pFrame_p->m_be_wEtherType);
3500 if (wEtherType == 0) {
3501 // assume EPL frame
3502 wEtherType = EPL_C_DLL_ETHERTYPE_EPL;
3503 AmiSetWordToBe(&pFrame_p->m_be_wEtherType, wEtherType);
3504 }
3505
3506 if (wEtherType == EPL_C_DLL_ETHERTYPE_EPL) {
3507 // source node ID
3508 AmiSetByteToLe(&pFrame_p->m_le_bSrcNodeId,
3509 (BYTE) EplDllkInstance_g.
3510 m_DllConfigParam.m_uiNodeId);
3511
3512 // check message type
3513 MsgType =
3514 AmiGetByteFromLe(&pFrame_p->m_le_bMessageType);
3515 if (MsgType == 0) {
3516 MsgType = kEplMsgTypeAsnd;
3517 AmiSetByteToLe(&pFrame_p->m_le_bMessageType,
3518 (BYTE) MsgType);
3519 }
3520
3521 if (MsgType == kEplMsgTypeAsnd) {
3522 // destination MAC address
3523 AmiSetQword48ToBe(&pFrame_p->m_be_abDstMac[0],
3524 EPL_C_DLL_MULTICAST_ASND);
3525 }
3526
3527 }
3528 }
3529
3530 return kEplSuccessful;
3531 }
3532
3533 //---------------------------------------------------------------------------
3534 //
3535 // Function: EplDllkCbCnTimer()
3536 //
3537 // Description: called by timer module. It monitors the EPL cycle when it is a CN.
3538 //
3539 // Parameters: pEventArg_p = timer event argument
3540 //
3541 // Returns: tEplKernel = error code
3542 //
3543 //
3544 // State:
3545 //
3546 //---------------------------------------------------------------------------
3547
3548 #if EPL_TIMER_USE_HIGHRES != FALSE
3549 static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p)
3550 {
3551 tEplKernel Ret = kEplSuccessful;
3552 tEplNmtState NmtState;
3553
3554 #if EPL_TIMER_USE_HIGHRES != FALSE
3555 if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle) { // zombie callback
3556 // just exit
3557 goto Exit;
3558 }
3559 #endif
3560
3561 NmtState = EplNmtkGetNmtState();
3562
3563 if (NmtState <= kEplNmtGsResetConfiguration) {
3564 goto Exit;
3565 }
3566
3567 Ret = EplDllkChangeState(kEplNmtEventDllCeFrameTimeout, NmtState);
3568 if (Ret != kEplSuccessful) {
3569 goto Exit;
3570 }
3571 // 2008/10/15 d.k. reprogramming of timer not necessary,
3572 // because it will be programmed, when SoC is received.
3573 /*
3574 // reprogram timer
3575 #if EPL_TIMER_USE_HIGHRES != FALSE
3576 if ((NmtState > kEplNmtCsPreOperational1)
3577 && (EplDllkInstance_g.m_ullFrameTimeout != 0))
3578 {
3579 Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle, EplDllkInstance_g.m_ullFrameTimeout, EplDllkCbCnTimer, 0L, FALSE);
3580 }
3581 #endif
3582 */
3583
3584 Exit:
3585 if (Ret != kEplSuccessful) {
3586 DWORD dwArg;
3587
3588 BENCHMARK_MOD_02_TOGGLE(9);
3589
3590 dwArg =
3591 EplDllkInstance_g.
3592 m_DllState | (kEplNmtEventDllCeFrameTimeout << 8);
3593
3594 // Error event for API layer
3595 Ret = EplEventkPostError(kEplEventSourceDllk,
3596 Ret, sizeof(dwArg), &dwArg);
3597 }
3598
3599 return Ret;
3600 }
3601 #endif
3602
3603 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3604
3605 //---------------------------------------------------------------------------
3606 //
3607 // Function: EplDllkCbMnTimerCycle()
3608 //
3609 // Description: called by timer module. It triggers the SoC when it is a MN.
3610 //
3611 // Parameters: pEventArg_p = timer event argument
3612 //
3613 // Returns: tEplKernel = error code
3614 //
3615 //
3616 // State:
3617 //
3618 //---------------------------------------------------------------------------
3619
3620 static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p)
3621 {
3622 tEplKernel Ret = kEplSuccessful;
3623 tEplNmtState NmtState;
3624
3625 #if EPL_TIMER_USE_HIGHRES != FALSE
3626 if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle) { // zombie callback
3627 // just exit
3628 goto Exit;
3629 }
3630 #endif
3631
3632 NmtState = EplNmtkGetNmtState();
3633
3634 if (NmtState <= kEplNmtGsResetConfiguration) {
3635 goto Exit;
3636 }
3637
3638 Ret = EplDllkChangeState(kEplNmtEventDllMeSocTrig, NmtState);
3639
3640 Exit:
3641 if (Ret != kEplSuccessful) {
3642 DWORD dwArg;
3643
3644 BENCHMARK_MOD_02_TOGGLE(9);
3645
3646 dwArg =
3647 EplDllkInstance_g.
3648 m_DllState | (kEplNmtEventDllMeSocTrig << 8);
3649
3650 // Error event for API layer
3651 Ret = EplEventkPostError(kEplEventSourceDllk,
3652 Ret, sizeof(dwArg), &dwArg);
3653 }
3654
3655 return Ret;
3656 }
3657
3658 //---------------------------------------------------------------------------
3659 //
3660 // Function: EplDllkCbMnTimerResponse()
3661 //
3662 // Description: called by timer module. It monitors the PRes timeout.
3663 //
3664 // Parameters: pEventArg_p = timer event argument
3665 //
3666 // Returns: tEplKernel = error code
3667 //
3668 //
3669 // State:
3670 //
3671 //---------------------------------------------------------------------------
3672
3673 static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg *
3674 pEventArg_p)
3675 {
3676 tEplKernel Ret = kEplSuccessful;
3677 tEplNmtState NmtState;
3678
3679 #if EPL_TIMER_USE_HIGHRES != FALSE
3680 if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlResponse) { // zombie callback
3681 // just exit
3682 goto Exit;
3683 }
3684 #endif
3685
3686 NmtState = EplNmtkGetNmtState();
3687
3688 if (NmtState <= kEplNmtGsResetConfiguration) {
3689 goto Exit;
3690 }
3691
3692 Ret = EplDllkChangeState(kEplNmtEventDllMePresTimeout, NmtState);
3693
3694 Exit:
3695 if (Ret != kEplSuccessful) {
3696 DWORD dwArg;
3697
3698 BENCHMARK_MOD_02_TOGGLE(9);
3699
3700 dwArg =
3701 EplDllkInstance_g.
3702 m_DllState | (kEplNmtEventDllMePresTimeout << 8);
3703
3704 // Error event for API layer
3705 Ret = EplEventkPostError(kEplEventSourceDllk,
3706 Ret, sizeof(dwArg), &dwArg);
3707 }
3708
3709 return Ret;
3710 }
3711
3712 //---------------------------------------------------------------------------
3713 //
3714 // Function: EplDllkGetNodeInfo()
3715 //
3716 // Description: returns node info structure of the specified node.
3717 //
3718 // Parameters: uiNodeId_p = node ID
3719 //
3720 // Returns: tEplDllkNodeInfo* = pointer to internal node info structure
3721 //
3722 //
3723 // State:
3724 //
3725 //---------------------------------------------------------------------------
3726
3727 static tEplDllkNodeInfo *EplDllkGetNodeInfo(unsigned int uiNodeId_p)
3728 {
3729 // $$$ d.k.: use hash algorithm to retrieve the appropriate node info structure
3730 // if size of array is less than 254.
3731 uiNodeId_p--; // node ID starts at 1 but array at 0
3732 if (uiNodeId_p >= tabentries(EplDllkInstance_g.m_aNodeInfo)) {
3733 return NULL;
3734 } else {
3735 return &EplDllkInstance_g.m_aNodeInfo[uiNodeId_p];
3736 }
3737 }
3738
3739 //---------------------------------------------------------------------------
3740 //
3741 // Function: EplDllkMnSendSoa()
3742 //
3743 // Description: it updates and transmits the SoA.
3744 //
3745 // Parameters: NmtState_p = current NMT state
3746 // pDllStateProposed_p = proposed DLL state
3747 // fEnableInvitation_p = enable invitation for asynchronous phase
3748 // it will be disabled for EPL_C_DLL_PREOP1_START_CYCLES SoAs
3749 //
3750 // Returns: tEplKernel = error code
3751 //
3752 //
3753 // State:
3754 //
3755 //---------------------------------------------------------------------------
3756
3757 static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
3758 tEplDllState * pDllStateProposed_p,
3759 BOOL fEnableInvitation_p)
3760 {
3761 tEplKernel Ret = kEplSuccessful;
3762 tEdrvTxBuffer *pTxBuffer = NULL;
3763 tEplFrame *pTxFrame;
3764 tEplDllkNodeInfo *pNodeInfo;
3765
3766 *pDllStateProposed_p = kEplDllMsNonCyclic;
3767
3768 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOA];
3769 if (pTxBuffer->m_pbBuffer != NULL) { // SoA does exist
3770 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3771
3772 if (fEnableInvitation_p != FALSE) { // fetch target of asynchronous phase
3773 if (EplDllkInstance_g.m_bFlag2 == 0) { // own queues are empty
3774 EplDllkInstance_g.m_LastReqServiceId =
3775 kEplDllReqServiceNo;
3776 } else if (((tEplDllAsyncReqPriority) (EplDllkInstance_g.m_bFlag2 >> EPL_FRAME_FLAG2_PR_SHIFT)) == kEplDllAsyncReqPrioNmt) { // frames in own NMT request queue available
3777 EplDllkInstance_g.m_LastReqServiceId =
3778 kEplDllReqServiceNmtRequest;
3779 } else {
3780 EplDllkInstance_g.m_LastReqServiceId =
3781 kEplDllReqServiceUnspecified;
3782 }
3783 Ret =
3784 EplDllkCalAsyncGetSoaRequest(&EplDllkInstance_g.
3785 m_LastReqServiceId,
3786 &EplDllkInstance_g.
3787 m_uiLastTargetNodeId);
3788 if (Ret != kEplSuccessful) {
3789 goto Exit;
3790 }
3791 if (EplDllkInstance_g.m_LastReqServiceId != kEplDllReqServiceNo) { // asynchronous phase will be assigned to one node
3792 if (EplDllkInstance_g.m_uiLastTargetNodeId == EPL_C_ADR_INVALID) { // exchange invalid node ID with local node ID
3793 EplDllkInstance_g.m_uiLastTargetNodeId =
3794 EplDllkInstance_g.m_DllConfigParam.
3795 m_uiNodeId;
3796 // d.k. DLL state WaitAsndTrig is not helpful;
3797 // so just step over to WaitSocTrig,
3798 // because own ASnd is sent automatically in CbFrameTransmitted() after SoA.
3799 //*pDllStateProposed_p = kEplDllMsWaitAsndTrig;
3800 *pDllStateProposed_p =
3801 kEplDllMsWaitSocTrig;
3802 } else { // assignment to CN
3803 *pDllStateProposed_p =
3804 kEplDllMsWaitAsnd;
3805 }
3806
3807 pNodeInfo =
3808 EplDllkGetNodeInfo(EplDllkInstance_g.
3809 m_uiLastTargetNodeId);
3810 if (pNodeInfo == NULL) { // no node info structure available
3811 Ret = kEplDllNoNodeInfo;
3812 goto Exit;
3813 }
3814 // update frame (EA, ER flags)
3815 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3816 m_le_bFlag1,
3817 pNodeInfo->
3818 m_bSoaFlag1 & (EPL_FRAME_FLAG1_EA
3819 |
3820 EPL_FRAME_FLAG1_ER));
3821 } else { // no assignment of asynchronous phase
3822 *pDllStateProposed_p = kEplDllMsWaitSocTrig;
3823 EplDllkInstance_g.m_uiLastTargetNodeId =
3824 EPL_C_ADR_INVALID;
3825 }
3826
3827 // update frame (target)
3828 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3829 m_le_bReqServiceId,
3830 (BYTE) EplDllkInstance_g.
3831 m_LastReqServiceId);
3832 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3833 m_le_bReqServiceTarget,
3834 (BYTE) EplDllkInstance_g.
3835 m_uiLastTargetNodeId);
3836
3837 } else { // invite nobody
3838 // update frame (target)
3839 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3840 m_le_bReqServiceId, (BYTE) 0);
3841 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3842 m_le_bReqServiceTarget, (BYTE) 0);
3843 }
3844
3845 // update frame (NMT state)
3846 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bNmtStatus,
3847 (BYTE) NmtState_p);
3848
3849 // send SoA frame
3850 Ret = EdrvSendTxMsg(pTxBuffer);
3851 }
3852
3853 Exit:
3854 return Ret;
3855 }
3856
3857 //---------------------------------------------------------------------------
3858 //
3859 // Function: EplDllkMnSendSoc()
3860 //
3861 // Description: it updates and transmits the SoA.
3862 //
3863 // Parameters: (none)
3864 //
3865 // Returns: tEplKernel = error code
3866 //
3867 //
3868 // State:
3869 //
3870 //---------------------------------------------------------------------------
3871
3872 static tEplKernel EplDllkMnSendSoc(void)
3873 {
3874 tEplKernel Ret = kEplSuccessful;
3875 tEdrvTxBuffer *pTxBuffer = NULL;
3876 tEplFrame *pTxFrame;
3877 tEplEvent Event;
3878
3879 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOC];
3880 if (pTxBuffer->m_pbBuffer != NULL) { // SoC does exist
3881 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3882
3883 // $$$ update NetTime
3884
3885 // send SoC frame
3886 Ret = EdrvSendTxMsg(pTxBuffer);
3887 if (Ret != kEplSuccessful) {
3888 goto Exit;
3889 }
3890 // trigger synchronous task
3891 Event.m_EventSink = kEplEventSinkSync;
3892 Event.m_EventType = kEplEventTypeSync;
3893 Event.m_uiSize = 0;
3894 Ret = EplEventkPost(&Event);
3895 }
3896
3897 Exit:
3898 return Ret;
3899 }
3900
3901 //---------------------------------------------------------------------------
3902 //
3903 // Function: EplDllkMnSendPreq()
3904 //
3905 // Description: it updates and transmits the PReq for the next isochronous CN
3906 // or own PRes if enabled.
3907 //
3908 // Parameters: NmtState_p = current NMT state
3909 // pDllStateProposed_p = proposed DLL state
3910 //
3911 // Returns: tEplKernel = error code
3912 //
3913 //
3914 // State:
3915 //
3916 //---------------------------------------------------------------------------
3917
3918 static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
3919 tEplDllState * pDllStateProposed_p)
3920 {
3921 tEplKernel Ret = kEplSuccessful;
3922 tEdrvTxBuffer *pTxBuffer = NULL;
3923 tEplFrame *pTxFrame;
3924 BYTE bFlag1 = 0;
3925
3926 if (EplDllkInstance_g.m_pCurNodeInfo == NULL) { // start with first isochronous CN
3927 EplDllkInstance_g.m_pCurNodeInfo =
3928 EplDllkInstance_g.m_pFirstNodeInfo;
3929 } else { // iterate to next isochronous CN
3930 EplDllkInstance_g.m_pCurNodeInfo =
3931 EplDllkInstance_g.m_pCurNodeInfo->m_pNextNodeInfo;
3932 }
3933
3934 if (EplDllkInstance_g.m_pCurNodeInfo == NULL) { // last isochronous CN reached
3935 Ret = EplDllkMnSendSoa(NmtState_p, pDllStateProposed_p, TRUE);
3936 goto Exit;
3937 } else {
3938 pTxBuffer = EplDllkInstance_g.m_pCurNodeInfo->m_pPreqTxBuffer;
3939 bFlag1 =
3940 EplDllkInstance_g.m_pCurNodeInfo->
3941 m_bSoaFlag1 & EPL_FRAME_FLAG1_EA;
3942 *pDllStateProposed_p = kEplDllMsWaitPres;
3943
3944 // start PRes Timer
3945 // $$$ d.k.: maybe move this call to CbFrameTransmitted(), because the time should run from there
3946 #if EPL_TIMER_USE_HIGHRES != FALSE
3947 Ret =
3948 EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.
3949 m_TimerHdlResponse,
3950 EplDllkInstance_g.
3951 m_pCurNodeInfo->
3952 m_dwPresTimeout,
3953 EplDllkCbMnTimerResponse, 0L,
3954 FALSE);
3955 #endif
3956 }
3957
3958 if (pTxBuffer == NULL) { // PReq does not exist
3959 Ret = kEplDllTxBufNotReady;
3960 goto Exit;
3961 }
3962
3963 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3964
3965 if (pTxFrame != NULL) { // PReq does exist
3966 if (NmtState_p == kEplNmtMsOperational) { // leave RD flag untouched
3967 bFlag1 |=
3968 AmiGetByteFromLe(&pTxFrame->m_Data.m_Preq.
3969 m_le_bFlag1) & EPL_FRAME_FLAG1_RD;
3970 }
3971
3972 if (pTxBuffer == &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES]) { // PRes of MN will be sent
3973 // update NMT state
3974 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus,
3975 (BYTE) NmtState_p);
3976 *pDllStateProposed_p = kEplDllMsWaitSoaTrig;
3977 }
3978 // $$$ d.k. set EPL_FRAME_FLAG1_MS if necessary
3979 // update frame (Flag1)
3980 AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, bFlag1);
3981
3982 // calculate frame size from payload size
3983 pTxBuffer->m_uiTxMsgLen =
3984 AmiGetWordFromLe(&pTxFrame->m_Data.m_Preq.m_le_wSize) + 24;
3985
3986 // send PReq frame
3987 Ret = EdrvSendTxMsg(pTxBuffer);
3988 } else {
3989 Ret = kEplDllTxFrameInvalid;
3990 }
3991
3992 Exit:
3993 return Ret;
3994 }
3995
3996 //---------------------------------------------------------------------------
3997 //
3998 // Function: EplDllkAsyncFrameNotReceived()
3999 //
4000 // Description: passes empty ASnd frame to receive FIFO.
4001 // It will be called only for frames with registered AsndServiceIds
4002 // (only kEplDllAsndFilterAny).
4003 //
4004 // Parameters: none
4005 //
4006 // Returns: tEplKernel = error code
4007 //
4008 //
4009 // State:
4010 //
4011 //---------------------------------------------------------------------------
4012
4013 static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
4014 ReqServiceId_p,
4015 unsigned int uiNodeId_p)
4016 {
4017 tEplKernel Ret = kEplSuccessful;
4018 BYTE abBuffer[18];
4019 tEplFrame *pFrame = (tEplFrame *) abBuffer;
4020 tEplFrameInfo FrameInfo;
4021
4022 // check if previous SoA invitation was not answered
4023 switch (ReqServiceId_p) {
4024 case kEplDllReqServiceIdent:
4025 case kEplDllReqServiceStatus:
4026 // ASnd service registered?
4027 if (EplDllkInstance_g.m_aAsndFilter[ReqServiceId_p] == kEplDllAsndFilterAny) { // ASnd service ID is registered
4028 AmiSetByteToLe(&pFrame->m_le_bSrcNodeId,
4029 (BYTE) uiNodeId_p);
4030 // EPL MsgType ASnd
4031 AmiSetByteToLe(&pFrame->m_le_bMessageType,
4032 (BYTE) kEplMsgTypeAsnd);
4033 // ASnd Service ID
4034 AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId,
4035 (BYTE) ReqServiceId_p);
4036 // create frame info structure
4037 FrameInfo.m_pFrame = pFrame;
4038 FrameInfo.m_uiFrameSize = 18; // empty non existing ASnd frame
4039 // forward frame via async receive FIFO to userspace
4040 Ret = EplDllkCalAsyncFrameReceived(&FrameInfo);
4041 }
4042 break;
4043 default:
4044 // no invitation issued or it was successfully answered or it is uninteresting
4045 break;
4046 }
4047
4048 return Ret;
4049 }
4050
4051 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
4052
4053 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
4054 // EOF
Support for the Chinese Samsung S3C2440 based development boards