/****************************************************************************
 *
 *  fadc250Config.c  -  configuration library file for fADC250 board 
 *
 *  SP, 07-Nov-2013
 *
 *  empty lines and line startes with # - will be ignored
 *  config file format:

CRATE             rocbcal1   <- ROC/crate name, usually IP name
FADC250_ALLSLOTS             <- just keyword - all settings after this line will be implemented
#                                              for all slots, till FADC250_SLOTS will be met
FADC250_SLOTS     3  8  15   <- slot_numbers - in which next settings will be implemented
#                                              till file ends or next FADC250_SLOTS will be met
FADC250_F_REV     0x0216     <- firmware revision  (0x0 Bits:7-0)
FADC250_B_REV     0x0908     <- board revision     (0x0 Bits:15-8)
FADC250_ID        0xfadc     <- board type         (0x0 Bits:31-16)

#                  /---- slots ##
#                 1  2         3         4         5         6         7         8         9        10  11  12          13        14        15        16        17        18        19        20  21
FADC250_ALLSN     0  0  ACDI-013  ACDI-014  ACDI-015  ACDI-016  ACDI-017  ACDI-002  ACDI-019  ACDI-020   0   0  B21595-19R  ACDI-024  ACDI-025  ACDI-026  ACDI-027  ACDI-037  ACDI-038  ACDI-043   0

FADC250_SL_SN     7  ACDI-571    <- single board Serial Number: sl# , SN


FADC250_MODE      1   <- process mode: 1-4  (0x10C Bits:2-0)
FADC250_W_OFFSET  50  <- number of sample back from trigger point. (0x120)
#                           (in Manual it is  PL=Trigger_Window(ns) * 250MHz)
FADC250_W_WIDTH   49  <- number of ADC sample to include in trigger window. (0x11C)
#                           (in M:  PTW=Trigger_Window(ns) * 250MHz, minimum is 6)
FADC250_NSB       3   <- number of sample before trigger point to include in data processing. (0x124)
#                           This include the trigger Point. (minimum is 2 in all mode)
FADC250_NSA       6   <- number of sample after trigger point to include in data processing. (0x128)
#                           Minimum is (6 in mode 2) and ( 3 in mode 0 and 1).
#                           Number of sample report is 1 more for odd and 2 more for even NSA number.
FADC250_NPEAK     1   <- number of Pulses in Mode 2 and 3.  (0x10C Bits:6-5)
#
#                 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 - channels ##
FADC250_ADC_MASK  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1  0   <- channel enable mask (0x110)
FADC250_TRG_MASK  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1   <- trigger enable mask 
#                                               (channel includes in global trigger, if bit set to 1)
#
FADC250_TET       110        <- board Trigger Energy Threshold (TET), same for all 16 channels
FADC250_CH_TET    0    110   <- channel# and TET_value for this channel
FADC250_ALLCH_TET 111  222  2  3  4  5  6  7  8  9  10  11  12  13  14  15   <- 16 TETs (0x12C - 0x148)
#
FADC250_DAC       3300       <- board DAC, one and the same for all 16 channels
FADC250_CH_DAC    0    3300  <- channel# and DAC_value for this channel
FADC250_ALLCH_DAC 3300 3280 3310 3280 3310 3280 3310 3280 3300 3280 3300 3280 3310 3280 3310 3280 <- 16 DACs
#
FADC250_PED       210        <- board Pedestals, same for all channels
FADC250_CH_PED    0    210   <- channel# and Pedestal_value for this channel
FADC250_ALLCH_PED 210  220  210  215  215  220  220  210  210  215  215  220  220  210  215  220  <- 16 PEDs



 cc -rdynamic -shared -o fadc250Config.so fadc250Config.c -I/home/halld/test_setup/coda/linuxvme/include /home/halld/test_setup/coda/linuxvme/jvme/libjvme.a /home/halld/test_setup/coda/linuxvme/fadcV2/libfadc.a -ldl -lpthread -lrt

/home/halld/test_setup/coda/linuxvme/fadcV2/fadcLib.c
/home/halld/test_setup/coda/linuxvme/fadcV2/fadcLib.h

 */

#include <stdio.h>
#include <string.h>
#include <jvme.h>

