/*************************************************************************
*                HB QUICK TEST VMEONLY AUTOMATIC VERSION                 *
*   Tests one Hit Buffer board.                                          *
*   It performs VME standalone tests only.                               *
*   Only makes tests that can be checked automatically, no LED tests,    *
*   no questions asked to operator.                                      *
*                                                                        *
*   Compile this program with: svtvmecomp hb_vmeonlytest_auto            *
*    also need first to copy hb_address.h from $SVTVME_DIR/src to        *
*    current directory. This may change as SVTVME pacakge evolves        *
*                                                                        *
**************************************************************************/

/*
*** REVISION HISTORY
* 25 May 00: S.Belforte. Original creation from hb_quit_test.c of the day
* 26 May 00: S.Belforte. Save/Read random seed, each run will use different
*                        maps to check SS/AM map. Beware. Delete each time
*                        lastseed file to get reproducibility.
*
**************************************************************************/
#include "svt_functions.h"
#include "hb_functions.h"
#include "hb_address.h"

#include "VISION.h"

uint4 rand16();
void get_random_seed();
void save_random_seed();

void bit_print(int v, int pos);
void reset_hb_PowerOnState(svtvme_t *board);
int  check_hb_PowerOnState(svtvme_t *board);
int  test_register(uint4 address, uint4 mask, svtvme_t *board);
int  test_ram(uint4 address, uint4 size, uint4 mask, int repeat,
	      svtvme_t *board);

int  largeVISIONwrite (VISION_SLAVE slave, unsigned int offset, 
		       unsigned int req_bytes, unsigned int *real_bytes, 
		       void *data );

int  largeVISIONread (VISION_SLAVE slave, unsigned int offset, 
		      unsigned int req_bytes, unsigned int *real_bytes, 
		      void *data );

int main(int argc, char * argv[])
{

  char verb[10];
  unsigned long   error_flag, error_enable;
  unsigned long   tmode, hit_spy, roadlimit, phisector;
  unsigned long   fifo = 0x678;
  unsigned long   hold, idprom;
  unsigned long   data, mdata;
  int   status, i;
  int   hb1add;
  char crate[20];
  svtvme_t *hb1;
  uint4 *Data;




  if (argc != 3) {
    printf("Usage: %s <crate> <slot>\n",argv[0]);
    exit (1);
  }
  sscanf(argv[1], "%s", crate);
  sscanf(argv[2], "%d", &hb1add);
  
  printf("Will QuickTest HitBuffer in slot %d of crate %s\n", hb1add,crate);

  strcpy(verb,"zzz");

  get_random_seed();
  hb1 = svtvme_svt_open(crate, hb1add);
  hb1->fpdebug=0;

  reset_hb_PowerOnState(hb1);
  assert (check_hb_PowerOnState(hb1));

/*
 * Test Enable
 */
  status = svtvme_hb_tModeEnable(hb1);
  printf(" Test Mode enabled with status %d\n", status);

  status = svtvme_hb_tModeStatus(&tmode, hb1);
  printf(" Test Mode state : "); bit_print(tmode,1);
  assert ( (tmode&1)==1 );

  /*
   * Test R/W Registers
   */
  printf("testing HB_OUTPUT register ... ");
  assert (test_register (HB_OUTPUT_REG, HB_OUTPUT_MASK, hb1));
  printf("OK\n");

  printf("testing FREEZE_VME register ... ");
  assert (test_register (HB_FREZZE_REG, HB_FREEZE_MASK, hb1));
  printf("OK\n");

  printf("testing ERROR_LINE_ENABLE register ... ");
  assert (test_register (HB_ERREN_REG, HB_ERREN_MASK, hb1));
  printf("OK\n");

  printf("testing CDF_ERROR_ENABLE register ... ");
  assert (test_register (HB_CDF_EN_REG, HB_CDF_ERR_MASK, hb1));
  printf("OK\n");


  /*
   * Test RAM
   */

  printf("testing ID PROM ... \n");
  assert (test_prom (hb1));
  printf("ID PROM OK\n\n");

  printf("testing SS_MAP memory ... "); fflush(0);
  assert (test_ram (HB_SS_MAP_REG, HB_SS_MAP_LENGTH, HB_SS_MAP_MASK, 2, hb1));
  printf("OK\n");

  printf("testing AM_MAP memory ... "); fflush(0);
  assert (test_ram (HB_AM_MAP_REG, HB_AM_MAP_LENGTH, HB_AM_MAP_MASK, 1, hb1));
  printf("OK\n");



/*
 * Init
 */

  status = svtvme_hb_init(hb1);
  printf("\n Init done with status %d\n\n", status);
  status = svtvme_hb_tModeStatus(&tmode, hb1);
  printf(" Test Mode state : "); bit_print(tmode,1);
  assert ( (tmode&1)==0 );

  reset_hb_PowerOnState(hb1);

  svtvme_svt_close(hb1);

  save_random_seed();
}

