[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / epl / EplInstDef.h

/****************************************************************************

  (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
      www.systec-electronic.com

  Project:      openPOWERLINK

  Description:  definitions for generating instances

  License:

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

    3. Neither the name of SYSTEC electronic GmbH nor the names of its
       contributors may be used to endorse or promote products derived
       from this software without prior written permission. For written
       permission, please contact info@systec-electronic.com.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

    Severability Clause:

        If a provision of this License is or becomes illegal, invalid or
        unenforceable in any jurisdiction, that shall not affect:
        1. the validity or enforceability in that jurisdiction of any other
           provision of this License; or
        2. the validity or enforceability in other jurisdictions of that or
           any other provision of this License.

  -------------------------------------------------------------------------

                $RCSfile: EplInstDef.h,v $

                $Author: D.Krueger $

                $Revision: 1.4 $  $Date: 2008/04/17 21:36:32 $

                $State: Exp $

                Build Environment:
                    ...

  -------------------------------------------------------------------------

  Revision History:

  r.d.: first implementation

****************************************************************************/

#ifndef _EPLINSTDEF_H_
#define _EPLINSTDEF_H_

// =========================================================================
// types and macros for generating instances
// =========================================================================

typedef enum {
	kStateUnused = 0,
	kStateDeleted = 1,
	kStateUsed = 0xFF
} tInstState;

//------------------------------------------------------------------------------------------

typedef void MEM *tEplPtrInstance;
typedef BYTE tEplInstanceHdl;

// define const for illegale values
#define CCM_ILLINSTANCE      NULL
#define CCM_ILLINSTANCE_HDL  0xFF

//------------------------------------------------------------------------------------------
// if more than one instance then use this macros
#if (EPL_MAX_INSTANCES > 1)

    //--------------------------------------------------------------------------------------
    // macro definition for instance table definition
    //--------------------------------------------------------------------------------------

    // memory attributes for instance table
#define INST_NEAR		// faster access to variables
#define INST_FAR		// variables wich have to located in xdata
#define STATIC			// prevent warnings for variables with same name

#define INSTANCE_TYPE_BEGIN     typedef struct {
#define INSTANCE_TYPE_END       } tEplInstanceInfo;

    //--------------------------------------------------------------------------------------
    // macro definition for API interface
    //--------------------------------------------------------------------------------------

    // declaration:

    // macros for declaration within function header or prototype of API functions
#define CCM_DECL_INSTANCE_HDL                   tEplInstanceHdl InstanceHandle
#define CCM_DECL_INSTANCE_HDL_                  tEplInstanceHdl InstanceHandle,

    // macros for declaration of pointer to instance handle within function header or prototype of API functions
#define CCM_DECL_PTR_INSTANCE_HDL               tEplInstanceHdl MEM* pInstanceHandle
#define CCM_DECL_PTR_INSTANCE_HDL_              tEplInstanceHdl MEM* pInstanceHandle,

    // macros for declaration instance as lokacl variable within functions
#define CCM_DECL_INSTANCE_PTR_LOCAL             tCcmInstanceInfo MEM* pInstance;
#define CCM_DECL_PTR_INSTANCE_HDL_LOCAL         tEplInstanceHdl  MEM* pInstanceHandle;

    // reference:

    // macros for reference of instance handle for function parameters
#define CCM_INSTANCE_HDL                        InstanceHandle
#define CCM_INSTANCE_HDL_                       InstanceHandle,

    // macros for reference of instance parameter for function parameters
#define CCM_INSTANCE_PARAM(par)                 par
#define CCM_INSTANCE_PARAM_(par)                par,

    // macros for reference of instance parameter for writing or reading values
#define CCM_INST_ENTRY                          (*((tEplPtrInstance)pInstance))

    // processing:

    // macros for process instance handle
#define CCM_CHECK_INSTANCE_HDL()                if (InstanceHandle >= EPL_MAX_INSTANCES) \
                                                        {return (kEplIllegalInstance);}

    // macros for process pointer to instance handle
#define CCM_CHECK_PTR_INSTANCE_HDL()            if (pInstanceHandle == NULL) \
                                                        {return (kEplInvalidInstanceParam);}

    // This macro returned the handle and pointer to next free instance.
#define CCM_GET_FREE_INSTANCE_AND_HDL()         pInstance = CcmGetFreeInstanceAndHandle (pInstanceHandle); \
                                                    ASSERT (*pInstanceHandle != CCM_ILLINSTANCE_HDL);

#define CCM_CHECK_INSTANCE_PTR()                if (pInstance == CCM_ILLINSTANCE) \
                                                        {return (kEplNoFreeInstance);}

#define CCM_GET_INSTANCE_PTR()                  pInstance = CcmGetInstancePtr (InstanceHandle);
#define CCM_GET_FREE_INSTANCE_PTR()             pInstance = GetFreeInstance (); \
                                                    ASSERT (pInstance != CCM_ILLINSTANCE);

    //--------------------------------------------------------------------------------------
    // macro definition for stack interface
    //--------------------------------------------------------------------------------------

    // macros for declaration within the function header, prototype or local var list
    // Declaration of pointers within function paramater list must defined as void MEM*
    // pointer.
#define EPL_MCO_DECL_INSTANCE_PTR                   void MEM* pInstance
#define EPL_MCO_DECL_INSTANCE_PTR_                  void MEM* pInstance,
#define EPL_MCO_DECL_INSTANCE_PTR_LOCAL             tEplPtrInstance  pInstance;

    // macros for reference of pointer to instance
    // These macros are used for parameter passing to called function.
#define EPL_MCO_INSTANCE_PTR                        pInstance
#define EPL_MCO_INSTANCE_PTR_                       pInstance,
#define EPL_MCO_ADDR_INSTANCE_PTR_                  &pInstance,

    // macro for access of struct members of one instance
    // An access to a member of instance table must be casted by the local
    // defined type of instance table.
#define EPL_MCO_INST_ENTRY                          (*(tEplPtrInstance)pInstance)
#define EPL_MCO_GLB_VAR(var)                        (((tEplPtrInstance)pInstance)->var)

    // macros for process pointer to instance
#define EPL_MCO_GET_INSTANCE_PTR()                  pInstance = (tEplPtrInstance) GetInstancePtr (InstanceHandle);
#define EPL_MCO_GET_FREE_INSTANCE_PTR()             pInstance = (tEplPtrInstance) GetFreeInstance (); \
                                                    ASSERT (pInstance != CCM_ILLINSTANCE);

    // This macro should be used to check the passed pointer to an public function
#define EPL_MCO_CHECK_INSTANCE_STATE()              ASSERT (pInstance != NULL); \
                                                    ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed);

    // macros for declaration of pointer to instance pointer