#include "fadc250Config.h"
#include "fadcLib.h"

extern int          nfadc;                        /* Number of FADC250s verified with the library */
extern int          fadcID[FA_MAX_BOARDS];        /* Array of slot numbers, discovered by the library */
extern unsigned int fadcAddrList[FA_MAX_BOARDS];  /* Array of a24 addresses for FADCs */
extern volatile struct fadc_struct *FAp[(FA_MAX_BOARDS+1)]; /* pointers to FADC memory map */

static int iFlag;
static int Naddr;
static int AllSl;

static FADC250_CONF  fa250[NBOARD];


#define SCAN_MSK \
	args = sscanf (str_tmp, "%*s %d %d %d %d %d %d %d %d   \
                                     %d %d %d %d %d %d %d %d", \
		       &msk[ 0], &msk[ 1], &msk[ 2], &msk[ 3], \
		       &msk[ 4], &msk[ 5], &msk[ 6], &msk[ 7], \
		       &msk[ 8], &msk[ 9], &msk[10], &msk[11], \
		       &msk[12], &msk[13], &msk[14], &msk[15])


#define SCAN_B_MSKS(BKEYWORD,BSTRUCT) \
  else if(strcmp(keyword,(BKEYWORD)) == 0) \
      { \
	SCAN_MSK; \
	ui1 = 0; \
	for(jj=0; jj<NCHAN; jj++) \
	{ \
	  if((msk[jj] < 0) || (msk[jj] > 1)) \
	  { \
	    printf("\nReadConfigFile: Wrong mask bit value, %d\n\n",msk[jj]); return(-7); \
	  } \
	  if(strcmp(keyword,"FADC250_ADC_MASK") == 0) msk[jj] = ~(msk[jj])&0x1; \
	  ui1 |= (msk[jj]<<jj); \
	} \
	for(ii=3; ii<NBOARD; ii++) if(fa250[ii].group == gr) (BSTRUCT) = ui1; \
	printf("\nReadConfigFile: %s = 0x%04x \n",keyword,ui1); \
      }

#define SCAN_B_XSETS(BKEYWORD,BSTRUCT) \
  else if(strcmp(keyword,(BKEYWORD)) == 0) \
      { \
        sscanf (str_tmp, "%*s %x", &i1); \
	for(ii=3; ii<NBOARD; ii++) if(fa250[ii].group == gr) (BSTRUCT) = i1; \
      }

#define SCAN_B_SETS(BKEYWORD,BSTRUCT) \
  else if(strcmp(keyword,(BKEYWORD)) == 0) \
      { \
        sscanf (str_tmp, "%*s %d", &i1); \
	for(ii=3; ii<NBOARD; ii++) if(fa250[ii].group == gr) (BSTRUCT) = i1; \
      }

#define SCAN_TDP(TDP_K,TDP_S) \
  else if(strcmp(keyword,(TDP_K)) == 0)	\
      { \
        sscanf (str_tmp, "%*s %d", &ui1); \
	for(ii=3; ii<NBOARD; ii++)  if(fa250[ii].group == gr) \
	  for(jj=0; jj<NCHAN; jj++)   (TDP_S)[jj] = ui1; \
      }

#define SCAN_TDP_CH(TDP2_K,TDP2_S) \
  else if(strcmp(keyword,(TDP2_K)) == 0) \
      { \
        sscanf (str_tmp, "%*s %d %d", &chan, &ui1); \
        if((chan<3) || (chan>=NCHAN)) \
        { \
	  printf("\nReadConfigFile: Wrong channel number %d, %s\n",slot,str_tmp); \
	  return(-8); \
        } \
	for(ii=3; ii<NBOARD; ii++)  if(fa250[ii].group == gr)  (TDP2_S)[chan] = ui1; \
      }

#define SCAN_TDP_ALLCH(TDP3_K,TDP3_S) \
  else if(strcmp(keyword,(TDP3_K)) == 0) \
      { \
	SCAN_MSK; \
	if(args != 16) \
        { \
	  printf("\nReadConfigFile: Wrong argument's number %d, should be 16\n\n",args); \
          return(-9); \
        } \
	for(ii=3; ii<NBOARD; ii++)  if(fa250[ii].group == gr) \
	  for(jj=0; jj<NCHAN; jj++)   (TDP3_S)[jj] = msk[jj]; \
      }



