drivers/staging/epl/EplDllkCal.c

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

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

  Project:      openPOWERLINK

  Description:  source file for kernel DLL Communication Abstraction Layer 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: EplDllkCal.c,v $

                $Author: D.Krueger $

                $Revision: 1.7 $  $Date: 2008/11/13 17:13:09 $

                $State: Exp $

                Build Environment:
                    GCC V3.4

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

  Revision History:

  2006/06/15 d.k.:   start of the implementation, version 1.00

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

#include "kernel/EplDllkCal.h"
#include "kernel/EplDllk.h"
#include "kernel/EplEventk.h"

#include "EplDllCal.h"
#ifndef EPL_NO_FIFO
#include "SharedBuff.h"
#endif

#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*          G L O B A L   D E F I N I T I O N S                            */
/*                                                                         */
/*                                                                         */
/***************************************************************************/

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

#ifndef min
#define min(a,b)            (((a) < (b)) ? (a) : (b))
#endif

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

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

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

/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*          C L A S S  EplDllkCal                                          */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
//
// Description:
//
//
/***************************************************************************/

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

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

#define EPL_DLLKCAL_MAX_QUEUES  5	// CnGenReq, CnNmtReq, {MnGenReq, MnNmtReq}, MnIdentReq, MnStatusReq

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

typedef struct {
#ifndef EPL_NO_FIFO
//    tShbInstance    m_ShbInstanceRx;      // FIFO for Rx ASnd frames
	tShbInstance m_ShbInstanceTxNmt;	// FIFO for Tx frames with NMT request priority
	tShbInstance m_ShbInstanceTxGen;	// FIFO for Tx frames with generic priority
#else
	unsigned int m_uiFrameSizeNmt;
	u8 m_abFrameNmt[1500];
	unsigned int m_uiFrameSizeGen;
	u8 m_abFrameGen[1500];
#endif

	tEplDllkCalStatistics m_Statistics;

#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
	// IdentRequest queue with CN node IDs
	unsigned int m_auiQueueIdentReq[EPL_D_NMT_MaxCNNumber_U8 + 1];	// 1 entry is reserved to distinguish between full and empty
	unsigned int m_uiWriteIdentReq;
	unsigned int m_uiReadIdentReq;

	// StatusRequest queue with CN node IDs
	unsigned int m_auiQueueStatusReq[EPL_D_NMT_MaxCNNumber_U8 + 1];	// 1 entry is reserved to distinguish between full and empty
	unsigned int m_uiWriteStatusReq;
	unsigned int m_uiReadStatusReq;

	unsigned int m_auiQueueCnRequests[254 * 2];
	// first 254 entries represent the generic requests of the corresponding node
	// second 254 entries represent the NMT requests of the corresponding node
	unsigned int m_uiNextQueueCnRequest;
	unsigned int m_uiNextRequestQueue;
#endif

} tEplDllkCalInstance;

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

// if no dynamic memory allocation shall be used
// define structures statically
static tEplDllkCalInstance EplDllkCalInstance_g;

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

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

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAddInstance()
//
// Description: add and initialize new instance of DLL CAL module
//
// Parameters:  none
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAddInstance()
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;
	unsigned int fShbNewCreated;

/*    ShbError = ShbCirAllocBuffer (EPL_DLLCAL_BUFFER_SIZE_RX, EPL_DLLCAL_BUFFER_ID_RX,
        &EplDllkCalInstance_g.m_ShbInstanceRx, &fShbNewCreated);
    // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg

    if (ShbError != kShbOk)
    {
        Ret = kEplNoResource;
    }
*/
	ShbError =
	    ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_NMT,
			      EPL_DLLCAL_BUFFER_ID_TX_NMT,
			      &EplDllkCalInstance_g.m_ShbInstanceTxNmt,
			      &fShbNewCreated);
	// returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg

	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
	}

/*    ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxNmt, EplDllkCalTxNmtSignalHandler, kShbPriorityNormal);
    // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg

    if (ShbError != kShbOk)
    {
        Ret = kEplNoResource;
    }
*/
	ShbError =
	    ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_GEN,
			      EPL_DLLCAL_BUFFER_ID_TX_GEN,
			      &EplDllkCalInstance_g.m_ShbInstanceTxGen,
			      &fShbNewCreated);
	// returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg

	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
	}

