/************************************************/
/*                                              */
/* File        : calb.c                         */
/* Description : Calorimeter-Boards library     */
/*                                              */
/* Author: G. Cabibbo, A. Passeri               */
/*                                              */
/* Created      : 11.02.1997                    */
/* Last modified: 30.12.1997                    */
/*                                              */
/************************************************/

#include <stdio.h>
#include "calb.h"


/*********************************************************************/
/*                                                                   */
/*                      readpage routines                            */
/*                                                                   */
/*********************************************************************/

int calb_readpage_i_csr(CALB_id calb_id,   /*  IN  */
                        CALB_PAGE_CSR_bits *bits)   /*   OUT   */
{
  int res;
  CALBH_CSR_regs  regs;
 
  res = calbh_readpage_csr(calb_id,regs);
  if(res!=CALBH_ERROR_OK)
    {
       ErrorSetF(CALB_ERROR_UNKNOWN,"calb_readpage_csr","calbh_readpage_csr error: %s",ErrorGetMessage());
       return CALB_ERROR_UNKNOWN;
    }
  
  calbb_regstobits_csr(regs,(* bits));
  return CALB_ERROR_OK;
}

int calb_readpage_i_ped(CALB_id calb_id,CALB_PEDS_val *peds)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_readpage_i_ped",
      "Cannot read pedestals while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_readpage_ped(calb_id,(* peds));
  }  
}

int calb_readpage_i_zsup (CALB_id calb_id,CALB_ZSUP_nwind  *zwind,
                              CALB_ZSUP_val zsup) 
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_readpage_i_zsup",
      "Cannot read zerosup memory while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_readpage_zsup(calb_id,(* zwind),zsup);
  }  
}



/*********************************************************************/
/*                                                                   */
/*                      writepage routines                            */
/*                                                                   */
/*********************************************************************/

int calb_writepage_i_ped(CALB_id calb_id,CALB_PEDS_val *peds)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_writepage_i_ped",
      "Cannot write pedestals while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_writepage_ped(calb_id,(* peds));
  }  
}

int calb_writepage_i_zsup (CALBH_id calb_id,CALBH_ZSUP_nwind  *zwind,
			      CALBH_ZSUP_val zsup) 
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_writepage_i_zsup",
      "Cannot write zerosup memory while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_writepage_zsup(calb_id,(* zwind),zsup);
  }  
}



/*********************************************************************/
/*                                                                   */
/*                   Register oriented routines                      */
/*                                                                   */
/*********************************************************************/

/*********************************************************************/
/*                    Read routines                                  */
/*********************************************************************/

int calb_read_i_creg(CALB_id calb_id,               
			     CALB_CREG_bits *creg)  
{
  unsigned short ctrl;

  ctrl=calbh_read_creg(calb_id);
  calbb_nrtocreg(ctrl,(*creg));

}

int calb_read_i_sreg(CALB_id calb_id,               
			     CALB_SREG_bits *sreg)  
{
  unsigned short status;

  status=calbh_read_sreg(calb_id);
  calbb_nrtosreg(status,(*sreg));

}


int calb_read_i_hfifo(CALB_id calb_id,              
			     CALB_HFIFO_bits *hfifo)
{
  unsigned int hdata;

  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_read_i_hfifo",
      "Cannot read fifo while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    hdata=calbh_read_hfifo(calb_id);
    calbb_nrtohfifo(hdata,(*hfifo));
  }
  return CALB_ERROR_OK;
}


int calb_read_i_dfifo(CALB_id calb_id,              
			     CALB_DFIFO_bits *dfifo)
{
  unsigned int ddata;

  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_read_i_dfifo",
      "Cannot read fifo while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    ddata=calbh_read_dfifo(calb_id);
    calbb_nrtodfifo(ddata,(*dfifo));
  }
  return CALB_ERROR_OK;
}


