/*************************************************************************
 *
 *  vme_list.c      - Library of routines for readout and buffering of 
 *                    events using a JLAB Trigger Interface V3 (TI) with 
 *                    a Linux VME controller in CODA 3.0.
 * 
 *                    This is for a CDC ADC125 crates controlled by a
 *                    trigger superviser
 *
 *        Modified:  Tue Apr 29 09:57:23 EDT 2014  B. Zihlmann
 *                   adaped for CDC readout using TS
 *
 */


/* Event Buffer definitions */
#define MAX_EVENT_POOL     10
#define MAX_EVENT_LENGTH   4096*1000   /* Size in Bytes: can not be more than 4MB*/

/* Define TI Type (TI_MASTER or TI_SLAVE) */
#define TI_SLAVE
/* TS Fiber Link trigger source (from TI Master, TD, or TS), POLL for available data */
#define TI_READOUT TI_READOUT_TS_POLL 
/* TI VME address, or 0 for Auto Initialize (search for TI by slot) */
#define TI_ADDR (21<<19)            


/* Measured longest fiber length in system */
/*#define FIBER_LATENCY_OFFSET 0x3A */
#define FIBER_LATENCY_OFFSET 0xCA

/* Define buffering level and block level */
/* should be done by setup procedure not hardcoded!*/
#define BUFFERLEVEL 1
#define BLOCKLEVEL 1
/*int blockLevel = BLOCKLEVEL;*/

/*int tsCrate=0;*/

#include "dmaBankTools.h"   /* Macros for handling CODA banks */
#include "tiprimary_list.c" /* Source required for CODA readout lists using the TI */

#include "fa125Lib.h"
extern unsigned int fa125AddrList[FA125_MAX_BOARDS];
extern int fa125A32Base;

#include "ccdb_inc.h" /* include file for C++ API wrapper*/

/* private variables for the time being needed for hard coded stuff*/
int  HOSTROC = 0;
char hnam[128];
char str1[128];
char DETECTOR[128];
int NADCS = 0;
int SLOT = 3;
int SETDACVALUESCONST = 0; /* if set to 1 set all DAC valvues to 0x8000 */ 

/* CCDB DATABASE VARIABLES*/
int DAC_Values[20][72];
int Thresholds[20][72];
int FA125ReadOutMode;
int FA125Latency;
int FA125WindowSize;
int FA125NSB;
int FA125NSA;
int FA125NP;

int ERRORCounter = 0;
int ERRORLOG = 100;

int EventCounter = 0;

/* NOTE THE FOLLOWING IS NEED TO DO SPARSIFICATION ON THE FLY ON THE ROC */
unsigned int new_array[325000];

/****************************************
 *  DOWNLOAD
 ****************************************/