#define EPL_MCO_DECL_PTR_INSTANCE_PTR               void MEM*  MEM* pInstancePtr
#define EPL_MCO_DECL_PTR_INSTANCE_PTR_              void MEM*  MEM* pInstancePtr,

    // macros for reference of pointer to instance pointer
    // These macros are used for parameter passing to called function.
#define EPL_MCO_PTR_INSTANCE_PTR                    pInstancePtr
#define EPL_MCO_PTR_INSTANCE_PTR_                   pInstancePtr,

    // macros for process pointer to instance pointer
#define EPL_MCO_CHECK_PTR_INSTANCE_PTR()            ASSERT (pInstancePtr != NULL);
#define EPL_MCO_SET_PTR_INSTANCE_PTR()              (*pInstancePtr = pInstance);

#define EPL_MCO_INSTANCE_PARAM(a)                   (a)
#define EPL_MCO_INSTANCE_PARAM_(a)                  (a),
#define EPL_MCO_INSTANCE_PARAM_IDX_()               EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex))
#define EPL_MCO_INSTANCE_PARAM_IDX()                EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex))
#define EPL_MCO_WRITE_INSTANCE_STATE(a)             EPL_MCO_GLB_VAR (m_InstState) = a;

    // this macro deletes all instance entries as unused
#define EPL_MCO_DELETE_INSTANCE_TABLE()                                    \
    {                                                                      \
        tEplInstanceInfo MEM*   pInstance       = &aEplInstanceTable_g[0]; \
        tFastByte               InstNumber      = 0;                       \
        tFastByte               i               = EPL_MAX_INSTANCES;       \
        do {                                                               \
            pInstance->m_InstState = (BYTE) kStateUnused;                  \
            pInstance->m_bInstIndex = (BYTE) InstNumber;                   \
            pInstance++; InstNumber++; i--;                                \
        } while (i != 0);                                                  \
    }

    // definition of functions which has to be defined in each module of CANopen stack
