/*************************************************************************
*                HB QUICK TEST                                           *
*   Tests one Hit Buffer board.                                          *
*   It performs VME standalone tests first, then data tests              *
*   using two or three other boards: Hit Senderer and Road Senderer.     *
*   One board is also needed as Receiver.                                *
*   Sender and Receiver Boards can be Mergers or HB or AMS.              *
*   Receiver can be same board as one of the Sender, or separate.        *
*                                                                        *
*   Compile this program with: svtvmecomp hb_quick_test                  *
*    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 hbqt.c and hbft.c
*                        Still very limited. Sender and Receiver baords
*                        can only be HitBuffers and crate/slot is
*                        hardwired in the code.
*                        No full data test yet, only 4 words.
*                        No Spy Buffer test
*                        Still uses a lot of old vmesvt calls in
*                        addition to new svtvme stuff.
* 10 aug 00: S.Belforte. Adapt previous version to new svtvme library,
*                        now no calls to vmesvt nor fision. Sender can
*                        be HB/AMS/MRG. Receiver is now only a Merger.
*
**************************************************************************/

#include "svtvme_public.h"


char testCrate[20];

void reset_hb_PowerOnState(svtvme_h board);
int  check_hb_PowerOnState(svtvme_h board);

void define_configuration(svtvme_h *HitSender, svtvme_h *RoadSender,
			  svtvme_h *Receiver, int *ReceiverFifo);

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

  char verb[10];
  uint4   error_flag, error_enable;
  uint4   tmode, hit_spy, roadlimit, phisector;
  uint4   hold, idprom;
  uint4   data, mdata;
  int   status, i, nerr, moreData;
  int   hb1add;
  svtvme_h hb1;
  svtvme_h HitSender, RoadSender, Receiver;
  int ReceiverFifo;

  uint4 *Hits;
  uint4 *Roads;
  uint4 *Outs;
  uint4 *Data;
  uint4 dummy;
  int nhits, nroads, nouts, nw, nwMax;
  int more;
  int   readw;

  char HitSenderCrate[40];
  char RoadSenderCrate[40];
  char ReceiverCrate[40];

  int HitSenderSlot;
  int RoadSenderSlot;
  int ReceiverSlot;


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

  strcpy(verb,"zzz");

  hb1 = svtvme_openBoard(testCrate, hb1add,HB);

  define_configuration(&HitSender, &RoadSender, &Receiver, &ReceiverFifo);
  
  svtvme_setGlobalFlag(VERBOSE,1);

  svtvme_init(HitSender);
  svtvme_setTmode(HitSender);
  svtvme_init(RoadSender);
  svtvme_setTmode(RoadSender);

  reset_hb_PowerOnState(hb1);

  assert (check_hb_PowerOnState(hb1));

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

  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  printf(" Test Mode state : "); bit_print(tmode,1);
  assert ( (tmode&1)==1 );
  printf(" did TM enable work ? Is run LED off ?\n");scanf("%s",verb);

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

  printf("testing FREEZE_VME register ... ");
  assert (svtvme_testRegister (hb1,HB_VME_FREEZE));
  printf("OK\n");

  printf("testing ERROR_LINE_ENABLE register ... ");
  assert (svtvme_testRegister (hb1,HB_ERROR_EN));
  printf("OK\n");

  printf("testing CDF_ERROR_ENABLE register ... ");
  assert (svtvme_testRegister (hb1,HB_CDFERR_EN));
  printf("OK\n");


  /*
   * Test RAM
   */

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

  printf("testing SS_MAP memory ... "); fflush(0);
  assert (svtvme_testMemory(hb1,HB_SS_MAP,2,STOP_AT_FIRST_ERROR,&nerr));
  printf("OK\n");

  printf("testing AM_MAP memory ... "); fflush(0);
  assert (svtvme_testMemory(hb1,HB_AM_MAP,1,STOP_AT_FIRST_ERROR,&nerr));
  printf("OK\n");



/*
 * Init
 */

  status = svtvme_init(hb1);
  printf("\n Init done with status %d\n\n", status);
  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  printf(" Test Mode state : "); bit_print(tmode,1);
  assert ( (tmode&1)==0 );
  printf(" did Init work ? Is run LED on (GREEN) ?\n");scanf("%s",verb);

