/************************************************/
/*                                              */
/* File        : userts.c                       */
/* Description : tl user part                   */
/*                                              */
/* Command     : ts                             */
/* Comment     : TS library tcl interface       */
/*               use ts v2 libs                 */
/* Author: Mei Wen                              */
/*                                              */
/* Created       : 30.01.1998                   */
/* Last modified : 26.02.1998                   */
/*                                              */
/************************************************/

#include <string.h>
#include <stdlib.h>

#include <Error.h>

#include "Vme.h"

#include "ts.h"

#include "userts.h"

/* ts ispresent_slot data function*/
/* return TL_OK iff no error */
int tst_tl_ispresent_slot(tst_t_ispresent_slot *data)
{
 data->result = tsh_ispresent_slot(data->slot, data->type); /* type: A or B */

 return TL_OK;
}
/* ts ispresent data function*/
/* return TL_OK iff no error */
int tst_tl_ispresent(tst_t_ispresent *data)
{
 data->result = ts_ispresent( data->type); /* type: A or B */

 return TL_OK;
}
/* ts open data function*/
/* return TL_OK iff no error */
int tst_tl_open(tst_t_open *data)
{
 TS_id ts_id;
 int res;

 res=ts_open(data->type,&ts_id);
 data->result = (void *) ts_id;

 if (res==TS_ERROR_OK)
    return TL_OK;
 else
   {
    char *tmp;

    tmp = (char *) ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
   }
}

/* ts close data function*/
/* return TL_OK iff no error */
int tst_tl_close(tst_t_close *data)
{
 ts_close(data->type, (TS_id) data->rid);

 return TL_OK;
}

/* ts read and decode a register */
/* decode intid */

int tst_tl_decode_intid(tst_t_decode_intid *data)
{
 data->result = ts_read_intid((TS_id) data-> rid);

}

/* ts read intlevel data function*/
/* return TL_OK iff no error */
int tst_tl_decode_intlevel(tst_t_decode_intlevel *data)
{
 TS_INTLEVEL_bits bits;

 ts_read_intlevel((TS_id) data->rid, bits);


 data->result.intlevel = bits.intlevel;
 data->result.roak = bits.roak;
 return TL_OK;
}



/* ts read status data function*/
/* return TL_OK iff no error */
int tst_tl_decode_status(tst_t_decode_status *data)
{
 TS_SREG_bits bits; 

 ts_read_status((TS_id) data->rid,bits);

 data->result.tmoutbusy = bits.tmoutbusy;
 data->result.syncfailstart = bits.syncfailstart;
 data->result.syncfailend = bits.syncfailend;
 data->result.tberr = bits.tberr;
 data->result.auxtberr = bits.auxtberr;
 data->result.ovfwacttime = bits.ovfwacttime;
 data->result.ovfwdeadtime = bits.ovfwdeadtime;
 data->result.erra = bits.erra;
 data->result.errb = bits.errb;
 data->result.errt1 = bits.errt1;
 data->result.errt2= bits.errt2; 
 data->result.errsyncfand= bits.errsyncfand; 
 data->result.errsyncfor = bits.errsyncfor;
 return TL_OK;
}
/*intmask */
int tst_tl_decode_intmask(tst_t_decode_intmask *data)
{
  TS_INTMASK_bits bits;
  ts_read_intmask((TS_id) data->rid, bits);
  
  data->result.tmoutbusy = bits.tmoutbusy;     
  data->result.syncfailstart = bits.syncfailstart;
  data->result.syncfailend = bits.syncfailend;
  data->result.tberr = bits.tberr;
  data->result.auxtberr = bits.auxtberr;
  data->result.ovfwacttime = bits.ovfwacttime;
  data->result.ovfwdeadtime = bits.ovfwdeadtime;
  data->result.erra = bits.erra;
  data->result.errb = bits.errb;
  data->result.errt1 = bits.errt1;
  data->result.errt2= bits.errt2; 
  data->result.errsyncfand= bits.errsyncfand; 
  data->result.errsyncfor = bits.errsyncfor;
 
  return TL_OK;
}

