/******************************************************************************
 * 
 *  Title  : primFunc_memoryTest.c 
 *  Version 0.0
 *   
 *  Description: memory test primitive function.    
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>
#include "primFunc_memoryTest.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_memoryTest()
 *=============================================================================
 *
 *	  Mem test primitive function
 *
 */
ERROR_ID primFunction_memoryTest(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[500];
	int status;

	struct MEMORY_TEST_IN *memTest=&primTable->params.memoryTest;
	struct MEMORY_TEST_OUT *memTestOut;  
	char subdir[PATHNAME_LENGTH];
	const int panel=global.panel.primEdit[getPrimArrayId(MEMORY_TEST)];
	
	struct HOST *host;
	int i;
	unsigned int listIndex;

		
	if(R_MEMORY_TEST!=R_MEMORY_TEST_HOST){  // 
		ERROR_CHECK(PROGRAM_ERROR, primitive MEMORY_TEST - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){
		case PRIM_PANEL_TO_TABLE:
		
			GetCtrlVal(panel, MEM_TEST_START_ADDR, (UINT32*)&memTest->start);
			GetCtrlVal(panel, MEM_TEST_SIZE, &memTest->size);
			GetCtrlVal(panel, MEM_TEST_ERRORS, &memTest->errorsBeforeFail); 
			GetCtrlVal(panel, MEM_TEST_CONTINUE, &memTest->continueOnError); 
			GetCtrlVal(panel, MEM_TEST_NREADS, &memTest->nReads); 
			GetCtrlVal(panel, MEM_TEST_DMAFLAG, &memTest->dmaFlag); 
			
			for(i=0; i<6; ++i){
				status=GetTableCellVal (panel, MEM_TEST_REPETITIONS, MakePoint(1,i+1), &(memTest->repetitions[i]));
				UIR_STATUS_CHECK(status, GetTableCellVal());  
			}	
			
			/* NO BREAK HERE!!!*/
		case PRIM_PARAMS_TO_TABLE:				
			/* add table headers - don't set indexes!!! */  
			primTable->inPrimHeader.length=SIZEOF(struct MEMORY_TEST_IN)+SIZEOF(struct MSG_HEAD); 
			primTable->inPrimHeader.id=MEMORY_TEST;
			primTable->inPrimHeader.primRevision=R_MEMORY_TEST; 
			/* reply data length */
			primTable->replyLength=SIZEOF(struct MEMORY_TEST_OUT)+SIZEOF(struct MSG_HEAD);
	  		break;
		
		case PRIM_TABLE_TO_PANEL:
			if(primTable->inPrimHeader.primRevision!=R_MEMORY_TEST){  
				ERROR_CHECK(PROGRAM_ERROR, primitive MEMORY_TEST - wrong revision number);
				return(PROGRAM_ERROR);
			}
			
			SetCtrlVal(panel, MEM_TEST_START_ADDR, (unsigned int) memTest->start);
			SetCtrlVal(panel, MEM_TEST_SIZE, memTest->size);
			SetCtrlVal(panel, MEM_TEST_ERRORS, memTest->errorsBeforeFail); 
			SetCtrlVal(panel, MEM_TEST_CONTINUE, memTest->continueOnError);
			SetCtrlVal(panel, MEM_TEST_NREADS, memTest->nReads); 
			SetCtrlVal(panel, MEM_TEST_DMAFLAG, memTest->dmaFlag); 
			
			for(i=0; i<6; ++i){
				status=SetTableCellVal (panel, MEM_TEST_REPETITIONS, MakePoint(1,i+1), memTest->repetitions[i]);
				UIR_STATUS_CHECK(status, SetTableCellVal());  
			}	
			

			break;
		case PRIM_BUILD:
 			/* copy data */
			*(struct MEMORY_TEST_IN*)(primDataPtr)=*memTest;
		
 			break;
 
		case REP_DATA_PROCESS:
		
			host=global.host[HOST_INDEX(slotNumber)];
			
			SetCtrlVal(host->panel.parent, ROD_MEM_TEST_TIME, TimeStr());
			listIndex=host->listTable.inListHeader.index;
			SetCtrlVal(host->panel.parent, ROD_MEM_TEST_INDEX, listIndex);
			SetCtrlVal(host->panel.parent, ROD_MEM_TEST_START, (unsigned int)memTest->start);
			SetCtrlVal(host->panel.parent, ROD_MEM_TEST_SIZE, memTest->size);  
			
			memTestOut=(struct MEMORY_TEST_OUT*)(primDataPtr);
			
			SetCtrlVal(host->panel.parent, ROD_MEM_TEST_RETURN_CODE, memTestOut->returnCode); 
			
			if(memTestOut->returnCode!=0){ /* not success */
				sprintf(errorMessage,"MemoryTest error(returnCode=0x%X)!!!", memTestOut->returnCode);
				hostError(__FILE__,__LINE__, REPLIST_ERROR, host, errorMessage);
				return(REPLIST_ERROR);
			}
			
			break;

		case WRITE_TO_FILE:
		
			file=(FILE*)inputParameter;
			
  			fprintf(file, "*start= 0x%X, size= 0x%X\n", (UINT32)memTest->start, memTest->size); 
  			fprintf(file, "repetitions[]={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n", 
  				memTest->repetitions[0], memTest->repetitions[1], memTest->repetitions[2],
  				memTest->repetitions[3], memTest->repetitions[4], memTest->repetitions[5]);
  			fprintf(file, "errorsBeforeFail= 0x%X, continueOnError= %d, nReads= 0x%X, dmaFlag= %d\n", 
  				memTest->errorsBeforeFail, memTest->continueOnError, memTest->nReads, memTest->dmaFlag); 	
		
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
			status=fscanf(file, "*start= 0x%X, size= 0x%X\n", (UINT32*)&memTest->start, &memTest->size);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}			
  			status=fscanf(file, "repetitions[]={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n", 
  				&memTest->repetitions[0], &memTest->repetitions[1], &memTest->repetitions[2],
  				&memTest->repetitions[3], &memTest->repetitions[4], &memTest->repetitions[5]);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}			
  			status=fscanf(file, "errorsBeforeFail= 0x%X, continueOnError= %d, nReads= 0x%X, dmaFlag= %d\n", 
  				&memTest->errorsBeforeFail, &memTest->continueOnError, &memTest->nReads, &memTest->dmaFlag); 
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}			
         	
			break;
		
		default: ;	
 	}

	return(SUCCESS);	
			
}

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