/************************************************/
/*                                              */
/* File        : userrock.h                     */
/* Description : tl compiler definitions        */
/*                                              */
/* Command     : rock                           */
/* Comment     : ROCK library tcl interface     */
/*                                              */
/* Author: Sfiligoi Igor                        */
/*                                              */
/* Created       : 28.01.1997                   */
/* Last modified : 20.03.1997                   */
/*                                              */
/************************************************/

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

#include <Error.h>
#include <rock.h>

#include "userrock.h"

/* rock ispresent data function*/
/* return TL_OK iff no error */
int rockt_tl_ispresent(rockt_t_ispresent *data)
{
 data->result=rock_ispresent(data->chain,data->crate);

 return TL_OK;
}

/* rock open data function*/
/* return TL_OK iff no error */
int rockt_tl_open(rockt_t_open *data)
{
 ROCK_id rock_id;
 int res;

 res=rock_open(data->chain,data->crate,&rock_id);
 data->result = (void *) rock_id;

 if (res==ROCK_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;
   }
}

/* rock raw open data function*/
/* return TL_OK iff no error */
int rockt_tl_raw_open(rockt_t_raw_open *data)
{
 ROCKH_id rock_id;
 int res;

/* Set default values if necessary */
 if (!data->offs_present)
        data->offs=0;
 if (!data->vme_size_present)
        data->vme_size=data->offs+0x40;
 if (!data->vme_am_present)
        data->vme_am=0x09;

 res=rockh_open_raw(data->vme_addr,data->vme_size,data->vme_am,data->offs,&rock_id);
 data->result = (void *) rock_id;

 if (res==ROCK_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;
   }
}

/* rock close data function*/
/* return TL_OK iff no error */
int rockt_tl_close(rockt_t_close *data)
{
 rock_close((ROCK_id) data->rid);

 return TL_OK;
}

/* rock write Golden data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_golden(rockt_t_encode_golden *data)
{
 ROCK_GOLDEN_bits golden;
 int res;

 golden.last = data->value.last;
 golden.cradd = data->value.cradd;
 golden.goldenref = data->value.goldenref;

 res=rock_write_golden((ROCK_id) data->rid,golden);

 if (res==ROCK_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;
   }
}

/* rock write Trigger data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_trigger(rockt_t_encode_trigger *data)
{
 ROCK_TRIGGER_bits trigger;
 int res;

 trigger.test = data->value;

 res=rock_write_trigger((ROCK_id) data->rid,trigger);

 if (res==ROCK_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;
   }
}

/* rock write CSR2 data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_csr2(rockt_t_encode_csr2 *data)
{
 ROCK_CSR2_bits csr2;
 int res;

 csr2.elapsed = data->value.elapsed;
 csr2.wscale = data->value.wscale;

 res=rock_write_csr2((ROCK_id) data->rid,csr2);

 if (res==ROCK_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;
   }
}

/* rock write CSR0 data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_csr0(rockt_t_encode_csr0 *data)
{
 ROCK_CSR0_bits csr0;
 int res;

 csr0.efmode = data->value.efmode;
 csr0.boe = data->value.boe;
 csr0.tkndis = data->value.tkndis;
 csr0.inttrg = data->value.inttrg;
 csr0.diag = data->value.diag;

 res=rock_write_csr0((ROCK_id) data->rid,csr0);

 if (res==ROCK_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;
   }
}

/* rock write Watchdog data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_watchdog(rockt_t_encode_watchdog *data)
{
 ROCK_WATCHDOG_bits watchdog;
 int res;

 watchdog = data->value;

 res=rock_write_watchdog((ROCK_id) data->rid,watchdog);

 if (res==ROCK_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;
   }
}

/* rock write reset data function*/
/* return TL_OK iff no error */
int rockt_tl_encode_reset(rockt_t_encode_reset *data)
{
 ROCK_RESET_bits reset;
 int res;

 reset.fltrst = data->value.fltrst;
 reset.intrst = data->value.intrst;
 reset.auxrst = data->value.auxrst;
 reset.dfifo = data->value.dfifo;
 reset.efifo = data->value.efifo;
 reset.tfifo = data->value.tfifo;
 reset.xintf = data->value.xintf;
 reset.cintf = data->value.cintf;

 res=rock_write_reset((ROCK_id) data->rid,reset);

 if (res==ROCK_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;
   }
}

