?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6/x86.git] / drivers / staging / epl / EplObd.c
blob1e463234d81ea831328b8376cd121ac1c14212c4
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 api function of EplOBD-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: EplObd.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.12 $ $Date: 2008/10/17 15:32:32 $
57
58 $State: Exp $
59
60 Build Environment:
61 Microsoft VC7
62
63 -------------------------------------------------------------------------
64
65 Revision History:
66
67 2006/06/02 k.t.: start of the implementation, version 1.00
68 ->based on CANopen OBD-Modul
69
70 ****************************************************************************/
71
72 #include "EplInc.h"
73 #include "kernel/EplObdk.h" // function prototyps of the EplOBD-Modul
74
75 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
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 // float definitions and macros
90 #define _SHIFTED_EXPONENT_MASK_SP 0xff
91 #define _BIAS_SP 126
92 #define T_SP 23
93 #define EXPONENT_DENORM_SP (-_BIAS_SP)
94 #define BASE_TO_THE_T_SP ((float) 8388608.0)
95 #define GET_EXPONENT_SP(x) ((((x) >> T_SP) & _SHIFTED_EXPONENT_MASK_SP) - _BIAS_SP)
96
97 //---------------------------------------------------------------------------
98 // local types
99 //---------------------------------------------------------------------------
100
101 // struct for instance table
102 INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER()
103
104 STATIC tEplObdInitParam m_ObdInitParam;
105 STATIC tEplObdStoreLoadObjCallback m_fpStoreLoadObjCallback;
106
107 INSTANCE_TYPE_END
108 // decomposition of float
109 typedef union {
110 tEplObdReal32 m_flRealPart;
111 int m_nIntegerPart;
112
113 } tEplObdRealParts;
114
115 //---------------------------------------------------------------------------
116 // modul globale vars
117 //---------------------------------------------------------------------------
118
119 // This macro replace the unspecific pointer to an instance through
120 // the modul specific type for the local instance table. This macro
121 // must defined in each modul.
122 //#define tEplPtrInstance tEplInstanceInfo *
123
124 EPL_MCO_DECL_INSTANCE_VAR()
125
126 u8 abEplObdTrashObject_g[8];
127
128 //---------------------------------------------------------------------------
129 // local function prototypes
130 //---------------------------------------------------------------------------
131
132 EPL_MCO_DEFINE_INSTANCE_FCT()
133
134 static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
135 tEplObdCallback fpCallback_p,
136 tEplObdCbParam *pCbParam_p);
137
138 static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p);
139
140 static tEplObdSize EplObdGetStrLen(void *pObjData_p,
141 tEplObdSize ObjLen_p, tEplObdType ObjType_p);
142
143 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
144 static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
145 void *pData_p);
146 #endif
147
148 static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
149 tEplObdVarEntry **ppVarEntry_p);
150
151 static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
152 unsigned int uiIndex_p,
153 unsigned int uiSubindex_p,
154 tEplObdEntryPtr * ppObdEntry_p,
155 tEplObdSubEntryPtr * ppObdSubEntry_p);
156
157 static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p);
158
159 static tEplKernel EplObdGetIndexIntern(tEplObdInitParam *pInitParam_p,
160 unsigned int uiIndex_p,
161 tEplObdEntryPtr * ppObdEntry_p);
162
163 static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
164 unsigned int uiSubIndex_p,
165 tEplObdSubEntryPtr * ppObdSubEntry_p);
166
167 static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
168 tEplObdPart CurrentOdPart_p,
169 tEplObdEntryPtr pObdEnty_p,
170 tEplObdDir Direction_p);
171
172 static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
173 static void *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
174
175 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
176
177 static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdCbStoreParam *pCbStoreParam_p);
178
179 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
180
181 static void EplObdCopyObjectData(void *pDstData_p,
182 void *pSrcData_p,
183 tEplObdSize ObjSize_p, tEplObdType ObjType_p);
184
185 void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p);
186
187 static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
188 BOOL * pfEntryNumerical_p);
189
190 static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
191 unsigned int uiSubIndex_p,
192 void *pSrcData_p,
193 void **ppDstData_p,
194 tEplObdSize Size_p,
195 tEplObdEntryPtr *ppObdEntry_p,
196 tEplObdSubEntryPtr *ppSubEntry_p,
197 tEplObdCbParam *pCbParam_p,
198 tEplObdSize *pObdSize_p);
199
200 static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
201 tEplObdSubEntryPtr pSubEntry_p,
202 tEplObdCbParam *pCbParam_p,
203 void *pSrcData_p,
204 void *pDstData_p,
205 tEplObdSize ObdSize_p);
206
207 //=========================================================================//
208 // //
209 // P U B L I C F U N C T I O N S //
210 // //
211 //=========================================================================//
212
213 //---------------------------------------------------------------------------
214 //
215 // Function: EplObdInit()
216 //
217 // Description: initializes the first instance
218 //
219 // Parameters: pInitParam_p = init parameter
220 //
221 // Return: tEplKernel = errorcode
222 //
223 // State:
224 //
225 //---------------------------------------------------------------------------
226
227 tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p)
228 {
229
230 tEplKernel Ret;
231 EPL_MCO_DELETE_INSTANCE_TABLE();
232
233 if (pInitParam_p == NULL) {
234 Ret = kEplSuccessful;
235 goto Exit;
236 }
237
238 Ret = EplObdAddInstance(EPL_MCO_PTR_INSTANCE_PTR_ pInitParam_p);
239
240 Exit:
241 return Ret;
242
243 }
244
245 //---------------------------------------------------------------------------
246 //
247 // Function: EplObdAddInstance()
248 //
249 // Description: adds a new instance
250 //
251 // Parameters: pInitParam_p
252 //
253 // Return: tEplKernel
254 //
255 // State:
256 //
257 //---------------------------------------------------------------------------
258
259 tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p)
260 {
261
262 EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
263
264 // check if pointer to instance pointer valid
265 // get free instance and set the globale instance pointer
266 // set also the instance addr to parameterlist
267 EPL_MCO_CHECK_PTR_INSTANCE_PTR();
268 EPL_MCO_GET_FREE_INSTANCE_PTR();
269 EPL_MCO_SET_PTR_INSTANCE_PTR();
270
271 // save init parameters
272 EPL_MEMCPY(&EPL_MCO_GLB_VAR(m_ObdInitParam), pInitParam_p,
273 sizeof(tEplObdInitParam));
274
275 // clear callback function for command LOAD and STORE
276 EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = NULL;
277
278 // sign instance as used
279 EPL_MCO_WRITE_INSTANCE_STATE(kStateUsed);
280
281 // initialize object dictionary
282 // so all all VarEntries will be initialized to trash object and default values will be set to current data
283 Ret = EplObdAccessOdPart(EPL_MCO_INSTANCE_PTR_
284 kEplObdPartAll, kEplObdDirInit);
285
286 return Ret;
287
288 }
289
290 //---------------------------------------------------------------------------
291 //
292 // Function: EplObdDeleteInstance()
293 //
294 // Description: delete instance
295 //
296 // Parameters: EPL_MCO_DECL_INSTANCE_PTR
297 //
298 // Return: tEplKernel
299 //
300 // State:
301 //
302 //---------------------------------------------------------------------------
303 #if (EPL_USE_DELETEINST_FUNC != FALSE)
304 tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
305 {
306 // check for all API function if instance is valid
307 EPL_MCO_CHECK_INSTANCE_STATE();
308
309 // sign instance as unused
310 EPL_MCO_WRITE_INSTANCE_STATE(kStateUnused);
311
312 return kEplSuccessful;
313
314 }
315 #endif // (EPL_USE_DELETEINST_FUNC != FALSE)
316
317 //---------------------------------------------------------------------------
318 //
319 // Function: EplObdWriteEntry()
320 //
321 // Description: Function writes data to an OBD entry. Strings
322 // are stored with added '\0' character.
323 //
324 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
325 // uiIndex_p = Index of the OD entry
326 // uiSubIndex_p = Subindex of the OD Entry
327 // pSrcData_p = Pointer to the data to write
328 // Size_p = Size of the data in Byte
329 //
330 // Return: tEplKernel = Errorcode
331 //
332 //
333 // State:
334 //
335 //---------------------------------------------------------------------------
336
337 tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
338 unsigned int uiSubIndex_p,
339 void *pSrcData_p, tEplObdSize Size_p)
340 {
341
342 tEplKernel Ret;
343 tEplObdEntryPtr pObdEntry;
344 tEplObdSubEntryPtr pSubEntry;
345 tEplObdCbParam CbParam;
346 void *pDstData;
347 tEplObdSize ObdSize;
348
349 Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
350 uiIndex_p,
351 uiSubIndex_p,
352 pSrcData_p,
353 &pDstData,
354 Size_p,
355 &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
356 if (Ret != kEplSuccessful) {
357 goto Exit;
358 }
359
360 Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
361 pObdEntry,
362 pSubEntry,
363 &CbParam, pSrcData_p, pDstData, ObdSize);
364 if (Ret != kEplSuccessful) {
365 goto Exit;
366 }
367
368 Exit:
369
370 return Ret;
371
372 }
373
374 //---------------------------------------------------------------------------
375 //
376 // Function: EplObdReadEntry()
377 //
378 // Description: The function reads an object entry. The application
379 // can always read the data even if attrib kEplObdAccRead
380 // is not set. The attrib is only checked up for SDO transfer.
381 //
382 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
383 // uiIndex_p = Index oof the OD entry to read
384 // uiSubIndex_p = Subindex to read
385 // pDstData_p = pointer to the buffer for data
386 // Offset_p = offset in data for read access
387 // pSize_p = IN: Size of the buffer
388 // OUT: number of readed Bytes
389 //
390 // Return: tEplKernel
391 //
392 // State:
393 //
394 //---------------------------------------------------------------------------
395
396 tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
397 unsigned int uiSubIndex_p,
398 void *pDstData_p, tEplObdSize *pSize_p)
399 {
400
401 tEplKernel Ret;
402 tEplObdEntryPtr pObdEntry;
403 tEplObdSubEntryPtr pSubEntry;
404 tEplObdCbParam CbParam;
405 void *pSrcData;
406 tEplObdSize ObdSize;
407
408 // check for all API function if instance is valid
409 EPL_MCO_CHECK_INSTANCE_STATE();
410
411 ASSERT(pDstData_p != NULL);
412 ASSERT(pSize_p != NULL);
413
414 // get address of index and subindex entry
415 Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
416 uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
417 if (Ret != kEplSuccessful) {
418 goto Exit;
419 }
420 // get pointer to object data
421 pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
422
423 // check source pointer
424 if (pSrcData == NULL) {
425 Ret = kEplObdReadViolation;
426 goto Exit;
427 }
428 //------------------------------------------------------------------------
429 // address of source data to structure of callback parameters
430 // so callback function can change this data before reading
431 CbParam.m_uiIndex = uiIndex_p;
432 CbParam.m_uiSubIndex = uiSubIndex_p;
433 CbParam.m_pArg = pSrcData;
434 CbParam.m_ObdEvent = kEplObdEvPreRead;
435 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
436 pObdEntry->m_fpCallback, &CbParam);
437 if (Ret != kEplSuccessful) {
438 goto Exit;
439 }
440 // get size of data and check if application has reserved enough memory
441 ObdSize = EplObdGetDataSizeIntern(pSubEntry);
442 // check if offset given and calc correct number of bytes to read
443 if (*pSize_p < ObdSize) {
444 Ret = kEplObdValueLengthError;
445 goto Exit;
446 }
447 // read value from object
448 EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
449 *pSize_p = ObdSize;
450
451 // write address of destination data to structure of callback parameters
452 // so callback function can change this data after reading
453 CbParam.m_pArg = pDstData_p;
454 CbParam.m_ObdEvent = kEplObdEvPostRead;
455 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
456 pObdEntry->m_fpCallback, &CbParam);
457
458 Exit:
459
460 return Ret;
461
462 }
463
464 //---------------------------------------------------------------------------
465 //
466 // Function: EplObdAccessOdPart()
467 //
468 // Description: restores default values of one part of OD
469 //
470 // Parameters: ObdPart_p
471 // Direction_p
472 //
473 // Return: tEplKernel
474 //
475 // State:
476 //
477 //---------------------------------------------------------------------------
478
479 tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPart ObdPart_p,
480 tEplObdDir Direction_p)
481 {
482
483 tEplKernel Ret = kEplSuccessful;
484 BOOL fPartFount;
485 tEplObdEntryPtr pObdEntry;
486
487 // check for all API function if instance is valid
488 EPL_MCO_CHECK_INSTANCE_STATE();
489
490 // part always has to be unequal to NULL
491 pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pPart);
492 ASSERTMSG(pObdEntry != NULL,
493 "EplObdAccessOdPart(): no OD part is defined!\n");
494
495 // if ObdPart_p is not valid fPartFound keeps FALSE and function returns kEplObdIllegalPart
496 fPartFount = FALSE;
497
498 // access to part
499 if ((ObdPart_p & kEplObdPartGen) != 0) {
500 fPartFount = TRUE;
501
502 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
503 kEplObdPartGen, pObdEntry,
504 Direction_p);
505 if (Ret != kEplSuccessful) {
506 goto Exit;
507 }
508 }
509 // access to manufacturer part
510 pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pManufacturerPart);
511
512 if (((ObdPart_p & kEplObdPartMan) != 0) && (pObdEntry != NULL)) {
513 fPartFount = TRUE;
514
515 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
516 kEplObdPartMan, pObdEntry,
517 Direction_p);
518 if (Ret != kEplSuccessful) {
519 goto Exit;
520 }
521 }
522 // access to device part
523 pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pDevicePart);
524
525 if (((ObdPart_p & kEplObdPartDev) != 0) && (pObdEntry != NULL)) {
526 fPartFount = TRUE;
527
528 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
529 kEplObdPartDev, pObdEntry,
530 Direction_p);
531 if (Ret != kEplSuccessful) {
532 goto Exit;
533 }
534 }
535 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
536 {
537 // access to user part
538 pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart);
539
540 if (((ObdPart_p & kEplObdPartUsr) != 0) && (pObdEntry != NULL)) {
541 fPartFount = TRUE;
542
543 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
544 kEplObdPartUsr,
545 pObdEntry, Direction_p);
546 if (Ret != kEplSuccessful) {
547 goto Exit;
548 }
549 }
550 }
551 #endif
552
553 // no access to an OD part was done? illegal OD part was specified!
554 if (fPartFount == FALSE) {
555 Ret = kEplObdIllegalPart;
556 }
557
558 Exit:
559
560 return Ret;
561
562 }
563
564 //---------------------------------------------------------------------------
565 //
566 // Function: EplObdDefineVar()
567 //
568 // Description: defines a variable in OD
569 //
570 // Parameters: pEplVarParam_p
571 //
572 // Return: tEplKernel
573 //
574 // State:
575 //
576 //---------------------------------------------------------------------------
577
578 tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam *pVarParam_p)
579 {
580
581 tEplKernel Ret;
582 tEplObdVarEntry *pVarEntry;
583 tEplVarParamValid VarValid;
584 tEplObdSubEntryPtr pSubindexEntry;
585
586 // check for all API function if instance is valid
587 EPL_MCO_CHECK_INSTANCE_STATE();
588
589 ASSERT(pVarParam_p != NULL); // is not allowed to be NULL
590
591 // get address of subindex entry
592 Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
593 pVarParam_p->m_uiIndex,
594 pVarParam_p->m_uiSubindex, NULL, &pSubindexEntry);
595 if (Ret != kEplSuccessful) {
596 goto Exit;
597 }
598 // get var entry
599 Ret = EplObdGetVarEntry(pSubindexEntry, &pVarEntry);
600 if (Ret != kEplSuccessful) {
601 goto Exit;
602 }
603
604 VarValid = pVarParam_p->m_ValidFlag;
605
606 // copy only this values, which valid flag is set
607 if ((VarValid & kVarValidSize) != 0) {
608 if (pSubindexEntry->m_Type != kEplObdTypDomain) {
609 tEplObdSize DataSize;
610
611 // check passed size parameter
612 DataSize = EplObdGetObjectSize(pSubindexEntry);
613 if (DataSize != pVarParam_p->m_Size) { // size of variable does not match
614 Ret = kEplObdValueLengthError;
615 goto Exit;
616 }
617 } else { // size can be set only for objects of type DOMAIN
618 pVarEntry->m_Size = pVarParam_p->m_Size;
619 }
620 }
621
622 if ((VarValid & kVarValidData) != 0) {
623 pVarEntry->m_pData = pVarParam_p->m_pData;
624 }
625 /*
626 #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
627 {
628 if ((VarValid & kVarValidCallback) != 0)
629 {
630 pVarEntry->m_fpCallback = pVarParam_p->m_fpCallback;
631 }
632
633 if ((VarValid & kVarValidArg) != 0)
634 {
635 pVarEntry->m_pArg = pVarParam_p->m_pArg;
636 }
637 }
638 #endif
639 */
640 // Ret is already set to kEplSuccessful from ObdGetVarIntern()
641
642 Exit:
643
644 return Ret;
645
646 }
647
648 //---------------------------------------------------------------------------
649 //
650 // Function: EplObdGetObjectDataPtr()
651 //
652 // Description: It returnes the current data pointer. But if object is an
653 // constant object it returnes the default pointer.
654 //
655 // Parameters: uiIndex_p = Index of the entry
656 // uiSubindex_p = Subindex of the entry
657 //
658 // Return: void * = pointer to object data
659 //
660 // State:
661 //
662 //---------------------------------------------------------------------------
663
664 void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
665 unsigned int uiSubIndex_p)
666 {
667 tEplKernel Ret;
668 void *pData;
669 tEplObdEntryPtr pObdEntry;
670 tEplObdSubEntryPtr pObdSubEntry;
671
672 // get pointer to index structure
673 Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
674 uiIndex_p, &pObdEntry);
675 if (Ret != kEplSuccessful) {
676 pData = NULL;
677 goto Exit;
678 }
679 // get pointer to subindex structure
680 Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
681 if (Ret != kEplSuccessful) {
682 pData = NULL;
683 goto Exit;
684 }
685 // get Datapointer
686 pData = EplObdGetObjectDataPtrIntern(pObdSubEntry);
687
688 Exit:
689 return pData;
690
691 }
692
693 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
694
695 //---------------------------------------------------------------------------
696 //
697 // Function: EplObdRegisterUserOd()
698 //
699 // Description: function registers the user OD
700 //
701 // Parameters: pUserOd_p =pointer to user ODd
702 //
703 // Return: tEplKernel = errorcode
704 //
705 // State:
706 //
707 //---------------------------------------------------------------------------
708 tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p)
709 {
710
711 EPL_MCO_CHECK_INSTANCE_STATE();
712
713 EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart) = pUserOd_p;
714
715 return kEplSuccessful;
716
717 }
718
719 #endif
720
721 //---------------------------------------------------------------------------
722 //
723 // Function: EplObdInitVarEntry()
724 //
725 // Description: function to initialize VarEntry dependened on object type
726 //
727 // Parameters: pVarEntry_p = pointer to var entry structure
728 // Type_p = object type
729 // ObdSize_p = size of object data
730 //
731 // Returns: none
732 //
733 // State:
734 //
735 //---------------------------------------------------------------------------
736
737 void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry *pVarEntry_p,
738 tEplObdType Type_p, tEplObdSize ObdSize_p)
739 {
740 /*
741 #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
742 {
743 // reset pointer to VAR callback and argument
744 pVarEntry_p->m_fpCallback = NULL;
745 pVarEntry_p->m_pArg = NULL;
746 }
747 #endif
748 */
749
750 // 10-dec-2004 r.d.: this function will not be used for strings
751 if ((Type_p == kEplObdTypDomain))
752 // (bType_p == kEplObdTypVString) /* ||
753 // (bType_p == kEplObdTypOString) ||
754 // (bType_p == kEplObdTypUString) */ )
755 {
756 // variables which are defined as DOMAIN or VSTRING should not point to
757 // trash object, because this trash object contains only 8 bytes. DOMAINS or
758 // STRINGS can be longer.
759 pVarEntry_p->m_pData = NULL;
760 pVarEntry_p->m_Size = 0;
761 } else {
762 // set address to variable data to trash object
763 // This prevents an access violation if user forgets to call EplObdDefineVar()
764 // for this variable but mappes it in a PDO.
765 pVarEntry_p->m_pData = &abEplObdTrashObject_g[0];
766 pVarEntry_p->m_Size = ObdSize_p;
767 }
768
769 }
770
771 //---------------------------------------------------------------------------
772 //
773 // Function: EplObdGetDataSize()
774 //
775 // Description: function to initialize VarEntry dependened on object type
776 //
777 // gets the data size of an object
778 // for string objects it returnes the string length
779 //
780 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
781 // uiIndex_p = Index
782 // uiSubIndex_p= Subindex
783 //
784 // Return: tEplObdSize
785 //
786 // State:
787 //
788 //---------------------------------------------------------------------------
789 tEplObdSize EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
790 unsigned int uiSubIndex_p)
791 {
792 tEplKernel Ret;
793 tEplObdSize ObdSize;
794 tEplObdEntryPtr pObdEntry;
795 tEplObdSubEntryPtr pObdSubEntry;
796
797 // get pointer to index structure
798 Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
799 uiIndex_p, &pObdEntry);
800 if (Ret != kEplSuccessful) {
801 ObdSize = 0;
802 goto Exit;
803 }
804 // get pointer to subindex structure
805 Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
806 if (Ret != kEplSuccessful) {
807 ObdSize = 0;
808 goto Exit;
809 }
810 // get size
811 ObdSize = EplObdGetDataSizeIntern(pObdSubEntry);
812 Exit:
813 return ObdSize;
814 }
815
816 //---------------------------------------------------------------------------
817 //
818 // Function: EplObdGetNodeId()
819 //
820 // Description: function returns nodeid from entry 0x1F93
821 //
822 //
823 // Parameters: EPL_MCO_DECL_INSTANCE_PTR = Instancepointer
824 //
825 // Return: unsigned int = Node Id
826 //
827 // State:
828 //
829 //---------------------------------------------------------------------------
830 unsigned int EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
831 {
832 tEplKernel Ret;
833 tEplObdSize ObdSize;
834 u8 bNodeId;
835
836 bNodeId = 0;
837 ObdSize = sizeof(bNodeId);
838 Ret = EplObdReadEntry(EPL_MCO_PTR_INSTANCE_PTR_
839 EPL_OBD_NODE_ID_INDEX,
840 EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, &ObdSize);
841 if (Ret != kEplSuccessful) {
842 bNodeId = EPL_C_ADR_INVALID;
843 goto Exit;
844 }
845
846 Exit:
847 return (unsigned int)bNodeId;
848
849 }
850
851 //---------------------------------------------------------------------------
852 //
853 // Function: EplObdSetNodeId()
854 //
855 // Description: function sets nodeid in entry 0x1F93
856 //
857 //
858 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
859 // uiNodeId_p = Node Id to set
860 // NodeIdType_p= Type on which way the Node Id was set
861 //
862 // Return: tEplKernel = Errorcode
863 //
864 // State:
865 //
866 //---------------------------------------------------------------------------
867 tEplKernel EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_ unsigned int uiNodeId_p,
868 tEplObdNodeIdType NodeIdType_p)
869 {
870 tEplKernel Ret;
871 tEplObdSize ObdSize;
872 u8 fHwBool;
873 u8 bNodeId;
874
875 // check Node Id
876 if (uiNodeId_p == EPL_C_ADR_INVALID) {
877 Ret = kEplInvalidNodeId;
878 goto Exit;
879 }
880 bNodeId = (u8) uiNodeId_p;
881 ObdSize = sizeof(u8);
882 // write NodeId to OD entry
883 Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR_
884 EPL_OBD_NODE_ID_INDEX,
885 EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, ObdSize);
886 if (Ret != kEplSuccessful) {
887 goto Exit;
888 }
889 // set HWBOOL-Flag in Subindex EPL_OBD_NODE_ID_HWBOOL_SUBINDEX
890 switch (NodeIdType_p) {
891 // type unknown
892 case kEplObdNodeIdUnknown:
893 {
894 fHwBool = OBD_FALSE;
895 break;
896 }
897
898 case kEplObdNodeIdSoftware:
899 {
900 fHwBool = OBD_FALSE;
901 break;
902 }
903
904 case kEplObdNodeIdHardware:
905 {
906 fHwBool = OBD_TRUE;
907 break;
908 }
909
910 default:
911 {
912 fHwBool = OBD_FALSE;
913 }
914
915 } // end of switch (NodeIdType_p)
916
917 // write flag
918 ObdSize = sizeof(fHwBool);
919 Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR
920 EPL_OBD_NODE_ID_INDEX,
921 EPL_OBD_NODE_ID_HWBOOL_SUBINDEX,
922 &fHwBool, ObdSize);
923 if (Ret != kEplSuccessful) {
924 goto Exit;
925 }
926
927 Exit:
928 return Ret;
929 }
930
931 //---------------------------------------------------------------------------
932 //
933 // Function: EplObdIsNumerical()
934 //
935 // Description: function checks if a entry is numerical or not
936 //
937 //
938 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
939 // uiIndex_p = Index
940 // uiSubIndex_p = Subindex
941 // pfEntryNumerical_p = pointer to BOOL for returnvalue
942 // -> TRUE if entry a numerical value
943 // -> FALSE if entry not a numerical value
944 //
945 // Return: tEplKernel = Errorcode
946 //
947 // State:
948 //
949 //---------------------------------------------------------------------------
950 tEplKernel EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
951 unsigned int uiSubIndex_p,
952 BOOL *pfEntryNumerical_p)
953 {
954 tEplKernel Ret;
955 tEplObdEntryPtr pObdEntry;
956 tEplObdSubEntryPtr pObdSubEntry;
957
958 // get pointer to index structure
959 Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
960 uiIndex_p, &pObdEntry);
961 if (Ret != kEplSuccessful) {
962 goto Exit;
963 }
964 // get pointer to subindex structure
965 Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
966 if (Ret != kEplSuccessful) {
967 goto Exit;
968 }
969
970 Ret = EplObdIsNumericalIntern(pObdSubEntry, pfEntryNumerical_p);
971
972 Exit:
973 return Ret;
974
975 }
976
977 //---------------------------------------------------------------------------
978 //
979 // Function: EplObdReadEntryToLe()
980 //
981 // Description: The function reads an object entry from the byteoder
982 // of the system to the little endian byteorder for numerical values.
983 // For other types a normal read will be processed. This is usefull for
984 // the PDO and SDO module. The application
985 // can always read the data even if attrib kEplObdAccRead
986 // is not set. The attrib is only checked up for SDO transfer.
987 //
988 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
989 // uiIndex_p = Index of the OD entry to read
990 // uiSubIndex_p = Subindex to read
991 // pDstData_p = pointer to the buffer for data
992 // Offset_p = offset in data for read access
993 // pSize_p = IN: Size of the buffer
994 // OUT: number of readed Bytes
995 //
996 // Return: tEplKernel
997 //
998 // State:
999 //
1000 //---------------------------------------------------------------------------
1001 tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
1002 unsigned int uiSubIndex_p,
1003 void *pDstData_p, tEplObdSize *pSize_p)
1004 {
1005 tEplKernel Ret;
1006 tEplObdEntryPtr pObdEntry;
1007 tEplObdSubEntryPtr pSubEntry;
1008 tEplObdCbParam CbParam;
1009 void *pSrcData;
1010 tEplObdSize ObdSize;
1011
1012 // check for all API function if instance is valid
1013 EPL_MCO_CHECK_INSTANCE_STATE();
1014
1015 ASSERT(pDstData_p != NULL);
1016 ASSERT(pSize_p != NULL);
1017
1018 // get address of index and subindex entry
1019 Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1020 uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
1021 if (Ret != kEplSuccessful) {
1022 goto Exit;
1023 }
1024 // get pointer to object data
1025 pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
1026
1027 // check source pointer
1028 if (pSrcData == NULL) {
1029 Ret = kEplObdReadViolation;
1030 goto Exit;
1031 }
1032 //------------------------------------------------------------------------
1033 // address of source data to structure of callback parameters
1034 // so callback function can change this data before reading
1035 CbParam.m_uiIndex = uiIndex_p;
1036 CbParam.m_uiSubIndex = uiSubIndex_p;
1037 CbParam.m_pArg = pSrcData;
1038 CbParam.m_ObdEvent = kEplObdEvPreRead;
1039 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1040 pObdEntry->m_fpCallback, &CbParam);
1041 if (Ret != kEplSuccessful) {
1042 goto Exit;
1043 }
1044 // get size of data and check if application has reserved enough memory
1045 ObdSize = EplObdGetDataSizeIntern(pSubEntry);
1046 // check if offset given and calc correct number of bytes to read
1047 if (*pSize_p < ObdSize) {
1048 Ret = kEplObdValueLengthError;
1049 goto Exit;
1050 }
1051 // check if numerical type
1052 switch (pSubEntry->m_Type) {
1053 //-----------------------------------------------
1054 // types without ami
1055 case kEplObdTypVString:
1056 case kEplObdTypOString:
1057 case kEplObdTypDomain:
1058 default:
1059 {
1060 // read value from object
1061 EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
1062 break;
1063 }
1064
1065 //-----------------------------------------------
1066 // numerical type which needs ami-write
1067 // 8 bit or smaller values
1068 case kEplObdTypBool:
1069 case kEplObdTypInt8:
1070 case kEplObdTypUInt8:
1071 {
1072 AmiSetByteToLe(pDstData_p, *((u8 *) pSrcData));
1073 break;
1074 }
1075
1076 // 16 bit values
1077 case kEplObdTypInt16:
1078 case kEplObdTypUInt16:
1079 {
1080 AmiSetWordToLe(pDstData_p, *((u16 *) pSrcData));
1081 break;
1082 }
1083
1084 // 24 bit values
1085 case kEplObdTypInt24:
1086 case kEplObdTypUInt24:
1087 {
1088 AmiSetDword24ToLe(pDstData_p, *((u32 *) pSrcData));
1089 break;
1090 }
1091
1092 // 32 bit values
1093 case kEplObdTypInt32:
1094 case kEplObdTypUInt32:
1095 case kEplObdTypReal32:
1096 {
1097 AmiSetDwordToLe(pDstData_p, *((u32 *) pSrcData));
1098 break;
1099 }
1100
1101 // 40 bit values
1102 case kEplObdTypInt40:
1103 case kEplObdTypUInt40:
1104 {
1105 AmiSetQword40ToLe(pDstData_p, *((u64 *) pSrcData));
1106 break;
1107 }
1108
1109 // 48 bit values
1110 case kEplObdTypInt48:
1111 case kEplObdTypUInt48:
1112 {
1113 AmiSetQword48ToLe(pDstData_p, *((u64 *) pSrcData));
1114 break;
1115 }
1116
1117 // 56 bit values
1118 case kEplObdTypInt56:
1119 case kEplObdTypUInt56:
1120 {
1121 AmiSetQword56ToLe(pDstData_p, *((u64 *) pSrcData));
1122 break;
1123 }
1124
1125 // 64 bit values
1126 case kEplObdTypInt64:
1127 case kEplObdTypUInt64:
1128 case kEplObdTypReal64:
1129 {
1130 AmiSetQword64ToLe(pDstData_p, *((u64 *) pSrcData));
1131 break;
1132 }
1133
1134 // time of day
1135 case kEplObdTypTimeOfDay:
1136 case kEplObdTypTimeDiff:
1137 {
1138 AmiSetTimeOfDay(pDstData_p, ((tTimeOfDay *) pSrcData));
1139 break;
1140 }
1141
1142 } // end of switch(pSubEntry->m_Type)
1143
1144 *pSize_p = ObdSize;
1145
1146 // write address of destination data to structure of callback parameters
1147 // so callback function can change this data after reading
1148 CbParam.m_pArg = pDstData_p;
1149 CbParam.m_ObdEvent = kEplObdEvPostRead;
1150 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1151 pObdEntry->m_fpCallback, &CbParam);
1152
1153 Exit:
1154
1155 return Ret;
1156
1157 }
1158
1159 //---------------------------------------------------------------------------
1160 //
1161 // Function: EplObdWriteEntryFromLe()
1162 //
1163 // Description: Function writes data to an OBD entry from a source with
1164 // little endian byteorder to the od with system specuific
1165 // byteorder. Not numerical values will only by copied. Strings
1166 // are stored with added '\0' character.
1167 //
1168 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
1169 // uiIndex_p = Index of the OD entry
1170 // uiSubIndex_p = Subindex of the OD Entry
1171 // pSrcData_p = Pointer to the data to write
1172 // Size_p = Size of the data in Byte
1173 //
1174 // Return: tEplKernel = Errorcode
1175 //
1176 //
1177 // State:
1178 //
1179 //---------------------------------------------------------------------------
1180 tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
1181 unsigned int uiSubIndex_p,
1182 void *pSrcData_p, tEplObdSize Size_p)
1183 {
1184 tEplKernel Ret;
1185 tEplObdEntryPtr pObdEntry;
1186 tEplObdSubEntryPtr pSubEntry;
1187 tEplObdCbParam CbParam;
1188 void *pDstData;
1189 tEplObdSize ObdSize;
1190 u64 qwBuffer;
1191 void *pBuffer = &qwBuffer;
1192
1193 Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
1194 uiIndex_p,
1195 uiSubIndex_p,
1196 pSrcData_p,
1197 &pDstData,
1198 Size_p,
1199 &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
1200 if (Ret != kEplSuccessful) {
1201 goto Exit;
1202 }
1203
1204 // check if numerical type
1205 switch (pSubEntry->m_Type) {
1206 //-----------------------------------------------
1207 // types without ami
1208 default:
1209 { // do nothing, i.e. use the given source pointer
1210 pBuffer = pSrcData_p;
1211 break;
1212 }
1213
1214 //-----------------------------------------------
1215 // numerical type which needs ami-write
1216 // 8 bit or smaller values
1217 case kEplObdTypBool:
1218 case kEplObdTypInt8:
1219 case kEplObdTypUInt8:
1220 {
1221 *((u8 *) pBuffer) = AmiGetByteFromLe(pSrcData_p);
1222 break;
1223 }
1224
1225 // 16 bit values
1226 case kEplObdTypInt16:
1227 case kEplObdTypUInt16:
1228 {
1229 *((u16 *) pBuffer) = AmiGetWordFromLe(pSrcData_p);
1230 break;
1231 }
1232
1233 // 24 bit values
1234 case kEplObdTypInt24:
1235 case kEplObdTypUInt24:
1236 {
1237 *((u32 *) pBuffer) = AmiGetDword24FromLe(pSrcData_p);
1238 break;
1239 }
1240
1241 // 32 bit values
1242 case kEplObdTypInt32:
1243 case kEplObdTypUInt32:
1244 case kEplObdTypReal32:
1245 {
1246 *((u32 *) pBuffer) = AmiGetDwordFromLe(pSrcData_p);
1247 break;
1248 }
1249
1250 // 40 bit values
1251 case kEplObdTypInt40:
1252 case kEplObdTypUInt40:
1253 {
1254 *((u64 *) pBuffer) = AmiGetQword40FromLe(pSrcData_p);
1255 break;
1256 }
1257
1258 // 48 bit values
1259 case kEplObdTypInt48:
1260 case kEplObdTypUInt48:
1261 {
1262 *((u64 *) pBuffer) = AmiGetQword48FromLe(pSrcData_p);
1263 break;
1264 }
1265
1266 // 56 bit values
1267 case kEplObdTypInt56:
1268 case kEplObdTypUInt56:
1269 {
1270 *((u64 *) pBuffer) = AmiGetQword56FromLe(pSrcData_p);
1271 break;
1272 }
1273
1274 // 64 bit values
1275 case kEplObdTypInt64:
1276 case kEplObdTypUInt64:
1277 case kEplObdTypReal64:
1278 {
1279 *((u64 *) pBuffer) = AmiGetQword64FromLe(pSrcData_p);
1280 break;
1281 }
1282
1283 // time of day
1284 case kEplObdTypTimeOfDay:
1285 case kEplObdTypTimeDiff:
1286 {
1287 AmiGetTimeOfDay(pBuffer, ((tTimeOfDay *) pSrcData_p));
1288 break;
1289 }
1290
1291 } // end of switch(pSubEntry->m_Type)
1292
1293 Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
1294 pObdEntry,
1295 pSubEntry,
1296 &CbParam, pBuffer, pDstData, ObdSize);
1297 if (Ret != kEplSuccessful) {
1298 goto Exit;
1299 }
1300
1301 Exit:
1302
1303 return Ret;
1304
1305 }
1306
1307 //---------------------------------------------------------------------------
1308 //
1309 // Function: EplObdGetAccessType()
1310 //
1311 // Description: Function returns accesstype of the entry
1312 //
1313 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
1314 // uiIndex_p = Index of the OD entry
1315 // uiSubIndex_p = Subindex of the OD Entry
1316 // pAccessTyp_p = pointer to buffer to store accesstype
1317 //
1318 // Return: tEplKernel = errorcode
1319 //
1320 //
1321 // State:
1322 //
1323 //---------------------------------------------------------------------------
1324 tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
1325 unsigned int uiSubIndex_p,
1326 tEplObdAccess *pAccessTyp_p)
1327 {
1328 tEplKernel Ret;
1329 tEplObdEntryPtr pObdEntry;
1330 tEplObdSubEntryPtr pObdSubEntry;
1331
1332 // get pointer to index structure
1333 Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
1334 uiIndex_p, &pObdEntry);
1335 if (Ret != kEplSuccessful) {
1336 goto Exit;
1337 }
1338 // get pointer to subindex structure
1339 Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
1340 if (Ret != kEplSuccessful) {
1341 goto Exit;
1342 }
1343 // get accessType
1344 *pAccessTyp_p = pObdSubEntry->m_Access;
1345
1346 Exit:
1347 return Ret;
1348 }
1349
1350 //---------------------------------------------------------------------------
1351 //
1352 // Function: EplObdSearchVarEntry()
1353 //
1354 // Description: gets variable from OD
1355 //
1356 // Parameters: uiIndex_p = index of the var entry to search
1357 // uiSubindex_p = subindex of var entry to search
1358 // ppVarEntry_p = pointer to the pointer to the varentry
1359 //
1360 // Return: tEplKernel
1361 //
1362 // State:
1363 //
1364 //---------------------------------------------------------------------------
1365
1366 tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
1367 unsigned int uiSubindex_p,
1368 tEplObdVarEntry **ppVarEntry_p)
1369 {
1370
1371 tEplKernel Ret;
1372 tEplObdSubEntryPtr pSubindexEntry;
1373
1374 // check for all API function if instance is valid
1375 EPL_MCO_CHECK_INSTANCE_STATE();
1376
1377 // get address of subindex entry
1378 Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1379 uiIndex_p, uiSubindex_p, NULL, &pSubindexEntry);
1380 if (Ret == kEplSuccessful) {
1381 // get var entry
1382 Ret = EplObdGetVarEntry(pSubindexEntry, ppVarEntry_p);
1383 }
1384
1385 return Ret;
1386
1387 }
1388
1389 //=========================================================================//
1390 // //
1391 // P R I V A T E D E F I N I T I O N S //
1392 // //
1393 //=========================================================================//
1394
1395 EPL_MCO_DECL_INSTANCE_FCT()
1396 //---------------------------------------------------------------------------
1397 //
1398 // Function: EplObdCallObjectCallback()
1399 //
1400 // Description: calls callback function of an object or of a variable
1401 //
1402 // Parameters: fpCallback_p
1403 // pCbParam_p
1404 //
1405 // Return: tEplKernel
1406 //
1407 // State:
1408 //
1409 //---------------------------------------------------------------------------
1410 static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
1411 tEplObdCallback fpCallback_p,
1412 tEplObdCbParam *pCbParam_p)
1413 {
1414
1415 tEplKernel Ret;
1416 tEplObdCallback fpCallback;
1417
1418 // check for all API function if instance is valid
1419 EPL_MCO_CHECK_INSTANCE_STATE();
1420
1421 ASSERT(pCbParam_p != NULL);
1422
1423 Ret = kEplSuccessful;
1424
1425 // check address of callback function before calling it
1426 if (fpCallback_p != NULL) {
1427 // KEIL C51 V6.01 has a bug.
1428 // Therefore the parameter fpCallback_p has to be copied in local variable fpCallback.
1429 fpCallback = fpCallback_p;
1430
1431 // call callback function for this object
1432 Ret = fpCallback(EPL_MCO_INSTANCE_PARAM_IDX_()
1433 pCbParam_p);
1434 }
1435
1436 return Ret;
1437 }
1438
1439 //---------------------------------------------------------------------------
1440 //
1441 // Function: EplObdGetDataSizeIntern()
1442 //
1443 // Description: gets the data size of an object
1444 // for string objects it returnes the string length
1445 //
1446 // Parameters: pSubIndexEntry_p
1447 //
1448 // Return: tEplObdSize
1449 //
1450 // State:
1451 //
1452 //---------------------------------------------------------------------------
1453
1454 static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p)
1455 {
1456
1457 tEplObdSize DataSize;
1458 void *pData;
1459
1460 // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
1461 // then the current pointer is always NULL. The function
1462 // returns the length of default string.
1463 DataSize = EplObdGetObjectSize(pSubIndexEntry_p);
1464
1465 if (pSubIndexEntry_p->m_Type == kEplObdTypVString) {
1466 // The pointer to current value can be received from EplObdGetObjectCurrentPtr()
1467 pData = ((void *)EplObdGetObjectCurrentPtr(pSubIndexEntry_p));
1468 if (pData != NULL) {
1469 DataSize =
1470 EplObdGetStrLen((void *)pData, DataSize,
1471 pSubIndexEntry_p->m_Type);
1472 }
1473
1474 }
1475
1476 return DataSize;
1477
1478 }
1479
1480 //---------------------------------------------------------------------------
1481 //
1482 // Function: EplObdGetStrLen()
1483 //
1484 // Description: The function calculates the length of string. The '\0'
1485 // character is included!!
1486 //
1487 // Parameters: pObjData_p = pointer to string
1488 // ObjLen_p = max. length of objectr entry
1489 // bObjType_p = object type (VSTRING, ...)
1490 //
1491 // Returns: string length + 1
1492 //
1493 // State:
1494 //
1495 //---------------------------------------------------------------------------
1496
1497 static tEplObdSize EplObdGetStrLen(void *pObjData_p,
1498 tEplObdSize ObjLen_p, tEplObdType ObjType_p)
1499 {
1500
1501 tEplObdSize StrLen = 0;
1502 u8 *pbString;
1503
1504 if (pObjData_p == NULL) {
1505 goto Exit;
1506 }
1507 //----------------------------------------
1508 // Visible String: data format byte
1509 if (ObjType_p == kEplObdTypVString) {
1510 pbString = pObjData_p;
1511
1512 for (StrLen = 0; StrLen < ObjLen_p; StrLen++) {
1513 if (*pbString == '\0') {
1514 StrLen++;
1515 break;
1516 }
1517
1518 pbString++;
1519 }
1520 }
1521 //----------------------------------------
1522 // other string types ...
1523
1524 Exit:
1525 return (StrLen);
1526
1527 }
1528
1529 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
1530
1531 //---------------------------------------------------------------------------
1532 //
1533 // Function: EplObdCheckObjectRange()
1534 //
1535 // Description: function to check value range of object data
1536 //
1537 // NOTICE: The pointer of data (pData_p) must point out to an even address,
1538 // if ObjType is unequal to kEplObdTypInt8 or kEplObdTypUInt8! But it is
1539 // always realiced because pointer m_pDefault points always to an
1540 // array of the SPECIFIED type.
1541 //
1542 // Parameters: pSubindexEntry_p
1543 // pData_p
1544 //
1545 // Return: tEplKernel
1546 //
1547 // State:
1548 //
1549 //---------------------------------------------------------------------------
1550
1551 static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
1552 void *pData_p)
1553 {
1554
1555 tEplKernel Ret;
1556 void *pRangeData;
1557
1558 ASSERTMSG(pSubindexEntry_p != NULL,
1559 "EplObdCheckObjectRange(): no address to subindex struct!\n");
1560
1561 Ret = kEplSuccessful;
1562
1563 // check if data range has to be checked
1564 if ((pSubindexEntry_p->m_Access & kEplObdAccRange) == 0) {
1565 goto Exit;
1566 }
1567 // get address of default data
1568 pRangeData = pSubindexEntry_p->m_pDefault;
1569
1570 // jump to called object type
1571 switch ((tEplObdType) pSubindexEntry_p->m_Type) {
1572 // -----------------------------------------------------------------
1573 // ObdType kEplObdTypBool will not be checked because there are only
1574 // two possible values 0 or 1.
1575
1576 // -----------------------------------------------------------------
1577 // ObdTypes which has to be check up because numerical values
1578 case kEplObdTypInt8:
1579
1580 // switch to lower limit
1581 pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
1582
1583 // check if value is to low
1584 if (*((tEplObdInteger8 *) pData_p) <
1585 *((tEplObdInteger8 *) pRangeData)) {
1586 Ret = kEplObdValueTooLow;
1587 break;
1588 }
1589 // switch to higher limit
1590 pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
1591
1592 // check if value is to high
1593 if (*((tEplObdInteger8 *) pData_p) >
1594 *((tEplObdInteger8 *) pRangeData)) {
1595 Ret = kEplObdValueTooHigh;
1596 }
1597
1598 break;
1599
1600 case kEplObdTypUInt8:
1601
1602 // switch to lower limit
1603 pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
1604
1605 // check if value is to low
1606 if (*((tEplObdUnsigned8 *) pData_p) <
1607 *((tEplObdUnsigned8 *) pRangeData)) {
1608 Ret = kEplObdValueTooLow;
1609 break;
1610 }
1611 // switch to higher limit
1612 pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
1613
1614 // check if value is to high
1615 if (*((tEplObdUnsigned8 *) pData_p) >
1616 *((tEplObdUnsigned8 *) pRangeData)) {
1617 Ret = kEplObdValueTooHigh;
1618 }
1619
1620 break;
1621
1622 case kEplObdTypInt16:
1623
1624 // switch to lower limit
1625 pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
1626
1627 // check if value is to low
1628 if (*((tEplObdInteger16 *) pData_p) <
1629 *((tEplObdInteger16 *) pRangeData)) {
1630 Ret = kEplObdValueTooLow;
1631 break;
1632 }
1633 // switch to higher limit
1634 pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
1635
1636 // check if value is to high
1637 if (*((tEplObdInteger16 *) pData_p) >
1638 *((tEplObdInteger16 *) pRangeData)) {
1639 Ret = kEplObdValueTooHigh;
1640 }
1641
1642 break;
1643
1644 case kEplObdTypUInt16:
1645
1646 // switch to lower limit
1647 pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
1648
1649 // check if value is to low
1650 if (*((tEplObdUnsigned16 *) pData_p) <
1651 *((tEplObdUnsigned16 *) pRangeData)) {
1652 Ret = kEplObdValueTooLow;
1653 break;
1654 }
1655 // switch to higher limit
1656 pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
1657
1658 // check if value is to high
1659 if (*((tEplObdUnsigned16 *) pData_p) >
1660 *((tEplObdUnsigned16 *) pRangeData)) {
1661 Ret = kEplObdValueTooHigh;
1662 }
1663
1664 break;
1665
1666 case kEplObdTypInt32:
1667
1668 // switch to lower limit
1669 pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
1670
1671 // check if value is to low
1672 if (*((tEplObdInteger32 *) pData_p) <
1673 *((tEplObdInteger32 *) pRangeData)) {
1674 Ret = kEplObdValueTooLow;
1675 break;
1676 }
1677 // switch to higher limit
1678 pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
1679
1680 // check if value is to high
1681 if (*((tEplObdInteger32 *) pData_p) >
1682 *((tEplObdInteger32 *) pRangeData)) {
1683 Ret = kEplObdValueTooHigh;
1684 }
1685
1686 break;
1687
1688 case kEplObdTypUInt32:
1689
1690 // switch to lower limit
1691 pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
1692
1693 // check if value is to low
1694 if (*((tEplObdUnsigned32 *) pData_p) <
1695 *((tEplObdUnsigned32 *) pRangeData)) {
1696 Ret = kEplObdValueTooLow;
1697 break;
1698 }
1699 // switch to higher limit
1700 pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
1701
1702 // check if value is to high
1703 if (*((tEplObdUnsigned32 *) pData_p) >
1704 *((tEplObdUnsigned32 *) pRangeData)) {
1705 Ret = kEplObdValueTooHigh;
1706 }
1707
1708 break;
1709
1710 case kEplObdTypReal32:
1711
1712 // switch to lower limit
1713 pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
1714
1715 // check if value is to low
1716 if (*((tEplObdReal32 *) pData_p) <
1717 *((tEplObdReal32 *) pRangeData)) {
1718 Ret = kEplObdValueTooLow;
1719 break;
1720 }
1721 // switch to higher limit
1722 pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
1723
1724 // check if value is to high
1725 if (*((tEplObdReal32 *) pData_p) >
1726 *((tEplObdReal32 *) pRangeData)) {
1727 Ret = kEplObdValueTooHigh;
1728 }
1729
1730 break;
1731
1732 // -----------------------------------------------------------------
1733 case kEplObdTypInt40:
1734 case kEplObdTypInt48:
1735 case kEplObdTypInt56:
1736 case kEplObdTypInt64:
1737
1738 // switch to lower limit
1739 pRangeData = ((signed u64 *)pRangeData) + 1;
1740
1741 // check if value is to low
1742 if (*((signed u64 *)pData_p) < *((signed u64 *)pRangeData)) {
1743 Ret = kEplObdValueTooLow;
1744 break;
1745 }
1746 // switch to higher limit
1747 pRangeData = ((signed u64 *)pRangeData) + 1;
1748
1749 // check if value is to high
1750 if (*((signed u64 *)pData_p) > *((signed u64 *)pRangeData)) {
1751 Ret = kEplObdValueTooHigh;
1752 }
1753
1754 break;
1755
1756 // -----------------------------------------------------------------
1757 case kEplObdTypUInt40:
1758 case kEplObdTypUInt48:
1759 case kEplObdTypUInt56:
1760 case kEplObdTypUInt64:
1761
1762 // switch to lower limit
1763 pRangeData = ((unsigned u64 *)pRangeData) + 1;
1764
1765 // check if value is to low
1766 if (*((unsigned u64 *)pData_p) <
1767 *((unsigned u64 *)pRangeData)) {
1768 Ret = kEplObdValueTooLow;
1769 break;
1770 }
1771 // switch to higher limit
1772 pRangeData = ((unsigned u64 *)pRangeData) + 1;
1773
1774 // check if value is to high
1775 if (*((unsigned u64 *)pData_p) >
1776 *((unsigned u64 *)pRangeData)) {
1777 Ret = kEplObdValueTooHigh;
1778 }
1779
1780 break;
1781
1782 // -----------------------------------------------------------------
1783 case kEplObdTypReal64:
1784
1785 // switch to lower limit
1786 pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
1787
1788 // check if value is to low
1789 if (*((tEplObdReal64 *) pData_p) <
1790 *((tEplObdReal64 *) pRangeData)) {
1791 Ret = kEplObdValueTooLow;
1792 break;
1793 }
1794 // switch to higher limit
1795 pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
1796
1797 // check if value is to high
1798 if (*((tEplObdReal64 *) pData_p) >
1799 *((tEplObdReal64 *) pRangeData)) {
1800 Ret = kEplObdValueTooHigh;
1801 }
1802
1803 break;
1804
1805 // -----------------------------------------------------------------
1806 case kEplObdTypTimeOfDay:
1807 case kEplObdTypTimeDiff:
1808 break;
1809
1810 // -----------------------------------------------------------------
1811 // ObdTypes kEplObdTypXString and kEplObdTypDomain can not be checkt because
1812 // they have no numerical value.
1813 default:
1814
1815 Ret = kEplObdUnknownObjectType;
1816 break;
1817 }
1818
1819 Exit:
1820
1821 return Ret;
1822
1823 }
1824 #endif // (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
1825
1826 //---------------------------------------------------------------------------
1827 //
1828 // Function: EplObdWriteEntryPre()
1829 //
1830 // Description: Function prepares write of data to an OBD entry. Strings
1831 // are stored with added '\0' character.
1832 //
1833 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
1834 // uiIndex_p = Index of the OD entry
1835 // uiSubIndex_p = Subindex of the OD Entry
1836 // pSrcData_p = Pointer to the data to write
1837 // Size_p = Size of the data in Byte
1838 //
1839 // Return: tEplKernel = Errorcode
1840 //
1841 //
1842 // State:
1843 //
1844 //---------------------------------------------------------------------------
1845
1846 static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
1847 unsigned int uiSubIndex_p,
1848 void *pSrcData_p,
1849 void **ppDstData_p,
1850 tEplObdSize Size_p,
1851 tEplObdEntryPtr *ppObdEntry_p,
1852 tEplObdSubEntryPtr *ppSubEntry_p,
1853 tEplObdCbParam *pCbParam_p,
1854 tEplObdSize *pObdSize_p)
1855 {
1856
1857 tEplKernel Ret;
1858 tEplObdEntryPtr pObdEntry;
1859 tEplObdSubEntryPtr pSubEntry;
1860 tEplObdAccess Access;
1861 void *pDstData;
1862 tEplObdSize ObdSize;
1863 BOOL fEntryNumerical;
1864
1865 #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1866 tEplObdVStringDomain MemVStringDomain;
1867 void *pCurrData;
1868 #endif
1869
1870 // check for all API function if instance is valid
1871 EPL_MCO_CHECK_INSTANCE_STATE();
1872
1873 ASSERT(pSrcData_p != NULL); // should never be NULL
1874
1875 //------------------------------------------------------------------------
1876 // get address of index and subindex entry
1877 Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1878 uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
1879 if (Ret != kEplSuccessful) {
1880 goto Exit;
1881 }
1882 // get pointer to object data
1883 pDstData = (void *)EplObdGetObjectDataPtrIntern(pSubEntry);
1884
1885 Access = (tEplObdAccess) pSubEntry->m_Access;
1886
1887 // check access for write
1888 // access violation if adress to current value is NULL
1889 if (((Access & kEplObdAccConst) != 0) || (pDstData == NULL)) {
1890 Ret = kEplObdAccessViolation;
1891 goto Exit;
1892 }
1893 //------------------------------------------------------------------------
1894 // get size of object
1895 // -as ObdSize = ObdGetObjectSize (pSubEntry);
1896
1897 //------------------------------------------------------------------------
1898 // To use the same callback function for ObdWriteEntry as well as for
1899 // an SDO download call at first (kEplObdEvPre...) the callback function
1900 // with the argument pointer to object size.
1901 pCbParam_p->m_uiIndex = uiIndex_p;
1902 pCbParam_p->m_uiSubIndex = uiSubIndex_p;
1903
1904 // Because object size and object pointer are
1905 // adapted by user callback function, re-read
1906 // this values.
1907 ObdSize = EplObdGetObjectSize(pSubEntry);
1908 pDstData = (void *)EplObdGetObjectDataPtrIntern(pSubEntry);
1909
1910 // 09-dec-2004 r.d.:
1911 // Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain
1912 // for String or Domain which lets called module directly change
1913 // the data pointer or size. This prevents a recursive call to
1914 // the callback function if it calls EplObdGetEntry().
1915 #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1916 if ((pSubEntry->m_Type == kEplObdTypVString) ||
1917 (pSubEntry->m_Type == kEplObdTypDomain) ||
1918 (pSubEntry->m_Type == kEplObdTypOString)) {
1919 if (pSubEntry->m_Type == kEplObdTypVString) {
1920 // reserve one byte for 0-termination
1921 // -as ObdSize -= 1;
1922 Size_p += 1;
1923 }
1924 // fill out new arg-struct
1925 MemVStringDomain.m_DownloadSize = Size_p;
1926 MemVStringDomain.m_ObjSize = ObdSize;
1927 MemVStringDomain.m_pData = pDstData;
1928
1929 pCbParam_p->m_ObdEvent = kEplObdEvWrStringDomain;
1930 pCbParam_p->m_pArg = &MemVStringDomain;
1931 // call user callback
1932 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1933 pObdEntry->m_fpCallback,
1934 pCbParam_p);
1935 if (Ret != kEplSuccessful) {
1936 goto Exit;
1937 }
1938 // write back new settings
1939 pCurrData = pSubEntry->m_pCurrent;
1940 if ((pSubEntry->m_Type == kEplObdTypVString)
1941 || (pSubEntry->m_Type == kEplObdTypOString)) {
1942 ((tEplObdVString *)pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
1943 ((tEplObdVString *)pCurrData)->m_pString = MemVStringDomain.m_pData;
1944 } else // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain)
1945 {
1946 ((tEplObdVarEntry *)pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
1947 ((tEplObdVarEntry *)pCurrData)->m_pData = (void *)MemVStringDomain.m_pData;
1948 }
1949
1950 // Because object size and object pointer are
1951 // adapted by user callback function, re-read
1952 // this values.
1953 ObdSize = MemVStringDomain.m_ObjSize;
1954 pDstData = (void *)MemVStringDomain.m_pData;
1955 }
1956 #endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1957
1958 // 07-dec-2004 r.d.: size from application is needed because callback function can change the object size
1959 // -as 16.11.04 CbParam.m_pArg = &ObdSize;
1960 // 09-dec-2004 r.d.: CbParam.m_pArg = &Size_p;
1961 pCbParam_p->m_pArg = &ObdSize;
1962 pCbParam_p->m_ObdEvent = kEplObdEvInitWrite;
1963 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1964 pObdEntry->m_fpCallback, pCbParam_p);
1965 if (Ret != kEplSuccessful) {
1966 goto Exit;
1967 }
1968
1969 if (Size_p > ObdSize) {
1970 Ret = kEplObdValueLengthError;
1971 goto Exit;
1972 }
1973
1974 if (pSubEntry->m_Type == kEplObdTypVString) {
1975 if (((char *)pSrcData_p)[Size_p - 1] == '\0') { // last byte of source string contains null character
1976
1977 // reserve one byte in destination for 0-termination
1978 Size_p -= 1;
1979 } else if (Size_p >= ObdSize) { // source string is not 0-terminated
1980 // and destination buffer is too short
1981 Ret = kEplObdValueLengthError;
1982 goto Exit;
1983 }
1984 }
1985
1986 Ret = EplObdIsNumericalIntern(pSubEntry, &fEntryNumerical);
1987 if (Ret != kEplSuccessful) {
1988 goto Exit;
1989 }
1990
1991 if ((fEntryNumerical != FALSE)
1992 && (Size_p != ObdSize)) {
1993 // type is numerical, therefor size has to fit, but it does not.
1994 Ret = kEplObdValueLengthError;
1995 goto Exit;
1996 }
1997 // use given size, because non-numerical objects can be written with shorter values
1998 ObdSize = Size_p;
1999
2000 // set output parameters
2001 *pObdSize_p = ObdSize;
2002 *ppObdEntry_p = pObdEntry;
2003 *ppSubEntry_p = pSubEntry;
2004 *ppDstData_p = pDstData;
2005
2006 // all checks are done
2007 // the caller may now convert the numerial source value to platform byte order in a temporary buffer
2008
2009 Exit:
2010
2011 return Ret;
2012
2013 }
2014
2015 //---------------------------------------------------------------------------
2016 //
2017 // Function: EplObdWriteEntryPost()
2018 //
2019 // Description: Function finishes write of data to an OBD entry. Strings
2020 // are stored with added '\0' character.
2021 //
2022 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_
2023 // uiIndex_p = Index of the OD entry
2024 // uiSubIndex_p = Subindex of the OD Entry
2025 // pSrcData_p = Pointer to the data to write
2026 // Size_p = Size of the data in Byte
2027 //
2028 // Return: tEplKernel = Errorcode
2029 //
2030 //
2031 // State:
2032 //
2033 //---------------------------------------------------------------------------
2034
2035 static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
2036 tEplObdSubEntryPtr pSubEntry_p,
2037 tEplObdCbParam *pCbParam_p,
2038 void *pSrcData_p,
2039 void *pDstData_p,
2040 tEplObdSize ObdSize_p)
2041 {
2042
2043 tEplKernel Ret;
2044
2045 // caller converted the source value to platform byte order
2046 // now the range of the value may be checked
2047
2048 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
2049 {
2050 // check data range
2051 Ret = EplObdCheckObjectRange(pSubEntry_p, pSrcData_p);
2052 if (Ret != kEplSuccessful) {
2053 goto Exit;
2054 }
2055 }
2056 #endif
2057
2058 // now call user callback function to check value
2059 // write address of source data to structure of callback parameters
2060 // so callback function can check this data
2061 pCbParam_p->m_pArg = pSrcData_p;
2062 pCbParam_p->m_ObdEvent = kEplObdEvPreWrite;
2063 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2064 pObdEntry_p->m_fpCallback, pCbParam_p);
2065 if (Ret != kEplSuccessful) {
2066 goto Exit;
2067 }
2068 // copy object data to OBD
2069 EPL_MEMCPY(pDstData_p, pSrcData_p, ObdSize_p);
2070
2071 // terminate string with 0
2072 if (pSubEntry_p->m_Type == kEplObdTypVString) {
2073 ((char *)pDstData_p)[ObdSize_p] = '\0';
2074 }
2075 // write address of destination to structure of callback parameters
2076 // so callback function can change data subsequently
2077 pCbParam_p->m_pArg = pDstData_p;
2078 pCbParam_p->m_ObdEvent = kEplObdEvPostWrite;
2079 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2080 pObdEntry_p->m_fpCallback, pCbParam_p);
2081
2082 Exit:
2083
2084 return Ret;
2085
2086 }
2087
2088 //---------------------------------------------------------------------------
2089 //
2090 // Function: EplObdGetObjectSize()
2091 //
2092 // Description: function to get size of object
2093 // The function determines if an object type an fixed data type (u8, u16, ...)
2094 // or non fixed object (string, domain). This information is used to decide
2095 // if download data are stored temporary or not. For objects with fixed data length
2096 // and types a value range checking can process.
2097 // For strings the function returns the whole object size not the
2098 // length of string.
2099 //
2100 // Parameters: pSubIndexEntry_p
2101 //
2102 // Return: tEplObdSize
2103 //
2104 // State:
2105 //
2106 //---------------------------------------------------------------------------
2107
2108 static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
2109 {
2110
2111 tEplObdSize DataSize = 0;
2112 void *pData;
2113
2114 switch (pSubIndexEntry_p->m_Type) {
2115 // -----------------------------------------------------------------
2116 case kEplObdTypBool:
2117
2118 DataSize = 1;
2119 break;
2120
2121 // -----------------------------------------------------------------
2122 // ObdTypes which has to be check because numerical values
2123 case kEplObdTypInt8:
2124 DataSize = sizeof(tEplObdInteger8);
2125 break;
2126
2127 // -----------------------------------------------------------------
2128 case kEplObdTypUInt8:
2129 DataSize = sizeof(tEplObdUnsigned8);
2130 break;
2131
2132 // -----------------------------------------------------------------
2133 case kEplObdTypInt16:
2134 DataSize = sizeof(tEplObdInteger16);
2135 break;
2136
2137 // -----------------------------------------------------------------
2138 case kEplObdTypUInt16:
2139 DataSize = sizeof(tEplObdUnsigned16);
2140 break;
2141
2142 // -----------------------------------------------------------------
2143 case kEplObdTypInt32:
2144 DataSize = sizeof(tEplObdInteger32);
2145 break;
2146
2147 // -----------------------------------------------------------------
2148 case kEplObdTypUInt32:
2149 DataSize = sizeof(tEplObdUnsigned32);
2150 break;
2151
2152 // -----------------------------------------------------------------
2153 case kEplObdTypReal32:
2154 DataSize = sizeof(tEplObdReal32);
2155 break;
2156
2157 // -----------------------------------------------------------------
2158 // ObdTypes which has to be not checked because not NUM values
2159 case kEplObdTypDomain:
2160
2161 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2162 if ((void *)pData != (void *)NULL) {
2163 DataSize = ((tEplObdVarEntry *) pData)->m_Size;
2164 }
2165 break;
2166
2167 // -----------------------------------------------------------------
2168 case kEplObdTypVString:
2169 //case kEplObdTypUString:
2170
2171 // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
2172 // then the current pointer is always NULL. The function
2173 // returns the length of default string.
2174 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2175 if ((void *)pData != (void *)NULL) {
2176 // The max. size of strings defined by STRING-Macro is stored in
2177 // tEplObdVString of current value.
2178 // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
2179 DataSize = ((tEplObdVString *) pData)->m_Size;
2180 } else {
2181 // The current position is not decleared. The string
2182 // is located in ROM, therefor use default pointer.
2183 pData = (void *)pSubIndexEntry_p->m_pDefault;
2184 if ((const void *)pData != (const void *)NULL) {
2185 // The max. size of strings defined by STRING-Macro is stored in
2186 // tEplObdVString of default value.
2187 DataSize = ((const tEplObdVString *)pData)->m_Size;
2188 }
2189 }
2190
2191 break;
2192
2193 // -----------------------------------------------------------------
2194 case kEplObdTypOString:
2195
2196 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2197 if ((void *)pData != (void *)NULL) {
2198 // The max. size of strings defined by STRING-Macro is stored in
2199 // tEplObdVString of current value.
2200 // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
2201 DataSize = ((tEplObdOString *) pData)->m_Size;
2202 } else {
2203 // The current position is not decleared. The string
2204 // is located in ROM, therefor use default pointer.
2205 pData = (void *)pSubIndexEntry_p->m_pDefault;
2206 if ((const void *)pData != (const void *)NULL) {
2207 // The max. size of strings defined by STRING-Macro is stored in
2208 // tEplObdVString of default value.
2209 DataSize = ((const tEplObdOString *)pData)->m_Size;
2210 }
2211 }
2212 break;
2213
2214 // -----------------------------------------------------------------
2215 case kEplObdTypInt24:
2216 case kEplObdTypUInt24:
2217
2218 DataSize = 3;
2219 break;
2220
2221 // -----------------------------------------------------------------
2222 case kEplObdTypInt40:
2223 case kEplObdTypUInt40:
2224
2225 DataSize = 5;
2226 break;
2227
2228 // -----------------------------------------------------------------
2229 case kEplObdTypInt48:
2230 case kEplObdTypUInt48:
2231
2232 DataSize = 6;
2233 break;
2234
2235 // -----------------------------------------------------------------
2236 case kEplObdTypInt56:
2237 case kEplObdTypUInt56:
2238
2239 DataSize = 7;
2240 break;
2241
2242 // -----------------------------------------------------------------
2243 case kEplObdTypInt64:
2244 case kEplObdTypUInt64:
2245 case kEplObdTypReal64:
2246
2247 DataSize = 8;
2248 break;
2249
2250 // -----------------------------------------------------------------
2251 case kEplObdTypTimeOfDay:
2252 case kEplObdTypTimeDiff:
2253
2254 DataSize = 6;
2255 break;
2256
2257 // -----------------------------------------------------------------
2258 default:
2259 break;
2260 }
2261
2262 return DataSize;
2263 }
2264
2265 //---------------------------------------------------------------------------
2266 //
2267 // Function: EplObdGetObjectDefaultPtr()
2268 //
2269 // Description: function to get the default pointer (type specific)
2270 //
2271 // Parameters: pSubIndexEntry_p = pointer to subindex structure
2272 //
2273 // Returns: (void *) = pointer to default value
2274 //
2275 // State:
2276 //
2277 //---------------------------------------------------------------------------
2278
2279 static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
2280 {
2281
2282 void *pDefault;
2283 tEplObdType Type;
2284
2285 ASSERTMSG(pSubIndexEntry_p != NULL,
2286 "EplObdGetObjectDefaultPtr(): pointer to SubEntry not valid!\n");
2287
2288 // get address to default data from default pointer
2289 pDefault = pSubIndexEntry_p->m_pDefault;
2290 if (pDefault != NULL) {
2291 // there are some special types, whose default pointer always is NULL or has to get from other structure
2292 // get type from subindex structure
2293 Type = pSubIndexEntry_p->m_Type;
2294
2295 // check if object type is a string value
2296 if ((Type == kEplObdTypVString) /* ||
2297 (Type == kEplObdTypUString) */ ) {
2298
2299 // EPL_OBD_SUBINDEX_RAM_VSTRING
2300 // tEplObdSize m_Size; --> size of default string
2301 // char * m_pDefString; --> pointer to default string
2302 // char * m_pString; --> pointer to string in RAM
2303 //
2304 pDefault =
2305 (void *)((tEplObdVString *) pDefault)->m_pString;
2306 } else if (Type == kEplObdTypOString) {
2307 pDefault =
2308 (void *)((tEplObdOString *) pDefault)->m_pString;
2309 }
2310 }
2311
2312 return pDefault;
2313
2314 }
2315
2316 //---------------------------------------------------------------------------
2317 //
2318 // Function: EplObdGetVarEntry()
2319 //
2320 // Description: gets a variable entry of an object
2321 //
2322 // Parameters: pSubindexEntry_p
2323 // ppVarEntry_p
2324 //
2325 // Return: tCopKernel
2326 //
2327 // State:
2328 //
2329 //---------------------------------------------------------------------------
2330
2331 static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
2332 tEplObdVarEntry **ppVarEntry_p)
2333 {
2334
2335 tEplKernel Ret = kEplObdVarEntryNotExist;
2336
2337 ASSERT(ppVarEntry_p != NULL); // is not allowed to be NULL
2338 ASSERT(pSubindexEntry_p != NULL);
2339
2340 // check VAR-Flag - only this object points to variables
2341 if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0) {
2342 // check if object is an array
2343 if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0) {
2344 *ppVarEntry_p = &((tEplObdVarEntry *)pSubindexEntry_p->m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
2345 } else {
2346 *ppVarEntry_p = (tEplObdVarEntry *)pSubindexEntry_p->m_pCurrent;
2347 }
2348
2349 Ret = kEplSuccessful;
2350 }
2351
2352 return Ret;
2353
2354 }
2355
2356 //---------------------------------------------------------------------------
2357 //
2358 // Function: EplObdGetEntry()
2359 //
2360 // Description: gets a index entry from OD
2361 //
2362 // Parameters: uiIndex_p = Index number
2363 // uiSubindex_p = Subindex number
2364 // ppObdEntry_p = pointer to the pointer to the entry
2365 // ppObdSubEntry_p = pointer to the pointer to the subentry
2366 //
2367 // Return: tEplKernel
2368
2369 //
2370 // State:
2371 //
2372 //---------------------------------------------------------------------------
2373
2374 static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
2375 unsigned int uiIndex_p,
2376 unsigned int uiSubindex_p,
2377 tEplObdEntryPtr * ppObdEntry_p,
2378 tEplObdSubEntryPtr * ppObdSubEntry_p)
2379 {
2380
2381 tEplObdEntryPtr pObdEntry;
2382 tEplObdCbParam CbParam;
2383 tEplKernel Ret;
2384
2385 // check for all API function if instance is valid
2386 EPL_MCO_CHECK_INSTANCE_STATE();
2387
2388 //------------------------------------------------------------------------
2389 // get address of entry of index
2390 Ret =
2391 EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam), uiIndex_p,
2392 &pObdEntry);
2393 if (Ret != kEplSuccessful) {
2394 goto Exit;
2395 }
2396 //------------------------------------------------------------------------
2397 // get address of entry of subindex
2398 Ret = EplObdGetSubindexIntern(pObdEntry, uiSubindex_p, ppObdSubEntry_p);
2399 if (Ret != kEplSuccessful) {
2400 goto Exit;
2401 }
2402 //------------------------------------------------------------------------
2403 // call callback function to inform user/stack that an object will be searched
2404 // if the called module returnes an error then we abort the searching with kEplObdIndexNotExist
2405 CbParam.m_uiIndex = uiIndex_p;
2406 CbParam.m_uiSubIndex = uiSubindex_p;
2407 CbParam.m_pArg = NULL;
2408 CbParam.m_ObdEvent = kEplObdEvCheckExist;
2409 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2410 pObdEntry->m_fpCallback, &CbParam);
2411 if (Ret != kEplSuccessful) {
2412 Ret = kEplObdIndexNotExist;
2413 goto Exit;
2414 }
2415 //------------------------------------------------------------------------
2416 // it is allowed to set ppObdEntry_p to NULL
2417 // if so, no address will be written to calling function
2418 if (ppObdEntry_p != NULL) {
2419 *ppObdEntry_p = pObdEntry;
2420 }
2421
2422 Exit:
2423
2424 return Ret;
2425
2426 }
2427
2428 //---------------------------------------------------------------------------
2429 //
2430 // Function: EplObdGetObjectCurrentPtr()
2431 //
2432 // Description: function to get Current pointer (type specific)
2433 //
2434 // Parameters: pSubIndexEntry_p
2435 //
2436 // Return: void *
2437 //
2438 // State:
2439 //
2440 //---------------------------------------------------------------------------
2441
2442 static void *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
2443 {
2444
2445 void *pData;
2446 unsigned int uiArrayIndex;
2447 tEplObdSize Size;
2448
2449 pData = pSubIndexEntry_p->m_pCurrent;
2450
2451 // check if constant object
2452 if (pData != NULL) {
2453 // check if object is an array
2454 if ((pSubIndexEntry_p->m_Access & kEplObdAccArray) != 0) {
2455 // calculate correct data pointer
2456 uiArrayIndex = pSubIndexEntry_p->m_uiSubIndex - 1;
2457 if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
2458 Size = sizeof(tEplObdVarEntry);
2459 } else {
2460 Size = EplObdGetObjectSize(pSubIndexEntry_p);
2461 }
2462 pData = ((u8 *) pData) + (Size * uiArrayIndex);
2463 }
2464 // check if VarEntry
2465 if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
2466 // The data pointer is stored in VarEntry->pData
2467 pData = ((tEplObdVarEntry *) pData)->m_pData;
2468 }
2469 // the default pointer is stored for strings in tEplObdVString
2470 else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString) /* ||
2471 (pSubIndexEntry_p->m_Type == kEplObdTypUString) */
2472 ) {
2473 pData = (void *)((tEplObdVString *)pData)->m_pString;
2474 } else if (pSubIndexEntry_p->m_Type == kEplObdTypOString) {
2475 pData =
2476 (void *)((tEplObdOString *)pData)->m_pString;
2477 }
2478 }
2479
2480 return pData;
2481
2482 }
2483
2484 //---------------------------------------------------------------------------
2485 //
2486 // Function: EplObdGetIndexIntern()
2487 //
2488 // Description: gets a index entry from OD
2489 //
2490 // Parameters: pInitParam_p
2491 // uiIndex_p
2492 // ppObdEntry_p
2493 //
2494 // Return: tEplKernel
2495 //
2496 // State:
2497 //
2498 //---------------------------------------------------------------------------
2499
2500 static tEplKernel EplObdGetIndexIntern(tEplObdInitParam *pInitParam_p,
2501 unsigned int uiIndex_p,
2502 tEplObdEntryPtr * ppObdEntry_p)
2503 {
2504
2505 tEplObdEntryPtr pObdEntry;
2506 tEplKernel Ret;
2507 unsigned int uiIndex;
2508
2509 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2510
2511 unsigned int nLoop;
2512
2513 // if user OD is used then objekts also has to be searched in user OD
2514 // there is less code need if we do this in a loop
2515 nLoop = 2;
2516
2517 #endif
2518
2519 ASSERTMSG(ppObdEntry_p != NULL,
2520 "EplObdGetIndexIntern(): pointer to index entry is NULL!\n");
2521
2522 Ret = kEplObdIndexNotExist;
2523
2524 // get start address of OD part
2525 // start address depends on object index because
2526 // object dictionary is divided in 3 parts
2527 if ((uiIndex_p >= 0x1000) && (uiIndex_p < 0x2000)) {
2528 pObdEntry = pInitParam_p->m_pPart;
2529 } else if ((uiIndex_p >= 0x2000) && (uiIndex_p < 0x6000)) {
2530 pObdEntry = pInitParam_p->m_pManufacturerPart;
2531 }
2532 // index range 0xA000 to 0xFFFF is reserved for DSP-405
2533 // DS-301 defines that range 0x6000 to 0x9FFF (!!!) is stored if "store" was written to 0x1010/3.
2534 // Therefore default configuration is OBD_INCLUDE_A000_TO_DEVICE_PART = FALSE.
2535 // But a CANopen Application which does not implement dynamic OD or user-OD but wants to use static objets 0xA000...
2536 // should set OBD_INCLUDE_A000_TO_DEVICE_PART to TRUE.
2537
2538 #if (EPL_OBD_INCLUDE_A000_TO_DEVICE_PART == FALSE)
2539 else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0x9FFF))
2540 #else
2541 else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0xFFFF))
2542 #endif
2543 {
2544 pObdEntry = pInitParam_p->m_pDevicePart;
2545 }
2546
2547 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2548
2549 // if index does not match in static OD then index only has to be searched in user OD
2550 else {
2551 // begin from first entry of user OD part
2552 pObdEntry = pInitParam_p->m_pUserPart;
2553
2554 // no user OD is available
2555 if (pObdEntry == NULL) {
2556 goto Exit;
2557 }
2558 // loop must only run once
2559 nLoop = 1;
2560 }
2561
2562 do {
2563
2564 #else
2565
2566 // no user OD is available
2567 // so other object can be found in OD
2568 else {
2569 Ret = kEplObdIllegalPart;
2570 goto Exit;
2571 }
2572
2573 #endif
2574
2575 // note:
2576 // The end of Index table is marked with m_uiIndex = 0xFFFF.
2577 // If this function will be called with wIndex_p = 0xFFFF, entry
2578 // should not be found. Therefor it is important to use
2579 // while{} instead of do{}while !!!
2580
2581 // get first index of index table
2582 uiIndex = pObdEntry->m_uiIndex;
2583
2584 // search Index in OD part
2585 while (uiIndex != EPL_OBD_TABLE_INDEX_END) {
2586 // go to the end of this function if index is found
2587 if (uiIndex_p == uiIndex) {
2588 // write address of OD entry to calling function
2589 *ppObdEntry_p = pObdEntry;
2590 Ret = kEplSuccessful;
2591 goto Exit;
2592 }
2593 // objects are sorted in OD
2594 // if the current index in OD is greater than the index which is to search then break loop
2595 // in this case user OD has to be search too
2596 if (uiIndex_p < uiIndex) {
2597 break;
2598 }
2599 // next entry in index table
2600 pObdEntry++;
2601
2602 // get next index of index table
2603 uiIndex = pObdEntry->m_uiIndex;
2604 }
2605
2606 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2607
2608 // begin from first entry of user OD part
2609 pObdEntry = pInitParam_p->m_pUserPart;
2610
2611 // no user OD is available
2612 if (pObdEntry == NULL) {
2613 goto Exit;
2614 }
2615 // switch next loop for user OD
2616 nLoop--;
2617
2618 }
2619
2620 while (nLoop > 0) ;
2621
2622 #endif
2623
2624 // in this line Index was not found
2625
2626 Exit:
2627
2628 return Ret;
2629
2630 }
2631
2632 //---------------------------------------------------------------------------
2633 //
2634 // Function: EplObdGetSubindexIntern()
2635 //
2636 // Description: gets a subindex entry from a index entry
2637 //
2638 // Parameters: pObdEntry_p
2639 // bSubIndex_p
2640 // ppObdSubEntry_p
2641 //
2642 // Return: tEplKernel
2643 //
2644 // State:
2645 //
2646 //---------------------------------------------------------------------------
2647
2648 static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
2649 unsigned int uiSubIndex_p,
2650 tEplObdSubEntryPtr * ppObdSubEntry_p)
2651 {
2652
2653 tEplObdSubEntryPtr pSubEntry;
2654 unsigned int nSubIndexCount;
2655 tEplKernel Ret;
2656
2657 ASSERTMSG(pObdEntry_p != NULL,
2658 "EplObdGetSubindexIntern(): pointer to index is NULL!\n");
2659 ASSERTMSG(ppObdSubEntry_p != NULL,
2660 "EplObdGetSubindexIntern(): pointer to subindex is NULL!\n");
2661
2662 Ret = kEplObdSubindexNotExist;
2663
2664 // get start address of subindex table and count of subindices
2665 pSubEntry = pObdEntry_p->m_pSubIndex;
2666 nSubIndexCount = pObdEntry_p->m_uiCount;
2667 ASSERTMSG((pSubEntry != NULL) && (nSubIndexCount > 0), "ObdGetSubindexIntern(): invalid subindex table within index table!\n"); // should never be NULL
2668
2669 // search subindex in subindex table
2670 while (nSubIndexCount > 0) {
2671 // check if array is found
2672 if ((pSubEntry->m_Access & kEplObdAccArray) != 0) {
2673 // check if subindex is in range
2674 if (uiSubIndex_p < pObdEntry_p->m_uiCount) {
2675 // update subindex number (subindex entry of an array is always in RAM !!!)
2676 pSubEntry->m_uiSubIndex = uiSubIndex_p;
2677 *ppObdSubEntry_p = pSubEntry;
2678 Ret = kEplSuccessful;
2679 goto Exit;
2680 }
2681 }
2682 // go to the end of this function if subindex is found
2683 else if (uiSubIndex_p == pSubEntry->m_uiSubIndex) {
2684 *ppObdSubEntry_p = pSubEntry;
2685 Ret = kEplSuccessful;
2686 goto Exit;
2687 }
2688 // objects are sorted in OD
2689 // if the current subindex in OD is greater than the subindex which is to search then break loop
2690 // in this case user OD has to be search too
2691 if (uiSubIndex_p < pSubEntry->m_uiSubIndex) {
2692 break;
2693 }
2694
2695 pSubEntry++;
2696 nSubIndexCount--;
2697 }
2698
2699 // in this line SubIndex was not fount
2700
2701 Exit:
2702
2703 return Ret;
2704
2705 }
2706
2707 //---------------------------------------------------------------------------
2708 //
2709 // Function: EplObdSetStoreLoadObjCallback()
2710 //
2711 // Description: function set address to callbackfunction for command Store and Load
2712 //
2713 // Parameters: fpCallback_p
2714 //
2715 // Return: tEplKernel
2716 //
2717 // State:
2718 //
2719 //---------------------------------------------------------------------------
2720 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
2721 tEplKernel EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdStoreLoadObjCallback fpCallback_p)
2722 {
2723
2724 EPL_MCO_CHECK_INSTANCE_STATE();
2725
2726 // set new address of callback function
2727 EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = fpCallback_p;
2728
2729 return kEplSuccessful;
2730
2731 }
2732 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
2733
2734 //---------------------------------------------------------------------------
2735 //
2736 // Function: EplObdAccessOdPartIntern()
2737 //
2738 // Description: runs through OD and executes a job
2739 //
2740 // Parameters: CurrentOdPart_p
2741 // pObdEnty_p
2742 // Direction_p = what is to do (load values from flash or EEPROM, store, ...)
2743 //
2744 // Return: tEplKernel
2745 //
2746 // State:
2747 //
2748 //---------------------------------------------------------------------------
2749
2750 static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
2751 tEplObdPart CurrentOdPart_p,
2752 tEplObdEntryPtr pObdEnty_p,
2753 tEplObdDir Direction_p)
2754 {
2755
2756 tEplObdSubEntryPtr pSubIndex;
2757 unsigned int nSubIndexCount;
2758 tEplObdAccess Access;
2759 void *pDstData;
2760 void *pDefault;
2761 tEplObdSize ObjSize;
2762 tEplKernel Ret;
2763 tEplObdCbStoreParam CbStore;
2764 tEplObdVarEntry *pVarEntry;
2765
2766 ASSERT(pObdEnty_p != NULL);
2767
2768 Ret = kEplSuccessful;
2769
2770 // prepare structure for STORE RESTORE callback function
2771 CbStore.m_bCurrentOdPart = (u8) CurrentOdPart_p;
2772 CbStore.m_pData = NULL;
2773 CbStore.m_ObjSize = 0;
2774
2775 // command of first action depends on direction to access
2776 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
2777 if (Direction_p == kEplObdDirLoad) {
2778 CbStore.m_bCommand = (u8) kEplObdCommOpenRead;
2779
2780 // call callback function for previous command
2781 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
2782 if (Ret != kEplSuccessful) {
2783 goto Exit;
2784 }
2785 // set command for index and subindex loop
2786 CbStore.m_bCommand = (u8) kEplObdCommReadObj;
2787 } else if (Direction_p == kEplObdDirStore) {
2788 CbStore.m_bCommand = (u8) kEplObdCommOpenWrite;
2789
2790 // call callback function for previous command
2791 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
2792 if (Ret != kEplSuccessful) {
2793 goto Exit;
2794 }
2795 // set command for index and subindex loop
2796 CbStore.m_bCommand = (u8) kEplObdCommWriteObj;
2797 }
2798 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
2799
2800 // we should not restore the OD values here
2801 // the next NMT command "Reset Node" or "Reset Communication" resets the OD data
2802 if (Direction_p != kEplObdDirRestore) {
2803 // walk through OD part till end is found
2804 while (pObdEnty_p->m_uiIndex != EPL_OBD_TABLE_INDEX_END) {
2805 // get address to subindex table and count of subindices
2806 pSubIndex = pObdEnty_p->m_pSubIndex;
2807 nSubIndexCount = pObdEnty_p->m_uiCount;
2808 ASSERT((pSubIndex != NULL) && (nSubIndexCount > 0)); // should never be NULL
2809
2810 // walk through subindex table till all subinices were restored
2811 while (nSubIndexCount != 0) {
2812 Access = (tEplObdAccess) pSubIndex->m_Access;
2813
2814 // get pointer to current and default data
2815 pDefault = EplObdGetObjectDefaultPtr(pSubIndex);
2816 pDstData = EplObdGetObjectCurrentPtr(pSubIndex);
2817
2818 // NOTE (for kEplObdTypVString):
2819 // The function returnes the max. number of bytes for a
2820 // current string.
2821 // r.d.: For stings the default-size will be read in other lines following (kEplObdDirInit).
2822 ObjSize = EplObdGetObjectSize(pSubIndex);
2823
2824 // switch direction of OD access
2825 switch (Direction_p) {
2826 // --------------------------------------------------------------------------
2827 // VarEntry structures has to be initialized
2828 case kEplObdDirInit:
2829
2830 // If VAR-Flag is set, m_pCurrent means not address of data
2831 // but address of tEplObdVarEntry. Address of data has to be get from
2832 // this structure.
2833 if ((Access & kEplObdAccVar) != 0) {
2834 EplObdGetVarEntry(pSubIndex,
2835 &pVarEntry);
2836 EplObdInitVarEntry(pVarEntry,
2837 pSubIndex->
2838 m_Type,
2839 ObjSize);
2840 /*
2841 if ((Access & kEplObdAccArray) == 0)
2842 {
2843 EplObdInitVarEntry (pSubIndex->m_pCurrent, pSubIndex->m_Type, ObjSize);
2844 }
2845 else
2846 {
2847 EplObdInitVarEntry ((tEplObdVarEntry *) (((u8 *) pSubIndex->m_pCurrent) + (sizeof (tEplObdVarEntry) * pSubIndex->m_uiSubIndex)),
2848 pSubIndex->m_Type, ObjSize);
2849 }
2850 */
2851 // at this time no application variable is defined !!!
2852 // therefore data can not be copied.
2853 break;
2854 } else if (pSubIndex->m_Type ==
2855 kEplObdTypVString) {
2856 // If pointer m_pCurrent is not equal to NULL then the
2857 // string was defined with EPL_OBD_SUBINDEX_RAM_VSTRING. The current
2858 // pointer points to struct tEplObdVString located in MEM.
2859 // The element size includes the max. number of
2860 // bytes. The element m_pString includes the pointer
2861 // to string in MEM. The memory location of default string
2862 // must be copied to memory location of current string.
2863
2864 pDstData =
2865 pSubIndex->m_pCurrent;
2866 if (pDstData != NULL) {
2867 // 08-dec-2004: code optimization !!!
2868 // entries ((tEplObdVStringDef*) pSubIndex->m_pDefault)->m_pString
2869 // and ((tEplObdVStringDef*) pSubIndex->m_pDefault)->m_Size were read
2870 // twice. thats not necessary!
2871
2872 // For copying data we have to set the destination pointer to the real RAM string. This
2873 // pointer to RAM string is located in default string info structure. (translated r.d.)
2874 pDstData = (void *)((tEplObdVStringDef*) pSubIndex->m_pDefault)->m_pString;
2875 ObjSize = ((tEplObdVStringDef *)pSubIndex->m_pDefault)->m_Size;
2876
2877 ((tEplObdVString *)pSubIndex->m_pCurrent)->m_pString = pDstData;
2878 ((tEplObdVString *)pSubIndex->m_pCurrent)->m_Size = ObjSize;
2879 }
2880
2881 } else if (pSubIndex->m_Type ==
2882 kEplObdTypOString) {
2883 pDstData =
2884 pSubIndex->m_pCurrent;
2885 if (pDstData != NULL) {
2886 // 08-dec-2004: code optimization !!!
2887 // entries ((tEplObdOStringDef*) pSubIndex->m_pDefault)->m_pString
2888 // and ((tEplObdOStringDef*) pSubIndex->m_pDefault)->m_Size were read
2889 // twice. thats not necessary!
2890
2891 // For copying data we have to set the destination pointer to the real RAM string. This
2892 // pointer to RAM string is located in default string info structure. (translated r.d.)
2893 pDstData = (void *)((tEplObdOStringDef *) pSubIndex->m_pDefault)->m_pString;
2894 ObjSize = ((tEplObdOStringDef *)pSubIndex->m_pDefault)->m_Size;
2895
2896 ((tEplObdOString *)pSubIndex->m_pCurrent)->m_pString = pDstData;
2897 ((tEplObdOString *)pSubIndex->m_pCurrent)->m_Size = ObjSize;
2898 }
2899
2900 }
2901
2902 // no break !! because copy of data has to done too.
2903
2904 // --------------------------------------------------------------------------
2905 // all objects has to be restored with default values
2906 case kEplObdDirRestore:
2907
2908 // 09-dec-2004 r.d.: optimization! the same code for kEplObdDirRestore and kEplObdDirLoad
2909 // is replaced to function ObdCopyObjectData() with a new parameter.
2910
2911 // restore object data for init phase
2912 EplObdCopyObjectData(pDstData, pDefault,
2913 ObjSize,
2914 pSubIndex->m_Type);
2915 break;
2916
2917 // --------------------------------------------------------------------------
2918 // objects with attribute kEplObdAccStore has to be load from EEPROM or from a file
2919 case kEplObdDirLoad:
2920
2921 // restore object data for init phase
2922 EplObdCopyObjectData(pDstData, pDefault,
2923 ObjSize,
2924 pSubIndex->m_Type);
2925
2926 // no break !! because callback function has to be called too.
2927
2928 // --------------------------------------------------------------------------
2929 // objects with attribute kEplObdAccStore has to be stored in EEPROM or in a file
2930 case kEplObdDirStore:
2931
2932 // when attribute kEplObdAccStore is set, then call callback function
2933 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
2934 if ((Access & kEplObdAccStore) != 0) {
2935 // fill out data pointer and size of data
2936 CbStore.m_pData = pDstData;
2937 CbStore.m_ObjSize = ObjSize;
2938
2939 // call callback function for read or write object
2940 Ret =
2941 ObdCallStoreCallback
2942 (EPL_MCO_INSTANCE_PTR_ &
2943 CbStore);
2944 if (Ret != kEplSuccessful) {
2945 goto Exit;
2946 }
2947 }
2948 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
2949 break;
2950
2951 // --------------------------------------------------------------------------
2952 // if OD Builder key has to be checked no access to subindex and data should be made
2953 case kEplObdDirOBKCheck:
2954
2955 // no break !! because we want to break the second loop too.
2956
2957 // --------------------------------------------------------------------------
2958 // unknown Direction
2959 default:
2960
2961 // so we can break the second loop earler
2962 nSubIndexCount = 1;
2963 break;
2964 }
2965
2966 nSubIndexCount--;
2967
2968 // next subindex entry
2969 if ((Access & kEplObdAccArray) == 0) {
2970 pSubIndex++;
2971 if ((nSubIndexCount > 0)
2972 &&
2973 ((pSubIndex->
2974 m_Access & kEplObdAccArray) !=
2975 0)) {
2976 // next subindex points to an array
2977 // reset subindex number
2978 pSubIndex->m_uiSubIndex = 1;
2979 }
2980 } else {
2981 if (nSubIndexCount > 0) {
2982 // next subindex points to an array
2983 // increment subindex number
2984 pSubIndex->m_uiSubIndex++;
2985 }
2986 }
2987 }
2988
2989 // next index entry
2990 pObdEnty_p++;
2991 }
2992 }
2993 // -----------------------------------------------------------------------------------------
2994 // command of last action depends on direction to access
2995 if (Direction_p == kEplObdDirOBKCheck) {
2996
2997 goto Exit;
2998 }
2999 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
3000 else {
3001 if (Direction_p == kEplObdDirLoad) {
3002 CbStore.m_bCommand = (u8) kEplObdCommCloseRead;
3003 } else if (Direction_p == kEplObdDirStore) {
3004 CbStore.m_bCommand = (u8) kEplObdCommCloseWrite;
3005 } else if (Direction_p == kEplObdDirRestore) {
3006 CbStore.m_bCommand = (u8) kEplObdCommClear;
3007 } else {
3008 goto Exit;
3009 }
3010
3011 // call callback function for last command
3012 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
3013 }
3014 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
3015
3016 // goto Exit;
3017
3018 Exit:
3019
3020 return Ret;
3021
3022 }
3023
3024 // ----------------------------------------------------------------------------
3025 // Function: EplObdCopyObjectData()
3026 //
3027 // Description: checks pointers to object data and copy them from source to destination
3028 //
3029 // Parameters: pDstData_p = destination pointer
3030 // pSrcData_p = source pointer
3031 // ObjSize_p = size of object
3032 // ObjType_p =
3033 //
3034 // Returns: tEplKernel = error code
3035 // ----------------------------------------------------------------------------
3036
3037 static void EplObdCopyObjectData(void *pDstData_p,
3038 void *pSrcData_p,
3039 tEplObdSize ObjSize_p, tEplObdType ObjType_p)
3040 {
3041
3042 tEplObdSize StrSize = 0;
3043
3044 // it is allowed to set default and current address to NULL (nothing to copy)
3045 if (pDstData_p != NULL) {
3046
3047 if (ObjType_p == kEplObdTypVString) {
3048 // The function calculates the really number of characters of string. The
3049 // object entry size can be bigger as string size of default string.
3050 // The '\0'-termination is included. A string with no characters has a
3051 // size of 1.
3052 StrSize =
3053 EplObdGetStrLen((void *)pSrcData_p, ObjSize_p,
3054 kEplObdTypVString);
3055
3056 // If the string length is greater than or equal to the entry size in OD then only copy
3057 // entry size - 1 and always set the '\0'-termination.
3058 if (StrSize >= ObjSize_p) {
3059 StrSize = ObjSize_p - 1;
3060 }
3061 }
3062
3063 if (pSrcData_p != NULL) {
3064 // copy data
3065 EPL_MEMCPY(pDstData_p, pSrcData_p, ObjSize_p);
3066
3067 if (ObjType_p == kEplObdTypVString) {
3068 ((char *)pDstData_p)[StrSize] = '\0';
3069 }
3070 }
3071 }
3072
3073 }
3074
3075 //---------------------------------------------------------------------------
3076 //
3077 // Function: EplObdIsNumericalIntern()
3078 //
3079 // Description: function checks if a entry is numerical or not
3080 //
3081 //
3082 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
3083 // uiIndex_p = Index
3084 // uiSubIndex_p = Subindex
3085 // pfEntryNumerical_p = pointer to BOOL for returnvalue
3086 // -> TRUE if entry a numerical value
3087 // -> FALSE if entry not a numerical value
3088 //
3089 // Return: tEplKernel = Errorcode
3090 //
3091 // State:
3092 //
3093 //---------------------------------------------------------------------------
3094 static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
3095 BOOL * pfEntryNumerical_p)
3096 {
3097 tEplKernel Ret = kEplSuccessful;
3098
3099 // get Type
3100 if ((pObdSubEntry_p->m_Type == kEplObdTypVString)
3101 || (pObdSubEntry_p->m_Type == kEplObdTypOString)
3102 || (pObdSubEntry_p->m_Type == kEplObdTypDomain)) { // not numerical types
3103 *pfEntryNumerical_p = FALSE;
3104 } else { // numerical types
3105 *pfEntryNumerical_p = TRUE;
3106 }
3107
3108 return Ret;
3109
3110 }
3111
3112 // -------------------------------------------------------------------------
3113 // function to classify object type (fixed/non fixed)
3114 // -------------------------------------------------------------------------
3115
3116 // ----------------------------------------------------------------------------
3117 // Function: EplObdCallStoreCallback()
3118 //
3119 // Description: checks address to callback function and calles it when unequal
3120 // to NULL
3121 //
3122 // Parameters: EPL_MCO_DECL_INSTANCE_PTR_ = (instance pointer)
3123 // pCbStoreParam_p = address to callback parameters
3124 //
3125 // Returns: tEplKernel = error code
3126 // ----------------------------------------------------------------------------
3127 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
3128 static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
3129 tEplObdCbStoreParam *
3130 pCbStoreParam_p)
3131 {
3132
3133 tEplKernel Ret = kEplSuccessful;
3134
3135 ASSERT(pCbStoreParam_p != NULL);
3136
3137 // check if function pointer is NULL - if so, no callback should be called
3138 if (EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) != NULL) {
3139 Ret =
3140 EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback)
3141 (EPL_MCO_INSTANCE_PARAM_IDX_()
3142 pCbStoreParam_p);
3143 }
3144
3145 return Ret;
3146
3147 }
3148 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
3149 //---------------------------------------------------------------------------
3150 //
3151 // Function: EplObdGetObjectDataPtrIntern()
3152 //
3153 // Description: Function gets the data pointer of an object.
3154 // It returnes the current data pointer. But if object is an
3155 // constant object it returnes the default pointer.
3156 //
3157 // Parameters: pSubindexEntry_p = pointer to subindex entry
3158 //
3159 // Return: void * = pointer to object data
3160 //
3161 // State:
3162 //
3163 //---------------------------------------------------------------------------
3164
3165 void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p)
3166 {
3167
3168 void *pData;
3169 tEplObdAccess Access;
3170
3171 ASSERTMSG(pSubindexEntry_p != NULL,
3172 "EplObdGetObjectDataPtrIntern(): pointer to SubEntry not valid!\n");
3173
3174 // there are are some objects whose data pointer has to get from other structure
3175 // get access type for this object
3176 Access = pSubindexEntry_p->m_Access;
3177
3178 // If object has access type = const,
3179 // for data only exists default values.
3180 if ((Access & kEplObdAccConst) != 0) {
3181 // The pointer to defualt value can be received from ObdGetObjectDefaultPtr()
3182 pData = ((void *)EplObdGetObjectDefaultPtr(pSubindexEntry_p));
3183 } else {
3184 // The pointer to current value can be received from ObdGetObjectCurrentPtr()
3185 pData = ((void *)EplObdGetObjectCurrentPtr(pSubindexEntry_p));
3186 }
3187
3188 return pData;
3189
3190 }
3191 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
3192 // EOF
x86 "subsystem" repository