From 3e01e7e9a7b7c013403ea2c6ddb3186950f07ebf Mon Sep 17 00:00:00 2001
From: Mike Black W9MDB <mdblack98@yahoo.com>
Date: Thu, 1 Dec 2022 15:05:20 -0600
Subject: [PATCH] Balance the ELAPSED functions

---
 src/rig.c | 185 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 176 insertions(+), 9 deletions(-)

diff --git a/src/rig.c b/src/rig.c
index 03e5c7879..ff1521c1b 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -1733,6 +1733,7 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_EINVAL);
     }
 
@@ -1759,6 +1760,7 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 
     if (caps->set_freq == NULL)
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_ENAVAIL);
     }
 
@@ -1843,6 +1845,7 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC2(-RIG_ENAVAIL);
         }
 
@@ -1894,7 +1897,11 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
             HAMLIB_TRACE;
             retcode = rig_get_freq(rig, vfo, &freq_new);
 
-            if (retcode != RIG_OK) { RETURNFUNC(retcode); }
+            if (retcode != RIG_OK)
+            {
+                ELAPSED2;
+                RETURNFUNC(retcode);
+            }
         }
 
         if (freq_new != freq)
@@ -2006,6 +2013,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC2(retcode);
         }
 
@@ -2015,6 +2023,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
                       "%s: split is on so returning VFOA last known freq\n",
                       __func__);
             *freq = rig->state.cache.freqMainA;
+            ELAPSED2;
             return (RIG_OK);
         }
     }
@@ -2049,6 +2058,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
     if (caps->get_freq == NULL)
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_ENAVAIL);
     }
 
@@ -2092,6 +2102,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC2(-RIG_ENAVAIL);
         }
 
@@ -2100,6 +2111,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC2(retcode);
         }
 
@@ -2217,17 +2229,23 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_EINVAL);
     }
 
     rig_get_lock_mode(rig, &locked_mode);
 
-    if (locked_mode) { return (RIG_OK); }
+    if (locked_mode)
+    {
+        ELAPSED2;
+        return (RIG_OK);
+    }
 
     // do not mess with mode while PTT is on
     if (rig->state.cache.ptt)
     {
         rig_debug(RIG_DEBUG_VERBOSE, "%s PTT on so set_mode ignored\n", __func__);
+        ELAPSED2;
         return RIG_OK;
     }
 
@@ -2235,6 +2253,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
     if (caps->set_mode == NULL)
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_ENAVAIL);
     }
 
@@ -2287,6 +2306,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
         {
             rig_debug(RIG_DEBUG_TRACE, "%s: VFOB mode not changing so ignoring\n",
                       __func__);
+            ELAPSED2;
             RETURNFUNC2(RIG_OK);
         }
 
@@ -2294,6 +2314,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC2(-RIG_ENAVAIL);
         }
 
@@ -2305,6 +2326,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC2(retcode);
         }
 
