[deliverable/linux.git] / drivers / staging / epl / EplIdentu.c

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

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

  Project:      openPOWERLINK

  Description:  source file for Identu-Module

  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: EplIdentu.c,v $

                $Author: D.Krueger $

                $Revision: 1.8 $  $Date: 2008/11/21 09:00:38 $

                $State: Exp $

                Build Environment:
                    GCC V3.4

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

  Revision History:

  2006/11/15 d.k.:   start of the implementation

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

#include "user/EplIdentu.h"
#include "user/EplDlluCal.h"

/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*          G L O B A L   D E F I N I T I O N S                            */
/*                                                                         */
/*                                                                         */
/***************************************************************************/

//---------------------------------------------------------------------------
// const defines
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// local types
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// modul globale vars
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// local function prototypes
//---------------------------------------------------------------------------

/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*          C L A S S  <xxxxx>                                             */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
//
// Description:
//
//
/***************************************************************************/

//=========================================================================//
//                                                                         //
//          P R I V A T E   D E F I N I T I O N S                          //
//                                                                         //
//=========================================================================//

//---------------------------------------------------------------------------
// const defines
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// local types
//---------------------------------------------------------------------------

typedef struct {
	tEplIdentResponse *m_apIdentResponse[254];	// the IdentResponse are managed dynamically
	tEplIdentuCbResponse m_apfnCbResponse[254];

} tEplIdentuInstance;

//---------------------------------------------------------------------------
// local vars
//---------------------------------------------------------------------------

static tEplIdentuInstance EplIdentuInstance_g;

//---------------------------------------------------------------------------
// local function prototypes
//---------------------------------------------------------------------------

static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p);

//=========================================================================//
//                                                                         //
//          P U B L I C   F U N C T I O N S                                //
//                                                                         //
//=========================================================================//

//---------------------------------------------------------------------------
//
// Function:    EplIdentuInit
//
// Description: init first instance of the module
//
//
//
// Parameters:
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit()
{
	tEplKernel Ret;

	Ret = EplIdentuAddInstance();

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuAddInstance
//
// Description: init other instances of the module
//
//
//
// Parameters:
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance()
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

	// reset instance structure
	EPL_MEMSET(&EplIdentuInstance_g, 0, sizeof(EplIdentuInstance_g));

	// register IdentResponse callback function
	Ret =
	    EplDlluCalRegAsndService(kEplDllAsndIdentResponse,
				     EplIdentuCbIdentResponse,
				     kEplDllAsndFilterAny);

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuDelInstance
//
// Description: delete instance
//
//
//
// Parameters:
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance()
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

	// deregister IdentResponse callback function
	Ret =
	    EplDlluCalRegAsndService(kEplDllAsndIdentResponse, NULL,
				     kEplDllAsndFilterNone);

	Ret = EplIdentuReset();

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuReset
//
// Description: resets this instance
//
//
//
// Parameters:
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset()
{
	tEplKernel Ret;
	int iIndex;

	Ret = kEplSuccessful;

	for (iIndex = 0;
	     iIndex < tabentries(EplIdentuInstance_g.m_apIdentResponse);
	     iIndex++) {
		if (EplIdentuInstance_g.m_apIdentResponse[iIndex] != NULL) {	// free memory
			EPL_FREE(EplIdentuInstance_g.m_apIdentResponse[iIndex]);
		}
	}

	EPL_MEMSET(&EplIdentuInstance_g, 0, sizeof(EplIdentuInstance_g));

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuGetIdentResponse
//
// Description: returns the IdentResponse for the specified node.
//
// Parameters:  uiNodeId_p                  = IN: node ID
//              ppIdentResponse_p           = OUT: pointer to pointer of IdentResponse
//                                            equals NULL, if no IdentResponse available
//
// Return:      tEplKernel                  = error code
//
// State:       not tested
//
//---------------------------------------------------------------------------

tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
					    tEplIdentResponse **
					    ppIdentResponse_p)
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

	// decrement node ID, because array is zero based
	uiNodeId_p--;
	if (uiNodeId_p < tabentries(EplIdentuInstance_g.m_apIdentResponse)) {
		*ppIdentResponse_p =
		    EplIdentuInstance_g.m_apIdentResponse[uiNodeId_p];
	} else {		// invalid node ID specified
		*ppIdentResponse_p = NULL;
		Ret = kEplInvalidNodeId;
	}

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuRequestIdentResponse
//
// Description: returns the IdentResponse for the specified node.
//
// Parameters:  uiNodeId_p                  = IN: node ID
//              pfnCbResponse_p             = IN: function pointer to callback function
//                                            which will be called if IdentResponse is received
//
// Return:      tEplKernel                  = error code
//
// State:       not tested
//
//---------------------------------------------------------------------------

tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
						tEplIdentuCbResponse
						pfnCbResponse_p)
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

	// decrement node ID, because array is zero based
	uiNodeId_p--;
	if (uiNodeId_p < tabentries(EplIdentuInstance_g.m_apfnCbResponse)) {
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
		if (EplIdentuInstance_g.m_apfnCbResponse[uiNodeId_p] != NULL) {	// request already issued (maybe by someone else)
			Ret = kEplInvalidOperation;
		} else {
			EplIdentuInstance_g.m_apfnCbResponse[uiNodeId_p] =
			    pfnCbResponse_p;
			Ret =
			    EplDlluCalIssueRequest(kEplDllReqServiceIdent,
						   (uiNodeId_p + 1), 0xFF);
		}
#else
		Ret = kEplInvalidOperation;
#endif
	} else {		// invalid node ID specified
		Ret = kEplInvalidNodeId;
	}

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplIdentuGetRunningRequests
//
// Description: returns a bit field with the running requests for node-ID 1-32
//              just for debugging purposes
//
//
// Parameters:
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void)
{
	DWORD dwReqs = 0;
	unsigned int uiIndex;

	for (uiIndex = 0; uiIndex < 32; uiIndex++) {
		if (EplIdentuInstance_g.m_apfnCbResponse[uiIndex] != NULL) {
			dwReqs |= (1 << uiIndex);
		}
	}

	return dwReqs;
}

