fixed userBufferOvl bug (fifo_flush)

diff --git a/libtrbnet/trbnet.c b/libtrbnet/trbnet.c
index 4d58c9ad89f1713848ca592cfee95e7dfa4b7f25..2c50612fd67f68e0342bd28187d5f10b751e62e3 100644 (file)
--- a/libtrbnet/trbnet.c
+++ b/libtrbnet/trbnet.c
@@ -1,4 +1,4 @@
-const char trbnet_version[] = "$Revision: 2.63 $";
+const char trbnet_version[] = "$Revision: 2.64 $";
 
 #include <stdlib.h>
 #include <signal.h>
@@ -386,14 +386,14 @@ static void fifo_flush(uint8_t channel)
   uint32_t tmp;
   uint32_t fifoAddress;
   unsigned int counter = 0;
-
+  
   fifoAddress = CHANNEL_N_RECEIVER_DATA | ((channel * 2 + 1) << 4);
   do {
     read32_from_FPGA(fifoAddress, &tmp);
     /* DEBUG INFO */
     if ((trb_debug > 1) && ((tmp & MASK_FIFO_VALID) != 0)) {
       fprintf(stderr, "FLUSH_FIFO_%03d:  0x%08x\n", counter, tmp);
-      counter++;
+      counter++;      
     }
   } while ((tmp & MASK_FIFO_VALID) != 0);
 }