/*==================================================================*/
/*====================  END OF MAIN  ===============================*/
/*==================================================================*/


/*------------------------------------------------------------------*/

void reset_hb_PowerOnState(svtvme_t *board)
{
  int status;
  uint4 data;
  data = 0xFF;
  status = svtvme_hb_setState(HB_ERREN, data, board);
  data = 0;
  status = svtvme_hb_setState(HB_CDF_ERR_EN, data, board);
  status = svtvme_hb_init(board);
}

/*------------------------------------------------------------------*/

int check_hb_PowerOnState(svtvme_t *board){
int status;
uint4 data, mdata;

  /*
   * Dump and check HB PowerOn state
   */

  status = svtvme_hb_tModeStatus(&data, board);
  mdata = data & HB_TMOD_MASK;
  printf(" Test Mode state : "); bit_print(data,1);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_ERROR, &data, board);
  mdata = data & HB_ERROR_MASK;
  printf("ERROR REGISTER     = %02x  ",mdata); bit_print(mdata, 8);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_HIT_FIFO, &data, board);
  mdata = data & HB_HIT_F_S_MASK;
  printf("HIT FIFO STATUS    = %2x  ",mdata); bit_print(mdata, 3);
  assert( mdata==6 );

  status = svtvme_hb_getState(HB_ROAD_FIFO, &data, board);
  mdata = data & HB_ROAD_F_S_MASK;
  printf("ROAD FIFO STATUS   = %2x  ",mdata); bit_print(mdata, 3);
  assert( mdata==6 );

  status = svtvme_hb_getState(HB_HOLD, &data, board);
  mdata = data & HB_HOLD_MASK;
  printf("OUTPUT HOLD STATUS = %2x  ",mdata); bit_print(mdata, 1);

  status = svtvme_hb_getState(HB_FSM, &data, board);
  mdata = data & HB_FSM_MASK;
  printf("FSM STATUS         = %2x  ",mdata); bit_print(mdata, 4);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_FSMH, &data, board);
  mdata = data & HB_FSMH_MASK;
  printf("FSMH STATUS        = %2x  ",mdata); bit_print(mdata, 2);
  assert( mdata==3 );

  status = svtvme_hb_getState(HB_FSMR, &data, board);
  mdata = data & HB_FSMR_MASK;
  printf("FSMR STATUS        = %2x  ",mdata); bit_print(mdata, 2);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_OUTPUT, &data, board);
  mdata = data & HB_OUTPUT_MASK;
  printf("OUTPUT REGISTER= %06x  ",mdata); bit_print(mdata, 23);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_FREEZE, &data, board);
  mdata = data & HB_FREEZE_MASK;
  printf("FREEZE VME         = %2x  ",mdata); bit_print(mdata, 1);
  assert( mdata==0 );

  assert ( test_spy_reg(HB_HIT_SPY, board) );
  assert ( test_spy_reg(HB_ROAD_SPY, board) );
  assert ( test_spy_reg(HB_OUT_SPY, board) );

  status = svtvme_hb_getState(HB_ERREN, &data, board);
  mdata = data & HB_ERREN_MASK;
  printf("SVT ERROR ENABLE   = %02x  ",mdata); bit_print(mdata, 8);
  assert( mdata==0xFF );

  status = svtvme_hb_getState(HB_CDF_ERR_EN, &data, board);
  mdata = data & HB_CDF_ERR_MASK;
  printf("CDF ERROR ENABLE   = %2x  ",mdata); bit_print(mdata, 1);
  assert( mdata==0 );

  status = svtvme_hb_getState(HB_CDF_ERR_ST, &data, board);
  mdata = data & HB_CDF_ERR_MASK;
  printf("CDF ERROR STATUS   = %2x  ",mdata); bit_print(mdata, 1);
  assert( mdata==1 );

  status = svtvme_hb_getState(HB_DIP_STAT, &data, board);
  mdata = data & HB_DIP_MASK;
  printf("DIP SWITCHES       = %2x  ",mdata); bit_print(mdata, 4);
  assert( mdata==15 );


}
/*------------------------------------------------------------------*/