/* rock read EFIFO data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_efifo(rockt_t_decode_efifo *data)
{
 ROCK_EFIFO_bits bits;

 rock_read_efifo((ROCK_id) data->rid,bits);

 data->result.nvd = bits.nvd;
 data->result.ff = bits.ff;
 data->result.hf = bits.hf;
 data->result.ef = bits.ef;
 data->result.fifodata = bits.fifodata;

 return TL_OK;
}

/* rock read DFIFO data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_dfifo(rockt_t_decode_dfifo *data)
{
 ROCK_DFIFO_bits bits;

 rock_read_dfifo((ROCK_id) data->rid,bits);

 data->result.nvd = bits.nvd;
 data->result.ff = bits.ff;
 data->result.hf = bits.hf;
 data->result.ef = bits.ef;
 data->result.fifodata = bits.fifodata;

 return TL_OK;
}

/* rock read Golden data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_golden(rockt_t_decode_golden *data)
{
 ROCK_GOLDEN_bits bits;

 rock_read_golden((ROCK_id) data->rid,bits);

 data->result.last = bits.last;
 data->result.cradd = bits.cradd;
 data->result.goldenref = bits.goldenref;

 return TL_OK;
}


/* rock read Rockinfo data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_rockinfo(rockt_t_decode_rockinfo *data)
{
 ROCK_ROCKINFO_bits bits;

 rock_read_rockinfo((ROCK_id) data->rid,bits);

 data->result.sof = bits.sof;
 data->result.eof = bits.eof;
 data->result.syncrespf = bits.syncrespf;
 data->result.rocksfail = bits.rocksfail;
 data->result.slvsfail = bits.slvsfail;
 data->result.lwadd = bits.lwadd;
 data->result.xadd = bits.xadd;

 return TL_OK;
}

/* rock read TNOW data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_tnow(rockt_t_decode_tnow *data)
{
 ROCK_TNOW_bits bits;

 rock_read_tnow((ROCK_id) data->rid,bits);

 data->result.cstate = bits.cstate;
 data->result.ptrg = bits.ptrg;

 return TL_OK;
}

/* rock read TQUE data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_tque(rockt_t_decode_tque *data)
{
 ROCK_TQUE_bits bits;

 rock_read_tque((ROCK_id) data->rid,bits);

 data->result.tff = bits.tff;
 data->result.link = bits.link;
 data->result.qtrg = bits.qtrg;

 return TL_OK;
}

/* rock read Trigger data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_trigger(rockt_t_decode_trigger *data)
{
 ROCK_TRIGGER_bits bits;

 rock_read_trigger((ROCK_id) data->rid,bits);

 data->result.halt = bits.halt;
 data->result.busy = bits.busy;
 data->result.synchf = bits.synchf;
 data->result.xbusy = bits.xbusy;
 data->result.xberr = bits.xberr;

 return TL_OK;
}

/* rock read Elapsed data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_elapsed(rockt_t_decode_elapsed *data)
{
 ROCK_ELAPSED_bits bits;

 rock_read_elapsed((ROCK_id) data->rid,bits);

 data->result = bits;

 return TL_OK;
}

/* rock read CSR2 data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_csr2(rockt_t_decode_csr2 *data)
{
 ROCK_CSR2_bits bits;

 rock_read_csr2((ROCK_id) data->rid,bits);

 data->result.efwren = bits.efwren;
 data->result.auxon = bits.auxon;
 data->result.timeout = bits.timeout;
 data->result.elapsed = bits.elapsed;
 data->result.wscale = bits.wscale;

 return TL_OK;
}

/* rock read CSR1 data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_csr1(rockt_t_decode_csr1 *data)
{
 ROCK_CSR1_bits bits;

 rock_read_csr1((ROCK_id) data->rid,bits);

 data->result.tknin = bits.tknin;
 data->result.tknout = bits.tknout;
 data->result.ceob = bits.ceob;
 data->result.cerr = bits.cerr;
 data->result.crst = bits.crst;
 data->result.crngt = bits.crngt;
 data->result.cbusy = bits.cbusy;
 data->result.ctrgv = bits.ctrgv;

 return TL_OK;
}

/* rock read CSR0 data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_csr0(rockt_t_decode_csr0 *data)
{
 ROCK_CSR0_bits bits;

 rock_read_csr0((ROCK_id) data->rid,bits);

 data->result.efmode = bits.efmode;
 data->result.boe = bits.boe;
 data->result.tkndis = bits.tkndis;
 data->result.inttrg = bits.inttrg;
 data->result.diag = bits.diag;

 return TL_OK;
}

/* rock read Watchdog data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_watchdog(rockt_t_decode_watchdog *data)
{
 ROCK_WATCHDOG_bits bits;

 rock_read_watchdog((ROCK_id) data->rid,bits);

 data->result = bits;

 return TL_OK;
}

/* rock read FIFO data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_fifo(rockt_t_decode_fifo *data)
{
 ROCK_FIFO_bits bits;

 rock_read_fifo((ROCK_id) data->rid,bits);

 data->result.dff = bits.dff;
 data->result.dhf = bits.dhf;
 data->result.def = bits.def;
 data->result.eff = bits.eff;
 data->result.ehf = bits.ehf;
 data->result.eef = bits.eef;
 data->result.tef = bits.tef;
 data->result.tff = bits.tff;

 return TL_OK;
}

/* rock read reset data function*/
/* return TL_OK iff no error */
int rockt_tl_decode_reset(rockt_t_decode_reset *data)
{
 ROCK_RESET_bits bits;

 rock_read_reset((ROCK_id) data->rid,bits);

 data->result.fltrst = bits.fltrst;
 data->result.intrst = bits.intrst;
 data->result.auxrst = bits.auxrst;
 data->result.dfifo = bits.dfifo;
 data->result.efifo = bits.efifo;
 data->result.tfifo = bits.tfifo;
 data->result.xintf = bits.xintf;
 data->result.cintf = bits.cintf;

 return TL_OK;
}