#define EPL_MCO_DEFINE_INSTANCE_FCT() \
        static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p);  \
        static tEplPtrInstance GetFreeInstance (void);
#define EPL_MCO_DECL_INSTANCE_FCT()                                            \
        static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \
            return &aEplInstanceTable_g[InstHandle_p]; }                       \
        static tEplPtrInstance GetFreeInstance (void) {                        \
            tEplInstanceInfo MEM*   pInstance   = &aEplInstanceTable_g[0];     \
            tFastByte               i           = EPL_MAX_INSTANCES;           \
            do { if (pInstance->m_InstState != kStateUsed) {                   \
                    return (tEplPtrInstance) pInstance; }                      \
                pInstance++; i--; }                                            \
            while (i != 0);                                                    \
            return CCM_ILLINSTANCE; }

    // this macro defines the instance table. Each entry is reserved for an instance of CANopen.
#define EPL_MCO_DECL_INSTANCE_VAR() \
        static tEplInstanceInfo MEM aEplInstanceTable_g [EPL_MAX_INSTANCES];

    // this macro defines member variables in instance table which are needed in
    // all modules of Epl stack
#define EPL_MCO_DECL_INSTANCE_MEMBER() \
        STATIC  BYTE                            m_InstState; \
        STATIC  BYTE                            m_bInstIndex;

#define EPL_MCO_INSTANCE_PARAM_IDX_()           EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex))
#define EPL_MCO_INSTANCE_PARAM_IDX()            EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex))

#else // only one instance is used

    // Memory attributes for instance table.
#define INST_NEAR   NEAR	// faster access to variables
#define INST_FAR    MEM		// variables wich have to located in xdata
#define STATIC      static	// prevent warnings for variables with same name

#define INSTANCE_TYPE_BEGIN
#define INSTANCE_TYPE_END

// macros for declaration, initializing and member access for instance handle
// This class of macros are used by API function to inform CCM-modul which
// instance is to be used.

    // macros for reference of instance handle
    // These macros are used for parameter passing to CANopen API function.
#define CCM_INSTANCE_HDL
#define CCM_INSTANCE_HDL_

#define CCM_DECL_INSTANCE_PTR_LOCAL

    // macros for declaration within the function header or prototype
#define CCM_DECL_INSTANCE_HDL                   void
#define CCM_DECL_INSTANCE_HDL_

    // macros for process instance handle
#define CCM_CHECK_INSTANCE_HDL()

    // macros for declaration of pointer to instance handle
#define CCM_DECL_PTR_INSTANCE_HDL               void
#define CCM_DECL_PTR_INSTANCE_HDL_

    // macros for process pointer to instance handle
#define CCM_CHECK_PTR_INSTANCE_HDL()

    // This macro returned the handle and pointer to next free instance.
#define CCM_GET_FREE_INSTANCE_AND_HDL()

#define CCM_CHECK_INSTANCE_PTR()

#define CCM_GET_INSTANCE_PTR()
#define CCM_GET_FREE_INSTANCE_PTR()

#define CCM_INSTANCE_PARAM(par)
#define CCM_INSTANCE_PARAM_(par)

#define CCM_INST_ENTRY                          aCcmInstanceTable_g[0]

// macros for declaration, initializing and member access for instance pointer
// This class of macros are used by CANopen internal function to point to one instance.

    // macros for declaration within the function header, prototype or local var list
#define EPL_MCO_DECL_INSTANCE_PTR                   void
#define EPL_MCO_DECL_INSTANCE_PTR_
#define EPL_MCO_DECL_INSTANCE_PTR_LOCAL

    // macros for reference of pointer to instance
    // These macros are used for parameter passing to called function.
#define EPL_MCO_INSTANCE_PTR
#define EPL_MCO_INSTANCE_PTR_
#define EPL_MCO_ADDR_INSTANCE_PTR_

    // macros for process pointer to instance