//=========================================================================//
//                                                                         //
//          P R I V A T E   F U N C T I O N S                              //
//                                                                         //
//=========================================================================//

//---------------------------------------------------------------------------
//
// Function:    EplIdentuCbIdentResponse
//
// Description: callback funktion for IdentResponse
//
//
//
// Parameters:  pFrameInfo_p            = Frame with the IdentResponse
//
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p)
{
	tEplKernel Ret = kEplSuccessful;
	unsigned int uiNodeId;
	unsigned int uiIndex;
	tEplIdentuCbResponse pfnCbResponse;

	uiNodeId = AmiGetByteFromLe(&pFrameInfo_p->m_pFrame->m_le_bSrcNodeId);

	uiIndex = uiNodeId - 1;

	if (uiIndex < tabentries(EplIdentuInstance_g.m_apfnCbResponse)) {
		// memorize pointer to callback function
		pfnCbResponse = EplIdentuInstance_g.m_apfnCbResponse[uiIndex];
		// reset callback function pointer so that caller may issue next request immediately
		EplIdentuInstance_g.m_apfnCbResponse[uiIndex] = NULL;

		if (pFrameInfo_p->m_uiFrameSize < EPL_C_DLL_MINSIZE_IDENTRES) {	// IdentResponse not received or it has invalid size
			if (pfnCbResponse == NULL) {	// response was not requested
				goto Exit;
			}
			Ret = pfnCbResponse(uiNodeId, NULL);
		} else {	// IdentResponse received
			if (EplIdentuInstance_g.m_apIdentResponse[uiIndex] == NULL) {	// memory for IdentResponse must be allocated
				EplIdentuInstance_g.m_apIdentResponse[uiIndex] =
				    EPL_MALLOC(sizeof(tEplIdentResponse));
				if (EplIdentuInstance_g.m_apIdentResponse[uiIndex] == NULL) {	// malloc failed
					if (pfnCbResponse == NULL) {	// response was not requested
						goto Exit;
					}
					Ret =
					    pfnCbResponse(uiNodeId,
							  &pFrameInfo_p->
							  m_pFrame->m_Data.
							  m_Asnd.m_Payload.
							  m_IdentResponse);
					goto Exit;
				}
			}
			// copy IdentResponse to instance structure
			EPL_MEMCPY(EplIdentuInstance_g.
				   m_apIdentResponse[uiIndex],
				   &pFrameInfo_p->m_pFrame->m_Data.m_Asnd.
				   m_Payload.m_IdentResponse,
				   sizeof(tEplIdentResponse));
			if (pfnCbResponse == NULL) {	// response was not requested
				goto Exit;
			}
			Ret =
			    pfnCbResponse(uiNodeId,
					  EplIdentuInstance_g.
					  m_apIdentResponse[uiIndex]);
		}
	}

      Exit:
	return Ret;
}

