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

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

  Project:      openPOWERLINK

  Description:  source file for NMT-CN-Userspace-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: EplNmtCnu.c,v $

                $Author: D.Krueger $

                $Revision: 1.6 $  $Date: 2008/10/17 15:32:32 $

                $State: Exp $

                Build Environment:
                    GCC V3.4

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

  Revision History:

  2006/06/09 k.t.:   start of the implementation

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

#include "EplInc.h"
#include "user/EplNmtCnu.h"
#include "user/EplDlluCal.h"

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

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

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

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

typedef struct {
	unsigned int m_uiNodeId;
	tEplNmtuCheckEventCallback m_pfnCheckEventCb;

} tEplNmtCnuInstance;

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

static tEplNmtCnuInstance EplNmtCnuInstance_g;

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

static tEplNmtCommand EplNmtCnuGetNmtCommand(tEplFrameInfo * pFrameInfo_p);

static BOOL EplNmtCnuNodeIdList(u8 * pbNmtCommandDate_p);

static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p);

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

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuInit
//
// Description: init the first instance of the module
//
//
//
// Parameters:      uiNodeId_p = NodeId of the local node
//
//
// Returns:         tEplKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplNmtCnuInit(unsigned int uiNodeId_p)
{
	tEplKernel Ret;

	Ret = EplNmtCnuAddInstance(uiNodeId_p);

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuAddInstance
//
// Description: init the add new instance of the module
//
//
//
// Parameters:      uiNodeId_p = NodeId of the local node
//
//
// Returns:         tEplKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplNmtCnuAddInstance(unsigned int uiNodeId_p)
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

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

	// save nodeid
	EplNmtCnuInstance_g.m_uiNodeId = uiNodeId_p;

	// register callback-function for NMT-commands
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
	Ret = EplDlluCalRegAsndService(kEplDllAsndNmtCommand,
				       EplNmtCnuCommandCb,
				       kEplDllAsndFilterLocal);
#endif

	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuDelInstance
//
// Description: delte instance of the module
//
//
//
// Parameters:
//
//
// Returns:         tEplKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplNmtCnuDelInstance(void)
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
	// deregister callback function from DLL
	Ret = EplDlluCalRegAsndService(kEplDllAsndNmtCommand,
				       NULL, kEplDllAsndFilterNone);
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuSendNmtRequest
//
// Description: Send an NMT-Request to the MN
//
//
//
// Parameters:      uiNodeId_p = NodeId of the local node
//                  NmtCommand_p = requested NMT-Command
//
//
// Returns:         tEplKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
				   tEplNmtCommand NmtCommand_p)
{
	tEplKernel Ret;
	tEplFrameInfo NmtRequestFrameInfo;
	tEplFrame NmtRequestFrame;

	Ret = kEplSuccessful;

	// build frame
	EPL_MEMSET(&NmtRequestFrame.m_be_abDstMac[0], 0x00, sizeof(NmtRequestFrame.m_be_abDstMac));	// set by DLL
	EPL_MEMSET(&NmtRequestFrame.m_be_abSrcMac[0], 0x00, sizeof(NmtRequestFrame.m_be_abSrcMac));	// set by DLL
	AmiSetWordToBe(&NmtRequestFrame.m_be_wEtherType,
		       EPL_C_DLL_ETHERTYPE_EPL);
	AmiSetByteToLe(&NmtRequestFrame.m_le_bDstNodeId, (u8) EPL_C_ADR_MN_DEF_NODE_ID);	// node id of the MN
	AmiSetByteToLe(&NmtRequestFrame.m_le_bMessageType,
		       (u8) kEplMsgTypeAsnd);
	AmiSetByteToLe(&NmtRequestFrame.m_Data.m_Asnd.m_le_bServiceId,
		       (u8) kEplDllAsndNmtRequest);
	AmiSetByteToLe(&NmtRequestFrame.m_Data.m_Asnd.m_Payload.
		       m_NmtRequestService.m_le_bNmtCommandId,
		       (u8) NmtCommand_p);
	AmiSetByteToLe(&NmtRequestFrame.m_Data.m_Asnd.m_Payload.m_NmtRequestService.m_le_bTargetNodeId, (u8) uiNodeId_p);	// target for the nmt command
	EPL_MEMSET(&NmtRequestFrame.m_Data.m_Asnd.m_Payload.m_NmtRequestService.
		   m_le_abNmtCommandData[0], 0x00,
		   sizeof(NmtRequestFrame.m_Data.m_Asnd.m_Payload.
			  m_NmtRequestService.m_le_abNmtCommandData));

	// build info-structure
	NmtRequestFrameInfo.m_NetTime.m_dwNanoSec = 0;
	NmtRequestFrameInfo.m_NetTime.m_dwSec = 0;
	NmtRequestFrameInfo.m_pFrame = &NmtRequestFrame;
	NmtRequestFrameInfo.m_uiFrameSize = EPL_C_DLL_MINSIZE_NMTREQ;	// sizeof(NmtRequestFrame);

	// send NMT-Request
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
	Ret = EplDlluCalAsyncSend(&NmtRequestFrameInfo,	// pointer to frameinfo
				  kEplDllAsyncReqPrioNmt);	// priority
#endif

	return Ret;
}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuRegisterStateChangeCb
//
// Description: register Callback-function go get informed about a
//              NMT-Change-State-Event
//
//
//
// Parameters:  pfnEplNmtStateChangeCb_p = functionpointer
//
//
// Returns:     tEplKernel  = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------