void
fadc250InitGlobals()
{
  int ii, jj;

  nfadc = 0;

  for(ii=0; ii<NBOARD; ii++)
  {
    sprintf(fa250[ii].SerNum, "%s", "");
    fa250[ii].group     = 0;
    fa250[ii].f_rev     = 0x0216;
    fa250[ii].b_rev     = 0x0908;
    fa250[ii].b_ID      = 0xfadc;
    fa250[ii].mode      = 1;
    fa250[ii].winOffset = 50;
    fa250[ii].winWidth  = 49;
    fa250[ii].nsb       = 3;
    fa250[ii].nsa       = 6;
    fa250[ii].npeak     = 1;
    fa250[ii].chDisMask = 0x0;
    fa250[ii].trigMask  = 0xffff;

    for(jj=0; jj<NCHAN; jj++)
    {
      fa250[ii].thr[jj] = 110;
      fa250[ii].dac[jj] = 3300;
      fa250[ii].ped[jj] = 210;
    }
  }
  /*
  for(ii=0; ii<NBOARD; ii++) printf("ReadConfigFile: ****** fa250[%d].group = %d \n",ii,fa250[ii].group);
  */

  /* Setup the iFlag.. flags for FADC initialization */
  iFlag = 0;
  /* Sync Source */
  iFlag |= (1<<0);    /* VXS */
  /* Trigger Source */
  iFlag |= (1<<2);    /* VXS */
  /* Clock Source */
  /*iFlag |= (1<<5);*/    /* VXS */
  iFlag |= (0<<5);    /* self*/
}


