00001 #include <algorithm>
00002
00003 #include "CommonWithDsp/primParams.h"
00004
00005 #include "RodCrate/RodPrimList.h"
00006
00007 #include "PrimBuilder.h"
00008 #include "utility.h"
00009
00010 using namespace SctApi;
00011
00012 PrimBuilder *PrimBuilder::singleton = 0;
00013
00014 PrimBuilder::PrimBuilder() {}
00015
00016 void PrimBuilder::slavePrimList(boost::shared_ptr<PrimListWrapper> parentList,
00017 boost::shared_ptr<PrimListWrapper> primList,
00018 unsigned int slaveNumber, bool await, bool response) {
00019 try {
00020 primList->list->bufferBuild();
00021 } catch (SctPixelRod::PrimListException &p) {
00022 std::cout << "Exception building prim list for slave " << slaveNumber << std::endl;
00023 std::cout << p.getDescriptor() << " ";
00024 std::cout << p.getData1() << ", " << p.getData2() << "\n";
00025 return;
00026 }
00027
00028
00029
00030 long buffLength = primList->list->getBufferLength();
00031 unsigned long* bufferStart = primList->list->getBuffer();
00032
00033
00034 int offset = sizeof(SEND_SLAVE_LIST_IN)/4;
00035
00036 long *slaveData = new long[offset+buffLength];
00037
00038 SEND_SLAVE_LIST_IN &slaveList = *(SEND_SLAVE_LIST_IN *)slaveData;
00039
00040 #if (R_SEND_SLAVE_LIST == 103)
00041 slaveList.slaveNumber = slaveNumber;
00042 slaveList.listLength = buffLength;
00043 slaveList.slavePrimList = (unsigned int*)DEFAULT;
00044 slaveList.slaveRepData = (unsigned int*)DEFAULT;
00045 #else
00046 #error "SEND_SLAVE_LIST not compiled (new revision)"
00047 #endif
00048
00049
00050 for (int i=0; i< buffLength; i++) {
00051 slaveData[offset + i] = bufferStart[i];
00052 }
00053
00054 parentList->addPrimitive(offset+buffLength, 1, SEND_SLAVE_LIST, R_SEND_SLAVE_LIST, slaveData);
00055
00056 delete [] slaveData;
00057
00058 startSlaveList(parentList, slaveNumber, await, response);
00059 }
00060
00061 void PrimBuilder::startSlaveList(boost::shared_ptr<PrimListWrapper> primList,
00062 unsigned int slaveNumber, bool await, bool response) {
00063 START_SLAVE_LIST_IN startPrim;
00064 #if (R_START_SLAVE_LIST == 103)
00065 startPrim.slaveNumber = slaveNumber;
00066 startPrim.pauseMasterList = await?1:0;
00067 startPrim.getSlaveReply = response?1:0;
00068 #else
00069 #error "START_SLAVE_LIST not compiled (new revision)"
00070 #endif
00071
00072 primList->addPrimitive(sizeof(START_SLAVE_LIST_IN)/4, 2, START_SLAVE_LIST, R_START_SLAVE_LIST, (long*)&startPrim);
00073 }
00074
00075 void PrimBuilder::echo(boost::shared_ptr<PrimListWrapper> primList, Utility::MemoryBlock block) {
00076 #if (R_ECHO != 100)
00077 #error "ECHO revision changed!"
00078 #endif
00079
00080 long *myData = new long[block.size()];
00081 std::copy(block.address(), block.address() + block.size(), myData);
00082 primList->addPrimitive(block.size(), 1, ECHO, R_ECHO, myData);
00083
00084 delete [] myData;
00085 }
00086
00087 void PrimBuilder::startSlave(boost::shared_ptr<PrimListWrapper> prim, int s) {
00088 START_SLAVE_EXECUTING_IN data;
00089 data.slaveNumber = s;
00090 data.commOnOff = SLV_DSP_COMM_ON;
00091 data.slaveType = SLAVE_MONITOR;
00092 data.timeoutInUsec = 0x200000;
00093
00094 prim->addPrimitive(sizeof(START_SLAVE_EXECUTING_IN)/4, 1, START_SLAVE_EXECUTING, R_START_SLAVE_EXECUTING, (long *)&data);
00095 }
00096
00097 void PrimBuilder::readFifo(boost::shared_ptr<PrimListWrapper> prim, int id, int bank, int elems) {
00098 RW_FIFO_IN fifo;
00099 #if (R_RW_FIFO == 104)
00100 fifo.fifoId = id;
00101 fifo.bank = bank;
00102 fifo.readNotWrite = 1;
00103 fifo.numElements = elems;
00104 fifo.dataBaseAdr = (UINT32 *)0xffffffff;
00105 #else
00106 #error "RW_FIFO revision change"
00107 #endif
00108
00109 prim->addPrimitive(sizeof(RW_FIFO_IN)/4, 1, RW_FIFO, R_RW_FIFO, (long *)&fifo);
00110 }
00111
00112 void PrimBuilder::pollRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int width, int val, int timeout) {
00113 POLL_REG_FIELD_IN poll;
00114
00115 #if (R_POLL_REG_FIELD == 105)
00116 poll.registerID = r;
00117 poll.offset = off;
00118 poll.width = width;
00119 poll.desiredValue = val;
00120 poll.timeoutInUsec = timeout;
00121 #else
00122 #error "POLL_REG_FIELD revision changed"
00123 #endif
00124
00125 prim->addPrimitive(sizeof(POLL_REG_FIELD_IN)/4, 1, POLL_REG_FIELD, R_POLL_REG_FIELD, (long*)&poll);
00126 }
00127
00128 void PrimBuilder::taskOp(boost::shared_ptr<PrimListWrapper> prim, int typ, int op, int data) {
00129 TASK_OPERATION_IN taskOp;
00130 #if (R_TASK_OPERATION == 100)
00131 taskOp.taskType = typ;
00132 taskOp.taskOperation = op;
00133 taskOp.data = data;
00134 #else
00135 #error "TASK_OPERATION revision change"
00136 #endif
00137
00138 prim->addPrimitive(sizeof(TASK_OPERATION_IN)/4, 1, TASK_OPERATION, R_TASK_OPERATION, (long*)&taskOp);
00139 }
00140
00141 void PrimBuilder::readRegister(boost::shared_ptr<PrimListWrapper> prim, int r) {
00142 RW_REG_FIELD_IN rField;
00143 #if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
00144 rField.registerID = r;
00145 rField.offset = 0;
00146 rField.width = 32;
00147 rField.readNotWrite = 1;
00148 rField.dataIn = 0;
00149 #else
00150 #error "RW_REG_FIELD revision change"
00151 #endif
00152
00153 prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
00154 }
00155
00156 void PrimBuilder::writeRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int wid, int value) {
00157 RW_REG_FIELD_IN rField;
00158 #if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
00159 rField.registerID = r;
00160 rField.offset = off;
00161 rField.width = wid;
00162 rField.readNotWrite = 0;
00163 rField.dataIn = value;
00164 #else
00165 #error "RW_REG_FIELD revision change"
00166 #endif
00167
00168 prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
00169 }
00170
00171 void PrimBuilder::sendStream(boost::shared_ptr<PrimListWrapper> prim, int cmdBuff, bool capture) {
00172 SEND_STREAM_IN sendStream;
00173
00174 #if (R_SEND_STREAM == 100)
00175 sendStream.cmdBuff = cmdBuff;
00176 sendStream.captureSerOn = capture;
00177 #else
00178 #error "SEND_STREAM revision change"
00179 #endif
00180
00181 prim->addPrimitive(sizeof(SEND_STREAM_IN)/4, 3, SEND_STREAM, R_SEND_STREAM, (long *)&sendStream);
00182 }
00183
00184 void PrimBuilder::startEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
00185 long trap[0] = {};
00186
00187 #if (R_START_EVENT_TRAPPING != 101)
00188 #error "START_EVENT_TRAPPING revision change"
00189 #endif
00190
00191 prim->addPrimitive(0, 0, START_EVENT_TRAPPING, R_START_EVENT_TRAPPING, trap);
00192 }
00193
00194 void PrimBuilder::stopEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
00195 long trap[0] = {};
00196
00197 #if (R_STOP_EVENT_TRAPPING != 100)
00198 #error "STOP_EVENT_TRAPPING revision change"
00199 #endif
00200
00201 prim->addPrimitive(0, 0, STOP_EVENT_TRAPPING, R_STOP_EVENT_TRAPPING, trap);
00202 }
00203
00204 void PrimBuilder::setMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long address, unsigned long words, long value) {
00205 SET_MEMORY_IN prim;
00206
00207 #if (R_SET_MEMORY == 100)
00208 prim.start = (UINT32 *)address;
00209 prim.size = words;
00210 prim.val = value;
00211 #else
00212 #error "SET_MEMORY revision changed"
00213 #endif
00214
00215 primList->addPrimitive(sizeof(SET_MEMORY_IN)/4, 1, SET_MEMORY, R_SET_MEMORY, (const long *)&prim);
00216 }
00217
00218 void PrimBuilder::readSlaveMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long slave, unsigned long address, unsigned long words) {
00219 RW_SLAVE_MEMORY_IN rwPrim;
00220
00221 #if (R_RW_SLAVE_MEMORY == 100)
00222 rwPrim.slaveNumber = slave;
00223 rwPrim.readNotWrite = 1;
00224 rwPrim.slaveAddress = (UINT32 *)address;
00225 rwPrim.masterAddress = (UINT32 *)0xffffffff;
00226 rwPrim.numWords = words;
00227 #else
00228 #error "RW_SLAVE_MEMORY revision change"
00229 #endif
00230
00231 primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4, 1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, (long*)&rwPrim);
00232 }
00233
00234 void PrimBuilder::writeSlaveMemory(boost::shared_ptr<PrimListWrapper> primList,
00235 unsigned long slave, unsigned long address, unsigned long length, unsigned long *data) {
00236 long *primData = new long[sizeof(RW_SLAVE_MEMORY_IN)/4 + length];
00237
00238 RW_SLAVE_MEMORY_IN &rwPrim = *(RW_SLAVE_MEMORY_IN*)primData;
00239
00240 #if (R_RW_SLAVE_MEMORY == 100)
00241 rwPrim.slaveNumber = slave;
00242 rwPrim.readNotWrite = 0;
00243 rwPrim.slaveAddress = (UINT32 *)address;
00244 rwPrim.masterAddress = (UINT32 *)0xffffffff;
00245 rwPrim.numWords = length;
00246 #else
00247 #error "RW_SLAVE_MEMORY revision change"
00248 #endif
00249
00250 std::copy(data, data + length, primData + 5);
00251
00252 primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4 + length,
00253 1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, primData);
00254 }
00255
00256 void PrimBuilder::rodMode(boost::shared_ptr<PrimListWrapper> rodModeList,
00257 int mode, int flag, int fifoSetup, int nBits, int delay, int message) {
00258 #ifndef SET_ROD_MODE
00259 throw SctApiException("Set Rod Mode wasn't compiled");
00260 #else
00261 SET_ROD_MODE_IN rodPrim;
00262
00263 #if (R_SET_ROD_MODE == 101)
00264 rodPrim.mode = mode;
00265 rodPrim.flag = flag;
00266 rodPrim.fifoSetup = fifoSetup;
00267 rodPrim.nBits = nBits;
00268 rodPrim.delay = delay;
00269 rodPrim.evtsPerL1A = 1;
00270 rodPrim.message = message;
00271 #else
00272 throw SctApiException("Set Rod Mode wasn't compiled (wrong prim version)");
00273
00274 #endif
00275
00276 rodModeList->addPrimitive(sizeof(SET_ROD_MODE_IN)/4,
00277 1, SET_ROD_MODE, R_SET_ROD_MODE, (long *)&rodPrim);
00278 #endif
00279 }
00280
00281 void PrimBuilder::moduleMask(boost::shared_ptr<PrimListWrapper> maskList,
00282 int module, int port, int useStructSet, int passOn, int slvs,
00283 int cmdLine, int dataLine0, int dataLine1,
00284 int cfg, int modMask0, int modMask1, int maskType, int storage, int maskSet) {
00285 #if (R_MODULE_MASK == 101)
00286
00287 MODULE_MASK_IN maskPrim;
00288 maskPrim.moduleNum = module;
00289 maskPrim.port = port;
00290 maskPrim.useStructSet = useStructSet;
00291 maskPrim.passOn = passOn;
00292 maskPrim.slvBits = slvs;
00293 maskPrim.cmdLine = cmdLine;
00294 maskPrim.dataLine[0] = dataLine0;
00295 maskPrim.dataLine[1] = dataLine1;
00296 maskPrim.dataLine[2] = 0;
00297 maskPrim.dataLine[3] = 0;
00298 maskPrim.cfg = cfg;
00299 maskPrim.modMask[0] = modMask0;
00300 maskPrim.modMask[1] = modMask1;
00301 maskPrim.maskType = maskType;
00302 maskPrim.storage = storage;
00303 maskPrim.maskSet = maskSet;
00304
00305 maskList->addPrimitive(sizeof(MODULE_MASK_IN)/4,
00306 1, MODULE_MASK, R_MODULE_MASK, (long *)&maskPrim);
00307 #elif (R_MODULE_MASK == 100)
00308 #warning "MODULE_MASK method not compiled"
00309 #else
00310 #error "MODULE_MASK revision change"
00311 #endif
00312 }
00313
00314 void PrimBuilder::masksFromConfig(boost::shared_ptr<PrimListWrapper> maskList, int port) {
00315
00316 moduleMask(maskList, ALL_MODULES, port, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
00317 }
00318
00319 void PrimBuilder::masksToSlaves(boost::shared_ptr<PrimListWrapper> maskList, int slvBits) {
00320
00321 moduleMask(maskList, ALL_MODULES, 0, 0, 1, slvBits,
00322
00323 0, 0, 0, 0, 0, 0, 0, 0, 0);
00324 }
00325
00326 void PrimBuilder::readModuleData(boost::shared_ptr<PrimListWrapper> primList, int bank, int channel) {
00327 RW_MODULE_DATA_IN primData;
00328
00329 #if (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
00330 primData.readNotWrite = 1;
00331 primData.structId = bank;
00332 primData.moduleNum = channel;
00333 #elif (R_RW_MODULE_DATA == 100)
00334 primData.readNotWrite = 1;
00335 primData.structID = bank;
00336 primData.moduleNum = channel;
00337 #else
00338 #error "RW_MODULE_DATA not compiled (primitive change)"
00339 #endif
00340
00341
00342 primList->addPrimitive(sizeof(RW_MODULE_DATA_IN)/4, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, (long*)&primData);
00343 }
00344
00345 void PrimBuilder::writeModuleData(boost::shared_ptr<PrimListWrapper> primList, const ABCDModule* module, int bank, int channel) {
00346 const unsigned int longsInConfig = sizeof(ABCDModule) / 4;
00347
00348 long *configData = new long[sizeof(RW_MODULE_DATA_IN)/4+longsInConfig];
00349
00350 RW_MODULE_DATA_IN ¶ms = *(RW_MODULE_DATA_IN*)configData;
00351 #if (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
00352 params.readNotWrite = 0;
00353 params.structId = bank;
00354 params.moduleNum = channel;
00355 params.configData = (ABCDModule *)0xffffffff;
00356 #else
00357 #error "RW_MODULE_DATA not compiled (primitive change)"
00358 #endif
00359
00360
00361 std::copy((long *)module, ((long*)module)+longsInConfig, configData+3);
00362
00363 primList->addPrimitive(sizeof(RW_MODULE_DATA_IN)/4+longsInConfig-1, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, configData);
00364
00365 delete [] configData;
00366 }
00367
00368 void PrimBuilder::sendConfig(boost::shared_ptr<PrimListWrapper> primList,
00369 int port, int capture, int module0, int module1, int chip, int setLinks, int restore,
00370 int bank, int group, int data, int active, int enableData) {
00371 if (enableData!=0) {
00372 enableData=1;
00373 }
00374 SEND_CONFIG_IN primData;
00375
00376 #if (R_SEND_CONFIG == 104) || (R_SEND_CONFIG == 105)
00377 primData.port = port;
00378 primData.captureSerOn = capture;
00379 primData.moduleNum[0] = module0;
00380 primData.moduleNum[1] = module1;
00381 primData.chipNum = chip;
00382 primData.setLinks = setLinks;
00383 primData.restore = restore;
00384 primData.structId = bank;
00385 primData.groupId = group;
00386 primData.dataType = data;
00387 primData.activeOnly = active;
00388 primData.enableDataTaking = enableData;
00389 #else
00390 #error "Send config not compiled! (new prim version)"
00391 #endif
00392
00393 primList->addPrimitive(sizeof(SEND_CONFIG_IN)/4, 1, SEND_CONFIG, R_SEND_CONFIG, (long *)&primData);
00394 }
00395
00396 void PrimBuilder::writeModuleVariable(boost::shared_ptr<PrimListWrapper> primList, int bank, int group, int channel, int chip, int type, float value) {
00397 #if (defined(RW_MODULE_VARIABLE) && defined(R_RW_MODULE_VARIABLE))
00398 RW_MODULE_VARIABLE_IN prim;
00399
00400 #if (R_RW_MODULE_VARIABLE == 101)
00401 #warning "This one doesn't work"
00402 #elif (R_RW_MODULE_VARIABLE == 102)
00403 prim.read = 0;
00404 prim.structId = bank;
00405 prim.groupId = group;
00406 prim.module = channel;
00407 prim.chip = chip;
00408 prim.varType = type;
00409 prim.info = 1;
00410 prim.dataLen = 1;
00411 prim.data = (MDAT32*)(*(unsigned int*)(&value));
00412 #else
00413 #warning "Modify config (ROD) not compiled! (new prim version)"
00414 #endif
00415
00416 primList->addPrimitive(sizeof(RW_MODULE_VARIABLE_IN)/4, 1, RW_MODULE_VARIABLE, R_RW_MODULE_VARIABLE, (long*)&prim);
00417 #else
00418 #warning "Modify config (ROD) not compiled! (primitive doesn't exist)"
00419 #endif
00420 }
00421
00422 void PrimBuilder::bocHistogram(boost::shared_ptr<PrimListWrapper> primList, int samples, int numLoops) {
00423 #ifdef R_BOC_HISTOGRAM
00424 BOC_HISTOGRAM_IN bocPrim;
00425
00426 #if (R_BOC_HISTOGRAM == 100)
00427 bocPrim.numSamples = samples;
00428 bocPrim.numLoops = numLoops;
00429 #else
00430 #warning "BOC_HISTOGRAM revision change"
00431 #endif
00432
00433 primList->addPrimitive(sizeof(BOC_HISTOGRAM_IN)/4, 1, BOC_HISTOGRAM, R_BOC_HISTOGRAM, (long*)&bocPrim);
00434 #else
00435 std::cout << "BOC_HISTOGRAM not compiled\n";
00436 #endif
00437 }
00438
00439 void PrimBuilder::setTrigger(boost::shared_ptr<PrimListWrapper> primList, int currentBin, int histogramSet)
00440 {
00441 SET_TRIGGER_IN triggerPrim;
00442
00443 #if (R_SET_TRIGGER == 102)
00444 triggerPrim.bin = currentBin;
00445 triggerPrim.set = histogramSet;
00446 #else
00447 #warning "SET_TRIGGER revision change"
00448 #endif
00449
00450 primList->addPrimitive(sizeof(SET_TRIGGER_IN)/4, 1, SET_TRIGGER, R_SET_TRIGGER, (long*)&triggerPrim);
00451 }
00452
00453 PrimBuilder& PrimBuilder::instance() {
00454 if(!singleton) {
00455 singleton = new PrimBuilder;
00456 }
00457
00458 return *singleton;
00459 }
00460