/* latchmask */
int tst_tl_decode_latchmask(tst_t_decode_latchmask *data)
{
 TS_LATMASK_bits bits;
 ts_read_latchmask((TS_id) data->rid, bits);

  
  data->result.tmoutbusy = bits.tmoutbusy;     
  data->result.syncfailstart = bits.syncfailstart;
  data->result.syncfailend = bits.syncfailend;
  data->result.tberr = bits.tberr;
  data->result.auxtberr = bits.auxtberr;
  data->result.ovfwacttime = bits.ovfwacttime;
  data->result.ovfwdeadtime = bits.ovfwdeadtime;
  data->result.erra = bits.erra;
  data->result.errb = bits.errb;
  data->result.errt1 = bits.errt1;
  data->result.errt2= bits.errt2; 
  data->result.errsyncfand= bits.errsyncfand; 
  data->result.errsyncfor = bits.errsyncfor;

  return TL_OK;

}

/* errmask*/
int  tst_tl_decode_errormask( tst_t_decode_errormask *data)
{
TS_ERRMASK_bits bits;
ts_read_errormask((TS_id) data->rid, bits);
 
  
  data->result.tmoutbusy = bits.tmoutbusy;     
  data->result.syncfailstart = bits.syncfailstart;
  data->result.syncfailend = bits.syncfailend;
  data->result.tberr = bits.tberr;
  data->result.auxtberr = bits.auxtberr;
  data->result.ovfwacttime = bits.ovfwacttime;
  data->result.ovfwdeadtime = bits.ovfwdeadtime;
  data->result.erra = bits.erra;
  data->result.errb = bits.errb;
  data->result.errt1 = bits.errt1;
  data->result.errt2= bits.errt2; 
  data->result.errsyncfand= bits.errsyncfand; 
  data->result.errsyncfor = bits.errsyncfor;


  return TL_OK;

}
/* wenable*/
int tst_tl_decode_wenable(tst_t_decode_wenable *data)
{
  data->result = ts_read_wenable((TS_id) data->rid);
  return TL_OK;  
}
/*
 trigger page
*/


/* ts read delay reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_delayt2(tst_t_decode_delayt2 *data)
{
  data->result = ts_read_delayt2((TS_id) data->rid);
  return TL_OK;
}

/* ts read delayt1 reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_delayt1(tst_t_decode_delayt1 *data)
{
 data->result = ts_read_delayt1((TS_id) data->rid);
 return TL_OK;
 
}

/* ts read goldnumber reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_goldnumb(tst_t_decode_goldnumb *data)
{
 data->result = ts_read_goldnumb((TS_id) data->rid);
 return TL_OK;
}

/* ts read Sync data function*/
/* return TL_OK iff no error */
int tst_tl_decode_sync(tst_t_decode_sync *data)
{
TS_SYNCMASK_bits bits;

 ts_read_syncmask((TS_id) data->rid,bits);

 data->result.mask = bits.mask;

 data->result.ena = bits.ena;

 return TL_OK;
}


/* ts read actime reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_actime(tst_t_decode_actime *data)
{
 
 data->result = ts_read_activetime((TS_id) data->rid);

 return TL_OK;
}


/* ts read tmode data function*/
/* return TL_OK iff no error */
int tst_tl_decode_tmode(tst_t_decode_tmode *data)
{
 TS_TMODE_bits bits;

 ts_read_tmode((TS_id) data->rid,bits);

 data->result.mode = bits.mode;
 data->result.presc = bits.presc;

 return TL_OK;
}


/* ts read run reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_run(tst_t_decode_run *data)
{
 
 data->result = ts_read_run((TS_id) data->rid);

 return TL_OK;
}

/* ts read trgcounter reg function*/
/* return TL_OK iff no error */

int tst_tl_decode_trgcounter(tst_t_decode_trgcounter *data)
{
 
 data->result = ts_read_trgcounter((TS_id) data->rid);

 return TL_OK;
}

/*
 watch dog
*/