void
rocDownload()
{
  int stat;
  int iFlag;
  int i,k,j;

  /* hard code numbers here for the time being*/
  /* and code that I understand */
  /* CONFIGURATION PARAMETERS FOR THE CRATE AND THE ADCS ARE CURRENTLY TAKEN FROM */
  /* ONLINE_CCDB AS DAQ CONFIGURATiON SCHEEME IS STILL UNDER CONTRUCTION */
  gethostname(hnam,128);
  strncpy(str1, &hnam[6], 128);
  HOSTROC = atoi(str1);
  strncpy(DETECTOR,&hnam[3],3);
  DETECTOR[3] = '\0';

  /*GET DAC values from DATA base and number of ADCS in crate*/
  NADCS = GetDACfromdatabase(HOSTROC, DETECTOR);
  /*if (HOSTROC==9){ //do not use the last 2 ADCs from rocfdc9
    NADCS -= 2;
    }
  */

  /* set DAC values to default constant value if requested*/
  if (SETDACVALUESCONST){
    set_DAC_Defaults(DETECTOR);
  }


  printf("NUMBER OF ADCS: %d\n",NADCS);
/*
  printf("DAC Values:(ADC# CHAN# DAC)\n");
  for (k=0;k<NADCS;k++) {
    for ( j=0;j<72;j++) {
      printf("%d  %d  %d \n", k,j, DAC_Values[k][j]);
    }
  }
*/
  GetReadOutConfigfromdatabase(DETECTOR);
  printf("ADC readout configuration from database:\n");
  printf("Mode       %d\n",FA125ReadOutMode);
  printf("Latency    %d\n",FA125Latency);
  printf("WindowSize %d\n",FA125WindowSize);
  printf("NSB        %d\n",FA125NSB);
  printf("NSA        %d\n",FA125NSA);
  printf("NP         %d\n",FA125NP);


  /* Setup Address and data modes for DMA transfers
   *   
   *  vmeDmaConfig(addrType, dataType, sstMode);
   *
   *  addrType = 0 (A16)    1 (A24)    2 (A32)
   *  dataType = 0 (D16)    1 (D32)    2 (BLK32) 3 (MBLK) 4 (2eVME) 5 (2eSST)
   *  sstMode  = 0 (SST160) 1 (SST267) 2 (SST320)
   */

  vmeDmaConfig(2,5,1);

  /* Define BLock Level variable to a default */
  /* will be set by TS */
  blockLevel = BLOCKLEVEL;

  /*****************
   *   TI SETUP
   *****************/

  /* Set the sync delay width to 0x40*32 = 2.048us */
  tiSetSyncDelayWidth(0x54, 0x40, 1);

  /* Set Trigger Buffer Level */
  tiSetBlockBufferLevel(BUFFERLEVEL);
  /* set ti busy source. NEEDED AT THIS POINT IN TIME !!!*/
  tiSetBusySource(TI_BUSY_LOOPBACK,1);

  printf("rocDownload: Initialize ADCs\n");

  int offset = 0;

  for (k=0;k<NADCS;k++){
    int slot = k+SLOT+offset;
    if (slot==10){
      offset = 2;
    }
    fa125AddrList[k] = (slot<<19);
  }
  iFlag  = (1<<17); /* use fa125AddrList */
  /*
    bits 2-1:  defines Trigger source
    (0) 0 0  VXS (P0)
    (1) 0 1  Internal Timer
    (2) 1 0  Internal Multiplicity Sum
    (3) 1 1  P2 Connector (Backplane)
    bit    3:  NOT USED WITH THIS FIRMWARE VERSION
    bits 5-4:  defines Clock Source
    (0) 0 0  P2 Connector (Backplane)
    (1) 0 1  VXS (P0)
    (2) 1 0  Internal 125MHz Clock
  */
  iFlag |= (0<<1);  /* Trigger Source */
  iFlag |= (1<<4);  /* Clock Source */
  iFlag |= (1<<18); /* Skip firmware check*/

  stat = fa125Init(fa125AddrList[0], 0, NADCS, iFlag);
  if (stat != OK) 
    {
      printf("rocDownload ERROR: %s ROC %d   fa125Init failed, stop right here!!!\n", 
	     DETECTOR, HOSTROC);
      return -1;
    }

  sdInit();
  sdSetActiveVmeSlots( fa125ScanMask());
  
  for (k=0;k<NADCS;k++) {
    int S = fa125Slot(k);
    fa125PowerOn(S);

    fa125Reset(S, 0); 

   /*enable all channels*/
    fa125SetChannelEnableMask(S, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF);

    int ichan = 0;
    unsigned short inp, out;
    for(ichan=0; ichan<72; ichan++)  {
 
      printf("Setting DAC Offset %d for slot %d channel %d \n", DAC_Values[k][ichan], S, ichan);
      fa125SetOffset(S,ichan,DAC_Values[k][ichan]);
      inp = DAC_Values[k][ichan];
      out = fa125ReadOffset(S,ichan);
      if (inp!=out){
	printf("DAC ERROR: readback %d not equals input %d\n",out,inp);
      }
      
      printf("Setting Threshold %d for slot %d channel %d \n", Thresholds[k][ichan], S, ichan);
      fa125SetThreshold(S, Thresholds[k][ichan], ichan);
    }
    fa125PrintThreshold(S);


    /* HARD CODED!!!!!!*/
    int pmode = FA125ReadOutMode;
    unsigned int PL = FA125Latency;   
    unsigned int PTW = FA125WindowSize;
    unsigned int NSB = FA125NSB;    
    unsigned int NSA = FA125NSA;   
    unsigned int NP = FA125NP;     
    printf("rocDownload: %s ROC %d   configure readout window size %d and latency %d\n", DETECTOR, HOSTROC, PTW,PL);
    //fa125Reset(S, 0);
    fa125SetProcMode(S, pmode, PL, PTW, NSB, NSA, NP);

  }
  
  sdStatus();     
  tiStatus(0);
  
  
  printf("rocDownload: User Download Executed\n");
  
  printf("\n");
  printf("rocDownload: TI FIBER LATENCY MEASUREMENT  DOWNLOAD %d \n",tiGetFiberLatencyMeasurement());
  printf("\n");
  
}

/****************************************
 *  PRESTART
 ****************************************/
void
rocPrestart()
{
  unsigned short iflag;
  int stat;
  int islot;
  int FA_SLOT;

  /* Unlock the VME Mutex */
  vmeBusUnlock();

  for(islot = 0; islot < NADCS; islot++) {
    FA_SLOT = fa125Slot(islot);

    fa125ResetToken(FA_SLOT);


    fa125Enable(FA_SLOT);
    fa125Status(FA_SLOT,1);
  }

  sdStatus(0);

  printf("\n");
  printf(" TI FIBER LATENCY MEASUREMENT  PRESTART %d \n",tiGetFiberLatencyMeasurement());
  printf("\n");


  printf("rocPrestart: %s ROC %d User Prestart Executed\n", DETECTOR, HOSTROC);

}

/****************************************
 *  GO
 ****************************************/