// EOF
Commit	Line	Data
9d7164cf DK	1	/****************************************************************************
	2
	3	(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
	4	www.systec-electronic.com
	5
	6	Project: openPOWERLINK
	7
	8	Description: source file for Identu-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: EplIdentu.c,v $
	53
	54	$Author: D.Krueger $
	55
	56	$Revision: 1.8 $ $Date: 2008/11/21 09:00:38 $
	57
	58	$State: Exp $
	59
	60	Build Environment:
	61	GCC V3.4
	62
	63	-------------------------------------------------------------------------
	64
65	Revision History:
66
67	2006/11/15 d.k.: start of the implementation
68
69	****************************************************************************/
70
71	#include "user/EplIdentu.h"
72	#include "user/EplDlluCal.h"
73
74	/***************************************************************************/
75	/* */
76	/* */
77	/* G L O B A L D E F I N I T I O N S */
78	/* */
79	/* */
80	/***************************************************************************/
81
82	//---------------------------------------------------------------------------
83	// const defines
84	//---------------------------------------------------------------------------
85
86	//---------------------------------------------------------------------------
87	// local types
88	//---------------------------------------------------------------------------
89
90	//---------------------------------------------------------------------------
91	// modul globale vars
92	//---------------------------------------------------------------------------
93
94	//---------------------------------------------------------------------------
95	// local function prototypes
96	//---------------------------------------------------------------------------
97
9d7164cf DK	98	/***************************************************************************/
	99	/* */
	100	/* */
	101	/* C L A S S <xxxxx> */
	102	/* */
	103	/* */
	104	/***************************************************************************/
	105	//
	106	// Description:
	107	//
	108	//
	109	/***************************************************************************/
	110
9d7164cf DK	111	//=========================================================================//
	112	// //
	113	// P R I V A T E D E F I N I T I O N S //
	114	// //
	115	//=========================================================================//
	116
	117	//---------------------------------------------------------------------------
	118	// const defines
	119	//---------------------------------------------------------------------------
	120
	121	//---------------------------------------------------------------------------
	122	// local types
	123	//---------------------------------------------------------------------------
	124
833dfbe7 GKH	125	typedef struct {
	126	tEplIdentResponse *m_apIdentResponse[254]; // the IdentResponse are managed dynamically
	127	tEplIdentuCbResponse m_apfnCbResponse[254];
9d7164cf DK	128
	129	} tEplIdentuInstance;
	130
	131	//---------------------------------------------------------------------------
	132	// local vars
	133	//---------------------------------------------------------------------------
	134
