peripheral {
  name = "FMC masterFIP core registers";
  description = "Wishbone slave for FMC masterFIP core";
  hdl_entity = "fmc_masterfip_csr";

  prefix = "mf";

-------------------------------------------------------------------------------
--                                   reset                                   --
-------------------------------------------------------------------------------
   reg {
      name = "rstn";
      prefix = "rstn";
      description = "software reset of the masterFIP core; active low; there is also an unlock word provided to prevent resetting the core by accidentally accessing this register.";

      field {
         name = "reset of the masterFIP core";
         description = "write 0: masterFIP core is held in reset\
                        write 1: normal core operation";
         type=BIT;
		 --type = PASS_THROUGH;
         --size = 1;
         prefix = "core";	
      };
	  
      field {
         name = "reset of the fieldrive chip (FD_RSTN)";
         description = "write 0: fieldrive is held in reset\
                        write 1: normal fieldrive operation";
         type=BIT;
		 --type = PASS_THROUGH;
         --size = 1;
         prefix = "fd";	
      };	  

      field {
         name = "reset magic value";
         description = "Protection field - the state of the rst line will\
                        only be updated if lock is written with 0xcafe together with the new state of the reset line.";
         type = PASS_THROUGH;
         prefix = "lock";
         align = 16;
         size = 16;
      };
   };


-------------------------------------------------------------------------------
--                              identification                               --
-------------------------------------------------------------------------------
   reg {
      name = "id";
      description = "an identification value";
      prefix = "id";

      field {
         name = "an id value";
         description = "equal to <code>0xc000ffee</code> for the moment";
         size = 32;
         type = CONSTANT;
         value = 0xc000ffee;
      };
   };


-------------------------------------------------------------------------------
--                                 debugging                                 --
-------------------------------------------------------------------------------   
   reg {
      name = "dbg";
      description = "for debugging purpuses";
      prefix = "dbg";

      field {
         name = "debugging";
         size = 32;
         type = SLV;
         access_bus = READ_WRITE;
         access_dev = READ_ONLY;
      };
   };
   
-------------------------------------------------------------------------------
--                               ADC power supplies                          --
-------------------------------------------------------------------------------
  reg {
    name = "adc";
    prefix = "adc";
	
    field {
      name = "1v8_shdn_n";
      prefix = "1v8_shdn_n";
	  description = "write 0: enable the adc_1v8_shdn_n_o\
                     write 1: disable the adc_1v8_shdn_n_o";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
	
    field {
      name = "m5v_shdn_n";
      prefix = "m5v_shdn_n";
	  description = "write 0: enable the adc_m5v_shdn_n_o\
                     write 1: disable the adc_m5v_shdn_n_o";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
	
	field {
      name = "5v_en_n";
      prefix = "5v_en_n";
	  description = "write 0: enable the adc_5v_en_n_o\
                     write 1: disable the adc_5v_en_n_o";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
	
	field {
      name = "prim_conn_n";
      prefix = "prim_conn_n";
	  description = "write 0: enable the prim_conn_n\
                     write 1: disable the prim_conn_n";
      type = BIT;
	  align = 8;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
	
	field {
      name = "sec_conn_n";
      prefix = "sec_conn_n";
	  description = "write 0: enable the sec_conn_n\
                     write 1: disable the sec_conn_n";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
	
  };

	
-------------------------------------------------------------------------------
--                               external synch                              --
-------------------------------------------------------------------------------
  reg {
    name = "ext sync";
    prefix = "ext_sync";
	
    field {
      name = "termination enable";
      prefix = "term_en";
	  description = "write 0: disable 50ohms termination of the external sync pulse\
                     write 1: enable  50ohms termination of the external sync pulse";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
	
    field {
      name = "tranceiver direction";
      prefix = "dir";
	  description = "write 0: normal operation\
                     write 1: test mode where a pulse from the FPGA can be output to the front panel LEMO connector";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
	
    field {
      name = "tranceiver output enable";
      prefix = "oe";
	  description = "write 0: the external sync pulse arrives to the FPGA\
                     write 1: the external sync pulse does not arrive to the FPGA";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };

    field {
      name = "test pulse";
      prefix = "tst_n";
	  description = "emulate a pulse";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
	
    field {
      name = "pulses counter reset";
      prefix = "p_cnt_rst";
	  description = "resets the pulses counter";
      type = BIT;
	  align = 8;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };		
  };

  reg {
    name = "ext sync pulses cnt";
    prefix = "ext_sync_p_cnt";
	
    field {
      name = "ext_sync_p_cnt";
      description = "number of ext sync pulses";
      type = SLV;
      size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };		
  };  
  
-------------------------------------------------------------------------------
--                              bus termination                              --
-------------------------------------------------------------------------------
  reg {
    name = "bus termination";
    prefix = "bus_term_en_n";
	
    field {
      name = "150ohms terination of the bus";
      description = "write 0: enable  150ohms termination on the bus\
	                 write 1: disable 150ohms termination on the bus";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
};


-------------------------------------------------------------------------------
--                    speed configuration from the board                     --
-------------------------------------------------------------------------------
  reg {
    name = "speed";
    prefix = "speed";

    field {
      name = "speed";
      description = "WorldFIP speed: 00: 31.25Kbps | 01: 1Mbps | 10: 2.5 Mbps | 11: 5 Mbps";
      type = SLV;
      size = 2;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
};


-------------------------------------------------------------------------------
--                                   counters                                --
-------------------------------------------------------------------------------
  reg {
    name = "macrocycle lgth";
    prefix = "macrocyc";
	
    field {
      name = "macrocycle lgth";
      description = "duration of the macrocycle in number of 25ns-clk-ticks";
	  prefix = "lgth";
      type = SLV;
      size = 31;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
    field {
      name = "macrocycle cnt start";
      description = "initiates the counting of the macrocycle counter";
	  prefix = "start";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };		
  };

  reg {
    name = "turnaround lgth";
    prefix = "turnar";
	
    field {
      name = "turnaround time";
      description = "turnaround time (i.e. time between two frames sent by the masterFIP) in number of 25ns-clk-ticks";
	  prefix = "lgth";
      type = SLV;
      size = 31;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
    field {
      name = "turnaround cnt start";
      description = "initiates the counting of the turnaround counter";
	  prefix = "start";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
  };

  reg {
    name = "silence lgth";
    prefix = "silen";
	
    field {
      name = "silence time";
      description = "silence time (i.e. time that the masterFIP waits for a response frame) number of 25ns-clk-ticks";
	  prefix = "lgth";
      type = SLV;
      size = 31;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
    field {
      name = "silence cnt start";
      description = "initiates the counting of the silence counter";
	  prefix = "start";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };	
  };

  
  reg {
    name = "macrocycle time cnt";
    prefix = "macrocyc_time_cnt";
	
    field {
      name = "macrocycle time counter";
      description = "current value of the macrocycle time counter";
      type = SLV;
      size = 31;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
  };

  reg {
    name = "macrocycles number cnt";
    prefix = "macrocyc_num_cnt";
	
    field {
      name = "number of macrocycles";
      description = "current amount of macrocycles";
      type = SLV;
      size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
  };
  
  
  reg {
    name = "turnaround time cnt";
    prefix = "turnar_time_cnt";
	
    field {
      name = "turnaround time counter";
      description = "current value of the turnaround time counter";
      type = SLV;
      size = 31;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };		
  };

  reg {
    name = "silence time cnt";
    prefix = "silen_time_cnt";
	
    field {
      name = "silence time counter";
      description = "current value of the silence time counter";
      type = SLV;
      size = 31;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };		
  };  
  

-------------------------------------------------------------------------------
--                              serializer ctrl                              --
-------------------------------------------------------------------------------
  reg {
    name = "tx ctrl";
    prefix = "tx_ctrl";

    field {
      name = "tx rst";
      description = "write 0: normal serializer operation\
                     write 1: serializer is held in reset";
      prefix = "rst";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };

    field {
      name = "tx strt";
      description = "initiates the serializer to send a frame";
      prefix = "start";
	  type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };

    field {
      name = "tx number of bytes";
      description = "number of bytes to serialize; sampled upon the strt";
      prefix = "bytes_num";
      type = SLV;
	  size = 9; -- max WorldFIP frame size = 263 bytes (without preamble, crc, postamble)
	  align = 8;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };		
  };

  
-------------------------------------------------------------------------------
--                              serializer stat                              --
-------------------------------------------------------------------------------  
  reg {
    name = "tx status";
    prefix = "tx_stat";
  
	field {
      name = "tx ended";
      description = "indication that the serializer finished the delivery of a frame";
      prefix = "stop";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
	
	field {
      name = "tx current byte";
      description = "index of the byte currently being serialized";
      prefix = "byte_index";
      type = SLV;
	  size = 9; -- max WorldFIP frame size = 263 bytes (without preamble, crc, postamble)
	  align = 8;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
	
	field {
      name = "tx enable";
      description = "fieldrive fd_txena signal; serializer is active putting bits to the bus";
      prefix = "ena";
      type = BIT;
	  align = 8;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
  };

  
-------------------------------------------------------------------------------
--                         fieldrive status signals                          --
-------------------------------------------------------------------------------
  reg {
    name = "fieldrive status";
    prefix = "fd";
	
    field {
      name = "fd watchdog";
      description = "fd_wdgn input from the fieldrive chip";
      prefix = "wdgn";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
    field {
      name = "fd transmitter error";
      description = "fd_txer input from the fieldrive chip";
      prefix = "txer";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
	};
  
-------------------------------------------------------------------------------
--                            deserializer ctrl                              --
-------------------------------------------------------------------------------  
  reg {
    name = "rx ctrl";
    prefix = "rx_ctrl";
	description = "active high reset of the deserializer";

    field {
      name = "rx rst";
	  description = "write 0: normal deserializer operation\
                     write 1: deserializer is held in reset";

	  prefix = "rst";
      type = BIT;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  

-------------------------------------------------------------------------------
--                            deserializer stat                              --
-------------------------------------------------------------------------------
  reg {
    name = "rx status";
    prefix = "rx_stat";
	
    field {
      name = "rx preamble detected";
      description = "indication that the deserializer has detected a preamble";
      prefix = "pream_ok";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
	
	field {
      name = "rx frame ok";
      description = "indication that the deserializer has finished with the reception of a complete frame; the preamble, crc and postambe of the frame are all ok";
      prefix = "frame_ok";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };	
	
	field {
      name = "rx frame error";
      description = "indication that the deserializer has detected an erroneous frame; the crc or frame size of the frame are wrong; the err_code reg defines the error";
      prefix = "frame_err";
      type = BIT;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };		

	field {
      name = "rx frame error code";
      description = "001: wrong crc | 010: unexpected frame size"; -- more to be added
      prefix = "frame_err_code";
      type = SLV;
	  size = 3;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };

    field {
      name = "rx number of data bytes";
      description = "number of bytes that have been received by the deserializer";
      prefix = "bytes_num";
      type = SLV;
	  size = 9; -- max WorldFIP frame size = 263 bytes (without preamble, crc, postamble)
	  align = 8;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
	};	

-------------------------------------------------------------------------------
--                               rx data bytes                               --
-------------------------------------------------------------------------------  

  reg {
    name = "rx data ctrl byte";
    prefix = "rx_data_ctrl";
	description = "contains the 8-bits of the control field of a received frame";

    field {
      name = "rx data ctrl byte";
	  description = "contains the 8-bits of the control field of a received frame";
      type = SLV;
 	  size = 8;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg1";
    prefix = "rx_data_reg1";
	description = "32 bits of the received frame";

    field {
      name = "reg 1";
	  description = "1st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg2";
    prefix = "rx_data_reg2";
	description = "32 bits of the received frame";

    field {
      name = "reg2";
	  description = "2nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
 
  reg {
    name = "rx data reg3";
    prefix = "rx_data_reg3";
	description = "32 bits of the received frame";

    field {
      name = "reg3";
	  description = "3rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg4";
    prefix = "rx_data_reg4";
	description = "32 bits of the received frame";

    field {
      name = "reg4";
	  description = "4th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg5";
    prefix = "rx_data_reg5";
	description = "32 bits of the received frame";

    field {
      name = "reg5";
	  description = "5th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg6";
    prefix = "rx_data_reg6";
	description = "32 bits of the received frame";

    field {
      name = "reg6";
	  description = "6th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg7";
    prefix = "rx_data_reg7";
	description = "32 bits of the received frame";

    field {
      name = "reg7";
	  description = "7th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg8";
    prefix = "rx_data_reg8";
	description = "32 bits of the received frame";

    field {
      name = "reg8";
	  description = "8th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg9";
    prefix = "rx_data_reg9";
	description = "32 bits of the received frame";

    field {
      name = "reg9";
	  description = "9th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  

  reg {
    name = "rx data reg10";
    prefix = "rx_data_reg10";
	description = "32 bits of the received frame";

    field {
      name = "reg10";
	  description = "10th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg11";
    prefix = "rx_data_reg11";
	description = "32 bits of the received frame";

    field {
      name = "reg11";
	  description = "11th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  

  reg {
    name = "rx data reg12";
    prefix = "rx_data_reg12";
	description = "32 bits of the received frame";

    field {
      name = "reg12";
	  description = "12th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg13";
    prefix = "rx_data_reg13";
	description = "32 bits of the received frame";

    field {
      name = "reg13";
	  description = "13th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg14";
    prefix = "rx_data_reg14";
	description = "32 bits of the received frame";

    field {
      name = "reg14";
	  description = "14th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  

  reg {
    name = "rx data reg15";
    prefix = "rx_data_reg15";
	description = "32 bits of the received frame";

    field {
      name = "reg15";
	  description = "15th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg16";
    prefix = "rx_data_reg16";
	description = "32 bits of the received frame";

    field {
      name = "reg16";
	  description = "16th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg17";
    prefix = "rx_data_reg17";
	description = "32 bits of the received frame";

    field {
      name = "reg17";
	  description = "17th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg18";
    prefix = "rx_data_reg18";
	description = "32 bits of the received frame";

    field {
      name = "reg18";
	  description = "18th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg19";
    prefix = "rx_data_reg19";
	description = "32 bits of the received frame";

    field {
      name = "reg19";
	  description = "19th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg20";
    prefix = "rx_data_reg20";
	description = "32 bits of the received frame";

    field {
      name = "reg20";
	  description = "20th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg21";
    prefix = "rx_data_reg21";
	description = "32 bits of the received frame";

    field {
      name = "reg21";
	  description = "21th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg22";
    prefix = "rx_data_reg22";
	description = "32 bits of the received frame";

    field {
      name = "reg22";
	  description = "22th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg23";
    prefix = "rx_data_reg23";
	description = "32 bits of the received frame";

    field {
      name = "reg23";
	  description = "23th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  
  
  reg {
    name = "rx data reg24";
    prefix = "rx_data_reg24";
	description = "32 bits of the received frame";

    field {
      name = "reg24";
	  description = "24th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  
 
  reg {
    name = "rx data reg25";
    prefix = "rx_data_reg25";
	description = "32 bits of the received frame";

    field {
      name = "reg25";
	  description = "25th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg26";
    prefix = "rx_data_reg26";
	description = "32 bits of the received frame";

    field {
      name = "reg26";
	  description = "26th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 
  
  reg {
    name = "rx data reg27";
    prefix = "rx_data_reg27";
	description = "32 bits of the received frame";

    field {
      name = "reg27";
	  description = "27th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg28";
    prefix = "rx_data_reg28";
	description = "32 bits of the received frame";

    field {
      name = "reg28";
	  description = "28th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg29";
    prefix = "rx_data_reg29";
	description = "32 bits of the received frame";

    field {
      name = "reg29";
	  description = "29th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg30";
    prefix = "rx_data_reg30";
	description = "32 bits of the received frame";

    field {
      name = "reg30";
	  description = "30th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg31";
    prefix = "rx_data_reg31";
	description = "32 bits of the received frame";

    field {
      name = "reg31";
	  description = "31th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 
  
  reg {
    name = "rx data reg32";
    prefix = "rx_data_reg32";
	description = "32 bits of the received frame";

    field {
      name = "reg32";
	  description = "32th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg33";
    prefix = "rx_data_reg33";
	description = "32 bits of the received frame";

    field {
      name = "reg 33";
	  description = "33rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg34";
    prefix = "rx_data_reg34";
	description = "32 bits of the received frame";

    field {
      name = "reg34";
	  description = "34th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
 
  reg {
    name = "rx data reg35";
    prefix = "rx_data_reg35";
	description = "32 bits of the received frame";

    field {
      name = "reg35";
	  description = "35th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg36";
    prefix = "rx_data_reg36";
	description = "32 bits of the received frame";

    field {
      name = "reg36";
	  description = "36th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg37";
    prefix = "rx_data_reg37";
	description = "32 bits of the received frame";

    field {
      name = "reg37";
	  description = "37th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg38";
    prefix = "rx_data_reg38";
	description = "32 bits of the received frame";

    field {
      name = "reg38";
	  description = "38th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg39";
    prefix = "rx_data_reg39";
	description = "32 bits of the received frame";

    field {
      name = "reg39";
	  description = "39th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg40";
    prefix = "rx_data_reg40";
	description = "32 bits of the received frame";

    field {
      name = "reg40";
	  description = "40th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg41";
    prefix = "rx_data_reg41";
	description = "32 bits of the received frame";

    field {
      name = "reg41";
	  description = "41th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  

  reg {
    name = "rx data reg42";
    prefix = "rx_data_reg42";
	description = "32 bits of the received frame";

    field {
      name = "reg42";
	  description = "42nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg43";
    prefix = "rx_data_reg43";
	description = "32 bits of the received frame";

    field {
      name = "reg43";
	  description = "43rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  

  reg {
    name = "rx data reg44";
    prefix = "rx_data_reg44";
	description = "32 bits of the received frame";

    field {
      name = "reg44";
	  description = "44th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 
  
  reg {
    name = "rx data reg45";
    prefix = "rx_data_reg45";
	description = "32 bits of the received frame";

    field {
      name = "reg45";
	  description = "45th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  
  
  reg {
    name = "rx data reg46";
    prefix = "rx_data_reg46";
	description = "32 bits of the received frame";

    field {
      name = "reg46";
	  description = "46th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  

  reg {
    name = "rx data reg47";
    prefix = "rx_data_reg47";
	description = "32 bits of the received frame";

    field {
      name = "reg47";
	  description = "47th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg48";
    prefix = "rx_data_reg48";
	description = "32 bits of the received frame";

    field {
      name = "reg48";
	  description = "48th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  
  
  reg {
    name = "rx data reg49";
    prefix = "rx_data_reg49";
	description = "32 bits of the received frame";

    field {
      name = "reg49";
	  description = "49th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  
  
  reg {
    name = "rx data reg50";
    prefix = "rx_data_reg50";
	description = "32 bits of the received frame";

    field {
      name = "reg50";
	  description = "50th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  
  
  reg {
    name = "rx data reg51";
    prefix = "rx_data_reg51";
	description = "32 bits of the received frame";

    field {
      name = "reg51";
	  description = "51st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	
  
  reg {
    name = "rx data reg52";
    prefix = "rx_data_reg52";
	description = "32 bits of the received frame";

    field {
      name = "reg52";
	  description = "52nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg53";
    prefix = "rx_data_reg53";
	description = "32 bits of the received frame";

    field {
      name = "reg53";
	  description = "53rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg54";
    prefix = "rx_data_reg54";
	description = "32 bits of the received frame";

    field {
      name = "reg54";
	  description = "54th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	

  reg {
    name = "rx data reg55";
    prefix = "rx_data_reg55";
	description = "32 bits of the received frame";

    field {
      name = "reg55";
	  description = "55th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  
  
  reg {
    name = "rx data reg56";
    prefix = "rx_data_reg56";
	description = "32 bits of the received frame";

    field {
      name = "reg56";
	  description = "56th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };  	  
 
  reg {
    name = "rx data reg57";
    prefix = "rx_data_reg57";
	description = "32 bits of the received frame";

    field {
      name = "reg57";
	  description = "57th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg58";
    prefix = "rx_data_reg58";
	description = "32 bits of the received frame";

    field {
      name = "reg58";
	  description = "58th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 
  
  reg {
    name = "rx data reg59";
    prefix = "rx_data_reg59";
	description = "32 bits of the received frame";

    field {
      name = "reg59";
	  description = "59th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg60";
    prefix = "rx_data_reg60";
	description = "32 bits of the received frame";

    field {
      name = "reg60";
	  description = "60th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg61";
    prefix = "rx_data_reg61";
	description = "32 bits of the received frame";

    field {
      name = "reg61";
	  description = "61st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg62";
    prefix = "rx_data_reg62";
	description = "32 bits of the received frame";

    field {
      name = "reg62";
	  description = "62nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg63";
    prefix = "rx_data_reg63";
	description = "32 bits of the received frame";

    field {
      name = "reg63";
	  description = "63rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 
  
  reg {
    name = "rx data reg64";
    prefix = "rx_data_reg64";
	description = "32 bits of the received frame";

    field {
      name = "reg64";
	  description = "64th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };

  reg {
    name = "rx data reg65";
    prefix = "rx_data_reg65";
	description = "32 bits of the received frame";

    field {
      name = "reg65";
	  description = "65th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  }; 

  reg {
    name = "rx data reg66";
    prefix = "rx_data_reg66";
	description = "32 bits of the received frame";

    field {
      name = "reg66";
	  description = "66th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_ONLY;
      access_dev = WRITE_ONLY;
    };
  };   
  

-------------------------------------------------------------------------------
--                                  tx data                                  --
-------------------------------------------------------------------------------  

  reg {
    name = "tx ctrl byte";
    prefix = "tx_data_ctrl";
	description = "contains the 8-bits of the control field of a frame to transmit";

    field {
      name = "tx ctrl byte";
	  description = "contains the 8-bits of the control field of a frame to transmit";
      type = SLV;
 	  size = 8;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg1";
    prefix = "tx_data_reg1";
	description = "32 bits of the received frame";

    field {
      name = "reg1";
	  description = "1st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg2";
    prefix = "tx_data_reg2";
	description = "32 bits of the received frame";

    field {
      name = "reg2";
	  description = "2nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
 
  reg {
    name = "tx data reg3";
    prefix = "tx_data_reg3";
	description = "32 bits of the received frame";

    field {
      name = "reg3";
	  description = "3rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg4";
    prefix = "tx_data_reg4";
	description = "32 bits of the received frame";

    field {
      name = "reg4";
	  description = "4th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg5";
    prefix = "tx_data_reg5";
	description = "32 bits of the received frame";

    field {
      name = "reg5";
	  description = "5th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg6";
    prefix = "tx_data_reg6";
	description = "32 bits of the received frame";

    field {
      name = "reg6";
	  description = "6th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg7";
    prefix = "tx_data_reg7";
	description = "32 bits of the received frame";

    field {
      name = "reg7";
	  description = "7th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg8";
    prefix = "tx_data_reg8";
	description = "32 bits of the received frame";

    field {
      name = "reg8";
	  description = "8th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg9";
    prefix = "tx_data_reg9";
	description = "32 bits of the received frame";

    field {
      name = "reg9";
	  description = "9th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  

  reg {
    name = "tx data reg10";
    prefix = "tx_data_reg10";
	description = "32 bits of the received frame";

    field {
      name = "reg10";
	  description = "10th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg11";
    prefix = "tx_data_reg11";
	description = "32 bits of the received frame";

    field {
      name = "reg11";
	  description = "11th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  

  reg {
    name = "tx data reg12";
    prefix = "tx_data_reg12";
	description = "32 bits of the received frame";

    field {
      name = "reg12";
	  description = "12th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  reg {
    name = "tx data reg13";
    prefix = "tx_data_reg13";
	description = "32 bits of the received frame";

    field {
      name = "reg13";
	  description = "13th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  reg {
    name = "tx data reg14";
    prefix = "tx_data_reg14";
	description = "32 bits of the received frame";

    field {
      name = "reg14";
	  description = "14th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  

  reg {
    name = "tx data reg15";
    prefix = "tx_data_reg15";
	description = "32 bits of the received frame";

    field {
      name = "reg15";
	  description = "15th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg16";
    prefix = "tx_data_reg16";
	description = "32 bits of the received frame";

    field {
      name = "reg16";
	  description = "16th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg17";
    prefix = "tx_data_reg17";
	description = "32 bits of the received frame";

    field {
      name = "reg17";
	  description = "17th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };
  
  reg {
    name = "tx data reg18";
    prefix = "tx_data_reg18";
	description = "32 bits of the received frame";

    field {
      name = "reg18";
	  description = "18th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };
  
  reg {
    name = "tx data reg19";
    prefix = "tx_data_reg19";
	description = "32 bits of the received frame";

    field {
      name = "reg19";
	  description = "19th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  
  
  reg {
    name = "tx data reg20";
    prefix = "tx_data_reg20";
	description = "32 bits of the received frame";

    field {
      name = "reg20";
	  description = "20th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg21";
    prefix = "tx_data_reg21";
	description = "32 bits of the received frame";

    field {
      name = "reg21";
	  description = "21th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg22";
    prefix = "tx_data_reg22";
	description = "32 bits of the received frame";

    field {
      name = "reg22";
	  description = "22th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg23";
    prefix = "tx_data_reg23";
	description = "32 bits of the received frame";

    field {
      name = "reg23";
	  description = "23th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  
  
  reg {
    name = "tx data reg24";
    prefix = "tx_data_reg24";
	description = "32 bits of the received frame";

    field {
      name = "reg24";
	  description = "24th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  
 
  reg {
    name = "tx data reg25";
    prefix = "tx_data_reg25";
	description = "32 bits of the received frame";

    field {
      name = "reg25";
	  description = "25th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg26";
    prefix = "tx_data_reg26";
	description = "32 bits of the received frame";

    field {
      name = "reg26";
	  description = "26th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  reg {
    name = "tx data reg27";
    prefix = "tx_data_reg27";
	description = "32 bits of the received frame";

    field {
      name = "reg27";
	  description = "27th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg28";
    prefix = "tx_data_reg28";
	description = "32 bits of the received frame";

    field {
      name = "reg28";
	  description = "28th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg29";
    prefix = "tx_data_reg29";
	description = "32 bits of the received frame";

    field {
      name = "reg29";
	  description = "29th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg30";
    prefix = "tx_data_reg30";
	description = "32 bits of the received frame";

    field {
      name = "reg30";
	  description = "30th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg31";
    prefix = "tx_data_reg31";
	description = "32 bits of the received frame";

    field {
      name = "reg31";
	  description = "31th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  reg {
    name = "tx data reg32";
    prefix = "tx_data_reg32";
	description = "32 bits of the received frame";

    field {
      name = "reg32";
	  description = "32th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  
  reg {
    name = "tx data reg33";
    prefix = "tx_data_reg33";
	description = "32 bits of the received frame";

    field {
      name = "reg 33";
	  description = "33rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg34";
    prefix = "tx_data_reg34";
	description = "32 bits of the received frame";

    field {
      name = "reg34";
	  description = "34th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
 
  reg {
    name = "tx data reg35";
    prefix = "tx_data_reg35";
	description = "32 bits of the received frame";

    field {
      name = "reg35";
	  description = "35th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg36";
    prefix = "tx_data_reg36";
	description = "32 bits of the received frame";

    field {
      name = "reg36";
	  description = "36th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg37";
    prefix = "tx_data_reg37";
	description = "32 bits of the received frame";

    field {
      name = "reg37";
	  description = "37th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg38";
    prefix = "tx_data_reg38";
	description = "32 bits of the received frame";

    field {
      name = "reg38";
	  description = "38th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg39";
    prefix = "tx_data_reg39";
	description = "32 bits of the received frame";

    field {
      name = "reg39";
	  description = "39th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg40";
    prefix = "tx_data_reg40";
	description = "32 bits of the received frame";

    field {
      name = "reg40";
	  description = "40th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg41";
    prefix = "tx_data_reg41";
	description = "32 bits of the received frame";

    field {
      name = "reg41";
	  description = "41th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  

  reg {
    name = "tx data reg42";
    prefix = "tx_data_reg42";
	description = "32 bits of the received frame";

    field {
      name = "reg42";
	  description = "42nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg43";
    prefix = "tx_data_reg43";
	description = "32 bits of the received frame";

    field {
      name = "reg43";
	  description = "43rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  

  reg {
    name = "tx data reg44";
    prefix = "tx_data_reg44";
	description = "32 bits of the received frame";

    field {
      name = "reg44";
	  description = "44th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  
  reg {
    name = "tx data reg45";
    prefix = "tx_data_reg45";
	description = "32 bits of the received frame";

    field {
      name = "reg45";
	  description = "45th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  
  
  reg {
    name = "tx data reg46";
    prefix = "tx_data_reg46";
	description = "32 bits of the received frame";

    field {
      name = "reg46";
	  description = "46th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  

  reg {
    name = "tx data reg47";
    prefix = "tx_data_reg47";
	description = "32 bits of the received frame";

    field {
      name = "reg47";
	  description = "47th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg48";
    prefix = "tx_data_reg48";
	description = "32 bits of the received frame";

    field {
      name = "reg48";
	  description = "48th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  
  
  reg {
    name = "tx data reg49";
    prefix = "tx_data_reg49";
	description = "32 bits of the received frame";

    field {
      name = "reg49";
	  description = "49th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  
  
  reg {
    name = "tx data reg50";
    prefix = "tx_data_reg50";
	description = "32 bits of the received frame";

    field {
      name = "reg50";
	  description = "50th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  
  
  reg {
    name = "tx data reg51";
    prefix = "tx_data_reg51";
	description = "32 bits of the received frame";

    field {
      name = "reg51";
	  description = "51st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	
  
  reg {
    name = "tx data reg52";
    prefix = "tx_data_reg52";
	description = "32 bits of the received frame";

    field {
      name = "reg52";
	  description = "52nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg53";
    prefix = "tx_data_reg53";
	description = "32 bits of the received frame";

    field {
      name = "reg53";
	  description = "53rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg54";
    prefix = "tx_data_reg54";
	description = "32 bits of the received frame";

    field {
      name = "reg54";
	  description = "54th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	

  reg {
    name = "tx data reg55";
    prefix = "tx_data_reg55";
	description = "32 bits of the received frame";

    field {
      name = "reg55";
	  description = "55th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  
  
  reg {
    name = "tx data reg56";
    prefix = "tx_data_reg56";
	description = "32 bits of the received frame";

    field {
      name = "reg56";
	  description = "56th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };  	  
 
  reg {
    name = "tx data reg57";
    prefix = "tx_data_reg57";
	description = "32 bits of the received frame";

    field {
      name = "reg57";
	  description = "57th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg58";
    prefix = "tx_data_reg58";
	description = "32 bits of the received frame";

    field {
      name = "reg58";
	  description = "58th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  
  reg {
    name = "tx data reg59";
    prefix = "tx_data_reg59";
	description = "32 bits of the received frame";

    field {
      name = "reg59";
	  description = "59th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg60";
    prefix = "tx_data_reg60";
	description = "32 bits of the received frame";

    field {
      name = "reg60";
	  description = "60th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg61";
    prefix = "tx_data_reg61";
	description = "32 bits of the received frame";

    field {
      name = "reg61";
	  description = "61st 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg62";
    prefix = "tx_data_reg62";
	description = "32 bits of the received frame";

    field {
      name = "reg62";
	  description = "62nd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg63";
    prefix = "tx_data_reg63";
	description = "32 bits of the received frame";

    field {
      name = "reg63";
	  description = "63rd 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 
  
  reg {
    name = "tx data reg64";
    prefix = "tx_data_reg64";
	description = "32 bits of the received frame";

    field {
      name = "reg64";
	  description = "64th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };

  reg {
    name = "tx data reg65";
    prefix = "tx_data_reg65";
	description = "32 bits of the received frame";

    field {
      name = "reg65";
	  description = "65th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  }; 

  reg {
    name = "tx data reg66";
    prefix = "tx_data_reg66";
	description = "32 bits of the received frame";

    field {
      name = "reg66";
	  description = "66th 32-bit word";
      type = SLV;
 	  size = 32;
      access_bus = READ_WRITE;
      access_dev = READ_ONLY;
    };
  };   
  
};