wip

slsDetectorServers/slsDetectorServer/include/loadPattern.h

@@ -4,4 +4,13 @@
 #include "clogger.h"
 
 int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat);
+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);
 #endif

slsDetectorServers/slsDetectorServer/src/loadPattern.c

@@ -1,7 +1,6 @@
 #include "loadPattern.h"
 #include "clogger.h"
 #include "common.h"
-#include "readDefaultPattern.h"
 #include "sls/ansi.h"
 #include "sls/sls_detector_defs.h"
 #include "slsDetectorServer_defs.h"
@@ -25,7 +24,7 @@ extern uint64_t setPatternWaitTime(int level, uint64_t t);
 extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
                            int *nLoop);
 
-int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
+int loadPattern(char *message, enum TLogLevel printLevel, patternParameters *pat) {
     LOG(logINFOBLUE, ("Loading Pattern\n"));
     int ret = OK;
     trimmingPrint = printLevel;
@@ -35,72 +34,43 @@ int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
             LOG(logDEBUG5, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
                             i, (long long int)pat->word[i]));
         }
-        writePatternWord(i, pat->word[i]);
+        ret = pattern_writeWord(message, i, pat->word[i]);
+        if (ret == FAIL) {
+            break;
+        }
     }
 #ifndef MYTHEN3D
     if (ret == OK) {
-        uint64_t retval64 = writePatternIOControl(pat->ioctrl);
+        ret = pattern_writeIOControl(message, pat->ioctrl);
-        validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX);
     }
 #endif
     if (ret == OK) {
-        int numLoops = -1;
+        ret = pattern_setLoopLimits(message, pat->limits[0], pat->limits[1]);
-        int retval0 = pat->limits[0];
-        int retval1 = pat->limits[1];
-        setPatternLoop(-1, &retval0, &retval1, &numLoops);
-        validate(pat->limits[0], retval0, "set pattern Limits start address",
-                 HEX);
-        validate(pat->limits[1], retval1, "set pattern Limits start address",
-                 HEX);
     }
