/******************************************************************************
 *
 *  Title  : primFunc_eventTrapSetup.c
 *  Version 0.0,
 *
 *  Description: Event trap setup primitive function.
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

/******************************************************************************
 *                              Header files                                  *
 ******************************************************************************/

#include <stdio.h>
#include "primFunc_eventTrapSetup.h"
#include "fileUtility.h"
#include "globalDefinitions.h"
#include "uirUtility.h"
#include "primParamsUir.h"
#include "mainUir.h"
#include <utility.h>
#include "primFunctionInit.h"

/******************************************************************************
 *                              Global functions                              *
 ******************************************************************************/

/*=============================================================================
 *                              primFunction_eventTrapSetup()
 *=============================================================================
 *
 *
 *
 */
ERROR_ID primFunction_eventTrapSetup(PRIM_FUNC_OPTION funcOption, struct PRIM_TABLE *primTable, void *primitive, UINT32 inputParameter, UINT8 slotNumber){


	FILE *file;
	
	struct MSG_HEAD* primHeader=(struct MSG_HEAD*) primitive;
	UINT32 *primDataPtr=(UINT32*)((UINT32)primHeader+sizeof(struct MSG_HEAD));

	ERROR_ID errorId=SUCCESS;
	char errorMessage[200];
	int status;

	UINT32 primBodyLength;
	UINT32 primitiveId;

	struct EVENT_TRAP_SETUP_IN *eventTrapSetup=&primTable->params.eventTrapSetup;
	const int panel=global.panel.primEdit[getPrimArrayId(EVENT_TRAP_SETUP)];
	UINT32 i;
	UINT32 dataLength;
	struct EVENT_TRAP_SETUP_OUT *eventTrapSetupOut;
	struct HOST *host;
	char textMessage[200];
	char errorText[100];
	UINT32 listIndex;
	int slave;

	if(R_EVENT_TRAP_SETUP!=R_EVENT_TRAP_SETUP_HOST){
		ERROR_CHECK(PROGRAM_ERROR, primitive EVENT_TRAP_SETUP - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){
		case PRIM_PANEL_TO_TABLE:
			eventTrapSetup->slvBits=0;
			GetCtrlVal(panel, EVENT_TRAP_SLV0, &slave);
			if(slave) SET_BIT(eventTrapSetup->slvBits, 0); 
			GetCtrlVal(panel, EVENT_TRAP_SLV1, &slave);
			if(slave) SET_BIT(eventTrapSetup->slvBits, 1);
			GetCtrlVal(panel, EVENT_TRAP_SLV2, &slave);
			if(slave) SET_BIT(eventTrapSetup->slvBits, 2);
			GetCtrlVal(panel, EVENT_TRAP_SLV3, &slave);
			if(slave) SET_BIT(eventTrapSetup->slvBits, 3);
			
			GetCtrlVal(panel, EVENT_TRAP_NUM_EVENTS, &eventTrapSetup->numberOfEvents);
			GetCtrlVal(panel, EVENT_TRAP_TIMEOUT, &eventTrapSetup->timeoutInUsec);
			GetCtrlVal(panel, EVENT_TRAP_EXT_ROUT_SET, &eventTrapSetup->extRouterSetup);
			GetCtrlVal(panel, EVENT_TRAP_DISTRIBUTE, &eventTrapSetup->distribute);
			GetCtrlVal(panel, EVENT_TRAP_RELEASE, &eventTrapSetup->releaseFrames);
			GetCtrlVal(panel, EVENT_TRAP_PERMIT_BP, &eventTrapSetup->permitBackPressure); 
			GetCtrlVal(panel, EVENT_TRAP_DATA_MODE, &eventTrapSetup->dataMode);  
			GetCtrlVal(panel, EVENT_TRAP_SLINK, &eventTrapSetup->sLink);
			GetCtrlVal(panel, EVENT_TRAP_STRAY, &eventTrapSetup->trapStray);
			GetCtrlVal(panel, EVENT_TRAP_FORMAT, &eventTrapSetup->format);
			GetCtrlVal(panel, EVENT_TRAP_ITER_LIMIT, &eventTrapSetup->iterLimit);  
			GetCtrlVal(panel, EVENT_TRAP_CFG0, &eventTrapSetup->trapConfig[0]); 
			GetCtrlVal(panel, EVENT_TRAP_CFG1, &eventTrapSetup->trapConfig[1]);
			GetCtrlVal(panel, EVENT_TRAP_EXC_FLAG0, &eventTrapSetup->trapExclusionFlag[0]); 
			GetCtrlVal(panel, EVENT_TRAP_EXC_FLAG1, &eventTrapSetup->trapExclusionFlag[1]);  
			GetCtrlVal(panel, EVENT_TRAP_FUNC0, &eventTrapSetup->trapFunction[0]); 
			GetCtrlVal(panel, EVENT_TRAP_FUNC1, &eventTrapSetup->trapFunction[1]);  
			GetCtrlVal(panel, EVENT_TRAP_MATCH0, &eventTrapSetup->trapMatch[0]); 
			GetCtrlVal(panel, EVENT_TRAP_MATCH1, &eventTrapSetup->trapMatch[1]);  
			GetCtrlVal(panel, EVENT_TRAP_MOD0, &eventTrapSetup->trapModulus[0]); 
			GetCtrlVal(panel, EVENT_TRAP_MOD1, &eventTrapSetup->trapModulus[1]);  
			GetCtrlVal(panel, EVENT_TRAP_REM0, &eventTrapSetup->trapRemainder[0]); 
			GetCtrlVal(panel, EVENT_TRAP_REM1, &eventTrapSetup->trapRemainder[1]);

			/* NO BREAK HERE!!!*/
		case PRIM_PARAMS_TO_TABLE:
			/* add table headers - don't set indexes!!! */
			primTable->inPrimHeader.length=SIZEOF(struct EVENT_TRAP_SETUP_IN)+SIZEOF(struct MSG_HEAD);
			primTable->inPrimHeader.id=EVENT_TRAP_SETUP;
			primTable->inPrimHeader.primRevision=R_EVENT_TRAP_SETUP;

			primTable->replyLength=SIZEOF(struct EVENT_TRAP_SETUP_OUT)+SIZEOF(struct MSG_HEAD);

	  		break;

		case PRIM_TABLE_TO_PANEL:
			if(primTable->inPrimHeader.primRevision!=R_EVENT_TRAP_SETUP){
				ERROR_CHECK(PROGRAM_ERROR, primitive EVENT_TRAP_SETUP - wrong revision number);
				return(PROGRAM_ERROR);
			}

			SetCtrlVal(panel, EVENT_TRAP_SLV0, READ_BIT(eventTrapSetup->slvBits, 0));
			SetCtrlVal(panel, EVENT_TRAP_SLV1, READ_BIT(eventTrapSetup->slvBits, 1));  
			SetCtrlVal(panel, EVENT_TRAP_SLV2, READ_BIT(eventTrapSetup->slvBits, 2));  
			SetCtrlVal(panel, EVENT_TRAP_SLV3, READ_BIT(eventTrapSetup->slvBits, 3));  

			SetCtrlVal(panel, EVENT_TRAP_NUM_EVENTS, eventTrapSetup->numberOfEvents);
			SetCtrlVal(panel, EVENT_TRAP_TIMEOUT, eventTrapSetup->timeoutInUsec);
			SetCtrlVal(panel, EVENT_TRAP_EXT_ROUT_SET, eventTrapSetup->extRouterSetup);
			SetCtrlVal(panel, EVENT_TRAP_DISTRIBUTE, eventTrapSetup->distribute);
			SetCtrlVal(panel, EVENT_TRAP_RELEASE, eventTrapSetup->releaseFrames);
			SetCtrlVal(panel, EVENT_TRAP_PERMIT_BP, eventTrapSetup->permitBackPressure); 
			SetCtrlVal(panel, EVENT_TRAP_DATA_MODE, eventTrapSetup->dataMode);  
			SetCtrlVal(panel, EVENT_TRAP_SLINK, eventTrapSetup->sLink);
			SetCtrlVal(panel, EVENT_TRAP_STRAY, eventTrapSetup->trapStray);
			SetCtrlVal(panel, EVENT_TRAP_FORMAT, eventTrapSetup->format); 
			SetCtrlVal(panel, EVENT_TRAP_ITER_LIMIT, eventTrapSetup->iterLimit);  
			SetCtrlVal(panel, EVENT_TRAP_CFG0, eventTrapSetup->trapConfig[0]); 
			SetCtrlVal(panel, EVENT_TRAP_CFG1, eventTrapSetup->trapConfig[1]);
			SetCtrlVal(panel, EVENT_TRAP_EXC_FLAG0, eventTrapSetup->trapExclusionFlag[0]); 
			SetCtrlVal(panel, EVENT_TRAP_EXC_FLAG1, eventTrapSetup->trapExclusionFlag[1]);  
			SetCtrlVal(panel, EVENT_TRAP_FUNC0, eventTrapSetup->trapFunction[0]); 
			SetCtrlVal(panel, EVENT_TRAP_FUNC1, eventTrapSetup->trapFunction[1]);  
			SetCtrlVal(panel, EVENT_TRAP_MATCH0, eventTrapSetup->trapMatch[0]); 
			SetCtrlVal(panel, EVENT_TRAP_MATCH1, eventTrapSetup->trapMatch[1]);  
			SetCtrlVal(panel, EVENT_TRAP_MOD0, eventTrapSetup->trapModulus[0]); 
			SetCtrlVal(panel, EVENT_TRAP_MOD1, eventTrapSetup->trapModulus[1]);  
			SetCtrlVal(panel, EVENT_TRAP_REM0, eventTrapSetup->trapRemainder[0]); 
			SetCtrlVal(panel, EVENT_TRAP_REM1, eventTrapSetup->trapRemainder[1]);

			break;
		case PRIM_BUILD:
 			/* copy data */
			*(struct EVENT_TRAP_SETUP_IN*)(primDataPtr)=*eventTrapSetup;

 			break;

		//dpsf 20.07.06: ETS now simply returns an error via status regs. and aborts list like all other primitives.
		//
		//case REP_DATA_PROCESS:
		//
		//	eventTrapSetupOut=(struct EVENT_TRAP_SETUP_OUT*)(primDataPtr);
		//
		//	if(eventTrapSetupOut->errorCode!=SUCCESS){
		//		host=global.host[HOST_INDEX(slotNumber)];
		//		sprintf(errorText, "EVENT_TRAP_SETUP fail (errorCode=%d)!!!", eventTrapSetupOut->errorCode);
		//		hostError(__FILE__, __LINE__, REPLIST_ERROR, host, errorText);
		//		return(REPLIST_ERROR);
		//	}
		//
		//	break;
			
		case WRITE_TO_FILE:

			file=(FILE*)inputParameter;
			
  			fprintf(file, "slvBits= %d, numberOfEvents= 0x%X, timeoutInUsec= 0x%X\n",
  				eventTrapSetup->slvBits, eventTrapSetup->numberOfEvents, eventTrapSetup->timeoutInUsec); 
  			fprintf(file, "extRouterSetup= %d, distribute= %d, releaseFrames= %d, permitBackPressure= %d\n",
  				eventTrapSetup->extRouterSetup, eventTrapSetup->distribute, eventTrapSetup->releaseFrames, eventTrapSetup->permitBackPressure);
  			fprintf(file, "dataMode= %d, sLink= %d, format= %d, trapStray= %d, iterLimit= 0x%X\n",
  				eventTrapSetup->dataMode, eventTrapSetup->sLink, eventTrapSetup->format, eventTrapSetup->trapStray, eventTrapSetup->iterLimit);	
			fprintf(file, "trapConfig[]={ %d, %d }, trapExclusionFlag[]={ %d, %d }, trapFunction[]={ %d, %d }\n",
  				eventTrapSetup->trapConfig[0], eventTrapSetup->trapConfig[1],
  				eventTrapSetup->trapExclusionFlag[0], eventTrapSetup->trapExclusionFlag[1],
  				eventTrapSetup->trapFunction[0], eventTrapSetup->trapFunction[1]);	
  			fprintf(file, "trapMatch[]={ %d, %d }, trapModulus[]={ %d, %d }, trapFunction[]={ %d, %d }\n",
  				eventTrapSetup->trapMatch[0], eventTrapSetup->trapMatch[1],
  				eventTrapSetup->trapModulus[0], eventTrapSetup->trapModulus[1],
  				eventTrapSetup->trapRemainder[0], eventTrapSetup->trapRemainder[1]);	
		
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
			status=fscanf(file, "slvBits= %d, numberOfEvents= 0x%X, timeoutInUsec= 0x%X\n",
  				&eventTrapSetup->slvBits, &eventTrapSetup->numberOfEvents, &eventTrapSetup->timeoutInUsec); 
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  			
  			status=fscanf(file, "extRouterSetup= %d, distribute= %d, releaseFrames= %d, permitBackPressure= %d\n",
  				&eventTrapSetup->extRouterSetup, &eventTrapSetup->distribute, &eventTrapSetup->releaseFrames, &eventTrapSetup->permitBackPressure);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  			
  			status=fscanf(file, "dataMode= %d, sLink= %d, format= %d, trapStray= %d, iterLimit= 0x%X\n",
  				&eventTrapSetup->dataMode, &eventTrapSetup->sLink, &eventTrapSetup->format, &eventTrapSetup->trapStray, &eventTrapSetup->iterLimit);	
			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
			
			status=fscanf(file, "trapConfig[]={ %d, %d }, trapExclusionFlag[]={ %d, %d }, trapFunction[]={ %d, %d }\n",
  				&eventTrapSetup->trapConfig[0], &eventTrapSetup->trapConfig[1],
  				&eventTrapSetup->trapExclusionFlag[0], &eventTrapSetup->trapExclusionFlag[1],
  				&eventTrapSetup->trapFunction[0], &eventTrapSetup->trapFunction[1]);	
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  			
  			status=fscanf(file, "trapMatch[]={ %d, %d }, trapModulus[]={ %d, %d }, trapFunction[]={ %d, %d }\n",
  				&eventTrapSetup->trapMatch[0], &eventTrapSetup->trapMatch[1],
  				&eventTrapSetup->trapModulus[0], &eventTrapSetup->trapModulus[1],
  				&eventTrapSetup->trapRemainder[0], &eventTrapSetup->trapRemainder[1]);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}			
         	
			break;	

		default: ;
 	}

	return(SUCCESS);

}

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