コード例 #1
0
ファイル: io_interface_b.c プロジェクト: vlabiitd/ecelab-iitd
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; 
}
コード例 #2
0
ファイル: temp1.c プロジェクト: vlabiitd/ecelab-iitd
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);
  }
}
コード例 #3
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";
  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;
}
コード例 #4
0
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;
}
コード例 #5
0
ファイル: imgtemplate1.c プロジェクト: vlabiitd/ecelab-iitd
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;

}
コード例 #6
0
ファイル: temp1.c プロジェクト: vlabiitd/ecelab-iitd
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;
}
コード例 #7
0
ファイル: load_input.c プロジェクト: vlabiitd/ecelab-iitd
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;
}
コード例 #8
0
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;
}
コード例 #9
0
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;
}
コード例 #10
0
ファイル: fpga_util.c プロジェクト: STFleming/MMMGF
void fpga_cleanup(void) {
    if (card != ADMXRC2_HANDLE_INVALID_VALUE)
        ADMXRC2_CloseCard(card);
}