/* ts read deadtime reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_deadtime(tst_t_decode_deadtime *data)
{

 data->result = ts_read_deadtime((TS_id) data->rid);


 return TL_OK;
}


/* ts read tmoutbusy reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_tmoutbusy(tst_t_decode_tmoutbusy *data)
{

 data->result = ts_read_tmoutbusy((TS_id) data->rid); 

 return TL_OK;
}

/* ts read tmoutsyncfstart reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_tmoutsyncfstart(tst_t_decode_tmoutsyncfstart *data)
{

 data->result = ts_read_tmoutsyncfstart((TS_id) data->rid);

 return TL_OK;
}

/* ts read tmoutsyncfend reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_tmoutsyncfend(tst_t_decode_tmoutsyncfend *data)
{
 

 data->result = ts_read_tmoutsyncfend((TS_id) data->rid);

 return TL_OK;
}

/*
 counter page
*/
/* ts read t1count reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_t1count(tst_t_decode_t1count *data)
{

 data->result = ts_read_t1count((TS_id) data->rid);

 return TL_OK;
}

/* ts read t1rate reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_t1rate(tst_t_decode_t1rate *data)
{
 

 data->result = ts_read_t1rate((TS_id) data->rid);

  return TL_OK;
}

/* ts read t2rate reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_t2rate(tst_t_decode_t2rate *data)
{
 

 data->result = ts_read_t2rate((TS_id) data->rid);

  return TL_OK;
}

/* ts read t2busy reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_t2busy(tst_t_decode_t2busy *data)
{

 data->result = ts_read_t2busy((TS_id) data->rid);

 return TL_OK;
}

/* ts read tmbusy reg function*/
/* return TL_OK iff no error */
int tst_tl_decode_tmbusy(tst_t_decode_tmbusy *data)
{
 
  data->result = ts_read_tmbusy((TS_id) data->rid);

 return TL_OK;
}

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

/* ts write status reg function */
/* return TL_OK iff no error */
int tst_tl_write_status(tst_t_write_status *data)
{
  int res;

  res = tsh_write_status((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc (strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write intmask reg function */
/* return TL_OK iff no error */
int tst_tl_write_intmask(tst_t_write_intmask *data)
{
  int res;



 
  res = tsh_write_intmask((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write latchmask reg function */
/* return TL_OK iff no error */
int tst_tl_write_latchmask(tst_t_write_latchmask *data)
{
  int res;

  res = tsh_write_latchmask((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write errormask reg function */
/* return TL_OK iff no error */
int tst_tl_write_errormask(tst_t_write_errormask *data)
{
  int res;

  res = tsh_write_errormask((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write wenable reg function */
/* return TL_OK iff no error */
int tst_tl_write_wenable(tst_t_write_wenable *data)
{
  int res;

  res = tsh_write_wenable((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/*
 trigger page
*/
/* ts write delayt2 reg function */
/* return TL_OK iff no error */
int tst_tl_write_delayt2(tst_t_write_delayt2 *data)
{
  int res;

  res = tsh_write_delayt2((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write delayt1 reg function */
/* return TL_OK iff no error */
int tst_tl_write_delayt1(tst_t_write_delayt1 *data)
{
  int res;

  res = tsh_write_delayt1((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write goldnumb reg function */
/* return TL_OK iff no error */
int tst_tl_write_goldnumb(tst_t_write_goldnumb *data)
{
  int res;

  res = tsh_write_goldnumb((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write sync reg function */
/* return TL_OK iff no error */
int tst_tl_write_sync(tst_t_write_sync *data)
{
  int res;

  res = tsh_write_syncmask((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write tmode reg function */
/* return TL_OK iff no error */
int tst_tl_write_tmode(tst_t_write_tmode *data)
{
  int res;

  res = tsh_write_tmode((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write run reg function */
/* return TL_OK iff no error */
int tst_tl_write_run(tst_t_write_run *data)
{
  int res;

  res = tsh_write_run((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}
/*
 watchdog Configuration page
*/
/* ts write tmoutbusy reg function */
/* return TL_OK iff no error */
int tst_tl_write_tmoutbusy(tst_t_write_tmoutbusy *data)
{
  int res;

  res = tsh_write_tmoutbusy((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write tmoutsyncfstart reg function */
/* return TL_OK iff no error */
int tst_tl_write_tmoutsyncfstart(tst_t_write_tmoutsyncfstart *data)
{
  int res;

  res = tsh_write_tmoutsyncfstart((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}

/* ts write tmoutsyncfend reg function */
/* return TL_OK iff no error */
int tst_tl_write_tmoutsyncfend(tst_t_write_tmoutsyncfend *data)
{
  int res;



 
  res = tsh_write_tmoutsyncfend((TS_id) data->rid, data->value, 0);

  if (res==TS_ERROR_OK)
    return TL_OK;
  else
    {
    char *tmp;

    tmp = ErrorGetMessage();
    data->errorstr = (char *) malloc(strlen(tmp)+1);
    strcpy(data->errorstr,tmp);

    return TL_OK+res;
  }

}