#define EPL_MCO_GET_INSTANCE_PTR()
#define EPL_MCO_GET_FREE_INSTANCE_PTR()

    // This macro should be used to check the passed pointer to an public function
#define EPL_MCO_CHECK_INSTANCE_STATE()

    // macros for declaration of pointer to instance pointer
#define EPL_MCO_DECL_PTR_INSTANCE_PTR               void
#define EPL_MCO_DECL_PTR_INSTANCE_PTR_

    // macros for reference of pointer to instance pointer
    // These macros are used for parameter passing to called function.
#define EPL_MCO_PTR_INSTANCE_PTR
#define EPL_MCO_PTR_INSTANCE_PTR_

    // macros for process pointer to instance pointer
#define EPL_MCO_CHECK_PTR_INSTANCE_PTR()
#define EPL_MCO_SET_PTR_INSTANCE_PTR()

#define EPL_MCO_INSTANCE_PARAM(a)
#define EPL_MCO_INSTANCE_PARAM_(a)
#define EPL_MCO_INSTANCE_PARAM_IDX_()
#define EPL_MCO_INSTANCE_PARAM_IDX()

    // macro for access of struct members of one instance
#define EPL_MCO_INST_ENTRY                          aEplInstanceTable_g[0]
#define EPL_MCO_GLB_VAR(var)                        (var)
#define EPL_MCO_WRITE_INSTANCE_STATE(a)

    // this macro deletes all instance entries as unused
#define EPL_MCO_DELETE_INSTANCE_TABLE()

    // definition of functions which has to be defined in each module of CANopen stack
#define EPL_MCO_DEFINE_INSTANCE_FCT()
#define EPL_MCO_DECL_INSTANCE_FCT()

    // this macro defines the instance table. Each entry is reserved for an instance of CANopen.
#define EPL_MCO_DECL_INSTANCE_VAR()

    // this macro defines member variables in instance table which are needed in
    // all modules of CANopen stack
#define EPL_MCO_DECL_INSTANCE_MEMBER()

#endif

/*
#if (CDRV_MAX_INSTANCES > 1)

    #define CDRV_REENTRANT                          REENTRANT

#else

    #define CDRV_REENTRANT

#endif
*/

#endif // _EPLINSTDEF_H_
Commit	Line	Data
9d7164cf DK	1	/****************************************************************************
	2
	3	(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
	4	www.systec-electronic.com
	5
	6	Project: openPOWERLINK
	7
	8	Description: definitions for generating instances
	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: EplInstDef.h,v $
	53
	54	$Author: D.Krueger $
	55
	56	$Revision: 1.4 $ $Date: 2008/04/17 21:36:32 $
	57
	58	$State: Exp $
	59
	60	Build Environment:
	61	...
	62
	63	-------------------------------------------------------------------------
	64
65	Revision History:
66
67	r.d.: first implementation
68
69	****************************************************************************/
70
71	#ifndef _EPLINSTDEF_H_
72	#define _EPLINSTDEF_H_
73
9d7164cf DK	74	// =========================================================================
	75	// types and macros for generating instances
	76	// =========================================================================
	77
e0ca0595 GKH	78	typedef enum {
	79	kStateUnused = 0,
	80	kStateDeleted = 1,
	81	kStateUsed = 0xFF
9d7164cf DK	82	} tInstState;
	83
	84	//------------------------------------------------------------------------------------------
	85
e0ca0595 GKH	86	typedef void MEM *tEplPtrInstance;
e0ca0595 GKH	87	typedef BYTE tEplInstanceHdl;
9d7164cf DK	88
	89	// define const for illegale values
	90	#define CCM_ILLINSTANCE NULL
	91	#define CCM_ILLINSTANCE_HDL 0xFF
	92
	93	//------------------------------------------------------------------------------------------
	94	// if more than one instance then use this macros
	95	#if (EPL_MAX_INSTANCES > 1)
	96
	97	//--------------------------------------------------------------------------------------
	98	// macro definition for instance table definition
	99	//--------------------------------------------------------------------------------------
	100
	101	// memory attributes for instance table
e0ca0595 GKH	102	#define INST_NEAR // faster access to variables
	103	#define INST_FAR // variables wich have to located in xdata
	104	#define STATIC // prevent warnings for variables with same name
