/****************************************************************************
 *
 *  dsc2Config.c  -  configuration library file for dsc2 board 
 *
 *  SP, 02-Dec-2013
 *
 *  empty lines and line startes with # - will be ignored
 *  config file format:

CRATE          rocbcal1   <- ROC/crate name, usually IP name
DSC2_ALLSLOTS             <- just keyword - all settings after this line will be implemented
#                                              for all slots, till DSC2_SLOTS will be met
DSC2_SLOTS     3  8  15   <- slot_numbers - in which next settings will be implemented
#                                              till file ends or next DSC2_SLOTS will be met
DSC2_SLOT      2          <- slot_number - next settings will be implemented only to this slot

DSC2_F_REV     0x010c     <- firmware revision                          (0x0400 Bits:15-0)
DSC2_ID        0x44534332 <- board type, 0x44534332 = "DSC2" in ASCII   (0x0404 Bits:31-0)

#               /---- slots ##
#              1         2         3         4         5         6         7         8         9        10  11  12        13        14        15        16        17        18        19        20         21
DSC2_ALLSN     0  TRIS-010  TRIS-013  TRIS-014  TRIS-015  ACDI-016  ACDI-017  ACDI-018  ACDI-019  ACDI-020   0   0  ACDI-023  ACDI-024  ACDI-322  ACDI-026  ACDI-027  ACDI-037  ACDI-038  ACDI-043   ACDI-046

DSC2_SL_SN     15  ACDI-322    <- single board Serial Number: sl# , SN


DSC2_WIDTH     20  40     <- TDC width (ns),   TRG width (ns)

#               0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 - channels ##
DSC2_TDCMASK    1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1     <- TDC enable mask
DSC2_TRGMASK    1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1     <- TRG enable mask
DSC2_TDCORMASK  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1     <- TDC OR mask
DSC2_TRGORMASK  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1     <- TRG OR mask

DSC2_THRESHOLD         20  50   <- board threshold: TDC threshold (mV), TRG threshold (mV)
DSC2_CH_THRESHOLD   0  20  50   <- channel threshold: channel#, TDC threshold (mV), TRG threshold (mV)

# following, if used, will supersede TRG width:
DSC2_TRGDIGITAL        40  64    <- board digital TRG output: width (ns), delay (ns)
DSC2_CH_TRGDIGITAL  0  40  64    <- channel digital TRG output: channel#, width (ns), delay (ns)


 cc -rdynamic -shared -o dsc2Config.so dsc2Config.c -DLinux_vme -I/home/halld/test_setup/coda/linuxvme/include /home/halld/test_setup/coda/linuxvme/jvme/libjvme.a /home/halld/test_setup/coda/linuxvme/dsc2/libdsc2.a -ldl -lpthread -lrt

 */

#if defined(VXWORKS) || defined(Linux_vme)

#ifdef VXWORKS
#include <vxWorks.h>
#include <vxLib.h>
#include <logLib.h>
#else
#include "jvme.h"
#endif

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

#include "dsc2Lib.h"
#include "dsc2Config.h"


#undef DEBUG

#define FNLEN     128       /* length of config. file name */
#define STRLEN    250       /* length of str_tmp */
#define ROCLEN     80       /* length of ROC_name */
#define NBOARD     22


/* Global variables */
static int       Ndsc = 0;                  /* Number of DSCs in Crate */
static DSC2_CONF dsc[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 DSC2_READ_MASKS(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(-6); \
	  } \
	  ui1 |= (msk[jj]<<jj); \
	} \
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) (BSTRUCT) = ui1; \
	printf("\nReadConfigFile: %s = 0x%04x \n",keyword,ui1); \
      }

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




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



/*
cd "/usr/local/clas12/coda/src/rol/VXWORKS_ppc/lib"
ld < librol.so
dsc2Init(0x100000,0x80000,20,0)
dsc2Config("")
dsc2Mon(0)
*/

/* main function, have to be called after dsc2Init() */
int
dsc2Config(char *fname)
{
  int res;

  /* set defaults */
  dsc2InitGlobals();

  /* dsc2Init() must be called by now; get the number of boards from there */
  Ndsc = dsc2GetNdsc();
  printf("dsc2Config: Ndsc=%d\n",Ndsc);

  /* read config file */
  if( (res = dsc2ReadConfigFile(fname)) < 0 ) return(res);

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

  return(0);
}


