drivers/staging/epl/EplObd.h

   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:  include 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.h,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.5 $  $Date: 2008/04/17 21:36: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
  69 ****************************************************************************/
  70
  71 #include "EplInc.h"
  72
  73 #ifndef _EPLOBD_H_
  74 #define _EPLOBD_H_
  75
  76 // ============================================================================
  77 // defines
  78 // ============================================================================
  79
  80 #define EPL_OBD_TABLE_INDEX_END     0xFFFF
  81
  82 // for the usage of BOOLEAN in OD
  83 #define OBD_TRUE    0x01
  84 #define OBD_FALSE   0x00
  85
  86 // default OD index for Node id
  87 #define EPL_OBD_NODE_ID_INDEX               0x1F93
  88 // default subindex for NodeId in OD
  89 #define EPL_OBD_NODE_ID_SUBINDEX            0x01
  90 // default subindex for NodeIDByHW_BOOL
  91 #define EPL_OBD_NODE_ID_HWBOOL_SUBINDEX     0x02
  92
  93 // ============================================================================
  94 // enums
  95 // ============================================================================
  96
  97 // directions for access to object dictionary
  98 typedef enum {
  99         kEplObdDirInit = 0x00,  // initialising after power on
 100         kEplObdDirStore = 0x01, // store all object values to non volatile memory
 101         kEplObdDirLoad = 0x02,  // load all object values from non volatile memory
 102         kEplObdDirRestore = 0x03,       // deletes non volatile memory (restore)
 103         kEplObdDirOBKCheck = 0xFF       // reserved
 104 } tEplObdDir;
 105
 106 // commands for store
 107 typedef enum {
 108         kEplObdCommNothing = 0x00,
 109         kEplObdCommOpenWrite = 0x01,
 110         kEplObdCommWriteObj = 0x02,
 111         kEplObdCommCloseWrite = 0x03,
 112         kEplObdCommOpenRead = 0x04,
 113         kEplObdCommReadObj = 0x05,
 114         kEplObdCommCloseRead = 0x06,
 115         kEplObdCommClear = 0x07,
 116         kEplObdCommUnknown = 0xFF
 117 } tEplObdCommand;
 118
 119 //-----------------------------------------------------------------------------------------------------------
 120 // events of object callback function
 121 typedef enum {
 122 //                                                                                                      m_pArg points to
 123 //                                                                                                    ---------------------
 124         kEplObdEvCheckExist = 0x06,     // checking if object does exist (reading and writing)    NULL
 125         kEplObdEvPreRead = 0x00,        // before reading an object                               source data buffer in OD
 126         kEplObdEvPostRead = 0x01,       // after reading an object                                destination data buffer from caller
 127         kEplObdEvWrStringDomain = 0x07, // event for changing string/domain data pointer or size  struct tEplObdVStringDomain in RAM
 128         kEplObdEvInitWrite = 0x04,      // initializes writing an object (checking object size)   size of object in OD (tEplObdSize)
 129         kEplObdEvPreWrite = 0x02,       // before writing an object                               source data buffer from caller
 130         kEplObdEvPostWrite = 0x03,      // after writing an object                                destination data buffer in OD
 131 //    kEplObdEvAbortSdo              = 0x05     // after an abort of an SDO transfer
 132
 133 } tEplObdEvent;
 134
 135 // part of OD (bit oriented)
 136 typedef unsigned int tEplObdPart;
 137
 138 #define kEplObdPartNo          0x00     // nothing
 139 #define kEplObdPartGen         0x01     //  part      (0x1000 - 0x1FFF)
 140 #define kEplObdPartMan         0x02     // manufacturer part (0x2000 - 0x5FFF)
 141 #define kEplObdPartDev         0x04     // device part       (0x6000 - 0x9FFF)
 142 #define kEplObdPartUsr         0x08     // dynamic part e.g. for ICE61131-3
 143
 144 // combinations
 145 #define kEplObdPartApp         (              kEplObdPartMan | kEplObdPartDev | kEplObdPartUsr) // manufacturer and device part (0x2000 - 0x9FFF) and user OD
 146 #define kEplObdPartAll         (kEplObdPartGen | kEplObdPartMan | kEplObdPartDev | kEplObdPartUsr)      // whole OD
 147
 148 //-----------------------------------------------------------------------------------------------------------
 149 // access types for objects
 150 // must be a difine because bit-flags
 151 typedef unsigned int tEplObdAccess;
 152
 153 #define kEplObdAccRead         0x01     // object can be read
 154 #define kEplObdAccWrite        0x02     // object can be written
 155 #define kEplObdAccConst        0x04     // object contains a constant value
 156 #define kEplObdAccPdo          0x08     // object can be mapped in a PDO
 157 #define kEplObdAccArray        0x10     // object contains an array of numerical values
 158 #define kEplObdAccRange        0x20     // object contains lower and upper limit
 159 #define kEplObdAccVar          0x40     // object data is placed in application
 160 #define kEplObdAccStore        0x80     // object data can be stored to non volatile memory
 161
 162 // combinations (not all combinations are required)
 163 #define kEplObdAccR            (0            | 0          | 0            | 0          | 0            | 0            | kEplObdAccRead)
 164 #define kEplObdAccW            (0            | 0          | 0            | 0          | 0            | kEplObdAccWrite | 0          )
 165 #define kEplObdAccRW           (0            | 0          | 0            | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 166 #define kEplObdAccCR           (0            | 0          | 0            | 0          | kEplObdAccConst | 0            | kEplObdAccRead)
 167 #define kEplObdAccGR           (0            | 0          | kEplObdAccRange | 0          | 0            | 0            | kEplObdAccRead)
 168 #define kEplObdAccGW           (0            | 0          | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | 0          )
 169 #define kEplObdAccGRW          (0            | 0          | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 170 #define kEplObdAccVR           (0            | kEplObdAccVar | 0            | 0          | 0            | 0            | kEplObdAccRead)
 171 #define kEplObdAccVW           (0            | kEplObdAccVar | 0            | 0          | 0            | kEplObdAccWrite | 0          )
 172 #define kEplObdAccVRW          (0            | kEplObdAccVar | 0            | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 173 #define kEplObdAccVPR          (0            | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | 0            | kEplObdAccRead)
 174 #define kEplObdAccVPW          (0            | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | kEplObdAccWrite | 0          )
 175 #define kEplObdAccVPRW         (0            | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | kEplObdAccWrite | kEplObdAccRead)
 176 #define kEplObdAccVGR          (0            | kEplObdAccVar | kEplObdAccRange | 0          | 0            | 0            | kEplObdAccRead)
 177 #define kEplObdAccVGW          (0            | kEplObdAccVar | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | 0          )
 178 #define kEplObdAccVGRW         (0            | kEplObdAccVar | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 179 #define kEplObdAccVGPR         (0            | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | 0            | kEplObdAccRead)
 180 #define kEplObdAccVGPW         (0            | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | kEplObdAccWrite | 0          )
 181 #define kEplObdAccVGPRW        (0            | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | kEplObdAccWrite | kEplObdAccRead)
 182 #define kEplObdAccSR           (kEplObdAccStore | 0          | 0            | 0          | 0            | 0            | kEplObdAccRead)
 183 #define kEplObdAccSW           (kEplObdAccStore | 0          | 0            | 0          | 0            | kEplObdAccWrite | 0          )
 184 #define kEplObdAccSRW          (kEplObdAccStore | 0          | 0            | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 185 #define kEplObdAccSCR          (kEplObdAccStore | 0          | 0            | 0          | kEplObdAccConst | 0            | kEplObdAccRead)
 186 #define kEplObdAccSGR          (kEplObdAccStore | 0          | kEplObdAccRange | 0          | 0            | 0            | kEplObdAccRead)
 187 #define kEplObdAccSGW          (kEplObdAccStore | 0          | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | 0          )
 188 #define kEplObdAccSGRW         (kEplObdAccStore | 0          | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 189 #define kEplObdAccSVR          (kEplObdAccStore | kEplObdAccVar | 0            | 0          | 0            | 0            | kEplObdAccRead)
 190 #define kEplObdAccSVW          (kEplObdAccStore | kEplObdAccVar | 0            | 0          | 0            | kEplObdAccWrite | 0          )
 191 #define kEplObdAccSVRW         (kEplObdAccStore | kEplObdAccVar | 0            | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 192 #define kEplObdAccSVPR         (kEplObdAccStore | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | 0            | kEplObdAccRead)
 193 #define kEplObdAccSVPW         (kEplObdAccStore | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | kEplObdAccWrite | 0          )
 194 #define kEplObdAccSVPRW        (kEplObdAccStore | kEplObdAccVar | 0            | kEplObdAccPdo | 0            | kEplObdAccWrite | kEplObdAccRead)
 195 #define kEplObdAccSVGR         (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | 0          | 0            | 0            | kEplObdAccRead)
 196 #define kEplObdAccSVGW         (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | 0          )
 197 #define kEplObdAccSVGRW        (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | 0          | 0            | kEplObdAccWrite | kEplObdAccRead)
 198 #define kEplObdAccSVGPR        (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | 0            | kEplObdAccRead)
 199 #define kEplObdAccSVGPW        (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | kEplObdAccWrite | 0          )
 200 #define kEplObdAccSVGPRW       (kEplObdAccStore | kEplObdAccVar | kEplObdAccRange | kEplObdAccPdo | 0            | kEplObdAccWrite | kEplObdAccRead)
 201
 202 typedef unsigned int tEplObdSize;       // For all objects as objects size are used an unsigned int.
 203
 204 // -------------------------------------------------------------------------
 205 // types for data types defined in DS301
 206 // -------------------------------------------------------------------------
 207
 208 // types of objects in object dictionary
 209 // DS-301 defines these types as WORD
 210 typedef enum {
 211 // types which are always supported
 212         kEplObdTypBool = 0x0001,
 213
 214         kEplObdTypInt8 = 0x0002,
 215         kEplObdTypInt16 = 0x0003,
 216         kEplObdTypInt32 = 0x0004,
 217         kEplObdTypUInt8 = 0x0005,
 218         kEplObdTypUInt16 = 0x0006,
 219         kEplObdTypUInt32 = 0x0007,
 220         kEplObdTypReal32 = 0x0008,
 221         kEplObdTypVString = 0x0009,
 222         kEplObdTypOString = 0x000A,
 223         kEplObdTypDomain = 0x000F,
 224
 225         kEplObdTypInt24 = 0x0010,
 226         kEplObdTypUInt24 = 0x0016,
 227
 228         kEplObdTypReal64 = 0x0011,
 229         kEplObdTypInt40 = 0x0012,
 230         kEplObdTypInt48 = 0x0013,
 231         kEplObdTypInt56 = 0x0014,
 232         kEplObdTypInt64 = 0x0015,
 233         kEplObdTypUInt40 = 0x0018,
 234         kEplObdTypUInt48 = 0x0019,
 235         kEplObdTypUInt56 = 0x001A,
 236         kEplObdTypUInt64 = 0x001B,
 237         kEplObdTypTimeOfDay = 0x000C,
 238         kEplObdTypTimeDiff = 0x000D
 239 } tEplObdType;
 240 // other types are not supported in this version
 241
 242 // -------------------------------------------------------------------------
 243 // types for data types defined in DS301
 244 // -------------------------------------------------------------------------
 245
 246 typedef unsigned char tEplObdBoolean;   // 0001
 247 typedef signed char tEplObdInteger8;    // 0002
 248 typedef signed short int tEplObdInteger16;      // 0003
 249 typedef signed long tEplObdInteger32;   // 0004
 250 typedef unsigned char tEplObdUnsigned8; // 0005
 251 typedef unsigned short int tEplObdUnsigned16;   // 0006
 252 typedef unsigned long tEplObdUnsigned32;        // 0007
 253 typedef float tEplObdReal32;    // 0008
 254 typedef unsigned char tEplObdDomain;    // 000F
 255 typedef signed long tEplObdInteger24;   // 0010
 256 typedef unsigned long tEplObdUnsigned24;        // 0016
 257
 258 typedef signed QWORD tEplObdInteger40;  // 0012
 259 typedef signed QWORD tEplObdInteger48;  // 0013
 260 typedef signed QWORD tEplObdInteger56;  // 0014
 261 typedef signed QWORD tEplObdInteger64;  // 0015
 262
 263 typedef unsigned QWORD tEplObdUnsigned40;       // 0018
 264 typedef unsigned QWORD tEplObdUnsigned48;       // 0019
 265 typedef unsigned QWORD tEplObdUnsigned56;       // 001A
 266 typedef unsigned QWORD tEplObdUnsigned64;       // 001B
 267
 268 typedef double tEplObdReal64;   // 0011
 269
 270 typedef tTimeOfDay tEplObdTimeOfDay;    // 000C
 271 typedef tTimeOfDay tEplObdTimeDifference;       // 000D
 272
 273 // -------------------------------------------------------------------------
 274 // structur for defining a variable
 275 // -------------------------------------------------------------------------
 276 // -------------------------------------------------------------------------
 277 typedef enum {
 278         kVarValidSize = 0x01,
 279         kVarValidData = 0x02,
 280 //    kVarValidCallback       = 0x04,
 281 //    kVarValidArg            = 0x08,
 282
 283         kVarValidAll = 0x03     // currently only size and data are implemented and used
 284 } tEplVarParamValid;
 285
 286 typedef tEplKernel(*tEplVarCallback) (CCM_DECL_INSTANCE_HDL_ void *pParam_p);
 287
 288 typedef struct {
 289         tEplVarParamValid m_ValidFlag;
 290         unsigned int m_uiIndex;
 291         unsigned int m_uiSubindex;
 292         tEplObdSize m_Size;
 293         void MEM *m_pData;
 294 //    tEplVarCallback     m_fpCallback;
 295 //    void *       m_pArg;
 296
 297 } tEplVarParam;
 298
 299 typedef struct {
 300         void MEM *m_pData;
 301         tEplObdSize m_Size;
 302 /*
 303     #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
 304         tEplVarCallback    m_fpCallback;
 305         void *   m_pArg;
 306     #endif
 307 */
 308 } tEplObdVarEntry;
 309
 310 typedef struct {
 311         tEplObdSize m_Size;
 312         BYTE *m_pString;
 313
 314 } tEplObdOString;               // 000C
 315
 316 typedef struct {
 317         tEplObdSize m_Size;
 318         char *m_pString;
 319 } tEplObdVString;               // 000D
 320
 321 typedef struct {
 322         tEplObdSize m_Size;
 323         char *m_pDefString;     // $$$ d.k. it is unused, so we could delete it
 324         char *m_pString;
 325
 326 } tEplObdVStringDef;
 327
 328 typedef struct {
 329         tEplObdSize m_Size;
 330         BYTE *m_pDefString;     // $$$ d.k. it is unused, so we could delete it
 331         BYTE *m_pString;
 332
 333 } tEplObdOStringDef;
 334
 335 //r.d. parameter struct for changing object size and/or pointer to data of Strings or Domains
 336 typedef struct {
 337         tEplObdSize m_DownloadSize;     // download size from SDO or APP
 338         tEplObdSize m_ObjSize;  // current object size from OD - should be changed from callback function
 339         void *m_pData;          // current object ptr  from OD - should be changed from callback function
 340
 341 } tEplObdVStringDomain;         // 000D
 342
 343 // ============================================================================
 344 // types
 345 // ============================================================================
 346 // -------------------------------------------------------------------------
 347 // subindexstruct
 348 // -------------------------------------------------------------------------
 349
 350 // Change not the order for this struct!!!
 351 typedef struct {
 352         unsigned int m_uiSubIndex;
 353         tEplObdType m_Type;
 354         tEplObdAccess m_Access;
 355         void *m_pDefault;
 356         void MEM *m_pCurrent;   // points always to RAM
 357
 358 } tEplObdSubEntry;
 359
 360 // r.d.: has always to be  because new OBD-Macros for arrays
 361 typedef tEplObdSubEntry *tEplObdSubEntryPtr;
 362
 363 // -------------------------------------------------------------------------
 364 // callback function for objdictionary modul
 365 // -------------------------------------------------------------------------
 366
 367 // parameters for callback function
 368 typedef struct {
 369         tEplObdEvent m_ObdEvent;
 370         unsigned int m_uiIndex;
 371         unsigned int m_uiSubIndex;
 372         void *m_pArg;
 373         DWORD m_dwAbortCode;
 374
 375 } tEplObdCbParam;
 376
 377 // define type for callback function: pParam_p points to tEplObdCbParam
 378 typedef tEplKernel(*tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbParam MEM * pParam_p);
 379
 380 // do not change the order for this struct!!!
 381
 382 typedef struct {
 383         unsigned int m_uiIndex;
 384         tEplObdSubEntryPtr m_pSubIndex;
 385         unsigned int m_uiCount;
 386         tEplObdCallback m_fpCallback;   // function is called back if object access
 387
 388 } tEplObdEntry;
 389
 390 // allways  pointer
 391 typedef tEplObdEntry *tEplObdEntryPtr;
 392
 393 // -------------------------------------------------------------------------
 394 // structur to initialize OBD module
 395 // -------------------------------------------------------------------------
 396
 397 typedef struct {
 398         tEplObdEntryPtr m_pPart;
 399         tEplObdEntryPtr m_pManufacturerPart;
 400         tEplObdEntryPtr m_pDevicePart;
 401
 402 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
 403
 404         tEplObdEntryPtr m_pUserPart;
 405
 406 #endif
 407
 408 } tEplObdInitParam;
 409
 410 // -------------------------------------------------------------------------
 411 // structur for parameters of STORE RESTORE command
 412 // -------------------------------------------------------------------------
 413
 414 typedef struct {
 415         tEplObdCommand m_bCommand;
 416         tEplObdPart m_bCurrentOdPart;
 417         void MEM *m_pData;
 418         tEplObdSize m_ObjSize;
 419
 420 } tEplObdCbStoreParam;
 421
 422 typedef tEplKernel(*tInitTabEntryCallback) (void MEM * pTabEntry_p,
 423                                                 unsigned int uiObjIndex_p);
 424
 425 typedef tEplKernel(*tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbStoreParam MEM *pCbStoreParam_p);
 426
 427 // -------------------------------------------------------------------------
 428 // this stucture is used for parameters for function ObdInitModuleTab()
 429 // -------------------------------------------------------------------------
 430 typedef struct {
 431         unsigned int m_uiLowerObjIndex; // lower limit of ObjIndex
 432         unsigned int m_uiUpperObjIndex; // upper limit of ObjIndex
 433         tInitTabEntryCallback m_fpInitTabEntry; // will be called if ObjIndex was found
 434         void MEM *m_pTabBase;   // base address of table
 435         unsigned int m_uiEntrySize;     // size of table entry      // 25-feb-2005 r.d.: expansion from BYTE to WORD necessary for PDO bit mapping
 436         unsigned int m_uiMaxEntries;    // max. tabel entries
 437
 438 } tEplObdModulTabParam;
 439
 440 //-------------------------------------------------------------------
 441 //  enum for function EplObdSetNodeId
 442 //-------------------------------------------------------------------
 443 typedef enum {
 444         kEplObdNodeIdUnknown = 0x00,    // unknown how the node id was set
 445         kEplObdNodeIdSoftware = 0x01,   // node id set by software
 446         kEplObdNodeIdHardware = 0x02    // node id set by hardware
 447 } tEplObdNodeIdType;
 448
 449 // ============================================================================
 450 // global variables
 451 // ============================================================================
 452
 453 // ============================================================================
 454 // public functions
 455 // ============================================================================
 456
 457 #endif // #ifndef _EPLOBD_H_