#include "fadcLib.h"        /* library of FADC250 routines */


unsigned int  MAXFADCWORDS  =  0;

/* FADC Library Variables */


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

unsigned int fadcSlotMask   = 0;    /* bit=slot (starting from 0) */

//extern int blockLevel;

int fa250_download(){

  int slot, ii;

  int Naddr = 0;

  memset(fadcAddrList, 0, sizeof(fadcAddrList));

  for(slot = 3; slot < 21; slot++){
    if(fa250[slot].group == 1){
      fadcAddrList[Naddr] = (slot<<19);
      Naddr++;
    }
  }

  printf("\n");
  printf(" NUMBER OF FADC250  boards found in config file =  %d \n",Naddr);
  printf("\n");


  NFADC = 0;

  /* Initially set block level, will be reseted when blockLevel is updated */
  //  MAXFADCWORDS = 15 * blockLevel * (1 + 2 + 100*16 + 1) + 2*32;

  MAXFADCWORDS = 15 * blockLevel * (1 + 2 + 100*16 + 1) + 2*32;



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

  iFlag |= (1<<17);     /* activate using fadcAddrList in faInit */


  vmeSetQuietFlag(1);   /* skip the errors associated with BUS Errors */
  
  faInit(fadcAddrList[0], 0, Naddr, iFlag);

  if(nfadc !=  Naddr){
    printf(BOLDRED " FATAL: faInit failed. Nfadc config =  %d, Nfadc found =  %d \n" RESET, Naddr, nfadc );
    daLogMsg("FATAL", " Fail to initialize fadc250.  Nfadc config =  %d, Nfadc found =  %d  \n",  Naddr, nfadc );
    ROL_SET_ERROR;
  }
  


  vmeSetQuietFlag(0);   /* Turn the error statements back on */

  NFADC = nfadc;        /* Redefine our NFADC with what was found from the driver */


  printf("\n");
  printf(BOLDBLUE " Number of boards found by faInit =  %d \n" RESET, NFADC);
  printf("\n");


  if(NFADC > 1) 
    faEnableMultiBlock(1);

  for(slot = 0; slot < NFADC; slot++){

    FA_SLOT = fadcID[slot];    
    fadcSlotMask |= (1<<FA_SLOT); /* Add it to the mask */
    
  }


  for(slot = 0; slot < NFADC; slot++){
    
    FA_SLOT = fadcID[slot];
    
    printf(" \nfadc250Download:  FA_SLOT=%d  group=%d  mode=%d  nsb=%d \n",FA_SLOT,
	   fa250[FA_SLOT].group, fa250[FA_SLOT].mode, fa250[FA_SLOT].nsb);
    
    printf(BOLDMAGENTA " TRIGGER GLOBAL DELAY = %d \n" RESET, trig_delay);

    faSetProcMode(FA_SLOT,
		  fa250[FA_SLOT].mode,
		  fa250[FA_SLOT].winOffset + trig_delay,
		  fa250[FA_SLOT].winWidth,
		  fa250[FA_SLOT].nsb,
		  fa250[FA_SLOT].nsa,
		  fa250[FA_SLOT].npeak, 0);
       
    
    for(ii = 0; ii < MAX_FADC250_CH; ii++) {
      faSetDAC(             FA_SLOT, fa250[FA_SLOT].dac[ii], (1<<ii));
      faSetThreshold(       FA_SLOT, fa250[FA_SLOT].read_thr[ii],(1<<ii));
      
      
      /*  Disable channels for the trigger  */
      if( ((1 << ii ) &  fa250[FA_SLOT].trigMask )  == 0)
	faSetChannelPedestal( FA_SLOT, ii, fa250[FA_SLOT].trig_bl[ii]);
      else {
	faSetChannelPedestal( FA_SLOT, ii, 0xFFFF);
	printf(BOLDMAGENTA "FADC250 in slot %d:  Disable channel %d  for the trigger  \n"  RESET, FA_SLOT, ii);   
      }      
    }


    /* FADC HitBit modes for PS, PSC, ST, and TOF  */
    if( (strcmp(roc_name, "rocps1") == 0) ||  (strcmp(roc_name, "rocps2")  == 0)  || 
	(strcmp(roc_name, "rocst") == 0)  ||  (strcmp(roc_name, "roctof1") == 0) ){
      printf(BOLDMAGENTA " HitBitMode Enabled \n" RESET);
      faGSetHitbitsMode(1);
    }
    

    faSetTriggerPathThreshold(FA_SLOT,  fa250[FA_SLOT].trig_thr);

    faSetTriggerPathSamples(FA_SLOT, fa250[FA_SLOT].trig_nsb, fa250[FA_SLOT].trig_nsa);


    faSetChannelDisableMask(FA_SLOT, fa250[FA_SLOT].chDisMask );

    /* Bus errors to terminate block transfers (preferred) */
    faEnableBusError(FA_SLOT);

    /* Set the Block level to the initial value*/
    faSetBlockLevel(FA_SLOT,blockLevel);
      

    faPrintThreshold(FA_SLOT);
    faPrintDAC(FA_SLOT);
      
    faStatus(FA_SLOT, 0);

  }
  

  for(slot = 0; slot < NFADC; slot++){

    FA_SLOT = fadcID[slot];

    if(fa250[FA_SLOT].trigMask)
      printf(BOLDMAGENTA "FADC250:  Disable trigger mask for FADC in SLOT  %d   =  0x%x   \n"  RESET, FA_SLOT, fa250[FA_SLOT].trigMask);
    
    if(fa250[FA_SLOT].chDisMask)
      printf(BOLDMAGENTA "FADC250:  Disable channel mask for FADC in SLOT  %d   =  0x%x   \n"   RESET,
	     FA_SLOT,fa250[FA_SLOT].chDisMask );   

    printf(" Trigger Baseline Settings for FADC in slot %d: ", FA_SLOT );

    for(ii = 0;ii < FA_MAX_ADC_CHANNELS;ii++) {
      if((ii%4)==0) printf("\n");
      printf("Chan %2d: %5d   ",(ii+1),faGetChannelPedestal(FA_SLOT, ii) );
    }
    printf("\n");

  }

  
  faGStatus(0);


  /***************************************
   *   SD SETUP
   ***************************************/
  sdInit();   /* Initialize the SD library */
  
  printf(BOLDBLUE "fadcSlotMask =  0x%x  \n" RESET ,fadcSlotMask); 
  
  sdSetActiveVmeSlots(fadcSlotMask);    /* Use the fadcSlotMask to configure the SD */
  sdStatus();

  return(0);

}