/* reading and parsing config file */
int
fadc250ReadConfigFile(char *filename)
{
  FILE   *fd;
  char   fname[FNLEN] = { "" };  /* config file name */
  int    ii, jj, ch;
  char   str_tmp[STRLEN], str2[STRLEN], keyword[ROCLEN];
  char   host[ROCLEN], ROC_name[ROCLEN];
  int    args, i1, i2, msk[16];
  char   sn[NBOARD][12];
  int    slot, chan, gr = 0;
  UINT32 ui1, ui2;
  char   *getenv();
  char   *halldparms;

  halldparms = getenv("HALLD_PARMS");
  gethostname(host,ROCLEN);

  if(strlen(filename)!=0) /* filename specified */
  {
    if ( filename[0]=='/' || (filename[0]=='.' && filename[1]=='/') )
    {
      sprintf(fname, "%s", filename);
    }
    else
    {
      sprintf(fname, "%s/fadc250/%s", halldparms, filename);
    }

    if((fd=fopen(fname,"r")) == NULL)
    {
      printf("\nReadConfigFile: Can't open config file >%s<\n",fname);
      return(-1);
    }
  }
  else /* filename does not specified */
  {
    sprintf(fname, "%s/fadc250/%s.cnf", halldparms, host);
    if((fd=fopen(fname,"r")) == NULL)
    {
      sprintf(fname, "%s/fadc250/default.cnf", halldparms);
      if((fd=fopen(fname,"r")) == NULL)
      {
        printf("\nReadConfigFile: Can't open config file >%s<\n",fname);
        return(-2);
      }
    }
  }
  printf("\nReadConfigFile: Using configuration file >%s<\n",fname);


  AllSl = 0;


  /* Parsing of config file */
  while ((ch = getc(fd)) != EOF)
  {
    if ( ch == '#' || ch == ' ' || ch == '\t' )
    {
      while (getc(fd) != '\n') {}
    }
    else if( ch == '\n' ) {}
    else
    {
      ungetc(ch,fd);
      fgets(str_tmp, STRLEN, fd);
      sscanf (str_tmp, "%s %s", keyword, ROC_name);


      /* Start parsing real config inputs */
      if(strcmp(keyword,"CRATE") == 0)
      {
	if(strcmp(ROC_name,host) != 0)
        {
	  printf("\nReadConfigFile: conf_CRATE_name = \"%s\"  host = \"%s\"\n",ROC_name,host);
	  printf("\nReadConfigFile: Wrong crate name in config file, %s\n",str_tmp);
          return(-3);
        }
	printf("\nReadConfigFile: conf_CRATE_name = %s  host = %s\n",ROC_name,host);
      }

      else if(strcmp(keyword,"FADC250_ALLSLOTS") == 0)
      {
	AllSl = 1;
	gr++;
	for(ii=3; ii<NBOARD; ii++)  if(ii!=11 && ii!=12)  fa250[ii].group = gr;
      }

      else if(strcmp(keyword,"FADC250_SLOTS") == 0)
      {
	gr++;
	SCAN_MSK;
	printf("\nReadConfigFile: gr = %d     args = %d \n",gr,args);

	for(ii=0; ii<args; ii++)
	{
	  slot = msk[ii];
	  if(slot<3 || slot==11 || slot==12 || slot>20)
	  {
	    printf("\nReadConfigFile: Wrong slot number %d, %s\n",slot,str_tmp);
	    return(-4);
	  }
	  fa250[slot].group = gr;
	}
      }

      SCAN_B_XSETS("FADC250_F_REV",   fa250[ii].f_rev)

      SCAN_B_XSETS("FADC250_B_REV",   fa250[ii].b_rev)

      SCAN_B_XSETS("FADC250_ID",      fa250[ii].b_ID)

      else if(strcmp(keyword,"FADC250_ALLSN") == 0)
      {
	args = sscanf (str_tmp, "%*s %s %s %s %s %s %s %s %s %s %s \
                                     %s %s %s %s %s %s %s %s %s %s %s",
		       &sn[ 1], &sn[ 2], &sn[ 3], &sn[ 4], &sn[ 5], &sn[ 6], &sn[ 7],
		       &sn[ 8], &sn[ 9], &sn[10], &sn[11], &sn[12], &sn[13], &sn[14],
		       &sn[15], &sn[16], &sn[17], &sn[18], &sn[19], &sn[20], &sn[21]);
	if(args != 21)
	{
	  printf("\nReadConfigFile: Wrong number of SNs %d, should be 21 :: %s\n\n",args,str_tmp);
	  return(-5);
	}
	for(ii=1; ii<NBOARD; ii++) sprintf((char *)fa250[ii].SerNum, "%s", sn[ii]);
      }

      else if(strcmp(keyword,"FADC250_SL_SN") == 0)
      {
	sscanf (str_tmp, "%*s %d %s",  &slot, &sn[0]);
	if(slot<3 || slot==11 || slot==12 || slot>20)
	{
	  printf("\nReadConfigFile: Wrong slot number %d, %s\n",slot,str_tmp);
	  return(-6);
	}
	sprintf((char *)fa250[slot].SerNum, "%s", sn[0]);
      }

      SCAN_B_SETS("FADC250_MODE",     fa250[ii].mode)

      SCAN_B_SETS("FADC250_W_OFFSET", fa250[ii].winOffset)

      SCAN_B_SETS("FADC250_W_WIDTH",  fa250[ii].winWidth)

      SCAN_B_SETS("FADC250_NSB",      fa250[ii].nsb)

      SCAN_B_SETS("FADC250_NSA",      fa250[ii].nsa)

      SCAN_B_SETS("FADC250_NPEAK",    fa250[ii].npeak)

      SCAN_B_MSKS("FADC250_ADC_MASK", fa250[ii].chDisMask)

      SCAN_B_MSKS("FADC250_TRG_MASK", fa250[ii].trigMask)


      SCAN_TDP("FADC250_TET",fa250[ii].thr)

      SCAN_TDP_CH("FADC250_CH_TET",fa250[ii].thr)

      SCAN_TDP_ALLCH("FADC250_ALLCH_TET",fa250[ii].thr)


      SCAN_TDP("FADC250_DAC",fa250[ii].dac)

      SCAN_TDP_CH("FADC250_CH_DAC",fa250[ii].dac)

      SCAN_TDP_ALLCH("FADC250_ALLCH_DAC",fa250[ii].dac)


      SCAN_TDP("FADC250_PED",fa250[ii].ped)

      SCAN_TDP_CH("FADC250_CH_PED",fa250[ii].ped)

      SCAN_TDP_ALLCH("FADC250_ALLCH_PED",fa250[ii].ped)
    }
  }
  fclose(fd);

  /* fill up fadcAddrList, to init only fadc250 from config file */
  Naddr = 0;
  if(AllSl == 0)   /* fill up only if FADC250_ALLSLOTS was not called */
    for(ii=3; ii<NBOARD; ii++)
      if(fa250[ii].group > 0)
      {
	fadcAddrList[Naddr] = ii<<19;
	Naddr++;
	printf("\nReadConfigFile:  ...fadcAddrList[%d] = 0x%08x  group=%d\n",
	       (Naddr-1),fadcAddrList[Naddr-1], fa250[ii].group);
      }

  /*
  for(ii=0; ii<NBOARD; ii++)
    printf("  ..Board [%2d] Serial Number = %s \n", ii, fa250[ii].SerNum);
  */

  gr--;
  return(gr);
}