tEplKernel EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback pfnEplNmtCheckEventCb_p)
{
	tEplKernel Ret;

	Ret = kEplSuccessful;

	// save callback-function in modul global var
	EplNmtCnuInstance_g.m_pfnCheckEventCb = pfnEplNmtCheckEventCb_p;

	return Ret;

}

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

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuCommandCb
//
// Description: callback funktion for NMT-Commands
//
//
//
// Parameters:      pFrameInfo_p = Frame with the NMT-Commando
//
//
// Returns:         tEplKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p)
{
	tEplKernel Ret = kEplSuccessful;
	tEplNmtCommand NmtCommand;
	BOOL fNodeIdInList;
	tEplNmtEvent NmtEvent = kEplNmtEventNoEvent;

	if (pFrameInfo_p == NULL) {
		Ret = kEplNmtInvalidFramePointer;
		goto Exit;
	}

	NmtCommand = EplNmtCnuGetNmtCommand(pFrameInfo_p);

	// check NMT-Command
	switch (NmtCommand) {

		//------------------------------------------------------------------------
		// plain NMT state commands
	case kEplNmtCmdStartNode:
		{		// send NMT-Event to state maschine kEplNmtEventStartNode
			NmtEvent = kEplNmtEventStartNode;
			break;
		}

	case kEplNmtCmdStopNode:
		{		// send NMT-Event to state maschine kEplNmtEventStopNode
			NmtEvent = kEplNmtEventStopNode;
			break;
		}

	case kEplNmtCmdEnterPreOperational2:
		{		// send NMT-Event to state maschine kEplNmtEventEnterPreOperational2
			NmtEvent = kEplNmtEventEnterPreOperational2;
			break;
		}

	case kEplNmtCmdEnableReadyToOperate:
		{		// send NMT-Event to state maschine kEplNmtEventEnableReadyToOperate
			NmtEvent = kEplNmtEventEnableReadyToOperate;
			break;
		}

	case kEplNmtCmdResetNode:
		{		// send NMT-Event to state maschine kEplNmtEventResetNode
			NmtEvent = kEplNmtEventResetNode;
			break;
		}

	case kEplNmtCmdResetCommunication:
		{		// send NMT-Event to state maschine kEplNmtEventResetCom
			NmtEvent = kEplNmtEventResetCom;
			break;
		}

	case kEplNmtCmdResetConfiguration:
		{		// send NMT-Event to state maschine kEplNmtEventResetConfig
			NmtEvent = kEplNmtEventResetConfig;
			break;
		}

	case kEplNmtCmdSwReset:
		{		// send NMT-Event to state maschine kEplNmtEventSwReset
			NmtEvent = kEplNmtEventSwReset;
			break;
		}

		//------------------------------------------------------------------------
		// extended NMT state commands

	case kEplNmtCmdStartNodeEx:
		{
			// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&
						(pFrameInfo_p->m_pFrame->m_Data.
						 m_Asnd.m_Payload.
						 m_NmtCommandService.
						 m_le_abNmtCommandData[0]));
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventStartNode;
			}
			break;
		}

	case kEplNmtCmdStopNodeEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventStopNode;
			}
			break;
		}

	case kEplNmtCmdEnterPreOperational2Ex:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventEnterPreOperational2;
			}
			break;
		}

	case kEplNmtCmdEnableReadyToOperateEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventEnableReadyToOperate;
			}
			break;
		}

	case kEplNmtCmdResetNodeEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventResetNode;
			}
			break;
		}

	case kEplNmtCmdResetCommunicationEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventResetCom;
			}
			break;
		}

	case kEplNmtCmdResetConfigurationEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventResetConfig;
			}
			break;
		}

	case kEplNmtCmdSwResetEx:
		{		// check if own nodeid is in EPL node list
			fNodeIdInList =
			    EplNmtCnuNodeIdList(&pFrameInfo_p->m_pFrame->m_Data.
						m_Asnd.m_Payload.
						m_NmtCommandService.
						m_le_abNmtCommandData[0]);
			if (fNodeIdInList != FALSE) {	// own nodeid in list
				// send event to process command
				NmtEvent = kEplNmtEventSwReset;
			}
			break;
		}

		//------------------------------------------------------------------------
		// NMT managing commands

		// TODO: add functions to process managing command (optional)

	case kEplNmtCmdNetHostNameSet:
		{
			break;
		}

	case kEplNmtCmdFlushArpEntry:
		{
			break;
		}

		//------------------------------------------------------------------------
		// NMT info services

		// TODO: forward event with infos to the application (optional)

	case kEplNmtCmdPublishConfiguredCN:
		{
			break;
		}

	case kEplNmtCmdPublishActiveCN:
		{
			break;
		}

	case kEplNmtCmdPublishPreOperational1:
		{
			break;
		}

	case kEplNmtCmdPublishPreOperational2:
		{
			break;
		}

	case kEplNmtCmdPublishReadyToOperate:
		{
			break;
		}

	case kEplNmtCmdPublishOperational:
		{
			break;
		}

	case kEplNmtCmdPublishStopped:
		{
			break;
		}

	case kEplNmtCmdPublishEmergencyNew:
		{
			break;
		}

	case kEplNmtCmdPublishTime:
		{
			break;
		}

		//-----------------------------------------------------------------------
		// error from MN
		// -> requested command not supported by MN
	case kEplNmtCmdInvalidService:
		{

			// TODO: errorevent to application
			break;
		}

		//------------------------------------------------------------------------
		// default
	default:
		{
			Ret = kEplNmtUnknownCommand;
			goto Exit;
		}

	}			// end of switch(NmtCommand)

	if (NmtEvent != kEplNmtEventNoEvent) {
		if (EplNmtCnuInstance_g.m_pfnCheckEventCb != NULL) {
			Ret = EplNmtCnuInstance_g.m_pfnCheckEventCb(NmtEvent);
			if (Ret == kEplReject) {
				Ret = kEplSuccessful;
				goto Exit;
			} else if (Ret != kEplSuccessful) {
				goto Exit;
			}
		}
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
		Ret = EplNmtuNmtEvent(NmtEvent);
#endif
	}

      Exit:
	return Ret;

}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuGetNmtCommand()
//
// Description: returns the NMT-Command from the frame
//
//
//
// Parameters:      pFrameInfo_p = pointer to the Frame
//                                 with the NMT-Command
//
//
// Returns:         tEplNmtCommand = NMT-Command
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplNmtCommand EplNmtCnuGetNmtCommand(tEplFrameInfo * pFrameInfo_p)
{
	tEplNmtCommand NmtCommand;
	tEplNmtCommandService *pNmtCommandService;

	pNmtCommandService =
	    &pFrameInfo_p->m_pFrame->m_Data.m_Asnd.m_Payload.
	    m_NmtCommandService;

	NmtCommand =
	    (tEplNmtCommand) AmiGetByteFromLe(&pNmtCommandService->
					      m_le_bNmtCommandId);

	return NmtCommand;
}