int fa250_prestart(){

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

  /* FADC Perform some resets, status */
  for(islot = 0; islot < NFADC; islot++){
    
    FA_SLOT = fadcID[islot];
      
    faSetClockSource(FA_SLOT,2);


    faSoftReset(FA_SLOT,0);
    
    faResetToken(FA_SLOT);
    faResetTriggerCount(FA_SLOT);
    
    faEnableSyncSrc(FA_SLOT);

    //    faStatus(FA_SLOT,0);
    
    
    //      faSetMGTTestMode(FA_SLOT,0);
    //      faDisable(FA_SLOT,0);      
    //      faChanDisable(FA_SLOT,0xffff);
    //      faSetMGTTestMode(FA_SLOT,0);
    //      faEnable(FA_SLOT,0,0);
    
  }
  
  faGStatus(1);

  sdStatus();
  
}

int fa250_go(){
  int islot;
  
  for(islot = 0; islot < NFADC; islot++) {
    FA_SLOT = fadcID[islot];
    //       faChanDisable(FA_SLOT,0x0);
    //       faSetMGTTestMode(FA_SLOT,1);

    faSetBlockLevel(FA_SLOT,blockLevel);
    printf(BOLDBLUE  "rocGo: Set block level to %d\n" RESET, blockLevel);
    
    faEnable(FA_SLOT,0,0);

    if(use_playback){
      faPPGEnable(FA_SLOT);   
    }

    //    faStatus(FA_SLOT,1);
    
  }
  
  faGStatus(1);
  

  return(0);

}

int fa250_end(){

  int islot;
  
  /* FADC Disable */
  for(islot = 0; islot < NFADC; islot++) {
    FA_SLOT = fadcID[islot];

    faDisable(FA_SLOT,0);
    faStatus(FA_SLOT,0);      

    if(use_playback)
      faPPGDisable(FA_SLOT);
        
  }

  sdStatus(1);

  return(0);
}




int fa250_cleanup(){
  int islot;

  for(islot = 0; islot < NFADC; islot++){
      FA_SLOT = fadcID[islot];
      faReset(FA_SLOT,1); /* Reset, and DO NOT restore A32 settings (1) */
    } 
  
  return(0);
}


int fa250_init_blayback(){

  unsigned short adc_playback[32];
  unsigned short adc_playback_allchannels[512];
  int sample, ichan;

  int slot;

  for(slot = 0;slot < NFADC; slot++){
    FA_SLOT = fadcID[slot];
    
    if( FA_SLOT == 10){
          
      for(sample = 0; sample < 32; sample++){
	adc_playback[sample] = 200;
      }     
        
      adc_playback[1] = 1200;
      adc_playback[2] = 1200;
      adc_playback[3] = 1200;
      adc_playback[4] = 1200;
      adc_playback[5] = 1200;
      adc_playback[6] = 1200;
      
      for(ichan = 0; ichan < 16; ichan++) {
	for(sample = 0; sample < 32; sample++) {
	  adc_playback_allchannels[ichan*32+sample] = adc_playback[sample];
	}
      }
      
      faSetPPG(FA_SLOT,0,adc_playback_allchannels,512);
      taskDelay(5);
      
      int jj = 0;
      
      for(jj = 0; jj < 512; jj++){
	printf(" SSS = %d \n", adc_playback_allchannels[jj]);
      }
      
    } else {  // Other boards
      
      memset(adc_playback_allchannels, 0, sizeof(adc_playback_allchannels));
      faSetPPG(FA_SLOT,0,adc_playback_allchannels,512); 
      taskDelay(5);
    }
  }

  return(0);

}