void
dsc2InitGlobals()
{
  int ii, jj;

  for(ii=0; ii<NBOARD; ii++)
  {
    sprintf(dsc[ii].SerNum, "%s", "");
    dsc[ii].group     = 0;
    dsc[ii].f_rev     = 0x010c;
    dsc[ii].b_ID      = 0x44534332;
    dsc[ii].TDCChMask = 0xffff;
    dsc[ii].TRGChMask = 0xffff;
    dsc[ii].TDCORMask = 0xffff;
    dsc[ii].TRGORMask = 0xffff;
    dsc[ii].TDCWidth  = 40;
    dsc[ii].TRGWidth  = 40;
    for(jj=0; jj<NCHAN; jj++) dsc[ii].TDCThreshold[jj]    = 20;
    for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGThreshold[jj]    = 40;
    for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGDigitalWidth[jj] = 0;
    for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGDigitalDelay[jj] = 0;
  }
}


/* reading and parsing config file */
/* config file will be selected using following rules:
     1. use 'filename' specified; if name starts from '/' or './', use it,
        otherwise use file from '$CLON_PARMS/dsc2/' area
     2. if name is "", use file 'hostname'.conf from '$CLON_PARMS/dsc2/' area
     3. if previous does not exist, use file '$EXPID.conf' from '$CLON_PARMS/dsc2/' area
 */