/* rock set data function*/
/* return TL_OK iff no error */
int rockt_tl_set(rockt_t_set *data)
{
 int res;

 switch (data->bit.nr)
   {
   case ROCKT_Cset_cintf:
     res=rock_set_cintf((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_xintf:
     res=rock_set_xintf((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_tfifo:
     res=rock_set_tfifo((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_efifo:
     res=rock_set_efifo((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_dfifo:
     res=rock_set_dfifo((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_auxrst:
     res=rock_set_auxrst((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_intrst:
     res=rock_set_intrst((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_fltrst:
     res=rock_set_fltrst((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_watchdog:
     res=rock_set_watchdog((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_efmode:
     res=rock_set_efmode((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_boe:
     res=rock_set_boe((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_tkndis:
     res=rock_set_tkndis((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_inttrg:
     res=rock_set_inttrg((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_diag:
     res=rock_set_diag((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_elapsed:
     res=rock_set_elapsed((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_wscale:
     res=rock_set_wscale((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_test:
     res=rock_set_test((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_last:
     res=rock_set_last((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_cradd:
     res=rock_set_cradd((ROCK_id) data->rid,data->value);
     break;
   case ROCKT_Cset_goldenref:
     res=rock_set_goldenref((ROCK_id) data->rid,data->value);
     break;
   }

 if (res==ROCK_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;
   }

}

/* rock get data function*/
/* return TL_OK iff no error */
int rockt_tl_get(rockt_t_get *data)
{
 switch(data->bit.nr)
   {
   case ROCKT_Cget_cintf:
     data->result = rock_get_cintf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_xintf:
     data->result = rock_get_xintf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tfifo:
     data->result = rock_get_tfifo((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_efifo:
     data->result = rock_get_efifo((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_dfifo:
     data->result = rock_get_dfifo((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_auxrst:
     data->result = rock_get_auxrst((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_intrst:
     data->result = rock_get_intrst((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_fltrst:
     data->result = rock_get_fltrst((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_dff:
     data->result = rock_get_dff((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_dhf:
     data->result = rock_get_dhf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_def:
     data->result = rock_get_def((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_eff:
     data->result = rock_get_eff((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_ehf:
     data->result = rock_get_ehf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_eef:
     data->result = rock_get_eef((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tef:
     data->result = rock_get_tef((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tff:
     data->result = rock_get_tff((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_watchdog:
     data->result = rock_get_watchdog((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_efmode:
     data->result = rock_get_efmode((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_boe:
     data->result = rock_get_boe((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tkndis:
     data->result = rock_get_tkndis((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_inttrg:
     data->result = rock_get_inttrg((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_diag:
     data->result = rock_get_diag((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tknin:
     data->result = rock_get_tknin((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_tknout:
     data->result = rock_get_tknout((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_ceob:
     data->result = rock_get_ceob((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_cerr:
     data->result = rock_get_cerr((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_crst:
     data->result = rock_get_crst((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_crngt:
     data->result = rock_get_crngt((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_cbusy:
     data->result = rock_get_cbusy((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_ctrgv:
     data->result = rock_get_ctrgv((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_efwren:
     data->result = rock_get_efwren((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_auxon:
     data->result = rock_get_auxon((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_timeout:
     data->result = rock_get_timeout((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_elapsed:
     data->result = rock_get_elapsed((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_wscale:
     data->result = rock_get_wscale((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_elapsedtime:
     data->result = rock_get_elapsedtime((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_halt:
     data->result = rock_get_halt((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_busy:
     data->result = rock_get_busy((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_synchf:
     data->result = rock_get_synchf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_xbusy:
     data->result = rock_get_xbusy((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_xberr:
     data->result = rock_get_xberr((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_qtrg:
     data->result = rock_get_qtrg((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_cstate:
     data->result = rock_get_cstate((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_ptrg:
     data->result = rock_get_ptrg((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_sof:
     data->result = rock_get_sof((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_eof:
     data->result = rock_get_eof((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_syncrespf:
     data->result = rock_get_syncrespf((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_rocksfail:
     data->result = rock_get_rocksfail((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_slvsfail:
     data->result = rock_get_slvsfail((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_lwadd:
     data->result = rock_get_lwadd((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_xadd:
     data->result = rock_get_xadd((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_last:
     data->result = rock_get_last((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_cradd:
     data->result = rock_get_cradd((ROCK_id) data->rid);
     break;
   case ROCKT_Cget_goldenref:
     data->result = rock_get_goldenref((ROCK_id) data->rid);
     break;
   }

 return TL_OK;
}

/* rock raw write data function*/
/* return TL_OK iff no error */
int rockt_tl_write(rockt_t_write *data)
{
 int res;

 if (data->and_present)
   data->value &= data->and;
 if (data->or_present)
   data->value |= data->or;

 switch (data->reg.nr)
   {
   case ROCKT_Cwrite_reset:
     res=rockh_write_reset((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_watchdog:
     res=rockh_write_watchdog((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_csr0:
     res=rockh_write_csr0((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_csr2:
     res=rockh_write_csr2((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_trigger:
     res=rockh_write_trigger((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_golden:
     res=rockh_write_golden((ROCK_id) data->rid,data->value,1);
     break;
   case ROCKT_Cwrite_edfifo:
     res=rockh_write_edfifo((ROCK_id) data->rid,data->value,1);
     break;
   }

 if (res==ROCK_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;
   }
}

/* rock raw read data function*/
/* return TL_OK iff no error */
int rockt_tl_read(rockt_t_read *data)
{
 switch(data->reg.nr)
   {
   case ROCKT_Cread_reset:
     data->result = rockh_read_reset((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_fifo:
     data->result = rockh_read_fifo((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_watchdog:
     data->result = rockh_read_watchdog((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_csr0:
     data->result = rockh_read_csr0((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_csr1:
     data->result = rockh_read_csr1((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_csr2:
     data->result = rockh_read_csr2((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_elapsed:
     data->result = rockh_read_elapsed((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_trigger:
     data->result = rockh_read_trigger((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_tque:
     data->result = rockh_read_tque((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_tnow:
     data->result = rockh_read_tnow((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_rockinfo:
     data->result = rockh_read_rockinfo((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_golden:
     data->result = rockh_read_golden((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_efifo:
     data->result = rockh_read_efifo((ROCK_id) data->rid);
     break;
   case ROCKT_Cread_dfifo:
     data->result = rockh_read_dfifo((ROCK_id) data->rid);
     break;
   }

 return TL_OK;
}

/* rock raw readpage internal data function*/
/* return TL_OK iff no error */
int rockt_tl_readpage_internal(rockt_t_readpage_internal *data)
{
 ROCKH_INTERNAL_regs regs;
 int res;
 
 res = rockh_readpage_internal((ROCK_id) data->rid,regs);

 if (res!=ROCKH_ERROR_OK)
   {
    char *tmp;

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

    return TL_OK+res;
   }

 data->result.reset = regs.reset;
 data->result.fifo = regs.fifo;
 data->result.watchdog = regs.watchdog;
 data->result.csr0 = regs.csr0;
 data->result.csr1 = regs.csr1;
 data->result.csr2 = regs.csr2;
 data->result.elapsed = regs.elapsed;
 data->result.trigger = regs.trigger;

 return TL_OK;
}

/* rock raw readpage info data function*/
/* return TL_OK iff no error */
int rockt_tl_readpage_info(rockt_t_readpage_info *data)
{
 ROCKH_INFO_regs regs;
 int res;
 
 res = rockh_readpage_info((ROCK_id) data->rid,regs);

 if (res!=ROCKH_ERROR_OK)
   {
    char *tmp;

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

    return TL_OK+res;
   }

 data->result.tque = regs.tque;
 data->result.tnow = regs.tnow;
 data->result.rockinfo = regs.rockinfo;
 data->result.golden = regs.golden;

 return TL_OK;
}

/* rock readpage internal data function*/
/* return TL_OK iff no error */
int rockt_tl_decodepage_internal(rockt_t_decodepage_internal *data)
{
 ROCK_PAGE_INTERNAL_bits bits;
 int res;
 
 res = rock_readpage_internal((ROCK_id) data->rid,bits);

 if (res!=ROCKH_ERROR_OK)
   {
    char *tmp;

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

    return TL_OK+res;
   }

 data->result.fltrst = bits.fltrst;
 data->result.intrst = bits.intrst;
 data->result.auxrst = bits.auxrst;
 data->result.dfifo = bits.dfifo;
 data->result.efifo = bits.efifo;
 data->result.xintf = bits.xintf;
 data->result.tfifo = bits.tfifo;
 data->result.cintf = bits.cintf;
 data->result.dff = bits.dff;
 data->result.dhf = bits.dhf;
 data->result.def = bits.def;
 data->result.eff = bits.eff;
 data->result.ehf = bits.ehf;
 data->result.eef = bits.eef;
 data->result.tef = bits.tef;
 data->result.tff = bits.tff;
 data->result.watchdog = bits.watchdog;
 data->result.efmode = bits.efmode;
 data->result.boe = bits.boe;
 data->result.tkndis = bits.tkndis;
 data->result.inttrg = bits.inttrg;
 data->result.diag = bits.diag;
 data->result.tknin = bits.tknin;
 data->result.tknout = bits.tknout;
 data->result.ceob = bits.ceob;
 data->result.cerr = bits.cerr;
 data->result.crst = bits.crst;
 data->result.crngt = bits.crngt;
 data->result.cbusy = bits.cbusy;
 data->result.ctrgv = bits.ctrgv;
 data->result.efwren = bits.efwren;
 data->result.auxon = bits.auxon;
 data->result.timeout = bits.timeout;
 data->result.elapsed = bits.elapsed;
 data->result.wscale = bits.wscale;
 data->result.elapsedtime = bits.elapsedtime;
 data->result.halt = bits.halt;
 data->result.busy = bits.busy;
 data->result.synchf = bits.synchf;
 data->result.xbusy = bits.xbusy;
 data->result.xberr = bits.xberr;

 return TL_OK;
}

/* rock readpage info data function*/
/* return TL_OK iff no error */
int rockt_tl_decodepage_info(rockt_t_decodepage_info *data)
{
 ROCK_PAGE_INFO_bits bits;
 int res;
 
 res = rock_readpage_info((ROCK_id) data->rid,bits);

 if (res!=ROCKH_ERROR_OK)
   {
    char *tmp;

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

    return TL_OK+res;
   }

 data->result.tff = bits.tff;
 data->result.link = bits.link;
 data->result.qtrg = bits.qtrg;
 data->result.cstate = bits.cstate;
 data->result.ptrg = bits.ptrg;
 data->result.sof = bits.sof;
 data->result.eof = bits.eof;
 data->result.syncrespf = bits.syncrespf;
 data->result.rocksfail = bits.rocksfail;
 data->result.slvsfail = bits.slvsfail;
 data->result.lwadd = bits.lwadd;
 data->result.xadd = bits.xadd;
 data->result.last = bits.last;
 data->result.cradd = bits.cradd;
 data->result.goldenref = bits.goldenref;

 return TL_OK;
}

/* rock readfifo DFIFO data function*/
/* return TL_OK iff no error */
int rockt_tl_readdfifo(rockt_t_readdfifo *data)
{
 int res;
 unsigned int count;
 unsigned int *buffer;
 _STR_natural *listel;

 if (!data->size_present)
   { /* set to default */
     data->size=16*1024;
   }

 buffer=(unsigned int *) malloc(data->size*4);

 count=data->size;
 res=rock_readfifo_dfifo(data->rid,count,buffer);

 /* check for error*/
 if (res!=ROCK_ERROR_OK)
   {
    char *tmp;

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

    free(buffer);
    return TL_OK+res;
   }

 /* create the list */
 {
   int i;

   for (i=count-1; i>=0; i--)
     {
       listel = (_STR_natural *) malloc(sizeof(_STR_natural));
       listel->next = data->result;
       listel->element = buffer[i];
       data->result = listel;
     }
 }

 free(buffer);
 return TL_OK;
}

/* rock readfifo EFIFO data function*/
/* return TL_OK iff no error */
int rockt_tl_readefifo(rockt_t_readefifo *data)
{
 int res;
 unsigned int count;
 unsigned int *buffer;
 _STR_natural *listel;

 if (!data->size_present)
   { /* set to default */
     data->size=16*1024;
   }

 buffer=(unsigned int *) malloc(data->size*4);

 count=data->size;
 res=rock_readfifo_efifo(data->rid,count,buffer);

 /* check for error*/
 if (res!=ROCK_ERROR_OK)
   {
    char *tmp;

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

    free(buffer);
    return TL_OK+res;
   }

 /* create the list */
  {
   int i;

   for (i=count-1; i>=0; i--)
     {
       listel = (_STR_natural *) malloc(sizeof(_STR_natural));
       listel->next = data->result;
       listel->element = buffer[i];
       data->result = listel;
     }
 }

 free(buffer);
 return TL_OK;
}