diff --git a/cmds/config_file/lab_testbed.json b/cmds/config_file/lab_testbed.json
new file mode 100644
index 0000000000000000000000000000000000000000..0060d7055e4f82f7bd584ca73a08b48f4e6361c7
--- /dev/null
+++ b/cmds/config_file/lab_testbed.json
@@ -0,0 +1,46 @@
+{
+ "deployment" : "Lab testbed setup at B02",
+ "version" : "1.0.0",
+ "notes" : "Testbed setup",
+ "topology": {
+ "0": {
+ "frontend" : "vmm_multiblade",
+ "nodes" : 1
+ },
+ "2": {
+ "frontend" : "ac701_testbed",
+ "nodes" : 1
+ }
+ },
+ "output_queues" : {
+ "default" : {
+ "enabled" : false,
+ "eth_src_mac" : "0e:05:05:00:00:04",
+ "eth_dst_mac" : "50:6b:4b:c0:b2:50",
+ "ip_src_addr" : "192.168.10.10",
+ "ip_dst_addr" : "192.168.10.100",
+ "udp_src_port" : 8997,
+ "udp_dst_port" : 9000,
+ "readout_type" : "0x48",
+ "pkt_gen_enable" : false,
+ "pkt_gen_idles" : "0x00000f",
+ "pkt_gen_length" : "0x000000ff"
+ },
+ "0": {
+ "enabled" : true,
+ "udp_dst_port" : 9000
+ },
+ "1": {
+ "enabled" : false,
+ "udp_dst_port" : 9001
+ },
+ "2": {
+ "enabled" : false,
+ "udp_dst_port" : 9002
+ },
+ "3": {
+ "enabled" : false,
+ "udp_dst_port" : 9003
+ }
+ }
+}
\ No newline at end of file
diff --git a/cmds/st.cmd b/cmds/st.cmd
new file mode 100644
index 0000000000000000000000000000000000000000..f6ccfa7ae796298c5c61f05672b3743ec7148f20
--- /dev/null
+++ b/cmds/st.cmd
@@ -0,0 +1,37 @@
+require vmmTbl
+
+epicsEnvSet("IPADDR", "192.168.50.2")
+epicsEnvSet("IPPORT", "65535")
+epicsEnvSet("P", "LAB:")
+epicsEnvSet("R", "NDet-RMM-001:")
+
+drvAsynIPPortConfigure("L0", "$(IPADDR):$(IPPORT) UDP", 0, 0, 1)
+
+#asynSetTraceMask( L0, -1, 0x9)
+#asynSetTraceIOMask( L0, -1, 0x4)
+#asynSetTraceInfoMask ( L0, -1, 0x9)
+
+RMMConfig("RMM", "L0", "/home/iocuser/douglas/fe-vmm-tbl/cmds/config_file/lab_testbed.json" 0)
+VMMTblConfig("RMM", 0, 0)
+
+dbLoadRecords("${asyn_DIR}/db/asynRecord.db","P=asyn:,R=Test,PORT=L0,ADDR=0,IMAX=0,OMAX=0")
+dbLoadRecords($(rmm_DB)/rmm.db, "P=$(P), R=$(R), PORT=RMM, ADDR=0, TIMEOUT=1")
+dbLoadRecords($(rmm_DB)/rmm_sensors.db, "P=$(P), R=$(R), PORT=RMM, TIMEOUT=1")
+dbLoadRecords($(rmm_DB)/topology.db, "P=$(P), R=$(R), PORT=RMM, TIMEOUT=1")
+
+dbLoadRecords("$(rmm_DB)/rmm_packets.template", "P=$(P), R=$(R), PORT=RMM, RING=0, NODE=0, ADDR=0, TIMEOUT=1")
+
+dbLoadRecords("$(vmmTbl_DB)/vmm_tbl.db", "P=$(P), R=NDet-VMM-001:, PORT=RMM, RING=0, NODE=0, ADDR=0, TIMEOUT=1")
+
+iocInit()
+
+dbpf $(P)$(R)Temperature-R.SCAN 2
+#dbpf $(P)$(R)ProcessPktCount-S.SCAN 2
+dbpf $(P)$(R)VoltVCCINT-R.SCAN 2
+dbpf $(P)$(R)VoltVCC1V8-R.SCAN 2
+dbpf $(P)$(R)VoltVADJ1V8-R.SCAN 2
+dbpf $(P)$(R)VoltVCC1V2-R.SCAN 2
+dbpf $(P)$(R)VoltMGTAVCC-R.SCAN 2
+dbpf $(P)$(R)VoltMGTAVTT-R.SCAN 2
+dbpf $(P)$(R)VoltVCCINTIOBRAM-R.SCAN 2
+#
\ No newline at end of file
diff --git a/vmmTblApp/Db/vmm_tbl.template b/vmmTblApp/Db/vmm_tbl.template
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..26af164409de408eac247592aefa274c0e410f28 100644
--- a/vmmTblApp/Db/vmm_tbl.template
+++ b/vmmTblApp/Db/vmm_tbl.template
@@ -0,0 +1,58 @@
+record(mbbo, "$(P)$(R)AnalogMon-VMM0-S") {
+ field(DESC, "Select analog monitor (sm)")
+ field(ZRST, "Pulser DAC [mV]")
+ field(ZRVL, "0")
+ field(ONST, "Threshold DAC [mV]")
+ field(ONVL, "1")
+ field(TWST, "Bandgap ref [mV]")
+ field(TWVL, "2")
+ field(THST, "Temperature [degC]")
+ field(THVL, "3")
+ field(DTYP, "asynInt32")
+ field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SEL_ANALOG_MONITOR_VMM0")
+}
+
+record(mbbo, "$(P)$(R)AnalogMon-VMM1-S") {
+ field(DESC, "Select analog monitor (sm)")
+ field(ZRST, "Pulser DAC [mV]")
+ field(ZRVL, "0")
+ field(ONST, "Threshold DAC [mV]")
+ field(ONVL, "1")
+ field(TWST, "Bandgap ref [mV]")
+ field(TWVL, "2")
+ field(THST, "Temperature [degC]")
+ field(THVL, "3")
+ field(DTYP, "asynInt32")
+ field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SEL_ANALOG_MONITOR_VMM1")
+}
+
+record(bo, "$(P)$(R)ReadADC-VMMs-S") {
+ field(DESC, "Input signal")
+ field(VAL, "0")
+ field(DTYP, "asynInt32")
+ field(HIGH, "0.1")
+ field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))READ_ADC_VMMS")
+}
+
+record(ai, "$(P)$(R)MonValue-VMM0-RB") {
+ field(DESC, "Monitor Value Read")
+ field(DTYP, "asynFloat64")
+ field(SCAN, "I/O Intr")
+ field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADC_VALUE_VMM0")
+}
+
+record(ai, "$(P)$(R)MonValue-VMM1-RB") {
+ field(DESC, "Monitor Value Read")
+ field(DTYP, "asynFloat64")
+ field(SCAN, "I/O Intr")
+ field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADC_VALUE_VMM1")
+}
+
+record(bo, "$(P)$(R)Acquire-S") {
+ field(DESC, "Start/stop FEN acquisition")
+ field(VAL, "0")
+ field(ZNAM, "Done")
+ field(ONAM, "Acquire")
+ field(DTYP, "asynInt32")
+ field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))VMM_FEN_ACQUIRE")
+}
diff --git a/vmmTblApp/src/hybrid.cpp b/vmmTblApp/src/hybrid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5397c35510baef63763d908853632b7622493d9f
--- /dev/null
+++ b/vmmTblApp/src/hybrid.cpp
@@ -0,0 +1,27 @@
+#include "hybrid.h"
+
+Hybrid::Hybrid() {
+ loadDefault();
+}
+
+Hybrid::~Hybrid() {}
+
+void Hybrid::loadDefault(){
+ hybrid_registers = {{"TP_skew", 0}, {"TP_width", 0}, {"TP_pol", 0}};
+ hybrid_info = {{"firmware_version", ""}, {"geo_id", ""}, {"hybrid_id", ""},{"link_status", "0"}, {"description", ""}};
+}
+
+VMM3a& Hybrid::getVMM(int index) {
+ if (index < 0 || index >= VMMS_PER_HYBRID)
+ throw std::out_of_range("Invalid VMM index");
+ return vmms[index];
+}
+
+vmmStatus Hybrid::getRegister(std::string feature, unsigned short& result) {
+ vmmStatus status = vmmSuccess;
+ if(hybrid_registers.find(feature) != hybrid_registers.end())
+ result = hybrid_registers[feature];
+ else
+ status = vmmParamNotFound;
+ return status;
+}
diff --git a/vmmTblApp/src/hybrid.h b/vmmTblApp/src/hybrid.h
new file mode 100644
index 0000000000000000000000000000000000000000..79664b6c281f02dd8b8ec5bfdc3c26a348ffc623
--- /dev/null
+++ b/vmmTblApp/src/hybrid.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <map>
+#include <iostream>
+
+#include "vmm_params.h"
+#include "vmm3a.h"
+
+class Hybrid {
+public:
+ Hybrid();
+ ~Hybrid();
+
+ void loadDefault();
+ VMM3a& getVMM(int index);
+ vmmStatus getRegister(std::string feature, unsigned short& result);
+
+private:
+ VMM3a vmms[VMMS_PER_HYBRID];
+ std::map<std::string, unsigned short> hybrid_registers;
+ std::map<std::string, std::string> hybrid_info;
+};
diff --git a/vmmTblApp/src/vmm3a.cpp b/vmmTblApp/src/vmm3a.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d526ff417a770c26f56f599cfa2925045d20fa14
--- /dev/null
+++ b/vmmTblApp/src/vmm3a.cpp
@@ -0,0 +1,206 @@
+#include "vmm3a.h"
+
+// Define a map to store the valid range for each feature
+std::map<std::string, std::pair<int, int>> featureRanges = {
+ {"sm5_sm0", {0, 67}},
+ {"sfam", {0, 1}},
+ {"st", {0, 3}},
+ {"sg", {0, 7}},
+ {"stc", {0, 3}},
+ {"sdt", {0, 1023}},
+ {"sdp10", {0, 1023}},
+ {"sc10b", {0, 3}},
+ {"sc8b", {0, 3}},
+ {"truncate_i", {0, 63}},
+ {"nskip_i", {0, 127}},
+ {"window_i", {0, 7}},
+ {"rollover_i", {0, 4095}},
+ {"L0offset_i", {0, 4095}},
+ {"offset_i", {0, 4095}}
+};
+
+std::map<std::string, std::pair<int, int>> featureChannelRanges = {
+ {"sd", {0, 31}},
+ {"sz10b", {0, 31}},
+ {"sz08b", {0, 15}},
+ {"sz06b", {0, 7}},
+ {"sc", {0, 1}},
+ {"sl", {0, 1}},
+ {"st", {0, 1}},
+ {"sth", {0, 1}},
+ {"sc8b", {0, 3}},
+ {"sm", {0, 1}},
+ {"smx", {0, 1}}
+};
+
+VMM3a::VMM3a(): vmm3aSettings(std::make_unique<VMM3aSettings>()) {
+ LoadDefault();
+}
+
+void VMM3a::LoadDefault() {
+ //VMM3a channel registers
+ for(int ch=0; ch<CHANNELS_PER_VMM; ch++){
+ vmm3aSettings->channels[ch] = {{"sc", 0}, {"sl", 0}, {"st", 0}, {"sth", 0}, {"sm", 0}, {"sd", 0}, {"smx", 0}, {"sz10b", 0}, {"sz08b", 0}, {"sz06b", 0} };
+ }
+
+ //Fill default values to map for Global Register
+ std::vector<std::string> reg_names = {
+ "sp", "sdp", "sbmx", "sbft", "sbfp",
+ "sbfm", "slg", "sm5_sm0", "scmx", "sfa",
+ "sfam", "st", "sfm", "sg", "sng",
+ "stot", "sttt", "ssh", "stc",
+ "sdt", "sdp10", "sc10b", "sc8b", "sc6b",
+ "s8b", "s6b", "s10b", "sdcks", "sdcka",
+ "sdck6b", "sdrv", "stpp",
+ "slvs", "s32", "stcr", "ssart", "srec",
+ "stlc", "sbip", "srat", "sfrst", "slvsbc",
+ "slvstp", "slvstk", "slvsdt", "slvsart", "slvstki",
+ "slvsena", "slvs6b", "sL0enaV", "slh", "slxh",
+ "stgc", "reset1", "reset2", "nskipm_i", "sL0cktest",
+ "sL0dckinv", "sL0ckinv", "sL0ena", "truncate_i",
+ "nskip_i", "window_i", "rollover_i", "L0offset_i", "offset_i"
+ };
+
+ for(const std::string& reg: reg_names) {
+ vmm3aSettings->globalRegisters.insert(std::pair<std::string, unsigned short>(reg, 0));
+ }
+
+ setRegister("sg", 2);//corrsponds to 3 mV/fC
+ setRegister("sm5_sm0", 67); //Temperature_sensor
+ setRegister("sdp10", 300);
+ setRegister("sdt",300);
+ setRegister("s10b",1);
+ setRegister("s8b",1);
+ setRegister("stc",0);
+ setRegister("sc8b",3);
+ setRegister("sc10b",3);
+ setRegister("srat",0);
+ setRegister("sbip",true);
+ setRegister("sbfm",true);
+ setRegister("sdcks",false);
+}
+
+const VMM3a::VMM3aSettings& VMM3a::getVMM3aSettings() const {
+ return *vmm3aSettings;
+}
+
+vmmStatus VMM3a::setRegister(std::string feature, int val) {
+ vmmStatus status = vmmSuccess;
+ status = updateRegisterMap(feature, val);
+
+ if (status == vmmParamNotFound)
+ std::cout << "ERROR register " << feature << " does not exist." << std::endl;
+ else if (status == vmmBadValue)
+ std::cout << "Value " << val << " is not valid to register: " << feature << std::endl;
+ return status;
+}
+
+vmmStatus VMM3a::setRegister(std::string feature, int val, int ch) {
+ vmmStatus status = vmmSuccess;
+ status = updateRegisterMap(feature, val, ch);
+
+ if (status == vmmParamNotFound)
+ std::cout << "ERROR register " << feature << " does not exist." << std::endl;
+ else if (status == vmmBadValue)
+ std::cout << "Value " << val << " is not valid to register: " << feature << std::endl;
+ else if (status == vmmChannelOutRange)
+ std::cout << "Channel " << ch << " out of the range (0 - 63)" << std::endl;
+ return status;
+}
+
+vmmStatus VMM3a::getRegister(std::string feature, unsigned short& result) const {
+ vmmStatus status = vmmSuccess;
+ if(vmm3aSettings->globalRegisters.find(feature)!=vmm3aSettings->globalRegisters.end())
+ result = vmm3aSettings->globalRegisters.at(feature);
+ else
+ status = vmmParamNotFound;
+ return status;
+}
+
+vmmStatus VMM3a::getRegister(std::string feature, int ch, unsigned short& result) const {
+ vmmStatus status = vmmSuccess;
+ if (ch >= 0 && ch < 64) {
+ auto it = vmm3aSettings->channels[ch].find(feature);
+ if (it != vmm3aSettings->channels[ch].end())
+ result = it->second;
+ else
+ status = vmmParamNotFound;
+ }
+ else status = vmmChannelOutRange;
+
+ return status;
+}
+
+vmmStatus VMM3a::updateRegisterMap(std::string feature, int value) {
+ vmmStatus status = vmmSuccess;
+ auto it = vmm3aSettings->globalRegisters.find(feature);
+ if (it != vmm3aSettings->globalRegisters.end()) {
+ auto range = featureRanges.find(feature);
+ if (range != featureRanges.end()) {
+ int minVal = range->second.first;
+ int maxVal = range->second.second;
+
+ if (feature == "sm5_sm0") {
+ if(value >= 0 && value <= 63) {
+ vmm3aSettings->globalRegisters.at("scmx") = 1;
+ vmm3aSettings->globalRegisters.at("sm5_sm0") = value;
+ } else if (value >= 64 && value <= 67) {
+ //Attention: Starts at 1: 1=Pulser_DAC, 2=Threshold_DAC, 3=Bandgap_reference, 4=Temperature_sensor
+ vmm3aSettings->globalRegisters.at("scmx") = 0;
+ vmm3aSettings->globalRegisters.at("sm5_sm0") = value - 63;
+ } else status = vmmBadValue;
+ }
+ else {
+ if (value >= minVal && value <= maxVal)
+ vmm3aSettings->globalRegisters.at(feature) = value;
+ else status = vmmBadValue;
+ }
+ }
+ // If not in the featureRanges, the param expects boolean value.
+ else {
+ if(value >= 0 && value <= 1)
+ vmm3aSettings->globalRegisters.at(feature) = value;
+ else status = vmmBadValue;
+ }
+ }
+ else { status = vmmParamNotFound; }
+ return status;
+}
+
+vmmStatus VMM3a::updateRegisterMap(std::string feature, int value, int ch) {
+ vmmStatus status = vmmSuccess;
+
+ if(ch >= 0 && ch < 64) {
+ auto range = featureChannelRanges.find(feature);
+ if (range != featureChannelRanges.end()) {
+ int minVal = range->second.first;
+ int maxVal = range->second.second;
+ if (value >= minVal && value <= maxVal)
+ vmm3aSettings->channels[ch][feature] = value;
+ else status = vmmBadValue;
+ }
+ else status = vmmParamNotFound;
+ }
+ else status = vmmChannelOutRange;
+ return status;
+}
+
+vmmStatus VMM3a::getInfo(const std::string& feature, std::string& result) {
+ vmmStatus status = vmmSuccess;
+ if (vmmInfo.find(feature) != vmmInfo.end())
+ result = vmmInfo[feature];
+ else
+ status = vmmParamNotFound;
+ return status;
+}
+
+vmmStatus VMM3a::setInfo(const std::string& feature, const std::string& value) {
+ vmmStatus status = vmmSuccess;
+ if (vmmInfo.find(feature) != vmmInfo.end())
+ vmmInfo[feature] = value;
+ else
+ status = vmmParamNotFound;
+ return status;
+}
+
+VMM3a::~VMM3a(){}
diff --git a/vmmTblApp/src/vmm3a.h b/vmmTblApp/src/vmm3a.h
new file mode 100644
index 0000000000000000000000000000000000000000..da12e72975f88ac08489f23814166194fcafd89f
--- /dev/null
+++ b/vmmTblApp/src/vmm3a.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <map>
+#include <vector>
+#include <memory>
+#include <iostream>
+
+#include "vmm_params.h"
+
+class VMM3a {
+public:
+ VMM3a();
+ ~VMM3a();
+
+ void LoadDefault();
+
+ struct VMM3aSettings{
+ std::map<std::string, unsigned short> channels[CHANNELS_PER_VMM];
+ std::map<std::string, unsigned short> globalRegisters;
+ };
+
+ const VMM3aSettings& getVMM3aSettings() const;
+ vmmStatus setRegister(std::string feature, int val);
+ vmmStatus setRegister(std::string feature, int val, int ch);
+ vmmStatus getRegister(std::string feature, unsigned short& result) const;
+ vmmStatus getRegister(std::string feature, int ch, unsigned short& result) const;
+ vmmStatus getInfo(const std::string& feature, std::string& result);
+ vmmStatus setInfo(const std::string& feature, const std::string& value);
+
+private:
+ vmmStatus updateRegisterMap(std::string feature, int value);
+ vmmStatus updateRegisterMap(std::string feature, int value, int ch);
+ std::unique_ptr<VMM3aSettings> vmm3aSettings;
+ std::map<std::string, std::string> vmmInfo = {{"all_sc", "0"}, {"all_sl", "0"}, {"all_st", "0"}, {"all_sth", "0"},{"all_sm", "0"}, {"all_sd", "0"},{"all_smx", "0"},
+ {"all_sz10b", "0"},{"all_sz08b", "0"}, {"all_sz06b", "0"},{"adc_value", ""}, {"description",""}};
+};
\ No newline at end of file
diff --git a/vmmTblApp/src/vmm_config.cpp b/vmmTblApp/src/vmm_config.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e1132c2aca6c2c9dc48ec150e9a3b704fc69cf4
--- /dev/null
+++ b/vmmTblApp/src/vmm_config.cpp
@@ -0,0 +1,434 @@
+#include "vmm_config.h"
+#include <sstream>
+#include <bitset>
+#include <algorithm>
+#include <chrono>
+#include <thread>
+#include <array>
+
+#include "FrontEndBase.h"
+
+void delayMilliseconds(int milliseconds) {
+ std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+FENConfigModule::FENConfigModule(FrontEndBase& frontend) : pFEN(&frontend) {
+}
+
+FENConfigModule::~FENConfigModule() {
+}
+
+void FENConfigModule::acquire(bool acquire) {
+ std::string message;
+ std::vector<std::string> linkStatus;
+ if (acquire) {
+ enableAcquisition(false);
+ sendAll(true);
+ enableAcquisition(true);
+ checkLinkStatus(message, linkStatus);
+ } else {
+ enableAcquisition(false);
+ checkLinkStatus(message, linkStatus);
+ }
+}
+
+void FENConfigModule::sendAll(bool useConfigCheck) {
+ configFEN();
+ for(int hybrid = 0; hybrid <= HYBRIDS_PER_FEN; hybrid++) {
+ if (isHybridEnabled(hybrid)) {
+ configHybrid(hybrid);
+
+ for(int vmm = 0; vmm < VMMS_PER_HYBRID; vmm++) {
+ configVMM(hybrid, vmm, useConfigCheck);
+ }
+ }
+ }
+}
+
+void FENConfigModule::enableAcquisition(bool enabled) {
+ pFEN->user_reg_write("app_acq_enable", enabled);
+ pFEN->user_reg_write("sc_acq_on_off", 0x00000000);
+ pFEN->user_reg_write("sc_acq_on_off", 0x00000001);
+ pFEN->user_reg_write("sc_acq_on_off", 0x00000000);
+}
+
+void FENConfigModule::checkLinkStatus(std::string& message, std::vector<std::string>& linkStatus) {
+ linkStatus.clear();
+ for (int n = 0; n < HYBRIDS_PER_FEN; n++) linkStatus.push_back("0");
+
+ uint32_t result = readWriteRegs("sc_app_link_status", 0, "app_link_status");
+
+ std::stringstream ss;
+
+ for (int n = 0; n < HYBRIDS_PER_FEN; n++) {
+ if (isHybridEnabled(n)) {
+ linkStatus[n] = std::to_string(result);
+ ss << "hybr. " + std::to_string(n) + ": " + linkStatus[n] << std::endl;
+ }
+ }
+ message = ss.str();
+ std::cout << "Message: " << message << std::endl;
+}
+
+void FENConfigModule::configFEN() {
+ pFEN->user_reg_write("app_debug_data_format", 0);
+ pFEN->user_reg_write("app_latency_reset", 27);
+ pFEN->user_reg_write("app_latency_data_max", 1024);
+ pFEN->user_reg_write("app_latency_data_jitter", 0);
+ pFEN->user_reg_write("app_tp_offset_first", 100);
+ pFEN->user_reg_write("app_tp_offset", 1000);
+ pFEN->user_reg_write("app_tp_latency", 46);
+ pFEN->user_reg_write("app_tp_number", 1);
+ pFEN->user_reg_write("app_chmask", getChMap());
+ pFEN->user_reg_write("sc_cfg_app", 0x00000000);
+ pFEN->user_reg_write("sc_cfg_app", 0x00000001);
+ pFEN->user_reg_write("sc_cfg_app", 0x00000000);
+}
+
+uint16_t FENConfigModule::getChMap() {
+ std::string chMapString = "0000000000000000";
+ for (int hybrid = 0; hybrid < HYBRIDS_PER_FEN; hybrid++) {
+ if (isHybridEnabled(hybrid)) {
+ for (int vmm = 0; vmm < VMMS_PER_HYBRID; vmm++) {
+ chMapString.replace(15 - (hybrid * 2 + vmm), 1, "1");
+ }
+ }
+ }
+ uint16_t chMap = std::stoi(chMapString, nullptr, 2);
+ return chMap;
+}
+
+bool FENConfigModule::enableHybrid(int hybrid, bool onOff) {
+ if(hybrid < HYBRIDS_PER_FEN) {
+ enabled_hybrids[hybrid] = onOff;
+ return true;
+ } else return false;
+}
+
+bool FENConfigModule::isHybridEnabled(int hybrid) {
+ if(hybrid < HYBRIDS_PER_FEN) return enabled_hybrids[hybrid];
+ else return false;
+}
+
+Hybrid& FENConfigModule::getHybrid(int index) {
+ if (index < 0 || index >= HYBRIDS_PER_FEN)
+ throw std::out_of_range("Invalid hybrid index");
+ return hybrids[index];
+}
+
+void FENConfigModule::configHybrid(int hybrid_index) {
+ std::array<std::string, 3> registers = {"hyb_tp_skew0", "hyb_tp_width0", "hyb_tp_polarity0"};
+
+ for (const auto& reg : registers) {
+ unsigned short result = 0;
+ hybrids[hybrid_index].getRegister(reg, result);
+ pFEN->user_reg_write(reg + std::to_string(hybrid_index), result);
+ }
+
+ uint32_t value = (1 << hybrid_index);
+ pFEN->user_reg_write("sc_cfg_hyb", 0x0);
+ pFEN->user_reg_write("sc_cfg_hyb", value);
+ pFEN->user_reg_write("sc_cfg_hyb", 0x0);
+}
+
+bool FENConfigModule::configVMM(int hybrid_index, int vmm_index, bool enableConfigCheck)
+{
+ bool result = true;
+ bool ok;
+
+ std::vector<std::string> globalRegisters;
+ globalRegisters.clear();
+ fillGlobalRegisters(globalRegisters, hybrid_index, vmm_index);
+
+ std::cout << "Global Registers:" << std::endl;
+ for (const auto& reg : globalRegisters) {
+ std::cout << reg << std::endl;
+ }
+
+ if(globalRegisters.size()!=3){
+ std::cout << "ERROR Global SPI does not have 3 words" << std::endl;
+ return -1;
+ }
+
+ std::vector<std::string> channelRegisters;
+ channelRegisters.clear();
+ fillChRegisters(channelRegisters, hybrid_index, vmm_index);
+ if(channelRegisters.size() != 64){
+ std::cout << "ERROR Channel registers do not have 64 values" << std::endl;
+ return -1;
+ }
+
+ std::vector<std::string> globalRegisters2;
+ globalRegisters2.clear();
+ fillGlobalRegisters2(globalRegisters2, hybrid_index, vmm_index);
+ if(globalRegisters2.size()!=3){
+ std::cout << "ERROR Global SPI does not have 3 words" << std::endl;
+ return -1;
+ }
+
+ int idx = hybrid_index * 2 + vmm_index;
+ std::string sVmmIndex = "99";
+ if(idx < 10) sVmmIndex = "0" + std::to_string(idx);
+ else if(idx < 16) sVmmIndex = std::to_string(idx);
+
+ bool g_use_config_check = true;
+ if(g_use_config_check) {
+ //reset I2C address 65 register 0
+ if(enableConfigCheck) {
+ // TODO: Check with we need that (the enableConfigCheck is always false in the VMM code)
+ //uint32_t value = (1 << hybrid_index);
+ //ESS_WriteSc("sc_i2c_reset_config_check", 0x00000000, ok);
+ //ESS_WriteSc("sc_i2c_reset_config_check", value, ok);
+ //ESS_WriteSc("sc_i2c_reset_config_check", 0x00000000, ok);
+ }
+ }
+
+ unsigned int firstGlobalRegSPI_2 = 0;
+ unsigned int lastGlobalRegSPI_2 = 2;
+ unsigned int firstGlobalRegSPI_1 = 67;
+ unsigned int lastGlobalRegSPI_1 = 69;
+
+ // global SPI / VMM3: global bank 0
+ for(unsigned int i = firstGlobalRegSPI_2; i <= lastGlobalRegSPI_2; i++) {
+ std::string param = "vmm_global_bank2_sp" + std::to_string(i - firstGlobalRegSPI_2) + sVmmIndex;
+ uint32_t value = std::stoul(globalRegisters2[i - firstGlobalRegSPI_2], nullptr, 2);
+ pFEN->user_reg_write(param, value);
+ }
+
+ //channel SPI
+ for(unsigned int i = 0; i < CHANNELS_PER_VMM; i++) {
+ std::string position_str = std::to_string(i);
+ if (position_str.size() == 1) position_str = "0" + position_str;
+ std::string param = "vmm_ch" + position_str + sVmmIndex;
+ uint32_t value = std::stoul(channelRegisters[i], nullptr, 2);
+ std::cout << "param: " << param << std::endl;
+ pFEN->user_reg_write(param, value);
+ }
+
+ // global SPI / VMM3: global bank 1
+ for(unsigned int i = firstGlobalRegSPI_1; i <= lastGlobalRegSPI_1; i++) {
+ std::string param = "vmm_global_bank1_sp" + std::to_string(i - firstGlobalRegSPI_1) + sVmmIndex;
+ uint32_t value = std::stoul(globalRegisters[i - firstGlobalRegSPI_1], nullptr, 2);
+ pFEN->user_reg_write(param, value);
+ }
+
+ uint32_t value = (1 << idx);
+ pFEN->user_reg_write("sc_cfg_vmm", 0x00000000);
+ pFEN->user_reg_write("sc_cfg_vmm", value);
+ pFEN->user_reg_write("sc_cfg_vmm", 0x00000000);
+
+ return result;
+}
+
+void FENConfigModule::fillGlobalRegisters(std::vector<std::string>& global, int hybrid_index, int vmm_index)
+{
+ unsigned short result;
+
+ global.clear();
+ int sequence = 0;
+
+ // GLOBAL SPI 0
+ std::string spi0 = "00000000000000000000000000000000";
+
+ //[0,3] reserved
+ sequence += 4;
+
+ // Function to replace a bit in the spi0 string with a value from VMM settings
+ auto replaceVMMBit = [&](int index, const std::string& settingName) {
+ // Convert value to '1' if it's not zero, otherwise '0'
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister(settingName, result);
+ spi0[index] = '0' + (result != 0);
+ };
+
+ const std::vector<std::string> settings = {"slvs", "s32", "stcr", "ssart", "srec", "stlc", "sbip", "srat", "sfrst",
+ "slvsbc", "slvstp", "slvstk", "slvsdt", "slvsart", "slvstki", "slvsena",
+ "slvs6b", "slh", "slxh", "stgc", "reset1", "reset2"};
+
+ for (const auto& setting : settings) {
+ if (setting == "reset1") sequence += 5; //[25,29] not used
+ replaceVMMBit(sequence, setting);
+ sequence++;
+ }
+
+ global.push_back(spi0);
+
+ // GLOBAL SPI 1
+ // Define a function to populate spi string based on VMM settings
+ auto populateSPI1 = [&](const std::vector<std::pair<std::string, int>>& settings) {
+ std::string spi;
+ int sequence = 0;
+ for (const auto& setting : settings) {
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister(setting.first, result);
+ std::string binary_string = std::bitset<16>(result).to_string().substr(16 - setting.second);
+
+ if (setting.first == "sdt") {
+ // Populate threshold DAC lowest 6 bits
+ for (int i = 4; i < 10; ++i) spi += binary_string[i];
+ } else spi += binary_string;
+ sequence += setting.second;
+ }
+
+ // Append '0' to the end of spi to reserve the last bit: [31] reserved
+ spi += '0';
+
+ // Push back the populated spi string to the global vector
+ global.push_back(spi);
+ };
+
+ // Populate SPI 1 settings
+ populateSPI1({{"sdt", 10},{"sdp10", 10}, {"sc10b", 2}, {"sc8b", 2},
+ {"sc6b", 3}, {"s8b", 1}, {"s6b", 1}, {"s10b", 1},
+ {"sdcks", 1}, {"sdcka", 1}, {"sdck6b", 1}, {"sdrv", 1},
+ {"stpp", 1}});
+
+ // GLOBAL SPI 2
+ // Define a function to populate spi string based on VMM settings
+ auto populateSPI2 = [&](const std::vector<std::pair<std::string, int>>& settings) {
+ std::string spi;
+ int sequence = 0;
+
+ for (const auto& setting : settings) {
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister(setting.first, result);
+ std::string binary_string = std::bitset<16>(result).to_string().substr(16 - setting.second);
+ if (setting.first == "sdt") {
+ // Populate threshold DAC highest 4 bits
+ for (int i = 0; i < 4; ++i) {
+ spi += binary_string[i];
+ sequence++;
+ }
+ } else {
+ spi += binary_string;
+ sequence += setting.second;
+ }
+ }
+ // Push back the populated spi string to the global vector
+ global.push_back(spi);
+ };
+
+ // Populate SPI 2 settings
+ populateSPI2({{"sp", 1}, {"sdp", 1}, {"sbmx", 1}, {"sbft", 1}, {"sbfp", 1},
+ {"sbfm", 1}, {"slg", 1}, {"sm5_sm0", 6}, {"scmx", 1}, {"sfa", 1},
+ {"sfam", 1}, {"st", 2}, {"sfm", 1}, {"sg", 3}, {"sng", 1}, {"stot", 1},
+ {"sttt", 1}, {"ssh", 1}, {"stc", 2}, {"sdt", 10}});
+
+}
+
+void FENConfigModule::fillChRegisters(std::vector<std::string>& registers, int hybrid_index, int vmm_index)
+{
+ registers.clear();
+ unsigned short result;
+
+ auto populateRegisters = [&](const std::vector<std::pair<std::string, int>>& regs, int channel) {
+ std::string _reg = "00000000";
+ int sequence = 8;
+
+ for (const auto& reg : regs) {
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister(reg.first, channel, result);
+ std::string binary_string = std::bitset<16>(result).to_string().substr(16 - reg.second);
+ if (reg.first == "sd" || reg.first == "sz10b" ||
+ reg.first == "sz08b" || reg.first == "sz06b") {
+ //According to ATLAS software, has to be reversed
+ std::reverse(binary_string.begin(), binary_string.end());
+ }
+ _reg += binary_string;
+ sequence += reg.second;
+ }
+
+ // Append '0' to the end of spi to reserve the last bit: [31] reserved
+ _reg += "0";
+
+ // Push back the populated _reg string to the registers vector
+ registers.push_back(_reg);
+ };
+
+ std::vector<std::pair<std::string, int>> registers_map = {{"sc", 1}, {"sl", 1}, {"st", 1},
+ {"sth", 1}, {"sm", 1}, {"smx", 1},
+ {"sd", 5}, {"sz10b", 5}, {"sz08b", 4},
+ {"sz06b", 3}};
+
+ for(int ch = 0; ch < CHANNELS_PER_VMM; ch++) {
+ populateRegisters(registers_map, ch);
+ }
+}
+
+void FENConfigModule::fillGlobalRegisters2(std::vector<std::string>& global, int hybrid_index, int vmm_index)
+{
+ unsigned short result;
+ int sequence = 0;
+
+ // GLOBAL SPI 0
+ std::string spi0 = "00000000000000000000000000000000";
+ //[0,30] not used
+ sequence+=31;
+
+ // magic number on BCID [31]
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("nskipm_i", result);
+ spi0.replace(sequence, 1, std::to_string(result));
+
+ global.push_back(spi0);
+
+ // GLOBAL SPI 1
+ std::string spi1 = "00000000000000000000000000000000";
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0cktest", result);
+ // clocks when L0 core disabled [0]
+ spi1.replace(sequence, 1, std::to_string(result));
+ sequence++;
+
+ //invert DCK [1]
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0dckinv", result);
+ spi1.replace(sequence, 1, std::to_string(result));
+ sequence++;
+
+ //invert BCCLK [2]
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0ckinv", result);
+ spi1.replace(sequence, 1, std::to_string(result));
+ sequence++;
+
+ //L0 core
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0ena", result);
+ spi1.replace(sequence, 1, std::to_string(result));
+ sequence++;
+
+ global.push_back(spi1);
+
+ // GLOBAL SPI 2
+ std::string spi2 = "00000000000000000000000000000000";
+ global.push_back(spi2);
+}
+
+int FENConfigModule::readADC(int hybrid_index, int vmm_index) {
+ int adc_result = 0;
+ int vmm = hybrid_index * 2 + vmm_index;
+ std::string sVmmIndex = "99";
+ if(vmm < 10) sVmmIndex = "0" + std::to_string(vmm);
+ else if(vmm < 16) sVmmIndex = std::to_string(vmm);
+
+ uint32_t result = readWriteRegs("sc_i2c_vmm_adc", vmm, "vmm_i2c_adc" + sVmmIndex);
+ adc_result = (result & 0xFFFF) >> 4; // bit shift
+
+ unsigned short sp_value = 0;
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sp", sp_value);
+ unsigned sm5_sm0_value = 0;
+ hybrids[hybrid_index].getVMM(vmm_index).getRegister("sm5_sm0", sp_value);
+
+ if((sp_value != 0) && (sm5_sm0_value == 1)) adc_result = 1200 - adc_result;
+
+ return adc_result;
+}
+
+uint32_t FENConfigModule::readWriteRegs(std::string command_reg, int index, std::string read_reg) {
+ unsigned int data = 0x00000000;
+ pFEN->user_reg_write(command_reg, data);
+ data = (1 << index);
+ pFEN->user_reg_write(command_reg, data);
+
+ //Do not read registers back too soon, otherwise old ADC value is read
+ delayMilliseconds(7);
+
+ uint32_t value = pFEN->user_reg_read(read_reg);
+ std::cout << "value: " << value << std::endl;
+ pFEN->user_reg_write(command_reg, 0x0);
+
+ return value;
+}
+
diff --git a/vmmTblApp/src/vmm_config.h b/vmmTblApp/src/vmm_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e301d48ff962af7bf101d6fd621b75d28a8ce9c
--- /dev/null
+++ b/vmmTblApp/src/vmm_config.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <map>
+#include <vector>
+#include <memory>
+#include <iostream>
+#include "hybrid.h"
+
+class FrontEndBase;
+
+class FENConfigModule {
+public:
+ FENConfigModule(FrontEndBase& frontend);
+ ~FENConfigModule();
+ void configFEN();
+ void configHybrid(int hybrid_index);
+ bool configVMM(int hybrid_index, int vmm_index, bool enableConfigCheck=false);
+ void fillGlobalRegisters(std::vector<std::string>& global, int hybrid_index, int vmm_index);
+ void fillGlobalRegisters2(std::vector<std::string>& global, int hybrid_index, int vmm_index);
+ void fillChRegisters(std::vector<std::string>& registers, int hybrid_index, int vmm_index);
+ int readADC(int hybrid_index, int vmm_index);
+ Hybrid& getHybrid(int index);
+ bool enableHybrid(int hybrid, bool onOff);
+ bool isHybridEnabled(int hybrid);
+ void acquire(bool acquire);
+
+private:
+ FrontEndBase *pFEN;
+ Hybrid hybrids[HYBRIDS_PER_FEN];
+ bool enabled_hybrids[HYBRIDS_PER_FEN] = {};
+ uint32_t readWriteRegs(std::string command_reg, int index, std::string read_reg);
+ uint16_t getChMap();
+ void checkLinkStatus(std::string& message, std::vector<std::string>& linkStatus);
+ void sendAll(bool useConfigCheck);
+ void enableAcquisition(bool enabled);
+};
diff --git a/vmmTblApp/src/vmm_params.h b/vmmTblApp/src/vmm_params.h
new file mode 100644
index 0000000000000000000000000000000000000000..93aa7270904977ef18645efccdfe8614b0b13498
--- /dev/null
+++ b/vmmTblApp/src/vmm_params.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#define CHANNELS_PER_VMM 64
+#define VMMS_PER_HYBRID 2
+#define HYBRIDS_PER_FEN 5
+
+typedef enum {
+ vmmSuccess,vmmTimeout,vmmParamNotFound,vmmBadValue,vmmChannelOutRange
+}vmmStatus;
diff --git a/vmmTblApp/src/vmm_tbl.cpp b/vmmTblApp/src/vmm_tbl.cpp
index bd04601c514e5610c96c9f34f520dc9b64589696..6e4fa7bfadfa44065f0f4c0432a287bea86c49c3 100644
--- a/vmmTblApp/src/vmm_tbl.cpp
+++ b/vmmTblApp/src/vmm_tbl.cpp
@@ -3,6 +3,7 @@
/** Constructor for the VMMTbl class */
VMMTbl::VMMTbl(RMM& rmm, int ring, int node)
: FrontEndBase(rmm.get_rmm_reg_access(), ring, node),
+ pVMMConfig(*this),
pRMM(&rmm)
{
addr_list = ring * NUMBER_NODES_PER_RING + node;
@@ -10,6 +11,7 @@ VMMTbl::VMMTbl(RMM& rmm, int ring, int node)
create_epics_params();
set_initial_epics_params();
pRMM->get_rmm_rings().set_topology(ring, node, "vmm-tbl");
+ pVMMConfig.enableHybrid(0, true);
}
void VMMTbl::config_FE() {
@@ -21,6 +23,13 @@ void VMMTbl::set_initial_epics_params() {
}
asynStatus VMMTbl::create_epics_params() {
+ pRMM->createParam(addr_list, "SEL_ANALOG_MONITOR_VMM0", asynParamInt32, &vmmSelectMonitorVMM0_);
+ pRMM->createParam(addr_list, "SEL_ANALOG_MONITOR_VMM1", asynParamInt32, &vmmSelectMonitorVMM1_);
+ pRMM->createParam(addr_list, "READ_ADC_VMMS", asynParamInt32, &vmmProcessReadMonitorVMMs_);
+ pRMM->createParam(addr_list, "ADC_VALUE_VMM0", asynParamFloat64, &vmmMonitorValueVMM0_);
+ pRMM->createParam(addr_list, "ADC_VALUE_VMM1", asynParamFloat64, &vmmMonitorValueVMM1_);
+ pRMM->createParam(addr_list, "VMM_FEN_ACQUIRE", asynParamInt32, &vmmAcquire_);
+
return asynSuccess;
}
@@ -30,6 +39,36 @@ asynStatus VMMTbl::writeInt32(asynUser *pasynUser, epicsInt32 value) {
int addr = 0;
pRMM->getAddress(pasynUser, &addr);
+ if ((value) && (function == vmmProcessReadMonitorVMMs_)) {
+ int adc_sensor = 0;
+ for (int vmm = 0; vmm <= 1; vmm++) {
+ pRMM->getIntegerParam(addr, vmmSelectMonitorVMM0_ + vmm, &adc_sensor);
+ std::cout << "adc_sensor" << adc_sensor << std::endl;
+ pVMMConfig.getHybrid(0).getVMM(vmm).setRegister("sm5_sm0", adc_sensor + 64);
+ pVMMConfig.configVMM(0, vmm);
+ int adc_read = pVMMConfig.readADC(0, vmm);
+
+ std::cout << "adc_read" << adc_read << std::endl;
+
+ if (adc_sensor == 3) {
+ double temperature = (725 - adc_read) / 1.85;
+ pRMM->setDoubleParam(addr, vmmMonitorValueVMM0_ + vmm, temperature);
+ }
+ else {
+ pRMM->setDoubleParam(addr, vmmMonitorValueVMM0_ + vmm, adc_read);
+ }
+ }
+ }
+
+ else if (function == vmmAcquire_) {
+ // enable test_pulse (st) of Hybrid 0, VMM 0, channel 0 to test purpose
+ // TODO: ADD PVs to enable/disable that
+ pVMMConfig.getHybrid(0).getVMM(0).setRegister("st", 1, 0);
+
+ if (value) pVMMConfig.acquire(true);
+ else pVMMConfig.acquire(false);
+ }
+
return status;
}
diff --git a/vmmTblApp/src/vmm_tbl.h b/vmmTblApp/src/vmm_tbl.h
index bf0d23def61d3d4f264d6b68b1e44bf67de42692..5d92c5fa3dc46d34af2680dc43b15cf2aca4995a 100644
--- a/vmmTblApp/src/vmm_tbl.h
+++ b/vmmTblApp/src/vmm_tbl.h
@@ -3,6 +3,7 @@
#include "rmm.h"
#include "FrontEndBase.h"
#include "vmm_tbl_regs_map.h"
+#include "vmm_config.h"
/** Class definition for the VMMTbl class */
class VMMTbl : public FrontEndBase {
@@ -13,9 +14,17 @@ public:
virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value);
void set_initial_epics_params();
void config_FE();
+
protected:
+ int vmmSelectMonitorVMM0_;
+ int vmmSelectMonitorVMM1_;
+ int vmmProcessReadMonitorVMMs_;
+ int vmmMonitorValueVMM0_;
+ int vmmMonitorValueVMM1_;
+ int vmmAcquire_;
private:
+ FENConfigModule pVMMConfig;
RMM *pRMM;
int addr_list = 0;
};
diff --git a/vmmTblApp/src/vmm_tbl_regs_map.cpp b/vmmTblApp/src/vmm_tbl_regs_map.cpp
index d9fb9ee7429fb84af9687718fcb9a9a024b34610..0b4d174685ebd4d8c4d53d1b76c53e3ccbfe7b31 100644
--- a/vmmTblApp/src/vmm_tbl_regs_map.cpp
+++ b/vmmTblApp/src/vmm_tbl_regs_map.cpp
@@ -1,4 +1,807 @@
#include "vmm_tbl_regs_map.h"
const std::unordered_map<std::string, uint32_t> vmm_tbl_register_map = {
+ { "REGBANK_VERSION", 0x00000000 },
+ { "PHASH", 0x00000004 },
+ { "ro_test", 0x00000008 },
+ { "rw_test", 0x0000000c },
+ { "GIT_HASH2", 0x00000010 },
+ { "GIT_HASH1", 0x00000014 },
+ { "GIT_HASH0", 0x00000018 },
+ { "led_ctl", 0x0000001c },
+ { "vmm_clk_freq", 0x00000020 },
+ { "test_data_en", 0x00000024 },
+ { "test_data_rate", 0x00000028 },
+ { "hit_cnt_rst", 0x0000002c },
+ { "hit_cnt_hv00", 0x00000030 },
+ { "hit_cnt_hv01", 0x00000034 },
+ { "hit_cnt_hv02", 0x00000038 },
+ { "hit_cnt_hv03", 0x0000003c },
+ { "sc_acq_on_off", 0x00000040 },
+ { "sc_cfg_app", 0x00000044 },
+ { "sc_cfg_hyb", 0x00000048 },
+ { "sc_cfg_vmm", 0x0000004c },
+ { "sc_eeprom_board_id", 0x00000050 },
+ { "sc_app_link_status", 0x00000054 },
+ { "sc_app_reset_assister", 0x00000058 },
+ { "sc_app_board_id", 0x0000005c },
+ { "sc_i2c_geo_id", 0x00000060 },
+ { "sc_i2c_firmware_version", 0x00000064 },
+ { "sc_i2c_hybrid_id", 0x00000068 },
+ { "sc_i2c_config_check", 0x0000006c },
+ { "sc_i2c_reset_config_check", 0x00000070 },
+ { "sc_i2c_vmm_adc", 0x00000074 },
+ { "eeprom_board_id", 0x00000078 },
+ { "app_board_id", 0x0000007c },
+ { "app_debug_data_format", 0x00000080 },
+ { "app_latency_reset", 0x00000084 },
+ { "app_latency_data_max", 0x00000088 },
+ { "app_latency_data_jitter", 0x0000008c },
+ { "app_chmask", 0x00000090 },
+ { "app_tp_offset_first", 0x00000094 },
+ { "app_tp_offset", 0x00000098 },
+ { "app_tp_latency", 0x0000009c },
+ { "app_tp_number", 0x000000a0 },
+ { "app_acq_enable", 0x000000a4 },
+ { "app_link_status", 0x000000a8 },
+ { "hyb_tp_skew00", 0x000000ac },
+ { "hyb_tp_skew01", 0x000000b0 },
+ { "hyb_tp_skew02", 0x000000b4 },
+ { "hyb_tp_skew03", 0x000000b8 },
+ { "hyb_tp_skew04", 0x000000bc },
+ { "hyb_tp_width00", 0x000000c0 },
+ { "hyb_tp_width01", 0x000000c4 },
+ { "hyb_tp_width02", 0x000000c8 },
+ { "hyb_tp_width03", 0x000000cc },
+ { "hyb_tp_width04", 0x000000d0 },
+ { "hyb_tp_polarity00", 0x000000d4 },
+ { "hyb_tp_polarity01", 0x000000d8 },
+ { "hyb_tp_polarity02", 0x000000dc },
+ { "hyb_tp_polarity03", 0x000000e0 },
+ { "hyb_tp_polarity04", 0x000000e4 },
+ { "hyb_i2c_geoid00", 0x000000e8 },
+ { "hyb_i2c_geoid01", 0x000000ec },
+ { "hyb_i2c_geoid02", 0x000000f0 },
+ { "hyb_i2c_geoid03", 0x000000f4 },
+ { "hyb_i2c_geoid04", 0x000000f8 },
+ { "hyb_i2c_firmware_version00", 0x000000fc },
+ { "hyb_i2c_firmware_version01", 0x00000100 },
+ { "hyb_i2c_firmware_version02", 0x00000104 },
+ { "hyb_i2c_firmware_version03", 0x00000108 },
+ { "hyb_i2c_firmware_version04", 0x0000010c },
+ { "hyb_i2c_hybrid_id000", 0x00000110 },
+ { "hyb_i2c_hybrid_id001", 0x00000114 },
+ { "hyb_i2c_hybrid_id002", 0x00000118 },
+ { "hyb_i2c_hybrid_id003", 0x0000011c },
+ { "hyb_i2c_hybrid_id004", 0x00000120 },
+ { "hyb_i2c_hybrid_id100", 0x00000124 },
+ { "hyb_i2c_hybrid_id101", 0x00000128 },
+ { "hyb_i2c_hybrid_id102", 0x0000012c },
+ { "hyb_i2c_hybrid_id103", 0x00000130 },
+ { "hyb_i2c_hybrid_id104", 0x00000134 },
+ { "hyb_i2c_hybrid_id200", 0x00000138 },
+ { "hyb_i2c_hybrid_id201", 0x0000013c },
+ { "hyb_i2c_hybrid_id202", 0x00000140 },
+ { "hyb_i2c_hybrid_id203", 0x00000144 },
+ { "hyb_i2c_hybrid_id204", 0x00000148 },
+ { "hyb_i2c_hybrid_id300", 0x0000014c },
+ { "hyb_i2c_hybrid_id301", 0x00000150 },
+ { "hyb_i2c_hybrid_id302", 0x00000154 },
+ { "hyb_i2c_hybrid_id303", 0x00000158 },
+ { "hyb_i2c_hybrid_id304", 0x0000015c },
+ { "hyb_i2c_config_check00", 0x00000160 },
+ { "hyb_i2c_config_check01", 0x00000164 },
+ { "hyb_i2c_config_check02", 0x00000168 },
+ { "hyb_i2c_config_check03", 0x0000016c },
+ { "hyb_i2c_config_check04", 0x00000170 },
+ { "vmm_i2c_adc00", 0x00000174 },
+ { "vmm_i2c_adc01", 0x00000178 },
+ { "vmm_i2c_adc02", 0x0000017c },
+ { "vmm_i2c_adc03", 0x00000180 },
+ { "vmm_i2c_adc04", 0x00000184 },
+ { "vmm_i2c_adc05", 0x00000188 },
+ { "vmm_i2c_adc06", 0x0000018c },
+ { "vmm_i2c_adc07", 0x00000190 },
+ { "vmm_i2c_adc08", 0x00000194 },
+ { "vmm_i2c_adc09", 0x00000198 },
+ { "vmm_global_bank2_sp000", 0x0000019c },
+ { "vmm_global_bank2_sp001", 0x000001a0 },
+ { "vmm_global_bank2_sp002", 0x000001a4 },
+ { "vmm_global_bank2_sp003", 0x000001a8 },
+ { "vmm_global_bank2_sp004", 0x000001ac },
+ { "vmm_global_bank2_sp005", 0x000001b0 },
+ { "vmm_global_bank2_sp006", 0x000001b4 },
+ { "vmm_global_bank2_sp007", 0x000001b8 },
+ { "vmm_global_bank2_sp008", 0x000001bc },
+ { "vmm_global_bank2_sp009", 0x000001c0 },
+ { "vmm_global_bank2_sp100", 0x000001c4 },
+ { "vmm_global_bank2_sp101", 0x000001c8 },
+ { "vmm_global_bank2_sp102", 0x000001cc },
+ { "vmm_global_bank2_sp103", 0x000001d0 },
+ { "vmm_global_bank2_sp104", 0x000001d4 },
+ { "vmm_global_bank2_sp105", 0x000001d8 },
+ { "vmm_global_bank2_sp106", 0x000001dc },
+ { "vmm_global_bank2_sp107", 0x000001e0 },
+ { "vmm_global_bank2_sp108", 0x000001e4 },
+ { "vmm_global_bank2_sp109", 0x000001e8 },
+ { "vmm_global_bank2_sp200", 0x000001ec },
+ { "vmm_global_bank2_sp201", 0x000001f0 },
+ { "vmm_global_bank2_sp202", 0x000001f4 },
+ { "vmm_global_bank2_sp203", 0x000001f8 },
+ { "vmm_global_bank2_sp204", 0x000001fc },
+ { "vmm_global_bank2_sp205", 0x00000200 },
+ { "vmm_global_bank2_sp206", 0x00000204 },
+ { "vmm_global_bank2_sp207", 0x00000208 },
+ { "vmm_global_bank2_sp208", 0x0000020c },
+ { "vmm_global_bank2_sp209", 0x00000210 },
+ { "vmm_ch0000", 0x00000214 },
+ { "vmm_ch0001", 0x00000218 },
+ { "vmm_ch0002", 0x0000021c },
+ { "vmm_ch0003", 0x00000220 },
+ { "vmm_ch0004", 0x00000224 },
+ { "vmm_ch0005", 0x00000228 },
+ { "vmm_ch0006", 0x0000022c },
+ { "vmm_ch0007", 0x00000230 },
+ { "vmm_ch0008", 0x00000234 },
+ { "vmm_ch0009", 0x00000238 },
+ { "vmm_ch0100", 0x0000023c },
+ { "vmm_ch0101", 0x00000240 },
+ { "vmm_ch0102", 0x00000244 },
+ { "vmm_ch0103", 0x00000248 },
+ { "vmm_ch0104", 0x0000024c },
+ { "vmm_ch0105", 0x00000250 },
+ { "vmm_ch0106", 0x00000254 },
+ { "vmm_ch0107", 0x00000258 },
+ { "vmm_ch0108", 0x0000025c },
+ { "vmm_ch0109", 0x00000260 },
+ { "vmm_ch0200", 0x00000264 },
+ { "vmm_ch0201", 0x00000268 },
+ { "vmm_ch0202", 0x0000026c },
+ { "vmm_ch0203", 0x00000270 },
+ { "vmm_ch0204", 0x00000274 },
+ { "vmm_ch0205", 0x00000278 },
+ { "vmm_ch0206", 0x0000027c },
+ { "vmm_ch0207", 0x00000280 },
+ { "vmm_ch0208", 0x00000284 },
+ { "vmm_ch0209", 0x00000288 },
+ { "vmm_ch0300", 0x0000028c },
+ { "vmm_ch0301", 0x00000290 },
+ { "vmm_ch0302", 0x00000294 },
+ { "vmm_ch0303", 0x00000298 },
+ { "vmm_ch0304", 0x0000029c },
+ { "vmm_ch0305", 0x000002a0 },
+ { "vmm_ch0306", 0x000002a4 },
+ { "vmm_ch0307", 0x000002a8 },
+ { "vmm_ch0308", 0x000002ac },
+ { "vmm_ch0309", 0x000002b0 },
+ { "vmm_ch0400", 0x000002b4 },
+ { "vmm_ch0401", 0x000002b8 },
+ { "vmm_ch0402", 0x000002bc },
+ { "vmm_ch0403", 0x000002c0 },
+ { "vmm_ch0404", 0x000002c4 },
+ { "vmm_ch0405", 0x000002c8 },
+ { "vmm_ch0406", 0x000002cc },
+ { "vmm_ch0407", 0x000002d0 },
+ { "vmm_ch0408", 0x000002d4 },
+ { "vmm_ch0409", 0x000002d8 },
+ { "vmm_ch0500", 0x000002dc },
+ { "vmm_ch0501", 0x000002e0 },
+ { "vmm_ch0502", 0x000002e4 },
+ { "vmm_ch0503", 0x000002e8 },
+ { "vmm_ch0504", 0x000002ec },
+ { "vmm_ch0505", 0x000002f0 },
+ { "vmm_ch0506", 0x000002f4 },
+ { "vmm_ch0507", 0x000002f8 },
+ { "vmm_ch0508", 0x000002fc },
+ { "vmm_ch0509", 0x00000300 },
+ { "vmm_ch0600", 0x00000304 },
+ { "vmm_ch0601", 0x00000308 },
+ { "vmm_ch0602", 0x0000030c },
+ { "vmm_ch0603", 0x00000310 },
+ { "vmm_ch0604", 0x00000314 },
+ { "vmm_ch0605", 0x00000318 },
+ { "vmm_ch0606", 0x0000031c },
+ { "vmm_ch0607", 0x00000320 },
+ { "vmm_ch0608", 0x00000324 },
+ { "vmm_ch0609", 0x00000328 },
+ { "vmm_ch0700", 0x0000032c },
+ { "vmm_ch0701", 0x00000330 },
+ { "vmm_ch0702", 0x00000334 },
+ { "vmm_ch0703", 0x00000338 },
+ { "vmm_ch0704", 0x0000033c },
+ { "vmm_ch0705", 0x00000340 },
+ { "vmm_ch0706", 0x00000344 },
+ { "vmm_ch0707", 0x00000348 },
+ { "vmm_ch0708", 0x0000034c },
+ { "vmm_ch0709", 0x00000350 },
+ { "vmm_ch0800", 0x00000354 },
+ { "vmm_ch0801", 0x00000358 },
+ { "vmm_ch0802", 0x0000035c },
+ { "vmm_ch0803", 0x00000360 },
+ { "vmm_ch0804", 0x00000364 },
+ { "vmm_ch0805", 0x00000368 },
+ { "vmm_ch0806", 0x0000036c },
+ { "vmm_ch0807", 0x00000370 },
+ { "vmm_ch0808", 0x00000374 },
+ { "vmm_ch0809", 0x00000378 },
+ { "vmm_ch0900", 0x0000037c },
+ { "vmm_ch0901", 0x00000380 },
+ { "vmm_ch0902", 0x00000384 },
+ { "vmm_ch0903", 0x00000388 },
+ { "vmm_ch0904", 0x0000038c },
+ { "vmm_ch0905", 0x00000390 },
+ { "vmm_ch0906", 0x00000394 },
+ { "vmm_ch0907", 0x00000398 },
+ { "vmm_ch0908", 0x0000039c },
+ { "vmm_ch0909", 0x000003a0 },
+ { "vmm_ch1000", 0x000003a4 },
+ { "vmm_ch1001", 0x000003a8 },
+ { "vmm_ch1002", 0x000003ac },
+ { "vmm_ch1003", 0x000003b0 },
+ { "vmm_ch1004", 0x000003b4 },
+ { "vmm_ch1005", 0x000003b8 },
+ { "vmm_ch1006", 0x000003bc },
+ { "vmm_ch1007", 0x000003c0 },
+ { "vmm_ch1008", 0x000003c4 },
+ { "vmm_ch1009", 0x000003c8 },
+ { "vmm_ch1100", 0x000003cc },
+ { "vmm_ch1101", 0x000003d0 },
+ { "vmm_ch1102", 0x000003d4 },
+ { "vmm_ch1103", 0x000003d8 },
+ { "vmm_ch1104", 0x000003dc },
+ { "vmm_ch1105", 0x000003e0 },
+ { "vmm_ch1106", 0x000003e4 },
+ { "vmm_ch1107", 0x000003e8 },
+ { "vmm_ch1108", 0x000003ec },
+ { "vmm_ch1109", 0x000003f0 },
+ { "vmm_ch1200", 0x000003f4 },
+ { "vmm_ch1201", 0x000003f8 },
+ { "vmm_ch1202", 0x000003fc },
+ { "vmm_ch1203", 0x00000400 },
+ { "vmm_ch1204", 0x00000404 },
+ { "vmm_ch1205", 0x00000408 },
+ { "vmm_ch1206", 0x0000040c },
+ { "vmm_ch1207", 0x00000410 },
+ { "vmm_ch1208", 0x00000414 },
+ { "vmm_ch1209", 0x00000418 },
+ { "vmm_ch1300", 0x0000041c },
+ { "vmm_ch1301", 0x00000420 },
+ { "vmm_ch1302", 0x00000424 },
+ { "vmm_ch1303", 0x00000428 },
+ { "vmm_ch1304", 0x0000042c },
+ { "vmm_ch1305", 0x00000430 },
+ { "vmm_ch1306", 0x00000434 },
+ { "vmm_ch1307", 0x00000438 },
+ { "vmm_ch1308", 0x0000043c },
+ { "vmm_ch1309", 0x00000440 },
+ { "vmm_ch1400", 0x00000444 },
+ { "vmm_ch1401", 0x00000448 },
+ { "vmm_ch1402", 0x0000044c },
+ { "vmm_ch1403", 0x00000450 },
+ { "vmm_ch1404", 0x00000454 },
+ { "vmm_ch1405", 0x00000458 },
+ { "vmm_ch1406", 0x0000045c },
+ { "vmm_ch1407", 0x00000460 },
+ { "vmm_ch1408", 0x00000464 },
+ { "vmm_ch1409", 0x00000468 },
+ { "vmm_ch1500", 0x0000046c },
+ { "vmm_ch1501", 0x00000470 },
+ { "vmm_ch1502", 0x00000474 },
+ { "vmm_ch1503", 0x00000478 },
+ { "vmm_ch1504", 0x0000047c },
+ { "vmm_ch1505", 0x00000480 },
+ { "vmm_ch1506", 0x00000484 },
+ { "vmm_ch1507", 0x00000488 },
+ { "vmm_ch1508", 0x0000048c },
+ { "vmm_ch1509", 0x00000490 },
+ { "vmm_ch1600", 0x00000494 },
+ { "vmm_ch1601", 0x00000498 },
+ { "vmm_ch1602", 0x0000049c },
+ { "vmm_ch1603", 0x000004a0 },
+ { "vmm_ch1604", 0x000004a4 },
+ { "vmm_ch1605", 0x000004a8 },
+ { "vmm_ch1606", 0x000004ac },
+ { "vmm_ch1607", 0x000004b0 },
+ { "vmm_ch1608", 0x000004b4 },
+ { "vmm_ch1609", 0x000004b8 },
+ { "vmm_ch1700", 0x000004bc },
+ { "vmm_ch1701", 0x000004c0 },
+ { "vmm_ch1702", 0x000004c4 },
+ { "vmm_ch1703", 0x000004c8 },
+ { "vmm_ch1704", 0x000004cc },
+ { "vmm_ch1705", 0x000004d0 },
+ { "vmm_ch1706", 0x000004d4 },
+ { "vmm_ch1707", 0x000004d8 },
+ { "vmm_ch1708", 0x000004dc },
+ { "vmm_ch1709", 0x000004e0 },
+ { "vmm_ch1800", 0x000004e4 },
+ { "vmm_ch1801", 0x000004e8 },
+ { "vmm_ch1802", 0x000004ec },
+ { "vmm_ch1803", 0x000004f0 },
+ { "vmm_ch1804", 0x000004f4 },
+ { "vmm_ch1805", 0x000004f8 },
+ { "vmm_ch1806", 0x000004fc },
+ { "vmm_ch1807", 0x00000500 },
+ { "vmm_ch1808", 0x00000504 },
+ { "vmm_ch1809", 0x00000508 },
+ { "vmm_ch1900", 0x0000050c },
+ { "vmm_ch1901", 0x00000510 },
+ { "vmm_ch1902", 0x00000514 },
+ { "vmm_ch1903", 0x00000518 },
+ { "vmm_ch1904", 0x0000051c },
+ { "vmm_ch1905", 0x00000520 },
+ { "vmm_ch1906", 0x00000524 },
+ { "vmm_ch1907", 0x00000528 },
+ { "vmm_ch1908", 0x0000052c },
+ { "vmm_ch1909", 0x00000530 },
+ { "vmm_ch2000", 0x00000534 },
+ { "vmm_ch2001", 0x00000538 },
+ { "vmm_ch2002", 0x0000053c },
+ { "vmm_ch2003", 0x00000540 },
+ { "vmm_ch2004", 0x00000544 },
+ { "vmm_ch2005", 0x00000548 },
+ { "vmm_ch2006", 0x0000054c },
+ { "vmm_ch2007", 0x00000550 },
+ { "vmm_ch2008", 0x00000554 },
+ { "vmm_ch2009", 0x00000558 },
+ { "vmm_ch2100", 0x0000055c },
+ { "vmm_ch2101", 0x00000560 },
+ { "vmm_ch2102", 0x00000564 },
+ { "vmm_ch2103", 0x00000568 },
+ { "vmm_ch2104", 0x0000056c },
+ { "vmm_ch2105", 0x00000570 },
+ { "vmm_ch2106", 0x00000574 },
+ { "vmm_ch2107", 0x00000578 },
+ { "vmm_ch2108", 0x0000057c },
+ { "vmm_ch2109", 0x00000580 },
+ { "vmm_ch2200", 0x00000584 },
+ { "vmm_ch2201", 0x00000588 },
+ { "vmm_ch2202", 0x0000058c },
+ { "vmm_ch2203", 0x00000590 },
+ { "vmm_ch2204", 0x00000594 },
+ { "vmm_ch2205", 0x00000598 },
+ { "vmm_ch2206", 0x0000059c },
+ { "vmm_ch2207", 0x000005a0 },
+ { "vmm_ch2208", 0x000005a4 },
+ { "vmm_ch2209", 0x000005a8 },
+ { "vmm_ch2300", 0x000005ac },
+ { "vmm_ch2301", 0x000005b0 },
+ { "vmm_ch2302", 0x000005b4 },
+ { "vmm_ch2303", 0x000005b8 },
+ { "vmm_ch2304", 0x000005bc },
+ { "vmm_ch2305", 0x000005c0 },
+ { "vmm_ch2306", 0x000005c4 },
+ { "vmm_ch2307", 0x000005c8 },
+ { "vmm_ch2308", 0x000005cc },
+ { "vmm_ch2309", 0x000005d0 },
+ { "vmm_ch2400", 0x000005d4 },
+ { "vmm_ch2401", 0x000005d8 },
+ { "vmm_ch2402", 0x000005dc },
+ { "vmm_ch2403", 0x000005e0 },
+ { "vmm_ch2404", 0x000005e4 },
+ { "vmm_ch2405", 0x000005e8 },
+ { "vmm_ch2406", 0x000005ec },
+ { "vmm_ch2407", 0x000005f0 },
+ { "vmm_ch2408", 0x000005f4 },
+ { "vmm_ch2409", 0x000005f8 },
+ { "vmm_ch2500", 0x000005fc },
+ { "vmm_ch2501", 0x00000600 },
+ { "vmm_ch2502", 0x00000604 },
+ { "vmm_ch2503", 0x00000608 },
+ { "vmm_ch2504", 0x0000060c },
+ { "vmm_ch2505", 0x00000610 },
+ { "vmm_ch2506", 0x00000614 },
+ { "vmm_ch2507", 0x00000618 },
+ { "vmm_ch2508", 0x0000061c },
+ { "vmm_ch2509", 0x00000620 },
+ { "vmm_ch2600", 0x00000624 },
+ { "vmm_ch2601", 0x00000628 },
+ { "vmm_ch2602", 0x0000062c },
+ { "vmm_ch2603", 0x00000630 },
+ { "vmm_ch2604", 0x00000634 },
+ { "vmm_ch2605", 0x00000638 },
+ { "vmm_ch2606", 0x0000063c },
+ { "vmm_ch2607", 0x00000640 },
+ { "vmm_ch2608", 0x00000644 },
+ { "vmm_ch2609", 0x00000648 },
+ { "vmm_ch2700", 0x0000064c },
+ { "vmm_ch2701", 0x00000650 },
+ { "vmm_ch2702", 0x00000654 },
+ { "vmm_ch2703", 0x00000658 },
+ { "vmm_ch2704", 0x0000065c },
+ { "vmm_ch2705", 0x00000660 },
+ { "vmm_ch2706", 0x00000664 },
+ { "vmm_ch2707", 0x00000668 },
+ { "vmm_ch2708", 0x0000066c },
+ { "vmm_ch2709", 0x00000670 },
+ { "vmm_ch2800", 0x00000674 },
+ { "vmm_ch2801", 0x00000678 },
+ { "vmm_ch2802", 0x0000067c },
+ { "vmm_ch2803", 0x00000680 },
+ { "vmm_ch2804", 0x00000684 },
+ { "vmm_ch2805", 0x00000688 },
+ { "vmm_ch2806", 0x0000068c },
+ { "vmm_ch2807", 0x00000690 },
+ { "vmm_ch2808", 0x00000694 },
+ { "vmm_ch2809", 0x00000698 },
+ { "vmm_ch2900", 0x0000069c },
+ { "vmm_ch2901", 0x000006a0 },
+ { "vmm_ch2902", 0x000006a4 },
+ { "vmm_ch2903", 0x000006a8 },
+ { "vmm_ch2904", 0x000006ac },
+ { "vmm_ch2905", 0x000006b0 },
+ { "vmm_ch2906", 0x000006b4 },
+ { "vmm_ch2907", 0x000006b8 },
+ { "vmm_ch2908", 0x000006bc },
+ { "vmm_ch2909", 0x000006c0 },
+ { "vmm_ch3000", 0x000006c4 },
+ { "vmm_ch3001", 0x000006c8 },
+ { "vmm_ch3002", 0x000006cc },
+ { "vmm_ch3003", 0x000006d0 },
+ { "vmm_ch3004", 0x000006d4 },
+ { "vmm_ch3005", 0x000006d8 },
+ { "vmm_ch3006", 0x000006dc },
+ { "vmm_ch3007", 0x000006e0 },
+ { "vmm_ch3008", 0x000006e4 },
+ { "vmm_ch3009", 0x000006e8 },
+ { "vmm_ch3100", 0x000006ec },
+ { "vmm_ch3101", 0x000006f0 },
+ { "vmm_ch3102", 0x000006f4 },
+ { "vmm_ch3103", 0x000006f8 },
+ { "vmm_ch3104", 0x000006fc },
+ { "vmm_ch3105", 0x00000700 },
+ { "vmm_ch3106", 0x00000704 },
+ { "vmm_ch3107", 0x00000708 },
+ { "vmm_ch3108", 0x0000070c },
+ { "vmm_ch3109", 0x00000710 },
+ { "vmm_ch3200", 0x00000714 },
+ { "vmm_ch3201", 0x00000718 },
+ { "vmm_ch3202", 0x0000071c },
+ { "vmm_ch3203", 0x00000720 },
+ { "vmm_ch3204", 0x00000724 },
+ { "vmm_ch3205", 0x00000728 },
+ { "vmm_ch3206", 0x0000072c },
+ { "vmm_ch3207", 0x00000730 },
+ { "vmm_ch3208", 0x00000734 },
+ { "vmm_ch3209", 0x00000738 },
+ { "vmm_ch3300", 0x0000073c },
+ { "vmm_ch3301", 0x00000740 },
+ { "vmm_ch3302", 0x00000744 },
+ { "vmm_ch3303", 0x00000748 },
+ { "vmm_ch3304", 0x0000074c },
+ { "vmm_ch3305", 0x00000750 },
+ { "vmm_ch3306", 0x00000754 },
+ { "vmm_ch3307", 0x00000758 },
+ { "vmm_ch3308", 0x0000075c },
+ { "vmm_ch3309", 0x00000760 },
+ { "vmm_ch3400", 0x00000764 },
+ { "vmm_ch3401", 0x00000768 },
+ { "vmm_ch3402", 0x0000076c },
+ { "vmm_ch3403", 0x00000770 },
+ { "vmm_ch3404", 0x00000774 },
+ { "vmm_ch3405", 0x00000778 },
+ { "vmm_ch3406", 0x0000077c },
+ { "vmm_ch3407", 0x00000780 },
+ { "vmm_ch3408", 0x00000784 },
+ { "vmm_ch3409", 0x00000788 },
+ { "vmm_ch3500", 0x0000078c },
+ { "vmm_ch3501", 0x00000790 },
+ { "vmm_ch3502", 0x00000794 },
+ { "vmm_ch3503", 0x00000798 },
+ { "vmm_ch3504", 0x0000079c },
+ { "vmm_ch3505", 0x000007a0 },
+ { "vmm_ch3506", 0x000007a4 },
+ { "vmm_ch3507", 0x000007a8 },
+ { "vmm_ch3508", 0x000007ac },
+ { "vmm_ch3509", 0x000007b0 },
+ { "vmm_ch3600", 0x000007b4 },
+ { "vmm_ch3601", 0x000007b8 },
+ { "vmm_ch3602", 0x000007bc },
+ { "vmm_ch3603", 0x000007c0 },
+ { "vmm_ch3604", 0x000007c4 },
+ { "vmm_ch3605", 0x000007c8 },
+ { "vmm_ch3606", 0x000007cc },
+ { "vmm_ch3607", 0x000007d0 },
+ { "vmm_ch3608", 0x000007d4 },
+ { "vmm_ch3609", 0x000007d8 },
+ { "vmm_ch3700", 0x000007dc },
+ { "vmm_ch3701", 0x000007e0 },
+ { "vmm_ch3702", 0x000007e4 },
+ { "vmm_ch3703", 0x000007e8 },
+ { "vmm_ch3704", 0x000007ec },
+ { "vmm_ch3705", 0x000007f0 },
+ { "vmm_ch3706", 0x000007f4 },
+ { "vmm_ch3707", 0x000007f8 },
+ { "vmm_ch3708", 0x000007fc },
+ { "vmm_ch3709", 0x00000800 },
+ { "vmm_ch3800", 0x00000804 },
+ { "vmm_ch3801", 0x00000808 },
+ { "vmm_ch3802", 0x0000080c },
+ { "vmm_ch3803", 0x00000810 },
+ { "vmm_ch3804", 0x00000814 },
+ { "vmm_ch3805", 0x00000818 },
+ { "vmm_ch3806", 0x0000081c },
+ { "vmm_ch3807", 0x00000820 },
+ { "vmm_ch3808", 0x00000824 },
+ { "vmm_ch3809", 0x00000828 },
+ { "vmm_ch3900", 0x0000082c },
+ { "vmm_ch3901", 0x00000830 },
+ { "vmm_ch3902", 0x00000834 },
+ { "vmm_ch3903", 0x00000838 },
+ { "vmm_ch3904", 0x0000083c },
+ { "vmm_ch3905", 0x00000840 },
+ { "vmm_ch3906", 0x00000844 },
+ { "vmm_ch3907", 0x00000848 },
+ { "vmm_ch3908", 0x0000084c },
+ { "vmm_ch3909", 0x00000850 },
+ { "vmm_ch4000", 0x00000854 },
+ { "vmm_ch4001", 0x00000858 },
+ { "vmm_ch4002", 0x0000085c },
+ { "vmm_ch4003", 0x00000860 },
+ { "vmm_ch4004", 0x00000864 },
+ { "vmm_ch4005", 0x00000868 },
+ { "vmm_ch4006", 0x0000086c },
+ { "vmm_ch4007", 0x00000870 },
+ { "vmm_ch4008", 0x00000874 },
+ { "vmm_ch4009", 0x00000878 },
+ { "vmm_ch4100", 0x0000087c },
+ { "vmm_ch4101", 0x00000880 },
+ { "vmm_ch4102", 0x00000884 },
+ { "vmm_ch4103", 0x00000888 },
+ { "vmm_ch4104", 0x0000088c },
+ { "vmm_ch4105", 0x00000890 },
+ { "vmm_ch4106", 0x00000894 },
+ { "vmm_ch4107", 0x00000898 },
+ { "vmm_ch4108", 0x0000089c },
+ { "vmm_ch4109", 0x000008a0 },
+ { "vmm_ch4200", 0x000008a4 },
+ { "vmm_ch4201", 0x000008a8 },
+ { "vmm_ch4202", 0x000008ac },
+ { "vmm_ch4203", 0x000008b0 },
+ { "vmm_ch4204", 0x000008b4 },
+ { "vmm_ch4205", 0x000008b8 },
+ { "vmm_ch4206", 0x000008bc },
+ { "vmm_ch4207", 0x000008c0 },
+ { "vmm_ch4208", 0x000008c4 },
+ { "vmm_ch4209", 0x000008c8 },
+ { "vmm_ch4300", 0x000008cc },
+ { "vmm_ch4301", 0x000008d0 },
+ { "vmm_ch4302", 0x000008d4 },
+ { "vmm_ch4303", 0x000008d8 },
+ { "vmm_ch4304", 0x000008dc },
+ { "vmm_ch4305", 0x000008e0 },
+ { "vmm_ch4306", 0x000008e4 },
+ { "vmm_ch4307", 0x000008e8 },
+ { "vmm_ch4308", 0x000008ec },
+ { "vmm_ch4309", 0x000008f0 },
+ { "vmm_ch4400", 0x000008f4 },
+ { "vmm_ch4401", 0x000008f8 },
+ { "vmm_ch4402", 0x000008fc },
+ { "vmm_ch4403", 0x00000900 },
+ { "vmm_ch4404", 0x00000904 },
+ { "vmm_ch4405", 0x00000908 },
+ { "vmm_ch4406", 0x0000090c },
+ { "vmm_ch4407", 0x00000910 },
+ { "vmm_ch4408", 0x00000914 },
+ { "vmm_ch4409", 0x00000918 },
+ { "vmm_ch4500", 0x0000091c },
+ { "vmm_ch4501", 0x00000920 },
+ { "vmm_ch4502", 0x00000924 },
+ { "vmm_ch4503", 0x00000928 },
+ { "vmm_ch4504", 0x0000092c },
+ { "vmm_ch4505", 0x00000930 },
+ { "vmm_ch4506", 0x00000934 },
+ { "vmm_ch4507", 0x00000938 },
+ { "vmm_ch4508", 0x0000093c },
+ { "vmm_ch4509", 0x00000940 },
+ { "vmm_ch4600", 0x00000944 },
+ { "vmm_ch4601", 0x00000948 },
+ { "vmm_ch4602", 0x0000094c },
+ { "vmm_ch4603", 0x00000950 },
+ { "vmm_ch4604", 0x00000954 },
+ { "vmm_ch4605", 0x00000958 },
+ { "vmm_ch4606", 0x0000095c },
+ { "vmm_ch4607", 0x00000960 },
+ { "vmm_ch4608", 0x00000964 },
+ { "vmm_ch4609", 0x00000968 },
+ { "vmm_ch4700", 0x0000096c },
+ { "vmm_ch4701", 0x00000970 },
+ { "vmm_ch4702", 0x00000974 },
+ { "vmm_ch4703", 0x00000978 },
+ { "vmm_ch4704", 0x0000097c },
+ { "vmm_ch4705", 0x00000980 },
+ { "vmm_ch4706", 0x00000984 },
+ { "vmm_ch4707", 0x00000988 },
+ { "vmm_ch4708", 0x0000098c },
+ { "vmm_ch4709", 0x00000990 },
+ { "vmm_ch4800", 0x00000994 },
+ { "vmm_ch4801", 0x00000998 },
+ { "vmm_ch4802", 0x0000099c },
+ { "vmm_ch4803", 0x000009a0 },
+ { "vmm_ch4804", 0x000009a4 },
+ { "vmm_ch4805", 0x000009a8 },
+ { "vmm_ch4806", 0x000009ac },
+ { "vmm_ch4807", 0x000009b0 },
+ { "vmm_ch4808", 0x000009b4 },
+ { "vmm_ch4809", 0x000009b8 },
+ { "vmm_ch4900", 0x000009bc },
+ { "vmm_ch4901", 0x000009c0 },
+ { "vmm_ch4902", 0x000009c4 },
+ { "vmm_ch4903", 0x000009c8 },
+ { "vmm_ch4904", 0x000009cc },
+ { "vmm_ch4905", 0x000009d0 },
+ { "vmm_ch4906", 0x000009d4 },
+ { "vmm_ch4907", 0x000009d8 },
+ { "vmm_ch4908", 0x000009dc },
+ { "vmm_ch4909", 0x000009e0 },
+ { "vmm_ch5000", 0x000009e4 },
+ { "vmm_ch5001", 0x000009e8 },
+ { "vmm_ch5002", 0x000009ec },
+ { "vmm_ch5003", 0x000009f0 },
+ { "vmm_ch5004", 0x000009f4 },
+ { "vmm_ch5005", 0x000009f8 },
+ { "vmm_ch5006", 0x000009fc },
+ { "vmm_ch5007", 0x00000a00 },
+ { "vmm_ch5008", 0x00000a04 },
+ { "vmm_ch5009", 0x00000a08 },
+ { "vmm_ch5100", 0x00000a0c },
+ { "vmm_ch5101", 0x00000a10 },
+ { "vmm_ch5102", 0x00000a14 },
+ { "vmm_ch5103", 0x00000a18 },
+ { "vmm_ch5104", 0x00000a1c },
+ { "vmm_ch5105", 0x00000a20 },
+ { "vmm_ch5106", 0x00000a24 },
+ { "vmm_ch5107", 0x00000a28 },
+ { "vmm_ch5108", 0x00000a2c },
+ { "vmm_ch5109", 0x00000a30 },
+ { "vmm_ch5200", 0x00000a34 },
+ { "vmm_ch5201", 0x00000a38 },
+ { "vmm_ch5202", 0x00000a3c },
+ { "vmm_ch5203", 0x00000a40 },
+ { "vmm_ch5204", 0x00000a44 },
+ { "vmm_ch5205", 0x00000a48 },
+ { "vmm_ch5206", 0x00000a4c },
+ { "vmm_ch5207", 0x00000a50 },
+ { "vmm_ch5208", 0x00000a54 },
+ { "vmm_ch5209", 0x00000a58 },
+ { "vmm_ch5300", 0x00000a5c },
+ { "vmm_ch5301", 0x00000a60 },
+ { "vmm_ch5302", 0x00000a64 },
+ { "vmm_ch5303", 0x00000a68 },
+ { "vmm_ch5304", 0x00000a6c },
+ { "vmm_ch5305", 0x00000a70 },
+ { "vmm_ch5306", 0x00000a74 },
+ { "vmm_ch5307", 0x00000a78 },
+ { "vmm_ch5308", 0x00000a7c },
+ { "vmm_ch5309", 0x00000a80 },
+ { "vmm_ch5400", 0x00000a84 },
+ { "vmm_ch5401", 0x00000a88 },
+ { "vmm_ch5402", 0x00000a8c },
+ { "vmm_ch5403", 0x00000a90 },
+ { "vmm_ch5404", 0x00000a94 },
+ { "vmm_ch5405", 0x00000a98 },
+ { "vmm_ch5406", 0x00000a9c },
+ { "vmm_ch5407", 0x00000aa0 },
+ { "vmm_ch5408", 0x00000aa4 },
+ { "vmm_ch5409", 0x00000aa8 },
+ { "vmm_ch5500", 0x00000aac },
+ { "vmm_ch5501", 0x00000ab0 },
+ { "vmm_ch5502", 0x00000ab4 },
+ { "vmm_ch5503", 0x00000ab8 },
+ { "vmm_ch5504", 0x00000abc },
+ { "vmm_ch5505", 0x00000ac0 },
+ { "vmm_ch5506", 0x00000ac4 },
+ { "vmm_ch5507", 0x00000ac8 },
+ { "vmm_ch5508", 0x00000acc },
+ { "vmm_ch5509", 0x00000ad0 },
+ { "vmm_ch5600", 0x00000ad4 },
+ { "vmm_ch5601", 0x00000ad8 },
+ { "vmm_ch5602", 0x00000adc },
+ { "vmm_ch5603", 0x00000ae0 },
+ { "vmm_ch5604", 0x00000ae4 },
+ { "vmm_ch5605", 0x00000ae8 },
+ { "vmm_ch5606", 0x00000aec },
+ { "vmm_ch5607", 0x00000af0 },
+ { "vmm_ch5608", 0x00000af4 },
+ { "vmm_ch5609", 0x00000af8 },
+ { "vmm_ch5700", 0x00000afc },
+ { "vmm_ch5701", 0x00000b00 },
+ { "vmm_ch5702", 0x00000b04 },
+ { "vmm_ch5703", 0x00000b08 },
+ { "vmm_ch5704", 0x00000b0c },
+ { "vmm_ch5705", 0x00000b10 },
+ { "vmm_ch5706", 0x00000b14 },
+ { "vmm_ch5707", 0x00000b18 },
+ { "vmm_ch5708", 0x00000b1c },
+ { "vmm_ch5709", 0x00000b20 },
+ { "vmm_ch5800", 0x00000b24 },
+ { "vmm_ch5801", 0x00000b28 },
+ { "vmm_ch5802", 0x00000b2c },
+ { "vmm_ch5803", 0x00000b30 },
+ { "vmm_ch5804", 0x00000b34 },
+ { "vmm_ch5805", 0x00000b38 },
+ { "vmm_ch5806", 0x00000b3c },
+ { "vmm_ch5807", 0x00000b40 },
+ { "vmm_ch5808", 0x00000b44 },
+ { "vmm_ch5809", 0x00000b48 },
+ { "vmm_ch5900", 0x00000b4c },
+ { "vmm_ch5901", 0x00000b50 },
+ { "vmm_ch5902", 0x00000b54 },
+ { "vmm_ch5903", 0x00000b58 },
+ { "vmm_ch5904", 0x00000b5c },
+ { "vmm_ch5905", 0x00000b60 },
+ { "vmm_ch5906", 0x00000b64 },
+ { "vmm_ch5907", 0x00000b68 },
+ { "vmm_ch5908", 0x00000b6c },
+ { "vmm_ch5909", 0x00000b70 },
+ { "vmm_ch6000", 0x00000b74 },
+ { "vmm_ch6001", 0x00000b78 },
+ { "vmm_ch6002", 0x00000b7c },
+ { "vmm_ch6003", 0x00000b80 },
+ { "vmm_ch6004", 0x00000b84 },
+ { "vmm_ch6005", 0x00000b88 },
+ { "vmm_ch6006", 0x00000b8c },
+ { "vmm_ch6007", 0x00000b90 },
+ { "vmm_ch6008", 0x00000b94 },
+ { "vmm_ch6009", 0x00000b98 },
+ { "vmm_ch6100", 0x00000b9c },
+ { "vmm_ch6101", 0x00000ba0 },
+ { "vmm_ch6102", 0x00000ba4 },
+ { "vmm_ch6103", 0x00000ba8 },
+ { "vmm_ch6104", 0x00000bac },
+ { "vmm_ch6105", 0x00000bb0 },
+ { "vmm_ch6106", 0x00000bb4 },
+ { "vmm_ch6107", 0x00000bb8 },
+ { "vmm_ch6108", 0x00000bbc },
+ { "vmm_ch6109", 0x00000bc0 },
+ { "vmm_ch6200", 0x00000bc4 },
+ { "vmm_ch6201", 0x00000bc8 },
+ { "vmm_ch6202", 0x00000bcc },
+ { "vmm_ch6203", 0x00000bd0 },
+ { "vmm_ch6204", 0x00000bd4 },
+ { "vmm_ch6205", 0x00000bd8 },
+ { "vmm_ch6206", 0x00000bdc },
+ { "vmm_ch6207", 0x00000be0 },
+ { "vmm_ch6208", 0x00000be4 },
+ { "vmm_ch6209", 0x00000be8 },
+ { "vmm_ch6300", 0x00000bec },
+ { "vmm_ch6301", 0x00000bf0 },
+ { "vmm_ch6302", 0x00000bf4 },
+ { "vmm_ch6303", 0x00000bf8 },
+ { "vmm_ch6304", 0x00000bfc },
+ { "vmm_ch6305", 0x00000c00 },
+ { "vmm_ch6306", 0x00000c04 },
+ { "vmm_ch6307", 0x00000c08 },
+ { "vmm_ch6308", 0x00000c0c },
+ { "vmm_ch6309", 0x00000c10 },
+ { "vmm_global_bank1_sp000", 0x00000c14 },
+ { "vmm_global_bank1_sp001", 0x00000c18 },
+ { "vmm_global_bank1_sp002", 0x00000c1c },
+ { "vmm_global_bank1_sp003", 0x00000c20 },
+ { "vmm_global_bank1_sp004", 0x00000c24 },
+ { "vmm_global_bank1_sp005", 0x00000c28 },
+ { "vmm_global_bank1_sp006", 0x00000c2c },
+ { "vmm_global_bank1_sp007", 0x00000c30 },
+ { "vmm_global_bank1_sp008", 0x00000c34 },
+ { "vmm_global_bank1_sp009", 0x00000c38 },
+ { "vmm_global_bank1_sp100", 0x00000c3c },
+ { "vmm_global_bank1_sp101", 0x00000c40 },
+ { "vmm_global_bank1_sp102", 0x00000c44 },
+ { "vmm_global_bank1_sp103", 0x00000c48 },
+ { "vmm_global_bank1_sp104", 0x00000c4c },
+ { "vmm_global_bank1_sp105", 0x00000c50 },
+ { "vmm_global_bank1_sp106", 0x00000c54 },
+ { "vmm_global_bank1_sp107", 0x00000c58 },
+ { "vmm_global_bank1_sp108", 0x00000c5c },
+ { "vmm_global_bank1_sp109", 0x00000c60 },
+ { "vmm_global_bank1_sp200", 0x00000c64 },
+ { "vmm_global_bank1_sp201", 0x00000c68 },
+ { "vmm_global_bank1_sp202", 0x00000c6c },
+ { "vmm_global_bank1_sp203", 0x00000c70 },
+ { "vmm_global_bank1_sp204", 0x00000c74 },
+ { "vmm_global_bank1_sp205", 0x00000c78 },
+ { "vmm_global_bank1_sp206", 0x00000c7c },
+ { "vmm_global_bank1_sp207", 0x00000c80 },
+ { "vmm_global_bank1_sp208", 0x00000c84 },
+ { "vmm_global_bank1_sp209", 0x00000c88 }
};