Commit | Line | Data |
---|---|---|
9d7164cf DK |
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 Communication Abstraction Layer 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: EplDllkCal.c,v $ | |
53 | ||
54 | $Author: D.Krueger $ | |
55 | ||
56 | $Revision: 1.7 $ $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/15 d.k.: start of the implementation, version 1.00 | |
68 | ||
69 | ****************************************************************************/ | |
70 | ||
71 | #include "kernel/EplDllkCal.h" | |
72 | #include "kernel/EplDllk.h" | |
73 | #include "kernel/EplEventk.h" | |
74 | ||
75 | #include "EplDllCal.h" | |
76 | #ifndef EPL_NO_FIFO | |
77 | #include "SharedBuff.h" | |
78 | #endif | |
79 | ||
80 | #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) | |
81 | /***************************************************************************/ | |
82 | /* */ | |
83 | /* */ | |
84 | /* G L O B A L D E F I N I T I O N S */ | |
85 | /* */ | |
86 | /* */ | |
87 | /***************************************************************************/ | |
88 | ||
89 | //--------------------------------------------------------------------------- | |
90 | // const defines | |
91 | //--------------------------------------------------------------------------- | |
92 | ||
93 | #ifndef min | |
94 | #define min(a,b) (((a) < (b)) ? (a) : (b)) | |
95 | #endif | |
96 | ||
97 | //--------------------------------------------------------------------------- | |
98 | // local types | |
99 | //--------------------------------------------------------------------------- | |
100 | ||
101 | //--------------------------------------------------------------------------- | |
102 | // modul globale vars | |
103 | //--------------------------------------------------------------------------- | |
104 | ||
105 | //--------------------------------------------------------------------------- | |
106 | // local function prototypes | |
107 | //--------------------------------------------------------------------------- | |
108 | ||
9d7164cf DK |
109 | /***************************************************************************/ |
110 | /* */ | |
111 | /* */ | |
112 | /* C L A S S EplDllkCal */ | |
113 | /* */ | |
114 | /* */ | |
115 | /***************************************************************************/ | |
116 | // | |
117 | // Description: | |
118 | // | |
119 | // | |
120 | /***************************************************************************/ | |
121 | ||
9d7164cf DK |
122 | //=========================================================================// |
123 | // // | |
124 | // P R I V A T E D E F I N I T I O N S // | |
125 | // // | |
126 | //=========================================================================// | |
127 | ||
128 | //--------------------------------------------------------------------------- | |
129 | // const defines | |
130 | //--------------------------------------------------------------------------- | |
131 | ||
833dfbe7 | 132 | #define EPL_DLLKCAL_MAX_QUEUES 5 // CnGenReq, CnNmtReq, {MnGenReq, MnNmtReq}, MnIdentReq, MnStatusReq |
9d7164cf DK |
133 | |
134 | //--------------------------------------------------------------------------- | |
135 | // local types | |
136 | //--------------------------------------------------------------------------- | |
137 | ||
833dfbe7 | 138 | typedef struct { |
9d7164cf DK |
139 | #ifndef EPL_NO_FIFO |
140 | // tShbInstance m_ShbInstanceRx; // FIFO for Rx ASnd frames | |
833dfbe7 GKH |
141 | tShbInstance m_ShbInstanceTxNmt; // FIFO for Tx frames with NMT request priority |
142 | tShbInstance m_ShbInstanceTxGen; // FIFO for Tx frames with generic priority | |
9d7164cf | 143 | #else |
833dfbe7 GKH |
144 | unsigned int m_uiFrameSizeNmt; |
145 | BYTE m_abFrameNmt[1500]; | |
146 | unsigned int m_uiFrameSizeGen; | |
147 | BYTE m_abFrameGen[1500]; | |
9d7164cf DK |
148 | #endif |
149 | ||
833dfbe7 | 150 | tEplDllkCalStatistics m_Statistics; |
9d7164cf DK |
151 | |
152 | #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) | |
833dfbe7 GKH |
153 | // IdentRequest queue with CN node IDs |
154 | unsigned int m_auiQueueIdentReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty | |
155 | unsigned int m_uiWriteIdentReq; | |
156 | unsigned int m_uiReadIdentReq; | |
157 | ||
158 | // StatusRequest queue with CN node IDs | |
159 | unsigned int m_auiQueueStatusReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty | |
160 | unsigned int m_uiWriteStatusReq; | |
161 | unsigned int m_uiReadStatusReq; | |
162 | ||
163 | unsigned int m_auiQueueCnRequests[254 * 2]; | |
164 | // first 254 entries represent the generic requests of the corresponding node | |
165 | // second 254 entries represent the NMT requests of the corresponding node | |
166 | unsigned int m_uiNextQueueCnRequest; | |
167 | unsigned int m_uiNextRequestQueue; | |
9d7164cf DK |
168 | #endif |
169 | ||
170 | } tEplDllkCalInstance; | |
171 | ||
172 | //--------------------------------------------------------------------------- | |
173 | // local vars | |
174 | //--------------------------------------------------------------------------- | |
175 | ||
176 | // if no dynamic memory allocation shall be used | |
177 | // define structures statically | |
833dfbe7 | 178 | static tEplDllkCalInstance EplDllkCalInstance_g; |
9d7164cf DK |
179 | |
180 | //--------------------------------------------------------------------------- | |
181 | // local function prototypes | |
182 | //--------------------------------------------------------------------------- | |
183 | ||
9d7164cf DK |
184 | //=========================================================================// |
185 | // // | |
186 | // P U B L I C F U N C T I O N S // | |
187 | // // | |
188 | //=========================================================================// | |
189 | ||
190 | //--------------------------------------------------------------------------- | |
191 | // | |
192 | // Function: EplDllkCalAddInstance() | |
193 | // | |
194 | // Description: add and initialize new instance of DLL CAL module | |
195 | // | |
196 | // Parameters: none | |
197 | // | |
198 | // Returns: tEplKernel = error code | |
199 | // | |
200 | // | |
201 | // State: | |
202 | // | |
203 | //--------------------------------------------------------------------------- | |
204 | ||
205 | tEplKernel EplDllkCalAddInstance() | |
206 | { | |
833dfbe7 | 207 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 208 | #ifndef EPL_NO_FIFO |
833dfbe7 GKH |
209 | tShbError ShbError; |
210 | unsigned int fShbNewCreated; | |
9d7164cf DK |
211 | |
212 | /* ShbError = ShbCirAllocBuffer (EPL_DLLCAL_BUFFER_SIZE_RX, EPL_DLLCAL_BUFFER_ID_RX, | |
213 | &EplDllkCalInstance_g.m_ShbInstanceRx, &fShbNewCreated); | |
214 | // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg | |
215 | ||
216 | if (ShbError != kShbOk) | |
217 | { | |
218 | Ret = kEplNoResource; | |
219 | } | |
220 | */ | |
833dfbe7 GKH |
221 | ShbError = |
222 | ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_NMT, | |
223 | EPL_DLLCAL_BUFFER_ID_TX_NMT, | |
224 | &EplDllkCalInstance_g.m_ShbInstanceTxNmt, | |
225 | &fShbNewCreated); | |
226 | // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg | |
9d7164cf | 227 | |
833dfbe7 GKH |
228 | if (ShbError != kShbOk) { |
229 | Ret = kEplNoResource; | |
230 | } | |
9d7164cf DK |
231 | |
232 | /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxNmt, EplDllkCalTxNmtSignalHandler, kShbPriorityNormal); | |
233 | // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg | |
234 | ||
235 | if (ShbError != kShbOk) | |
236 | { | |
237 | Ret = kEplNoResource; | |
238 | } | |
239 | */ | |
833dfbe7 GKH |
240 | ShbError = |
241 | ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_GEN, | |
242 | EPL_DLLCAL_BUFFER_ID_TX_GEN, | |
243 | &EplDllkCalInstance_g.m_ShbInstanceTxGen, | |
244 | &fShbNewCreated); | |
245 | // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg | |
9d7164cf | 246 | |
833dfbe7 GKH |
247 | if (ShbError != kShbOk) { |
248 | Ret = kEplNoResource; | |
249 | } | |
9d7164cf DK |
250 | |
251 | /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxGen, EplDllkCalTxGenSignalHandler, kShbPriorityNormal); | |
252 | // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg | |
253 | ||
254 | if (ShbError != kShbOk) | |
255 | { | |
256 | Ret = kEplNoResource; | |
257 | } | |
258 | */ | |
259 | #else | |
833dfbe7 GKH |
260 | EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
261 | EplDllkCalInstance_g.m_uiFrameSizeGen = 0; | |
9d7164cf DK |
262 | #endif |
263 | ||
833dfbe7 | 264 | return Ret; |
9d7164cf DK |
265 | } |
266 | ||
267 | //--------------------------------------------------------------------------- | |
268 | // | |
269 | // Function: EplDllkCalDelInstance() | |
270 | // | |
271 | // Description: deletes instance of DLL CAL module | |
272 | // | |
273 | // Parameters: none | |
274 | // | |
275 | // Returns: tEplKernel = error code | |
276 | // | |
277 | // | |
278 | // State: | |
279 | // | |
280 | //--------------------------------------------------------------------------- | |
281 | ||
282 | tEplKernel EplDllkCalDelInstance() | |
283 | { | |
833dfbe7 | 284 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 285 | #ifndef EPL_NO_FIFO |
833dfbe7 | 286 | tShbError ShbError; |
9d7164cf DK |
287 | |
288 | /* ShbError = ShbCirReleaseBuffer (EplDllkCalInstance_g.m_ShbInstanceRx); | |
289 | if (ShbError != kShbOk) | |
290 | { | |
291 | Ret = kEplNoResource; | |
292 | } | |
293 | EplDllkCalInstance_g.m_ShbInstanceRx = NULL; | |
294 | */ | |
833dfbe7 GKH |
295 | ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt); |
296 | if (ShbError != kShbOk) { | |
297 | Ret = kEplNoResource; | |
298 | } | |
299 | EplDllkCalInstance_g.m_ShbInstanceTxNmt = NULL; | |
300 | ||
301 | ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen); | |
302 | if (ShbError != kShbOk) { | |
303 | Ret = kEplNoResource; | |
304 | } | |
305 | EplDllkCalInstance_g.m_ShbInstanceTxGen = NULL; | |
9d7164cf DK |
306 | |
307 | #else | |
833dfbe7 GKH |
308 | EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
309 | EplDllkCalInstance_g.m_uiFrameSizeGen = 0; | |
9d7164cf DK |
310 | #endif |
311 | ||
833dfbe7 | 312 | return Ret; |
9d7164cf DK |
313 | } |
314 | ||
315 | //--------------------------------------------------------------------------- | |
316 | // | |
317 | // Function: EplDllkCalProcess | |
318 | // | |
319 | // Description: process the passed configuration | |
320 | // | |
321 | // Parameters: pEvent_p = event containing configuration options | |
322 | // | |
323 | // Returns: tEplKernel = error code | |
324 | // | |
325 | // | |
326 | // State: | |
327 | // | |
328 | //--------------------------------------------------------------------------- | |
329 | ||
330 | tEplKernel EplDllkCalProcess(tEplEvent * pEvent_p) | |
331 | { | |
833dfbe7 GKH |
332 | tEplKernel Ret = kEplSuccessful; |
333 | ||
334 | switch (pEvent_p->m_EventType) { | |
335 | case kEplEventTypeDllkServFilter: | |
336 | { | |
337 | tEplDllCalAsndServiceIdFilter *pServFilter; | |
338 | ||
339 | pServFilter = | |
340 | (tEplDllCalAsndServiceIdFilter *) pEvent_p->m_pArg; | |
341 | Ret = | |
342 | EplDllkSetAsndServiceIdFilter(pServFilter-> | |
343 | m_ServiceId, | |
344 | pServFilter-> | |
345 | m_Filter); | |
346 | break; | |
347 | } | |
9d7164cf DK |
348 | |
349 | #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) | |
833dfbe7 GKH |
350 | case kEplEventTypeDllkIssueReq: |
351 | { | |
352 | tEplDllCalIssueRequest *pIssueReq; | |
353 | ||
354 | pIssueReq = (tEplDllCalIssueRequest *) pEvent_p->m_pArg; | |
355 | Ret = | |
356 | EplDllkCalIssueRequest(pIssueReq->m_Service, | |
357 | pIssueReq->m_uiNodeId, | |
358 | pIssueReq->m_bSoaFlag1); | |
359 | break; | |
360 | } | |
361 | ||
362 | case kEplEventTypeDllkAddNode: | |
363 | { | |
364 | tEplDllNodeInfo *pNodeInfo; | |
365 | ||
366 | pNodeInfo = (tEplDllNodeInfo *) pEvent_p->m_pArg; | |
367 | Ret = EplDllkAddNode(pNodeInfo); | |
368 | break; | |
369 | } | |
370 | ||
371 | case kEplEventTypeDllkDelNode: | |
372 | { | |
373 | unsigned int *puiNodeId; | |
374 | ||
375 | puiNodeId = (unsigned int *)pEvent_p->m_pArg; | |
376 | Ret = EplDllkDeleteNode(*puiNodeId); | |
377 | break; | |
378 | } | |
379 | ||
380 | case kEplEventTypeDllkSoftDelNode: | |
381 | { | |
382 | unsigned int *puiNodeId; | |
383 | ||
384 | puiNodeId = (unsigned int *)pEvent_p->m_pArg; | |
385 | Ret = EplDllkSoftDeleteNode(*puiNodeId); | |
386 | break; | |
387 | } | |
9d7164cf DK |
388 | #endif |
389 | ||
833dfbe7 GKH |
390 | case kEplEventTypeDllkIdentity: |
391 | { | |
392 | tEplDllIdentParam *pIdentParam; | |
393 | ||
394 | pIdentParam = (tEplDllIdentParam *) pEvent_p->m_pArg; | |
395 | if (pIdentParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) { | |
396 | pIdentParam->m_uiSizeOfStruct = | |
397 | pEvent_p->m_uiSize; | |
398 | } | |
399 | Ret = EplDllkSetIdentity(pIdentParam); | |
400 | break; | |
401 | } | |
402 | ||
403 | case kEplEventTypeDllkConfig: | |
404 | { | |
405 | tEplDllConfigParam *pConfigParam; | |
406 | ||
407 | pConfigParam = (tEplDllConfigParam *) pEvent_p->m_pArg; | |
408 | if (pConfigParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) { | |
409 | pConfigParam->m_uiSizeOfStruct = | |
410 | pEvent_p->m_uiSize; | |
411 | } | |
412 | Ret = EplDllkConfig(pConfigParam); | |
413 | break; | |
414 | } | |
415 | ||
416 | default: | |
417 | break; | |
418 | } | |
9d7164cf DK |
419 | |
420 | //Exit: | |
833dfbe7 | 421 | return Ret; |
9d7164cf DK |
422 | } |
423 | ||
9d7164cf DK |
424 | //--------------------------------------------------------------------------- |
425 | // | |
426 | // Function: EplDllkCalAsyncGetTxCount() | |
427 | // | |
428 | // Description: returns count of Tx frames of FIFO with highest priority | |
429 | // | |
430 | // Parameters: none | |
431 | // | |
432 | // Returns: tEplKernel = error code | |
433 | // | |
434 | // | |
435 | // State: | |
436 | // | |
437 | //--------------------------------------------------------------------------- | |
438 | ||
833dfbe7 GKH |
439 | tEplKernel EplDllkCalAsyncGetTxCount(tEplDllAsyncReqPriority * pPriority_p, |
440 | unsigned int *puiCount_p) | |
9d7164cf | 441 | { |
833dfbe7 | 442 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 443 | #ifndef EPL_NO_FIFO |
833dfbe7 GKH |
444 | tShbError ShbError; |
445 | unsigned long ulFrameCount; | |
446 | ||
447 | // get frame count of Tx FIFO with NMT request priority | |
448 | ShbError = | |
449 | ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt, | |
450 | &ulFrameCount); | |
451 | // returns kShbOk, kShbInvalidArg | |
452 | ||
453 | // error handling | |
454 | if (ShbError != kShbOk) { | |
455 | Ret = kEplNoResource; | |
456 | goto Exit; | |
457 | } | |
458 | ||
459 | if (ulFrameCount > | |
460 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) { | |
461 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = | |
462 | ulFrameCount; | |
463 | } | |
464 | ||
465 | if (ulFrameCount != 0) { // NMT requests are in queue | |
466 | *pPriority_p = kEplDllAsyncReqPrioNmt; | |
467 | *puiCount_p = (unsigned int)ulFrameCount; | |
468 | goto Exit; | |
469 | } | |
470 | // get frame count of Tx FIFO with generic priority | |
471 | ShbError = | |
472 | ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen, | |
473 | &ulFrameCount); | |
474 | // returns kShbOk, kShbInvalidArg | |
475 | ||
476 | // error handling | |
477 | if (ShbError != kShbOk) { | |
478 | Ret = kEplNoResource; | |
479 | goto Exit; | |
480 | } | |
481 | ||
482 | if (ulFrameCount > | |
483 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) { | |
484 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = | |
485 | ulFrameCount; | |
486 | } | |
487 | ||
488 | *pPriority_p = kEplDllAsyncReqPrioGeneric; | |
489 | *puiCount_p = (unsigned int)ulFrameCount; | |
490 | ||
491 | Exit: | |
9d7164cf | 492 | #else |
833dfbe7 GKH |
493 | if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) { |
494 | *pPriority_p = kEplDllAsyncReqPrioNmt; | |
495 | *puiCount_p = 1; | |
496 | } else if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) { | |
497 | *pPriority_p = kEplDllAsyncReqPrioGeneric; | |
498 | *puiCount_p = 1; | |
499 | } else { | |
500 | *pPriority_p = kEplDllAsyncReqPrioGeneric; | |
501 | *puiCount_p = 0; | |
502 | } | |
9d7164cf DK |
503 | #endif |
504 | ||
833dfbe7 | 505 | return Ret; |
9d7164cf DK |
506 | } |
507 | ||
508 | //--------------------------------------------------------------------------- | |
509 | // | |
510 | // Function: EplDllkCalAsyncGetTxFrame() | |
511 | // | |
512 | // Description: returns Tx frames from FIFO with specified priority | |
513 | // | |
514 | // Parameters: pFrame_p = IN: pointer to buffer | |
515 | // puiFrameSize_p = IN: max size of buffer | |
516 | // OUT: actual size of frame | |
517 | // Priority_p = IN: priority | |
518 | // | |
519 | // Returns: tEplKernel = error code | |
520 | // | |
521 | // | |
522 | // State: | |
523 | // | |
524 | //--------------------------------------------------------------------------- | |
525 | ||
833dfbe7 GKH |
526 | tEplKernel EplDllkCalAsyncGetTxFrame(void *pFrame_p, |
527 | unsigned int *puiFrameSize_p, | |
528 | tEplDllAsyncReqPriority Priority_p) | |
9d7164cf | 529 | { |
833dfbe7 | 530 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 531 | #ifndef EPL_NO_FIFO |
833dfbe7 GKH |
532 | tShbError ShbError; |
533 | unsigned long ulFrameSize; | |
534 | ||
535 | switch (Priority_p) { | |
536 | case kEplDllAsyncReqPrioNmt: // NMT request priority | |
537 | ShbError = | |
538 | ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxNmt, | |
539 | (BYTE *) pFrame_p, *puiFrameSize_p, | |
540 | &ulFrameSize); | |
541 | // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData | |
542 | break; | |
543 | ||
544 | default: // generic priority | |
545 | ShbError = | |
546 | ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxGen, | |
547 | (BYTE *) pFrame_p, *puiFrameSize_p, | |
548 | &ulFrameSize); | |
549 | // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData | |
550 | break; | |
551 | ||
552 | } | |
553 | ||
554 | // error handling | |
555 | if (ShbError != kShbOk) { | |
556 | if (ShbError == kShbNoReadableData) { | |
557 | Ret = kEplDllAsyncTxBufferEmpty; | |
558 | } else { // other error | |
559 | Ret = kEplNoResource; | |
560 | } | |
561 | goto Exit; | |
562 | } | |
563 | ||
564 | *puiFrameSize_p = (unsigned int)ulFrameSize; | |
565 | ||
566 | Exit: | |
9d7164cf | 567 | #else |
833dfbe7 GKH |
568 | switch (Priority_p) { |
569 | case kEplDllAsyncReqPrioNmt: // NMT request priority | |
570 | *puiFrameSize_p = | |
571 | min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeNmt); | |
572 | EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameNmt, | |
573 | *puiFrameSize_p); | |
574 | EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; | |
575 | break; | |
576 | ||
577 | default: // generic priority | |
578 | *puiFrameSize_p = | |
579 | min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeGen); | |
580 | EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameGen, | |
581 | *puiFrameSize_p); | |
582 | EplDllkCalInstance_g.m_uiFrameSizeGen = 0; | |
583 | break; | |
584 | } | |
9d7164cf DK |
585 | |
586 | #endif | |
587 | ||
833dfbe7 | 588 | return Ret; |
9d7164cf DK |
589 | } |
590 | ||
591 | //--------------------------------------------------------------------------- | |
592 | // | |
593 | // Function: EplDllkCalAsyncFrameReceived() | |
594 | // | |
595 | // Description: passes ASnd frame to receive FIFO. | |
596 | // It will be called only for frames with registered AsndServiceIds. | |
597 | // | |
598 | // Parameters: none | |
599 | // | |
600 | // Returns: tEplKernel = error code | |
601 | // | |
602 | // | |
603 | // State: | |
604 | // | |
605 | //--------------------------------------------------------------------------- | |
606 | ||
607 | tEplKernel EplDllkCalAsyncFrameReceived(tEplFrameInfo * pFrameInfo_p) | |
608 | { | |
833dfbe7 GKH |
609 | tEplKernel Ret = kEplSuccessful; |
610 | tEplEvent Event; | |
611 | ||
612 | Event.m_EventSink = kEplEventSinkDlluCal; | |
613 | Event.m_EventType = kEplEventTypeAsndRx; | |
614 | Event.m_pArg = pFrameInfo_p->m_pFrame; | |
615 | Event.m_uiSize = pFrameInfo_p->m_uiFrameSize; | |
616 | // pass NetTime of frame to userspace | |
617 | Event.m_NetTime = pFrameInfo_p->m_NetTime; | |
618 | ||
619 | Ret = EplEventkPost(&Event); | |
620 | if (Ret != kEplSuccessful) { | |
621 | EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount++; | |
622 | } else { | |
623 | EplDllkCalInstance_g.m_Statistics.m_ulMaxRxFrameCount++; | |
624 | } | |
625 | ||
626 | return Ret; | |
9d7164cf DK |
627 | } |
628 | ||
9d7164cf DK |
629 | //--------------------------------------------------------------------------- |
630 | // | |
631 | // Function: EplDllkCalAsyncSend() | |
632 | // | |
633 | // Description: puts the given frame into the transmit FIFO with the specified | |
634 | // priority. | |
635 | // | |
636 | // Parameters: pFrameInfo_p = frame info structure | |
637 | // Priority_p = priority | |
638 | // | |
639 | // Returns: tEplKernel = error code | |
640 | // | |
641 | // | |
642 | // State: | |
643 | // | |
644 | //--------------------------------------------------------------------------- | |
645 | ||
833dfbe7 GKH |
646 | tEplKernel EplDllkCalAsyncSend(tEplFrameInfo * pFrameInfo_p, |
647 | tEplDllAsyncReqPriority Priority_p) | |
9d7164cf | 648 | { |
833dfbe7 GKH |
649 | tEplKernel Ret = kEplSuccessful; |
650 | tEplEvent Event; | |
9d7164cf | 651 | #ifndef EPL_NO_FIFO |
833dfbe7 GKH |
652 | tShbError ShbError; |
653 | ||
654 | switch (Priority_p) { | |
655 | case kEplDllAsyncReqPrioNmt: // NMT request priority | |
656 | ShbError = | |
657 | ShbCirWriteDataBlock(EplDllkCalInstance_g. | |
658 | m_ShbInstanceTxNmt, | |
659 | pFrameInfo_p->m_pFrame, | |
660 | pFrameInfo_p->m_uiFrameSize); | |
661 | // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg | |
662 | break; | |
663 | ||
664 | default: // generic priority | |
665 | ShbError = | |
666 | ShbCirWriteDataBlock(EplDllkCalInstance_g. | |
667 | m_ShbInstanceTxGen, | |
668 | pFrameInfo_p->m_pFrame, | |
669 | pFrameInfo_p->m_uiFrameSize); | |
670 | // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg | |
671 | break; | |
672 | ||
673 | } | |
674 | ||
675 | // error handling | |
676 | switch (ShbError) { | |
677 | case kShbOk: | |
678 | break; | |
679 | ||
680 | case kShbExceedDataSizeLimit: | |
681 | Ret = kEplDllAsyncTxBufferFull; | |
682 | break; | |
683 | ||
684 | case kShbBufferFull: | |
685 | Ret = kEplDllAsyncTxBufferFull; | |
686 | break; | |
687 | ||
688 | case kShbInvalidArg: | |
689 | default: | |
690 | Ret = kEplNoResource; | |
691 | break; | |
692 | } | |
9d7164cf DK |
693 | |
694 | #else | |
695 | ||
833dfbe7 GKH |
696 | switch (Priority_p) { |
697 | case kEplDllAsyncReqPrioNmt: // NMT request priority | |
698 | if (EplDllkCalInstance_g.m_uiFrameSizeNmt == 0) { | |
699 | EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameNmt, | |
700 | pFrameInfo_p->m_pFrame, | |
701 | pFrameInfo_p->m_uiFrameSize); | |
702 | EplDllkCalInstance_g.m_uiFrameSizeNmt = | |
703 | pFrameInfo_p->m_uiFrameSize; | |
704 | } else { | |
705 | Ret = kEplDllAsyncTxBufferFull; | |
706 | goto Exit; | |
707 | } | |
708 | break; | |
709 | ||
710 | default: // generic priority | |
711 | if (EplDllkCalInstance_g.m_uiFrameSizeGen == 0) { | |
712 | EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameGen, | |
713 | pFrameInfo_p->m_pFrame, | |
714 | pFrameInfo_p->m_uiFrameSize); | |
715 | EplDllkCalInstance_g.m_uiFrameSizeGen = | |
716 | pFrameInfo_p->m_uiFrameSize; | |
717 | } else { | |
718 | Ret = kEplDllAsyncTxBufferFull; | |
719 | goto Exit; | |
720 | } | |
721 | break; | |
722 | } | |
9d7164cf DK |
723 | |
724 | #endif | |
725 | ||
833dfbe7 GKH |
726 | // post event to DLL |
727 | Event.m_EventSink = kEplEventSinkDllk; | |
728 | Event.m_EventType = kEplEventTypeDllkFillTx; | |
729 | EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); | |
730 | Event.m_pArg = &Priority_p; | |
731 | Event.m_uiSize = sizeof(Priority_p); | |
732 | Ret = EplEventkPost(&Event); | |
9d7164cf DK |
733 | |
734 | #ifdef EPL_NO_FIFO | |
833dfbe7 | 735 | Exit: |
9d7164cf DK |
736 | #endif |
737 | ||
833dfbe7 | 738 | return Ret; |
9d7164cf DK |
739 | } |
740 | ||
9d7164cf DK |
741 | //--------------------------------------------------------------------------- |
742 | // | |
743 | // Function: EplDllkCalAsyncClearBuffer() | |
744 | // | |
745 | // Description: clears the transmit buffer | |
746 | // | |
747 | // Parameters: (none) | |
748 | // | |
749 | // Returns: tEplKernel = error code | |
750 | // | |
751 | // | |
752 | // State: | |
753 | // | |
754 | //--------------------------------------------------------------------------- | |
755 | ||
756 | tEplKernel EplDllkCalAsyncClearBuffer(void) | |
757 | { | |
833dfbe7 | 758 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 759 | #ifndef EPL_NO_FIFO |
833dfbe7 | 760 | tShbError ShbError; |
9d7164cf | 761 | |
833dfbe7 GKH |
762 | ShbError = |
763 | ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt, 1000, | |
764 | NULL); | |
765 | ShbError = | |
766 | ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen, 1000, | |
767 | NULL); | |
9d7164cf DK |
768 | |
769 | #else | |
833dfbe7 GKH |
770 | EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
771 | EplDllkCalInstance_g.m_uiFrameSizeGen = 0; | |
9d7164cf DK |
772 | #endif |
773 | ||
774 | // EPL_MEMSET(&EplDllkCalInstance_g.m_Statistics, 0, sizeof (tEplDllkCalStatistics)); | |
833dfbe7 | 775 | return Ret; |
9d7164cf DK |
776 | } |
777 | ||
9d7164cf DK |
778 | //--------------------------------------------------------------------------- |
779 | // | |
780 | // Function: EplDllkCalAsyncClearQueues() | |
781 | // | |
782 | // Description: clears the transmit buffer | |
783 | // | |
784 | // Parameters: (none) | |
785 | // | |
786 | // Returns: tEplKernel = error code | |
787 | // | |
788 | // | |
789 | // State: | |
790 | // | |
791 | //--------------------------------------------------------------------------- | |
792 | ||
793 | #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) | |
794 | tEplKernel EplDllkCalAsyncClearQueues(void) | |
795 | { | |
833dfbe7 | 796 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 797 | |
833dfbe7 GKH |
798 | // clear MN asynchronous queues |
799 | EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0; | |
800 | EplDllkCalInstance_g.m_uiNextRequestQueue = 0; | |
801 | EplDllkCalInstance_g.m_uiReadIdentReq = 0; | |
802 | EplDllkCalInstance_g.m_uiWriteIdentReq = 0; | |
803 | EplDllkCalInstance_g.m_uiReadStatusReq = 0; | |
804 | EplDllkCalInstance_g.m_uiWriteStatusReq = 0; | |
9d7164cf | 805 | |
833dfbe7 | 806 | return Ret; |
9d7164cf DK |
807 | } |
808 | #endif | |
809 | ||
9d7164cf DK |
810 | //--------------------------------------------------------------------------- |
811 | // | |
812 | // Function: EplDllkCalGetStatistics() | |
813 | // | |
814 | // Description: returns statistics of the asynchronous queues. | |
815 | // | |
816 | // Parameters: ppStatistics = statistics structure | |
817 | // | |
818 | // Returns: tEplKernel = error code | |
819 | // | |
820 | // | |
821 | // State: | |
822 | // | |
823 | //--------------------------------------------------------------------------- | |
824 | ||
825 | tEplKernel EplDllkCalGetStatistics(tEplDllkCalStatistics ** ppStatistics) | |
826 | { | |
833dfbe7 | 827 | tEplKernel Ret = kEplSuccessful; |
9d7164cf | 828 | #ifndef EPL_NO_FIFO |
833dfbe7 GKH |
829 | tShbError ShbError; |
830 | ||
831 | ShbError = | |
832 | ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt, | |
833 | &EplDllkCalInstance_g.m_Statistics. | |
834 | m_ulCurTxFrameCountNmt); | |
835 | ShbError = | |
836 | ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen, | |
837 | &EplDllkCalInstance_g.m_Statistics. | |
838 | m_ulCurTxFrameCountGen); | |
9d7164cf DK |
839 | // ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceRx, &EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount); |
840 | ||
841 | #else | |
833dfbe7 GKH |
842 | if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) { |
843 | EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 1; | |
844 | } else { | |
845 | EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 0; | |
846 | } | |
847 | if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) { | |
848 | EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 1; | |
849 | } else { | |
850 | EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 0; | |
851 | } | |
9d7164cf DK |
852 | #endif |
853 | ||
833dfbe7 GKH |
854 | *ppStatistics = &EplDllkCalInstance_g.m_Statistics; |
855 | return Ret; | |
9d7164cf DK |
856 | } |
857 | ||
9d7164cf DK |
858 | #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
859 | ||
860 | //--------------------------------------------------------------------------- | |
861 | // | |
862 | // Function: EplDllkCalIssueRequest() | |
863 | // | |
864 | // Description: issues a StatusRequest or a IdentRequest to the specified node. | |
865 | // | |
866 | // Parameters: Service_p = request service ID | |
867 | // uiNodeId_p = node ID | |
868 | // bSoaFlag1_p = flag1 for this node (transmit in SoA and PReq) | |
869 | // If 0xFF this flag is ignored. | |
870 | // | |
871 | // Returns: tEplKernel = error code | |
872 | // | |
873 | // | |
874 | // State: | |
875 | // | |
876 | //--------------------------------------------------------------------------- | |
877 | ||
833dfbe7 GKH |
878 | tEplKernel EplDllkCalIssueRequest(tEplDllReqServiceId Service_p, |
879 | unsigned int uiNodeId_p, BYTE bSoaFlag1_p) | |
9d7164cf | 880 | { |
833dfbe7 GKH |
881 | tEplKernel Ret = kEplSuccessful; |
882 | ||
883 | if (bSoaFlag1_p != 0xFF) { | |
884 | Ret = EplDllkSetFlag1OfNode(uiNodeId_p, bSoaFlag1_p); | |
885 | if (Ret != kEplSuccessful) { | |
886 | goto Exit; | |
887 | } | |
888 | } | |
889 | // add node to appropriate request queue | |
890 | switch (Service_p) { | |
891 | case kEplDllReqServiceIdent: | |
892 | { | |
893 | if (((EplDllkCalInstance_g.m_uiWriteIdentReq + | |
894 | 1) % | |
895 | tabentries(EplDllkCalInstance_g. | |
896 | m_auiQueueIdentReq)) | |
897 | == EplDllkCalInstance_g.m_uiReadIdentReq) { // queue is full | |
898 | Ret = kEplDllAsyncTxBufferFull; | |
899 | goto Exit; | |
900 | } | |
901 | EplDllkCalInstance_g. | |
902 | m_auiQueueIdentReq[EplDllkCalInstance_g. | |
903 | m_uiWriteIdentReq] = uiNodeId_p; | |
904 | EplDllkCalInstance_g.m_uiWriteIdentReq = | |
905 | (EplDllkCalInstance_g.m_uiWriteIdentReq + | |
906 | 1) % | |
907 | tabentries(EplDllkCalInstance_g.m_auiQueueIdentReq); | |
908 | break; | |
909 | } | |
910 | ||
911 | case kEplDllReqServiceStatus: | |
912 | { | |
913 | if (((EplDllkCalInstance_g.m_uiWriteStatusReq + | |
914 | 1) % | |
915 | tabentries(EplDllkCalInstance_g. | |
916 | m_auiQueueStatusReq)) | |
917 | == EplDllkCalInstance_g.m_uiReadStatusReq) { // queue is full | |
918 | Ret = kEplDllAsyncTxBufferFull; | |
919 | goto Exit; | |
920 | } | |
921 | EplDllkCalInstance_g. | |
922 | m_auiQueueStatusReq[EplDllkCalInstance_g. | |
923 | m_uiWriteStatusReq] = | |
924 | uiNodeId_p; | |
925 | EplDllkCalInstance_g.m_uiWriteStatusReq = | |
926 | (EplDllkCalInstance_g.m_uiWriteStatusReq + | |
927 | 1) % | |
928 | tabentries(EplDllkCalInstance_g. | |
929 | m_auiQueueStatusReq); | |
930 | break; | |
931 | } | |
932 | ||
933 | default: | |
934 | { | |
935 | Ret = kEplDllInvalidParam; | |
936 | goto Exit; | |
937 | } | |
938 | } | |
939 | ||
940 | Exit: | |
941 | return Ret; | |
9d7164cf DK |
942 | } |
943 | ||
9d7164cf DK |
944 | //--------------------------------------------------------------------------- |
945 | // | |
946 | // Function: EplDllkCalAsyncGetSoaRequest() | |
947 | // | |
948 | // Description: returns next request for SoA. This function is called by DLLk module. | |
949 | // | |
950 | // Parameters: pReqServiceId_p = pointer to request service ID | |
951 | // IN: available request for MN NMT or generic request queue (Flag2.PR) | |
952 | // or kEplDllReqServiceNo if queues are empty | |
953 | // OUT: next request | |
954 | // puiNodeId_p = OUT: pointer to node ID of next request | |
955 | // = EPL_C_ADR_INVALID, if request is self addressed | |
956 | // | |
957 | // Returns: tEplKernel = error code | |
958 | // | |
959 | // | |
960 | // State: | |
961 | // | |
962 | //--------------------------------------------------------------------------- | |
963 | ||
833dfbe7 GKH |
964 | tEplKernel EplDllkCalAsyncGetSoaRequest(tEplDllReqServiceId * pReqServiceId_p, |
965 | unsigned int *puiNodeId_p) | |
9d7164cf | 966 | { |
833dfbe7 GKH |
967 | tEplKernel Ret = kEplSuccessful; |
968 | unsigned int uiCount; | |
9d7164cf DK |
969 | |
970 | // *pReqServiceId_p = kEplDllReqServiceNo; | |
971 | ||
833dfbe7 GKH |
972 | for (uiCount = EPL_DLLKCAL_MAX_QUEUES; uiCount > 0; uiCount--) { |
973 | switch (EplDllkCalInstance_g.m_uiNextRequestQueue) { | |
974 | case 0: | |
975 | { // CnGenReq | |
976 | for (; | |
977 | EplDllkCalInstance_g. | |
978 | m_uiNextQueueCnRequest < | |
979 | (tabentries | |
980 | (EplDllkCalInstance_g. | |
981 | m_auiQueueCnRequests) / 2); | |
982 | EplDllkCalInstance_g. | |
983 | m_uiNextQueueCnRequest++) { | |
984 | if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found | |
985 | // remove one request from queue | |
986 | EplDllkCalInstance_g. | |
987 | m_auiQueueCnRequests | |
988 | [EplDllkCalInstance_g. | |
989 | m_uiNextQueueCnRequest]--; | |
990 | *puiNodeId_p = | |
991 | EplDllkCalInstance_g. | |
992 | m_uiNextQueueCnRequest + 1; | |
993 | *pReqServiceId_p = | |
994 | kEplDllReqServiceUnspecified; | |
995 | EplDllkCalInstance_g. | |
996 | m_uiNextQueueCnRequest++; | |
997 | if (EplDllkCalInstance_g.m_uiNextQueueCnRequest >= (tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { // last node reached | |
998 | // continue with CnNmtReq queue at next SoA | |
999 | EplDllkCalInstance_g. | |
1000 | m_uiNextRequestQueue | |
1001 | = 1; | |
1002 | } | |
1003 | goto Exit; | |
1004 | } | |
1005 | } | |
1006 | // all CnGenReq queues are empty -> continue with CnNmtReq queue | |
1007 | EplDllkCalInstance_g.m_uiNextRequestQueue = 1; | |
1008 | break; | |
1009 | } | |
1010 | ||
1011 | case 1: | |
1012 | { // CnNmtReq | |
1013 | for (; | |
1014 | EplDllkCalInstance_g. | |
1015 | m_uiNextQueueCnRequest < | |
1016 | tabentries(EplDllkCalInstance_g. | |
1017 | m_auiQueueCnRequests); | |
1018 | EplDllkCalInstance_g. | |
1019 | m_uiNextQueueCnRequest++) { | |
1020 | if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found | |
1021 | // remove one request from queue | |
1022 | EplDllkCalInstance_g. | |
1023 | m_auiQueueCnRequests | |
1024 | [EplDllkCalInstance_g. | |
1025 | m_uiNextQueueCnRequest]--; | |
1026 | *puiNodeId_p = | |
1027 | EplDllkCalInstance_g. | |
1028 | m_uiNextQueueCnRequest + 1 - | |
1029 | (tabentries | |
1030 | (EplDllkCalInstance_g. | |
1031 | m_auiQueueCnRequests) / | |
1032 | 2); | |
1033 | *pReqServiceId_p = | |
1034 | kEplDllReqServiceNmtRequest; | |
1035 | EplDllkCalInstance_g. | |
1036 | m_uiNextQueueCnRequest++; | |
1037 | if (EplDllkCalInstance_g.m_uiNextQueueCnRequest > tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests)) { // last node reached | |
1038 | // restart CnGenReq queue | |
1039 | EplDllkCalInstance_g. | |
1040 | m_uiNextQueueCnRequest | |
1041 | = 0; | |
1042 | // continue with MnGenReq queue at next SoA | |
1043 | EplDllkCalInstance_g. | |
1044 | m_uiNextRequestQueue | |
1045 | = 2; | |
1046 | } | |
1047 | goto Exit; | |
1048 | } | |
1049 | } | |
1050 | // restart CnGenReq queue | |
1051 | EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0; | |
1052 | // all CnNmtReq queues are empty -> continue with MnGenReq queue | |
1053 | EplDllkCalInstance_g.m_uiNextRequestQueue = 2; | |
1054 | break; | |
1055 | } | |
1056 | ||
1057 | case 2: | |
1058 | { // MnNmtReq and MnGenReq | |
1059 | // next queue will be MnIdentReq queue | |
1060 | EplDllkCalInstance_g.m_uiNextRequestQueue = 3; | |
1061 | if (*pReqServiceId_p != kEplDllReqServiceNo) { | |
1062 | *puiNodeId_p = EPL_C_ADR_INVALID; // DLLk must exchange this with the actual node ID | |
1063 | goto Exit; | |
1064 | } | |
1065 | break; | |
1066 | } | |
1067 | ||
1068 | case 3: | |
1069 | { // MnIdentReq | |
1070 | // next queue will be MnStatusReq queue | |
1071 | EplDllkCalInstance_g.m_uiNextRequestQueue = 4; | |
1072 | if (EplDllkCalInstance_g.m_uiReadIdentReq != EplDllkCalInstance_g.m_uiWriteIdentReq) { // queue is not empty | |
1073 | *puiNodeId_p = | |
1074 | EplDllkCalInstance_g. | |
1075 | m_auiQueueIdentReq | |
1076 | [EplDllkCalInstance_g. | |
1077 | m_uiReadIdentReq]; | |
1078 | EplDllkCalInstance_g.m_uiReadIdentReq = | |
1079 | (EplDllkCalInstance_g. | |
1080 | m_uiReadIdentReq + | |
1081 | 1) % | |
1082 | tabentries(EplDllkCalInstance_g. | |
1083 | m_auiQueueIdentReq); | |
1084 | *pReqServiceId_p = | |
1085 | kEplDllReqServiceIdent; | |
1086 | goto Exit; | |
1087 | } | |
1088 | break; | |
1089 | } | |
1090 | ||
1091 | case 4: | |
1092 | { // MnStatusReq | |
1093 | // next queue will be CnGenReq queue | |
1094 | EplDllkCalInstance_g.m_uiNextRequestQueue = 0; | |
1095 | if (EplDllkCalInstance_g.m_uiReadStatusReq != EplDllkCalInstance_g.m_uiWriteStatusReq) { // queue is not empty | |
1096 | *puiNodeId_p = | |
1097 | EplDllkCalInstance_g. | |
1098 | m_auiQueueStatusReq | |
1099 | [EplDllkCalInstance_g. | |
1100 | m_uiReadStatusReq]; | |
1101 | EplDllkCalInstance_g.m_uiReadStatusReq = | |
1102 | (EplDllkCalInstance_g. | |
1103 | m_uiReadStatusReq + | |
1104 | 1) % | |
1105 | tabentries(EplDllkCalInstance_g. | |
1106 | m_auiQueueStatusReq); | |
1107 | *pReqServiceId_p = | |
1108 | kEplDllReqServiceStatus; | |
1109 | goto Exit; | |
1110 | } | |
1111 | break; | |
1112 | } | |
1113 | ||
1114 | } | |
1115 | } | |
1116 | ||
1117 | Exit: | |
1118 | return Ret; | |
9d7164cf DK |
1119 | } |
1120 | ||
1121 | //--------------------------------------------------------------------------- | |
1122 | // | |
1123 | // Function: EplDllkCalAsyncSetPendingRequests() | |
1124 | // | |
1125 | // Description: sets the pending asynchronous frame requests of the specified node. | |
1126 | // This will add the node to the asynchronous request scheduler. | |
1127 | // | |
1128 | // Parameters: uiNodeId_p = node ID | |
1129 | // AsyncReqPrio_p = asynchronous request priority | |
1130 | // uiCount_p = count of asynchronous frames | |
1131 | // | |
1132 | // Returns: tEplKernel = error code | |
1133 | // | |
1134 | // | |
1135 | // State: | |
1136 | // | |
1137 | //--------------------------------------------------------------------------- | |
1138 | ||
833dfbe7 GKH |
1139 | tEplKernel EplDllkCalAsyncSetPendingRequests(unsigned int uiNodeId_p, |
1140 | tEplDllAsyncReqPriority | |
1141 | AsyncReqPrio_p, | |
1142 | unsigned int uiCount_p) | |
9d7164cf | 1143 | { |
833dfbe7 GKH |
1144 | tEplKernel Ret = kEplSuccessful; |
1145 | ||
1146 | // add node to appropriate request queue | |
1147 | switch (AsyncReqPrio_p) { | |
1148 | case kEplDllAsyncReqPrioNmt: | |
1149 | { | |
1150 | uiNodeId_p--; | |
1151 | if (uiNodeId_p >= | |
1152 | (tabentries | |
1153 | (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { | |
1154 | Ret = kEplDllInvalidParam; | |
1155 | goto Exit; | |
1156 | } | |
1157 | uiNodeId_p += | |
1158 | tabentries(EplDllkCalInstance_g. | |
1159 | m_auiQueueCnRequests) / 2; | |
1160 | EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] = | |
1161 | uiCount_p; | |
1162 | break; | |
1163 | } | |
1164 | ||
1165 | default: | |
1166 | { | |
1167 | uiNodeId_p--; | |
1168 | if (uiNodeId_p >= | |
1169 | (tabentries | |
1170 | (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { | |
1171 | Ret = kEplDllInvalidParam; | |
1172 | goto Exit; | |
1173 | } | |
1174 | EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] = | |
1175 | uiCount_p; | |
1176 | break; | |
1177 | } | |
1178 | } | |
1179 | ||
1180 | Exit: | |
1181 | return Ret; | |
9d7164cf DK |
1182 | } |
1183 | #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) | |
1184 | ||
1185 | //=========================================================================// | |
1186 | // // | |
1187 | // P R I V A T E F U N C T I O N S // | |
1188 | // // | |
1189 | //=========================================================================// | |
1190 | ||
1191 | //--------------------------------------------------------------------------- | |
1192 | // Callback handler for new data signaling | |
1193 | //--------------------------------------------------------------------------- | |
1194 | ||
1195 | #ifndef EPL_NO_FIFO | |
1196 | /*static void EplDllkCalTxNmtSignalHandler ( | |
1197 | tShbInstance pShbRxInstance_p, | |
1198 | unsigned long ulDataSize_p) | |
1199 | { | |
1200 | tEplKernel Ret = kEplSuccessful; | |
1201 | tEplEvent Event; | |
1202 | tEplDllAsyncReqPriority Priority; | |
1203 | #ifndef EPL_NO_FIFO | |
1204 | tShbError ShbError; | |
1205 | unsigned long ulBlockCount; | |
1206 | ||
9d7164cf DK |
1207 | ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxNmt, &ulBlockCount); |
1208 | if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) | |
1209 | { | |
1210 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = ulBlockCount; | |
1211 | } | |
1212 | ||
1213 | #endif | |
1214 | ||
1215 | // post event to DLL | |
1216 | Priority = kEplDllAsyncReqPrioNmt; | |
1217 | Event.m_EventSink = kEplEventSinkDllk; | |
1218 | Event.m_EventType = kEplEventTypeDllkFillTx; | |
1219 | EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); | |
1220 | Event.m_pArg = &Priority; | |
1221 | Event.m_uiSize = sizeof(Priority); | |
1222 | Ret = EplEventkPost(&Event); | |
1223 | ||
1224 | } | |
1225 | ||
1226 | static void EplDllkCalTxGenSignalHandler ( | |
1227 | tShbInstance pShbRxInstance_p, | |
1228 | unsigned long ulDataSize_p) | |
1229 | { | |
1230 | tEplKernel Ret = kEplSuccessful; | |
1231 | tEplEvent Event; | |
1232 | tEplDllAsyncReqPriority Priority; | |
1233 | #ifndef EPL_NO_FIFO | |
1234 | tShbError ShbError; | |
1235 | unsigned long ulBlockCount; | |
1236 | ||
9d7164cf DK |
1237 | ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxGen, &ulBlockCount); |
1238 | if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) | |
1239 | { | |
1240 | EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = ulBlockCount; | |
1241 | } | |
1242 | ||
1243 | #endif | |
1244 | ||
1245 | // post event to DLL | |
1246 | Priority = kEplDllAsyncReqPrioGeneric; | |
1247 | Event.m_EventSink = kEplEventSinkDllk; | |
1248 | Event.m_EventType = kEplEventTypeDllkFillTx; | |
1249 | EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); | |
1250 | Event.m_pArg = &Priority; | |
1251 | Event.m_uiSize = sizeof(Priority); | |
1252 | Ret = EplEventkPost(&Event); | |
1253 | ||
1254 | } | |
1255 | */ | |
1256 | #endif | |
1257 | ||
9d7164cf DK |
1258 | #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) |
1259 | ||
1260 | // EOF |