/****************************************************************/
/*                                                              */
/*  file: rcuscope.c                                            */
/*                                                              */
/* This program allows to access the resources of the RCU card  */
/* in a user friendly way and includes some test routines       */
/*                                                              */
/*  Author: Luciano Musa, CERN-PH                               */
/*                                                              */
/*  10. May. 08  LM   created                                   */
/*  21. May. 08  last modified                                  */
/*                                                              */
/****************************************************************/
// TEMPORARY CORRECTIONS
// 1. MCONTROL needs to have an SCTONROL to be used in the TESTALL
//    temporary the numric valus has been put in reg_mask



#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/file.h>
#include <signal.h>

#include "get_input.h"
#include "rcc_time_stamp.h"
#include "fec2rorc_lib.h"
#include "rcu.h"

#define MAX_MEM 6144

/*************/
/* Globals */
/*************/
u_int packageId=99;
u_int traceLevel=0;
int rcu_id;
rorc_node_t rorc_node;
chan_key *rorc;
extern rcu_bank_t *rcu_mem[12]; 
u_int reg_add[14] = {A_ALTROIF,A_TRGCONF,A_RDOMOD,A_ALTROCFG1,A_ALTROCFG2, \
  		     A_BP_VERSION,A_SIFBLREG,A_CONTROL,A_ROI_CONFIG1,A_ROI_CONFIG2, \
		     A_L1_LATENCY,A_L2_LATENCY,A_ROI_LATENCY,A_L1_MSG_LATENCY};
		      
u_int reg_mask[14] ={M_ALTROIF,M_TRGCONF,M_RDOMOD,M_ALTROCFG1,M_ALTROCFG2, \
  		     M_BP_VERSION,M_SIFBLREG,0xf0f,M_ROI_CONFIG1,M_ROI_CONFIG2, \
		     M_L1_LATENCY,M_L2_LATENCY,M_ROI_LATENCY,M_L1_MSG_LATENCY};


/*************/
/* Prototypes*/
/*************/
int mainhelp(void);
int rcufuncmenu(void);
int setdebug(void);


/****************/
int setdebug(void)
/****************/
{
  printf("\nPackage identifier:\n");
  printf("RCU library: %d\n", P_ID_RCU);
  printf("\n");
  printf("Enter the debug package: ");
  packageId = getdecd(packageId);
  printf("Enter the debug level: ");
  traceLevel = getdecd(traceLevel);
/*  RCU_SetDebug(packageId, traceLevel); */
  return(0);
}

/****************/
int mainhelp(void)
/****************/
{
  printf("Call Luciano Musa, 76261, 163119 if you need help\n");
  return(0);
}

/******************************/
int main(int argc, char *argv[])
/******************************/
{  
  static int ret, fun = 1;
    
  ret = ts_open(1, TS_DUMMY);
  if (ret)
    rcc_error_print(stdout, ret); 
 
  printf("\n\n\nThis is RCUSCOPE\n");
  while(fun != 0)
  {
    printf("\n");
    printf("Select an option:\n");
    printf("  1 Print help\n");
    printf("  2 RCU menu\n");
    printf("  3 Set debugging parameters\n"); 
    printf("  0 Quit\n");
    printf("Your choice ");
    fun = getdecd(fun);
    if (fun == 1) mainhelp();
    if (fun == 2) rcufuncmenu();
    if (fun == 3) setdebug(); 
  }

  ts_close(TS_DUMMY); 
  exit(0);
}