/*    ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxGen, EplDllkCalTxGenSignalHandler, kShbPriorityNormal);
    // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg

    if (ShbError != kShbOk)
    {
        Ret = kEplNoResource;
    }
*/
#else
	EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
	EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalDelInstance()
//
// Description: deletes instance of DLL CAL module
//
// Parameters:  none
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalDelInstance()
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;

/*    ShbError = ShbCirReleaseBuffer (EplDllkCalInstance_g.m_ShbInstanceRx);
    if (ShbError != kShbOk)
    {
        Ret = kEplNoResource;
    }
    EplDllkCalInstance_g.m_ShbInstanceRx = NULL;
*/
	ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt);
	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
	}
	EplDllkCalInstance_g.m_ShbInstanceTxNmt = NULL;

	ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen);
	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
	}
	EplDllkCalInstance_g.m_ShbInstanceTxGen = NULL;

#else
	EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
	EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalProcess
//
// Description: process the passed configuration
//
// Parameters:  pEvent_p                = event containing configuration options
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalProcess(tEplEvent * pEvent_p)
{
	tEplKernel Ret = kEplSuccessful;

	switch (pEvent_p->m_EventType) {
	case kEplEventTypeDllkServFilter:
		{
			tEplDllCalAsndServiceIdFilter *pServFilter;

			pServFilter =
			    (tEplDllCalAsndServiceIdFilter *) pEvent_p->m_pArg;
			Ret =
			    EplDllkSetAsndServiceIdFilter(pServFilter->
							  m_ServiceId,
							  pServFilter->
							  m_Filter);
			break;
		}

#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
	case kEplEventTypeDllkIssueReq:
		{
			tEplDllCalIssueRequest *pIssueReq;

			pIssueReq = (tEplDllCalIssueRequest *) pEvent_p->m_pArg;
			Ret =
			    EplDllkCalIssueRequest(pIssueReq->m_Service,
						   pIssueReq->m_uiNodeId,
						   pIssueReq->m_bSoaFlag1);
			break;
		}

	case kEplEventTypeDllkAddNode:
		{
			tEplDllNodeInfo *pNodeInfo;

			pNodeInfo = (tEplDllNodeInfo *) pEvent_p->m_pArg;
			Ret = EplDllkAddNode(pNodeInfo);
			break;
		}

	case kEplEventTypeDllkDelNode:
		{
			unsigned int *puiNodeId;

			puiNodeId = (unsigned int *)pEvent_p->m_pArg;
			Ret = EplDllkDeleteNode(*puiNodeId);
			break;
		}

	case kEplEventTypeDllkSoftDelNode:
		{
			unsigned int *puiNodeId;

			puiNodeId = (unsigned int *)pEvent_p->m_pArg;
			Ret = EplDllkSoftDeleteNode(*puiNodeId);
			break;
		}
#endif

	case kEplEventTypeDllkIdentity:
		{
			tEplDllIdentParam *pIdentParam;

			pIdentParam = (tEplDllIdentParam *) pEvent_p->m_pArg;
			if (pIdentParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) {
				pIdentParam->m_uiSizeOfStruct =
				    pEvent_p->m_uiSize;
			}
			Ret = EplDllkSetIdentity(pIdentParam);
			break;
		}

	case kEplEventTypeDllkConfig:
		{
			tEplDllConfigParam *pConfigParam;

			pConfigParam = (tEplDllConfigParam *) pEvent_p->m_pArg;
			if (pConfigParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) {
				pConfigParam->m_uiSizeOfStruct =
				    pEvent_p->m_uiSize;
			}
			Ret = EplDllkConfig(pConfigParam);
			break;
		}

	default:
		break;
	}

//Exit:
	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncGetTxCount()
//
// Description: returns count of Tx frames of FIFO with highest priority
//
// Parameters:  none
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncGetTxCount(tEplDllAsyncReqPriority * pPriority_p,
				     unsigned int *puiCount_p)
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;
	unsigned long ulFrameCount;

	// get frame count of Tx FIFO with NMT request priority
	ShbError =
	    ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
				    &ulFrameCount);
	// returns kShbOk, kShbInvalidArg

	// error handling
	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
		goto Exit;
	}

	if (ulFrameCount >
	    EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) {
		EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt =
		    ulFrameCount;
	}

	if (ulFrameCount != 0) {	// NMT requests are in queue
		*pPriority_p = kEplDllAsyncReqPrioNmt;
		*puiCount_p = (unsigned int)ulFrameCount;
		goto Exit;
	}
	// get frame count of Tx FIFO with generic priority
	ShbError =
	    ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen,
				    &ulFrameCount);
	// returns kShbOk, kShbInvalidArg

	// error handling
	if (ShbError != kShbOk) {
		Ret = kEplNoResource;
		goto Exit;
	}

	if (ulFrameCount >
	    EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) {
		EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen =
		    ulFrameCount;
	}

	*pPriority_p = kEplDllAsyncReqPrioGeneric;
	*puiCount_p = (unsigned int)ulFrameCount;

      Exit:
#else
	if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) {
		*pPriority_p = kEplDllAsyncReqPrioNmt;
		*puiCount_p = 1;
	} else if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) {
		*pPriority_p = kEplDllAsyncReqPrioGeneric;
		*puiCount_p = 1;
	} else {
		*pPriority_p = kEplDllAsyncReqPrioGeneric;
		*puiCount_p = 0;
	}
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncGetTxFrame()
//
// Description: returns Tx frames from FIFO with specified priority
//
// Parameters:  pFrame_p                = IN: pointer to buffer
//              puiFrameSize_p          = IN: max size of buffer
//                                        OUT: actual size of frame
//              Priority_p              = IN: priority
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncGetTxFrame(void *pFrame_p,
				     unsigned int *puiFrameSize_p,
				     tEplDllAsyncReqPriority Priority_p)
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;
	unsigned long ulFrameSize;

	switch (Priority_p) {
	case kEplDllAsyncReqPrioNmt:	// NMT request priority
		ShbError =
		    ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
					(u8 *) pFrame_p, *puiFrameSize_p,
					&ulFrameSize);
		// returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData
		break;

	default:		// generic priority
		ShbError =
		    ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxGen,
					(u8 *) pFrame_p, *puiFrameSize_p,
					&ulFrameSize);
		// returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData
		break;

	}

	// error handling
	if (ShbError != kShbOk) {
		if (ShbError == kShbNoReadableData) {
			Ret = kEplDllAsyncTxBufferEmpty;
		} else {	// other error
			Ret = kEplNoResource;
		}
		goto Exit;
	}

	*puiFrameSize_p = (unsigned int)ulFrameSize;

      Exit:
#else
	switch (Priority_p) {
	case kEplDllAsyncReqPrioNmt:	// NMT request priority
		*puiFrameSize_p =
		    min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeNmt);
		EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameNmt,
			   *puiFrameSize_p);
		EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
		break;

	default:		// generic priority
		*puiFrameSize_p =
		    min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeGen);
		EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameGen,
			   *puiFrameSize_p);
		EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
		break;
	}

