int main(int argc, char *argv[])
{
volatile uint32_t* fpgaSpace;
int i,j;
ADMXRC2_HANDLE card = ADMXRC2_HANDLE_INVALID_VALUE;
unsigned long dataOut,dataIn;
A myclass;
myclass = admxrc_handle();
printf("====================\n" );
printf("Enter values for I/O\n" );
printf("====================\n" );
scanf("%lx", &dataOut);
fpgaSpace[0] = os_cpu_to_le32((uint32_t) dataOut);
wait(1);
dataIn = (unsigned long) os_le32_to_cpu(fpgaSpace[0]);
printf("In = %8.8lx, Out = %8.8lx\n",
(unsigned long) dataOut, (unsigned long) dataIn);
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return 0;
}
void clean_all(void){
if (rambuf != NULL) {
ADMXRC2_Free(rambuf);
}
if (chkbuf != NULL) {
ADMXRC2_Free(chkbuf);
}
if (dmaDesc1Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc1);
}
if (dmaDesc2Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc2);
}
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
}
int main(int argc, char *argv[])
{
int ret = 0;
const float mclk_freq = 33.0f;
ADMXRC2_STATUS status;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
ADMXRC2_BANK_INFO bankInfo, bankInfo2;
const char* filename;
Option options[8];
Arguments arguments;
float freq, min_freq, max_freq;
unsigned long i;
uint32_t sizeReg;
BOOLEAN dma;
BOOLEAN use64bit;
BOOLEAN speed;
unsigned long nrep;
BOOLEAN failed;
/* Set up expected options */
options[0].key = "banks";
options[0].type = Option_hex;
options[0].def.hexVal = 0xffffffff;
options[0].meaning = "bitmask of banks to test";
options[1].key = "card";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "ID of card to use";
options[2].key = "index";
options[2].type = Option_uint;
options[2].def.uintVal = 0;
options[2].meaning = "index of card to use";
options[3].key = "lclk";
options[3].type = Option_float;
options[3].def.floatVal = 33.0;
options[3].meaning = "local bus clock speed (MHz)";
options[4].key = "repeat";
options[4].type = Option_uint;
options[4].def.uintVal = 1;
options[4].meaning = "number of repetitions";
options[5].key = "speed";
options[5].type = Option_boolean;
options[5].def.booleanVal = TRUE;
options[5].meaning = "TRUE => measure access speed";
options[6].key = "usedma";
options[6].type = Option_boolean;
options[6].def.booleanVal = TRUE;
options[6].meaning = "TRUE => use 64 bit local bus";
options[7].key = "64";
options[7].type = Option_boolean;
options[7].def.booleanVal = FALSE;
options[7].meaning = "TRUE => use DMA for test";
arguments.nOption = 8;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("memtest", argc, argv, &arguments);
if (options[1].specified && options[2].specified) {
printf("*** Do not specify both /card and /index\n");
ret = -1;
goto done;
}
if (!options[2].specified) {
ADMXRC2_CARDID cardID = options[1].value.uintVal;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
} else {
unsigned int index = options[2].value.uintVal;
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
}
freq = options[3].value.floatVal;
nrep = options[4].value.uintVal;
speed = options[5].value.booleanVal;
dma = options[6].value.booleanVal;
use64bit = options[7].value.booleanVal;
/*
** Get card information, specifically for device fitted and
** number of SSRAM banks
*/
status = ADMXRC2_GetCardInfo(card, &cardInfo);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get card info: %s\n", ADMXRC2_GetStatusString(status));
return -1;
}
switch (cardInfo.BoardType) {
case ADMXRC2_BOARD_ADMXRC:
case ADMXRC2_BOARD_ADMXRC_P:
case ADMXRC2_BOARD_ADMXRC2_LITE:
min_freq = 25.0;
max_freq = 40.0;
break;
case ADMXRC2_BOARD_ADMXRC2:
min_freq = 24.0;
max_freq = 66.0;
break;
case ADMXRC2_BOARD_ADMXRC2_PRO_LITE:
min_freq = 24.0;
max_freq = 80.0;
break;
default:
printf("*** This example must be run on one of the following cards:\n\n");
printf("\tADM-XRC\n");
printf("\tADM-XRC-P\n");
printf("\tADM-XRCII-Lite\n");
printf("\tADM-XRCII\n");
printf("\tADM-XRCIIPro-Lite\n");
ret = -1;
goto done;
}
if (freq > max_freq || freq < min_freq) {
printf("*** LCLK frequency of %.1f MHz is not supported\n", freq);
ret = -1;
goto done;
}
if (use64bit && cardInfo.BoardType != ADMXRC2_BOARD_ADMXRC2_PRO_LITE) {
printf("*** 64-bit local bus is not supported on the specified card.\n");
ret = -1;
goto done;
}
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
if (!options[0].specified) {
bankTestMask = cardInfo.RAMBanksFitted;
} else {
bankTestMask = options[0].value.hexVal & cardInfo.RAMBanksFitted;
}
/*
** Check that the type, size, width etc. of each SSRAM bank
** is the same.
*/
numBank = 0;
testSize = 0;
for (i = 0; i < cardInfo.NumRAMBank; i++) {
status = ADMXRC2_GetBankInfo(card, i, &bankInfo2);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get bank %ld info: %s\n",
(unsigned long) i,
ADMXRC2_GetStatusString(status));
return -1;
}
if (!(bankInfo2.Type & (ADMXRC2_RAM_ZBTP | ADMXRC2_RAM_ZBTFT))) {
/* Ignore any banks that are not ZBT SSRAM */
continue;
}
if (!bankInfo2.Fitted) {
printf("*** Not all SSRAM banks are fitted - aborting.\n");
ret = -1;
goto done;
}
if (cardInfo.BoardType == ADMXRC2_BOARD_ADMXRC2_PRO_LITE && !use64bit) {
/*
** ADM-XPL ZBT bank width is 64 bits but the 32-bit version of design
** uses only the lower 32 bits of the ZBT bank.
*/
bankInfo2.Width = 32;
}
if (!numBank) {
memcpy(&bankInfo, &bankInfo2, sizeof(bankInfo));
bankSize = (bankInfo.Width / 8) * bankInfo.Size / 4;
} else {
if (bankInfo2.Type != bankInfo.Type ||
bankInfo2.Width != bankInfo.Width ||
bankInfo2.Size != bankInfo.Size) {
printf("*** Not all SSRAM banks are the same - aborting.\n");
ret = -1;
goto done;
}
}
numBank++;
if (bankTestMask & (0x1UL << i)) {
testSize += (bankInfo.Width / 8) * bankInfo.Size / 4;
}
}
if (!numBank) {
printf("*** No SSRAM banks found - aborting.\n");
ret = -1;
goto done;
}
/*
** Calculate memory size in longwords (32-bit words)
*/
memorySize = numBank * bankSize;
lastPageSize = memorySize & (pageSize - 1);
/*
** Determine value to program into the SIZE register in the FPGA
*/
switch (bankInfo.Size) {
case 128*1024:
sizeReg = 0;
break;
case 256*1024:
sizeReg = 1;
break;
case 512*1024:
sizeReg = 2;
break;
case 1024*1024:
sizeReg = 3;
break;
default:
printf("*** SSRAM of %ld words x %ld is not supported by this application\n",
(unsigned long) bankInfo.Size, (unsigned long) bankInfo.Width);
ret = -1;
goto done;
}
ssram = (volatile uint32_t*) (((uint8_t*) fpgaSpace) + ssramOffset);
rambuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (rambuf == NULL) {
printf("*** Failed to allocate RAM buffer - aborting\n");
ret = -1;
goto done;
}
chkbuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (chkbuf == NULL) {
printf("*** Failed to allocate RAM readback buffer - aborting\n");
ret = -1;
goto done;
}
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set LCLK to %.1fMHz: %s\n",
freq, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
if (cardInfo.BoardType != ADMXRC2_BOARD_ADMXRC2_PRO_LITE) {
status = ADMXRC2_SetClockRate(card, 1, mclk_freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set clock 1 to %.1fMHz: %s\n",
mclk_freq, ADMXRC2_GetStatusString(status));
return -1;
}
}
filename="/var/www/html/VirtualLabs/experiments/exp_3/bitfiles/user_configuration.bit";
status = ADMXRC2_ConfigureFromFile(card, filename);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to load the bitstream '%s': %s\n",
filename, ADMXRC2_GetStatusString(status));
return -1;
}
if (use64bit) {
uint32_t config;
config = ADMXRC2_SPACE_SET_WIDTH | ADMXRC2_SPACE_WIDTH_64;
status = ADMXRC2_SetSpaceConfig(card, 0, config);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to set space configuration: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
}
status = ADMXRC2_SetupDMA(card,
rambuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc1);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
status = ADMXRC2_SetupDMA(card,
chkbuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc2);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
dmaMode = ADMXRC2_BuildDMAModeWord(cardInfo.BoardType,
use64bit ? ADMXRC2_IOWIDTH_64 : ADMXRC2_IOWIDTH_32,
0,
ADMXRC2_DMAMODE_USEREADY | ADMXRC2_DMAMODE_USEBTERM | ADMXRC2_DMAMODE_BURSTENABLE);
/* Wait for DLLs/DCMs to lock */
sleep(1);
fpgaSpace[ZBT_SIZE_REG] = sizeReg;
fpgaSpace[ZBT_SIZE_REG]; /* make sure it's got there */
//Set the FPGA to pipelined mode
fpgaSpace[ZBT_PIPELINE_REG] = 0x1;
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
//printf("\n\t Dmamode\t%08X",dmaMode);
failed = FALSE;
unsigned long j, k;
uint32_t exp, act;
unsigned long rep;
if (!failed) {
//rambuf_8 = rambuf;
for (j = 0; j < bankSize; j++) {
rambuf[j] = j;
rambuf[j+2*bankSize] = 262143 - j;
rambuf[j+4*bankSize] = 0x12348765;
}
status = writeSSRAM(rambuf, 0, 6*bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to write SSRAM\n");
failed = TRUE;
}
fpgaSpace[6] = os_cpu_to_le32(1);
fpgaSpace[6];
while(fpgaSpace[7]!=os_cpu_to_le32(0x31));
fpgaSpace[6] = os_cpu_to_le32(0);
fpgaSpace[6];
}
for (j = 0; j < numBank; j++) {
for (k = 0; k < bankSize; k++) {
unsigned long idx = j * bankSize + k;
chkbuf[idx] = 0;
}
}
status = readSSRAM(chkbuf, 0,6*bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to read SSRAM\n");
failed = TRUE;
}
printf("\nData written onto the banks\n");
for (j = 0;j < 20;j++){
printf("\n%02d %08X %08X %08X %08X %08X %08X ", j,rambuf[j],rambuf[1*bankSize+j],rambuf[2*bankSize+j],rambuf[3*bankSize+j],rambuf[4*bankSize+j],rambuf[5*bankSize+j]);
}
printf("\n\nData read from all the banks\n");
for (j = 0;j < 20;j++){
printf("\n%02d %08X %08X %08X %08X %08X %08X ", j,chkbuf[j],chkbuf[1*bankSize+j],chkbuf[2*bankSize+j],chkbuf[3*bankSize+j],chkbuf[4*bankSize+j],chkbuf[5*bankSize+j]);
}
if (failed){
printf("*** FAILED***\n");
goto done;
}
done:
if (rambuf != NULL) {
ADMXRC2_Free(rambuf);
}
if (chkbuf != NULL) {
ADMXRC2_Free(chkbuf);
}
if (dmaDesc1Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc1);
}
if (dmaDesc2Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc2);
}
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return ret;
}
int main(int argc, char *argv[])
{
int ret = 0,inputs,i,j,outputs;
ADMXRC2_STATUS status;
ADMXRC2_HANDLE card = ADMXRC2_HANDLE_INVALID_VALUE;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
volatile uint32_t* fpgaSpace;
unsigned long dataOut[30],dataIn[30],terminate_condition;
const char* filename;
Option options[3];
Arguments arguments;
int use64bit;
/* Set up expected options */
options[0].key = "card";
options[0].type = Option_uint;
options[0].def.uintVal = 0;
options[0].meaning = "ID of card to use";
options[1].key = "index";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "index of card to use";
options[2].key = "64";
options[2].type = Option_boolean;
options[2].def.booleanVal = FALSE;
options[2].meaning = "TRUE => use 64 bit local bus";
arguments.nOption = 3;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("simple",
argc,
argv,
&arguments);
if (options[0].specified && options[1].specified) {
printf("Do not specify both /card and /index\n");
ret = -1;
goto done;
}
if (!options[1].specified) {
ADMXRC2_CARDID cardID = options[0].value.uintVal;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
} else {
unsigned int index = options[1].value.uintVal;
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
}
use64bit = options[2].value.booleanVal;
status = ADMXRC2_GetCardInfo(card, &cardInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get card info: %s\n", ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
switch (cardInfo.BoardType) {
case ADMXRC2_BOARD_ADMXRC:
case ADMXRC2_BOARD_ADMXRC_P:
case ADMXRC2_BOARD_ADMXRC2_LITE:
case ADMXRC2_BOARD_ADMXRC2:
case ADMXRC2_BOARD_ADPWRC2:
case ADMXRC2_BOARD_ADPDRC2:
case ADMXRC2_BOARD_ADMXRC4LS:
case ADMXRC2_BOARD_ADMXRC4LX:
case ADMXRC2_BOARD_ADMXRC4SX:
if (use64bit) {
printf("*** The specified card cannot operate in 64 bit local bus mode\n");
ret = -1;
goto done;
}
break;
case ADMXRC2_BOARD_ADMXPL:
case ADMXRC2_BOARD_ADMXP:
case ADMXRC2_BOARD_ADPXPI:
case ADMXRC2_BOARD_ADPEXRC4FX:
case ADMXRC2_BOARD_ADMXRC4FX:
case ADMXRC2_BOARD_ADMXRC5LX:
case ADMXRC2_BOARD_ADMXRC5T1:
break;
default:
printf("This example must be run on one of the following cards:\n\n");
printf("\tADM-XRC\n");
printf("\tADM-XRC-P\n");
printf("\tADM-XRC-II-Lite\n");
printf("\tADM-XRC-II\n");
printf("\tADM-XPL\n");
printf("\tADM-XP\n");
printf("\tADP-WRC-II\n");
printf("\tADP-DRC-II\n");
printf("\tADP-XPI\n");
printf("\tADM-XRC-4LX\n");
printf("\tADM-XRC-4SX\n");
printf("\tADM-XRC-4FX\n");
printf("\tADPE-XRC-4FX\n");
printf("\tADM-XRC-5LX\n");
printf("\tADM-XRC-5T1\n");
ret = -1;
goto done;
}
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
/* Set local bus clock to nominal frequency */
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, 33.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to set LCLK to %.1fMHz: %s\n",
33.0e6, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
filename = "/var/www/html/VirtualLabs/experiments/exp_2/bitfiles/template-xrc2-2v6000.bit";
status = ADMXRC2_ConfigureFromFile(card, filename);
if (status != ADMXRC2_SUCCESS) {
printf ("Failed to load the bitstream '%s': %s\n",
filename, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
if (use64bit) {
uint32_t config;
config = ADMXRC2_SPACE_SET_WIDTH | ADMXRC2_SPACE_WIDTH_64;
status = ADMXRC2_SetSpaceConfig(card, 0, config);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to set space configuration: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
}
printf("====================\n" );
printf("Enter values for I/O\n" );
printf("====================\n" );
scanf("%d", &inputs);
scanf("%d", &outputs);
terminate_condition = 0;
while (terminate_condition != 0x55aa)
{
for(i=0; i<inputs; i++) //number of inputs
{
scanf("%lx", &dataOut[i]);
fpgaSpace[i] = os_cpu_to_le32((uint32_t) dataOut[i]);
}
for(i=0; i<outputs; i++) // number of outputs
{ dataIn[i] = (unsigned long) os_le32_to_cpu(fpgaSpace[i]);
}
wait (1);
for(i=0; i<inputs; i++)
{
printf("User Input= %8.8lx\n",(unsigned long) dataOut[i]);
}
for(i=0; i<outputs; i++)
{
printf("Output= %8.8lx\n",(unsigned long) dataIn[i]);
}
//Enter 55aa to stop
scanf ("%lx",&terminate_condition);
}
done:
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return ret;
}
int main(int argc, char *argv[])
{
int ret = 0;
const float mclk_freq = 33.0f;
ADMXRC2_STATUS status;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
ADMXRC2_BANK_INFO bankInfo, bankInfo2;
const char* filename;
Option options[8];
Arguments arguments;
float freq, min_freq, max_freq;
unsigned long i;
uint32_t sizeReg;
BOOLEAN dma;
BOOLEAN use64bit;
BOOLEAN speed;
unsigned long nrep;
BOOLEAN failed;
/* Set up expected options */
options[0].key = "banks";
options[0].type = Option_hex;
options[0].def.hexVal = 0xffffffff;
options[0].meaning = "bitmask of banks to test";
options[1].key = "card";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "ID of card to use";
options[2].key = "index";
options[2].type = Option_uint;
options[2].def.uintVal = 0;
options[2].meaning = "index of card to use";
options[3].key = "lclk";
options[3].type = Option_float;
options[3].def.floatVal = 33.0;
options[3].meaning = "local bus clock speed (MHz)";
options[4].key = "repeat";
options[4].type = Option_uint;
options[4].def.uintVal = 1;
options[4].meaning = "number of repetitions";
options[5].key = "speed";
options[5].type = Option_boolean;
options[5].def.booleanVal = TRUE;
options[5].meaning = "TRUE => measure access speed";
options[6].key = "usedma";
options[6].type = Option_boolean;
options[6].def.booleanVal = TRUE;
options[6].meaning = "TRUE => use DMA transfers";
options[7].key = "64";
options[7].type = Option_boolean;
options[7].def.booleanVal = FALSE;
options[7].meaning = "TRUE => use 64-bit local bus";
arguments.nOption = 8;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("memtest", argc, argv, &arguments);
if (options[1].specified && options[2].specified) {
printf("*** Do not specify both /card and /index\n");
ret = -1;
//goto done;
}
if (!options[2].specified) {
ADMXRC2_CARDID cardID = options[1].value.uintVal;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
ret = -1;
//goto done;
}
} else {
unsigned int index = options[2].value.uintVal;
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
// goto done;
}
}
freq = options[3].value.floatVal;
nrep = options[4].value.uintVal;
speed = options[5].value.booleanVal;
dma = options[6].value.booleanVal;
use64bit = options[7].value.booleanVal;
/*
** Find out if we're running on a big-endian machine
*/
bBigEndian = (os_cpu_to_le32(0x1U) != 0x1U);
/*
** Get card information, specifically for device fitted and
** number of SSRAM banks
*/
status = ADMXRC2_GetCardInfo(card, &cardInfo);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get card info: %s\n", ADMXRC2_GetStatusString(status));
return -1;
}
switch (cardInfo.BoardType) {
case ADMXRC2_BOARD_ADMXRC:
case ADMXRC2_BOARD_ADMXRC_P:
case ADMXRC2_BOARD_ADMXRC2_LITE:
min_freq = 25.0;
max_freq = 40.0;
break;
case ADMXRC2_BOARD_ADMXRC2:
case ADMXRC2_BOARD_ADMXRC4LS:
case ADMXRC2_BOARD_ADMXRC4LX:
case ADMXRC2_BOARD_ADMXRC4SX:
min_freq = 24.0;
max_freq = 66.0;
break;
case ADMXRC2_BOARD_ADMXPL:
min_freq = 24.0;
max_freq = 80.0;
break;
default:
printf("*** This example must be run on one of the following cards:\n\n");
printf("\tADM-XRC\n");
printf("\tADM-XRC-P\n");
printf("\tADM-XRCII-Lite\n");
printf("\tADM-XRCII\n");
printf("\tADM-XPL\n");
printf("\tADM-XRC4LX\n");
printf("\tADM-XRC4SX\n");
ret = -1;
//goto done;
}
if (freq > max_freq || freq < min_freq) {
printf("*** LCLK frequency of %.1f MHz is not supported\n", freq);
ret = -1;
// goto done;
}
if (use64bit && cardInfo.BoardType != ADMXRC2_BOARD_ADMXPL) {
printf("*** 64-bit local bus is not supported on the specified card.\n");
ret = -1;
//goto done;
}
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
fpgaSpace[6] = os_cpu_to_le32(0);
fpgaSpace[6];
fpgaSpace[7] = os_cpu_to_le32(0);
fpgaSpace[7];
if (!options[0].specified) {
bankTestMask = cardInfo.RAMBanksFitted;
} else {
bankTestMask = options[0].value.hexVal & cardInfo.RAMBanksFitted;
}
/*
** Check that the type, size, width etc. of each SSRAM bank
** is the same.
*/
numBank = 0;
testSize = 0;
for (i = 0; i < cardInfo.NumRAMBank; i++) {
status = ADMXRC2_GetBankInfo(card, i, &bankInfo2);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get bank %ld info: %s\n",
(unsigned long) i,
ADMXRC2_GetStatusString(status));
return -1;
}
if (!(bankInfo2.Type & (ADMXRC2_RAM_ZBTP | ADMXRC2_RAM_ZBTFT))) {
/* Ignore any banks that are not ZBT SSRAM */
continue;
}
if (!bankInfo2.Fitted) {
printf("*** Not all SSRAM banks are fitted - aborting.\n");
ret = -1;
//goto done;
}
if (cardInfo.BoardType == ADMXRC2_BOARD_ADMXPL && !use64bit) {
/*
** ADM-XPL ZBT bank width is 64 bits but the 32-bit version of design
** uses only the lower 32 bits of the ZBT bank.
*/
bankInfo2.Width = 32;
}
if (!numBank) {
memcpy(&bankInfo, &bankInfo2, sizeof(bankInfo));
bankSize = (bankInfo.Width / 8) * bankInfo.Size;
} else {
if (bankInfo2.Type != bankInfo.Type ||
bankInfo2.Width != bankInfo.Width ||
bankInfo2.Size != bankInfo.Size) {
printf("*** Not all SSRAM banks are the same - aborting.\n");
ret = -1;
//goto done;
}
}
numBank++;
if (bankTestMask & (0x1UL << i)) {
testSize += (bankInfo.Width / 8) * bankInfo.Size;
}
}
if (!numBank) {
printf("*** No SSRAM banks found - aborting.\n");
ret = -1;
//goto done;
}
/*
** Calculate memory size in bytes
*/
memorySize = numBank * bankSize;
lastPageSize = memorySize & (pageSize - 1);
/*
** Determine value to program into the SIZE register in the FPGA
*/
switch (bankInfo.Size) {
case 128*1024:
sizeReg = 0;
break;
case 256*1024:
sizeReg = 1;
break;
case 512*1024:
sizeReg = 2;
break;
case 1024*1024:
sizeReg = 3;
break;
case 2048*1024:
sizeReg = 4;
break;
default:
printf("*** SSRAM of %ld words x %ld is not supported by this application\n",
(unsigned long) bankInfo.Size, (unsigned long) bankInfo.Width);
ret = -1;
//goto done;
}
ssram = (volatile uint32_t*) (((uint8_t*) fpgaSpace) + ssramOffset);
rambuf = (uint8_t*) ADMXRC2_Malloc(memorySize);
if (rambuf == NULL) {
printf("*** Failed to allocate RAM buffer - aborting\n");
ret = -1;
//goto done;
}
rambuf32 = (uint32_t*) rambuf;
chkbuf = (uint8_t*) ADMXRC2_Malloc(memorySize);
if (chkbuf == NULL) {
printf("*** Failed to allocate RAM readback buffer - aborting\n");
ret = -1;
///goto done;
}
chkbuf32 = (uint32_t*) chkbuf;
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set LCLK to %.1fMHz: %s\n",
freq, ADMXRC2_GetStatusString(status));
ret = -1;
//goto done;
}
if (cardInfo.BoardType != ADMXRC2_BOARD_ADMXPL) {
status = ADMXRC2_SetClockRate(card, 1, mclk_freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set clock 1 to %.1fMHz: %s\n",
mclk_freq, ADMXRC2_GetStatusString(status));
return -1;
}
}
filename="/var/www/html/VirtualLabs/experiments/exp_4/bitfiles/user_configuration.bit";
status = ADMXRC2_ConfigureFromFile(card, filename);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to load the bitstream '%s': %s\n",
filename, ADMXRC2_GetStatusString(status));
return -1;
}
if (use64bit) {
uint32_t config;
config = ADMXRC2_SPACE_SET_WIDTH | ADMXRC2_SPACE_WIDTH_64;
status = ADMXRC2_SetSpaceConfig(card, 0, config);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to set space configuration: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
}
status = ADMXRC2_SetupDMA(card,
rambuf,
memorySize,
0,
&dmaDesc1);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
status = ADMXRC2_SetupDMA(card,
chkbuf,
memorySize,
0,
&dmaDesc2);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
dmaMode = ADMXRC2_BuildDMAModeWord(cardInfo.BoardType,
use64bit ? ADMXRC2_IOWIDTH_64 : ADMXRC2_IOWIDTH_32,
0,
ADMXRC2_DMAMODE_USEREADY | ADMXRC2_DMAMODE_USEBTERM | ADMXRC2_DMAMODE_BURSTENABLE);
/* Wait for DLLs/DCMs to lock */
sleep(1);
/*
** Program the number of address bits used by the SSRAMs
*/
fpgaSpace[ZBT_SIZE_REG] = os_cpu_to_le32(sizeReg);
fpgaSpace[ZBT_SIZE_REG]; /* make sure it's got there */
printf("Size reg = 0x%8.8lx\n", (unsigned long) os_le32_to_cpu(fpgaSpace[ZBT_SIZE_REG]));
printf("Info reg = 0x%8.8lx\n", (unsigned long) os_le32_to_cpu(fpgaSpace[ZBT_INFO_REG]));
printf("Status reg = 0x%8.8lx\n", (unsigned long) os_le32_to_cpu(fpgaSpace[ZBT_STATUS_REG]));
failed = FALSE;
// printf("Performing memory tests using %s\n",
// dma ? "DMA" : "programmed I/O");
/* Iterate over flowthrough and pipelined */
for (i = 0; i < 2; i++) {
int nError = 0;
unsigned long j, k;
uint32_t exp, act;
unsigned long rep;
if (i == 0) {
if (!(bankInfo.Type & ADMXRC2_RAM_ZBTFT)) {
continue;
}
/*
** Set the FPGA to flowthrough mode
*/
fpgaSpace[ZBT_PIPELINE_REG] = os_cpu_to_le32(0x0);
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
// printf("Testing %ld kB in flowthrough mode...\n", testSize / 1024);
} else {
if (!(bankInfo.Type & ADMXRC2_RAM_ZBTP)) {
continue;
}
/*
** Set the FPGA to pipelined mode
*/
fpgaSpace[ZBT_PIPELINE_REG] = os_cpu_to_le32(0x1);
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
printf("Testing %ld kB in pipelined mode...\n", testSize / 1024);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
FILE *fptr;
char filen[30];
char initial[16];
char temp[16];
argc --;
if(argc > 0)
strcpy(filen,*(argv+1));
else
{
printf(" Image file name not specified \n");
exit(1);
}
if(!(fptr = fopen(filen,"r")))
{
printf(" Image file does not exist specify some other existing image file \n");
exit(1);
}
int row=0,col=0,count =0,j;
int header =0;
char ch;
while( count!=3)
{
count ++;
ch=fgetc(fptr);
initial[header]=ch;
header++;
}
ch=fgetc(fptr);
initial[header]=ch;
header++;
while(ch!=32)
{
col= col*10+ (ch-48) ;
ch = fgetc(fptr);
initial[header]=ch;
header++;
}
ch= fgetc(fptr);
initial[header]=ch;
header++;
while(ch!=10)
{
row = row*10 + (ch-48);
ch= fgetc(fptr);
initial[header]=ch;
header++;
}
count =0;
while( count!=4)
{
count ++;
ch=fgetc(fptr);
initial[header]=ch;
header++;
}
initial[header]='\0';
// printf( "\n row === %d",row);
// printf( "\n col === %d",col);
strcpy(temp,initial);
// printf( "\n header len === %d",header);
// printf( "\n Header === %s======%s",initial,temp);
int matrix[row][col];
for(i=0;i< row;i++)
{
for( j= 0;j< col;j++)
matrix[i][j]=fgetc(fptr);
}
fclose(fptr);
int output[row][col];
int m,n;
count = 0;
for(m=0;m<row;m++)
{for(n=0;n<col;n++)
{ output[m][n]=0;
rambuf[count] = matrix[m][n];
count++;}
}
count = 0;
for(j=0;j<2;j++)
{
status = writeSSRAM(rambuf + j * bankSize, j * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to write SSRAM\n");
failed = TRUE;
}
}
fpgaSpace[6] = os_cpu_to_le32(1);
fpgaSpace[6];
while(fpgaSpace[7]!=os_cpu_to_le32(0x31));
fpgaSpace[6] = os_cpu_to_le32(0);
fpgaSpace[6];
sleep(10);
if (!failed) {
for (j = 0; j < 2; j++) {
if (!(bankTestMask & (1U << j))) {
continue;
}
status = readSSRAM(chkbuf + j * bankSize, j * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to read SSRAM\n");
failed = TRUE;
break;
}
}
}
count = 0;
for(m=0;m<row;m++)
{for(n=0;n<col;n++)
{ output[m][n]=chkbuf[count];
count++;}
}
//=========================================== new IMAGE FILE BUILD============================
char newFile[] = "Converted_Imag";
char *newfile= strncat(newFile,".pgm",4);
fptr = fopen(newfile,"w");
count=0;
// strcpy(initial,temp);
printf("\n %s..... %s\n",initial,temp);
while(count!=15)
{
fputc(initial[count],fptr);
count++;
}
for(i=0;i< row;i++)
{
for( j= 0;j< col;j++)
fputc(output[i][j],fptr);
}
fclose(fptr);
////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (speed) {
/*
** Measure the host read and host write speeds of the SSRAM,
** using DMA.
*/
float bytes, rate;
double delta;
struct timeval start, now, elapsed;
printf("Measuring access speed...\n");
start = get_time();
bytes = 0.0f;
do {
readSSRAM(rambuf, 0, memorySize, dma);
bytes += (float) memorySize;
now = get_time();
elapsed = time_subtract(&now, &start);
delta = time_to_double(&elapsed);
} while (delta < 2.0);
rate = bytes / delta;
printf("SSRAM to host throughput = %.1fMB/s\n", rate / 1048576.0f);
start = get_time();
bytes = 0.0f;
do {
writeSSRAM(rambuf, 0, memorySize, dma);
bytes += (float) memorySize;
now = get_time();
elapsed = time_subtract(&now, &start);
delta = time_to_double(&elapsed);
} while (delta < 2.0);
rate = bytes / delta;
printf("Host to SSRAM throughput = %.1fMB/s\n", rate / 1048576.0f);
}
ADMXRC2_Free (rambuf);
ADMXRC2_Free (chkbuf);
ADMXRC2_CloseCard (card);
exit(0);
return 0;
}
int card_initialize( void ){
const float mclk_freq = 33.0f;
ADMXRC2_STATUS status;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
ADMXRC2_BANK_INFO bankInfo, bankInfo2;
const char* filename;
unsigned long i;
uint32_t sizeReg;
BOOLEAN use64bit = FALSE;
ADMXRC2_CARDID cardID = 0;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return -1;
}
/*
** Get card information, specifically for device fitted and
** number of SSRAM banks
*/
status = ADMXRC2_GetCardInfo(card, &cardInfo);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get card info: %s\n", ADMXRC2_GetStatusString(status));
return -1;
}
/*
** Check that the type, size, width etc. of each SSRAM bank
** is the same.
*/
status = ADMXRC2_GetBankInfo(card, i, &bankInfo2);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get bank %ld info: %s\n",
(unsigned long) i,
ADMXRC2_GetStatusString(status));
return -1;
}
memcpy(&bankInfo, &bankInfo2, sizeof(bankInfo));
bankSize = (bankInfo.Width / 8) * bankInfo.Size / 4;
/*
** Calculate memory size in longwords (32-bit words)
*/
numBank = cardInfo.NumRAMBank;
memorySize = numBank * bankSize;
lastPageSize = memorySize & (pageSize - 1);
/*
** Determine value to program into the SIZE register in the FPGA
*/
switch (bankInfo.Size) {
case 128*1024:
sizeReg = 0;
break;
case 256*1024:
sizeReg = 1;
break;
case 512*1024:
sizeReg = 2;
break;
case 1024*1024:
sizeReg = 3;
break;
default:
printf("*** SSRAM of %ld words x %ld is not supported by this application\n",
(unsigned long) bankInfo.Size, (unsigned long) bankInfo.Width);
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return -1;
}
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, 33.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set LCLK to %.1fMHz: %s\n",
33.0e6, ADMXRC2_GetStatusString(status));
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return -1;
}
// ssram = (volatile uint32_t*) (((uint8_t*) fpgaSpace) + ssramOffset);
rambuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (rambuf == NULL) {
printf("*** Failed to allocate RAM buffer - aborting\n");
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return -1;
}
chkbuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (chkbuf == NULL) {
printf("*** Failed to allocate RAM readback buffer - aborting\n");
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return -1;
}
if (cardInfo.BoardType != ADMXRC2_BOARD_ADMXRC2_PRO_LITE) {
status = ADMXRC2_SetClockRate(card, 1, mclk_freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set clock 1 to %.1fMHz: %s\n",
mclk_freq, ADMXRC2_GetStatusString(status));
return -1;
}
}
/*
if (use64bit) {
uint32_t config;
config = ADMXRC2_SPACE_SET_WIDTH | ADMXRC2_SPACE_WIDTH_64;
status = ADMXRC2_SetSpaceConfig(card, 0, config);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to set space configuration: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
}
*/
//*************************************DMA DESCRIPTORS**************************************
status = ADMXRC2_SetupDMA(card,
rambuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc1);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
status = ADMXRC2_SetupDMA(card,
chkbuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc2);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
//*********************************************************************************************
dmaMode = ADMXRC2_BuildDMAModeWord(cardInfo.BoardType,
use64bit ? ADMXRC2_IOWIDTH_64 : ADMXRC2_IOWIDTH_32,
0,
ADMXRC2_DMAMODE_USEREADY | ADMXRC2_DMAMODE_USEBTERM | ADMXRC2_DMAMODE_BURSTENABLE);
/* Wait for DLLs/DCMs to lock */
sleep(1);
fpgaSpace[ZBT_SIZE_REG] = sizeReg;
fpgaSpace[ZBT_SIZE_REG]; /* make sure it's got there */
//Set the FPGA to pipelined mode
fpgaSpace[ZBT_PIPELINE_REG] = 0x1;
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
return 0;
}
int main(int argc, char *argv[])
{
int ret = 0;
const float mclk_freq = 33.0f;
ADMXRC2_STATUS status;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
ADMXRC2_BANK_INFO bankInfo, bankInfo2;
const char* filename;
Option options[8];
Arguments arguments;
float freq, min_freq, max_freq;
unsigned long i;
uint32_t sizeReg;
BOOLEAN dma;
BOOLEAN use64bit;
BOOLEAN speed;
unsigned long nrep;
BOOLEAN failed;
/* Set up expected options */
options[0].key = "banks";
options[0].type = Option_hex;
options[0].def.hexVal = 0xffffffff;
options[0].meaning = "bitmask of banks to test";
options[1].key = "card";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "ID of card to use";
options[2].key = "index";
options[2].type = Option_uint;
options[2].def.uintVal = 0;
options[2].meaning = "index of card to use";
options[3].key = "lclk";
options[3].type = Option_float;
options[3].def.floatVal = 33.0;
options[3].meaning = "local bus clock speed (MHz)";
options[4].key = "repeat";
options[4].type = Option_uint;
options[4].def.uintVal = 1;
options[4].meaning = "number of repetitions";
options[5].key = "speed";
options[5].type = Option_boolean;
options[5].def.booleanVal = TRUE;
options[5].meaning = "TRUE => measure access speed";
options[6].key = "usedma";
options[6].type = Option_boolean;
options[6].def.booleanVal = TRUE;
options[6].meaning = "TRUE => use 64 bit local bus";
options[7].key = "64";
options[7].type = Option_boolean;
options[7].def.booleanVal = FALSE;
options[7].meaning = "TRUE => use DMA for test";printf("Writing 0xAAAAAAAA...\n");
arguments.nOption = 8;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("memtest", argc, argv, &arguments);
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
freq = options[3].value.floatVal;
nrep = options[4].value.uintVal;
speed = options[5].value.booleanVal;
dma = options[6].value.booleanVal;
use64bit = options[7].value.booleanVal;
/*
** Get card information, specifically for device fitted and
** number of SSRAM banks
*/
status = ADMXRC2_GetCardInfo(card, &cardInfo);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get card info: %s\n", ADMXRC2_GetStatusString(status));
return -1;
}
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
if (!options[0].specified) {
bankTestMask = cardInfo.RAMBanksFitted;
} else {
bankTestMask = options[0].value.hexVal & cardInfo.RAMBanksFitted;
}
/*
** Check that the type, size, width etc. of each SSRAM bank
** is the same.
*/
numBank = 0;
testSize = 0;
for (i = 0; i < cardInfo.NumRAMBank; i++) {
status = ADMXRC2_GetBankInfo(card, i, &bankInfo2);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to get bank %ld info: %s\n",
(unsigned long) i,
ADMXRC2_GetStatusString(status));
return -1;
}
if (!(bankInfo2.Type & (ADMXRC2_RAM_ZBTP | ADMXRC2_RAM_ZBTFT))) {
/* Ignore any banks that are not ZBT SSRAM */
continue;
}
if (!bankInfo2.Fitted) {
printf("*** Not all SSRAM banks are fitted - aborting.\n");
ret = -1;
goto done;
}
if (!numBank) {
memcpy(&bankInfo, &bankInfo2, sizeof(bankInfo));
bankSize = (bankInfo.Width / 8) * bankInfo.Size / 4;
} else {
if (bankInfo2.Type != bankInfo.Type ||
bankInfo2.Width != bankInfo.Width ||
bankInfo2.Size != bankInfo.Size) {
printf("*** Not all SSRAM banks are the same - aborting.\n");
ret = -1;
goto done;
}
}
numBank++;
if (bankTestMask & (0x1UL << i)) {
testSize += (bankInfo.Width / 8) * bankInfo.Size / 4;
}
}
if (!numBank) {
printf("*** No SSRAM banks found - aborting.\n");
ret = -1;
goto done;
}
/*
** Calculate memory size in longwords (32-bit words)
*/
memorySize = numBank * bankSize;
lastPageSize = memorySize & (pageSize - 1);
/*
** Determine value to program into the SIZE register in the FPGA
*/
switch (bankInfo.Size) {
case 128*1024:
sizeReg = 0;
break;
case 256*1024:
sizeReg = 1;
break;
case 512*1024:
sizeReg = 2;
break;
case 1024*1024:
sizeReg = 3;
break;
default:
printf("*** SSRAM of %ld words x %ld is not supported by this application\n",
(unsigned long) bankInfo.Size, (unsigned long) bankInfo.Width);
ret = -1;
goto done;
}
ssram = (volatile uint32_t*) (((uint8_t*) fpgaSpace) + ssramOffset);
rambuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (rambuf == NULL) {
printf("*** Failed to allocate RAM buffer - aborting\n");
ret = -1;
goto done;
}
chkbuf = (uint32_t*) ADMXRC2_Malloc(memorySize * sizeof(uint32_t));
if (chkbuf == NULL) {
printf("*** Failed to allocate RAM readback buffer - aborting\n");
ret = -1;
goto done;
}
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set LCLK to %.1fMHz: %s\n",
freq, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
if (cardInfo.BoardType != ADMXRC2_BOARD_ADMXRC2_PRO_LITE) {
status = ADMXRC2_SetClockRate(card, 1, mclk_freq * 1.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("*** Failed to set clock 1 to %.1fMHz: %s\n",
mclk_freq, ADMXRC2_GetStatusString(status));
return -1;
}
}
if (use64bit) {
uint32_t config;
config = ADMXRC2_SPACE_SET_WIDTH | ADMXRC2_SPACE_WIDTH_64;
status = ADMXRC2_SetSpaceConfig(card, 0, config);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to set space configuration: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
}
status = ADMXRC2_SetupDMA(card,
rambuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc1);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
status = ADMXRC2_SetupDMA(card,
chkbuf,
memorySize * sizeof(uint32_t),
0,
&dmaDesc2);
if (status != ADMXRC2_SUCCESS) {
printf ("*** Failed to get a DMA descriptor: %s\n",
ADMXRC2_GetStatusString(status));
return -1;
}
dmaMode = ADMXRC2_BuildDMAModeWord(cardInfo.BoardType,
use64bit ? ADMXRC2_IOWIDTH_64 : ADMXRC2_IOWIDTH_32,
0,
ADMXRC2_DMAMODE_USEREADY | ADMXRC2_DMAMODE_USEBTERM | ADMXRC2_DMAMODE_BURSTENABLE);
/* Wait for DLLs/DCMs to lock */
sleep(1);
/*
** Program the number of address bits used by the SSRAMs
*/
fpgaSpace[ZBT_SIZE_REG] = sizeReg;
fpgaSpace[ZBT_SIZE_REG]; /* make sure it's got there */
printf("Size reg = 0x%8.8lx\n", (unsigned long) fpgaSpace[ZBT_SIZE_REG]);
printf("Info reg = 0x%8.8lx\n", (unsigned long) fpgaSpace[ZBT_INFO_REG]);
printf("Status reg = 0x%8.8lx\n", (unsigned long) fpgaSpace[ZBT_STATUS_REG]);
failed = FALSE;
/* Iterate over flowthrough and pipelined */
for (i = 0; i < 2; i++) {
int nError = 0;
unsigned long j, k;
//char m= 'a';
uint32_t exp, act;
unsigned long rep;
if (i == 0) {
if (!(bankInfo.Type & ADMXRC2_RAM_ZBTFT)) {
continue;
}
/*
** Set the FPGA to flowthrough mode
*/
fpgaSpace[ZBT_PIPELINE_REG] = 0x0;
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
printf("Testing %ld kB in flowthrough mode...\n", testSize * 4 / 1024);
} else {
if (!(bankInfo.Type & ADMXRC2_RAM_ZBTP)) {
continue;
}
/*
** Set the FPGA to pipelined mode
*/
fpgaSpace[ZBT_PIPELINE_REG] = 0x1;
fpgaSpace[ZBT_PIPELINE_REG]; /* make sure it's got there */
printf("Testing %ld kB in pipelined mode...\n", testSize * 4 / 1024);
}
for (rep = 0; rep < nrep; rep++) {
printf("Repetition %ld\n", rep);
///////////////////////////////////////////STARTING//////////////////////////////////////
/* Perform 0xAAAAAAA test - look for shorted/stuck data pins */
if (!failed && nError == 0) {
rambuf_8 = rambuf;
for (j = 0; j < 50; j++) {
rambuf_8[j+12*bankSize] = j;
}
for (j = 0; j < 50; j++) {
rambuf[j+4*bankSize] = 0;
}
status = writeSSRAM(rambuf, 3 * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to write SSRAM\n");
failed = TRUE;
}
status = writeSSRAM(rambuf, 4 * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to write SSRAM\n");
failed = TRUE;
}
fpgaSpace[6] = os_cpu_to_le32(1);
fpgaSpace[6];
while(fpgaSpace[7]!=os_cpu_to_le32(0x31));
fpgaSpace[6] = os_cpu_to_le32(0);
fpgaSpace[6];
}
for (j = 0; j < numBank; j++) {
for (k = 0; k < bankSize; k++) {
unsigned long idx = j * bankSize + k;
chkbuf[idx] = 0;
}
}
status = readSSRAM(chkbuf, 4 * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to read SSRAM\n");
failed = TRUE;
}
status = readSSRAM(chkbuf, 3 * bankSize, bankSize, dma);
if (status != ADMXRC2_SUCCESS) {
printf("Error: failed to read SSRAM\n");
failed = TRUE;
}
for (j = 0;j < 50;j++){
printf("\n%02d %08X %08X ", j,chkbuf[j+3*bankSize],chkbuf[4*bankSize+j]);
}
if (!failed && nError == 0) {
printf("PASSED\n");
} else {
printf("*** FAILED with %ld error(s)\n", (long) nError);
break;
}
}
if (failed) {
break;
}
}
if (speed) {
/*
** Measure the host read and host write speeds of the SSRAM,
** using DMA.
*/
float bytes, rate;
double delta;
struct timeval start, now, elapsed;
printf("Measuring access speed...\n");
start = get_time();
bytes = 0.0f;
do {
readSSRAM(rambuf, 0, memorySize, dma);
bytes += (float) (memorySize * sizeof(uint32_t));
now = get_time();
elapsed = time_subtract(&now, &start);
delta = time_to_double(&elapsed);
} while (delta < 2.0);
rate = bytes / delta;
printf("SSRAM to host throughput = %.1fMB/s\n", rate / 1048576.0f);
start = get_time();
bytes = 0.0f;
do {
writeSSRAM(rambuf, 0, memorySize, dma);
bytes += (float) (memorySize * sizeof(uint32_t));
now = get_time();
elapsed = time_subtract(&now, &start);
delta = time_to_double(&elapsed);
} while (delta < 2.0);
rate = bytes / delta;
printf("Host to SSRAM throughput = %.1fMB/s\n", rate / 1048576.0f);
}
done:
if (rambuf != NULL) {
ADMXRC2_Free(rambuf);
}
if (chkbuf != NULL) {
ADMXRC2_Free(chkbuf);
}
if (dmaDesc1Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc1);
}
if (dmaDesc2Valid) {
ADMXRC2_UnsetupDMA(card, dmaDesc2);
}
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return ret;
}
int main(int argc, char *argv[])
{
int ret = 0,inputs,i,j,outputs;
ADMXRC2_STATUS status;
ADMXRC2_HANDLE card = ADMXRC2_HANDLE_INVALID_VALUE;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
volatile uint32_t* fpgaSpace;
unsigned long dataOut[30],dataIn[30];
const char* filename;
Option options[3];
Arguments arguments;
int use64bit;
/* Set up expected options */
options[0].key = "card";
options[0].type = Option_uint;
options[0].def.uintVal = 0;
options[0].meaning = "ID of card to use";
options[1].key = "index";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "index of card to use";
options[2].key = "64";
options[2].type = Option_boolean;
options[2].def.booleanVal = FALSE;
options[2].meaning = "TRUE => use 64 bit local bus";
arguments.nOption = 3;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("simple",
argc,
argv,
&arguments);
if (!options[1].specified) {
ADMXRC2_CARDID cardID = options[0].value.uintVal;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
} else {
unsigned int index = options[1].value.uintVal;
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
}
use64bit = options[2].value.booleanVal;
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
/* Set local bus clock to nominal frequency */
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, 33.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to set LCLK to %.1fMHz: %s\n",
33.0e6, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
printf("====================\n" );
printf("Enter values for I/O\n" );
printf("====================\n" );
for(i=0; i<2; i++)
{
scanf("%lx", &dataOut[i]);
fpgaSpace[i] = os_cpu_to_le32((uint32_t) dataOut[i]);
}
sleep(1);
for(i=0; i<2; i++)
{ dataIn[i] = (unsigned long) os_le32_to_cpu(fpgaSpace[i]);
for(j=0; j<5; j++);
}
for(i=1; i<2; i++)
{
printf("Input = %8.8lx\n",(unsigned long) dataOut[i]);
}
//for(i=0;i<2;i++)
//{
printf("output = %8.8lx\n",(unsigned long) dataIn[0]);
printf("state = %8.8lx\n",(unsigned long) dataIn[1]);
//}
done:
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return ret;
}
int main(int argc, char *argv[])
{
int ret = 0,inputs,i,j,outputs;
ADMXRC2_STATUS status;
ADMXRC2_HANDLE card = ADMXRC2_HANDLE_INVALID_VALUE;
ADMXRC2_CARD_INFO cardInfo;
ADMXRC2_SPACE_INFO spInfo;
volatile uint32_t* fpgaSpace;
unsigned long dataOut[30],dataIn[30];
unsigned long read_value, write_value1, write_value2;
const char* filename;
Option options[3];
Arguments arguments;
int use64bit;
/* Set up expected options */
options[0].key = "card";
options[0].type = Option_uint;
options[0].def.uintVal = 0;
options[0].meaning = "ID of card to use";
options[1].key = "index";
options[1].type = Option_uint;
options[1].def.uintVal = 0;
options[1].meaning = "index of card to use";
options[2].key = "64";
options[2].type = Option_boolean;
options[2].def.booleanVal = FALSE;
options[2].meaning = "TRUE => use 64 bit local bus";
arguments.nOption = 3;
arguments.option = options;
arguments.nParamType = 0;
arguments.minNParam = 0;
/* Parse command line */
parse_command_line("simple",
argc,
argv,
&arguments);
if (!options[1].specified) {
ADMXRC2_CARDID cardID = options[0].value.uintVal;
status = ADMXRC2_OpenCard(cardID, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with ID %ld: %s\n",
(unsigned long) cardID, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
} else {
unsigned int index = options[1].value.uintVal;
status = ADMXRC2_OpenCardByIndex(index, &card);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to open card with index %ld: %s\n",
(unsigned long) index, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
}
use64bit = options[2].value.booleanVal;
/* Get the address of FPGA space */
status = ADMXRC2_GetSpaceInfo(card, 0, &spInfo);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to get space 0 info: %s\n",
ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
fpgaSpace = (volatile uint32_t*) spInfo.VirtualBase;
/* Set local bus clock to nominal frequency */
status = ADMXRC2_SetClockRate(card, ADMXRC2_CLOCK_LCLK, 33.0e6, NULL);
if (status != ADMXRC2_SUCCESS) {
printf("Failed to set LCLK to %.1fMHz: %s\n",
33.0e6, ADMXRC2_GetStatusString(status));
ret = -1;
goto done;
}
printf("====================\n" );
printf("Enter values for I/O\n" );
printf("====================\n" );
scanf("%lx", &dataOut[0]);
fpgaSpace[0] = os_cpu_to_le32((uint32_t) dataOut[0]);
sleep_ms(1);
FILE *fptr1,*fptr2;
if(!(fptr1 = fopen("../temp/input_file.txt","r")))
{
printf("input_file does not exist specify some other existing file \n");
return -1;
}
if(!(fptr2 = fopen("../temp/output_file.txt","w")))
{
printf("Error in creating output_file \n");
return -1;
}
fprintf(fptr2,"Output\t\tState\n");
fscanf(fptr1,"%lx",&read_value);
while(!feof(fptr1))
{
write_value1 = (unsigned long) os_le32_to_cpu(fpgaSpace[0]);
write_value2 = (unsigned long) os_le32_to_cpu(fpgaSpace[1]);
fprintf(fptr2, "%lx\t\t%ld\n", write_value1, write_value2);
fpgaSpace[0] = os_cpu_to_le32((uint32_t) 0);
fpgaSpace[1] = os_cpu_to_le32((uint32_t) read_value);
sleep_ms(1);
printf("hi1\t%lx\n",read_value);
fscanf(fptr1,"%lx",&read_value);
}
fclose (fptr1);
fclose (fptr2);
done:
if (card != ADMXRC2_HANDLE_INVALID_VALUE) {
ADMXRC2_CloseCard(card);
}
return ret;
}
void fpga_cleanup(void) {
if (card != ADMXRC2_HANDLE_INVALID_VALUE)
ADMXRC2_CloseCard(card);
}