833dfbe7	135	static tEplIdentuInstance EplIdentuInstance_g;
9d7164cf DK	136
	137	//---------------------------------------------------------------------------
	138	// local function prototypes
	139	//---------------------------------------------------------------------------
	140
	141	static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p);
	142
	143	//=========================================================================//
	144	// //
	145	// P U B L I C F U N C T I O N S //
	146	// //
	147	//=========================================================================//
	148
	149	//---------------------------------------------------------------------------
	150	//
	151	// Function: EplIdentuInit
	152	//
	153	// Description: init first instance of the module
	154	//
	155	//
	156	//
	157	// Parameters:
	158	//
	159	//
	160	// Returns: tEplKernel = errorcode
	161	//
	162	//
	163	// State:
	164	//
	165	//---------------------------------------------------------------------------
	166
	167	EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit()
	168	{
833dfbe7	169	tEplKernel Ret;
9d7164cf	170
833dfbe7	171	Ret = EplIdentuAddInstance();
9d7164cf	172
833dfbe7	173	return Ret;
9d7164cf DK	174	}
9d7164cf DK	175
9d7164cf DK	176	//---------------------------------------------------------------------------
	177	//
	178	// Function: EplIdentuAddInstance
	179	//
	180	// Description: init other instances of the module
	181	//
	182	//
	183	//
	184	// Parameters:
	185	//
	186	//
	187	// Returns: tEplKernel = errorcode
	188	//
	189	//
	190	// State:
	191	//
	192	//---------------------------------------------------------------------------
	193
	194	EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance()
	195	{
833dfbe7	196	tEplKernel Ret;
9d7164cf	197
833dfbe7	198	Ret = kEplSuccessful;
9d7164cf	199
833dfbe7 GKH	200	// reset instance structure
833dfbe7 GKH	201	EPL_MEMSET(&EplIdentuInstance_g, 0, sizeof(EplIdentuInstance_g));
9d7164cf	202
833dfbe7 GKH	203	// register IdentResponse callback function
	204	Ret =
	205	EplDlluCalRegAsndService(kEplDllAsndIdentResponse,
	206	EplIdentuCbIdentResponse,
	207	kEplDllAsndFilterAny);
9d7164cf	208
833dfbe7	209	return Ret;
9d7164cf DK	210
	211	}
	212
9d7164cf DK	213	//---------------------------------------------------------------------------
	214	//
	215	// Function: EplIdentuDelInstance
	216	//
	217	// Description: delete instance
	218	//
	219	//
	220	//
	221	// Parameters:
	222	//
	223	//
	224	// Returns: tEplKernel = errorcode
	225	//
	226	//
	227	// State:
	228	//
	229	//---------------------------------------------------------------------------
	230
	231	EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance()
	232	{
833dfbe7	233	tEplKernel Ret;
9d7164cf	234
833dfbe7	235	Ret = kEplSuccessful;
9d7164cf	236
833dfbe7 GKH	237	// deregister IdentResponse callback function
	238	Ret =
	239	EplDlluCalRegAsndService(kEplDllAsndIdentResponse, NULL,
	240	kEplDllAsndFilterNone);
9d7164cf	241
833dfbe7	242	Ret = EplIdentuReset();
9d7164cf	243
833dfbe7	244	return Ret;
9d7164cf DK	245
	246	}
	247
9d7164cf DK	248	//---------------------------------------------------------------------------
	249	//
	250	// Function: EplIdentuReset
	251	//
	252	// Description: resets this instance
	253	//
	254	//
	255	//
	256	// Parameters:
	257	//
	258	//
	259	// Returns: tEplKernel = errorcode
	260	//
	261	//
	262	// State:
	263	//
	264	//---------------------------------------------------------------------------
	265
	266	EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset()
	267	{
833dfbe7 GKH	268	tEplKernel Ret;
833dfbe7 GKH	269	int iIndex;
9d7164cf	270
833dfbe7	271	Ret = kEplSuccessful;
9d7164cf	272
833dfbe7 GKH	273	for (iIndex = 0;
	274	iIndex < tabentries(EplIdentuInstance_g.m_apIdentResponse);
	275	iIndex++) {
	276	if (EplIdentuInstance_g.m_apIdentResponse[iIndex] != NULL) { // free memory
	277	EPL_FREE(EplIdentuInstance_g.m_apIdentResponse[iIndex]);
	278	}
	279	}
9d7164cf	280
833dfbe7	281	EPL_MEMSET(&EplIdentuInstance_g, 0, sizeof(EplIdentuInstance_g));
9d7164cf	282
833dfbe7	283	return Ret;
9d7164cf DK	284
	285	}
	286