@@ -475,7 +475,8 @@ static int trb_fifo_read(uint8_t channel,
   int packageCtr = -1;
   int fifoDebugCtr = -1;
   unsigned int endPointCtr = 0;
-
+  
+  int userBufferOvf = 0;
   unsigned int timeout = 0;
 
   /* Determin FIFO-Address */
@@ -615,118 +616,60 @@ static int trb_fifo_read(uint8_t channel,
       }
 
       /* Get Data F0 - F3 and store it in User-Data-Buffer if requested */
-      switch (mode) {
-
-      case FIFO_MODE_TERM_ONLY:
-        if (packageCtr > 0) {
-          fifo_flush(channel);
-          trb_errno = TRB_INVALID_PKG_NUMBER;
-          return -1; 
-        }
-        if (headerType != HEADER_TRM) {
-          fifo_flush(channel);
-          trb_errno = TRB_FIFO_INVALID_HEADER;
-          return -1;  
-        }
-        break;
+      if (userBufferOvf == 0) {
+        switch (mode) {
 
-      case FIFO_MODE_REG_READ:
-
-        switch (headerType) {
-        case HEADER_HDR:
-          if ((packageCtr - endPointCtr * 2) != 0) {
-            fifo_flush(channel);
-            trb_errno = TRB_FIFO_INVALID_HEADER;
-            return -1;
-          }
-          if (dataCtr < dsize) {
-            data[dataCtr++] = (uint32_t)package.F0;
-#ifdef TRB_DEBUGGER
-            fprintf(stderr, "D: 0x%04x  ", data[dataCtr - 1]);
-#endif
-          } else {
+        case FIFO_MODE_TERM_ONLY:
+          if (packageCtr > 0) {
             fifo_flush(channel);
-            trb_errno = TRB_USER_BUFFER_OVF;
-            return -1;
+            trb_errno = TRB_INVALID_PKG_NUMBER;
+            return -1; 
           }
-          break;
-
-        case HEADER_DAT:
-          if ((packageCtr - endPointCtr * 2) != 1) {
+          if (headerType != HEADER_TRM) {
             fifo_flush(channel);
             trb_errno = TRB_FIFO_INVALID_HEADER;
-            return -1;
-          }
-          if (dataCtr < dsize) {
-            data[dataCtr++] = (((uint32_t)package.F1 << 16) |
-                               ((uint32_t)package.F2));
-#ifdef TRB_DEBUGGER
-            fprintf(stderr, "0x%08x\n", data[dataCtr - 1]); 
-#endif
-            endPointCtr++;
-          } else {
-            fifo_flush(channel);
-            trb_errno = TRB_USER_BUFFER_OVF;
-            return -1;
+            return -1;  
           }
           break;
 
-        case HEADER_TRM:
-          break;
-
-        default:
-          fifo_flush(channel);
-          trb_errno = TRB_FIFO_INVALID_HEADER;
-          return -1;
-        }
-
-        break;
-
-      case FIFO_MODE_REG_READ_MEM:
-        {
-          static uint32_t* lastHeader = NULL;
-          static uint32_t memLen = 0;
+        case FIFO_MODE_REG_READ:
 
           switch (headerType) {
           case HEADER_HDR:
+            if ((packageCtr - endPointCtr * 2) != 0) {
+              fifo_flush(channel);
+              trb_errno = TRB_FIFO_INVALID_HEADER;
+              return -1;
+            }
             if (dataCtr < dsize) {
-              if (lastHeader != NULL) {
-                *lastHeader |= (memLen << 16);
-              }
-              memLen = 0;
-              lastHeader = &data[dataCtr];
               data[dataCtr++] = (uint32_t)package.F0;
 #ifdef TRB_DEBUGGER
-              fprintf(stderr, "D: H: 0x%04x\n", data[dataCtr - 1]);
+              fprintf(stderr, "D: 0x%04x  ", data[dataCtr - 1]);
 #endif
             } else {
-              fifo_flush(channel);
-              trb_errno = TRB_USER_BUFFER_OVF;
-              return -1;
+              userBufferOvf = 1;
             }
             break;
 
           case HEADER_DAT:
+            if ((packageCtr - endPointCtr * 2) != 1) {
+              fifo_flush(channel);
+              trb_errno = TRB_FIFO_INVALID_HEADER;
+              return -1;
+            }
             if (dataCtr < dsize) {
-              if (package.F0 == 0x0000) break; /* it a hack, ask Jan */
               data[dataCtr++] = (((uint32_t)package.F1 << 16) |
                                  ((uint32_t)package.F2));
 #ifdef TRB_DEBUGGER
-              fprintf(stderr,
-                      "D: 0x%04x  0x%08x\n", memLen, data[dataCtr - 1]); 
+              fprintf(stderr, "0x%08x\n", data[dataCtr - 1]); 
 #endif
-              memLen++;
+              endPointCtr++;
             } else {
-              fifo_flush(channel);
-              trb_errno = TRB_USER_BUFFER_OVF;
-              return -1;
+              userBufferOvf = 1;
             }
             break;
 
           case HEADER_TRM:
-            if (lastHeader != NULL) {
-              *lastHeader |= (memLen << 16);
-            }
             break;
 
           default:
@@ -734,145 +677,193 @@ static int trb_fifo_read(uint8_t channel,
             trb_errno = TRB_FIFO_INVALID_HEADER;
             return -1;
           }
-        }
-        break;
 
-      case FIFO_MODE_REG_WRITE:
-        if (headerType == HEADER_TRM) break;
-        break;
+          break;
 
-      case FIFO_MODE_IPU_DATA:
-        {
-          static unsigned int len = 0;
-          unsigned int i;
+        case FIFO_MODE_REG_READ_MEM:
+          {
+            static uint32_t* lastHeader = NULL;
+            static uint32_t memLen = 0;
 
-          switch (headerType) {
+            switch (headerType) {
+            case HEADER_HDR:
+              if (dataCtr < dsize) {
+                if (lastHeader != NULL) {
+                  *lastHeader |= (memLen << 16);
+                }
+                memLen = 0;
+                lastHeader = &data[dataCtr];
+                data[dataCtr++] = (uint32_t)package.F0;
+#ifdef TRB_DEBUGGER
+                fprintf(stderr, "D: H: 0x%04x\n", data[dataCtr - 1]);
+#endif
+              } else {
+                userBufferOvf = 1;
+              }
+              break;
 
-          case HEADER_TRM:
-            if ((packageCtr > 0) && (dataCtr != len)) {
-              /* Error invalid length */
-              fifo_flush(channel);
-              trb_errno = TRB_HDR_DLEN;
-              return -1;
-            }
-            break;
+            case HEADER_DAT:
+              if (dataCtr < dsize) {
+                if (package.F0 == 0x0000) break; /* it a hack, ask Jan */
+                data[dataCtr++] = (((uint32_t)package.F1 << 16) |
+                                   ((uint32_t)package.F2));
+#ifdef TRB_DEBUGGER
+                fprintf(stderr,
+                        "D: 0x%04x  0x%08x\n", memLen, data[dataCtr - 1]); 
+#endif
+                memLen++;
+              } else {
+                userBufferOvf = 1;
+              }
+              break;
 
-          case HEADER_HDR:
-            if (packageCtr != 0) {
+            case HEADER_TRM:
+              if (lastHeader != NULL) {
+                *lastHeader |= (memLen << 16);
+              }
+              break;
+
+            default:
               fifo_flush(channel);
               trb_errno = TRB_FIFO_INVALID_HEADER;
               return -1;
             }
-            len = (unsigned int)package.F2;
-            break;
+          }
+          break;
 
-          case HEADER_DAT:
-            for (i = 0; (i < 2) && (dataCtr < len); i++) {
-              if (dataCtr < dsize) {
-                data[dataCtr++] = (i == 0)
-                  ? (((uint32_t)package.F0 << 16) |
-                     ((uint32_t)package.F1))
-                  : (((uint32_t)package.F2 << 16) |
-                     ((uint32_t)package.F3));
-#ifdef TRB_DEBUGGER   
-                fprintf(stderr, "D: 0x%08x\n", data[dataCtr - 1]);
-#endif
-              } else {
+        case FIFO_MODE_REG_WRITE:
+          if (headerType == HEADER_TRM) break;
+          break;
+
+        case FIFO_MODE_IPU_DATA:
+          {
+            static unsigned int len = 0;
+            unsigned int i;
+
+            switch (headerType) {
+
+            case HEADER_TRM:
+              if ((packageCtr > 0) && (dataCtr != len)) {
+                /* Error invalid length */
                 fifo_flush(channel);
-                trb_errno = TRB_USER_BUFFER_OVF;
+                trb_errno = TRB_HDR_DLEN;
                 return -1;
               }
-            }
-            break;
+              break;
 
-          default:
-            fifo_flush(channel);
-            trb_errno = TRB_FIFO_INVALID_HEADER;
-            return -1;
-          }
-        }
-        break;
+            case HEADER_HDR:
+              if (packageCtr != 0) {
+                fifo_flush(channel);
+                trb_errno = TRB_FIFO_INVALID_HEADER;
+                return -1;
+              }
+              len = (unsigned int)package.F2;
+              break;
 
-      case FIFO_MODE_UID:
-        {
-          static uint32_t uidLow;
-          static uint32_t uidHigh;
-          static uint32_t sourceAddress;
+            case HEADER_DAT:
+              for (i = 0; (i < 2) && (dataCtr < len); i++) {
+                if (dataCtr < dsize) {
+                  data[dataCtr++] = (i == 0)
+                    ? (((uint32_t)package.F0 << 16) |
+                       ((uint32_t)package.F1))
+                    : (((uint32_t)package.F2 << 16) |
+                       ((uint32_t)package.F3));
+#ifdef TRB_DEBUGGER   
+                  fprintf(stderr, "D: 0x%08x\n", data[dataCtr - 1]);
+#endif
+                } else {
+                  userBufferOvf = 1;
+                }
+              }
+              break;
 
-          switch (headerType) {
-          case HEADER_HDR:
-            if ((packageCtr - endPointCtr * 3) != 0) {
+            default:
               fifo_flush(channel);
               trb_errno = TRB_FIFO_INVALID_HEADER;
               return -1;
             }
-            sourceAddress = (uint32_t)package.F0;
-            break;
+          }
+          break;
 
-          case HEADER_DAT:
-            if ((packageCtr - endPointCtr * 3) == 1) {
-              uidHigh = (((uint32_t)package.F0 <<  0) |
-                         ((uint32_t)package.F1 << 16));
-              uidLow = (((uint32_t)package.F2 <<  0) |
-                        ((uint32_t)package.F3 << 16));
+        case FIFO_MODE_UID:
+          {
+            static uint32_t uidLow;
+            static uint32_t uidHigh;
+            static uint32_t sourceAddress;
+
+            switch (headerType) {
+            case HEADER_HDR:
+              if ((packageCtr - endPointCtr * 3) != 0) {
+                fifo_flush(channel);
+                trb_errno = TRB_FIFO_INVALID_HEADER;
+                return -1;
+              }
+              sourceAddress = (uint32_t)package.F0;
               break;
-            }
 
-            if ((packageCtr - endPointCtr * 3) == 2) {
-              if ((dataCtr + 3) < dsize) {
-                /* store uid, endPoint and sourceAddress in userDataBuffer */
-                data[dataCtr++] = uidLow;
-                data[dataCtr++] = uidHigh;
-                data[dataCtr++] = (uint32_t)package.F0;
-                data[dataCtr++] = (uint32_t)sourceAddress;
-                endPointCtr++;
+            case HEADER_DAT:
+              if ((packageCtr - endPointCtr * 3) == 1) {
+                uidHigh = (((uint32_t)package.F0 <<  0) |
+                           ((uint32_t)package.F1 << 16));
+                uidLow = (((uint32_t)package.F2 <<  0) |
+                          ((uint32_t)package.F3 << 16));
+                break;
+              }
+
+              if ((packageCtr - endPointCtr * 3) == 2) {
+                if ((dataCtr + 3) < dsize) {
+                  /* store uid, endPoint and sourceAddress in userDataBuffer */
+                  data[dataCtr++] = uidLow;
+                  data[dataCtr++] = uidHigh;
+                  data[dataCtr++] = (uint32_t)package.F0;
+                  data[dataCtr++] = (uint32_t)sourceAddress;
+                  endPointCtr++;
 #ifdef TRB_DEBUGGER
-                fprintf(stderr, "D: 0x%04x  0x%08x%08x  0x%02x\n",
-                        (uint32_t)sourceAddress,
-                        uidLow, uidHigh, 
-                        (uint32_t)package.F0);
+                  fprintf(stderr, "D: 0x%04x  0x%08x%08x  0x%02x\n",
+                          (uint32_t)sourceAddress,
+                          uidLow, uidHigh, 
+                          (uint32_t)package.F0);
 #endif
-              } else {
-                fifo_flush(channel);
-                trb_errno = TRB_USER_BUFFER_OVF;
-                return -1;
+                } else {
+                  userBufferOvf = 1;
+                }
+                break;
               }
+            case HEADER_TRM:
               break;
-            }
-          case HEADER_TRM:
-            break;
 
-          default:
-            fifo_flush(channel);
-            trb_errno = TRB_FIFO_INVALID_HEADER;
-            return -1;
+            default:
+              fifo_flush(channel);
+              trb_errno = TRB_FIFO_INVALID_HEADER;
+              return -1;
+            }
           }
-        }
-        break;
+          break;
 
-      case FIFO_MODE_SET_ADDRESS:
-        if (headerType == HEADER_TRM) break;
+        case FIFO_MODE_SET_ADDRESS:
+          if (headerType == HEADER_TRM) break;
 
-        if ((packageCtr == 1) && (headerType == HEADER_DAT)) {
-          if (package.F0 != NET_ACKADDRESS) {
+          if ((packageCtr == 1) && (headerType == HEADER_DAT)) {
+            if (package.F0 != NET_ACKADDRESS) {
+              fifo_flush(channel);
+              return -1;
+            }
+          }
+
+          if (packageCtr > 1) {
             fifo_flush(channel);
+            trb_errno = TRB_INVALID_PKG_NUMBER;
             return -1;
           }
-        }
 
-        if (packageCtr > 1) {
+          dataCtr++;
+          break;
+
+        default:
           fifo_flush(channel);
-          trb_errno = TRB_INVALID_PKG_NUMBER;
+          trb_errno = TRB_FIFO_INVALID_MODE;
           return -1;
         }
-
-        dataCtr++;
-        break;
-
-      default:
-        fifo_flush(channel);
-        trb_errno = TRB_FIFO_INVALID_MODE;
-        return -1;
       }
     }
 
@@ -901,6 +892,12 @@ static int trb_fifo_read(uint8_t channel,
   trb_term.status_channel =  package.F1;
   trb_term.sequence = package.F3;
   trb_term.channel = channel;
+  
+  /* Check UserBufferOvf */
+  if (userBufferOvf == 1) {
+    trb_errno = TRB_USER_BUFFER_OVF;
+    return -1;
+  }
 
   /* Check whether last package is complete */
   if ((packageCtr >= 0) && (counter != 5)) {
@@ -978,6 +975,11 @@ static int unlockPorts()
 
 /* ----- Global Functions ----------------------------------------------- */
 
+int trb_connect(const char* server)
+{
+  return init_ports();
+}
+
 /* Intit FPGA Interface */
 int init_ports()
 {
@@ -1149,7 +1151,7 @@ int trb_register_read(uint16_t trb_address,
     trb_errno = TRB_INVALID_PKG_NUMBER;
     return -1;
   }
-
+  
   return status;
 }
 
@@ -1663,8 +1665,9 @@ int network_reset()
   }
 
   write32_to_FPGA(0x10, 0x0000);  
+  sleep(1);
   write32_to_FPGA(0x10, 0x8000);  
-  write32_to_FPGA(0x10, 0x8000);  
+  sleep(6);
   
   if (unlockPorts() == -1) return -1;