//---------------------------------------------------------------------------
//
// Function:    EplNmtCnuNodeIdList()
//
// Description: check if the own nodeid is set in EPL Node List
//
//
//
// Parameters:      pbNmtCommandDate_p = pointer to the data of the NMT Command
//
//
// Returns:         BOOL = TRUE if nodeid is set in EPL Node List
//                         FALSE if nodeid not set in EPL Node List
//
//
// State:
//
//---------------------------------------------------------------------------
static BOOL EplNmtCnuNodeIdList(u8 * pbNmtCommandDate_p)
{
	BOOL fNodeIdInList;
	unsigned int uiByteOffset;
	u8 bBitOffset;
	u8 bNodeListByte;

	// get byte-offset of the own nodeid in NodeIdList
	// devide though 8
	uiByteOffset = (unsigned int)(EplNmtCnuInstance_g.m_uiNodeId >> 3);
	// get bitoffset
	bBitOffset = (u8) EplNmtCnuInstance_g.m_uiNodeId % 8;

	bNodeListByte = AmiGetByteFromLe(&pbNmtCommandDate_p[uiByteOffset]);
	if ((bNodeListByte & bBitOffset) == 0) {
		fNodeIdInList = FALSE;
	} else {
		fNodeIdInList = TRUE;
	}

	return fNodeIdInList;
}

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

// EOF