9d7164cf DK	287	//---------------------------------------------------------------------------
	288	//
	289	// Function: EplIdentuGetIdentResponse
	290	//
	291	// Description: returns the IdentResponse for the specified node.
	292	//
	293	// Parameters: uiNodeId_p = IN: node ID
	294	// ppIdentResponse_p = OUT: pointer to pointer of IdentResponse
	295	// equals NULL, if no IdentResponse available
	296	//
	297	// Return: tEplKernel = error code
	298	//
	299	// State: not tested
	300	//
	301	//---------------------------------------------------------------------------
	302
833dfbe7 GKH	303	tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
	304	tEplIdentResponse **
	305	ppIdentResponse_p)
9d7164cf	306	{
833dfbe7	307	tEplKernel Ret;
9d7164cf	308
833dfbe7	309	Ret = kEplSuccessful;
9d7164cf	310
833dfbe7 GKH	311	// decrement node ID, because array is zero based
	312	uiNodeId_p--;
	313	if (uiNodeId_p < tabentries(EplIdentuInstance_g.m_apIdentResponse)) {
	314	*ppIdentResponse_p =
	315	EplIdentuInstance_g.m_apIdentResponse[uiNodeId_p];
	316	} else { // invalid node ID specified
	317	*ppIdentResponse_p = NULL;
	318	Ret = kEplInvalidNodeId;
	319	}
9d7164cf	320
833dfbe7	321	return Ret;
9d7164cf DK	322
	323	}
	324
9d7164cf DK	325	//---------------------------------------------------------------------------
	326	//
	327	// Function: EplIdentuRequestIdentResponse
	328	//
	329	// Description: returns the IdentResponse for the specified node.
	330	//
	331	// Parameters: uiNodeId_p = IN: node ID
	332	// pfnCbResponse_p = IN: function pointer to callback function
	333	// which will be called if IdentResponse is received
	334	//
	335	// Return: tEplKernel = error code
	336	//
	337	// State: not tested
	338	//
	339	//---------------------------------------------------------------------------
	340
833dfbe7 GKH	341	tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
	342	tEplIdentuCbResponse
	343	pfnCbResponse_p)
9d7164cf	344	{
833dfbe7	345	tEplKernel Ret;
9d7164cf	346
833dfbe7	347	Ret = kEplSuccessful;
9d7164cf	348
833dfbe7 GKH	349	// decrement node ID, because array is zero based
	350	uiNodeId_p--;
	351	if (uiNodeId_p < tabentries(EplIdentuInstance_g.m_apfnCbResponse)) {
9d7164cf	352	#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
833dfbe7 GKH	353	if (EplIdentuInstance_g.m_apfnCbResponse[uiNodeId_p] != NULL) { // request already issued (maybe by someone else)
	354	Ret = kEplInvalidOperation;
	355	} else {
	356	EplIdentuInstance_g.m_apfnCbResponse[uiNodeId_p] =
	357	pfnCbResponse_p;
	358	Ret =
	359	EplDlluCalIssueRequest(kEplDllReqServiceIdent,
	360	(uiNodeId_p + 1), 0xFF);
	361	}
9d7164cf	362	#else
833dfbe7	363	Ret = kEplInvalidOperation;
9d7164cf	364	#endif
833dfbe7 GKH	365	} else { // invalid node ID specified
	366	Ret = kEplInvalidNodeId;
	367	}
9d7164cf	368
833dfbe7	369	return Ret;
9d7164cf DK	370
	371	}
	372
