00001 #include <CommonWithDsp/sctStructure.h>
00002 #include <ABCD/ABCDscans.h>
00003 #include <ABCD/ABCDchip.h>
00004 #include "extraScans.h"
00005 #include "SctApiFwd.h"
00006
00007 #include <iostream>
00008
00009 namespace SctApi{
00011 class ConfigUtility{
00012 public:
00017 static unsigned diff(const ABCDBasic& first, const ABCDBasic& second);
00022 static unsigned diff(const ABCDConfig& first, const ABCDConfig& second);
00027 static unsigned diff(const ABCDCaldata& first, const ABCDCaldata& second);
00032 static unsigned diff(const ABCDChip& first, const ABCDChip& second);
00037 static unsigned diff(const ABCDModule& first, const ABCDModule& second);
00041 static std::auto_ptr<ABCDModule> clone(const ABCDModule& first);
00045 static std::auto_ptr<ABCDBasic> clone(const ABCDBasic& first);
00046
00050 static void modifyVar(ABCDModule* module, UINT32 typ, FLOAT32 val);
00054 static void modifyVar(ABCDModule* module, unsigned chip, UINT32 typ, FLOAT32 val);
00055
00059 static bool isBOCRegister(UINT32 typ);
00060
00061 enum ConfigVarType {
00062 BOC_CHANNEL_CONFIG_VAR, BOC_GLOBAL_CONFIG_VAR,
00063 MODULE_GLOBAL_CONFIG_VAR, MODULE_CHIP_CONFIG_VAR, MODULE_CHANNEL_CONFIG_VAR,
00064 UNKNOWN_CONFIG_VAR
00065 };
00066
00070 static ConfigVarType variableType(UINT32 typ);
00071 private:
00072 static ConfigUtility& ConfigUtility::instance();
00073 ConfigUtility();
00074 UINT16 config_compare_mask;
00075 static void setToken(ABCDModule* module, unsigned token, int link0, int link1);
00076 static INT32 ConfigUtility::setChipRole(ABCDModule *module, UINT32 theChip, ABCD_ROLES role);
00077 };
00078
00079 inline std::auto_ptr<ABCDModule> ConfigUtility::clone(const ABCDModule& first){
00080 std::auto_ptr<ABCDModule> m (new ABCDModule);
00081 const size_t size=sizeof(ABCDModule);
00082 memcpy(m.get(), &first, size);
00083 return m;
00084 }
00085
00086 inline std::auto_ptr<ABCDBasic> ConfigUtility::clone(const ABCDBasic& first){
00087 std::auto_ptr<ABCDBasic> a (new ABCDBasic);
00088 const size_t size=sizeof(ABCDBasic);
00089 memcpy(a.get(), &first, size);
00090 return a;
00091 }
00092
00093 inline
00094 ConfigUtility::ConfigUtility(){
00095 config_compare_mask=0xffff;
00096 reinterpret_cast<ABCDConfig*>(&config_compare_mask)->padding=0;
00097 }
00098
00099 inline
00100 ConfigUtility& ConfigUtility::instance(){
00101 static ConfigUtility config;
00102 return config;
00103 }
00104
00105
00106 inline unsigned ConfigUtility::diff(const ABCDConfig& first, const ABCDConfig& second){
00107 unsigned diff_bits=SCTAPI_CONFIG_NONE;
00108 const UINT16* p=reinterpret_cast<const UINT16*>(&first);
00109 const UINT16* q=reinterpret_cast<const UINT16*>(&second);
00110 const UINT16& cfg_mask=instance().config_compare_mask;
00111
00112 UINT16 cfgdiff = *p^*q;
00113 cfgdiff &= cfg_mask;
00114 if (cfgdiff) {
00115 diff_bits |= 1<<SCTAPI_CONFIG_CFG;
00116 }
00117 return diff_bits;
00118 }
00119
00120 inline unsigned ConfigUtility::diff(const ABCDBasic& first, const ABCDBasic& second){
00121 unsigned diff_bits=diff(first.config, second.config);
00122
00123 if (first.vthr!=second.vthr || first.vcal!=second.vcal ||
00124 first.delay!=second.delay || first.preamp!=second.preamp ||
00125 first.shaper!=second.shaper) diff_bits|=1<<SCTAPI_CONFIG_BASIC;
00126
00127 for (unsigned i=0; i<4; ++i){
00128 if (first.mask[i]!=second.mask[i]) diff_bits|=1<<SCTAPI_CONFIG_MASK;
00129 }
00130 return diff_bits;
00131 }
00132
00133 inline unsigned ConfigUtility::diff(const ABCDCaldata& first, const ABCDCaldata& second){
00134 unsigned diff_bits=SCTAPI_CONFIG_NONE;
00135
00136 if (first.rc_function!=second.rc_function ||
00137 first.c_factor!=second.c_factor) diff_bits |= 1<<SCTAPI_CONFIG_OTHER;
00138
00139 for (unsigned i=0; i<3; ++i){
00140 if (first.rc_params[i]!=second.rc_params[i]) diff_bits |= 1<< SCTAPI_CONFIG_OTHER;
00141 }
00142
00143 return diff_bits;
00144 }
00145
00146 inline unsigned ConfigUtility::diff(const ABCDChip& first, const ABCDChip& second){
00147 unsigned diff_bits=SCTAPI_CONFIG_NONE;
00148
00149 diff_bits |= diff(first.basic, second.basic);
00150 diff_bits |= diff(first.caldata, second.caldata);
00151
00152 for (unsigned i=0; i<N_SCT_CHANS; ++i){
00153 if (first.trim[i]!=second.trim[i]) diff_bits |= 1<<SCTAPI_CONFIG_TRIM;
00154 }
00155
00156 if (first.active!=second.active ||
00157 first.address!=second.address ||
00158 first.target!=second.target ) diff_bits |= 1<<SCTAPI_CONFIG_OTHER;
00159 return diff_bits;
00160 }
00161
00162 inline unsigned ConfigUtility::diff(const ABCDModule& first, const ABCDModule& second){
00163 unsigned diff_bits=SCTAPI_CONFIG_NONE;
00164
00165 for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
00166 diff_bits |= diff(first.chip[ichip], second.chip[ichip]);
00167 }
00168
00169 if (first.present!=second.present || first.active!=second.active ||
00170 first.select!=second.select || first.groupId!=second.groupId ||
00171 first.pTTC!=second.pTTC || first.rTTC!=second.rTTC ||
00172 first.rx[1]!=second.rx[1] || first.rx[2]!=second.rx[2]) {
00173 diff_bits |= 1<<SCTAPI_CONFIG_OTHER;
00174 }
00175 return diff_bits;
00176 }
00177
00178
00179 inline bool ConfigUtility::isBOCRegister(UINT32 typ){
00180 switch(typ) {
00181 case ST_RX_DELAY:
00182 case ST_RX_DELAY0:
00183 case ST_RX_DELAY1:
00184 case ST_RX_THRESHOLD:
00185 case ST_RX_THRESHOLD0:
00186 case ST_RX_THRESHOLD1:
00187 case ST_TX_CURRENT:
00188 case ST_TX_MARKSPACE:
00189 case ST_TX_DELAY:
00190 case ST_TX_COARSE:
00191 case ST_TX_FINE:
00192 case SCT_SCAN_BOC_BPM_PHASE:
00193 case SCT_SCAN_BOC_BREG_PHASE:
00194 case SCT_SCAN_BOC_V0_PHASE:
00195 case SCT_SCAN_BOC_V1_PHASE:
00196 case SCT_SCAN_BOC_V_PHASES:
00197 case SCT_SCAN_BOC_VRN_FINE:
00198 case SCT_SCAN_TX_CHANNELS:
00199 case SCT_SCAN_RAW_TX_CHANNELS:
00200 return true;
00201 default:
00202 return false;
00203 }
00204 }
00205
00206 }