int
dsc2ReadConfigFile(char *filename)
{
  FILE   *fd;
  char   fname[FNLEN] = { "" };  /* config file name */
  int    ii, jj, ch, gr = 0;
  char   str_tmp[STRLEN], keyword[ROCLEN];
  char   host[ROCLEN], ROC_name[ROCLEN];
  int    args, i1, i2, msk[NCHAN];
  char   sn[NBOARD][12];
  int    slot, chan;
  UINT32 ui1;
  char   *getenv();
  char   *clonparms;
  char   *expid;
  char   *halldparms;


  expid      = getenv("EXPID");
  clonparms  = getenv("CLON_PARMS");
  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/dsc2/%s", clonparms, filename); */
      sprintf(fname, "%s/dsc2/%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/dsc2/%s.conf", clonparms, host); */
    sprintf(fname, "%s/dsc2/%s.conf", halldparms, host);
    if((fd=fopen(fname,"r")) == NULL)
    {
      /* sprintf(fname, "%s/dsc2/%s.conf", clonparms, expid); */
      sprintf(fname, "%s/dsc2/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);


  /* 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", keyword);
#ifdef DEBUG
      printf("\nfgets returns %s so keyword=%s\n\n",str_tmp,keyword);
#endif


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

      else if(strcmp(keyword,"DSC2_ALLSLOTS") == 0)
      {
	gr++;
	for(ii=0; ii<NBOARD; ii++)  dsc[ii].group = gr;
      }

      else if(strcmp(keyword,"DSC2_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<1 || slot>21)
	  {
	    printf("\nReadConfigFile: Wrong slot number %d, %s\n",slot,str_tmp);
	    return(-4);
	  }
	  dsc[slot].group = gr;
	}
      }

      else if(strcmp(keyword,"DSC2_SLOT") == 0)
      {
	gr++;
        sscanf (str_tmp, "%*s %d", &slot);
	if(slot<1 || slot>21)
	{
	  printf("\nReadConfigFile: Wrong slot number %d, %s\n",slot,str_tmp);
	  return(-5);
	}
	dsc[slot].group = gr;
      }

      DSC2_B_XSCAN("DSC2_F_REV", dsc[ii].f_rev)

      DSC2_B_XSCAN("DSC2_ID",    dsc[ii].b_ID)

      else if(strcmp(keyword,"DSC2_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 *)dsc[ii].SerNum, "%s", sn[ii]);
      }

      else if(strcmp(keyword,"DSC2_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 *)dsc[slot].SerNum, "%s", sn[0]);
      }

      DSC2_READ_MASKS("DSC2_TDCMASK",   dsc[ii].TDCChMask)

      DSC2_READ_MASKS("DSC2_TRGMASK",   dsc[ii].TRGChMask)

      DSC2_READ_MASKS("DSC2_TDCORMASK", dsc[ii].TDCORMask)

      DSC2_READ_MASKS("DSC2_TRGORMASK", dsc[ii].TRGORMask)

      else if(strcmp(keyword,"DSC2_WIDTH") == 0)
      {
        sscanf (str_tmp, "%*s %d %d", &i1, &i2);
	for(ii=0; ii<NBOARD; ii++)  if(dsc[ii].group == gr)  dsc[ii].TDCWidth = i1;
	for(ii=0; ii<NBOARD; ii++)  if(dsc[ii].group == gr)  dsc[ii].TRGWidth = i2;
      }

      else if(strcmp(keyword,"DSC2_THRESHOLD") == 0)
      {
        sscanf (str_tmp, "%*s %d %d", &i1, &i2);
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) for(jj=0; jj<NCHAN; jj++) dsc[ii].TDCThreshold[jj] = i1;
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGThreshold[jj] = i2;
      }

      else if(strcmp(keyword,"DSC2_CH_THRESHOLD") == 0)
      {
        sscanf (str_tmp, "%*s %d %d %d", &chan, &i1, &i2);
        if((chan<0) || (chan>=NCHAN))
        {
          printf("\nReadConfigFile: Wrong channel number, %d\n\n",chan);
          return(-7);
        }
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) dsc[ii].TDCThreshold[chan] = i1;
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) dsc[ii].TRGThreshold[chan] = i2;
      }

      else if(strcmp(keyword,"DSC2_TRGDIGITAL") == 0)
      {
        sscanf (str_tmp, "%*s %d %d", &i1, &i2);
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGDigitalWidth[jj] = i1;
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) for(jj=0; jj<NCHAN; jj++) dsc[ii].TRGDigitalDelay[jj] = i2;
      }

      else if(strcmp(keyword,"DSC2_CH_TRGDIGITAL") == 0)
      {
        sscanf (str_tmp, "%*s %d %d %d", &chan, &i1, &i2);
        if((chan<0) || (chan>=NCHAN))
        {
          printf("\nReadConfigFile: Wrong channel number, %d\n\n",chan);
          return(-8);
        }
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) dsc[ii].TRGDigitalWidth[chan] = i1;
	for(ii=0; ii<NBOARD; ii++) if(dsc[ii].group == gr) dsc[ii].TRGDigitalDelay[chan] = i2;
      }

      else
      {
        printf("ReadConfigFile: Unknown Field or Missed Field in\n");
        printf("   %s \n", fname);
        printf("   str_tmp=%s", str_tmp);
        printf("   keyword=%s \n\n", keyword);
        return(-9);
      }
    }
  }
  fclose(fd);

#ifdef DEBUG
  Ndsc = dsc2GetNdsc();
  for(ii=0; ii<Ndsc; ii++)
  {
    slot = dsc2Slot(ii);
    printf("\nslot=%2d\n",slot);
	printf("   TDCWidth=%d\n",dsc[slot].TDCWidth);
	printf("   TRGWidth=%d\n",dsc[slot].TRGWidth);
	printf("   TDCChannelMask=0x%04x\n",dsc[slot].TDCChMask);
	printf("   TRGChannelMask=0x%04x\n",dsc[slot].TRGChMask);
	printf("   TDCORMask=0x%04x\n",dsc[slot].TDCORMask);
	printf("   TRGORMask=0x%04x\n",dsc[slot].TRGORMask);
    for(jj=0;jj<NCHAN;jj++)
    {
      printf("      chan=%2d, TDCThreshold=%d, TRGThreshold=%d\n",
	     jj,dsc[slot].TDCThreshold[jj],dsc[slot].TRGThreshold[jj]);
    }
    for(jj=0;jj<NCHAN;jj++)
    {
      printf("      chan=%2d, TRGDigitalWidth=%d, TRGDigitalDelay=%d\n",
	     jj,dsc[slot].TRGDigitalWidth[jj],dsc[slot].TRGDigitalDelay[jj]);
    }
  }
#endif

  gr--;
  return(gr);
}


int
dsc2DownloadAll()
{
  int slot, chan, kk;
  UINT16 selMask;
  UINT16 bypMask;

  Ndsc = dsc2GetNdsc();
  for(kk=0; kk<Ndsc; kk++)
  {
    slot = dsc2Slot(kk);

    dsc2SetChannelMask(slot,   dsc[slot].TDCChMask, 1);
    dsc2SetChannelMask(slot,   dsc[slot].TRGChMask, 2);
    dsc2SetChannelORMask(slot, dsc[slot].TDCORMask, 1);
    dsc2SetChannelORMask(slot, dsc[slot].TRGORMask, 2);
    dsc2SetPulseWidth(slot,    dsc[slot].TDCWidth, 1);
    dsc2SetPulseWidth(slot,    dsc[slot].TRGWidth, 2);

    for(chan=0; chan<NCHAN; chan++)
    {
      dsc2SetThreshold(slot,chan,dsc[slot].TDCThreshold[chan],1);
      dsc2SetThreshold(slot,chan,dsc[slot].TRGThreshold[chan],2);
    }

    selMask = 0xFFFF; /* by default, trigger output will use TRG discriminator */
    bypMask = 0xFFFF; /* by default, TRG discriminator output goes directly to trigger output */

    for(chan=0; chan<NCHAN; chan++)
    {
      dsc2SetTRGOut(slot, chan, dsc[slot].TRGDigitalWidth[chan], dsc[slot].TRGDigitalDelay[chan]);
      /* if TRGDigitalWidth>0, set trigger output to the digital */
      if(dsc[slot].TRGDigitalWidth[chan]>0)
      {
	/*printf("[%2d][%2d] befor 0x%04x\n",slot,chan,bypMask);*/
        bypMask = bypMask ^ (1<<chan);
	/*printf("[%2d][%2d] after 0x%04x\n",slot,chan,bypMask);*/
      }
    }
    dsc2SetTRGOutSource(slot, selMask, bypMask);

  }
  return(0);
}


/* print board registers; if slot is zero, print all boards */
void
dsc2Mon(int slot)
{
  int  id, start, end, kk, jj;
  char *bb;
  char bSN[12];
  UINT16 bypMask;
  UINT32 boardID;

  Ndsc = dsc2GetNdsc();
  if(slot==0)
  {
    start = 0;
    end = Ndsc;
  }
  else if((id = dsc2Id(slot)) >= 0)
  {
    start = id;
    end = start + 1;
  }
  else
  {
    return;
  }

  printf("Ndsc=%d\n",Ndsc);
  for(kk=start; kk<end; kk++)
  {
    slot = dsc2Slot(kk);
    printf("\nDSC2 number %d in slot %d\n",kk,slot);
    printf("   Board Firmware Rev = 0x%04x\n", dsc2GetFirmwareVersion(slot,0));
    boardID = dsc2GetBoardID(slot,0);
    bb = (char *)&boardID;
    printf("   Board Type/ID      = 0x%x  (%c%c%c%c)\n", boardID,*(bb+3),*(bb+2),*(bb+1),*bb);
    dsc2GetSerialNumber(slot, (char **)&bSN, 0);
    printf("   Serial Number      = %s ", bSN);
    printf(",   Conf.SN = %s\n",   dsc[slot].SerNum);

    printf("   Channel Mask       = 0x%08x \n   Channel OR Mask    = 0x%08x \n",
	   dsc2GetChannelMask(slot, 0),
	   dsc2GetChannelORMask(slot, 0));
    printf("   TDCWidth = %d(ns) \n   TRGWidth = %d(ns)\n",
	   dsc2GetPulseWidth(slot,1),
	   dsc2GetPulseWidth(slot,2));
    for(jj=0;jj<NCHAN;jj++)
    {
      printf("      TDC_threshold[%2d] =%4d(mV)   TRG_threshold[%2d] =%4d(mV)\n",
	   jj, dsc2GetThreshold(slot,jj,1),
	   jj, dsc2GetThreshold(slot,jj,2));
    }
    bypMask = dsc2GetTRGOutSource(slot,1);
    for(jj=0;jj<NCHAN;jj++)
    {
      if( (bypMask&(1<<jj))==0 )
	  {
        printf("      TRGDigitalDelay[%2d] =%4d(ns)   TRGDigitalWidth[%2d] =%4d(ns) <- supersede TRGWidth\n",
	      jj, dsc2GetTRGOutDelay(slot,jj),
	      jj, dsc2GetTRGOutWidth(slot,jj));
	  }
    }
    printf("\n");
  }
}


void
dsc2PrintIDBySlot(unsigned int slot)
{
  printf("%d\n",dsc2Id(slot));
}


#else /* dummy version*/

void
dsc2Config_dummy()
{
  return;
}

#endif