int
fadc250DownloadAll()
{
  int FA_SLOT, gg, ii, jj;

  /* download setting into all found fadc250 if FADC250_ALLSLOTS was not called */
  if(AllSl == 1)
  {
    gg = 5000;
    for(ii=0; ii<nfadc; ii++)
      fa250[fadcID[ii]].group = 5005;
  }
  else  gg = 0;
  for(ii=3; ii<NBOARD; ii++)
  {
    if(fa250[ii].group > gg)
    {
      FA_SLOT = ii;
      printf("\nfadc250DownloadAll:  FA_SLOT=%d   fa250[%d].group=%d\n",
	     FA_SLOT,ii,fa250[ii].group);

      faSetProcMode(FA_SLOT,
		    fa250[ii].mode,
		    fa250[ii].winOffset,
		    fa250[ii].winWidth,
		    fa250[ii].nsb,
		    fa250[ii].nsa,
		    fa250[ii].npeak, 0);
      faChanDisable(  FA_SLOT, fa250[ii].chDisMask);
      for(jj=0; jj<NCHAN; jj++)
      {
	faSetDAC(             FA_SLOT, fa250[ii].dac[jj], (1<<jj));
	faSetThreshold(       FA_SLOT, fa250[ii].thr[jj],(1<<jj));
	faSetChannelPedestal( FA_SLOT, jj, fa250[ii].ped[jj]);
      }
    }
  }

  return(0);
}


/* main function, it calls faInit two times: */
/* faInit((unsigned int)(3<<19),(1<<19),18,iFlag);    start from 0x00180000, increment 0x00080000 */
/* faInit((unsigned int)(3<<19),(1<<19),Naddr,iFlag); use fadcAddrList { iFlag |= (1<<17); }  */
int
fadc250Config(char *fname)
{
  int res;

  /* set defaults */
  fadc250InitGlobals();

  /* reading and parsing config file */
  if( (res = fadc250ReadConfigFile(fname)) < 0 ) return(res);

  /* 1-st Init: init all fadc250 in a crate */
  vmeSetQuietFlag(1); /* skip the errors associated with BUS Errors */
  faInit((unsigned int)(3<<19),(1<<19),18,iFlag);
  printf("\n\n  -----------  Naddr = %d     nfadc = %d  -----------\n\n",Naddr,nfadc);

  /* 2-nd Init: init only fadc250 from config file */
  if(AllSl == 0)
  {
    iFlag |= (1<<17);   /* activate useing fadcAddrList in faInit */
    /*  faInit((unsigned int)(3<<19),(1<<19),Naddr,iFlag); */
    faInit(fadcAddrList[0],0,Naddr,iFlag);
  }
  vmeSetQuietFlag(0); /* turn the error statements back on */

  /* download to all boards */
  fadc250DownloadAll();

  return(0);
}