9d7164cf	105
e0ca0595 GKH	106	#define INSTANCE_TYPE_BEGIN typedef struct {
e0ca0595 GKH	107	#define INSTANCE_TYPE_END } tEplInstanceInfo;
9d7164cf DK	108
	109	//--------------------------------------------------------------------------------------
	110	// macro definition for API interface
	111	//--------------------------------------------------------------------------------------
	112
	113	// declaration:
	114
	115	// macros for declaration within function header or prototype of API functions
e0ca0595 GKH	116	#define CCM_DECL_INSTANCE_HDL tEplInstanceHdl InstanceHandle
e0ca0595 GKH	117	#define CCM_DECL_INSTANCE_HDL_ tEplInstanceHdl InstanceHandle,
9d7164cf DK	118
9d7164cf DK	119	// macros for declaration of pointer to instance handle within function header or prototype of API functions
e0ca0595 GKH	120	#define CCM_DECL_PTR_INSTANCE_HDL tEplInstanceHdl MEM* pInstanceHandle
e0ca0595 GKH	121	#define CCM_DECL_PTR_INSTANCE_HDL_ tEplInstanceHdl MEM* pInstanceHandle,
9d7164cf DK	122
9d7164cf DK	123	// macros for declaration instance as lokacl variable within functions
e0ca0595 GKH	124	#define CCM_DECL_INSTANCE_PTR_LOCAL tCcmInstanceInfo MEM* pInstance;
e0ca0595 GKH	125	#define CCM_DECL_PTR_INSTANCE_HDL_LOCAL tEplInstanceHdl MEM* pInstanceHandle;
9d7164cf DK	126
	127	// reference:
	128
	129	// macros for reference of instance handle for function parameters
e0ca0595 GKH	130	#define CCM_INSTANCE_HDL InstanceHandle
e0ca0595 GKH	131	#define CCM_INSTANCE_HDL_ InstanceHandle,
9d7164cf DK	132
9d7164cf DK	133	// macros for reference of instance parameter for function parameters
e0ca0595 GKH	134	#define CCM_INSTANCE_PARAM(par) par
e0ca0595 GKH	135	#define CCM_INSTANCE_PARAM_(par) par,
9d7164cf DK	136
9d7164cf DK	137	// macros for reference of instance parameter for writing or reading values
e0ca0595	138	#define CCM_INST_ENTRY (*((tEplPtrInstance)pInstance))
9d7164cf DK	139
	140	// processing:
	141
	142	// macros for process instance handle
e0ca0595	143	#define CCM_CHECK_INSTANCE_HDL() if (InstanceHandle >= EPL_MAX_INSTANCES) \
9d7164cf DK	144	{return (kEplIllegalInstance);}
9d7164cf DK	145
9d7164cf	146	// macros for process pointer to instance handle
e0ca0595	147	#define CCM_CHECK_PTR_INSTANCE_HDL() if (pInstanceHandle == NULL) \
9d7164cf DK	148	{return (kEplInvalidInstanceParam);}
	149
	150	// This macro returned the handle and pointer to next free instance.
e0ca0595	151	#define CCM_GET_FREE_INSTANCE_AND_HDL() pInstance = CcmGetFreeInstanceAndHandle (pInstanceHandle); \
9d7164cf DK	152	ASSERT (*pInstanceHandle != CCM_ILLINSTANCE_HDL);
9d7164cf DK	153
e0ca0595	154	#define CCM_CHECK_INSTANCE_PTR() if (pInstance == CCM_ILLINSTANCE) \
9d7164cf DK	155	{return (kEplNoFreeInstance);}
9d7164cf DK	156
e0ca0595 GKH	157	#define CCM_GET_INSTANCE_PTR() pInstance = CcmGetInstancePtr (InstanceHandle);
e0ca0595 GKH	158	#define CCM_GET_FREE_INSTANCE_PTR() pInstance = GetFreeInstance (); \
9d7164cf DK	159	ASSERT (pInstance != CCM_ILLINSTANCE);
9d7164cf DK	160
9d7164cf DK	161	//--------------------------------------------------------------------------------------
	162	// macro definition for stack interface
	163	//--------------------------------------------------------------------------------------
	164
	165	// macros for declaration within the function header, prototype or local var list
	166	// Declaration of pointers within function paramater list must defined as void MEM*
	167	// pointer.