-    uint64_t retval64;
+
     if (ret == OK) {
         for (int i = 0; i <= 2; ++i) {
-            char msg[128];
+            // loop addr
-            int retval0 = -1, retval1 = -1, numLoops = -1;
+            ret = pattern_setLoopAddresses(message, i, pat->loop[i * 2 + 0], pat->loop[i * 2 + 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(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(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(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(pat->wait[i], retval0, msg, HEX);
             if (ret == FAIL) {
                 break;
             }
 
-            // patwaittime
+            // num loops
-            if (pattern_setWaitTime(mess, i, pat->waittime[i]) == FAIL) {
+            ret = pattern_setLoopCycles(message, i, pat->nloop[i]);
+            if (ret == FAIL) {
                 break;
             }
            
-            memset(msg, 0, sizeof(msg));
+            // wait addr
-            sprintf(msg, "set pattern Loop %d wait time", i);
+            ret = pattern_setWaitAddresses(message, i, pat->wait[i]);
-            retval64 = setPatternWaitTime(i, pat->waittime[i]);
+            if (ret == FAIL) {
-            validate64(pat->waittime[i], retval64, msg, HEX);
+                break;
-            if (retval64 == FAIL) {
+            }
+
+            // wait time
+            ret = pattern_setWaitTime(message, i, pat->waittime[i]);
+            if (ret == FAIL) {
                 break;
             }
         }
@@ -110,34 +80,183 @@ int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
     return ret;
 }
 
-int pattern_setWaitTime(char *mess, int level, uint64_t waittime) {
+int pattern_writeWord(char *message, uint32_t addr, uint64_t word) {
-    memset(mess, 0, sizeof(mess));
+    // vaiidate input
-    char msg[128];
+    if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
-    memset(msg, 0, sizeof(msg));
+        sprintf(message,
-    // validations
+                "Cannot set pattern word. Addr must be between 0 and 0x%x.\n",
-    if (level < 0 || level > 2) {
+                MAX_PATTERN_LENGTH);
-        sprintf(initErrorMessage,
+        LOG(logERROR, (message));
-                "Cannot set patwaittime from default "
-                "pattern file. Level must be between 0 and 2. Line:[%s]\n",
-                line);
         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);
+    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);
+
+    // validate result
+    int ret = OK;
+    validate64(&ret, message, arg, retval, "set pattern IO Control", HEX);
+    return ret;
+}
+#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;
+    }
+
+    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);
+
+    // 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) {
+    memset(message, 0, sizeof(message));
+
+    // 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);
 
-    // validate
+    // validate result
-    if (retval != waittime) {
+    int ret = OK;
-#ifdef VIRTUAL
+    char mode[128];
-        sprintf(initErrorMessage,
+    memset(mode, 0, sizeof(mode));
-                "Could not set patwaittime (level: %d) from default "
+    sprintf(mode, "set pattern Loop %d wait time", level);
-                "pattern file. Read %ld wait time. Line:[%s]\n",
+    validate64(&ret, message, waittime, retval, mode, DEC);
-                level, retval, line);
+    return ret;
-#else
-        sprintf(initErrorMessage,
-                "Could not set patwaittime (level: %d) from default "
-                "pattern file. Read %lld wait time. Line:[%s]\n",
-                level, retval, line);
-#endif
-        return FAIL;
-    }
-    return OK;
 }

slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c

@@ -1,23 +1,33 @@
 #include "readDefaultPattern.h"
 #include "clogger.h"
 #include "common.h"
-#include "loadPattern.h"
+#include "Pattern.h"
 #include "sls/ansi.h"
 #include "sls/sls_detector_defs.h"
 #include "slsDetectorServer_defs.h"
 
 #include <string.h>
 
-extern char initErrorMessage[MAX_STR_LENGTH];
-
 #ifndef MYTHEN3D
 extern uint64_t writePatternIOControl(uint64_t word);
+#else
+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);
+extern int pattern_writeWord(char *message, uint32_t addr, uint64_t word);
+#ifndef MYTHEN3D
+extern int pattern_writeIOControl(char *message, uint64_t arg);
+#endif
+extern int pattern_setLoopLimits(char *message, uint32_t startAddr, uint32_t stopAddr);
+extern int pattern_setLoopAddresses(char *message, int level, uint32_t startAddr, uint32_t stopAddr);
+extern int pattern_setLoopCycles(char *message, int level, int numLoops);
+extern int pattern_setWaitAddresses(char *message, int level, uint32_t addr);
+extern int pattern_setWaitTime(char *message, int level, uint64_t waittime); 
+
 
 int loadDefaultPattern(char *patFname,
                        char *errMessage) { // this needs to be copied to
@@ -41,6 +51,8 @@ int loadDefaultPattern(char *patFname,
     char line[LZ];
     memset(line, 0, LZ);
     char command[LZ];
+    char temp[MAX_STR_LENGTH];
+    memset(temp, 0, MAX_STR_LENGTH);
 
     // keep reading a line
     while (fgets(line, LZ, fd)) {
@@ -96,14 +108,11 @@ int loadDefaultPattern(char *patFname,
 #else
             if (sscanf(line, "%s 0x%x 0x%llx", command, &addr, &word) != 3) {
 #endif
-                sprintf(errMessage,
+                strcpy(temp, "Could not scan patword arguments.\n");
-                        "Could not scan patword arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        line);
                 break;
             }
 
-            if (default_writePatternWord(line, addr, word) == FAIL) {
+            if (pattern_writeWord(temp, addr, word) == FAIL) {
                 break;
             }
         }
@@ -119,14 +128,11 @@ int loadDefaultPattern(char *patFname,
 #else
             if (sscanf(line, "%s 0x%llx", command, &arg) != 2) {
 #endif
-                sprintf(errMessage,
+                strcpy(temp, "Could not scan patioctrl arguments.\n");
-                        "Could not scan patioctrl arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        line);
                 break;
             }
 
-            if (default_writePatternIOControl(line, arg) == FAIL) {
+            if (pattern_writeIOControl(temp, arg) == FAIL) {
                 break;
             }
         }
@@ -140,15 +146,11 @@ int loadDefaultPattern(char *patFname,
             // cannot scan values
             if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
                 3) {
-                sprintf(errMessage,
+                strcpy(temp, "Could not scan patlimits arguments.\n");
-                        "Could not scan patlimits arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        line);
                 break;
             }
 
-            if (default_setPatternLoopLimits(line, startAddr, stopAddr) ==
+            if (pattern_setLoopLimits(temp, startAddr, stopAddr) == FAIL) {
-                FAIL) {
                 break;
             }
         }
@@ -173,15 +175,11 @@ int loadDefaultPattern(char *patFname,
             // cannot scan values
             if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
                 3) {
-                sprintf(errMessage,
+                sprintf(temp, "Could not scan patloop%d arguments.\n", level);
-                        "Could not scan patloop%d arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        level, line);
                 break;
             }
 
-            if (default_setPatternLoopAddresses(line, level, startAddr,
+            if (pattern_setLoopAddresses(temp, level, startAddr, stopAddr) == FAIL) {
-                                                stopAddr) == FAIL) {
                 break;
             }
         }
@@ -204,14 +202,11 @@ int loadDefaultPattern(char *patFname,
             int numLoops = -1;
             // cannot scan values
             if (sscanf(line, "%s %d", command, &numLoops) != 2) {
-                sprintf(errMessage,
+                sprintf(temp, "Could not scan patnloop %d arguments.\n", level);
-                        "Could not scan patnloop%d arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        level, line);
                 break;
             }
 
-            if (default_setPatternLoopCycles(line, level, numLoops) == FAIL) {
+            if (pattern_setLoopCycles(temp, level, numLoops) == FAIL) {
                 break;
             }
         }
@@ -234,14 +229,11 @@ int loadDefaultPattern(char *patFname,
             uint32_t addr = 0;
             // cannot scan values
             if (sscanf(line, "%s 0x%x", command, &addr) != 2) {
-                sprintf(errMessage,
+                sprintf(temp, "Could not scan patwait%d arguments.\n", level);
-                        "Could not scan patwait%d arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        level, line);
                 break;
             }
 
-            if (default_setPatternWaitAddresses(line, level, addr) == FAIL) {
+            if (pattern_setWaitAddresses(temp, level, addr) == FAIL) {
                 break;
             }
         }
@@ -269,215 +261,33 @@ int loadDefaultPattern(char *patFname,
 #else
             if (sscanf(line, "%s %lld", command, &waittime) != 2) {
 #endif
-                sprintf(errMessage,
+                sprintf(temp, "Could not scan patwaittime%d arguments.\n", level);
-                        "Could not scan patwaittime%d arguments from default "
-                        "pattern file. Line:[%s].\n",
-                        level, line);
                 break;
             }
 
-            if (pattern_setWaitTime(errMessage, level, waittime) == FAIL) {
+            if (pattern_setWaitTime(temp, level, waittime) == FAIL) {
-                sprintf(initErrorMessage,
+                break;
-                        "%s(Default pattern file. Line: %s)\n", errMessage,
-                        line);
-                return FAIL;
             }
         }
 
         memset(line, 0, LZ);
     }
+
     fclose(fd);
 
-    if (strlen(errMessage)) {
+    if (strlen(temp)) {
-        LOG(logERROR, ("%s\n\n", errMessage));
+        sprintf(errMessage, "%s(Default pattern file. Line: %s)\n", temp, line);
         return FAIL;
     }
+
     LOG(logINFOBLUE, ("Successfully read default pattern file\n"));
     return OK;
 }
 
-int default_writePatternWord(char *line, uint32_t addr, uint64_t word) {
-    // validations
-    if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
-        sprintf(initErrorMessage,
-                "Cannot set pattern word from default "
-                "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
-                MAX_PATTERN_LENGTH, line);
-        return FAIL;
-    }
-    writePatternWord(addr, word);
-    // cannot validate for moench, ctb ( same as executing pattern word)
-    return OK;
-}
 
-#ifndef MYTHEN3D
-int default_writePatternIOControl(char *line, uint64_t arg) {
-    uint64_t retval = writePatternIOControl(arg);
-    if (retval != arg) {
-#ifdef VIRTUAL
-        sprintf(initErrorMessage,
-                "Could not set patioctrl from default pattern "
-                "file. Set 0x%lx, read 0x%lx. Line:[%s]\n",
-                arg, retval, line);
-#else
-        sprintf(initErrorMessage,
-                "Could not set patioctrl from default pattern "
-                "file. Set 0x%llx, read 0x%llx. Line:[%s]\n",
-                arg, retval, line);
-#endif
-        return FAIL;
-    }
-    return OK;
-}
-#endif
 
-int default_setPatternLoopLimits(char *line, uint32_t startAddr,
-                                 uint32_t stopAddr) {
-    // validations
-    if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
-        (int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
-        sprintf(initErrorMessage,
-                "Cannot set patlimits from default "
-                "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
-                MAX_PATTERN_LENGTH, line);
-        return FAIL;
-    }
-    int numLoops = -1;
-    int r_startAddr = startAddr, r_stopAddr = stopAddr;
-    setPatternLoop(-1, &r_startAddr, &r_stopAddr, &numLoops);
 
-    // validate
-    if (r_startAddr != (int)startAddr || r_stopAddr != (int)stopAddr) {
-        sprintf(initErrorMessage,
-                "Could not set patlimits from default pattern "
-                "file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n",
-                r_startAddr, r_stopAddr, line);
-        return FAIL;
-    }
-    return OK;
-}
 
-int default_setPatternLoopAddresses(char *line, int level, uint32_t startAddr,
-                                    uint32_t stopAddr) {
-    // validations
-    if (level < 0 || level > 2) {
-        sprintf(initErrorMessage,
-                "Cannot set patloop from default "
-                "pattern file. Level must be between 0 and 2. Line:[%s]\n",
-                line);
-        return FAIL;
-    }
-    if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
-        (int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
-        sprintf(initErrorMessage,
-                "Cannot set patloop (level: %d) from default "
-                "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
-                level, MAX_PATTERN_LENGTH, line);
-        return FAIL;
-    }
-    int numLoops = -1;
-    int r_startAddr = startAddr, r_stopAddr = stopAddr;
-    setPatternLoop(level, &r_startAddr, &r_stopAddr, &numLoops);
 
-    // validate
-    if (r_startAddr != (int)startAddr || r_stopAddr != (int)stopAddr) {
-        sprintf(
-            initErrorMessage,
-            "Could not set patloop (level: %d) from default "
-            "pattern file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n",
-            level, r_startAddr, r_stopAddr, line);
-        return FAIL;
-    }
-    return OK;
-}
 
-int default_setPatternLoopCycles(char *line, int level, int numLoops) {
-    // validations
-    if (level < 0 || level > 2) {
-        sprintf(initErrorMessage,
-                "Cannot set patnloop from default "
-                "pattern file. Level must be between 0 and 2. Line:[%s]\n",
-                line);
-        return FAIL;
-    }
-    if (numLoops < 0) {
-        sprintf(initErrorMessage,
-                "Cannot set patnloop from default "
-                "pattern file. Iterations must be between > 0. Line:[%s]\n",
-                line);
-        return FAIL;
-    }
-    int startAddr = -1;
-    int stopAddr = -1;
-    int r_numLoops = numLoops;
-    setPatternLoop(level, &startAddr, &stopAddr, &r_numLoops);
 
-    // validate
-    if (r_numLoops != numLoops) {
-        sprintf(initErrorMessage,
-                "Could not set patnloop (level: %d) from default "
-                "pattern file. Read %d loops. Line:[%s]\n",
-                level, r_numLoops, line);
-        return FAIL;
-    }
-    return OK;
-}
-
-int default_setPatternWaitAddresses(char *line, int level, uint32_t addr) {
-    // validations
-    if (level < 0 || level > 2) {
-        sprintf(initErrorMessage,
-                "Cannot set patwait address from default "
-                "pattern file. Level must be between 0 and 2. Line:[%s]\n",
-                line);
-        return FAIL;
-    }
-    if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
-        sprintf(initErrorMessage,
-                "Cannot set patwait address (level: %d) from default "
-                "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
-                level, MAX_PATTERN_LENGTH, line);
-        return FAIL;
-    }
-
-    uint32_t retval = setPatternWaitAddress(level, addr);
-
-    // validate
-    if (retval != addr) {
-        sprintf(initErrorMessage,
-                "Could not set patwait address (level: %d) from default "
-                "pattern file. Read addr: 0x%x. Line:[%s]\n",
-                level, retval, line);
-        return FAIL;
-    }
-    return OK;
-}
-
-int default_setPatternWaitTime(char *line, int level, uint64_t waittime) {
-    // validations
-    if (level < 0 || level > 2) {
-        sprintf(initErrorMessage,
-                "Cannot set patwaittime from default "
-                "pattern file. Level must be between 0 and 2. Line:[%s]\n",
-                line);
-        return FAIL;
-    }
-    uint64_t retval = setPatternWaitTime(level, waittime);
-
-    // validate
-    if (retval != waittime) {
-#ifdef VIRTUAL
-        sprintf(initErrorMessage,
-                "Could not set patwaittime (level: %d) from default "
-                "pattern file. Read %ld wait time. Line:[%s]\n",
-                level, retval, line);
-#else
-        sprintf(initErrorMessage,
-                "Could not set patwaittime (level: %d) from default "
-                "pattern file. Read %lld wait time. Line:[%s]\n",
-                level, retval, line);
-#endif
-        return FAIL;
-    }
-    return OK;
-}

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -574,7 +574,7 @@ int set_external_signal_flag(int file_des) {
         if (ret == OK) {
             setExtSignal(signalIndex, flag);
             retval = getExtSignal(signalIndex);
-            validate(&ret, mess, &ret, mess, (int)flag, (int)retval,
+            validate(&ret, mess, (int)flag, (int)retval,
                      "set external signal flag", DEC);
             LOG(logDEBUG1, ("External Signal Flag: %d\n", retval));
         }
@@ -2001,7 +2001,7 @@ int set_num_triggers(int file_des) {
         setNumTriggers(arg);
         int64_t retval = getNumTriggers();
         LOG(logDEBUG1, ("retval num triggers %lld\n", (long long int)retval));
-        validate64(arg, retval, "set number of triggers", DEC);
+        validate64(&ret, mess, arg, retval, "set number of triggers", DEC);
     }
     return Server_SendResult(file_des, INT64, NULL, 0);
 }
@@ -3964,7 +3964,7 @@ int threshold_temp(int file_des) {
         else {
             retval = setThresholdTemperature(arg);
             LOG(logDEBUG1, ("Threshold temperature: %d\n", retval));
-            validate(arg, retval, "set threshold temperature", DEC);
+            validate(&ret, mess, arg, retval, "set threshold temperature", DEC);
         }
     }
 #endif