int calb_read_i_rdtrg(CALB_id calb_id)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_read_i_rdtrg",
      "Cannot read trignum while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    return calbh_read_rdtrg(calb_id);
  }
}

/*********************************************************************/
/*                    ReadLATCH routines                             */
/*********************************************************************/

int calb_readlatch_i_chan(CALB_id calb_id,unsigned int  chan)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_readlatch_i_chan",
      "Cannot read latches while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    return calbh_readlatch_chan(calb_id,chan);
  }  
}

int calb_readlatch_i_all(CALB_id calb_id,CALB_CHANNELS latch)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_readlatch_i_all",
      "Cannot read latches while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_readlatch_all(calb_id,latch);
  }  
}


/*********************************************************************/
/*                    Write routines                                  */
/*********************************************************************/

int calb_write_i_clrtrg(CALB_id calb_id)
{
  if ( calb_get_acqen(calb_id) )
  {
    ErrorSetF(CALB_ERROR_ACQEN,"calb_read_i_rdtrg",
      "Cannot read trignum while acq is enabled: %s",ErrorGetMessage());
    return CALB_ERROR_ACQEN;
  }
  else
  {
    calbh_write_clrtrg(calb_id);
  }
  return CALB_ERROR_OK;
}

int calb_write_i_swtrg(CALB_id calb_id)
{
  if ( calb_get_acqen(calb_id) )
  {
    if ( calb_get_alu(calb_id)!=5 )
    { 
      ErrorSetF(CALB_ERROR_ACQEN,"calb_read_i_rdtrg",
       "Cannot read trignum while acq is enabled: %s",ErrorGetMessage());
      return CALB_ERROR_ACQEN;
    }
  }
  else
  {
    calbh_write_swtrg(calb_id);
  }
  return CALB_ERROR_OK;
}




/*********************************************************************/
/*                                                                   */
/*                      readfifo routine                             */
/*                                                                   */
/*********************************************************************/

/********  disabled for the moment !

int calb_read_pio_i_bothfifo (CALBH_id calb_id,	
			CALB_FIFO_EVENT data)	
{
  unsigned int nrec,nev=1;
  unsigned int head,nrecold;
  unsigned int* tempbuf;
  
  int loop;
  int ErrFlag;

  ErrFlag = calbh_read_pio_hfifo(calb_id,nev,&head);
    if (  ErrFlag == CALBH_ERROR_OK ) {
      nrecold = 
	nrec = bits_get_bits(head,CALB_HFIFO_NREC_SHIFT,CALB_HFIFO_NREC_LEN);
      tempbuf= (unsigned int *) malloc(nrec*sizeof(unsigned int));
      if (tempbuf == NULL)
	{
	  ErrorSetF(CALBH_ERROR_UNKNOWN,"calb_read_pio_i_bothfifo",
		    "AllocateBuffer error: %s",ErrorGetMessage());
	  return CALBH_ERROR_UNKNOWN;
	}
      ErrFlag = calbh_read_pio_dfifo(calb_id,nrec,tempbuf);
      if (nrec != nrecold){
	ErrorSetF(CALBH_ERROR_UNKNOWN,"calb_read_pio_i_bothfifo",
		  "DFIFO - HFIFO syncronization error: %s",ErrorGetMessage());
	return CALBH_ERROR_UNKNOWN;
      }
      data->ntrig=bits_get_bits(head,CALB_HFIFO_NTRG_SHIFT,CALB_HFIFO_NTRG_SHIFT);
      data->nchan=nrec;
      
      for(loop=0;loop<nrec;loop++){
	data->chan[loop] = 
	  bits_get_bits(tempbuf[loop],CALB_DFIFO_NCH_SHIFT,CALB_DFIFO_NCH_LEN); 
	data->data[loop] = 
	  bits_get_bits(tempbuf[loop],CALB_DFIFO_DATA_SHIFT,CALB_DFIFO_DATA_LEN);
      }
    }
  return ErrFlag;
}
              ***************/