e0ca0595 GKH	168	#define EPL_MCO_DECL_INSTANCE_PTR void MEM* pInstance
	169	#define EPL_MCO_DECL_INSTANCE_PTR_ void MEM* pInstance,
	170	#define EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplPtrInstance pInstance;
9d7164cf DK	171
	172	// macros for reference of pointer to instance
	173	// These macros are used for parameter passing to called function.
e0ca0595 GKH	174	#define EPL_MCO_INSTANCE_PTR pInstance
	175	#define EPL_MCO_INSTANCE_PTR_ pInstance,
	176	#define EPL_MCO_ADDR_INSTANCE_PTR_ &pInstance,
9d7164cf DK	177
	178	// macro for access of struct members of one instance
	179	// An access to a member of instance table must be casted by the local
	180	// defined type of instance table.
e0ca0595 GKH	181	#define EPL_MCO_INST_ENTRY (*(tEplPtrInstance)pInstance)
e0ca0595 GKH	182	#define EPL_MCO_GLB_VAR(var) (((tEplPtrInstance)pInstance)->var)
9d7164cf DK	183
9d7164cf DK	184	// macros for process pointer to instance
e0ca0595 GKH	185	#define EPL_MCO_GET_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetInstancePtr (InstanceHandle);
e0ca0595 GKH	186	#define EPL_MCO_GET_FREE_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetFreeInstance (); \
9d7164cf DK	187	ASSERT (pInstance != CCM_ILLINSTANCE);
	188
	189	// This macro should be used to check the passed pointer to an public function
e0ca0595	190	#define EPL_MCO_CHECK_INSTANCE_STATE() ASSERT (pInstance != NULL); \
9d7164cf DK	191	ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed);
	192
	193	// macros for declaration of pointer to instance pointer
e0ca0595 GKH	194	#define EPL_MCO_DECL_PTR_INSTANCE_PTR void MEM* MEM* pInstancePtr
e0ca0595 GKH	195	#define EPL_MCO_DECL_PTR_INSTANCE_PTR_ void MEM* MEM* pInstancePtr,
9d7164cf DK	196
	197	// macros for reference of pointer to instance pointer
	198	// These macros are used for parameter passing to called function.
e0ca0595 GKH	199	#define EPL_MCO_PTR_INSTANCE_PTR pInstancePtr
e0ca0595 GKH	200	#define EPL_MCO_PTR_INSTANCE_PTR_ pInstancePtr,
9d7164cf DK	201
9d7164cf DK	202	// macros for process pointer to instance pointer
e0ca0595 GKH	203	#define EPL_MCO_CHECK_PTR_INSTANCE_PTR() ASSERT (pInstancePtr != NULL);
e0ca0595 GKH	204	#define EPL_MCO_SET_PTR_INSTANCE_PTR() (*pInstancePtr = pInstance);
9d7164cf	205
e0ca0595 GKH	206	#define EPL_MCO_INSTANCE_PARAM(a) (a)
	207	#define EPL_MCO_INSTANCE_PARAM_(a) (a),
	208	#define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex))
	209	#define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex))
	210	#define EPL_MCO_WRITE_INSTANCE_STATE(a) EPL_MCO_GLB_VAR (m_InstState) = a;
9d7164cf DK	211
9d7164cf DK	212	// this macro deletes all instance entries as unused
e0ca0595	213	#define EPL_MCO_DELETE_INSTANCE_TABLE() \
9d7164cf DK	214	{ \
	215	tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \
	216	tFastByte InstNumber = 0; \
	217	tFastByte i = EPL_MAX_INSTANCES; \
	218	do { \
	219	pInstance->m_InstState = (BYTE) kStateUnused; \
	220	pInstance->m_bInstIndex = (BYTE) InstNumber; \
	221	pInstance++; InstNumber++; i--; \
	222	} while (i != 0); \
	223	}
	224
	225	// definition of functions which has to be defined in each module of CANopen stack