#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncFrameReceived()
//
// Description: passes ASnd frame to receive FIFO.
//              It will be called only for frames with registered AsndServiceIds.
//
// Parameters:  none
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncFrameReceived(tEplFrameInfo * pFrameInfo_p)
{
	tEplKernel Ret = kEplSuccessful;
	tEplEvent Event;

	Event.m_EventSink = kEplEventSinkDlluCal;
	Event.m_EventType = kEplEventTypeAsndRx;
	Event.m_pArg = pFrameInfo_p->m_pFrame;
	Event.m_uiSize = pFrameInfo_p->m_uiFrameSize;
	// pass NetTime of frame to userspace
	Event.m_NetTime = pFrameInfo_p->m_NetTime;

	Ret = EplEventkPost(&Event);
	if (Ret != kEplSuccessful) {
		EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount++;
	} else {
		EplDllkCalInstance_g.m_Statistics.m_ulMaxRxFrameCount++;
	}

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncSend()
//
// Description: puts the given frame into the transmit FIFO with the specified
//              priority.
//
// Parameters:  pFrameInfo_p            = frame info structure
//              Priority_p              = priority
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncSend(tEplFrameInfo * pFrameInfo_p,
			       tEplDllAsyncReqPriority Priority_p)
{
	tEplKernel Ret = kEplSuccessful;
	tEplEvent Event;
#ifndef EPL_NO_FIFO
	tShbError ShbError;

	switch (Priority_p) {
	case kEplDllAsyncReqPrioNmt:	// NMT request priority
		ShbError =
		    ShbCirWriteDataBlock(EplDllkCalInstance_g.
					 m_ShbInstanceTxNmt,
					 pFrameInfo_p->m_pFrame,
					 pFrameInfo_p->m_uiFrameSize);
		// returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg
		break;

	default:		// generic priority
		ShbError =
		    ShbCirWriteDataBlock(EplDllkCalInstance_g.
					 m_ShbInstanceTxGen,
					 pFrameInfo_p->m_pFrame,
					 pFrameInfo_p->m_uiFrameSize);
		// returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg
		break;

	}

	// error handling
	switch (ShbError) {
	case kShbOk:
		break;

	case kShbExceedDataSizeLimit:
		Ret = kEplDllAsyncTxBufferFull;
		break;

	case kShbBufferFull:
		Ret = kEplDllAsyncTxBufferFull;
		break;

	case kShbInvalidArg:
	default:
		Ret = kEplNoResource;
		break;
	}

#else

	switch (Priority_p) {
	case kEplDllAsyncReqPrioNmt:	// NMT request priority
		if (EplDllkCalInstance_g.m_uiFrameSizeNmt == 0) {
			EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameNmt,
				   pFrameInfo_p->m_pFrame,
				   pFrameInfo_p->m_uiFrameSize);
			EplDllkCalInstance_g.m_uiFrameSizeNmt =
			    pFrameInfo_p->m_uiFrameSize;
		} else {
			Ret = kEplDllAsyncTxBufferFull;
			goto Exit;
		}
		break;

	default:		// generic priority
		if (EplDllkCalInstance_g.m_uiFrameSizeGen == 0) {
			EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameGen,
				   pFrameInfo_p->m_pFrame,
				   pFrameInfo_p->m_uiFrameSize);
			EplDllkCalInstance_g.m_uiFrameSizeGen =
			    pFrameInfo_p->m_uiFrameSize;
		} else {
			Ret = kEplDllAsyncTxBufferFull;
			goto Exit;
		}
		break;
	}

#endif

	// post event to DLL
	Event.m_EventSink = kEplEventSinkDllk;
	Event.m_EventType = kEplEventTypeDllkFillTx;
	EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
	Event.m_pArg = &Priority_p;
	Event.m_uiSize = sizeof(Priority_p);
	Ret = EplEventkPost(&Event);

#ifdef EPL_NO_FIFO
      Exit:
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncClearBuffer()
//
// Description: clears the transmit buffer
//
// Parameters:  (none)
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncClearBuffer(void)
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;

	ShbError =
	    ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt, 1000,
			      NULL);
	ShbError =
	    ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen, 1000,
			      NULL);

#else
	EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
	EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
#endif

//    EPL_MEMSET(&EplDllkCalInstance_g.m_Statistics, 0, sizeof (tEplDllkCalStatistics));
	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncClearQueues()
//
// Description: clears the transmit buffer
//
// Parameters:  (none)
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplKernel EplDllkCalAsyncClearQueues(void)
{
	tEplKernel Ret = kEplSuccessful;

	// clear MN asynchronous queues
	EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0;
	EplDllkCalInstance_g.m_uiNextRequestQueue = 0;
	EplDllkCalInstance_g.m_uiReadIdentReq = 0;
	EplDllkCalInstance_g.m_uiWriteIdentReq = 0;
	EplDllkCalInstance_g.m_uiReadStatusReq = 0;
	EplDllkCalInstance_g.m_uiWriteStatusReq = 0;

	return Ret;
}
#endif

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalGetStatistics()
//
// Description: returns statistics of the asynchronous queues.
//
// Parameters:  ppStatistics            = statistics structure
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalGetStatistics(tEplDllkCalStatistics ** ppStatistics)
{
	tEplKernel Ret = kEplSuccessful;
#ifndef EPL_NO_FIFO
	tShbError ShbError;

	ShbError =
	    ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
				    &EplDllkCalInstance_g.m_Statistics.
				    m_ulCurTxFrameCountNmt);
	ShbError =
	    ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen,
				    &EplDllkCalInstance_g.m_Statistics.
				    m_ulCurTxFrameCountGen);