int test_spy_reg(uint4 spyreg, svtvme_t *board){
  int status;
  char reg[4];
  uint4 data,mdata;

  if (spyreg == HB_HIT_SPY)
    strcpy(reg,"HIT");
  else if (spyreg == HB_ROAD_SPY)
    strcpy(reg,"ROAD");
  else if (spyreg == HB_OUT_SPY)
    strcpy(reg,"OUT");
  else
    {
      printf("test_hb_spy- wrong 1st argument: %d\n",spyreg);
    return 0;
    }

  status = svtvme_hb_getState(spyreg, &data, board);
  mdata = data & SPY_POINTER;
  printf("%s SPY POINTER = %05x  ",reg, mdata); bit_print(mdata, 17);
  if (mdata != 0) {
    printf ("    Try to reset it: ");
    status = svtvme_hb_resetState(spyreg, board);
    status = svtvme_hb_getState(spyreg, &data, board);
    mdata = data & SPY_POINTER;
    printf("%s SPY POINTER = %05x  ",reg, mdata); bit_print(mdata, 17);
  }
  assert( mdata==0 || mdata==1 );

  mdata = (data & SPY_WRAP)>>17;
  printf("%s SPY WRAP       = %2x  ",reg, mdata); bit_print(mdata, 1);
  assert( mdata==0 );

  mdata = (data & SPY_FREEZE)>>18;
  printf("%s SPY FREEZE     = %2x  ",reg, mdata); bit_print(mdata, 1);
  assert( mdata==1 );

  return 1;
}

/*------------------------------------------------------------------*/


int test_register(uint4 address, uint4 mask, svtvme_t *board)
{
  uint4 wdata;
  uint4 rdata;
  unsigned int nXfer;
  int i,j,nbits;
  int status;
  int ok=1;

  /* find the register length */
  j=0;
  for (i=0; i<32; i++)
    {
      j |= 1<<i;
      if ((j&mask) != j) break;
    }
  nbits = i;

  /* fill with 0 */
  wdata = 0;
  ok = w_r_check_reg (board, address, mask, wdata);

  /* fill with 1 */
  wdata = mask;
  ok = w_r_check_reg (board, address, mask, wdata);

  /* rotate 0's */
  for (i=0; i<nbits; i++)
    {
      wdata = mask & ~1<<i;
      ok = w_r_check_reg (board, address, mask, wdata);
    }

  /* rotate 1's */
  for (i=0; i<nbits; i++)
    {
      wdata = 1<<i;
      ok = w_r_check_reg (board, address, mask, wdata);
    }

  return ok;
}

/*------------------------------------------------------------------*/

int w_r_check_reg (svtvme_t *board, uint4 add, uint4 mask, uint4 data)
{
  uint4 wdata, rdata, status;
  unsigned int nXfer;
  int ok = 1;
  wdata = data;
  status= VISIONwrite (board->vs, add, sizeof(wdata), &nXfer, &wdata);
  status= VISIONread  (board->vs, add, sizeof(wdata), &nXfer, &rdata);
  rdata &= mask;
  if (rdata != wdata)
    ok = 0;
  return ok;
}


/*------------------------------------------------------------------*/

