Ran clang-format on all FE code in src/fe and src/include/drv directories. No other changes.

src/fe/commData3.c

 /// 	@file commData3.c
 ///	@brief This is the generic software for communicating realtime data
-///between CDS applications.
+/// between CDS applications.
 ///	@detail This software supports data communication via: \n
 ///		1) Shared memory, between two processes on the same computer \n
 ///		2) GE Fanuc 5565 Reflected Memory PCIe hardware \n
@@ -29,7 +29,7 @@
 #endif
 
 ///	This function is called from the user application to initialize
-///communications structures 	and pointers.
+/// communications structures 	and pointers.
 ///	@param[in] connects = total number of IPC connections in the application
 ///	@param[in] rate = Sample rate of the calling application eg 2048
 ///	@param[in,out] ipcInfo[] = Stucture to hold information about each IPC
@@ -233,12 +233,12 @@ commData3Init(
 
 // *************************************************************************************************
 ///	This function is called from the user application to send data via IPC
-///connections.
+/// connections.
 ///	@param[in] connects = total number of IPC connections in the application
 ///	@param[in,out] ipcInfo[] = Stucture to hold information about each IPC
 ///	@param[in] timeSec = Present GPS time in GPS seconds
 ///	@param[in] cycle = Present cycle of the user application making this
-///call.
+/// call.
 INLINE void commData3Send(
     int          connects, // Total number of IPC connections in the application
     CDS_IPC_INFO ipcInfo[], // IPC information structure
@@ -322,10 +322,10 @@ INLINE void commData3Send(
     if ( lastPcie >= 0 )
     {
         clflush_cache_range(
-            (void *)&( ipcInfo[ lastPcie ]
-                   .pIpcDataWrite[ 0 ]
-                   ->dBlock[ sendBlock ][ ipcInfo[ lastPcie ].ipcNum ]
-                   .data ),
+            (void*)&( ipcInfo[ lastPcie ]
+                          .pIpcDataWrite[ 0 ]
+                          ->dBlock[ sendBlock ][ ipcInfo[ lastPcie ].ipcNum ]
+                          .data ),
             16 );
     }
     lastPcie = -1;
@@ -381,22 +381,22 @@ INLINE void commData3Send(
     if ( lastPcie >= 0 )
     {
         clflush_cache_range(
-            (void *)&( ipcInfo[ lastPcie ]
-                   .pIpcDataWrite[ 0 ]
-                   ->dBlock[ sendBlock ][ ipcInfo[ lastPcie ].ipcNum ]
-                   .data ),
+            (void*)&( ipcInfo[ lastPcie ]
+                          .pIpcDataWrite[ 0 ]
+                          ->dBlock[ sendBlock ][ ipcInfo[ lastPcie ].ipcNum ]
+                          .data ),
             16 );
     }
 }
 
 // *************************************************************************************************
 ///	This function is called from the user application to receive data via
-///IPC connections.
+/// IPC connections.
 ///	@param[in] connects = total number of IPC connections in the application
 ///	@param[in,out] ipcInfo[] = Stucture to hold information about each IPC
 ///	@param[in] timeSec = Present GPS time in GPS seconds
 ///	@param[in] cycle = Present cycle of the user application making this
-///call.
+/// call.
 INLINE void commData3Receive(
     int          connects, // Total number of IPC connections in the application
     CDS_IPC_INFO ipcInfo[], // IPC information structure
@@ -417,8 +417,8 @@ INLINE void commData3Receive(
     int    rcvBlock; // Which of the IPC_BLOCKS IPC data blocks to read from
     double tmp; // Temp location for data for checking NaN
     // static unsigned long ptim = 0;	// last printing time
-    // static unsigned long nskipped = 0;	// number of skipped error messages
-    // (couldn't print that fast)
+    // static unsigned long nskipped = 0;	// number of skipped error
+    // messages (couldn't print that fast)
 
     // Determine which block to read, based on present code cycle
     rcvBlock = ( ( cycle ) * ( IPC_MAX_RATE / IPC_RATE ) ) % IPC_BLOCKS;

src/fe/timing.c

@@ -5,13 +5,15 @@
 /// \brief Get current kernel time (in GPS)
 ///	@return Current time in form of GPS Seconds.
 //***********************************************************************
-inline unsigned long current_time_fe(void) {
-    struct timespec t;
-    extern struct timespec current_kernel_time(void);
-    	t = current_kernel_time();
-	// Added leap second for July 1, 2015
-        t.tv_sec += - 315964819 + 33 + 3 + 1;
-        return t.tv_sec;
+inline unsigned long
+current_time_fe( void )
+{
+    struct timespec        t;
+    extern struct timespec current_kernel_time( void );
+    t = current_kernel_time( );
+    // Added leap second for July 1, 2015
+    t.tv_sec += -315964819 + 33 + 3 + 1;
+    return t.tv_sec;
 }
 
 //***********************************************************************
@@ -19,65 +21,66 @@ inline unsigned long current_time_fe(void) {
 ///< Code should only run on IOP
 //***********************************************************************
 #ifdef ADC_MASTER
-inline float duotime(int count, float meanVal, float data[])
+inline float
+duotime( int count, float meanVal, float data[] )
 {
-  float x,y,sumX,sumY,sumXX,sumXY,msumX;
-  int ii;
-  float xInc;
-  float offset,slope,answer;
-  float den;
-
-  x = 0;
-  sumX = 0;
-  sumY = 0;
-  sumXX = 0;
-  sumXY= 0;
-  xInc = 1000000/IOP_IO_RATE;
-
+    float x, y, sumX, sumY, sumXX, sumXY, msumX;
+    int   ii;
+    float xInc;
+    float offset, slope, answer;
+    float den;
 
-  for(ii=0;ii<count;ii++)
-  {
-          y = data[ii];
-          sumX += x;
-          sumY += y;
-          sumXX += x * x;
-          sumXY += x * y;
-          x += xInc;
-  }
-  msumX = sumX * -1;
-  den = (count*sumXX-sumX*sumX);
-  if(den == 0.0)
-  {
-          return(-1000);
-  }
-  offset = (msumX*sumXY+sumXX*sumY)/den;
-  slope = (msumX*sumY+count*sumXY)/den;
-  if(slope == 0.0)
-  {
-          return(-1000);
-  }
-  meanVal -= offset;
-  answer = meanVal/slope - 91.552;
-  return(answer);
+    x = 0;
+    sumX = 0;
+    sumY = 0;
+    sumXX = 0;
+    sumXY = 0;
+    xInc = 1000000 / IOP_IO_RATE;
 
+    for ( ii = 0; ii < count; ii++ )
+    {
+        y = data[ ii ];
+        sumX += x;
+        sumY += y;
+        sumXX += x * x;
+        sumXY += x * y;
+        x += xInc;
+    }
+    msumX = sumX * -1;
+    den = ( count * sumXX - sumX * sumX );
+    if ( den == 0.0 )
+    {
+        return ( -1000 );
+    }
+    offset = ( msumX * sumXY + sumXX * sumY ) / den;
+    slope = ( msumX * sumY + count * sumXY ) / den;
+    if ( slope == 0.0 )
+    {
+        return ( -1000 );
+    }
+    meanVal -= offset;
+    answer = meanVal / slope - 91.552;
+    return ( answer );
 }
-inline void initializeDuotoneDiags(duotone_diag_t *dt_diag)
+inline void
+initializeDuotoneDiags( duotone_diag_t* dt_diag )
 {
-  int ii;
-    for(ii=0;ii<IOP_IO_RATE;ii++) {
-        dt_diag->adc[ii] = 0;
-        dt_diag->dac[ii] = 0;
+    int ii;
+    for ( ii = 0; ii < IOP_IO_RATE; ii++ )
+    {
+        dt_diag->adc[ ii ] = 0;
+        dt_diag->dac[ ii ] = 0;
     }
     dt_diag->totalAdc = 0.0;
     dt_diag->totalDac = 0.0;
     dt_diag->meanAdc = 0.0;
     dt_diag->meanDac = 0.0;
     dt_diag->dacDuoEnable = 0.0;
-
 }
 #endif
 
-inline void initializeTimingDiags(timing_diag_t *timeinfo)
+inline void
+initializeTimingDiags( timing_diag_t* timeinfo )
 {
     timeinfo->cpuTimeEverMax = 0;
     timeinfo->cpuTimeEverMaxWhen = 0;
@@ -89,11 +92,11 @@ inline void initializeTimingDiags(timing_diag_t *timeinfo)
     timeinfo->timeHoldWhenHold = 0;
     timeinfo->usrTime = 0;
     timeinfo->cycleTime = 0;
-
 }
-inline void sendTimingDiags2Epics(volatile CDS_EPICS *pLocalEpics, 
-                                  timing_diag_t *timeinfo,
-                                  adcInfo_t *adcinfo)
+inline void
+sendTimingDiags2Epics( volatile CDS_EPICS* pLocalEpics,
+                       timing_diag_t*      timeinfo,
+                       adcInfo_t*          adcinfo )
 {
     pLocalEpics->epicsOutput.cpuMeter = timeinfo->timeHold;
     pLocalEpics->epicsOutput.cpuMeterMax = timeinfo->timeHoldMax;
@@ -103,41 +106,50 @@ inline void sendTimingDiags2Epics(volatile CDS_EPICS *pLocalEpics,
     timeinfo->timeHoldWhenHold = timeinfo->timeHoldWhen;
     timeinfo->usrHoldTime = 0;
 
-    pLocalEpics->epicsOutput.adcWaitTime = adcinfo->adcHoldTimeAvg/(CYCLE_PER_SECOND / UNDERSAMPLE);
+    pLocalEpics->epicsOutput.adcWaitTime =
+        adcinfo->adcHoldTimeAvg / ( CYCLE_PER_SECOND / UNDERSAMPLE );
     pLocalEpics->epicsOutput.adcWaitMin = adcinfo->adcHoldTimeMin;
     pLocalEpics->epicsOutput.adcWaitMax = adcinfo->adcHoldTimeMax;
 
-    adcinfo->adcHoldTimeAvgPerSec = adcinfo->adcHoldTimeAvg/CYCLE_PER_SECOND;
+    adcinfo->adcHoldTimeAvgPerSec = adcinfo->adcHoldTimeAvg / CYCLE_PER_SECOND;
     adcinfo->adcHoldTimeMax = 0;
     adcinfo->adcHoldTimeMin = 0xffff;
     adcinfo->adcHoldTimeAvg = 0;
-
 }
-inline void captureEocTiming(int cycle, unsigned int cycle_gps, timing_diag_t *timeinfo,adcInfo_t *adcinfo)
+inline void
+captureEocTiming( int            cycle,
+                  unsigned int   cycle_gps,
+                  timing_diag_t* timeinfo,
+                  adcInfo_t*     adcinfo )
 {
 
     // Hold the max cycle time over the last 1 second
-    if(timeinfo->cycleTime > timeinfo->timeHold) { 
-      timeinfo->timeHold = timeinfo->cycleTime;
-      timeinfo->timeHoldWhen = cycle;
+    if ( timeinfo->cycleTime > timeinfo->timeHold )
+    {
+        timeinfo->timeHold = timeinfo->cycleTime;
+        timeinfo->timeHoldWhen = cycle;
     }
     // Hold the max cycle time since last diag reset
-    if(timeinfo->cycleTime > timeinfo->timeHoldMax) timeinfo->timeHoldMax = timeinfo->cycleTime;
+    if ( timeinfo->cycleTime > timeinfo->timeHoldMax )
+        timeinfo->timeHoldMax = timeinfo->cycleTime;
     // Avoid calculating the max hold time for the first few seconds
     // if (cycle != 0 && (timeinfo->startGpsTime+3) < cycle_gps) {
-    if ((timeinfo->startGpsTime+3) < cycle_gps) {
-      if(adcinfo->adcHoldTime > adcinfo->adcHoldTimeMax) 
-        adcinfo->adcHoldTimeMax = adcinfo->adcHoldTime;
-      if(adcinfo->adcHoldTime < adcinfo->adcHoldTimeMin) 
-        adcinfo->adcHoldTimeMin = adcinfo->adcHoldTime;
-      adcinfo->adcHoldTimeAvg += adcinfo->adcHoldTime;
-      if (adcinfo->adcHoldTimeMax > adcinfo->adcHoldTimeEverMax)  {
-        adcinfo->adcHoldTimeEverMax = adcinfo->adcHoldTimeMax;
-        adcinfo->adcHoldTimeEverMaxWhen = cycle_gps;
-      }
-      if (timeinfo->timeHoldMax > timeinfo->cpuTimeEverMax)  {
-        timeinfo->cpuTimeEverMax = timeinfo->timeHoldMax;
-        timeinfo->cpuTimeEverMaxWhen = cycle_gps;
-      }
+    if ( ( timeinfo->startGpsTime + 3 ) < cycle_gps )
+    {
+        if ( adcinfo->adcHoldTime > adcinfo->adcHoldTimeMax )
+            adcinfo->adcHoldTimeMax = adcinfo->adcHoldTime;
+        if ( adcinfo->adcHoldTime < adcinfo->adcHoldTimeMin )
+            adcinfo->adcHoldTimeMin = adcinfo->adcHoldTime;
+        adcinfo->adcHoldTimeAvg += adcinfo->adcHoldTime;
+        if ( adcinfo->adcHoldTimeMax > adcinfo->adcHoldTimeEverMax )
+        {
+            adcinfo->adcHoldTimeEverMax = adcinfo->adcHoldTimeMax;
+            adcinfo->adcHoldTimeEverMaxWhen = cycle_gps;
+        }
+        if ( timeinfo->timeHoldMax > timeinfo->cpuTimeEverMax )
+        {
+            timeinfo->cpuTimeEverMax = timeinfo->timeHoldMax;
+            timeinfo->cpuTimeEverMaxWhen = cycle_gps;
+        }
     }
 }