9d7164cf DK	373	//---------------------------------------------------------------------------
	374	//
	375	// Function: EplIdentuGetRunningRequests
	376	//
	377	// Description: returns a bit field with the running requests for node-ID 1-32
	378	// just for debugging purposes
	379	//
	380	//
	381	// Parameters:
	382	//
	383	//
	384	// Returns: tEplKernel = errorcode
	385	//
	386	//
	387	// State:
	388	//
	389	//---------------------------------------------------------------------------
	390
	391	EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void)
	392	{
833dfbe7 GKH	393	DWORD dwReqs = 0;
833dfbe7 GKH	394	unsigned int uiIndex;
9d7164cf	395
833dfbe7 GKH	396	for (uiIndex = 0; uiIndex < 32; uiIndex++) {
	397	if (EplIdentuInstance_g.m_apfnCbResponse[uiIndex] != NULL) {
	398	dwReqs \|= (1 << uiIndex);
	399	}
	400	}
	401
	402	return dwReqs;
	403	}
9d7164cf DK	404
	405	//=========================================================================//
	406	// //
	407	// P R I V A T E F U N C T I O N S //
	408	// //
	409	//=========================================================================//
	410
	411	//---------------------------------------------------------------------------
	412	//
	413	// Function: EplIdentuCbIdentResponse
	414	//
	415	// Description: callback funktion for IdentResponse
	416	//
	417	//
	418	//
	419	// Parameters: pFrameInfo_p = Frame with the IdentResponse
	420	//
	421	//
	422	// Returns: tEplKernel = error code
	423	//
	424	//
	425	// State:
	426	//
	427	//---------------------------------------------------------------------------
	428
	429	static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p)
	430	{
833dfbe7 GKH	431	tEplKernel Ret = kEplSuccessful;
	432	unsigned int uiNodeId;
	433	unsigned int uiIndex;
	434	tEplIdentuCbResponse pfnCbResponse;
	435
	436	uiNodeId = AmiGetByteFromLe(&pFrameInfo_p->m_pFrame->m_le_bSrcNodeId);
	437
	438	uiIndex = uiNodeId - 1;
	439
	440	if (uiIndex < tabentries(EplIdentuInstance_g.m_apfnCbResponse)) {
	441	// memorize pointer to callback function
	442	pfnCbResponse = EplIdentuInstance_g.m_apfnCbResponse[uiIndex];
	443	// reset callback function pointer so that caller may issue next request immediately
	444	EplIdentuInstance_g.m_apfnCbResponse[uiIndex] = NULL;
	445
	446	if (pFrameInfo_p->m_uiFrameSize < EPL_C_DLL_MINSIZE_IDENTRES) { // IdentResponse not received or it has invalid size
	447	if (pfnCbResponse == NULL) { // response was not requested
	448	goto Exit;
	449	}
	450	Ret = pfnCbResponse(uiNodeId, NULL);
	451	} else { // IdentResponse received
	452	if (EplIdentuInstance_g.m_apIdentResponse[uiIndex] == NULL) { // memory for IdentResponse must be allocated
	453	EplIdentuInstance_g.m_apIdentResponse[uiIndex] =
	454	EPL_MALLOC(sizeof(tEplIdentResponse));
	455	if (EplIdentuInstance_g.m_apIdentResponse[uiIndex] == NULL) { // malloc failed
	456	if (pfnCbResponse == NULL) { // response was not requested
	457	goto Exit;
	458	}
	459	Ret =
	460	pfnCbResponse(uiNodeId,
	461	&pFrameInfo_p->
	462	m_pFrame->m_Data.
	463	m_Asnd.m_Payload.
	464	m_IdentResponse);
	465	goto Exit;
	466	}
	467	}
	468	// copy IdentResponse to instance structure
	469	EPL_MEMCPY(EplIdentuInstance_g.
	470	m_apIdentResponse[uiIndex],
	471	&pFrameInfo_p->m_pFrame->m_Data.m_Asnd.
	472	m_Payload.m_IdentResponse,
	473	sizeof(tEplIdentResponse));
	474	if (pfnCbResponse == NULL) { // response was not requested
	475	goto Exit;
	476	}
	477	Ret =
	478	pfnCbResponse(uiNodeId,
	479	EplIdentuInstance_g.
	480	m_apIdentResponse[uiIndex]);
	481	}
	482	}
	483
	484	Exit:
	485	return Ret;
9d7164cf DK	486	}
	487
	488	// EOF