/*
 * DATA PROCESSING
 */


  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  printf(" Test Mode enabled with status %d\n", status);
  status = svtvme_getState(hb1,HB_TMODE,&tmode);
  assert ( (tmode&1)==1 );

  status = svtvme_setState(hb1,HB_CDFERR_EN, 0);
  status = svtvme_setState(hb1,HB_ERROR_EN, 0);

  status = svtvme_init(HitSender);
  status = svtvme_setTmode(HitSender);
  status = svtvme_init(RoadSender);
  status = svtvme_setTmode(RoadSender);

  /* prepare some generic words to test data paths */
  nwMax=128*1024;
  assert (Data=malloc(nwMax*4));
  assert (Hits=malloc(nwMax*4));
  assert (Roads=malloc(nwMax*4));
  assert (Outs=malloc(nwMax*4));
  Data[0] = 0x255555;
  Data[1] = 0x2aaaaa;
  Data[2] = 0x255555;
  Data[3] = 0x2aaaaa;

  nw=4;
  for (i=0; i<nw; i++) {
    Hits[i] = Data[i];
    Roads[i] = Data[i];
    Outs[i] = Data[i];
  }

  printf("sending Hits..\n");
  svtvme_sendDataOnce(HitSender, nw, Hits, FAST);
  printf("Hits sent\n");
 /*
 did_ds_blink ?
 check_fifo_status;
 */
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==7 );
  /*
 read words from fifo, check data and EF_;
 */
  readw = svtvme_readAllFifo(hb1, HB_HIT_FIFO, nwMax, Data, &more);
  assert (readw==nw);
  
  for (i=0;i<(nw-1);i++) {
    assert( (Data[i] == (Hits[i] | 0x80000000)));
  }
  assert ( (Data[i]&0x7fffff) == Hits[i] );
  assert ( (Data[i]&0x80000000) == 0 );

  printf("HIT_FIFO data path OK\n");

/*
 same for roads;
 */

  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  svtvme_sendDataOnce(RoadSender, nw, Roads, FAST);
  status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==7 );

  readw = svtvme_readAllFifo(hb1, HB_ROAD_FIFO, nwMax, Data, &more);
  assert (readw==nw);
  
  for (i=0;i<(nw-1);i++) {
    assert ( (Data[i] == (Roads[i] | 0x80000000)));
  }
  assert ( (Data[i]&0x7fffff) == Roads[i] );
  assert ( (Data[i]&0x80000000) == 0 );

  printf("ROAD_FIFO data path OK\n");

  /*
 check hold: led, fifo, cable;
 */

  /*dirty trick because merger does not ignore hold, so has
    to clear data sent to AMS=RoadSender */
  svtvme_init(RoadSender);
  svtvme_setTmode(RoadSender);
  svtvme_init(hb1); /* just in AMS spit something out when in run mode */
  svtvme_setTmode(hb1);
  /* end of dirty trick */
  nw=4000;
  printf("Filling Hit fifo to check Hold... ");
  printf("Make sure Hit Ds LED is on (GREEN)\n");
  svtvme_sendDataOnce(HitSender, nw, Hits, SLOW);
  printf("Was Hit Ds LED on (GREEN) ?");scanf("%s",verb);
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==5 );
  assert (SenderHold(HitSender));
  printf("Is Hit Hold LED on (RED) ?");scanf("%s",verb);
  
  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  nw=4000;
  printf("Filling Road fifo to check Hold... ");
  printf("Make sure Road Ds LED is on (GREEN)\n");
  svtvme_sendDataOnce(RoadSender, nw, Roads, SLOW);
  printf("Was Road Ds LED on (GREEN) ?");scanf("%s",verb);
  status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==5 );
  assert (SenderHold(RoadSender));
  printf("Is Road Hold LED on (RED) ?");scanf("%s",verb);

  /*
 check overflow: fifo, error, svt error+led, cdferror+led;
 */