e0ca0595	226	#define EPL_MCO_DEFINE_INSTANCE_FCT() \
9d7164cf DK	227	static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p); \
9d7164cf DK	228	static tEplPtrInstance GetFreeInstance (void);
e0ca0595	229	#define EPL_MCO_DECL_INSTANCE_FCT() \
9d7164cf DK	230	static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \
	231	return &aEplInstanceTable_g[InstHandle_p]; } \
	232	static tEplPtrInstance GetFreeInstance (void) { \
	233	tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \
	234	tFastByte i = EPL_MAX_INSTANCES; \
	235	do { if (pInstance->m_InstState != kStateUsed) { \
	236	return (tEplPtrInstance) pInstance; } \
	237	pInstance++; i--; } \
	238	while (i != 0); \
	239	return CCM_ILLINSTANCE; }
	240
	241	// this macro defines the instance table. Each entry is reserved for an instance of CANopen.
e0ca0595	242	#define EPL_MCO_DECL_INSTANCE_VAR() \
9d7164cf DK	243	static tEplInstanceInfo MEM aEplInstanceTable_g [EPL_MAX_INSTANCES];
	244
	245	// this macro defines member variables in instance table which are needed in
	246	// all modules of Epl stack
e0ca0595	247	#define EPL_MCO_DECL_INSTANCE_MEMBER() \
9d7164cf DK	248	STATIC BYTE m_InstState; \
	249	STATIC BYTE m_bInstIndex;
	250
e0ca0595 GKH	251	#define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex))
e0ca0595 GKH	252	#define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex))
9d7164cf	253
e0ca0595	254	#else // only one instance is used
9d7164cf DK	255
9d7164cf DK	256	// Memory attributes for instance table.
e0ca0595 GKH	257	#define INST_NEAR NEAR // faster access to variables
	258	#define INST_FAR MEM // variables wich have to located in xdata
	259	#define STATIC static // prevent warnings for variables with same name
9d7164cf	260
e0ca0595 GKH	261	#define INSTANCE_TYPE_BEGIN
e0ca0595 GKH	262	#define INSTANCE_TYPE_END
9d7164cf DK	263
	264	// macros for declaration, initializing and member access for instance handle
	265	// This class of macros are used by API function to inform CCM-modul which
	266	// instance is to be used.
	267
	268	// macros for reference of instance handle
	269	// These macros are used for parameter passing to CANopen API function.
e0ca0595 GKH	270	#define CCM_INSTANCE_HDL
e0ca0595 GKH	271	#define CCM_INSTANCE_HDL_
9d7164cf	272
e0ca0595	273	#define CCM_DECL_INSTANCE_PTR_LOCAL
9d7164cf DK	274
9d7164cf DK	275	// macros for declaration within the function header or prototype
e0ca0595 GKH	276	#define CCM_DECL_INSTANCE_HDL void
e0ca0595 GKH	277	#define CCM_DECL_INSTANCE_HDL_
9d7164cf DK	278
9d7164cf DK	279	// macros for process instance handle
e0ca0595	280	#define CCM_CHECK_INSTANCE_HDL()
9d7164cf DK	281
9d7164cf DK	282	// macros for declaration of pointer to instance handle
e0ca0595 GKH	283	#define CCM_DECL_PTR_INSTANCE_HDL void
e0ca0595 GKH	284	#define CCM_DECL_PTR_INSTANCE_HDL_
9d7164cf DK	285
9d7164cf DK	286	// macros for process pointer to instance handle
e0ca0595	287	#define CCM_CHECK_PTR_INSTANCE_HDL()
9d7164cf DK	288
9d7164cf DK	289	// This macro returned the handle and pointer to next free instance.
e0ca0595	290	#define CCM_GET_FREE_INSTANCE_AND_HDL()
9d7164cf	291
e0ca0595	292	#define CCM_CHECK_INSTANCE_PTR()
9d7164cf	293
e0ca0595 GKH	294	#define CCM_GET_INSTANCE_PTR()
e0ca0595 GKH	295	#define CCM_GET_FREE_INSTANCE_PTR()
9d7164cf	296
e0ca0595 GKH	297	#define CCM_INSTANCE_PARAM(par)
e0ca0595 GKH	298	#define CCM_INSTANCE_PARAM_(par)
9d7164cf	299
e0ca0595	300	#define CCM_INST_ENTRY aCcmInstanceTable_g[0]
9d7164cf DK	301
	302	// macros for declaration, initializing and member access for instance pointer
	303	// This class of macros are used by CANopen internal function to point to one instance.
	304
	305	// macros for declaration within the function header, prototype or local var list
