/************************************************************************************/
/*! \file  commTest.c
    \brief Contains the communications test structure.

   The communications test routine is for testing out the speed & accuracy of
   MDSP->SDSP communications.
*/
#include <std.h>      /* must be included 1st */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "resources.h"
#include "comRegDfns.h"
#include "simulation.h"
#include "commRegs.h"
#include "commTest.h"

#define DAS_BLINKEN_LICHT

#pragma CODE_SECTION(sdspCommTest,     "xcode");

#pragma CODE_SECTION(sdspCommTest_i1,   "icode");
#pragma CODE_SECTION(sdspCommTest_i2,   "icode");
#pragma CODE_SECTION(sdspCommTest_i3,   "icode");
#pragma CODE_SECTION(sdspCommTest_i4,   "icode");
#pragma CODE_SECTION(sdspCommTest_i5,   "icode");
#pragma CODE_SECTION(sdspCommTest_i6,   "icode");
#pragma CODE_SECTION(sdspCommTest_i7,   "icode");

#pragma CODE_SECTION(sdspCommTest_x1,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x2,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x3,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x4,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x5,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x6,   "xcode");
#pragma CODE_SECTION(sdspCommTest_x7,   "xcode");


extern char genStr[];
extern TIMER_Handle timer1;  /* general purpose timer, started in main() */

// B: simple extern access.
// C: extern access to idata section, D: extern access to external memory
extern     SdspRegTest sdspRegsB[N_SDSP]; 
extern far SdspRegTest sdspRegsC[N_SDSP], sdspRegsD[N_SDSP];

//Local structures:
SdspRegTest sdspRegsA[N_SDSP];

int32 sdspCommTest_i1(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i2(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i3(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i4(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i5(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i6(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_i7(void *ptr, void *sdspRegs, uint32 ntimes);

int32 sdspCommTest_x1(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x2(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x3(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x4(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x5(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x6(void *ptr, void *sdspRegs, uint32 ntimes);
int32 sdspCommTest_x7(void *ptr, void *sdspRegs, uint32 ntimes);

/************************************************************************************
 *  sdspCommTest:
 *
 *   synopsis: Tests the communications between the MDSP and SDSPs. The test is
 *             primarily for speed of communications- testing the effects of code
 *      and data placement & access on the speed of the communications. It is used
 *      to optimize MDSP routines where code size & speed must be balanced. Generally
 *      the access is to & from the communications registers; any valid	SDSP address
 *      can be used though.The speed is reported at the end, and is visible on the
 *      oscilloscope if the LEDs are compiled in.
 *
 *   author: Douglas Ferguson 
 ************************************************************************************/
int32 sdspCommTest(void *ptr) {
	int32 returnCode= SUCCESS, status;
	uint32   t0, dt, i, nTimes[2];
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs;
	int32 (*testFxn)(void *ptr, void *sRegs, uint32 nTimes)= NULL;

	if      (commTest->sdspSect == 0) sdspRegs= &sdspRegsA[0];  //local.
	else if (commTest->sdspSect == 1) sdspRegs= &sdspRegsB[0];  //extern
	else if (commTest->sdspSect == 2) sdspRegs= &sdspRegsC[0];  //extern idata
	else if (commTest->sdspSect == 3) sdspRegs= &sdspRegsD[0];  //extern xpdata

	if (commTest->nWords >= N_COMM_TEST_REGS) {
		newError(&returnCode, PARAM_ERROR, FATAL_ERR, "sdspCommTest",
		 "Too many SDSP registers.", __FILE__, __LINE__);
		return returnCode;
	}

	if (commTest->codePos == 0) {
			if      (commTest->codeType == 1) testFxn= sdspCommTest_i1;
			else if (commTest->codeType == 2) testFxn= sdspCommTest_i2;
			else if (commTest->codeType == 3) testFxn= sdspCommTest_i3;
			else if (commTest->codeType == 4) testFxn= sdspCommTest_i4;
			else if (commTest->codeType == 5) testFxn= sdspCommTest_i5;
			else if (commTest->codeType == 6) testFxn= sdspCommTest_i6;
			else if (commTest->codeType == 7) testFxn= sdspCommTest_i7;
	}
	else if (commTest->codePos == 1) {
			if      (commTest->codeType == 1) testFxn= sdspCommTest_x1;
			else if (commTest->codeType == 2) testFxn= sdspCommTest_x2;
			else if (commTest->codeType == 3) testFxn= sdspCommTest_x3;
			else if (commTest->codeType == 4) testFxn= sdspCommTest_x4;
			else if (commTest->codeType == 5) testFxn= sdspCommTest_x5;
			else if (commTest->codeType == 6) testFxn= sdspCommTest_x6;
			else if (commTest->codeType == 7) testFxn= sdspCommTest_x7;
	}

	if (testFxn == NULL) {
		newError(&returnCode, PARAM_ERROR, FATAL_ERR, "sdspCommTest",
		 "Function does not exist.", __FILE__, __LINE__);
		return returnCode;
	}


	//The SDSP address is not tested for errors since if it's a bad input the FPGA
	//code will simply ignore it.

	//Note: sdspRegs is a pointer, so &sdspRegs => the *pointer's* address...
	setMem((uint32 *) sdspRegs, N_SDSP*SIZEOF(SdspRegTest), 0); //Clear the buffer.

	if (commTest->intLoop) {nTimes[0]= 1;  nTimes[1]= commTest->nTimes; } //int. loop
	else                   {nTimes[1]= 1;  nTimes[0]= commTest->nTimes; } //ext. loop

	t0= TIMER_getCount(timer1);

	for (i=0; i<nTimes[0]; ++i) {
		status= testFxn(ptr, sdspRegs, nTimes[1]);
		//if (status != SUCCESS) break;
	}

	dt= delta_t(t0);
	sprintf(genStr, "Communication Test delta-t: %d (10ths us).\n", dt);
	newInformation(__FILE__, __LINE__, genStr);
	WRITE_REG(RESERVED_REG_8, dt);	

	if (status != SUCCESS) returnCode= status;

	return returnCode;
}	

uint32 getSdspReg(Uint32 sdsp, Uint32 addr); //dpsf: move to fxnProto.h
/************************************************************************************/
int32 sdspCommTest_i1(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspReg(sdsp, addr);
			}	
		}	
	} //Fxn. body loop

	return status;
}	

/************************************************************************************/
int32 sdspCommTest_x1(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspReg(sdsp, addr);
			}	
		}	
	} //Fxn. body loop

	return status;
}	




/************************************************************************************/
int32 sdspCommTest_i2(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI(sdsp, addr);
			}	
		}	
	} //Fxn. body loop

	return status;
}	

/************************************************************************************/
int32 sdspCommTest_x2(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI(sdsp, addr);
			}	
		}	
	} //Fxn. body loop

	return status;
}	



