detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-26 08:10:02 +02:00
Code Issues Actions Packages Releases Activity

wip

Browse Source
This commit is contained in:
maliakal_d 2021-06-18 19:38:47 +02:00
parent a8c0049f88
commit 665a3be6d8
9 changed files with 761 additions and 1353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
slsDetectorServers/ctbDetectorServer/CMakeLists.txt
View File

@ -17,6 +17,7 @@ add_executable(ctbDetectorServer_virtual
../slsDetectorServer/src/MAX1932.c
../slsDetectorServer/src/programFpgaBlackfin.c
../slsDetectorServer/src/sharedMemory.c
../slsDetectorServer/src/loadPattern.c
)
include_directories(

2
slsDetectorServers/ctbDetectorServer/Makefile
View File

@ -13,7 +13,7 @@ DESTDIR ?= bin
INSTMODE = 0777
SRCS = slsDetectorFunctionList.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD7689.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)I2C.c $(main_src)INA226.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)/sharedMemory.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD7689.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)I2C.c $(main_src)INA226.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c
OBJS = $(SRCS:.c=.o)

289
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -11,6 +11,7 @@
#include "UDPPacketHeaderGenerator.h"
#include "common.h"
#include "communication_funcs_UDP.h"
#include "loadPattern.h"
#include <netinet/in.h>
#include <string.h>
@ -42,7 +43,6 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif
@ -478,7 +478,7 @@ void setupDetector() {
ndSamples = 1;
#ifdef VIRTUAL
sharedMemory_setStatus(IDLE);
memset(virtual_pattern, 0, sizeof(virtual_pattern));
initializePatternWord();
#endif
ALTERA_PLL_ResetPLLAndReconfiguration();
@ -969,7 +969,7 @@ int setExpTime(int64_t val) {
}
int64_t getExpTime() {
return setPatternWaitTime(0, -1) / (1E-3 * clkFrequency[RUN_CLK]);
return getPatternWaitTime(0) / (1E-3 * clkFrequency[RUN_CLK]);
}
int setPeriod(int64_t val) {
@ -1880,273 +1880,6 @@ int getPipeline(enum CLKINDEX ind) {
ADC_OFFSET_ADC_PPLN_OFST);
}
// patterns
uint64_t writePatternIOControl(uint64_t word) {
if ((int64_t)word != -1) {
LOG(logINFO,
("Setting Pattern I/O Control: 0x%llx\n", (long long int)word));
set64BitReg(word, PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
uint64_t retval =
get64BitReg(PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
LOG(logDEBUG1, (" I/O Control retval: 0x%llx\n", (long long int)retval));
return retval;
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logINFORED, (" Reading (Executing) Pattern Word (addr:0x%x)\n", addr));
uint32_t reg = PATTERN_CNTRL_REG;
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set read strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_RD_MSK);
// unset read strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_RD_MSK));
usleep(WAIT_TIME_PATTERN_READ);
// read value
uint64_t retval = get64BitReg(PATTERN_OUT_LSB_REG, PATTERN_OUT_MSB_REG);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
#ifdef VIRTUAL
retval = virtual_pattern[addr];
#endif
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
uint32_t reg = PATTERN_CNTRL_REG;
// write word
set64BitReg(word, PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG)));
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set write strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_WR_MSK);
// unset write strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_WR_MSK));
#ifdef VIRTUAL
virtual_pattern[addr] = word;
#endif
return word;
// return readPatternWord(addr); // will start executing the pattern
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(logINFO, ("Setting Pattern Wait Address (level:%d, addr:0x%x)\n",
level, addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(logINFO, ("Setting Pattern Wait Time (level:%d, t:%lld)\n", level,
(long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(logINFO,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(logINFO,
("Setting Pattern Loop (level:%d, startaddr:0x%x, stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
LOG(logDEBUG1, ("Addr:0x%x, val:0x%x\n", addr, bus_r(addr)));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
int setLEDEnable(int enable) {
uint32_t addr = CONFIG_REG;
@ -2189,22 +1922,6 @@ void setDigitalIODelay(uint64_t pinMask, int delay) {
bus_w(addr, bus_r(addr) & (~OUTPUT_DELAY_0_OTPT_TRGGR_MSK));
}
void setPatternMask(uint64_t mask) {
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
/* aquisition */
int startStateMachine() {

289
slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
View File

@ -41,7 +41,6 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif
@ -485,7 +484,7 @@ void setupDetector() {
nSamples = 1;
#ifdef VIRTUAL
sharedMemory_setStatus(IDLE);
memset(virtual_pattern, 0, sizeof(virtual_pattern));
initializePatternWord();
#endif
ALTERA_PLL_ResetPLLAndReconfiguration();
@ -819,7 +818,7 @@ int setExpTime(int64_t val) {
}
int64_t getExpTime() {
return setPatternWaitTime(0, -1) / (1E-3 * clkFrequency[RUN_CLK]);
return getPatternWaitTime(0) / (1E-3 * clkFrequency[RUN_CLK]);
}
int setPeriod(int64_t val) {
@ -1560,290 +1559,6 @@ int getPipeline(enum CLKINDEX ind) {
ADC_OFFSET_ADC_PPLN_OFST);
}
// patterns
uint64_t writePatternIOControl(uint64_t word) {
if ((int64_t)word != -1) {
LOG(logINFO,
("Setting Pattern I/O Control: 0x%llx\n", (long long int)word));
set64BitReg(word, PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
uint64_t retval =
get64BitReg(PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
LOG(logDEBUG1, (" I/O Control retval: 0x%llx\n", (long long int)retval));
return retval;
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logINFORED, (" Reading (Executing) Pattern Word (addr:0x%x)\n", addr));
uint32_t reg = PATTERN_CNTRL_REG;
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set read strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_RD_MSK);
// unset read strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_RD_MSK));
usleep(WAIT_TIME_PATTERN_READ);
// read value
uint64_t retval = get64BitReg(PATTERN_OUT_LSB_REG, PATTERN_OUT_MSB_REG);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
#ifdef VIRTUAL
retval = virtual_pattern[addr];
#endif
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
uint32_t reg = PATTERN_CNTRL_REG;
// write word
set64BitReg(word, PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG)));
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set write strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_WR_MSK);
// unset write strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_WR_MSK));
#ifdef VIRTUAL
virtual_pattern[addr] = word;
#endif
return word;
// return readPatternWord(addr); // will start executing the pattern
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(logINFO, ("Setting Pattern Wait Address (level:%d, addr:0x%x)\n",
level, addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(logINFO, ("Setting Pattern Wait Time (level:%d, t:%lld)\n", level,
(long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(logINFO,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(logINFO,
("Setting Pattern Loop (level:%d, startaddr:0x%x, stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
LOG(logDEBUG1, ("Addr:0x%x, val:0x%x\n", addr, bus_r(addr)));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
void setPatternMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern bit mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
/* aquisition */
int startStateMachine() {

267
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -1748,273 +1748,6 @@ int enableTenGigabitEthernet(int val) {
return oneG ? 0 : 1;
}
/* pattern */
void startPattern() {
LOG(logINFOBLUE, ("Starting Pattern\n"));
bus_w(CONTROL_REG, bus_r(CONTROL_REG) | CONTROL_STRT_PATTERN_MSK);
usleep(1);
while (bus_r(PAT_STATUS_REG) & PAT_STATUS_RUN_BUSY_MSK) {
usleep(1);
}
LOG(logINFOBLUE, ("Pattern done\n"));
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, (" Reading Pattern Word (addr:0x%x)\n", addr));
uint32_t reg_lsb =
PATTERN_STEP0_LSB_REG +
addr * REG_OFFSET * 2; // the first word in RAM as base plus the
// offset of the word to write (addr)
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
// read value
uint64_t retval = get64BitReg(reg_lsb, reg_msb);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
// write word
uint32_t reg_lsb =
PATTERN_STEP0_LSB_REG +
addr * REG_OFFSET * 2; // the first word in RAM as base plus the
// offset of the word to write (addr)
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
set64BitReg(word, reg_lsb, reg_msb);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(reg_lsb, reg_msb)));
return readPatternWord(addr);
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(trimmingPrint,
("Setting Pattern Wait Address (level:%d, addr:0x%x)\n", level,
addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(trimmingPrint, ("Setting Pattern Wait Time (level:%d, t:%lld)\n",
level, (long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
*startAddr = -1;
*stopAddr = -1;
*nLoop = -1;
return;
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(trimmingPrint,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(trimmingPrint, ("Setting Pattern Loop (level:%d, startaddr:0x%x, "
"stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
void setPatternMask(uint64_t mask) {
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
int checkDetectorType() {
#ifdef VIRTUAL
return OK;

61
slsDetectorServers/slsDetectorServer/include/loadPattern.h
View File

@ -3,16 +3,57 @@
#include "Pattern.h"
#include "clogger.h"
int pattern_writeWord(char *message, uint32_t addr, uint64_t word);
#ifndef MYTHEN3D
int pattern_writeIOControl(char *message, uint64_t arg);
#endif
int pattern_setLoopLimits(char *message, uint32_t startAddr, uint32_t stopAddr);
int pattern_setLoopAddresses(char *message, int level, uint32_t startAddr,
uint32_t stopAddr);
int pattern_setLoopCycles(char *message, int level, int numLoops);
int pattern_setWaitAddresses(char *message, int level, uint32_t addr);
int pattern_setWaitTime(char *message, int level, uint64_t waittime);
int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat);
int getPattern(char *mess, patternParameters *pat);
int loadPatternFile(char *patFname, char *errMessage);
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
#ifdef VIRTUAL
void initializePatternWord();
#endif
uint64_t pattern_readIOControl();
int pattern_writeIOControl(char *message, uint64_t arg);
void writePatternIOControl(uint64_t word);
#endif
int pattern_readWord(char *message, int addr, uint64_t *word);
uint64_t readPatternWord(int addr);
int pattern_writeWord(char *message, int addr, uint64_t word);
void writePatternWord(int addr, uint64_t word);
int pattern_getWaitAddresses(char *message, int level, int *addr);
int getPatternWaitAddress(int level);
int pattern_setWaitAddresses(char *message, int level, int addr);
void setPatternWaitAddress(int level, int addr);
int pattern_getWaitTime(char *message, int level, uint64_t *waittime);
uint64_t getPatternWaitTime(int level);
int pattern_setWaitTime(char *message, int level, uint64_t waittime);
void setPatternWaitTime(int level, uint64_t t);
int pattern_getLoopCycles(char *message, int level, int *numLoops);
int getPatternLoopCycles(int level);
int pattern_setLoopCycles(char *message, int level, int numLoops);
void setPatternLoopCycles(int level, int nLoop);
void pattern_getLoopLimits(int *startAddr, int *stopAddr);
int pattern_setLoopLimits(char *message, int startAddr, int stopAddr);
void setPatternLoopLimits(int startAddr, int stopAddr);
int pattern_getLoopAddresses(char *message, int level, int *startAddr,
int *stopAddr);
void getPatternLoopAddresses(int level, int *startAddr, int *stopAddr);
int pattern_setLoopAddresses(char *message, int level, int startAddr,
int stopAddr);
void setPatternLoopAddresses(int level, int startAddr, int stopAddr);
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
#ifdef MYTHEN3D
void startPattern();
#endif
#endif

24
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -425,22 +425,12 @@ int getFrequency(enum CLKINDEX ind);
void configureSyncFrequency(enum CLKINDEX ind);
void setPipeline(enum CLKINDEX ind, int val);
int getPipeline(enum CLKINDEX ind);
// patterns
uint64_t writePatternIOControl(uint64_t word);
uint64_t readPatternWord(int addr);
uint64_t writePatternWord(int addr, uint64_t word);
int setPatternWaitAddress(int level, int addr);
uint64_t setPatternWaitTime(int level, uint64_t t);
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);
#endif
#ifdef CHIPTESTBOARDD
int setLEDEnable(int enable);
void setDigitalIODelay(uint64_t pinMask, int delay);
#endif
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
#endif
// jungfrau specific - powerchip, autocompdisable, clockdiv, asictimer, clock,
// pll, flashing firmware
@ -488,16 +478,6 @@ int getActivate(int *retval);
int setPhase(enum CLKINDEX ind, int val, int degrees);
#elif MYTHEN3D
void startPattern();
uint64_t readPatternWord(int addr);
uint64_t writePatternWord(int addr, uint64_t word);
int setPatternWaitAddress(int level, int addr);
uint64_t setPatternWaitTime(int level, uint64_t t);
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
int checkDetectorType();
int powerChip(int on);
int setPhase(enum CLKINDEX ind, int val, int degrees);

858
slsDetectorServers/slsDetectorServer/src/loadPattern.c
View File

@ -7,218 +7,29 @@
#include <string.h>
#include <unistd.h>
#ifndef MYTHEN3D
extern uint64_t writePatternIOControl(uint64_t word);
#else
extern enum TLogLevel trimmingPrint;
extern uint64_t readPatternWord(int addr);
#endif
extern uint64_t writePatternWord(int addr, uint64_t word);
extern int setPatternWaitAddress(int level, int addr);
extern uint64_t setPatternWaitTime(int level, uint64_t t);
extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
int *nLoop);
int pattern_writeWord(char *message, uint32_t addr, uint64_t word) {
// vaiidate input
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set pattern word. Addr must be between 0 and 0x%x.\n",
MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
writePatternWord(addr, word);
// validate result
int ret = OK;
// cannot validate for moench, ctb ( same as executing pattern word)
#ifdef MYTHEN3D
uint64_t retval = readPatternWord(addr);
LOG(logDEBUG1, ("Pattern word (addr:0x%x) retval: 0x%llx\n", addr,
(long long int)retval));
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern word for addr 0x%x", addr);
validate64(&ret, message, word, retval, "set pattern word", HEX);
#endif
return ret;
}
#ifndef MYTHEN3D
int pattern_writeIOControl(char *message, uint64_t arg) {
uint64_t retval = writePatternIOControl(arg);
LOG(logDEBUG1,
("Pattern IO Control retval: 0x%llx\n", (long long int)retval));
// validate result
int ret = OK;
validate64(&ret, message, arg, retval, "set pattern IO Control", HEX);
return ret;
}
extern enum TLogLevel trimmingPrint;
#endif
int pattern_setLoopLimits(char *message, uint32_t startAddr,
uint32_t stopAddr) {
// vaiidate input
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patlimits from default "
"pattern file. Addr must be between 0 and 0x%x.\n",
MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
#ifdef VIRTUAL
uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
#endif
#endif
int numLoops = -1;
int r_startAddr = startAddr, r_stopAddr = stopAddr;
setPatternLoop(-1, &r_startAddr, &r_stopAddr, &numLoops);
// validate result
int ret = OK;
// start addr
validate(&ret, message, startAddr, r_startAddr,
"set pattern Limits start addr", HEX);
if (ret == FAIL) {
return FAIL;
}
// stop addr
validate(&ret, message, stopAddr, r_stopAddr,
"set pattern Limits stop addr", HEX);
return ret;
}
int pattern_setLoopAddresses(char *message, int level, uint32_t startAddr,
uint32_t stopAddr) {
// vaiidate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patloop. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patloop (level: %d). Addr must be between 0 and "
"0x%x.\n",
level, MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
int numLoops = -1;
int r_startAddr = startAddr, r_stopAddr = stopAddr;
setPatternLoop(level, &r_startAddr, &r_stopAddr, &numLoops);
// validate result
int ret = OK;
char mode[128];
// start addr
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d start addr", level);
validate(&ret, message, startAddr, r_startAddr, mode, HEX);
if (ret == FAIL) {
return FAIL;
}
// stop addr
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d stop addr", level);
validate(&ret, message, stopAddr, r_stopAddr, mode, HEX);
return ret;
}
int pattern_setLoopCycles(char *message, int level, int numLoops) {
// vaiidate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patnloop. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if (numLoops < 0) {
sprintf(message,
"Cannot set patnloop. Iterations must be between > 0.\n");
LOG(logERROR, (message));
return FAIL;
}
int startAddr = -1;
int stopAddr = -1;
int r_numLoops = numLoops;
setPatternLoop(level, &startAddr, &stopAddr, &r_numLoops);
// validate result
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d num loops", level);
validate(&ret, message, numLoops, r_numLoops, mode, DEC);
return ret;
}
int pattern_setWaitAddresses(char *message, int level, uint32_t addr) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patwait address. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patwait address (level: %d). Addr must be between "
"0 and 0x%x.\n",
level, MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
uint32_t retval = setPatternWaitAddress(level, addr);
LOG(logDEBUG1,
("Pattern wait address (level:%d) retval: 0x%x\n", level, retval));
// validate result
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d wait address", level);
validate(&ret, message, addr, retval, mode, HEX);
return ret;
}
int pattern_setWaitTime(char *message, int level, uint64_t waittime) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patwaittime. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
uint64_t retval = setPatternWaitTime(level, waittime);
LOG(logDEBUG1, ("Pattern wait time (level:%d) retval: %d\n", level,
(long long int)retval));
// validate result
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d wait time", level);
validate64(&ret, message, waittime, retval, mode, DEC);
return ret;
}
extern void bus_w(u_int32_t offset, u_int32_t data);
extern u_int32_t bus_r(u_int32_t offset);
extern int64_t get64BitReg(int aLSB, int aMSB);
extern int64_t set64BitReg(int64_t value, int aLSB, int aMSB);
int loadPattern(char *message, enum TLogLevel printLevel,
patternParameters *pat) {
LOG(logINFOBLUE, ("Loading Pattern\n"));
LOG(logINFOBLUE, ("Loading Pattern from structure\n"));
int ret = OK;
#ifdef MYTHEN3D
trimmingPrint = printLevel;
#endif
// words
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logDEBUG5, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
@ -229,11 +40,13 @@ int loadPattern(char *message, enum TLogLevel printLevel,
break;
}
}
// iocontrol
#ifndef MYTHEN3D
if (ret == OK) {
ret = pattern_writeIOControl(message, pat->ioctrl);
}
#endif
// limits
if (ret == OK) {
ret = pattern_setLoopLimits(message, pat->limits[0], pat->limits[1]);
}
@ -272,6 +85,67 @@ int loadPattern(char *message, enum TLogLevel printLevel,
return ret;
}
int getPattern(char *message, patternParameters *pat) {
LOG(logINFO, ("Getting Pattern into structure\n"));
int ret = OK;
uint64_t retval64 = 0;
int retval1 = -1, retval2 = -1;
// words
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
ret = pattern_readWord(message, i, &retval64);
if (ret == FAIL) {
break;
}
pat->word[i] = retval64;
}
// iocontrol
#ifndef MYTHEN3D
if (ret == OK) {
pattern_readIOControl();
}
#endif
// limits
if (ret == OK) {
pattern_getLoopLimits(&retval1, &retval2);
pat->limits[0] = retval1;
pat->limits[1] = retval2;
}
if (ret == OK) {
for (int i = 0; i <= 2; ++i) {
// loop addr
ret = pattern_getLoopAddresses(message, i, &retval1, &retval2);
if (ret == FAIL) {
break;
}
pat->loop[i * 2 + 0] = retval1;
pat->loop[i * 2 + 1] = retval2;
// num loops
ret = pattern_getLoopCycles(message, i, &retval1);
if (ret == FAIL) {
break;
}
pat->nloop[i] = retval1;
// wait addr
ret = pattern_getWaitAddresses(message, i, &retval1);
if (ret == FAIL) {
break;
}
pat->wait[i] = retval1;
// wait time
ret = pattern_getWaitTime(message, i, &retval64);
if (ret == FAIL) {
break;
}
pat->waittime[i] = retval64;
}
}
return ret;
}
int loadPatternFile(char *patFname, char *errMessage) {
char fname[128];
if (getAbsPath(fname, 128, patFname) == FAIL) {
@ -340,7 +214,7 @@ int loadPatternFile(char *patFname, char *errMessage) {
// patword
if (!strncmp(line, "patword", strlen("patword"))) {
uint32_t addr = 0;
int addr = 0;
uint64_t word = 0;
// cannot scan values
@ -381,8 +255,8 @@ int loadPatternFile(char *patFname, char *errMessage) {
// patlimits
if (!strncmp(line, "patlimits", strlen("patlimits"))) {
uint32_t startAddr = 0;
uint32_t stopAddr = 0;
int startAddr = 0;
int stopAddr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
@ -411,8 +285,8 @@ int loadPatternFile(char *patFname, char *errMessage) {
level = 2;
}
uint32_t startAddr = 0;
uint32_t stopAddr = 0;
int startAddr = 0;
int stopAddr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
3) {
@ -468,7 +342,7 @@ int loadPatternFile(char *patFname, char *errMessage) {
level = 2;
}
uint32_t addr = 0;
int addr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x", command, &addr) != 2) {
sprintf(temp, "Could not scan patwait%d arguments.\n", level);
@ -526,3 +400,573 @@ int loadPatternFile(char *patFname, char *errMessage) {
LOG(logINFOBLUE, ("Successfully read default pattern file\n"));
return OK;
}
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
#ifdef VIRTUAL
void initializePatternWord() {
memset(virtual_pattern, 0, sizeof(virtual_pattern));
}
#endif
uint64_t pattern_readIOControl() {
return get64BitReg(PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
int pattern_writeIOControl(char *message, uint64_t arg) {
writePatternIOControl(arg);
// validate result
uint64_t retval = pattern_readIOControl();
LOG(logDEBUG1,
("Pattern IO Control retval: 0x%llx\n", (long long int)retval));
int ret = OK;
validate64(&ret, message, arg, retval, "set pattern IO Control", HEX);
return ret;
}
void writePatternIOControl(uint64_t word) {
LOG(logINFO,
("Setting Pattern I/O Control: 0x%llx\n", (long long int)word));
set64BitReg(word, PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
#endif
int pattern_readWord(char *message, int addr, uint64_t *word) {
// validate input
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot read pattern word. Addr must be between 0 and 0x%x.\n",
MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
*word = readPatternWord(addr);
return OK;
}
uint64_t readPatternWord(int addr) {
#ifdef MYTHEN3D
LOG(logDEBUG1, (" Reading Pattern Word (addr:0x%x)\n", addr));
// the first word in RAM as base plus the offset of the word to write (addr)
uint32_t reg_lsb = PATTERN_STEP0_LSB_REG + addr * REG_OFFSET * 2;
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
return get64BitReg(reg_lsb, reg_msb);
#else
LOG(logINFORED, (" Reading (Executing) Pattern Word (addr:0x%x)\n", addr));
uint32_t reg = PATTERN_CNTRL_REG;
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set read strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_RD_MSK);
// unset read strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_RD_MSK));
usleep(WAIT_TIME_PATTERN_READ);
// read value
#ifndef VIRTUAL
return get64BitReg(PATTERN_OUT_LSB_REG, PATTERN_OUT_MSB_REG);
#else
return virtual_pattern[addr];
#endif
#endif
}
int pattern_writeWord(char *message, int addr, uint64_t word) {
// validate input
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set pattern word. Addr must be between 0 and 0x%x.\n",
MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
writePatternWord(addr, word);
// validate result
int ret = OK;
// cannot validate for moench, ctb ( same as executing pattern word)
#ifdef MYTHEN3D
uint64_t retval = readPatternWord(addr);
LOG(logDEBUG1, ("Pattern word (addr:0x%x) retval: 0x%llx\n", addr,
(long long int)retval));
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern word for addr 0x%x", addr);
validate64(&ret, message, word, retval, "set pattern word", HEX);
#endif
return ret;
}
void writePatternWord(int addr, uint64_t word) {
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
#ifndef MYTHEN3D
uint32_t reg = PATTERN_CNTRL_REG;
// write word
set64BitReg(word, PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG);
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set write strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_WR_MSK);
// unset write strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_WR_MSK));
#ifdef VIRTUAL
virtual_pattern[addr] = word;
#endif
// mythen
#else
// the first word in RAM as base plus the offset of the word to write (addr)
uint32_t reg_lsb = PATTERN_STEP0_LSB_REG + addr * REG_OFFSET * 2;
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
set64BitReg(word, reg_lsb, reg_msb);
#endif
}
int pattern_getWaitAddresses(char *message, int level, int *addr) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot get patwait address. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
*addr = getPatternWaitAddress(level);
return OK;
}
int getPatternWaitAddress(int level) {
switch (level) {
case 0:
return ((bus_r(PATTERN_WAIT_0_ADDR_REG) & PATTERN_WAIT_0_ADDR_MSK) >>
PATTERN_WAIT_0_ADDR_OFST);
case 1:
return ((bus_r(PATTERN_WAIT_1_ADDR_REG) & PATTERN_WAIT_1_ADDR_MSK) >>
PATTERN_WAIT_1_ADDR_OFST);
case 2:
return ((bus_r(PATTERN_WAIT_2_ADDR_REG) & PATTERN_WAIT_2_ADDR_MSK) >>
PATTERN_WAIT_2_ADDR_OFST);
default:
return -1;
}
}
int pattern_setWaitAddresses(char *message, int level, int addr) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patwait address. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patwait address (level: %d). Addr must be between "
"0 and 0x%x.\n",
level, MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
setPatternWaitAddress(level, addr);
// validate result
int retval = getPatternWaitAddress(level);
LOG(logDEBUG1,
("Pattern wait address (level:%d) retval: 0x%x\n", level, retval));
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d wait address", level);
validate(&ret, message, addr, retval, mode, HEX);
return ret;
}
void setPatternWaitAddress(int level, int addr) {
#ifdef MYTHEN3D
LOG(trimmingPrint,
#else
LOG(logINFO,
#endif
("Setting Pattern Wait Address (level:%d, addr:0x%x)\n", level, addr));
switch (level) {
case 0:
bus_w(PATTERN_WAIT_0_ADDR_REG,
((addr << PATTERN_WAIT_0_ADDR_OFST) & PATTERN_WAIT_0_ADDR_MSK));
break;
case 1:
bus_w(PATTERN_WAIT_1_ADDR_REG,
((addr << PATTERN_WAIT_1_ADDR_OFST) & PATTERN_WAIT_1_ADDR_MSK));
break;
case 2:
bus_w(PATTERN_WAIT_2_ADDR_REG,
((addr << PATTERN_WAIT_2_ADDR_OFST) & PATTERN_WAIT_2_ADDR_MSK));
break;
default:
return;
}
}
int pattern_getWaitTime(char *message, int level, uint64_t *waittime) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot get patwaittime. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
*waittime = getPatternWaitTime(level);
return OK;
}
uint64_t getPatternWaitTime(int level) {
switch (level) {
case 0:
return get64BitReg(PATTERN_WAIT_TIMER_0_LSB_REG,
PATTERN_WAIT_TIMER_0_MSB_REG);
case 1:
return get64BitReg(PATTERN_WAIT_TIMER_1_LSB_REG,
PATTERN_WAIT_TIMER_1_MSB_REG);
case 2:
return get64BitReg(PATTERN_WAIT_TIMER_2_LSB_REG,
PATTERN_WAIT_TIMER_2_MSB_REG);
default:
return -1;
}
}
int pattern_setWaitTime(char *message, int level, uint64_t waittime) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patwaittime. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
setPatternWaitTime(level, waittime);
// validate result
uint64_t retval = getPatternWaitTime(level);
LOG(logDEBUG1, ("Pattern wait time (level:%d) retval: %d\n", level,
(long long int)retval));
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d wait time", level);
validate64(&ret, message, waittime, retval, mode, DEC);
return ret;
}
void setPatternWaitTime(int level, uint64_t t) {
#ifdef MYTHEN3D
LOG(trimmingPrint,
#else
LOG(logINFO,
#endif
("Setting Pattern Wait Time (level:%d) :%lld\n", level,
(long long int)t));
switch (level) {
case 0:
set64BitReg(t, PATTERN_WAIT_TIMER_0_LSB_REG,
PATTERN_WAIT_TIMER_0_MSB_REG);
break;
case 1:
set64BitReg(t, PATTERN_WAIT_TIMER_1_LSB_REG,
PATTERN_WAIT_TIMER_1_MSB_REG);
break;
case 2:
set64BitReg(t, PATTERN_WAIT_TIMER_2_LSB_REG,
PATTERN_WAIT_TIMER_2_MSB_REG);
break;
default:
return;
}
}
int pattern_getLoopCycles(char *message, int level, int *numLoops) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot get patnloop. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
*numLoops = getPatternLoopCycles(level);
return OK;
}
int getPatternLoopCycles(int level) {
switch (level) {
case 0:
return bus_r(PATTERN_LOOP_0_ITERATION_REG);
case 1:
return bus_r(PATTERN_LOOP_1_ITERATION_REG);
case 2:
return bus_r(PATTERN_LOOP_2_ITERATION_REG);
default:
return -1;
}
}
int pattern_setLoopCycles(char *message, int level, int numLoops) {
// validate input
if (level < 0 || level > 2) {
sprintf(message,
"Cannot set patnloop. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if (numLoops < 0) {
sprintf(message,
"Cannot set patnloop. Iterations must be between > 0.\n");
LOG(logERROR, (message));
return FAIL;
}
setPatternLoopCycles(level, numLoops);
// validate result
int retval = getPatternLoopCycles(level);
int ret = OK;
char mode[128];
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d num loops", level);
validate(&ret, message, numLoops, retval, mode, DEC);
return ret;
}
void setPatternLoopCycles(int level, int nLoop) {
#ifdef MYTHEN3D
LOG(trimmingPrint,
#else
LOG(logINFO,
#endif
("Setting Pattern Loop Cycles(level:%d, nLoop:%d)\n", level, nLoop));
switch (level) {
case 0:
bus_w(PATTERN_LOOP_0_ITERATION_REG, nLoop);
break;
case 1:
bus_w(PATTERN_LOOP_1_ITERATION_REG, nLoop);
break;
case 2:
bus_w(PATTERN_LOOP_2_ITERATION_REG, nLoop);
break;
default:
return;
}
}
void pattern_getLoopLimits(int *startAddr, int *stopAddr) {
*startAddr = ((bus_r(PATTERN_LIMIT_REG) & PATTERN_LIMIT_STRT_MSK) >>
PATTERN_LIMIT_STRT_OFST);
*stopAddr = ((bus_r(PATTERN_LIMIT_REG) & PATTERN_LIMIT_STP_MSK) >>
PATTERN_LIMIT_STP_OFST);
}
int pattern_setLoopLimits(char *message, int startAddr, int stopAddr) {
// validate input
if (startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH || stopAddr < 0 ||
stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patlimits from default "
"pattern file. Addr must be between 0 and 0x%x.\n",
MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
setPatternLoopLimits(startAddr, stopAddr);
// validate result
int r_startAddr = -1, r_stopAddr = -1;
pattern_getLoopLimits(&r_startAddr, &r_stopAddr);
int ret = OK;
// start addr
validate(&ret, message, startAddr, r_startAddr,
"set pattern Limits start addr", HEX);
if (ret == FAIL) {
return FAIL;
}
// stop addr
validate(&ret, message, stopAddr, r_stopAddr,
"set pattern Limits stop addr", HEX);
return ret;
}
void setPatternLoopLimits(int startAddr, int stopAddr) {
#ifdef MYTHEN3D
LOG(trimmingPrint,
#else
LOG(logINFO,
#endif
("Setting Pattern Loop Limits(startaddr:0x%x, stopaddr:0x%x)\n",
startAddr, stopAddr));
bus_w(PATTERN_LIMIT_REG,
((startAddr << PATTERN_LIMIT_STRT_OFST) & PATTERN_LIMIT_STRT_MSK) |
((stopAddr << PATTERN_LIMIT_STP_OFST) & PATTERN_LIMIT_STP_MSK));
}
int pattern_getLoopAddresses(char *message, int level, int *startAddr,
int *stopAddr) {
// validate input
if (level < 0 || level > 2) {
sprintf(
message,
"Cannot get patloop addresses. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
getPatternLoopAddresses(level, startAddr, stopAddr);
return OK;
}
void getPatternLoopAddresses(int level, int *startAddr, int *stopAddr) {
switch (level) {
case 0:
*startAddr =
((bus_r(PATTERN_LOOP_0_ADDR_REG) & PATTERN_LOOP_0_ADDR_STRT_MSK) >>
PATTERN_LOOP_0_ADDR_STRT_OFST);
*stopAddr =
((bus_r(PATTERN_LOOP_0_ADDR_REG) & PATTERN_LOOP_0_ADDR_STP_MSK) >>
PATTERN_LOOP_0_ADDR_STP_OFST);
break;
case 1:
*startAddr =
((bus_r(PATTERN_LOOP_1_ADDR_REG) & PATTERN_LOOP_1_ADDR_STRT_MSK) >>
PATTERN_LOOP_1_ADDR_STRT_OFST);
*stopAddr =
((bus_r(PATTERN_LOOP_1_ADDR_REG) & PATTERN_LOOP_1_ADDR_STP_MSK) >>
PATTERN_LOOP_1_ADDR_STP_OFST);
break;
case 2:
*startAddr =
((bus_r(PATTERN_LOOP_2_ADDR_REG) & PATTERN_LOOP_2_ADDR_STRT_MSK) >>
PATTERN_LOOP_2_ADDR_STRT_OFST);
*stopAddr =
((bus_r(PATTERN_LOOP_2_ADDR_REG) & PATTERN_LOOP_2_ADDR_STP_MSK) >>
PATTERN_LOOP_2_ADDR_STP_OFST);
break;
default:
return;
}
}
int pattern_setLoopAddresses(char *message, int level, int startAddr,
int stopAddr) {
// validate input
if (level < 0 || level > 2) {
sprintf(
message,
"Cannot set patloop addresses. Level must be between 0 and 2.\n");
LOG(logERROR, (message));
return FAIL;
}
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(message,
"Cannot set patloop addresses (level: %d). Addr must be "
"between 0 and "
"0x%x.\n",
level, MAX_PATTERN_LENGTH);
LOG(logERROR, (message));
return FAIL;
}
setPatternLoopAddresses(level, startAddr, stopAddr);
// validate result
int r_startAddr = -1, r_stopAddr = -1;
getPatternLoopAddresses(level, &r_startAddr, &r_stopAddr);
int ret = OK;
char mode[128];
// start addr
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d start addr", level);
validate(&ret, message, startAddr, r_startAddr, mode, HEX);
if (ret == FAIL) {
return FAIL;
}
// stop addr
memset(mode, 0, sizeof(mode));
sprintf(mode, "set pattern Loop %d stop addr", level);
validate(&ret, message, stopAddr, r_stopAddr, mode, HEX);
return ret;
}
void setPatternLoopAddresses(int level, int startAddr, int stopAddr) {
#ifdef MYTHEN3D
LOG(trimmingPrint,
#else
LOG(logINFO,
#endif
("Setting Pattern Loop Address (level:%d, startaddr:0x%x, "
"stopaddr:0x%x)\n",
level, startAddr, stopAddr));
switch (level) {
case 0:
bus_w(PATTERN_LOOP_0_ADDR_REG,
((startAddr << PATTERN_LOOP_0_ADDR_STRT_OFST) &
PATTERN_LOOP_0_ADDR_STRT_MSK) |
((stopAddr << PATTERN_LOOP_0_ADDR_STP_OFST) &
PATTERN_LOOP_0_ADDR_STP_MSK));
break;
case 1:
bus_w(PATTERN_LOOP_1_ADDR_REG,
((startAddr << PATTERN_LOOP_1_ADDR_STRT_OFST) &
PATTERN_LOOP_1_ADDR_STRT_MSK) |
((stopAddr << PATTERN_LOOP_1_ADDR_STP_OFST) &
PATTERN_LOOP_1_ADDR_STP_MSK));
break;
case 2:
bus_w(PATTERN_LOOP_2_ADDR_REG,
((startAddr << PATTERN_LOOP_2_ADDR_STRT_OFST) &
PATTERN_LOOP_2_ADDR_STRT_MSK) |
((stopAddr << PATTERN_LOOP_2_ADDR_STP_OFST) &
PATTERN_LOOP_2_ADDR_STP_MSK));
break;
default:
return;
}
}
void setPatternMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern bit mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
#ifdef MYTHEN3D
void startPattern() {
LOG(logINFOBLUE, ("Starting Pattern\n"));
bus_w(CONTROL_REG, bus_r(CONTROL_REG) | CONTROL_STRT_PATTERN_MSK);
usleep(1);
while (bus_r(PAT_STATUS_REG) & PAT_STATUS_RUN_BUSY_MSK) {
usleep(1);
}
LOG(logINFOBLUE, ("Pattern done\n"));
}
#endif

321
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -2969,10 +2969,10 @@ int set_pattern_io_control(int file_des) {
LOG(logDEBUG1,
("Setting Pattern IO Control to 0x%llx\n", (long long int)arg));
if (((int64_t)arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = writePatternIOControl(arg);
LOG(logDEBUG1,
("Pattern IO Control retval: 0x%llx\n", (long long int)retval));
validate64(&ret, mess, arg, retval, "set Pattern IO Control", HEX);
if ((int64_t)arg != GET_FLAG) {
ret = pattern_writeIOControl(mess, arg);
}
retval = pattern_readIOControl();
}
#endif
return Server_SendResult(file_des, INT64, &retval, sizeof(retval));
@ -2996,19 +2996,10 @@ int set_pattern_word(int file_des) {
(long long int)word));
}
if (Server_VerifyLock() == OK) {
// valid address
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern (Word, addr:0x%x). Addr must be "
"between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
if (word != (uint64_t)-1) {
ret = pattern_writeWord(mess, addr, word);
} else {
retval = writePatternWord(addr, word);
LOG(logDEBUG1,
("Pattern Word retval: 0x%llx\n", (long long int)retval));
// no validation (cannot read as it will execute the pattern)
ret = pattern_readWord(mess, addr, &retval);
}
}
#endif
@ -3034,38 +3025,27 @@ int set_pattern_loop_addresses(int file_des) {
loopLevel, startAddr, stopAddr));
if ((startAddr == GET_FLAG) || (stopAddr == GET_FLAG) ||
(Server_VerifyLock() == OK)) {
// valid loop level
if (loopLevel < -1 ||
loopLevel > 2) { // loop level of -1 : complete pattern
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop addresses. Level %d should be "
"between -1 and 2\n",
loopLevel);
LOG(logERROR, (mess));
// loop limits
if (loopLevel == -1) {
// set
if (startAddr >= 0 && stopAddr >= 0) {
ret = pattern_setLoopLimits(mess, startAddr, stopAddr);
}
// get
pattern_getLoopLimits(&retvals[0], &retvals[1]);
}
// loop addresses
else {
// set
if (startAddr >= 0 && stopAddr >= 0) {
ret = pattern_setLoopAddresses(mess, loopLevel, startAddr,
stopAddr);
}
// get
if (ret == OK) {
ret = pattern_getLoopAddresses(mess, loopLevel, &retvals[0],
&retvals[1]);
}
// valid addr for loop level 0-2
else if (startAddr >= MAX_PATTERN_LENGTH ||
stopAddr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop addresses. Address (start "
"addr:0x%x and stop addr:0x%x) "
"should be less than 0x%x\n",
startAddr, stopAddr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
} else {
int numLoops = -1;
setPatternLoop(loopLevel, &startAddr, &stopAddr, &numLoops);
LOG(logDEBUG1,
("Pattern loop addresses retval: (start:0x%x, stop:0x%x)\n",
startAddr, stopAddr));
retvals[0] = startAddr;
retvals[1] = stopAddr;
validate(&ret, mess, args[1], startAddr,
"set Pattern loops' start address", HEX);
validate(&ret, mess, args[2], stopAddr,
"set Pattern loops' stop address", HEX);
}
}
#endif
@ -3088,23 +3068,13 @@ int set_pattern_loop_cycles(int file_des) {
LOG(logDEBUG1, ("Setting Pattern loop cycles (loopLevel:%d numLoops:%d)\n",
loopLevel, numLoops));
if ((numLoops == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop cycles. Level %d should be "
"between 0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
} else {
int startAddr = GET_FLAG;
int stopAddr = GET_FLAG;
setPatternLoop(loopLevel, &startAddr, &stopAddr, &numLoops);
retval = numLoops;
LOG(logDEBUG1,
("Pattern loop cycles retval: (ncycles:%d)\n", retval));
validate(&ret, mess, args[1], retval,
"set Pattern loops' number of cycles", DEC);
// set
if (numLoops != GET_FLAG) {
ret = pattern_setLoopCycles(mess, loopLevel, numLoops);
}
// get
if (ret == OK) {
ret = pattern_getLoopCycles(mess, loopLevel, &retval);
}
}
#endif
@ -3127,27 +3097,13 @@ int set_pattern_wait_addr(int file_des) {
LOG(logDEBUG1, ("Setting Pattern wait address (loopLevel:%d addr:0x%x)\n",
loopLevel, addr));
if ((addr == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level 0-2
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait address. Level %d should be "
"between 0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
// set
if (addr != GET_FLAG) {
ret = pattern_setWaitAddresses(mess, loopLevel, addr);
}
// valid addr
else if (addr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait address. Address (0x%x) should be "
"between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
} else {
retval = setPatternWaitAddress(loopLevel, addr);
LOG(logDEBUG1, ("Pattern wait address retval: 0x%x\n", retval));
validate(&ret, mess, addr, retval, "set Pattern wait address", HEX);
// get
if (ret == OK) {
ret = pattern_getWaitAddresses(mess, loopLevel, &retval);
}
}
#endif
@ -3170,20 +3126,13 @@ int set_pattern_wait_time(int file_des) {
LOG(logDEBUG1, ("Setting Pattern wait time (loopLevel:%d timeval:0x%llx)\n",
loopLevel, (long long int)timeval));
if (((int64_t)timeval == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level 0-2
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait time. Level %d should be between "
"0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
} else {
retval = setPatternWaitTime(loopLevel, timeval);
LOG(logDEBUG1,
("Pattern wait time retval: 0x%llx\n", (long long int)retval));
validate64(&ret, mess, timeval, retval, "set Pattern wait time",
HEX);
// set
if ((int64_t)timeval != GET_FLAG) {
ret = pattern_setWaitTime(mess, loopLevel, timeval);
}
// get
if (ret == OK) {
ret = pattern_getWaitTime(mess, loopLevel, &retval);
}
}
#endif
@ -7568,89 +7517,7 @@ int set_pattern(int file_des) {
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Setting Pattern from structure\n"));
LOG(logINFO,
("Setting Pattern Word (printing every 10 words that are not 0\n"));
/****************************************************************************************************************/
/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A
* SEPARATE FUNCTION WHICH COULD BE REUSED*/
/* added loadPattern.c/h - the same func could be reused also in
* readDefaultPattern */
/***************************************************************************************************************/
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
i, (long long int)pat->word[i]));
}
writePatternWord(i, pat->word[i]);
}
#ifndef MYTHEN3D
if (ret == OK) {
uint64_t retval64 = writePatternIOControl(pat->ioctrl);
validate64(&ret, mess, pat->ioctrl, retval64,
"set pattern IO Control", HEX);
}
#endif
if (ret == OK) {
int numLoops = -1;
int retval0 = pat->limits[0];
int retval1 = pat->limits[1];
setPatternLoop(-1, &retval0, &retval1, &numLoops);
validate(&ret, mess, pat->limits[0], retval0,
"set pattern Limits start address", HEX);
validate(&ret, mess, pat->limits[1], retval1,
"set pattern Limits start address", HEX);
}
if (ret == OK) {
for (int i = 0; i <= 2; ++i) {
char msg[128];
int retval0 = -1, retval1 = -1, numLoops = -1;
uint64_t retval64 = -1;
// patloop
retval0 = pat->loop[i * 2 + 0];
retval1 = pat->loop[i * 2 + 1];
numLoops = pat->nloop[i];
setPatternLoop(i, &retval0, &retval1, &numLoops);
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d start address", i);
validate(&ret, mess, pat->loop[i * 2 + 0], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d stop address", i);
validate(&ret, mess, pat->loop[i * 2 + 1], retval1, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d num loops", i);
validate(&ret, mess, pat->nloop[i], numLoops, msg, HEX);
if (ret == FAIL) {
break;
}
// patwait
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait address", i);
retval0 = setPatternWaitAddress(i, pat->wait[i]);
validate(&ret, mess, pat->wait[i], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
// patwaittime
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait time", i);
retval64 = setPatternWaitTime(i, pat->waittime[i]);
validate64(&ret, mess, pat->waittime[i], retval64, msg, HEX);
if (ret == FAIL) {
break;
}
}
}
/******* DOWN TO HERE ***********/
ret = loadPattern(mess, logINFO, pat);
}
if (pat != NULL)
free(pat);
@ -7672,97 +7539,7 @@ int get_pattern(int file_des) {
memset(pat, 0, sizeof(patternParameters));
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Getting Pattern from structure\n"));
// patword
LOG(logDEBUG,
("retval pattern word (printing every 10 words that are not 0\n"));
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
pat->word[i] = readPatternWord(i);
if ((int64_t)pat->word[i] == -1) {
ret = FAIL;
sprintf(mess, "could not read pattern word for address 0x%x\n",
i);
LOG(logERROR, (mess));
break;
}
// debug print
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logDEBUG,
("retval Patpattern word (addr:0x%x, word:0x%llx)\n", i,
(long long int)pat->word[i]));
}
}
// patioctrl
#ifndef MYTHEN3D
if (ret == OK) {
pat->ioctrl = writePatternIOControl(-1);
LOG(logDEBUG, ("retval pattern io control:0x%llx\n",
(long long int)pat->ioctrl));
}
#endif
if (ret == OK) {
// patlimits
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(-1, &retval0, &retval1, &numLoops);
pat->limits[0] = retval0;
pat->limits[1] = retval1;
LOG(logDEBUG, ("retval pattern limits start:0x%x stop:0x%x\n",
pat->limits[0], pat->limits[1]));
for (int i = 0; i <= 2; ++i) {
// patloop
{
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(i, &retval0, &retval1, &numLoops);
pat->nloop[i] = numLoops;
pat->loop[i * 2 + 0] = retval0;
pat->loop[i * 2 + 1] = retval1;
LOG(logDEBUG, ("retval pattern loop level %d start:0x%x "
"stop:0x%x numLoops:%d\n",
i, pat->loop[i * 2 + 0],
pat->loop[i * 2 + 0], pat->nloop[i]));
}
// patwait
{
pat->wait[i] = setPatternWaitAddress(i, -1);
if ((int)pat->wait[i] == -1) {
ret = FAIL;
sprintf(mess,
"could not read pattern wait address for level "
"%d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait address for level %d: 0x%x\n", i,
pat->wait[i]));
}
// patwaittime
{
pat->waittime[i] = setPatternWaitTime(i, -1);
if ((int64_t)pat->waittime[i] == -1) {
ret = FAIL;
sprintf(
mess,
"could not read pattern wait time for level %d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait time for level %d: %lld\n", i,
(long long int)pat->waittime[i]));
}
}
}
ret = getPattern(mess, pat);
}
// ignoring endianness for eiger