@@ -2323,6 +2345,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     {
         rig_debug(RIG_DEBUG_TRACE, "%s: failed set_mode(%s)=%s\n",
                   __func__, rig_strrmode(mode), rigerror(retcode));
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -2368,11 +2391,13 @@ int HAMLIB_API rig_get_mode(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!mode || !width)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2380,6 +2405,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
 
     if (caps->get_mode == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -2437,6 +2463,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC(-RIG_ENAVAIL);
         }
 
@@ -2450,6 +2477,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -2685,12 +2713,17 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     vfo = vfo_fixup(rig, vfo, rig->state.cache.split);
 
-    if (vfo == RIG_VFO_CURR) { RETURNFUNC(RIG_OK); }
+    if (vfo == RIG_VFO_CURR)
+    {
+        ELAPSED2;
+        RETURNFUNC(RIG_OK);
+    }
 
     if (rig->caps->get_vfo)
     {
@@ -2712,6 +2745,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: rig does not have %s\n", __func__,
                   rig_strvfo(vfo));
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2719,6 +2753,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: rig does not have %s\n", __func__,
                   rig_strvfo(vfo));
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2730,6 +2765,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
 
     if (caps->set_vfo == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -2737,6 +2773,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
     {
         rig_debug(RIG_DEBUG_TRACE, "%s: Ignoring set_vfo due to VFO twiddling\n",
                   __func__);
+        ELAPSED2;
         RETURNFUNC(
             RIG_OK); // would be better as error but other software won't handle errors
     }
@@ -2822,6 +2859,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
 
     if (CHECK_RIG_ARG(rig) || !vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2829,6 +2867,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: no vfo?  rig=%p, vfo=%p\n", __func__,
                   rig, vfo);
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2837,6 +2876,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
     if (caps->get_vfo == NULL)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: no get_vfo\n", __func__);
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -2905,6 +2945,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -2922,6 +2963,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     case RIG_PTT_RIG_MICDATA:
         if (caps->set_ptt == NULL)
         {
+            ELAPSED2;
             RETURNFUNC(-RIG_ENIMPL);
         }
 
@@ -2937,7 +2979,11 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
                 HAMLIB_TRACE;
                 retcode = caps->set_ptt(rig, vfo, ptt);
 
-                if (retcode != RIG_OK) { RETURNFUNC(retcode); }
+                if (retcode != RIG_OK)
+                {
+                    ELAPSED2;
+                    RETURNFUNC(retcode);
+                }
 
 #if 0
                 hl_usleep(50 * 1000); // give PTT a chance to do it's thing
@@ -2972,6 +3018,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 
             if (!caps->set_vfo)
             {
+                ELAPSED2;
                 RETURNFUNC(-RIG_ENAVAIL);
             }
 
@@ -3005,7 +3052,11 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
                     HAMLIB_TRACE;
                     retcode = caps->set_ptt(rig, vfo, ptt);
 
-                    if (retcode != RIG_OK) { RETURNFUNC(retcode); }
+                    if (retcode != RIG_OK)
+                    {
+                        ELAPSED2;
+                        RETURNFUNC(retcode);
+                    }
 
 #if 0
                     retcode = rig_get_ptt(rig, vfo, &tptt);
@@ -3057,6 +3108,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
                           "%s: cannot open PTT device \"%s\"\n",
                           __func__,
                           rs->pttport.pathname);
+                ELAPSED2;
                 RETURNFUNC(-RIG_EIO);
             }
 
@@ -3067,6 +3119,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 
             if (RIG_OK != retcode)
             {
+                ELAPSED2;
                 RETURNFUNC(retcode);
             }
         }
@@ -3105,6 +3158,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
                           "%s: cannot open PTT device \"%s\"\n",
                           __func__,
                           rs->pttport.pathname);
+                ELAPSED2;
                 RETURNFUNC(-RIG_EIO);
             }
 
@@ -3116,6 +3170,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
             if (RIG_OK != retcode)
             {
                 rig_debug(RIG_DEBUG_ERR, "%s: ser_set_dtr retcode=%d\n", __func__, retcode);
+                ELAPSED2;
                 RETURNFUNC(retcode);
             }
         }
@@ -3148,6 +3203,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
         break;
 
     default:
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3204,11 +3260,13 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!ptt)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3259,6 +3317,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC(-RIG_ENAVAIL);
         }
 
@@ -3283,6 +3342,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3318,6 +3378,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
                 rig->state.cache.ptt = *ptt;
             }
 
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3351,6 +3412,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
                 rig->state.cache.ptt = *ptt;
             }
 
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3384,6 +3446,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
                 rig->state.cache.ptt = *ptt;
             }
 
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3410,6 +3473,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
                 rig->state.cache.ptt = *ptt;
             }
 
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3437,6 +3501,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
                 rig->state.cache.ptt = *ptt;
             }
 
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3446,9 +3511,11 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
         RETURNFUNC(retcode);
 
     case RIG_PTT_NONE:
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);    /* not available */
 
     default:
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3477,15 +3544,18 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
     int retcode, rc2, status;
     vfo_t curr_vfo;
 
+    ELAPSED1;
     ENTERFUNC;
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!dcd)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3496,6 +3566,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
     case RIG_DCD_RIG:
         if (caps->get_dcd == NULL)
         {
+            ELAPSED2;
             RETURNFUNC(-RIG_ENIMPL);
         }
 
@@ -3504,11 +3575,13 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         {
             HAMLIB_TRACE;
             retcode = caps->get_dcd(rig, vfo, dcd);
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
         if (!caps->set_vfo)
         {
+            ELAPSED2;
             RETURNFUNC(-RIG_ENAVAIL);
         }
 
@@ -3518,6 +3591,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
 
@@ -3532,6 +3606,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
             retcode = rc2;
         }
 
+        ELAPSED2;
         RETURNFUNC(retcode);
 
         break;
@@ -3541,6 +3616,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
                sizeof(rig->state.dcdport_deprecated));
         *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
+        ELAPSED2;
         RETURNFUNC(retcode);
 
     case RIG_DCD_SERIAL_DSR:
@@ -3548,6 +3624,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
                sizeof(rig->state.dcdport_deprecated));
         *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
