tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 communication abstraction layer
9 for the Epl-Obd-Userspace-Modul
10
11 License:
12
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions
15 are met:
16
17 1. Redistributions of source code must retain the above copyright
18 notice, this list of conditions and the following disclaimer.
19
20 2. Redistributions in binary form must reproduce the above copyright
21 notice, this list of conditions and the following disclaimer in the
22 documentation and/or other materials provided with the distribution.
23
24 3. Neither the name of SYSTEC electronic GmbH nor the names of its
25 contributors may be used to endorse or promote products derived
26 from this software without prior written permission. For written
27 permission, please contact info@systec-electronic.com.
28
29 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
32 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
33 COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
34 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
35 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
36 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
37 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
39 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 POSSIBILITY OF SUCH DAMAGE.
41
42 Severability Clause:
43
44 If a provision of this License is or becomes illegal, invalid or
45 unenforceable in any jurisdiction, that shall not affect:
46 1. the validity or enforceability in that jurisdiction of any other
47 provision of this License; or
48 2. the validity or enforceability in other jurisdictions of that or
49 any other provision of this License.
50
51 -------------------------------------------------------------------------
52
53 $RCSfile: EplObduCal.c,v $
54
55 $Author: D.Krueger $
56
57 $Revision: 1.6 $ $Date: 2008/10/17 15:32:32 $
58
59 $State: Exp $
60
61 Build Environment:
62 GCC V3.4
63
64 -------------------------------------------------------------------------
65
66 Revision History:
67
68 2006/06/19 k.t.: start of the implementation
69
70****************************************************************************/
71#include "EplInc.h"
72#include "user/EplObduCal.h"
73#include "kernel/EplObdk.h"
74
75#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) && (EPL_OBD_USE_KERNEL != FALSE)
76
77/***************************************************************************/
78/* */
79/* */
80/* G L O B A L D E F I N I T I O N S */
81/* */
82/* */
83/***************************************************************************/
84
85//---------------------------------------------------------------------------
86// const defines
87//---------------------------------------------------------------------------
88
89//---------------------------------------------------------------------------
90// local types
91//---------------------------------------------------------------------------
92
93//---------------------------------------------------------------------------
94// modul globale vars
95//---------------------------------------------------------------------------
96
97//---------------------------------------------------------------------------
98// local function prototypes
99//---------------------------------------------------------------------------
100
101//=========================================================================//
102// //
103// P U B L I C F U N C T I O N S //
104// //
105//=========================================================================//
106
107//---------------------------------------------------------------------------
108//
109// Function: EplObduCalWriteEntry()
110//
111// Description: Function encapsulate access of function EplObdWriteEntry
112//
113// Parameters: uiIndex_p = Index of the OD entry
114// uiSubIndex_p = Subindex of the OD Entry
115// pSrcData_p = Pointer to the data to write
116// Size_p = Size of the data in Byte
117//
118// Return: tEplKernel = Errorcode
119//
120//
121// State:
122//
123//---------------------------------------------------------------------------
124tEplKernel EplObduCalWriteEntry(unsigned int uiIndex_p,
125 unsigned int uiSubIndex_p,
126 void *pSrcData_p, tEplObdSize Size_p)
127{
128 tEplKernel Ret;
129
130#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
131 Ret = EplObdWriteEntry(uiIndex_p, uiSubIndex_p, pSrcData_p, Size_p);
132#else
133 Ret = kEplSuccessful;
134#endif
135
136 return Ret;
137}
138
139//---------------------------------------------------------------------------
140//
141// Function: EplObduCalReadEntry()
142//
143// Description: Function encapsulate access of function EplObdReadEntry
144//
145// Parameters: uiIndex_p = Index oof the OD entry to read
146// uiSubIndex_p = Subindex to read
147// pDstData_p = pointer to the buffer for data
148// Offset_p = offset in data for read access
149// pSize_p = IN: Size of the buffer
150// OUT: number of readed Bytes
151//
152// Return: tEplKernel = errorcode
153//
154// State:
155//
156//---------------------------------------------------------------------------
157tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
158 unsigned int uiSubIndex_p,
159 void *pDstData_p, tEplObdSize *pSize_p)
160{
161 tEplKernel Ret;
162
163#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
164 Ret = EplObdReadEntry(uiIndex_p, uiSubIndex_p, pDstData_p, pSize_p);
165#else
166 Ret = kEplSuccessful;
167#endif
168
169 return Ret;
170}
171
172//---------------------------------------------------------------------------
173//
174// Function: EplObduCalAccessOdPart()
175//
176// Description: Function encapsulate access of function EplObdAccessOdPart
177//
178// Parameters: ObdPart_p = od-part to reset
179// Direction_p = directory flag for
180//
181// Return: tEplKernel = errorcode
182//
183// State:
184//
185//---------------------------------------------------------------------------
186tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p, tEplObdDir Direction_p)
187{
188 tEplKernel Ret;
189
190#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
191 Ret = EplObdAccessOdPart(ObdPart_p, Direction_p);
192#else
193 Ret = kEplSuccessful;
194#endif
195
196 return Ret;
197}
198
199//---------------------------------------------------------------------------
200//
201// Function: EplObduCalDefineVar()
202//
203// Description: Function encapsulate access of function EplObdDefineVar
204//
205// Parameters: pEplVarParam_p = varentry
206//
207// Return: tEplKernel = errorcode
208//
209// State:
210//
211//---------------------------------------------------------------------------
212tEplKernel EplObduCalDefineVar(tEplVarParam *pVarParam_p)
213{
214 tEplKernel Ret;
215
216#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
217 Ret = EplObdDefineVar(pVarParam_p);
218#else
219 Ret = kEplSuccessful;
220#endif
221
222 return Ret;
223}
224
225//---------------------------------------------------------------------------
226//
227// Function: EplObduCalGetObjectDataPtr()
228//
229// Description: Function encapsulate access of function EplObdGetObjectDataPtr
230//
231// Parameters: uiIndex_p = Index of the entry
232// uiSubindex_p = Subindex of the entry
233//
234// Return: void * = pointer to object data
235//
236// State:
237//
238//---------------------------------------------------------------------------
239void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p, unsigned int uiSubIndex_p)
240{
241 void *pData;
242
243#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
244 pData = EplObdGetObjectDataPtr(uiIndex_p, uiSubIndex_p);
245#else
246 pData = NULL;
247#endif
248
249 return pData;
250}
251
252//---------------------------------------------------------------------------
253//
254// Function: EplObduCalRegisterUserOd()
255//
256// Description: Function encapsulate access of function EplObdRegisterUserOd
257//
258// Parameters: pUserOd_p = pointer to user OD
259//
260// Return: tEplKernel = errorcode
261//
262// State:
263//
264//---------------------------------------------------------------------------
265#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
266tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p)
267{
268 tEplKernel Ret;
269
270#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
271 Ret = EplObdRegisterUserOd(pUserOd_p);
272#else
273 Ret = kEplSuccessful;
274#endif
275
276 return Ret;
277
278}
279#endif
280//---------------------------------------------------------------------------
281//
282// Function: EplObduCalInitVarEntry()
283//
284// Description: Function encapsulate access of function EplObdInitVarEntry
285//
286// Parameters: pVarEntry_p = pointer to var entry structure
287// bType_p = object type
288// ObdSize_p = size of object data
289//
290// Returns: none
291//
292// State:
293//
294//---------------------------------------------------------------------------
295void EplObduCalInitVarEntry(tEplObdVarEntry *pVarEntry_p, u8 bType_p,
296 tEplObdSize ObdSize_p)
297{
298#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
299 EplObdInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
300#endif
301}
302
303//---------------------------------------------------------------------------
304//
305// Function: EplObduCalGetDataSize()
306//
307// Description: Function encapsulate access of function EplObdGetDataSize
308//
309// gets the data size of an object
310// for string objects it returnes the string length
311//
312// Parameters: uiIndex_p = Index
313// uiSubIndex_p= Subindex
314//
315// Return: tEplObdSize
316//
317// State:
318//
319//---------------------------------------------------------------------------
320tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
321 unsigned int uiSubIndex_p)
322{
323 tEplObdSize Size;
324
325#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
326 Size = EplObdGetDataSize(uiIndex_p, uiSubIndex_p);
327#else
328 Size = 0;
329#endif
330
331 return Size;
332}
333
334//---------------------------------------------------------------------------
335//
336// Function: EplObduCalGetNodeId()
337//
338// Description: Function encapsulate access of function EplObdGetNodeId
339//
340//
341// Parameters:
342//
343// Return: unsigned int = Node Id
344//
345// State:
346//
347//---------------------------------------------------------------------------
348unsigned int EplObduCalGetNodeId(void)
349{
350 unsigned int uiNodeId;
351
352#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
353 uiNodeId = EplObdGetNodeId();
354#else
355 uiNodeId = 0;
356#endif
357
358 return uiNodeId;
359}
360
361//---------------------------------------------------------------------------
362//
363// Function: EplObduCalSetNodeId()
364//
365// Description: Function encapsulate access of function EplObdSetNodeId
366//
367//
368// Parameters: uiNodeId_p = Node Id to set
369// NodeIdType_p= Type on which way the Node Id was set
370//
371// Return: tEplKernel = Errorcode
372//
373// State:
374//
375//---------------------------------------------------------------------------
376tEplKernel EplObduCalSetNodeId(unsigned int uiNodeId_p,
377 tEplObdNodeIdType NodeIdType_p)
378{
379 tEplKernel Ret;
380
381#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
382 Ret = EplObdSetNodeId(uiNodeId_p, NodeIdType_p);
383#else
384 Ret = kEplSuccessful;
385#endif
386
387 return Ret;
388}
389
390//---------------------------------------------------------------------------
391//
392// Function: EplObduCalGetAccessType()
393//
394// Description: Function encapsulate access of function EplObdGetAccessType
395//
396// Parameters: uiIndex_p = Index of the OD entry
397// uiSubIndex_p = Subindex of the OD Entry
398// pAccessTyp_p = pointer to buffer to store accesstype
399//
400// Return: tEplKernel = errorcode
401//
402//
403// State:
404//
405//---------------------------------------------------------------------------
406tEplKernel EplObduCalGetAccessType(unsigned int uiIndex_p,
407 unsigned int uiSubIndex_p,
408 tEplObdAccess *pAccessTyp_p)
409{
410 tEplObdAccess AccesType;
411
412#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
413 AccesType = EplObdGetAccessType(uiIndex_p, uiSubIndex_p, pAccessTyp_p);
414#else
415 AccesType = 0;
416#endif
417
418 return AccesType;
419
420}
421
422//---------------------------------------------------------------------------
423//
424// Function: EplObduCalReadEntryToLe()
425//
426// Description: Function encapsulate access of function EplObdReadEntryToLe
427//
428// Parameters: uiIndex_p = Index of the OD entry to read
429// uiSubIndex_p = Subindex to read
430// pDstData_p = pointer to the buffer for data
431// Offset_p = offset in data for read access
432// pSize_p = IN: Size of the buffer
433// OUT: number of readed Bytes
434//
435// Return: tEplKernel
436//
437// State:
438//
439//---------------------------------------------------------------------------
440tEplKernel EplObduCalReadEntryToLe(unsigned int uiIndex_p,
441 unsigned int uiSubIndex_p,
442 void *pDstData_p,
443 tEplObdSize *pSize_p)
444{
445 tEplKernel Ret;
446
447#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
448 Ret = EplObdReadEntryToLe(uiIndex_p, uiSubIndex_p, pDstData_p, pSize_p);
449#else
450 Ret = kEplSuccessful;
451#endif
452
453 return Ret;
454}
455
456//---------------------------------------------------------------------------
457//
458// Function: EplObduCalWriteEntryFromLe()
459//
460// Description: Function encapsulate access of function EplObdWriteEntryFromLe
461//
462// Parameters: uiIndex_p = Index of the OD entry
463// uiSubIndex_p = Subindex of the OD Entry
464// pSrcData_p = Pointer to the data to write
465// Size_p = Size of the data in Byte
466//
467// Return: tEplKernel = Errorcode
468//
469//
470// State:
471//
472//---------------------------------------------------------------------------
473tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
474 unsigned int uiSubIndex_p,
475 void *pSrcData_p, tEplObdSize Size_p)
476{
477 tEplKernel Ret;
478
479#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
480 Ret =
481 EplObdWriteEntryFromLe(uiIndex_p, uiSubIndex_p, pSrcData_p, Size_p);
482#else
483 Ret = kEplSuccessful;
484#endif
485 return Ret;
486}
487
488//---------------------------------------------------------------------------
489//
490// Function: EplObduCalSearchVarEntry()
491//
492// Description: gets variable from OD
493//
494// Parameters: uiIndex_p = index of the var entry to search
495// uiSubindex_p = subindex of var entry to search
496// ppVarEntry_p = pointer to the pointer to the varentry
497//
498// Return: tEplKernel
499//
500// State:
501//
502//---------------------------------------------------------------------------
503tEplKernel EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
504 unsigned int uiSubindex_p,
505 tEplObdVarEntry **ppVarEntry_p)
506{
507 tEplKernel Ret;
508
509#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
510 Ret = EplObdSearchVarEntry(uiIndex_p, uiSubindex_p, ppVarEntry_p);
511#else
512 Ret = kEplSuccessful;
513#endif
514 return Ret;
515}
516
517//=========================================================================//
518// //
519// P R I V A T E F U N C T I O N S //
520// //
521//=========================================================================//
522
523//---------------------------------------------------------------------------
524//
525// Function:
526//
527// Description:
528//
529//
530//
531// Parameters:
532//
533//
534// Returns:
535//
536//
537// State:
538//
539//---------------------------------------------------------------------------
540
541#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0)
542
543// EOF