//    ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceRx, &EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount);

#else
	if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) {
		EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 1;
	} else {
		EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 0;
	}
	if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) {
		EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 1;
	} else {
		EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 0;
	}
#endif

	*ppStatistics = &EplDllkCalInstance_g.m_Statistics;
	return Ret;
}

#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalIssueRequest()
//
// Description: issues a StatusRequest or a IdentRequest to the specified node.
//
// Parameters:  Service_p               = request service ID
//              uiNodeId_p              = node ID
//              bSoaFlag1_p             = flag1 for this node (transmit in SoA and PReq)
//                                        If 0xFF this flag is ignored.
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalIssueRequest(tEplDllReqServiceId Service_p,
				  unsigned int uiNodeId_p, u8 bSoaFlag1_p)
{
	tEplKernel Ret = kEplSuccessful;

	if (bSoaFlag1_p != 0xFF) {
		Ret = EplDllkSetFlag1OfNode(uiNodeId_p, bSoaFlag1_p);
		if (Ret != kEplSuccessful) {
			goto Exit;
		}
	}
	// add node to appropriate request queue
	switch (Service_p) {
	case kEplDllReqServiceIdent:
		{
			if (((EplDllkCalInstance_g.m_uiWriteIdentReq +
			      1) %
			     tabentries(EplDllkCalInstance_g.
					m_auiQueueIdentReq))
			    == EplDllkCalInstance_g.m_uiReadIdentReq) {	// queue is full
				Ret = kEplDllAsyncTxBufferFull;
				goto Exit;
			}
			EplDllkCalInstance_g.
			    m_auiQueueIdentReq[EplDllkCalInstance_g.
					       m_uiWriteIdentReq] = uiNodeId_p;
			EplDllkCalInstance_g.m_uiWriteIdentReq =
			    (EplDllkCalInstance_g.m_uiWriteIdentReq +
			     1) %
			    tabentries(EplDllkCalInstance_g.m_auiQueueIdentReq);
			break;
		}

	case kEplDllReqServiceStatus:
		{
			if (((EplDllkCalInstance_g.m_uiWriteStatusReq +
			      1) %
			     tabentries(EplDllkCalInstance_g.
					m_auiQueueStatusReq))
			    == EplDllkCalInstance_g.m_uiReadStatusReq) {	// queue is full
				Ret = kEplDllAsyncTxBufferFull;
				goto Exit;
			}
			EplDllkCalInstance_g.
			    m_auiQueueStatusReq[EplDllkCalInstance_g.
						m_uiWriteStatusReq] =
			    uiNodeId_p;
			EplDllkCalInstance_g.m_uiWriteStatusReq =
			    (EplDllkCalInstance_g.m_uiWriteStatusReq +
			     1) %
			    tabentries(EplDllkCalInstance_g.
				       m_auiQueueStatusReq);
			break;
		}

	default:
		{
			Ret = kEplDllInvalidParam;
			goto Exit;
		}
	}

      Exit:
	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncGetSoaRequest()
//
// Description: returns next request for SoA. This function is called by DLLk module.
//
// Parameters:  pReqServiceId_p         = pointer to request service ID
//                                        IN: available request for MN NMT or generic request queue (Flag2.PR)
//                                            or kEplDllReqServiceNo if queues are empty
//                                        OUT: next request
//              puiNodeId_p             = OUT: pointer to node ID of next request
//                                             = EPL_C_ADR_INVALID, if request is self addressed
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncGetSoaRequest(tEplDllReqServiceId * pReqServiceId_p,
					unsigned int *puiNodeId_p)
{
	tEplKernel Ret = kEplSuccessful;
	unsigned int uiCount;

//    *pReqServiceId_p = kEplDllReqServiceNo;

	for (uiCount = EPL_DLLKCAL_MAX_QUEUES; uiCount > 0; uiCount--) {
		switch (EplDllkCalInstance_g.m_uiNextRequestQueue) {
		case 0:
			{	// CnGenReq
				for (;
				     EplDllkCalInstance_g.
				     m_uiNextQueueCnRequest <
				     (tabentries
				      (EplDllkCalInstance_g.
				       m_auiQueueCnRequests) / 2);
				     EplDllkCalInstance_g.
				     m_uiNextQueueCnRequest++) {
					if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) {	// non empty queue found
						// remove one request from queue
						EplDllkCalInstance_g.
						    m_auiQueueCnRequests
						    [EplDllkCalInstance_g.
						     m_uiNextQueueCnRequest]--;
						*puiNodeId_p =
						    EplDllkCalInstance_g.
						    m_uiNextQueueCnRequest + 1;
						*pReqServiceId_p =
						    kEplDllReqServiceUnspecified;
						EplDllkCalInstance_g.
						    m_uiNextQueueCnRequest++;
						if (EplDllkCalInstance_g.m_uiNextQueueCnRequest >= (tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) {	// last node reached
							// continue with CnNmtReq queue at next SoA
							EplDllkCalInstance_g.
							    m_uiNextRequestQueue
							    = 1;
						}
						goto Exit;
					}
				}
				// all CnGenReq queues are empty -> continue with CnNmtReq queue
				EplDllkCalInstance_g.m_uiNextRequestQueue = 1;
				break;
			}

		case 1:
			{	// CnNmtReq
				for (;
				     EplDllkCalInstance_g.
				     m_uiNextQueueCnRequest <
				     tabentries(EplDllkCalInstance_g.
						m_auiQueueCnRequests);
				     EplDllkCalInstance_g.
				     m_uiNextQueueCnRequest++) {
					if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) {	// non empty queue found
						// remove one request from queue
						EplDllkCalInstance_g.
						    m_auiQueueCnRequests
						    [EplDllkCalInstance_g.
						     m_uiNextQueueCnRequest]--;
						*puiNodeId_p =
						    EplDllkCalInstance_g.
						    m_uiNextQueueCnRequest + 1 -
						    (tabentries
						     (EplDllkCalInstance_g.
						      m_auiQueueCnRequests) /
						     2);
						*pReqServiceId_p =
						    kEplDllReqServiceNmtRequest;
						EplDllkCalInstance_g.
						    m_uiNextQueueCnRequest++;
						if (EplDllkCalInstance_g.m_uiNextQueueCnRequest > tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests)) {	// last node reached
							// restart CnGenReq queue
							EplDllkCalInstance_g.
							    m_uiNextQueueCnRequest
							    = 0;
							// continue with MnGenReq queue at next SoA
							EplDllkCalInstance_g.
							    m_uiNextRequestQueue
							    = 2;
						}
						goto Exit;
					}
				}
				// restart CnGenReq queue
				EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0;
				// all CnNmtReq queues are empty -> continue with MnGenReq queue
				EplDllkCalInstance_g.m_uiNextRequestQueue = 2;
				break;
			}

		case 2:
			{	// MnNmtReq and MnGenReq
				// next queue will be MnIdentReq queue
				EplDllkCalInstance_g.m_uiNextRequestQueue = 3;
				if (*pReqServiceId_p != kEplDllReqServiceNo) {
					*puiNodeId_p = EPL_C_ADR_INVALID;	// DLLk must exchange this with the actual node ID
					goto Exit;
				}
				break;
			}

		case 3:
			{	// MnIdentReq
				// next queue will be MnStatusReq queue
				EplDllkCalInstance_g.m_uiNextRequestQueue = 4;
				if (EplDllkCalInstance_g.m_uiReadIdentReq != EplDllkCalInstance_g.m_uiWriteIdentReq) {	// queue is not empty
					*puiNodeId_p =
					    EplDllkCalInstance_g.
					    m_auiQueueIdentReq
					    [EplDllkCalInstance_g.
					     m_uiReadIdentReq];
					EplDllkCalInstance_g.m_uiReadIdentReq =
					    (EplDllkCalInstance_g.
					     m_uiReadIdentReq +
					     1) %
					    tabentries(EplDllkCalInstance_g.
						       m_auiQueueIdentReq);
					*pReqServiceId_p =
					    kEplDllReqServiceIdent;
					goto Exit;
				}
				break;
			}

		case 4:
			{	// MnStatusReq
				// next queue will be CnGenReq queue
				EplDllkCalInstance_g.m_uiNextRequestQueue = 0;
				if (EplDllkCalInstance_g.m_uiReadStatusReq != EplDllkCalInstance_g.m_uiWriteStatusReq) {	// queue is not empty
					*puiNodeId_p =
					    EplDllkCalInstance_g.
					    m_auiQueueStatusReq
					    [EplDllkCalInstance_g.
					     m_uiReadStatusReq];
					EplDllkCalInstance_g.m_uiReadStatusReq =
					    (EplDllkCalInstance_g.
					     m_uiReadStatusReq +
					     1) %
					    tabentries(EplDllkCalInstance_g.
						       m_auiQueueStatusReq);
					*pReqServiceId_p =
					    kEplDllReqServiceStatus;
					goto Exit;
				}
				break;
			}

		}
	}

      Exit:
	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplDllkCalAsyncSetPendingRequests()
//
// Description: sets the pending asynchronous frame requests of the specified node.
//              This will add the node to the asynchronous request scheduler.
//
// Parameters:  uiNodeId_p              = node ID
//              AsyncReqPrio_p          = asynchronous request priority
//              uiCount_p               = count of asynchronous frames
//
// Returns:     tEplKernel              = error code
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplDllkCalAsyncSetPendingRequests(unsigned int uiNodeId_p,
					     tEplDllAsyncReqPriority
					     AsyncReqPrio_p,
					     unsigned int uiCount_p)
{
	tEplKernel Ret = kEplSuccessful;

	// add node to appropriate request queue
	switch (AsyncReqPrio_p) {
	case kEplDllAsyncReqPrioNmt:
		{
			uiNodeId_p--;
			if (uiNodeId_p >=
			    (tabentries
			     (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) {
				Ret = kEplDllInvalidParam;
				goto Exit;
			}
			uiNodeId_p +=
			    tabentries(EplDllkCalInstance_g.
				       m_auiQueueCnRequests) / 2;
			EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] =
			    uiCount_p;
			break;
		}

	default:
		{
			uiNodeId_p--;
			if (uiNodeId_p >=
			    (tabentries
			     (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) {
				Ret = kEplDllInvalidParam;
				goto Exit;
			}
			EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] =
			    uiCount_p;
			break;
		}
	}

      Exit:
	return Ret;
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)

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

//---------------------------------------------------------------------------
//  Callback handler for new data signaling
//---------------------------------------------------------------------------

#ifndef EPL_NO_FIFO
/*static void  EplDllkCalTxNmtSignalHandler (
    tShbInstance pShbRxInstance_p,
    unsigned long ulDataSize_p)
{
tEplKernel      Ret = kEplSuccessful;
tEplEvent       Event;
tEplDllAsyncReqPriority Priority;
#ifndef EPL_NO_FIFO
tShbError   ShbError;
unsigned long   ulBlockCount;

    ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxNmt, &ulBlockCount);
    if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt)
    {
        EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = ulBlockCount;
    }

#endif

    // post event to DLL
    Priority = kEplDllAsyncReqPrioNmt;
    Event.m_EventSink = kEplEventSinkDllk;
    Event.m_EventType = kEplEventTypeDllkFillTx;
    EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
    Event.m_pArg = &Priority;
    Event.m_uiSize = sizeof(Priority);
    Ret = EplEventkPost(&Event);

}

static void  EplDllkCalTxGenSignalHandler (
    tShbInstance pShbRxInstance_p,
    unsigned long ulDataSize_p)
{
tEplKernel      Ret = kEplSuccessful;
tEplEvent       Event;
tEplDllAsyncReqPriority Priority;
#ifndef EPL_NO_FIFO
tShbError   ShbError;
unsigned long   ulBlockCount;

    ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxGen, &ulBlockCount);
    if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen)
    {
        EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = ulBlockCount;
    }

#endif

    // post event to DLL
    Priority = kEplDllAsyncReqPrioGeneric;
    Event.m_EventSink = kEplEventSinkDllk;
    Event.m_EventType = kEplEventTypeDllkFillTx;
    EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
    Event.m_pArg = &Priority;
    Event.m_uiSize = sizeof(Priority);
    Ret = EplEventkPost(&Event);

}
*/
#endif

#endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)

// EOF