+        ELAPSED2;
         RETURNFUNC(retcode);
 
     case RIG_DCD_SERIAL_CAR:
@@ -3555,6 +3632,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
                sizeof(rig->state.dcdport_deprecated));
         *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
+        ELAPSED2;
         RETURNFUNC(retcode);
 
 
@@ -3562,6 +3640,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         retcode = par_dcd_get(&rig->state.dcdport, dcd);
         memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
                sizeof(rig->state.dcdport_deprecated));
+        ELAPSED2;
         RETURNFUNC(retcode);
 
     case RIG_DCD_GPIO:
@@ -3569,15 +3648,19 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
         retcode = gpio_dcd_get(&rig->state.dcdport, dcd);
         memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
                sizeof(rig->state.dcdport_deprecated));
+        ELAPSED2;
         RETURNFUNC(retcode);
 
     case RIG_DCD_NONE:
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);    /* not available */
 
     default:
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
+    ELAPSED2;
     RETURNFUNC(RIG_OK);
 }
 
@@ -3602,10 +3685,12 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    ELAPSED1;
     ENTERFUNC;
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3613,6 +3698,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
 
     if (caps->set_rptr_shift == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3621,11 +3707,13 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
     {
         HAMLIB_TRACE;
         retcode = caps->set_rptr_shift(rig, vfo, rptr_shift);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
     if (!caps->set_vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3635,6 +3723,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -3649,6 +3738,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
         retcode = rc2;
     }
 
+    ELAPSED2;
     RETURNFUNC(retcode);
 }
 
@@ -3673,15 +3763,18 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    ELAPSED1;
     ENTERFUNC;
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!rptr_shift)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3689,6 +3782,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
 
     if (caps->get_rptr_shift == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3697,11 +3791,13 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
     {
         HAMLIB_TRACE;
         retcode = caps->get_rptr_shift(rig, vfo, rptr_shift);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
     if (!caps->set_vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3711,6 +3807,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -3725,6 +3822,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
         retcode = rc2;
     }
 
+    ELAPSED2;
     RETURNFUNC(retcode);
 }
 
@@ -3749,10 +3847,12 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    ELAPSED1;
     ENTERFUNC;
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3760,6 +3860,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
 
     if (caps->set_rptr_offs == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3768,6 +3869,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
     {
         HAMLIB_TRACE;
         retcode = caps->set_rptr_offs(rig, vfo, rptr_offs);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -3776,12 +3878,15 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
+    ELAPSED2;
+
     curr_vfo = rig->state.current_vfo;
     HAMLIB_TRACE;
     retcode = caps->set_vfo(rig, vfo);
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -3795,6 +3900,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
         retcode = rc2;
     }
 
+    ELAPSED2;
     RETURNFUNC(retcode);
 }
 
@@ -3819,15 +3925,18 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    ELAPSED1;
     ENTERFUNC;
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!rptr_offs)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -3835,6 +3944,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
 
     if (caps->get_rptr_offs == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3843,11 +3953,13 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
     {
         HAMLIB_TRACE;
         retcode = caps->get_rptr_offs(rig, vfo, rptr_offs);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
     if (!caps->set_vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -3857,6 +3969,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -3870,6 +3983,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
         retcode = rc2;
     }
 
+    ELAPSED2;
     RETURNFUNC(retcode);
 }
 
@@ -3899,6 +4013,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_EINVAL);
     }
 
@@ -3924,6 +4039,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
     if (tfreq == tx_freq)
     {
         rig_debug(RIG_DEBUG_TRACE, "%s: freq set not needed\n", __func__);
+        ELAPSED2;
         RETURNFUNC2(RIG_OK);
     }
 
@@ -3982,11 +4098,13 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
     }
     else
     {
+        ELAPSED2;
         RETURNFUNC2(-RIG_ENAVAIL);
     }
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC2(retcode);
     }
 
@@ -4064,11 +4182,13 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!tx_freq)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4104,6 +4224,7 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
     {
         HAMLIB_TRACE;
         retcode = caps->get_freq(rig, tx_vfo, tx_freq);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4128,11 +4249,13 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
     }
     else
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4219,6 +4342,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4229,6 +4353,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
     {
         rig_debug(RIG_DEBUG_TRACE, "%s: mode already %s so no change required\n",
                   __func__, rig_strrmode(tx_mode));
+        ELAPSED2;
         RETURNFUNC(RIG_OK);
     }
     else
