/******************************************************************************
 *
 *  Title  : primFunc_RWSlaveMemory.c
 *  Version 0.0,
 *
 *  Description: RW slave DSP memory primitive function.
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>
#include "primFunc_RWSlaveMemory.h"
#include "globalDefinitions.h"
#include "uirUtility.h"
#include "primParamsUir.h"
#include "mainUir.h"
#include <utility.h>
#include "primFunctionInit.h"
#include "RWlists.h"

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

/*=============================================================================
 *                              primFunction_RWSlaveMemory()
 *=============================================================================
 *
 *	   RW slave DSP memory primitive function
 *
 */
ERROR_ID primFunction_RWSlaveMemory(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;
	unsigned int fileSize;

	UINT32 primBodyLength;
	UINT32 primitiveId;

	struct PRIM_RW_SLAVE_MEMORY_PARAMS *RWSlaveMemory=&primTable->params.RWSlaveMemory;
	const int panel=global.panel.primEdit[getPrimArrayId(RW_SLAVE_MEMORY)];
	UINT32 i;
	UINT32 dataLength;
	struct RW_SLAVE_MEMORY_IN *RWSlaveMemoryIn;
	struct HOST *host;
	char textMessage[200];
	char errorText[100];
	UINT32 listIndex;
	int ringIndex;
	int paramsLength;
	int outFileOption;
	char fileName[PATHNAME_LENGTH];
	UINT32 maxLength;


	if(R_RW_SLAVE_MEMORY!=R_RW_SLAVE_MEMORY_HOST){
		ERROR_CHECK(PROGRAM_ERROR, primitive RW_SLAVE_MEMORY - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){
		case PRIM_PANEL_TO_TABLE:

			GetCtrlVal(panel, RW_SLAVE_SLV_ID, &RWSlaveMemory->inputParams.slaveNumber);
			GetCtrlVal(panel, RW_SLAVE_START_ADDRESS, (UINT32*)&RWSlaveMemory->inputParams.slaveAddress);
			GetCtrlVal(panel, RW_SLAVE_NUM_WORDS, &RWSlaveMemory->inputParams.numWords);

			GetCtrlVal(panel, RW_SLAVE_READ_NOT_WRITE, &RWSlaveMemory->inputParams.readNotWrite);

			if(RWSlaveMemory->inputParams.readNotWrite==1){ /* read */
				GetCtrlVal(panel, RW_SLAVE_OUTPUT_OPT, &outFileOption);
				if(outFileOption){
					GetCtrlVal(panel, RW_SLAVE_OUT_FILE, RWSlaveMemory->dataFileName);
					GetCtrlVal(panel, RW_SLAVE_WRITE_OR_APPEND, &RWSlaveMemory->appendNotWrite);
				} else {
					RWSlaveMemory->dataFileName[0]=0;
				}
			}else{ /* write */
				GetCtrlVal(panel, RW_SLAVE_INP_FILE, RWSlaveMemory->dataFileName);
				if(RWSlaveMemory->dataFileName[0]==0){
					status=MessagePopup ("WARNING", "Select input data!");
					UIR_STATUS_CHECK(status, MessagePopup());
					return(PROGRAM_ERROR);
				};
			};

			RWSlaveMemory->inputParams.masterAddress=(UINT32*)DEFAULT; /* list in primBuff !!!!! */

			/* NO BREAK HERE!!!*/
		case PRIM_PARAMS_TO_TABLE:
			/* add table headers - don't set indexes!!! */
			/* minus *slaveData!!!*/
			paramsLength=SIZEOF(struct MSG_HEAD)+SIZEOF(struct RW_SLAVE_MEMORY_IN);

			if(RWSlaveMemory->inputParams.readNotWrite==0){ /* write */
			    primTable->inPrimHeader.length=paramsLength+RWSlaveMemory->inputParams.numWords;
			    primTable->replyLength=0;
			}else{	/* read */
			    primTable->inPrimHeader.length=paramsLength;
			    primTable->replyLength=SIZEOF(struct MSG_HEAD)+RWSlaveMemory->inputParams.numWords;
			}

			primTable->inPrimHeader.id=RW_SLAVE_MEMORY;
			primTable->inPrimHeader.primRevision=R_RW_SLAVE_MEMORY;

	  		break;

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

			SetCtrlVal(panel, RW_SLAVE_SLV_ID, RWSlaveMemory->inputParams.slaveNumber);
			SetCtrlVal(panel, RW_SLAVE_START_ADDRESS, (UINT32)RWSlaveMemory->inputParams.slaveAddress);
			SetCtrlVal(panel, RW_SLAVE_NUM_WORDS, RWSlaveMemory->inputParams.numWords);
			SetCtrlVal(panel, RW_SLAVE_NUM_BYTES, RWSlaveMemory->inputParams.numWords*4);
			SetCtrlVal(panel, RW_SLAVE_READ_NOT_WRITE, RWSlaveMemory->inputParams.readNotWrite);

			if(RWSlaveMemory->inputParams.readNotWrite==1){ /* read */
				status=SetCtrlAttribute(panel, RW_SLAVE_NUM_WORDS, ATTR_FRAME_COLOR, 0xCC9966);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				status=SetCtrlAttribute(panel, RW_SLAVE_NUM_WORDS, ATTR_CTRL_MODE, VAL_NORMAL);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());

				SetCtrlVal(panel, RW_SLAVE_OUT_FILE, RWSlaveMemory->dataFileName);
				SetCtrlVal(panel, RW_SLAVE_WRITE_OR_APPEND, RWSlaveMemory->appendNotWrite);
				SetCtrlVal(panel, RW_SLAVE_INP_FILE, 0);
				status=SetInputMode(panel, RW_SLAVE_INP_FILE, 0);
				UIR_STATUS_CHECK(status, SetInputMode());

				if(RWSlaveMemory->dataFileName[0]==0){
					SetCtrlVal(panel, RW_SLAVE_OUTPUT_OPT, 0);
					status=SetInputMode(panel, RW_SLAVE_OUT_FILE, 0);
					UIR_STATUS_CHECK(status, SetInputMode());
				}else{
					SetCtrlVal(panel, RW_SLAVE_OUTPUT_OPT, 1);
					status=SetInputMode(panel, RW_SLAVE_OUT_FILE, 1);
					UIR_STATUS_CHECK(status, SetInputMode());
				}
				status=SetInputMode(panel, RW_SLAVE_OUTPUT_OPT, 1);
				UIR_STATUS_CHECK(status, SetInputMode());

				status=SetInputMode(panel, RW_SLAVE_WRITE_OR_APPEND, 1);
				UIR_STATUS_CHECK(status, SetInputMode());


			}else{ /* write */
				status=SetCtrlAttribute(panel, RW_SLAVE_NUM_WORDS, ATTR_CTRL_MODE, VAL_INDICATOR);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				status=SetCtrlAttribute(panel, RW_SLAVE_NUM_WORDS, ATTR_FRAME_COLOR, VAL_LT_GRAY);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());

				status=SetInputMode(panel, RW_SLAVE_INP_FILE, 1);
				UIR_STATUS_CHECK(status, SetInputMode());
				SetCtrlVal(panel, RW_SLAVE_INP_FILE, RWSlaveMemory->dataFileName);

				SetCtrlVal(panel, RW_SLAVE_OUTPUT_OPT, 0);
				status=SetInputMode(panel, RW_SLAVE_OUTPUT_OPT, 0);
				UIR_STATUS_CHECK(status, SetInputMode());
				SetCtrlVal(panel, RW_SLAVE_OUT_FILE, 0);
				status=SetInputMode(panel, RW_SLAVE_OUT_FILE, 0);
				UIR_STATUS_CHECK(status, SetInputMode());

				status=SetInputMode(panel, RW_SLAVE_WRITE_OR_APPEND, 0);
				UIR_STATUS_CHECK(status, SetInputMode());


			}
			break;
		case PRIM_BUILD:
			 maxLength=inputParameter; /* !!! */
		
 			/* copy params */
			paramsLength=sizeof(struct RW_SLAVE_MEMORY_IN);
			memcpy(primDataPtr, &RWSlaveMemory->inputParams, paramsLength);
			/* copy data */
			if(RWSlaveMemory->inputParams.readNotWrite==0){ /* write */
				primDataPtr+=(paramsLength/sizeof(UINT32));

				/*	check file size again */
				errorId=getFileSize (RWSlaveMemory->dataFileName, &fileSize);
				ERROR_CHECK(errorId, getFileSize());
				if(errorId!=SUCCESS) return(errorId);

				if(RWSlaveMemory->inputParams.numWords!=fileSize){
				 	RWSlaveMemory->inputParams.numWords=(fileSize+3)/4;
				 	if((fileSize%4)!=0){
				 		ERROR_CHECK(PROGRAM_ERROR, "File size not aligned on word boundary!");
				 	}

					paramsLength=SIZEOF(struct RW_SLAVE_MEMORY_IN)+SIZEOF(struct MSG_HEAD);
					/* +3 byte to word alignment!!! */
					paramsLength+=RWSlaveMemory->inputParams.numWords;
					primTable->inPrimHeader.length=paramsLength;
					primHeader->length=primTable->inPrimHeader.length;
				}

		 		if(primTable->inPrimHeader.length>maxLength){
		 			ERROR_CHECK(PROGRAM_ERROR, Load slave mem prim - length exceeded!);
		 			return(PROGRAM_ERROR);
		 		}

		 		errorId=readFromBinFile(RWSlaveMemory->dataFileName, primDataPtr, sizeof(UINT32)*RWSlaveMemory->inputParams.numWords);
		 		ERROR_CHECK(errorId, readFromBinFile());
		 		if(errorId!=SUCCESS) return(errorId);
		 	}

 			break;

		case REP_DATA_PROCESS:

			host=global.host[HOST_INDEX(slotNumber)];

			if(RWSlaveMemory->inputParams.readNotWrite==1){ /* read */
				if(RWSlaveMemory->dataFileName[0]!=0){
					/* save reply data to file */
					strcpy(fileName, host->dataDir);
					strcat(fileName, RWSlaveMemory->dataFileName);
					errorId=writeToBinFile(fileName, RWSlaveMemory->appendNotWrite, primDataPtr, sizeof(UINT32)*RWSlaveMemory->inputParams.numWords);
					ERROR_CHECK(errorId, writeToBinFile());
					if(errorId!=SUCCESS) return(errorId);
				}
			}

			break;
		
		case WRITE_TO_FILE:

			file=(FILE*)inputParameter;
			
  			fprintf(file, "slaveNumber= %d, readNotWrite= %d, *slaveAddress= 0x%X, *masterAddress= 0x%X, numWords= 0x%X\n",
  				RWSlaveMemory->inputParams.slaveNumber, RWSlaveMemory->inputParams.readNotWrite,
  				(UINT32)RWSlaveMemory->inputParams.slaveAddress, (UINT32)RWSlaveMemory->inputParams.masterAddress,
  				RWSlaveMemory->inputParams.numWords); 
  			fprintf(file, "dataFileName[]= %s\n", RWSlaveMemory->dataFileName); 
  			if(RWSlaveMemory->inputParams.readNotWrite){
  				fprintf(file, "appendNotWrite= %d\n", RWSlaveMemory->appendNotWrite);
  			}	
		
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
  			status=fscanf(file, "slaveNumber= %d, readNotWrite= %d, *slaveAddress= 0x%X, *masterAddress= 0x%X, numWords= 0x%X\n",
  				&RWSlaveMemory->inputParams.slaveNumber, &RWSlaveMemory->inputParams.readNotWrite,
  				(UINT32*)&RWSlaveMemory->inputParams.slaveAddress, (UINT32*)&RWSlaveMemory->inputParams.masterAddress,
  				&RWSlaveMemory->inputParams.numWords); 
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}		
  			status=readLineFromIndex(file, strlen("dataFileName[]= "), PATHNAME_LENGTH, RWSlaveMemory->dataFileName);
  			if(status!=0) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
  			if(RWSlaveMemory->inputParams.readNotWrite){
  				status=fscanf(file, "appendNotWrite= %d\n", &RWSlaveMemory->appendNotWrite);
  				if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
  			}	
         	
			break;	

		default: ;
 	}

	return(SUCCESS);

}

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