e0ca0595 GKH	306	#define EPL_MCO_DECL_INSTANCE_PTR void
	307	#define EPL_MCO_DECL_INSTANCE_PTR_
	308	#define EPL_MCO_DECL_INSTANCE_PTR_LOCAL
9d7164cf DK	309
	310	// macros for reference of pointer to instance
	311	// These macros are used for parameter passing to called function.
e0ca0595 GKH	312	#define EPL_MCO_INSTANCE_PTR
	313	#define EPL_MCO_INSTANCE_PTR_
	314	#define EPL_MCO_ADDR_INSTANCE_PTR_
9d7164cf DK	315
9d7164cf DK	316	// macros for process pointer to instance
e0ca0595 GKH	317	#define EPL_MCO_GET_INSTANCE_PTR()
e0ca0595 GKH	318	#define EPL_MCO_GET_FREE_INSTANCE_PTR()
9d7164cf DK	319
9d7164cf DK	320	// This macro should be used to check the passed pointer to an public function
e0ca0595	321	#define EPL_MCO_CHECK_INSTANCE_STATE()
9d7164cf DK	322
9d7164cf DK	323	// macros for declaration of pointer to instance pointer
e0ca0595 GKH	324	#define EPL_MCO_DECL_PTR_INSTANCE_PTR void
e0ca0595 GKH	325	#define EPL_MCO_DECL_PTR_INSTANCE_PTR_
9d7164cf DK	326
	327	// macros for reference of pointer to instance pointer
	328	// These macros are used for parameter passing to called function.
e0ca0595 GKH	329	#define EPL_MCO_PTR_INSTANCE_PTR
e0ca0595 GKH	330	#define EPL_MCO_PTR_INSTANCE_PTR_
9d7164cf DK	331
9d7164cf DK	332	// macros for process pointer to instance pointer
e0ca0595 GKH	333	#define EPL_MCO_CHECK_PTR_INSTANCE_PTR()
e0ca0595 GKH	334	#define EPL_MCO_SET_PTR_INSTANCE_PTR()
9d7164cf	335
e0ca0595 GKH	336	#define EPL_MCO_INSTANCE_PARAM(a)
	337	#define EPL_MCO_INSTANCE_PARAM_(a)
	338	#define EPL_MCO_INSTANCE_PARAM_IDX_()
	339	#define EPL_MCO_INSTANCE_PARAM_IDX()
9d7164cf DK	340
9d7164cf DK	341	// macro for access of struct members of one instance
e0ca0595 GKH	342	#define EPL_MCO_INST_ENTRY aEplInstanceTable_g[0]
	343	#define EPL_MCO_GLB_VAR(var) (var)
	344	#define EPL_MCO_WRITE_INSTANCE_STATE(a)
9d7164cf DK	345
9d7164cf DK	346	// this macro deletes all instance entries as unused
e0ca0595	347	#define EPL_MCO_DELETE_INSTANCE_TABLE()
9d7164cf DK	348
9d7164cf DK	349	// definition of functions which has to be defined in each module of CANopen stack
e0ca0595 GKH	350	#define EPL_MCO_DEFINE_INSTANCE_FCT()
e0ca0595 GKH	351	#define EPL_MCO_DECL_INSTANCE_FCT()
9d7164cf DK	352
9d7164cf DK	353	// this macro defines the instance table. Each entry is reserved for an instance of CANopen.
e0ca0595	354	#define EPL_MCO_DECL_INSTANCE_VAR()
9d7164cf DK	355
	356	// this macro defines member variables in instance table which are needed in
	357	// all modules of CANopen stack
e0ca0595	358	#define EPL_MCO_DECL_INSTANCE_MEMBER()
9d7164cf DK	359
	360	#endif
	361
9d7164cf DK	362	/*
	363	#if (CDRV_MAX_INSTANCES > 1)
	364
	365	#define CDRV_REENTRANT REENTRANT
	366
	367	#else
	368
	369	#define CDRV_REENTRANT
	370
	371	#endif
	372	*/
	373
9d7164cf DK	374	#endif // _EPLINSTDEF_H_
	375
	376