int test_ram(uint4 address, uint4 size, uint4 mask, int repeat,
	     svtvme_t *board)
{
  uint4 *tdata;
  unsigned int XfBytes;
  int i, n;
  int status;
  int ok=1;
  uint4 offset;
  uint4 nbytes;
  const int wordsInBunch = 128*1024;
  const int bytesInBunch = sizeof(uint4) * wordsInBunch;

  nbytes = size * sizeof(uint4);
  tdata = malloc (nbytes);
  assert (tdata);

  /* fill with 0 */
  /*
  printf("0."); fflush(0);
  for (i=0; i<size; i++) tdata[i]=0;
  ok = w_r_check_ram (board, address, size, mask, tdata);
  */
  /* fill with 1 */
  /*
  printf("1."); fflush(0);
  for (i=0; i<size; i++) tdata[i]=mask;
  ok = w_r_check_ram (board, address, size, mask, tdata);
  */
  printf("Random test will repeat %d times: ",repeat);

  for (n=0; n<repeat; n++)
    {
      /* random */
      printf("r%d.",n+1); fflush(0);
      for (i=0; i<size; i++) tdata[i]=rand16();
      ok = w_r_check_ram (board, address, size, mask, tdata);
      /* complementary */
      printf("!."); fflush(0);
      for (i=0; i<size; i++) tdata[i]= (~tdata[i]) & mask;
      ok = w_r_check_ram (board, address, size, mask, tdata);
    }
  free (tdata);

  return ok;
}

/*------------------------------------------------------------------*/

uint4 rand16(){
  /* returns random 16-bit unsigned long */
  uint4 word = 0xFFFF;
  float r;
  r = ((float)word*rand()/(RAND_MAX+1.0));
  return (uint4)r;
}

/*------------------------------------------------------------------*/

int w_r_check_ram(svtvme_t *board, uint4 add, uint4 size,
		  uint4 mask, uint4 *data)
{
  uint4 status;
  unsigned int nXfer;
  int i;
  int nbytes = sizeof(uint4) * size;
  int ok = 1;
  uint4 *rdata;
  rdata = malloc(nbytes);
  assert(rdata);
  status= largeVISIONwrite (board->vs, add, nbytes, &nXfer, data);
  status= largeVISIONread  (board->vs, add, nbytes, &nXfer, rdata);
  for (i=0; i<size; i++)
    {
      rdata[i] &= mask;
      if (rdata[i] != data[i]) {ok = 0; break;};
    }
  free (rdata);
  return ok;
}

/*------------------------------------------------------------------*/

int largeVISIONwrite (VISION_SLAVE slave, unsigned int offset, 
        unsigned int req_bytes, unsigned int *real_bytes, 
        void *data )
{
  unsigned int RunningOffset;
  unsigned int XfBytes;
  int nXfer, rest, i;
  int status;
  const int wordsInBunch = 128*1024;
  const int bytesInBunch = sizeof(unsigned int) * wordsInBunch;

  nXfer = (int)req_bytes / (bytesInBunch);
  rest  = (int)req_bytes % (bytesInBunch);

  *real_bytes=0;

  for (i=0; i<nXfer; i++)
    {
      RunningOffset = offset + i* bytesInBunch;
      status= VISIONwrite (slave, RunningOffset,
			   bytesInBunch, &XfBytes, data+i*bytesInBunch);
      if (status)
	return (status);
      else
	*real_bytes = *real_bytes + XfBytes;
    }
  if (rest != 0)
    {
      RunningOffset = offset + i* bytesInBunch;
      status= VISIONwrite (slave, RunningOffset,
			   rest, &XfBytes, data+i*bytesInBunch);
      if (status)
	return (status);
      else
	*real_bytes = *real_bytes + XfBytes;
    }
return (status);
}

/*------------------------------------------------------------------*/