/************************************************************************************/
int32 sdspCommTest_i3(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI2(sdsp, addr);
			}	
		}	



	} //Fxn. body loop

	return status;
}	

/************************************************************************************/
int32 sdspCommTest_x3(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI2(sdsp, addr);
			}	
		}	



	} //Fxn. body loop

	return status;
}	


/************************************************************************************/
int32 sdspCommTest_i4(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI3(sdsp, addr);
			}	
		}	



	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_x4(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			for (addr= commTest->sdspAddr, i=0; i<commTest->nWords; ++i, addr+=4) {
				sdspRegs[sdsp]->reg[i]= getSdspRegI3(sdsp, addr);
			}	
		}	



	} //Fxn. body loop

	return status;
}	

/************************************************************************************/
int32 sdspCommTest_i5(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSlvBlock(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_x5(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSlvBlock(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_i6(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSdspBlockI(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_x6(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSdspBlockI(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_i7(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSdspBlockI2(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}

/************************************************************************************/
int32 sdspCommTest_x7(void *ptr, void *sRegs, uint32 nTimes) {
	int32 status= SUCCESS;
	uint32 sdsp, i, loop, addr, *mdspPtr, *sdspPtr;
	CommTest *commTest= ptr;
	SdspRegTest *sdspRegs[4];
	
	//The internal vs. external loops measure function calling overhead.
	for (loop=0; loop<nTimes; ++loop) {
		for (i=0; i<N_SDSP; ++i) sdspRegs[i]= (SdspRegTest *) sRegs +i;
	
		for (sdsp=0; sdsp<N_SDSP; ++sdsp) {
			if (!(commTest->slvBits & (1<<sdsp))) continue;
	
			mdspPtr= (uint32 *) &sdspRegs[sdsp]->reg[0];
			sdspPtr= (uint32 *) commTest->sdspAddr;
			readSdspBlockI2(sdsp, sdspPtr, mdspPtr, commTest->nWords);
		}	
	} //Fxn. body loop

	return status;
}