@@ -4331,6 +4456,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
     {
         // special handlingt for netrigctl to avoid set_vfo
         retcode = caps->set_split_mode(rig, vfo, tx_mode, tx_width);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4356,6 +4482,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4436,11 +4563,13 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!tx_mode || !tx_width)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4474,6 +4603,7 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
     {
         HAMLIB_TRACE;
         retcode = caps->get_mode(rig, tx_vfo, tx_mode, tx_width);
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4490,11 +4620,13 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
     }
     else
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -4532,6 +4664,7 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
         *tx_width = rig_passband_normal(rig, *tx_mode);
     }
 
+    ELAPSED2;
     RETURNFUNC(retcode);
 }
 
@@ -4574,6 +4707,7 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4692,11 +4826,13 @@ int HAMLIB_API rig_get_split_freq_mode(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (!tx_freq || !tx_mode || !tx_width)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4755,6 +4891,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4762,6 +4899,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
     if (caps->set_split_vfo == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -4839,6 +4977,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
     if (!caps->set_vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -4851,6 +4990,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
         if (retcode != RIG_OK)
         {
+            ELAPSED2;
             RETURNFUNC(retcode);
         }
     }
@@ -4919,6 +5059,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4926,6 +5067,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
     {
         rig_debug(RIG_DEBUG_ERR, "%s: split or tx_vfo is null, split=%p, tx_vfo=%p\n",
                   __func__, split, tx_vfo);
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -4983,6 +5125,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
 
     if (!caps->set_vfo)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -4992,6 +5135,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -6036,6 +6180,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -6045,6 +6190,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
     {
         rig_debug(RIG_DEBUG_WARN, "%s: vfo_op=%p, has_vfo_op=%d\n", __func__,
                   caps->vfo_op, rig_has_vfo_op(rig, op));
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -6069,6 +6215,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
     if (retcode != RIG_OK)
     {
+        ELAPSED2;
         RETURNFUNC(retcode);
     }
 
@@ -6712,11 +6859,13 @@ int HAMLIB_API rig_set_vfo_opt(RIG *rig, int status)
 
     if CHECK_RIG_ARG(rig)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
     if (rig->caps->set_vfo_opt == NULL)
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_ENAVAIL);
     }
 
@@ -6829,7 +6978,11 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
     vfoB = vfo_fixup(rig, RIG_VFO_B, rig->state.cache.split);
     ret = rig_get_vfo_info(rig, vfoA, &freqA, &modeA, &widthA, &split, &satmode);
 
-    if (ret != RIG_OK) { RETURNFUNC2(ret); }
+    if (ret != RIG_OK)
+    {
+        ELAPSED2;
+        RETURNFUNC2(ret);
+    }
 
     // we need both vfo and mode targetable to avoid vfo swapping
     if ((rig->caps->targetable_vfo & RIG_TARGETABLE_FREQ)
@@ -6837,7 +6990,11 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
     {
         ret = rig_get_vfo_info(rig, vfoB, &freqB, &modeB, &widthB, &split, &satmode);
 
-        if (ret != RIG_OK) { RETURNFUNC2(ret); }
+        if (ret != RIG_OK)
+        {
+            ELAPSED2;
+            RETURNFUNC2(ret);
+        }
     }
     else
     {
@@ -6873,6 +7030,7 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
     {
         rig_debug(RIG_DEBUG_ERR, "%s(%d): response len exceeded max %d chars\n",
                   __FILE__, __LINE__, max_response_len);
+        ELAPSED2;
         RETURNFUNC2(RIG_EINTERNAL);
     }
 
@@ -6908,6 +7066,7 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
 
     if (CHECK_RIG_ARG(rig))
     {
+        ELAPSED2;
         RETURNFUNC(-RIG_EINVAL);
     }
 
@@ -6934,7 +7093,11 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
         HAMLIB_TRACE;
         retval = rig_get_mode(rig, vfo, mode, width);
 
-        if (retval != RIG_OK) { RETURNFUNC(retval); }
+        if (retval != RIG_OK)
+        {
+            ELAPSED2;
+            RETURNFUNC(retval);
+        }
     }
     else // we'll just us VFOA so we don't swap vfos -- freq is what's important
     {
@@ -6948,7 +7111,11 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
     vfo_t tx_vfo;
     retval = rig_get_split_vfo(rig, RIG_VFO_CURR, split, &tx_vfo);
 
-    if (retval != RIG_OK) { RETURNFUNC(retval); }
+    if (retval != RIG_OK)
+    {
+        ELAPSED2;
+        RETURNFUNC(retval);
+    }
 
     ELAPSED2;
     RETURNFUNC(RIG_OK);