/* print board registers; if slot is zero, print all boards */
void
fadc250Mon(int slot)
{
  int  sl, sl2, ii, jj;
  int  f_rev;
  int  b_rev;
  int  b_ID;
  char SerNum[12];
  int  mode;
  unsigned int winOffset;
  unsigned int winWidth;
  unsigned int nsb;
  unsigned int nsa;
  unsigned int npeak;
  unsigned int chDisMask;
  unsigned int chEnaMask;
  unsigned int trigMask;
  unsigned int adcConf[3];
  unsigned short pval[NCHAN];

  sl2 = slot;
  for(ii=0; ii<nfadc; ii++)
  {
    sl = fadcID[ii];
    if(slot==0) sl2 = sl;

    if(sl == sl2)
    {
      /*
      faStatus(sl,0);
      */

      f_rev =  vmeRead32(&FAp[sl]->version);
      b_ID  = ((f_rev)&FA_BOARD_MASK)>>16;
      f_rev = (f_rev)&0xffff;
      b_rev = (vmeRead32(&(FAp[sl]->adc_status[0]))&0xFFFF)&FA_ADC_VERSION_MASK;

      adcConf[0] = (vmeRead32(&(FAp[sl]->adc_config[0]))&0xFFFF);
      adcConf[1] = (vmeRead32(&(FAp[sl]->adc_config[1]))&0xFFFF);

      mode      = (adcConf[0]&FA_ADC_PROC_MASK) + 1;
      winOffset = (vmeRead32(&(FAp[sl]->adc_pl))&0xFFFF)*FA_ADC_NS_PER_CLK;
      winWidth  = (vmeRead32(&(FAp[sl]->adc_ptw))&0xFFFF)*FA_ADC_NS_PER_CLK;
      nsb       = (vmeRead32(&(FAp[sl]->adc_nsb))&0xFFFF)*FA_ADC_NS_PER_CLK;
      nsa       = (vmeRead32(&(FAp[sl]->adc_nsa))&0xFFFF)*FA_ADC_NS_PER_CLK;
      for(jj=0; jj<NCHAN; jj++) 
	pval[jj] = vmeRead32(&FAp[sl]->adc_pedestal[jj]) & FA_ADC_PEDESTAL_MASK;
      npeak     = (adcConf[0]&FA_ADC_PEAK_MASK)>>4;
      chDisMask = (adcConf[1]&FA_ADC_CHAN_MASK);
      chEnaMask = ~(chDisMask)&0xFFFF;

      faGetSerialNumber(sl, (char **)&SerNum, 1);

      printf("\nFADC250 number %d in slot %d\n", ii, sl);
      printf("  Board Firmware Rev  = 0x%04x\n", f_rev);
      printf("  ADC Processing Rev  = 0x%04x\n", b_rev);
      printf("  Board Type/ID       = 0x%04x\n", b_ID);
      printf("  Board Serial Number = %s ",      SerNum);
      printf(",     Conf.SN = %s\n",   fa250[sl].SerNum);

      printf("\n ADC Processing Configuration: \n");
      printf("   Channel Enable Mask = 0x%04x\n", chEnaMask);

      printf("   Window Offset (PL)  = %d ns\n", winOffset);
      printf("   Window Width  (PTW) = %d ns\n", winWidth);
      printf("   Time Before Peak    = %d ns\n", nsb);
      printf("   Time After Peak     = %d ns\n", nsa);
      printf("   Max Peak Count      = %d \n",   npeak);
      printf("   Mode = %d  \n\n",mode);

      faPrintDAC(sl);
      printf("\n");
      faPrintThreshold(sl);

      printf("\n Pedestal Settings for FADC in slot %d:",sl);
      for(jj=0; jj<NCHAN; jj++) 
      {
	if((jj%4)==0) printf("\n");
	printf("Chan %2d: %5d   ",(jj+1),pval[jj]);
      }
      printf("\n-----------------------------------------------------------------\n");

    }
  }
}


/************************************************************************/
/************************************************************************/
/************************************************************************/

void
SP1()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
}

void
SP2(char *str)
{
  char * pch;
  char str2[3][80];
  int zz;

  if(strstr(str,":"))
  {
    printf ("Splitting string \"%s\" into tokens:\n",str);
    pch = strtok (str,":");
    zz=0;
    while (pch != NULL && zz<2)
      {
	printf ("%s\n",pch);
	sprintf(str2[zz], "%s", pch);
	zz++;
	pch = strtok (NULL, ":");
      }
    zz = atoi(str2[1]);
    printf ("\n host =  \"%s\"    port = %d\n\n",str2[0],zz);
  }
}