void
rocGo()
{
  int islot;

  /* Get the broadcasted Block Level from TS or TI Master */
  blockLevel = tiGetCurrentBlockLevel();
  printf("rocGo: Block Level set to %d\n",blockLevel);
  
  /* Enable/Set Block Level on modules, if needed, here */
  for (islot=0;islot<NADCS;islot++) {
    fa125SetBlocklevel(fa125Slot(islot),blockLevel);
  }

  sdStatus(0);

  printf("\n");
  printf("rocGo: TI FIBER LATENCY MEASUREMENT  GO %d \n",tiGetFiberLatencyMeasurement());
  printf("\n");


}

/****************************************
 *  END
 ****************************************/
void
rocEnd()
{
  int islot,k;

  printf("--- TI STATUS ---\n");
  tiStatus(0);

  /*  for (k=0;k<NADCS;k++) {
    int S = fa125Slot(k);
    fa125PowerOff(S);
  }
  */
  printf("rocEnd: %s ROC %d Ended after %d blocks\n", DETECTOR, HOSTROC, tiGetIntCount());
  EventCounter = 0;
}

/****************************************
 *  TRIGGER
 ****************************************/
/*void rocTrigger()*/
rocTrigger(int arg)
{
  int ii, islot;
  int stat, dCnt, len=0, idata;
  unsigned int val;
  unsigned int *start;
  float adc1,adc2;
  int timeout = 100000;
  int iread, gbready;


  EventCounter++;
  
  /*  if (!(EventCounter%100)){*/
  printf("Event Number: %d\n",EventCounter);
  /*}*/
  

  /* Set TI output 1 high for diagnostics */
  /*tiSetOutputPort(1,0,0,0);*/


  /* Readout the trigger block from the TI 
     Trigger Block MUST be reaodut first */
  dCnt = tiReadTriggerBlock(dma_dabufp);
  if(dCnt<=0) {
    ERRORCounter++;
    if (ERRORCounter<100) {
      printf("tiReadTriggerBlock(): %s ROC %d No data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
      daLogMsg("ERROR","tiReadTriggerBlock(): %s ROC %d No data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
    }
    else if (ERRORCounter%ERRORLOG) {
      printf("tiReadTriggerBlock(): %s ROC %d No data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
      daLogMsg("ERROR","tiReadTriggerBlock(): %s ROC %d No data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
      ERRORLOG *=10;
    }
  } else { /* TI Data is already in a bank structure.  Bump the pointer */
    dma_dabufp += dCnt;
    /*printf("TI read block %d \n",dCnt);*/
  }

  /* EXAMPLE: How to open a bank (type=5) and add data words by hand */
  for(iread = 0; iread < timeout; iread++)  {
    gbready = fa125GBready();
    if(gbready == fa125ScanMask())
      break;
  }

  if(iread==timeout) { /* ADCS not responding */
    printf("fa125 timeout  (fa125GBready: 0x%08x != 0x%08x)\n",gbready,fa125ScanMask());
    daLogMsg("ERROR","fa125 timeout  (fa125GBready: 0x%08x != 0x%08x) on Event %d\n",gbready,fa125ScanMask(),EventCounter);
    fa125GStatus(0);
    int thisisslot19 = (gbready & 0x80000);
    //if ((HOSTROC == 8) && (!thisisslot19)){
    if (HOSTROC == 5){

      printf("\n\nTHIS IS ROCFDC8 DO YOU WANT TO CONTINUE? (hit return)....\n");
      getchar();

    }


 
  } else { /* read ADCS */

    BANKOPEN(16,BT_UI4,blockLevel);

    dCnt = fa125ReadBlock(0,(volatile UINT32 *)dma_dabufp, 0x59000, 0x2);

    if(fa125ReadBlockStatus(1)!=0)
      {
	printf(" Token Mask = 0x%08x\n",fa125GetTokenMask());
      }

    if(dCnt<=0) { /* NO DATA FROM ADCS */
      ERRORCounter++;
      if (ERRORCounter<100){
	printf("fa125ReadBlock(): %s ROC %d No fa125 data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
	daLogMsg("ERROR","fa125ReadBlock(): %s ROC %d No fa125 data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
      } else if (ERRORCounter%ERRORLOG){
	ERRORLOG *=10;
	printf("fa125ReadBlock(): %s ROC %d No fa125 data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
	daLogMsg("ERROR","fa125ReadBlock(): %s ROC %d No fa125 data or error.  dCnt = %d\n", DETECTOR, HOSTROC, dCnt);
      }
    }

    dma_dabufp += dCnt;
    
    BANKCLOSE;
    
  } /* got data */ 
  
  fa125ResetToken(fa125Slot(0));  
 
  /* Set TI output 0 low */
  tiSetOutputPort(0,0,0,0);
  
}

void
rocCleanup()
{
  int islot=0;

  printf("rocCleanup: %s ROC %d   : %s: Reset all Modules\n", DETECTOR, HOSTROC, __FUNCTION__);
  
}