#if 0 /* can't do this from merger yet */
   nw=200;
  svtvme_sendDataOnce(HitSender, nw, Hits, 0);
  status = svtvme_getState(hb1, HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==1 );
#endif

  nw=200;
  svtvme_sendDataOnce(RoadSender, nw, Roads, 0);
  status = svtvme_getState(hb1, HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==1 );

  status = svtvme_setState(hb1, HB_ERROR_EN, 3);
  status = svtvme_getState(hb1, HB_ERROR, &data);
  printf("ERROR REGISTER     = %02x  ",data); bit_print(data, 8);
  /*  assert( data==3 ); this requires also HITS ! */
  assert( data==2 );
  printf("Is SVT_ERROR LED on (YELLOW) ?");scanf("%s",verb);
  printf("Is BACKPLANE Svt_Error LED on (YELLOW) ?");scanf("%s",verb);

  status = svtvme_setState(hb1, HB_CDFERR_EN, 1);
  status = svtvme_getState(hb1, HB_CDFERR, &data);
  printf("CDF ERROR STATUS   = %2x  ",data); bit_print(data, 1);
  assert( data==0 );
  printf("Is CDF_ERROR LED on (RED) ?");scanf("%s",verb);
  printf("Is BACKPLANE Cdf_Error LED on (RED) ?");scanf("%s",verb);
 
  /*
  send output and check data
  */
  status = svtvme_init(hb1);
  status = svtvme_setTmode(hb1);
  status = svtvme_init(Receiver);
  status = svtvme_setTmode(Receiver);

  nw = 4;
  svtvme_sendDataOnce (hb1,nw, Outs, FAST);
  readw = svtvme_readAllFifo (Receiver, ReceiverFifo, 
			      nwMax, Data, &moreData);
  /*  getData (nwMax, &readw, Data, Receiver, ReceiverFifo);*/
  printf("Sent 4 words, found %d in receiver fifo\n",readw);
  assert(readw==4);
  for (i=0;i<readw;i++) {
    assert ( (Data[i]&0x7fffff) == Outs[i] );
  }
  printf("OUTPUT data path OK\n");

  /*
 stop receiver, overflow it, check ds & hold led & status;
 */
  nw = 4000;
  printf("Filling Receiver fifo to check Hold... ");
  printf("Make sure OUT Ds LED is on (GREEN)\n");
  /*  stop_Receiver(Receiver); */
  svtvme_sendDataOnce (hb1, nw, Outs, SLOW);
  printf("Was Out Ds LED on (GREEN) ?");scanf("%s",verb);
  data = svtvme_isHeld(hb1);
  printf("OUTPUT HOLD STATUS    = %1x  ",data); bit_print(data, 1);
  assert( data==1 );
  printf("Is Out Hold LED on (RED) ?");scanf("%s",verb);

  /* now do it in run mode and check spy buffer data path */
  /*
    prepare simple ssmap & ammap, allow jhit/road=all-5 and all-a
    plus allow simple invalid hit/road;
    load simple ssmap & am_map ;
    send hit & road :
    check spys;
    send invalid data & check;
    send parity error & check;
    send lost sync & check;
    stop receiver, send dummy until hold, check hb data flow stops;
        send 5k 600000hex on hit
	send 5k 600000hex on roads
	check test HB ospy ptr = 3969
	flush receiver
	check test HB ospy ptr = 5000 (anyhow > 3969)
    */

  /* all done, now must run extensive ram/ss tests and random test */
 

  reset_hb_PowerOnState(hb1);

  svtvme_closeBoard(hb1);
}

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


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

void reset_hb_PowerOnState(svtvme_h board)
{
  int status;
  status = svtvme_setState(board,HB_ERROR_EN, 0xFF);
  status = svtvme_setState(board,HB_CDFERR_EN, 0);
  status = svtvme_init(board);
}

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