int largeVISIONread (VISION_SLAVE slave, unsigned int offset, 
        unsigned int req_bytes, unsigned int *real_bytes, 
        void *data )
{
  unsigned int RunningOffset;
  unsigned int XfBytes;
  int nXfer, rest, i;
  int status;
  const int wordsInBunch = 128*1024;
  const int bytesInBunch = sizeof(unsigned int) * wordsInBunch;

  nXfer = (int)req_bytes / (bytesInBunch);
  rest  = (int)req_bytes % (bytesInBunch);

  *real_bytes=0;

  for (i=0; i<nXfer; i++)
    {
      RunningOffset = offset + i* bytesInBunch;
      status= VISIONread (slave, RunningOffset,
			   bytesInBunch, &XfBytes, data+i*bytesInBunch);
      if (status)
	return (status);
      else
	*real_bytes = *real_bytes + XfBytes;
    }
  if (rest != 0)
    {
      RunningOffset = offset + i* bytesInBunch;
      status= VISIONread (slave, RunningOffset,
			   rest, &XfBytes, data+i*bytesInBunch);
      if (status)
	return (status);
      else
	*real_bytes = *real_bytes + XfBytes;
    }
return (status);
}

/*------------------------------------------------------------------*/

int test_prom (svtvme_t *board)
{
  uint4 *idprom;
  int num_word;
  int i,j;
  int FoundTerm;
  int PreTerm;
  int JustFound;
  int refprom;
  int repeat0;
  int error;
  int status;
  char text[81];

  def_struct(0x10000,&idprom);


  text[0]=0;

  num_word=64*1024;
  /*  status = hit_buffer_IdPromRead(hb0,idprom,num_word,0); */
  status = svtvme_svt_memoryOperation (ID_PROM, SVT_READ, 0, 0, idprom, board);
  assert(status>0);
  if (status <= 0) 
    printf("VME error. ID Prom read with status %d\n\n", status);
  else
    for (i=0; i<num_word; i++) idprom[i] = idprom[i] >>24 & 0xFF;


  FoundTerm = 0;
  PreTerm=0;
  j = 0;
  refprom = 0;
  repeat0 = 1;
  error=0;
  for (i=0; i<num_word; i++) {
    if (!FoundTerm)
      {
	if (PreTerm & (idprom[i]==0xFF)) FoundTerm=1;
	if (idprom[i]==0xFF) PreTerm=1;
	else
	  {
	    text[j++]=idprom[i]; text[j]=0;
	    if (j==80) { printf("%s\n",text); j=0; text[0]=0; }
	  }
	if (FoundTerm & (!JustFound)) JustFound=1;
      }
    else
      {
	if (JustFound) {
	  printf("%s\n",text); JustFound=0;
	  printf("Standard terminator found at add %4ddec %4xhex\n",i,i);
	}
	/* now compare to standard pattern */
	if (idprom[i] != refprom)
	  {
	    printf("Error at add %d %x: ref=%2x, prom=%2x\n",
		 i,i, refprom,idprom[i]);
	    error++;
	  }
      }
    /* update standard pattern for next eprom location */
    if (refprom==0 & repeat0) repeat0=0;
    else refprom++;
    if (refprom==256) {refprom=0; repeat0=1;}
  } /* end loop on 64K prom locations */
  if (error==0)
    printf("Content matches to standard pattern till the end.\nTest OK.\n");
  else
    printf("TEST FAILED!!! %d error found\n", error);

  return ~error;
}

/*------------------------------------------------------------------*/
/*
 *   Bit print of an int expression
 */

void bit_print(int v, int pos)
{
  int i, mask = 1 << 31;
  
  if (pos > 32) i = 32;
  for (i=1;i <= (32-pos); ++i) {
    v <<= 1;
  }
  for (i=1;i <= pos; ++i) {
    putchar(((v & mask) == 0) ? '0' : '1');
    v <<=1;
    if ((32 - pos + i) % 8 ==0 && i != 32) putchar(' ');
  }
  printf("\n");

}

/*------------------------------------------------------------------*/


/*------------------------------------------------------------------*/

/*------------------------------------------------------------------*/

void get_random_seed()
{
  unsigned int seed;
  FILE* seedfile;

  if ( (seedfile = fopen("lastseed","r")) != NULL)
    { fscanf(seedfile,"%i",&seed);
    fclose(seedfile);            }
  else
    seed = rand();
  
  srand(seed);

  return;
}

/*------------------------------------------------------------------*/

void save_random_seed()
{
  unsigned int seed;
  FILE* seedfile;

  seedfile = fopen("lastseed","w");
  seed = rand();
  fprintf(seedfile,"%i\n",seed);
  fclose(seedfile);
  srand(seed);

return;
}