/*******************/
int rcufuncmenu(void)
/*******************/
{  
  static u_int fun, choice, ncycles=1, tofile=0, dsource=0, fsize=0, sib_nempty;
  int ret = 0;
  static u_int mem_add=0, offset=0, max_nr_words, rcode=0, rdata=0,data_mask;
  static u_int ccode=0;
  static u_int fdata[MAX_MEM]={0};
  static char fname[200] = {0};
  u_long rsize=10, osize, word=0x55555555; 
  u_long memdata[MAX_MEM]={0}, memout[MAX_MEM]={0}; 
  u_int loop, index, cycle, tcount, ii;
  tstamp ts1, ts2;
  float delta_t;
  FILE  *file;
  
  /* new added */
  static u_int wdata = 0;
  static u_long data_in, data_out=0;
  u_int reg_num = 14;

  fun = 1; 
  while(fun != 0)
  {
    printf("\n");
    printf("Select an option:\n");
    printf("   1 RCU_Open               2 RCU_Close\n");    
    printf("  ------------------------------------------\n");    
    printf("   3 RCU_IMEM_Read          4 RCU_IMEM_Write\n");
    printf("   5 RCU_ROLM_Read          6 RCU_ROLM_Write\n");
    printf("   7 RCU_RESM_Read          8 RCU_RESM_Write\n");
    printf("   9 RCU_HTLM_Read         10 RCU_HTLM_Write\n");
    printf("  11 RCU_DATM_Read         12 RCU_DATM_Write\n");
    printf("  ------------------------------------------\n");    
    printf("  13 RCU_CSR               14 RCU_Commands\n");
    printf("  15 TrgMod_CSR	           16 TrgMod_Commands\n");
    printf("  ------------------------------------------\n");    
/*    printf("  17 MSM_CSR               18 MSM_Commands\n"); not available */
    printf("  ------------------------------------------\n");    
    printf("  18 MEM_W_R_Check         21 Test All      \n");
    printf("  ------------------------------------------\n");    
    printf("  19 RCU_File_Read         20 RCU_File_Write\n");
    printf("  ------------------------------------------\n");    
    printf("  22 RCU (HITM) loop back test              \n");
    printf("  ============================================\n");
    printf("   0 Quit\n");
    printf("Your choice ");
    fun = getdecd(fun); 

    if ((fun < 0) || (fun == 17) || (fun > 22)) {
      printf ("\n ERROR: your selection is out of range\n");  
      return(-1);
    }	

    
/************************************************/
/*		    RCU OPEN			*/
/************************************************/    
    if (fun == 1) 
    {
      char revision_var[100];
      char serial_var  [100];
      char channel_var [100];
      printf("\nWhich RCU you want to work with? ");
      printf("Values range from 0 (innermost) to 5 (outermost)\n");
      printf("Your choice: ");
      rcu_id = getdecd(rcu_id); printf("\n");   
      
      sprintf(revision_var,"RORC_REVISION%d",rcu_id);
      sprintf(serial_var,  "RORC_SERIAL%d",  rcu_id);
      sprintf(channel_var, "RORC_CHANNEL%d", rcu_id);
      if (getenv(revision_var)!=NULL && 
	  getenv(serial_var  )!=NULL && 
	  getenv(channel_var )!=NULL) {
	DEBUG_TEXT(P_ID_RCU, 80 ,("using environment variables for RORC parameters"))
	rorc_node.revision=atoi(getenv(revision_var));
	rorc_node.serial  =atoi(getenv(serial_var  ));
	rorc_node.channel =atoi(getenv(channel_var ));
      }
      else {
	DEBUG_TEXT(P_ID_RCU, 80 ,("using hardcoded/default RORC parameters"))
      switch(rcu_id)
      {
        case 0:
	   rorc_node.revision = RORC_REVISION0;
	   rorc_node.serial   = RORC_SERIAL0;
	   rorc_node.channel  = RORC_CHANNEL0;
	   break;
	case 1:   
	   rorc_node.revision = RORC_REVISION1;
	   rorc_node.serial   = RORC_SERIAL1;
	   rorc_node.channel  = RORC_CHANNEL1;
	   break;
	case 2:   
	   rorc_node.revision 	= RORC_REVISION2;
	   rorc_node.serial	= RORC_SERIAL2;
	   rorc_node.channel   = RORC_CHANNEL2;
	   break;
	case 3:   
	   rorc_node.revision 	= RORC_REVISION3;
	   rorc_node.serial	= RORC_SERIAL3;
	   rorc_node.channel   = RORC_CHANNEL3;
	   break;
	case 4:   
	   rorc_node.revision 	= RORC_REVISION4;
	   rorc_node.serial	= RORC_SERIAL4;
	   rorc_node.channel   = RORC_CHANNEL4;
	   break;
	case 5:   
	   rorc_node.revision 	= RORC_REVISION5;
	   rorc_node.serial	= RORC_SERIAL5;
	   rorc_node.channel   = RORC_CHANNEL5;
	   break;
	default:
	   printf("\n ERROR: your selection is out of range\n");
	   return (-1);
           break;
     }     
      }
      DEBUG_TEXT(P_ID_RCU, 80 ,("RORC parameters: revision: %d, serail number: %d, channel: %d",rorc_node.revision,rorc_node.serial,rorc_node.channel))
     ret = RCU_Open(&rorc_node); 
     if(ret)
     {
       DEBUG_TEXT(P_ID_RCU, 10,("RCU_Open() fail: %d\n", ret));
       return ret; 
     }
     DEBUG_TEXT(P_ID_RCU, 80 ,("RORC parameters:\nMinor number:\t%d\nChannel number:\t%d\nStatus:\t%d\n", \
                                rorc->minor, rorc->channel, rorc->status ));     
  } 
  
  
/************************************************************************/
/*		   		 RCU CLOSE				*/
/************************************************************************/    
    if (fun == 2)
    {
       ret = RCU_Close();
       if(ret)
       { 
         DEBUG_TEXT(P_ID_RCU, 10,("RCU_Close() fail: %d\n", ret));
         return ret; 
       }     
    }       
    

/************************************************************************/
/*		READ MEMORIES: IMEM, ROLM, RESM, HITM			*/
/************************************************************************/
    if ((fun == 3) || (fun == 5) || (fun == 7) || (fun == 9))
    {
      printf("\nEnter the offset were you want to start reading ");
      offset = getdecd(offset);
      
      switch (fun)
      {
        case  3: 
           max_nr_words = S_IMEM - offset;
	   break;
        case  5: 
           max_nr_words = S_ROLM - offset;
	   break;
        case  7: 
           max_nr_words = S_RESM - offset;
	   break;
        case  9: 
           max_nr_words = S_HITM - offset;
	   break;
      }	   

      printf("How many words do you want to read (max %d) ", max_nr_words);
      rsize = getdecd(rsize);
      if (rsize > max_nr_words){
         printf("Wrong choice. The max nr. of words allowed (%d) will be read from memory\n\n", max_nr_words);
         rsize = max_nr_words;
      }
      
      printf("Do you want to write the data to file (1=yes 0=no): ");
        tofile = getdecd(tofile);
      
      if (tofile)
      {
         printf("Enter the path and name of the file to write: ");
         getstrd(fname, fname);
      }

      switch (fun)
      {
        case  3: 
           ret = RCU_IMEM_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_IMEM_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  5: 
           ret = RCU_ROLM_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_ROLM_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  7: 
           ret = RCU_RESM_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_RESM_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  9: 
           ret = RCU_HITM_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_HITM_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
      }	   

      if (tofile)
      {
        DEBUG_TEXT(P_ID_RCU, 50,("Dumping data to file\n"));
        file = fopen(fname, "w");
	if (file == 0) 
	{
          DEBUG_TEXT(P_ID_RCU, 5,("Can't open output file\n"));
	  return(-1);
	}
  
        printf("The first 20 words are\n\n");	
        for (loop = 0; loop < rsize; loop++)
	{
	  if (loop < 20)
	    printf("Addr %x = 0x%08x\n", loop+offset, memdata[loop]);
	  else if (loop == 20)
	    printf("........\n"); 
	  fprintf(file,"%x\n",memdata[loop]);
        }
        fclose(file);
      }      

      else
      {  
        
        for (loop = 0; loop < rsize; loop++)
          printf("Addr %x = 0x%08x\n", loop+offset, memdata[loop]); 
      } 
    }  


/************************************************************************/
/*		WRITE MEMORIES: IMEM, ROLM, RESM, HITM			*/
/************************************************************************/ 
    if ((fun == 4) || (fun == 6) || (fun == 8) || (fun == 10))
    {
      printf("\nEnter the offset were you want to start writing ");
      offset = getdecd(offset);
      
      switch (fun)
      {
        case  4: 
           max_nr_words = S_IMEM - offset;
	   break;
        case  6: 
           max_nr_words = S_ROLM - offset;
	   break;
        case  8: 
           max_nr_words = S_RESM - offset;
	   break;
        case 10: 
           max_nr_words = S_HITM - offset;
	   break;
      }	   

      printf("How many words do you want to write (max %d) ", max_nr_words);
      rsize = getdecd(rsize);
      if (rsize > max_nr_words){
         printf("Wrong choice. The max nr. of words allowed (%d) will be written into memory\n\n", max_nr_words);
         rsize = max_nr_words;
      }
      
      printf("Select the data source");
      printf("\n 0 = Enter by hand");
      printf("\n 1 = From last RCU_File_Read");
      printf("\n 2 = Incremental pattern");
      printf("\n 3 = Constant pattern\n");
      dsource = getdecd(dsource);
 
      if (dsource == 0){
        for (loop = 0; loop < rsize; loop++)
	{
	  printf("Enter data word%d 0x", loop);
	  memdata[loop] = gethexd(memdata[loop]);
	}
      }
      else if (dsource == 1){
        for (loop = 0; loop < rsize; loop++)
	  memdata[loop] = fdata[loop];
      }
      else if (dsource == 2){
        for(loop=0; loop <rsize; loop++)
          memdata[loop] = loop;     
      }
      else{
        printf("Enter data word 0x");
        word = gethexd(word);
        for (loop = 0; loop < rsize; loop++)
	  memdata[loop] = word;
      }
      
      switch (fun)
      {
        case  4: 
           ret = RCU_IMEM_Write(offset, rsize, memdata);
	   if(ret){
             DEBUG_TEXT(P_ID_RCU, 5, ("RCU_IMEM_Write() fail: ret=%d", ret));
	     return ret;
           }
	   break;
        case  6: 
           ret = RCU_ROLM_Write(offset, rsize, memdata);
	   if(ret){
             DEBUG_TEXT(P_ID_RCU, 5, ("RCU_ROLM_Write() fail: ret=%d", ret));
	     return ret;
           }
	   break;
        case  8: 
           ret = RCU_RESM_Write(offset, rsize, memdata);
	   if(ret){
             DEBUG_TEXT(P_ID_RCU, 5, ("RCU_RESM_Write() fail: ret=%d", ret));
	     return ret;
           }
	   break;
        case 10: 
           ret = RCU_HITM_Write(offset, rsize, memdata);
	   if(ret){
             DEBUG_TEXT(P_ID_RCU, 5, ("RCU_HITM_Write() fail: ret=%d", ret));
	     return ret;
           }
	   break;
      }	         
    }

/************************************************************************/
/*				READ DATA MEMORY			*/
/************************************************************************/

    if (fun == 11) 
    {
      printf("\nWhich Data Memory do you want to read\n ");
      printf("1 Branch A DM0 20LSB\n ");
      printf("2 Branch A DM0 20MSB\n ");
      printf("3 Branch A DM1 20LSB\n ");
      printf("4 Branch A DM1 20MSB\n ");
      printf("5 Branch B DM0 20LSB\n ");
      printf("6 Branch B DM0 20MSB\n ");
      printf("7 Branch B DM1 20LSB\n ");
      printf("8 Branch B DM1 20MSB\n ");
      choice = getdecd(choice);

      printf("\nEnter the offset were you want to start reading ");
      offset = getdecd(offset);
      max_nr_words = S_DATM - offset;

      printf("How many words do you want to read (max %d) ", max_nr_words);
      rsize = getdecd(rsize);
      if (rsize > max_nr_words){
         printf("Wrong choice. The max nr. of words allowed (%d) will be read from memory\n\n", max_nr_words);
         rsize = max_nr_words;
      }
      
      printf("Do you want to write the data to file (1=yes 0=no): ");
        tofile = getdecd(tofile);
      
      if (tofile)
      {
         printf("Enter the path and name of the file to write: ");
         getstrd(fname, fname);
      }

      switch (choice)
      {
        case  1: 
           ret = RCU_DATM_A0L_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A0L_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  2: 
           ret = RCU_DATM_A0H_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A0H_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  3: 
           ret = RCU_DATM_A1L_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A1L_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  4: 
           ret = RCU_DATM_A1H_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A1H_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  5: 
           ret = RCU_DATM_B0L_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B0L_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  6: 
           ret = RCU_DATM_B0H_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B0H_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  7: 
           ret = RCU_DATM_B1L_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B1L_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  8: 
           ret = RCU_DATM_B1H_Read(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B1H_Read() fail: ret=%d", ret));
            return ret;
           }
	   break;
      }	   

      if (tofile)
      {
        DEBUG_TEXT(P_ID_RCU, 50,("Dumping data to file\n"));
        file = fopen(fname, "w");
	if (file == 0) 
	{
          DEBUG_TEXT(P_ID_RCU, 5,("Can't open output file\n"));
	  return(-1);
	}
  
        printf("The first 20 words are\n\n");	
        for (loop = 0; loop < rsize; loop++)
	{
	  if (loop < 20)
	    printf("Addr %x = 0x%08x\n", loop+offset, memdata[loop]);
	  else if (loop == 20)
	    printf("........\n"); 
	  fprintf(file,"%x\n",memdata[loop]);
        }
        fclose(file);
      }      

      else
      {  
        
        for (loop = 0; loop < rsize; loop++)
          printf("Addr %x = 0x%08x\n", loop+offset, memdata[loop]); 
      } 
    }  

/************************************************************************/
/*				READ DATA MEMORY			*/
/************************************************************************/
    if (fun == 12) 
    {
      printf("\nWhich Data Memory do you want to write\n ");
      printf("1 Branch A DM0 20LSB\n ");
      printf("2 Branch A DM0 20MSB\n ");
      printf("3 Branch A DM1 20LSB\n ");
      printf("4 Branch A DM1 20MSB\n ");
      printf("5 Branch B DM0 20LSB\n ");
      printf("6 Branch B DM0 20MSB\n ");
      printf("7 Branch B DM1 20LSB\n ");
      printf("8 Branch B DM1 20MSB\n ");
      choice = getdecd(choice);
      
      printf("\nEnter the offset were you want to start writing ");
      offset = getdecd(offset);
      max_nr_words = S_DATM - offset;

      printf("How many words do you want to write (max %d) ", max_nr_words);
      rsize = getdecd(rsize);
      if (rsize > max_nr_words){
         printf("Wrong choice. The max nr. of words allowed (%d) will be written into memory\n\n", max_nr_words);
         rsize = max_nr_words;
      }
      
      printf("Select the data source");
      printf("\n 0 = Enter by hand");
      printf("\n 1 = From last RCU_File_Read");
      printf("\n 2 = Incremental pattern");
      printf("\n 3 = Constant pattern\n");
      dsource = getdecd(dsource);
 
      if (dsource == 0){
        for (loop = 0; loop < rsize; loop++)
	{
	  printf("Enter data word%d 0x", loop);
	  memdata[loop] = gethexd(memdata[loop]);
	}
      }
      else if (dsource == 1){
        for (loop = 0; loop < rsize; loop++)
	  memdata[loop] = fdata[loop];
      }
      else if (dsource == 2){
        for(loop=0; loop <rsize; loop++)
          memdata[loop] = loop;     
      }
      else{
        printf("Enter data word 0x");
        word = gethexd(word);
        for (loop = 0; loop < rsize; loop++)
	  memdata[loop] = word;
      }
      
      switch (choice)
      {
        case  1: 
           ret = RCU_DATM_A0L_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A0L_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  2: 
           ret = RCU_DATM_A0H_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A0H_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  3: 
           ret = RCU_DATM_A1L_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A1L_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  4: 
           ret = RCU_DATM_A1H_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_A1H_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  5: 
           ret = RCU_DATM_B0L_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B0L_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  6: 
           ret = RCU_DATM_B0H_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B0H_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  7: 
           ret = RCU_DATM_B1L_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B1L_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
        case  8: 
           ret = RCU_DATM_B1H_Write(offset, rsize, memdata);
           if(ret){
            DEBUG_TEXT(P_ID_RCU, 5, ("RCU_DATM_B1H_Write() fail: ret=%d", ret));
            return ret;
           }
	   break;
      }
    }	   


/************************************************************************/
/*  		ACCESS TO CONFIGURATION & STATUS REGISTERS  		*/
/************************************************************************/
    if (fun == 13)
    {
      choice = 1;
      while(choice != 0)
      {
    	printf("\n");
    	printf("Select an option:\n");
	printf("\n  General Configuration Registers");
	printf("\n  ------------------------------------------\n");
    	printf("   1 Read ACTFECLIST        2 Write ACTFECLIST\n");
    	printf("   3 Read ALTROIF           4 Write ALTROIF\n");
    	printf("   5 Read TRGCONF           6 Write TRGCONF\n");
    	printf("   7 Read RDOMOD            8 Write RDOMOD\n");
    	printf("   9 Read ALTROCFG1        10 Write ALTROCFG1\n");
    	printf("  11 Read ALTROCFG2        12 Write ALTROCFG2\n");
    	printf("  13 Read BP_VERSION       14 Write BP_VERSION\n");
    	printf("  15 Read RCU_ID           16 Write RCU_ID\n");
	printf("\n  Status and Error Registers");
	printf("\n  ------------------------------------------\n");
	printf("  17 Read RCU_VERSION      		      \n");
    	printf("  18 Read FECERRA          19 Read FECERRB\n");
    	printf("  20 Read RDOERR           21 Read ALTROBUS\n");
    	printf("  22 Read BUSSTTRSF        23 Read RCUBUSBUSY\n");
    	printf("  24 Read SWTTRGCNT        25 Read AUXTRGCNT\n");
    	printf("  26 Read TTCL2ACNT        27 Read TTCL2RCNT\n");
    	printf("  28 Read DSTBACNT         29 Read DSTBBCNT\n");
    	printf("  30 Read TRSFACNT         31 Read TRSFBRCNT\n");
    	printf("  32 Read ACKACNT          33 Read ACKBCNT\n");
    	printf("  34 Read CSTBACNT         35 Read CSTBBCNT\n");
    	printf("  36 Read DSTBNUMA         37 Read DSTBNUMB\n");
    	printf("  38 Read ADDRMISMATCH     39 Read BLENMISMATCH\n");
    	printf("  40 Read MEBCNT  	   41 Read ABDFSM      \n");
	printf("  42 Read RDOFSM	   43 Read ISFSM	\n");
	printf("  44 Read EVTMANFSM				\n"); 
	printf("\n  SIF REGISTERS");
	printf("\n  ------------------------------------------\n");
    	printf("  45 Read STATUS REG       46 Read ERROR REG\n");
    	printf("  47 Read BL REG      	   48 Write BL REG  \n");
    	printf("  ============================================\n");
    	printf("   0 Quit\n");
    	printf("Your choice ");
    	choice = getdecd(choice);
        if ((choice < 0) || (choice > 48)){
      	  printf ("\n ERROR: your selection is out of range\n");  
          return(-1);
        }	

        if((choice ==  2) || (choice ==  4) || (choice ==  6) || (choice ==  8) || \
	   (choice == 10) || (choice == 12) || (choice == 14) || (choice == 16) || \
	   (choice == 48))
	{	
           printf("Enter data that you want to write ");
           wdata = gethexd(wdata);
	}
	      	
        switch (choice)
	{
	   case 1:
	     ret = RCU_ACTFECLIST_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ACTFECLIST_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ACTFECLIST:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 2:
	     ret = RCU_ACTFECLIST_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ACTFECLIST_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;

	   case 3:
	     ret = RCU_ALTROIF_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROIF_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 4:
	     ret = RCU_ALTROIF_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROIF_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		               
	     
	   case 5:
	     ret = RCU_TRGCONF_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TRGCONF_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 6:
	     ret = RCU_TRGCONF_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TRGCONF_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;			     

	   case 7:
	     ret = RCU_RDOMOD_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RDOMOD_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 8:
	     ret = RCU_RDOMOD_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RDOMOD_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;			     

	   case 9:
	     ret = RCU_ALTROCFG1_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROCFG1_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 10:
	     ret = RCU_ALTROCFG1_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROCFG1_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;			     

	   case 11:
	     ret = RCU_ALTROCFG2_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROCFG2_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 12:
	     ret = RCU_ALTROCFG2_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROCFG2_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;			     

	   case 13:
	     ret = RCU_BP_VERSION_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BP_VERSION_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register BP_VERSION:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 14:
	     ret = RCU_BP_VERSION_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BP_VERSION_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;	     

	   case 15:
	     ret = RCU_RCUID_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RCUID_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 16:
	     ret = RCU_RCUID_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RCUID_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;	

	   case 17:
	     ret = RCU_RCU_VERSION_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RCU_VERSION_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 18:
	     ret = RCU_FECERRA_Get();
  	     printf("\nreturn1 = %d\n", ret);  
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_FECERRA_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 19:
	     ret = RCU_FECERRB_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_FECERRB_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 20:
	     ret = RCU_RDOERR_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RDOERR_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 21:
	     ret = RCU_ALTROBUS_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ALTROBUS_Read() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 22:
	     ret = RCU_BUSSTTRSF_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BUSSTTRSF_Read() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 23:
	     ret = RCU_RCUBUSBUSY_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RCUBUSBUSY_Read() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 24:
	     ret = RCU_SWTTRGCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_SWTTRGCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter SWTTRGCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 25:
	     ret = RCU_AUXTRGCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_AUXTRGCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter AUXTRGCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 26:
	     ret = RCU_TTCL2ACNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TTCL2ACNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter TTCL2ACNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 27:
	     ret = RCU_TTCL2RCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TTCL2RCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter TTCL2RCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 28:
	     ret = RCU_DSTBACNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_DSTBACNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter DSTBACNT:\t%x\n\n\n", memdata[0]);
	     break;	     	     
	   case 29:
	     ret = RCU_DSTBBCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_DSTBBCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter DSTBBCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 30:
	     ret = RCU_TRSFACNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TRSFACNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter TRSFACNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 31:
	     ret = RCU_TRSFBCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_TRSFBCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter TRSFBCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 32:
	     ret = RCU_ACKACNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ACKACNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter ACKACNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 33:
	     ret = RCU_ACKBCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ACKBCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter ACKBCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 34:
	     ret = RCU_CSTBACNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_CSTBACNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter CSTBACNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 35:
	     ret = RCU_CSTBBCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_CSTBBCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter CSTBBCNT:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 36:
	     ret = RCU_DSTBNUMA_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_DSTBNUMA_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter DSTBNUMA:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 37:
	     ret = RCU_DSTBNUMB_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_DSTBNUMB_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter DSTBNUMB:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 38:
	     ret = RCU_ADDRMISMATCH_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ADDRMISMATCH_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter ADDRMISMATCH:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 39:
	     ret = RCU_BLENMISMATCH_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BLENMISMATCH_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter BLENMISMATCH:\t%x\n\n\n", memdata[0]);
	     break;	     
	   case 40:
	     ret = RCU_MEBCNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MEBCNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter MEBCNT:\t%x\n\n\n", memdata[0]);
	     break;	     

	   case 41:
	     ret = RCU_ABDFSM_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ABDFSM_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter ABDFSM:\t%x\n\n\n", memdata[0]);
	     break;	     

	   case 42:
	     ret = RCU_RDOFSM_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_RDOFSM_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter RDOFSM:\t%x\n\n\n", memdata[0]);
	     break;	     

	   case 43:
	     ret = RCU_ISFSM_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ISFSM_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter ISFSM:\t%x\n\n\n", memdata[0]);
	     break;	     

	   case 44:
	     ret = RCU_EVTMANFSM_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_EVTMANFSM_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Counter EVTMANFSM:\t%x\n\n\n", memdata[0]);
	     break;	     

	   case 45:
	     ret = RCU_SIF_STATUS_Get();
  	     printf("\nreturn1 = %d\n", ret);  
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_SIF_STATUS_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 46:
	     ret = RCU_SIF_ERROR_Get();
  	     printf("\nreturn1 = %d\n", ret);  
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_SIF_ERROR_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       
	     
	   case 47:
	     ret = RCU_SIFBLREG_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_SIFBLREG_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register SIFBLREG:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 48:
	     ret = RCU_SIFBLREG_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_SIFBLREG_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;
	}
	
      }
    }


/************************************************************************/
/*			TTC INTERFACE MODULE REGISTERS			*/
/************************************************************************/
    if (fun == 15)
    {
      choice = 1;
      while(choice != 0)
      {
    	printf("\n");
    	printf("Select an option:\n");
	printf("\n Configuration & Status Registers");
	printf("\n  ------------------------------------------\n");
    	printf("   1 Read Control           2 Write Control\n");
    	printf("   3 Read ROI_Config1       4 Write ROI_Config1\n");
    	printf("   5 Read ROI_Config2       6 Write ROI_Config2\n");
    	printf("   7 Read L1_Latency        8 Write L1_Latency\n");
    	printf("   9 Read L2_Latency       10 Write L2_Latency\n");
    	printf("  11 Read RoI_Latency      12 Write RoI_Latency\n");
    	printf("  13 Read L1_msg_latency   14 Write L1_msg_latency\n");
	printf("\n  Read-only Registers");
	printf("\n  ------------------------------------------\n");
    	printf("  15 Read Pre_pulse_cnt    16 Read BCID_Local\n");
    	printf("  17 Read L0_counter       18 Read L1_counter\n");
    	printf("  19 Read L1_msg_counter   20 Read L2a_counter\n");
    	printf("  21 Read L2r_counter      22 Read RoI_counter\n");
    	printf("  23 Read Bunchcounter     24 Read hamngErrorCnt\n");
    	printf("  25 Read ErrorCnt         26 Read Buffered_events  \n");
    	printf("  27 Read DAQ_Header       28 Read Event_info  \n");
    	printf("  29 Read Event_error      30 Read L1_MsgHeader  \n");
    	printf("  31 Read L1_MsgData       32 Read L2aMsgHeader  \n");
    	printf("  33 Read L2a_MsgData      34 Read L2rMsgHeader  \n");
    	printf("  35 Read RoI_Msg_Header   36 Read RoIMsgData  \n");
    	printf("  37 Read FIFO_DAQ_Header  \n");
    	printf("  ============================================\n");
    	printf("   0 Quit\n");
    	printf("Your choice ");
    	choice = getdecd(choice);
        if ((choice < 0) || (choice > 37)){
      	  printf ("\n ERROR: your selection is out of range\n");  
          return(-1);
        }	

        if((choice ==  2) || (choice ==  4) || (choice ==  6) || (choice ==  8) || \
	   (choice == 10) || (choice == 12) || (choice == 14))
	{	
           printf("Enter data that you want to write ");
           wdata = gethexd(wdata);
	}
	      	
        switch (choice)
	{
	   case 1:
	     ret = RCU_CONTROL_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_CONTROL_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 2:
	     ret = RCU_CONTROL_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_CONTROL_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		

	   case 3:
	     ret = RCU_ROI_CONFIG1_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_CONFIG1_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ROI_CONFIG1:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 4:
	     ret = RCU_ROI_CONFIG1_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_CONFIG1_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;

	   case 5:
	     ret = RCU_ROI_CONFIG2_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_CONFIG2_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ROI_CONFIG2:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 6:
	     ret = RCU_ROI_CONFIG2_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_CONFIG2_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;

	   case 7:
	     ret = RCU_L1_LATENCY_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_LATENCY_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 8:
	     ret = RCU_L1_LATENCY_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_LATENCY_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		

	   case 9:
	     ret = RCU_L2_LATENCY_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2_LATENCY_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 10:
	     ret = RCU_L2_LATENCY_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2_LATENCY_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		

	   case 11:
	     ret = RCU_ROI_LATENCY_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_LATENCY_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 12:
	     ret = RCU_ROI_LATENCY_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_LATENCY_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		

	   case 13:
	     ret = RCU_L1_MSG_LATENCY_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_MSG_LATENCY_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 14:
	     ret = RCU_L1_MSG_LATENCY_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_MSG_LATENCY_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		

	   case 15:
	     ret = RCU_PRE_PULSE_CNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_PRE_PULSE_CNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register PRE_PULSE_CNT:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 16:
	     ret = RCU_BCID_LOCAL_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BCID_LOCAL_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register BCID_LOCAL:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 17:
	     ret = RCU_L0_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L0_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L0_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 18:
	     ret = RCU_L1_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L1_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 19:
	     ret = RCU_L1_MSG_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_MSG_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L1_MSG_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 20:
	     ret = RCU_L2A_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2A_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L2A_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 21:
	     ret = RCU_L2R_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2R_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L2R_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 22:
	     ret = RCU_ROI_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ROI_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 23:
	     ret = RCU_BUNCH_COUNTER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BUNCH_COUNTER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register BUNCH_COUNTER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 24:
	     ret = RCU_HAMNG_ERR_CNT_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_HAMNG_ERR_CNT_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register HAMNG_ERR_CNT:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 25:
	     ret = RCU_ERROR_CNT_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ERROR_CNT_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	       

	   case 26:
	     ret = RCU_BUFFERED_EVENTS_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_BUFFERED_EVENTS_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register BUFFERED_EVENTS:\t%x\n\n\n", memdata[0]);
	     break;	
	            
	   case 27:
	     ret = RCU_DAQ_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_DAQ_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register DAQ_HEADER:\n");
	     for(loop =0; loop<7; loop++)
	        printf("DATA[%d] = 0x%x\n", loop, memdata[loop]);
	     break;	       	     

	   case 28:
	     ret = RCU_EVENT_INFO_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_EVENT_INFO_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;

	   case 29:
	     ret = RCU_EVENT_ERROR_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_EVENT_ERROR_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;

	   case 30:
	     ret = RCU_L1_MSG_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_MSG_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L1_MSG_HEADER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 31:
	     ret = RCU_L1_MSG_DATA_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L1_MSG_DATA_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L1_MSG_DATA:\n");
	     for(loop =0; loop<3; loop++)
	        printf("DATA[%d] = 0x%x\n", loop, memdata[loop]);
	     break;	       

	   case 32:
	     ret = RCU_L2A_MSG_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2A_MSG_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L2A_MSG_HEADER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 33:
	     ret = RCU_L2A_MSG_DATA_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2A_MSG_DATA_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L2A_MSG_DATA:\n");
	     for(loop =0; loop<7; loop++)
	        printf("DATA[%d] = 0x%x\n", loop, memdata[loop]);
	     break;	       

	   case 34:
	     ret = RCU_L2R_MSG_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_L2R_MSG_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register L2R_MSG_HEADER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 35:
	     ret = RCU_ROI_MSG_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_MSG_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ROI_MSG_HEADER:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 36:
	     ret = RCU_ROI_MSG_DATA_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_ROI_MSG_DATA_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register ROI_MSG_DATA:\n");
	     for(loop =0; loop<7; loop++)
	        printf("DATA[%d] = 0x%x\n", loop, memdata[loop]);
	     break;	       

	   case 37:
	     ret = RCU_FIFO_DAQ_HEADER_Read(memdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_FIFO_DAQ_HEADER_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register FIFO_DAQ_HEADER:\t%x\n\n\n", memdata[0]);
	     break;	       
	}    
     }               
    }
   
/************************************************************************/
/*		      		RCU COMMANDS              		*/
/************************************************************************/
    if (fun == 14)
    {
      choice = 1;
      while(choice != 0)
      {
      printf("Select an option:\n");
      printf("\n  General Commands");
      printf("\n  ------------------------------------------\n");
      printf("   1 CONFEC                 2 EXECSEQ\n");
      printf("   3 ABORT_SEQ              4 SWTTRG\n");
      printf("   5 CLRREGS                6 CLR_RD_RX_REG\n");
      printf("   7 CLR_TRG_CNT            8 ARBITER_IRQ\n");
      printf("\n  SIF Commands");
      printf("\n  ------------------------------------------\n");
      printf("   9 SIFRESET              10 GRESET\n");
      printf("  11 FECRESET       	   12 RCURESET  \n");     	
      printf("  13 CLEARSIB       	   14 CLEARSOB  \n");     	
      printf("  15 CLEARERR  \n");     	
      printf("  ============================================\n");
      printf("   0 Quit\n");
      printf("Your choice ");
      choice = getdecd(choice);
      if ((choice < 0) || (choice > 15)){
         printf ("\n ERROR: your selection is out of range\n");  
         return(-1);
      }	
           
     switch (choice)
     {
        case 1:
          ret = RCU_Exec_CONFEC();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CONFEC failed: ret=%d", ret));
          break;
   
        case 2:
          ret = RCU_Exec_EXECSEQ();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_EXESEQ failed: ret=%d", ret));
          break;
   
        case 3:
          ret = RCU_Exec_ABORTSEQ();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_ABORTSEQ failed: ret=%d", ret));
          break;

        case 4:
          ret = RCU_Exec_SWTTRG();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_SWTTRG failed: ret=%d", ret));
          break;
   
        case 5:
          ret = RCU_Exec_CLRREGS();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLRREGS failed: ret=%d", ret));
          break;
   
        case 6:
          ret = RCU_Exec_CLRRDRX();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLRRDRX failed: ret=%d", ret));
          break;
   
        case 7:
          ret = RCU_Exec_CLRTRGCNT();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLRTRGCNT failed: ret=%d", ret));
          break;
   
        case 8:
          ret = RCU_Exec_ARBITERIRQ();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_ARBITERIRQ failed: ret=%d", ret));
          break;
   
        case 9:
          ret = RCU_Exec_SIFRESET();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_SIFRESET failed: ret=%d", ret));
          break;
   
        case 10:
          ret = RCU_Exec_RESETALL();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_RESETALL failed: ret=%d", ret));
          break;
   
        case 11:
          ret = RCU_Exec_FECRESET();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_FECRESET failed: ret=%d", ret));
          break;

        case 12:
          ret = RCU_Exec_RCURESET();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_FECRESET failed: ret=%d", ret));
          break;
	  
        case 13:
          ret = RCU_Exec_CLEARSIB();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLEARSIB failed: ret=%d", ret));
          break;
	  
        case 14:
          ret = RCU_Exec_CLEARSOB();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLEARSOB failed: ret=%d", ret));
          break;

        case 15:
          ret = RCU_Exec_CLEARERR();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_CLEARERR failed: ret=%d", ret));
          break;
     }      
   }
   }

/************************************************************************/
/*		      		TRIGGER MODULE  COMMANDS              	*/
/************************************************************************/
    if (fun == 16)
    {
      choice = 1;
      while(choice != 0)
      {
      printf("Select an option:\n");
      printf("\n  Trigger Receiver Module Commands");
      printf("\n  ------------------------------------------\n");
      printf("   1 MODULE RESET           2 RESET COUNTERS\n");
      printf("   3 ISSUE TEST MODE        4 FIF READ EN\n");
      printf("  ============================================\n");
      printf("   0 Quit\n");
      printf("Your choice ");
      choice = getdecd(choice);
      if ((choice < 0) || (choice > 4)){
         printf ("\n ERROR: your selection is out of range\n");  
         return(-1);
      }	
           
     switch (choice)
     {
        case 1:
          ret = RCU_Exec_TMODULE_RESET();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_TMODULE_RESET failed: ret=%d", ret));
   
        case 2:
          ret = RCU_Exec_TRESET_COUNTERS();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_TRESET_COUNTERS failed: ret=%d", ret));
   
        case 3:
          ret = RCU_Exec_TISSUE_TEST_MODE();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_TISSUE_TEST_MODE failed: ret=%d", ret));

        case 4:
          ret = RCU_Exec_TFIFO_READ_EN();
	  if(ret)
	     DEBUG_TEXT(P_ID_RCU, 5, ("RCUSCOPE()> RCU_Exec_TFIFO_READ_EN failed: ret=%d", ret));
   
     }      
   }
   }

/************************************************************************/
/*  		ACCESS TO MSM CONFIGURATION & STATUS REGISTERS          */
/************************************************************************/
    if (fun == 17)
    {
      choice = 1;
      while(choice != 0)
      {
    	printf("\n");
    	printf("Select an option:\n");
	printf("\n  MSM Configuration Registers");
	printf("\n  ------------------------------------------\n");
    	printf("   1 Read INTMODE           2 Write INTMODE\n");
    	printf("   3 Read SCADD             4 Write SCADD\n");
    	printf("   5 Read SCDATA            6 Write SCDATA\n");
	printf("\n  Read-only Registers");
	printf("\n  ------------------------------------------\n");
    	printf("   7 Read RESULT            8 Read ERROR\n");
    	printf("  ============================================\n");
    	printf("   0 Quit\n");
    	printf("Your choice ");
    	choice = getdecd(choice);
        if ((choice < 0) || (choice > 8)){
      	  printf ("\n ERROR: your selection is out of range\n");  
          return(-1);
        }	

        if((choice ==  2) || (choice ==  4) || (choice ==  6))
	{	
           printf("Enter data that you want to write ");
           wdata = gethexd(wdata);
	}
	      	
        switch (choice)
	{
	   case 1:
	     ret = RCU_MSM_INTMODE_Get();
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_INTMODE_Read() failed: ret=%d", ret));
               return ret;
             }
	     printf("\n\nContent of Register MSM_INTMODE:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 2:
	     ret = RCU_MSM_INTMODE_Write(wdata);     
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_INTMODE_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;

	   case 3:
	     ret = RCU_MSM_SCADD_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_SCADD_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	   case 4:
	     ret = RCU_MSM_SCADD_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_SCADD_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		               
	     
	   case 5:
	     ret = RCU_MSM_SCDATA_Read(memdata);
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_SCADATA_Read() failed: ret=%d", ret));
             return ret;
             }
	     printf("\n\nContent of Register MSM_SCDATA:\t%x\n\n\n", memdata[0]);
	     break;	       
	   case 6:
	     ret = RCU_MSM_SCDATA_Write(wdata);
	     if (ret) {
               DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_SCDATA_Write() failed: ret=%d", ret));
               return ret;
             }
	     break;		               

	   case 7:
	     ret = RCU_MSM_RESULT_Read(memdata);
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_RESULT_Read() failed: ret=%d", ret));
             return ret;
             }
	     printf("\n\nContent of Register MSM_RESULT:\t%x\n\n\n", memdata[0]);
	     break;	       

	   case 8:
	     ret = RCU_MSM_ERROR_Get();
	     if (ret) {
             DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE> RCU_MSM_ERROR_Get() failed: ret=%d", ret));
             return ret;
             }
	     break;	
	}
	}
     }
     
/************************************************/
/*		RCU FILE READ			*/
/************************************************/
    if (fun == 19)
    {    
      printf("Enter the path and name of the file to read ");
      getstrd(fname, fname);
      printf("Enter the number of words to read ");
      fsize = getdecd(fsize);

      ret = RCU_File_Read(fname, fsize, fdata);
      if (ret)
      {
        rcc_error_print(stdout, ret);
        return(-1);
      }
      printf("The file has been read into the internal array\n"); 
      for(ii=0; ii<fsize; ii++)
        printf("\ndata = %x", fdata[ii]);
    }     
 
/************************************************/
/*		RCU FILE WRITE			*/
/************************************************/
    if (fun == 20)
    {    
      printf("Enter the path and name of the file to write ");
      getstrd(fname, fname);
      printf("Enter the number of words to write ");
      fsize = getdecd(fsize);

      ret = RCU_File_Write(fname, fsize, fdata);
      if (ret)
      {
        rcc_error_print(stdout, ret);
        return(-1);
      }
      printf("The file has been written with data from the internal array\n");       
    }     
  



     
/*************************************************************************/
/*  				TEST ALL 				 */
/*************************************************************************/
    if (fun == 21)
    {
      printf("How many test cycle you want to run ");
      ncycles = getdecd(ncycles);
      
      printf("Select the data source");
      printf("\n 0 = From last RCU_File_Read");
      printf("\n 1 = Incremental pattern");
      printf("\n 2 = Constant pattern\n");
      dsource = getdecd(dsource);
   
      if (dsource == 0){
        for (loop = 0; loop < MAX_MEM; loop++)
	  memdata[loop] = fdata[loop];
      }
      else if (dsource == 1){
        for(loop=0; loop < MAX_MEM; loop++)
          memdata[loop] = loop;     
      }
      else{
        printf("Enter data word 0x");
        word = gethexd(word);
	data_in = word;
        for (loop = 0; loop < MAX_MEM; loop++)
	  memdata[loop] = word;
      }

      printf("\nDo you want to write the results of the check to file (1=yes 0=no): ");
      tofile = getdecd(tofile);  
      if (tofile)
      {
        printf("Enter the path and name of the file to write: ");
        getstrd(fname, fname);
      }

      /* opening the file to write the results */
      if (tofile)
      {
        file = fopen(fname, "w");
	if (file == 0) 
	{
	  printf("Can't open output file\n");
	  return(-1);
        }
      }

/*************** MEMORIES ******************/
      for(cycle=0; cycle<ncycles; cycle++)
      {   
	 for(index=0; index<12; index++)
	 {   
	   ret = RCU_Memory_Write(rcu_mem[index], 0, rcu_mem[index]->size, memdata); 
           if(ret)
	   {
	      DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE()> RCU_Memory_Write fail: %d", ret));
	      return ret;
	   }
	   ret = RCU_Memory_Read(rcu_mem[index], 0, rcu_mem[index]->size, memout); 
           if(ret)
	   {
	      DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE()> RCU_Memory_Write fail: %d", ret));
	      return ret;
	   }
	
           /* CHECK memout data */
           for(loop=0; loop<rcu_mem[index]->size; loop++)
           {           

             if((memout[loop] & rcu_mem[index]->mask) != (memdata[loop] & rcu_mem[index]->mask))
	     {   
               if(tofile)
	       {
	         fprintf(file, "Error in test cycle nr. %d\n", cycle);
	         fprintf(file, "at memory 0x%x\t and location 0x%x\t: expected %x\t found %x\n", \
	              rcu_mem[index]->id, loop, memdata[loop] & rcu_mem[index]->mask, memout[loop]); 
	       }
	       else
	       {   
	         printf("Error in test cycle nr. %d\n", cycle);
	         printf("at memory location %d\t expected %d\t found %d\n", \
	              loop, memdata[loop] & rcu_mem[index]->mask, memout[loop]); 
	       } 
	     }   

           } 
 
         } 
       }
       
/*************** REGISTERS ******************/
      ts_delay(100000);
      for(cycle=0; cycle<ncycles; cycle++)
      {      

         for(index=0; index<reg_num; index++)
	 {
	   ts_delay(10000);
	   ret = RCU_Reg_Write(reg_add[index], data_in);
	   ts_delay(10000);
	   ret = RCU_Reg_Read(reg_add[index], &data_out);

	   DEBUG_TEXT(P_ID_RCU, 1, ("ADD = 0x%x\tDATA_IN = 0x%x\tDATA_OUT = 0x%x", reg_add[index], data_in,
	   data_out)); 

           /* CHECK memout data */
          if((data_out & reg_mask[index]) != (data_in & reg_mask[index]))
	     {   
               if(tofile)
	       {
	         fprintf(file, "Error in test cycle nr. %d\n", cycle);
	         fprintf(file, "At Reg ADD = 0x%x:\texpected 0x%x\t found 0x%x\n", \
	              reg_add[index], data_in & reg_mask[index], data_out); 
	       }
	       else
	       {   
	         printf("Error in test cycle nr. %d\n", cycle);
	         printf("At Reg ADD = 0x%x:\texpected 0x%x\t found 0x%x\n", \
	              reg_add[index], data_in & reg_mask[index], data_out); 
	       }
	     }  
          }
       }  
       
       if(tofile)
         fclose(file);
         
     } /* end of main if() */
    
    if (fun == 22) {

      printf("How many test cycle you want to run ");
      ncycles = getdecd(ncycles);
      
      printf("Select the data source");
      printf("\n 0 = From last RCU_File_Read");
      printf("\n 1 = Incremental pattern");
      printf("\n 2 = Constant pattern");
      printf("\n 3 = Random pattern\n");
      dsource = getdecd(dsource);
   
      if (dsource == 0){
        for (loop = 0; loop < MAX_MEM; loop++)
	  memdata[loop] = fdata[loop];
      }
      else if (dsource == 1){
        for(loop=0; loop < MAX_MEM; loop++)
          memdata[loop] = loop;     
      }
      else if (dsource == 3){
        for(loop=0; loop < MAX_MEM; loop++)
          memdata[loop] = rand()^rand()<<16;      /* ugly... but! */
      }
      else{
        printf("Enter data word 0x");
        word = gethexd(word);
	data_in = word;
        for (loop = 0; loop < MAX_MEM; loop++)
	  memdata[loop] = word;
      }

      printf("\nDo you want to write the results of the check to file (1=yes 0=no): ");
      tofile = getdecd(tofile);  
      if (tofile)
      {
        printf("Enter the path and name of the file to write: ");
        getstrd(fname, fname);
      }

      /* opening the file to write the results */
      if (tofile)
      {
        file = fopen(fname, "w");
	if (file == 0) 
	{
	  printf("Can't open output file\n");
	  return(-1);
        }
      }



      for(cycle=0;cycle<ncycles;++cycle) {   
	if (dsource == 3){
	  for(loop=0; loop < MAX_MEM; loop++)
	    memdata[loop] = rand()^rand()<<16;      /* ugly... but! */
	}
	printf("\rcycle %d of %d... ",cycle+1,ncycles);
	ret = RCU_HITM_Write(0,S_HITM,memdata);
	if(ret) {
	  DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE()> RCU_HITM_Write fail: %d", ret));
	  return ret;
	}
	ret = RCU_HITM_Read(0,S_HITM,memout);
	if(ret) {
	  DEBUG_TEXT(P_ID_RCU, 5,("RCUSCOPE()> RCU_HITM_Read fail: %d", ret));
	  return ret;
	}

	/* CHECK memout data */
	for(loop=0; loop<S_HITM; loop++) {           
	  if((memout[loop] & 0xFFFFFFFF) != (memdata[loop] & 0xFFFFFFFF)) {   
	    if(tofile) {
	      fprintf(file, "Error in test cycle nr. %d\n", cycle);
	      fprintf(file, "at memory 0x%x\t and location 0x%x\t: expected %x\t found %x\n",
		      rcu_mem[index]->id, loop, memdata[loop] & rcu_mem[index]->mask, memout[loop]); 
	    }
	    else {
	      printf("Error in test cycle nr. %d\n", cycle);
	      printf("at memory location %d\t expected %d\t found %d\n",
		     loop, memdata[loop] & rcu_mem[index]->mask, memout[loop]); 
	    } 
	  }   
	}
      }
      printf("\n");
    }
  }
}