int check_hb_PowerOnState(svtvme_h board){
int status;
uint4 data;

  /*
   * Dump and check HB PowerOn state
   */

  status = svtvme_getState(board,HB_TMODE, &data);
  printf(" Test Mode state : "); bit_print(data,1);
  assert( data==0 );

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

  status = svtvme_getState(board,HB_HIT_FIFO_REG, &data);
  printf("HIT FIFO STATUS    = %2x  ",data); bit_print(data, 3);
  assert( data==6 );

  status = svtvme_getState(board,HB_ROAD_FIFO_REG, &data);
  printf("ROAD FIFO STATUS   = %2x  ",data); bit_print(data, 3);
  assert( data==6 );

  status = svtvme_getState(board, HB_OUT_HOLD, &data);
  printf("OUTPUT HOLD STATUS = %2x  ",data); bit_print(data, 1);

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

  status = svtvme_getState(board, HB_HF_FSM, &data);
  printf("FSMH STATUS        = %2x  ",data); bit_print(data, 2);
  assert( data==3 );

  status = svtvme_getState(board, HB_RF_FSM, &data);
  printf("FSMR STATUS        = %2x  ",data); bit_print(data, 2);
  assert( data==0 );

  status = svtvme_getState(board,HB_VME_FREEZE, &data);
  printf("FREEZE VME         = %2x  ",data); bit_print(data, 1);
  assert( data==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_getState(board,HB_ERROR_EN, &data);
  printf("SVT ERROR ENABLE   = %02x  ",data); bit_print(data, 8);
  assert( data==0xFF );

  status = svtvme_getState(board,HB_CDFERR_EN, &data);
  printf("CDF ERROR ENABLE   = %2x  ",data); bit_print(data, 1);
  assert( data==0 );

  status = svtvme_getState(board,HB_CDFERR, &data);
  printf("CDF ERROR STATUS   = %2x  ",data); bit_print(data, 1);
  assert( data==1 );

  status = svtvme_getState(board,HB_SWITCHES, &data);
  printf("DIP SWITCHES       = %2x  ",data); bit_print(data, 4);
  assert( data==13 );


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

int test_spy_reg(uint4 spy, svtvme_h board){
  int status;
  int ptr, frz, wrp;
  char reg[4];
  uint4 data,mdata;

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

  data = svtvme_spyCounter(board, spy);
  if (data != 0) {
    printf("%s SPY POINTER = %05x  ",reg, data); bit_print(data, 17);
    printf ("    Try to reset it: ");
    status = svtvme_resetSpy(board,spy);
    data = svtvme_spyCounter(board, spy);
    printf("%s SPY POINTER = %05x  ",reg, data); bit_print(data, 17);
  }
  assert( data==0 );

  data = svtvme_isWrapped(board,spy);
  printf("%s SPY WRAP       = %2x  ",reg, data); bit_print(data, 1);
  assert( data==0 );

  data = svtvme_isFrozen(board, spy);
  printf("%s SPY FREEZE     = %2x  ",reg, data); bit_print(data, 1);
  assert( data==0 );

  return 1;
}

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

/*==================================================================*/
/*====================  DATA SEND/READ STUFF =======================*/
/*==================================================================*/

void define_configuration(svtvme_h *HitSender, svtvme_h *RoadSender,
			  svtvme_h *Receiver, int *ReceiverFifo)
{
  char HitSenderCrate[40];
  char RoadSenderCrate[40];
  char ReceiverCrate[40];

  int HitSenderSlot;
  int RoadSenderSlot;
  int ReceiverSlot;

  strcpy (HitSenderCrate,testCrate);
  HitSenderSlot=7;
  strcpy (RoadSenderCrate,testCrate);
  RoadSenderSlot=8;
  strcpy (ReceiverCrate,testCrate);
  ReceiverSlot=16;

  
  *HitSender = svtvme_openBoard(HitSenderCrate, HitSenderSlot,MRG);
  *RoadSender = svtvme_openBoard(RoadSenderCrate, RoadSenderSlot,AMS);
  *Receiver = svtvme_openBoard(ReceiverCrate, ReceiverSlot,MRG);
  *ReceiverFifo = MRG_A_FIFO;
}

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

int SenderHold(svtvme_h board)
{
  int status;
  int data;

  
  if (svtvme_getBoardType(board)==MRG) data=1;
  else data = svtvme_isHeld (board);

  return (data);
}
/*------------------------------------------------------------------*/

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