/*************************************************************************
 *
 *  ti_slave_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 TI in Slave Mode controlled by a
 *                    Master TI or Trigger Supervisor
 *
 *        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   1300000    /* 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  0           

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

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

#define BLOCKLEVEL 1

#include "fa125Lib.h"
extern unsigned int fa125AddrList[FA125_MAX_BOARDS];            /* array of a24 addresses for FA125s */

/* CONFIGURATION IS CURRENTLY DONE USING ONLINE_CCDB */
/* 
#include "confutils.h"
#include "confutils.c"
*/

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

/* Define buffering level */
#define BUFFERLEVEL 10

/* 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 NODAC = 1; /* if set to 1 set all DAC valvues to 0x8000 */ 
int DAC_Values[20][72];
int Thresholds[20][72];
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;

  /* 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';

  NADCS = GetDACfromdatabase(HOSTROC, DETECTOR);
  if (NADCS<1)
    {
      printf("rocDownload ERROR: %s ROC %d    failed to read DAC values from database!", DETECTOR, HOSTROC);
    }
  else
    {
      printf("rocDownload: %s ROC %d    DAC and sparsification values loaded from database for %d ADCs!", DETECTOR, HOSTROC, NADCS);
    }

  /* 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 = 1;


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

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

  /* Set Trigger Buffer Level */
  tiSetBlockBufferLevel(BUFFERLEVEL);

  /* Init the SD library so we can get status info */
  stat = sdInit();
  if(stat==0) 
    {
      tiSetBusySource(TI_BUSY_SWB,1);
      sdSetActiveVmeSlots(0);
      sdStatus(0);
    }
  else
    { /* No SD or the TI is not in the Proper slot */
      tiSetBusySource(TI_BUSY_LOOPBACK,1);
    }
  
  tiStatus(0);


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

  int offset = 0;
  int k = 0;
  for (k=0;k<NADCS;k++)
    {
      fa125AddrList[k] = ((k+SLOT+offset)<<19);
      if (k+SLOT==10){
        offset = 2;
      }
    }
  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 */
  
  stat = fa125Init(0, 0, NADCS, iFlag);
  if (stat != OK) 
    {
      printf("rocDownload ERROR: %s ROC %d   fa125Init failed, stop right here!!!", DETECTOR, HOSTROC);
      return -1;
    }
 
 for (k=0;k<NADCS;k++)
   {
     int S = fa125Slot(k);
     fa125PowerOn(S);
     printf("rocDownload: %s ROC %d   Set DAC values for all channels in ADC slot %d", DETECTOR, HOSTROC,S);
     int ichan = 0;
     for(ichan=0; ichan<72; ichan++) 
       {
	 if (!NODAC){
	   fa125SetOffset(S,ichan,DAC_Values[k][ichan]);
	 } else{
	   fa125SetOffset(S,ichan,0x8000);
	 }
       }
     /* HARD CODED!!!!!!*/
     int pmode = 1;
     unsigned int PL = 500;   
     unsigned int PTW = 160;  
     unsigned int NSB = 3;    
     unsigned int NSA = 30;   
     unsigned int NP = 1;     
     printf("rocDownload: %s ROC %d   configure readout window size %d and latency %d", DETECTOR, HOSTROC, PTW,PL);
     fa125SetProcMode(S, pmode, PL, PTW, NSB, NSA, NP);
   }


  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;

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

  tiStatus(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 */

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


}

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

  tiStatus(0);

  printf("rocEnd: %s ROC %d Ended after %d blocks\n", DETECTOR, HOSTROC, tiGetIntCount());
  
}

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

  EventCounter++;


  /* Set TI output 1 high for diagnostics */
  tiSetOutputPort(1,0,0,0);
  vmeDmaConfig(2,5,1); 
  
  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);
        }
      else if (ERRORCounter%ERRORLOG)
        {
          printf("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=6) and add data words by hand */
  BANKOPEN(6,BT_UI4,blockLevel);
  int ReadyCode=0;
  for(iread=0; iread<timeout; iread++) 
    {
      ReadyCode = fa125GBready();
      if(ReadyCode == fa125ScanMask())
        break;
    }
  if(iread==timeout) 
    {
      ERRORCounter++;
      if (ERRORCounter<100){
        printf("rocTrigger(): %s ROC %d ADC read timeout!\n", DETECTOR, HOSTROC, dCnt);
        printf("              event: %d,  return Mask = %x, should be = %x\n",EventCounter,ReadyCode, fa125ScanMask() );
      } else if (ERRORCounter%ERRORLOG){
        printf("rocTrigger(): %s ROC %d ADC read timeout!\n", DETECTOR, HOSTROC, dCnt);
        printf("              event: %d,  return Mask = %x, should be = %x\n",EventCounter,ReadyCode, fa125ScanMask() );
        ERRORLOG *= 10;
      }
      fa125ResetToken(fa125Slot(0));
      return ;
    }
  else 
    {
      dCnt = fa125ReadBlock(0,(volatile UINT32 *)dma_dabufp, 0x59000, 0x2);
    }
  if(dCnt<=0) 
    {
      fa125ResetToken(fa125Slot(0));
      ERRORCounter++;
      if (ERRORCounter<100)
	{
	  printf("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);
	}
      return;
    } 
  else 
    {
      int dCnt_new = 0;
      int SLOTNUM,CHANNEL;
      int OT = 0;
      int idata = 0;
      unsigned int dataword;
      int WSize;
      
      if (1) /* no sparsification at the moment !!!!!*/
	{
	  dma_dabufp += dCnt;
	}
      else 
	{
	  
	  for(idata=0; idata<dCnt; idata++)
	    {
	      dataword = LSWAP(dma_dabufp[idata]);
	      new_array[dCnt_new++] = dataword;
	      
	      if (((dataword & 0xf8000000) >>27) == 0x10) 
		{
		  SLOTNUM = ((dataword & 0x7C00000)>>22);
		  if (SLOTNUM<11)
		    {
		      SLOTNUM -=3;
		    } else 
		    {
		      SLOTNUM -= 5;
		    }
		} 
	      
	      if (((dataword & 0xf8000000)>>27) != 0x14)
		{
		  
		  OT = 0;
		  CHANNEL = ((dataword & 0x7F00000)>>20) ; 
		  WSize =  (dataword & 0xFFF) / 2 ;
		  int k = 0;
		  int pedcnt = 0;
		  float ped = 0.;
		  for (k=0;k<WSize;k++){
		    dataword =  LSWAP(dma_dabufp[idata+k+1]);
		    adc1 = (float) ((dataword & 0x1FFF0000) >> 16);
		    adc2 = (float) (dataword & 0x1FFF);
		    if (pedcnt<9)
		      {
			ped += (float) (adc1+adc2);
			pedcnt += 2;
			if (pedcnt>9)
			  {
			    ped /= 10.;
			  }
		      }
		    else 
		      {
			float v1 = adc1 -  ped ;
			float v2 = adc2 -  ped ;
			if ((v1>Thresholds[SLOTNUM][CHANNEL] || v2>Thresholds[SLOTNUM][CHANNEL]))
			  {
			    OT = 1;
			  } 
		      }
		  }
		  if (!OT)
		    {
		      dCnt_new--;
		      idata += WSize+1;
		    }
		  else 
		    {
		      for (k=0;k<WSize;k++)
			{
			  dataword =  LSWAP(dma_dabufp[++idata]);
			  new_array[dCnt_new++] = dataword;
			}
		    }
		}
	    }
	  
	  for(idata=0; idata<dCnt_new; idata++)
	    {
	      dma_dabufp[idata] = LSWAP(new_array[idata]);
	    }
	  dma_dabufp += dCnt_new;
	} /* end of sparsification code */
      
    } /* data read*/
  
  BANKCLOSE;
  
  /* 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__);
  
}