Convert rigs/yaesu

No more code references to raw port structures in rigs/*

rigs/yaesu/frg100.c

@@ -253,7 +253,7 @@ static int frg100_do_transaction(RIG *rig,
                                  const unsigned char cmd[YAESU_CMD_LENGTH],
                                  unsigned char *retbuf, size_t retbuf_len)
 {
-    struct rig_state    *rs;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char       default_retbuf[1];
     int                 retval;
 
@@ -263,15 +263,14 @@ static int frg100_do_transaction(RIG *rig,
         retbuf_len = sizeof(default_retbuf);
     }
 
-    rs = &rig->state;
     memset(retbuf, 0, retbuf_len);
 
-    rig_flush(&rs->rigport);
+    rig_flush(rp);
-    retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval != RIG_OK) { return retval; }
 
-    retval = read_block(&rs->rigport, retbuf, retbuf_len);
+    retval = read_block(rp, retbuf, retbuf_len);
 
     if (retval != retbuf_len)
     {
@@ -353,7 +352,7 @@ int frg100_open(RIG *rig)
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
     /* send 0 delay pacing */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
 }
 
@@ -372,7 +371,7 @@ int frg100_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     to_bcd(cmd, freq / 10, 8);
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -384,7 +383,7 @@ int frg100_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     /* fill in p1 */
     cmd[3] = mode2rig(rig, mode, width);
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -400,7 +399,7 @@ int frg100_set_powerstat(RIG *rig, powerstat_t status)
     cmd[3] = status == RIG_POWER_OFF ? 0x00 : 0x01;
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -428,7 +427,7 @@ int frg100_set_vfo(RIG *rig, vfo_t vfo)
         return -RIG_EINVAL;     /* sorry, wrong VFO */
     }
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -436,16 +435,17 @@ int frg100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xf7};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     if (level != RIG_LEVEL_RAWSTR)
     {
         return -RIG_EINVAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     /* send READ STATUS(Meter only) cmd to rig  */
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -453,7 +453,7 @@ int frg100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 5);
+    retval = read_block(rp, cmd, 5);
 
     if (retval < 1)
     {

rigs/yaesu/frg8800.c

@@ -160,7 +160,7 @@ int frg8800_open(RIG *rig)
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
     /* send Ext Cntl ON: Activate CAT */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
 }
 
@@ -171,7 +171,7 @@ int frg8800_close(RIG *rig)
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
     /* send Ext Cntl OFF: Deactivate CAT */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
 }
 
@@ -189,7 +189,7 @@ int frg8800_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     cmd[0] = (cmd[0] & 0xf0) | (1 << ((((long long)freq) % 100) / 25));
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -232,7 +232,7 @@ int frg8800_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     cmd[3] = md;
 
     /* Mode set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -246,6 +246,6 @@ int frg8800_set_powerstat(RIG *rig, powerstat_t status)
     cmd[3] = status == RIG_POWER_OFF ? 0xff : 0xfe;
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 

rigs/yaesu/frg9600.c

@@ -148,7 +148,7 @@ int frg9600_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     to_bcd_be(cmd + 1, freq / 10, 8);
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -191,6 +191,6 @@ int frg9600_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     cmd[0] = md;
 
     /* Mode set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 

rigs/yaesu/ft100.c

@@ -526,20 +526,21 @@ static int ft100_send_priv_cmd(RIG *rig, unsigned char cmd_index)
 
     if (!rig) { return -RIG_EINVAL; }
 
-    return write_block(&rig->state.rigport, (unsigned char *) &ncmd[cmd_index].nseq,
+    return write_block(RIGPORT(rig), (unsigned char *) &ncmd[cmd_index].nseq,
                        YAESU_CMD_LENGTH);
 }
 
 static int ft100_read_status(RIG *rig)
 {
     struct ft100_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int ret;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
     priv = (struct ft100_priv_data *)rig->state.priv;
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     ret = ft100_send_priv_cmd(rig, FT100_NATIVE_CAT_READ_STATUS);
 
@@ -548,7 +549,7 @@ static int ft100_read_status(RIG *rig)
         return ret;
     }
 
-    ret = read_block(&rig->state.rigport, (unsigned char *) &priv->status,
+    ret = read_block(rp, (unsigned char *) &priv->status,
                      sizeof(FT100_STATUS_INFO));
     rig_debug(RIG_DEBUG_VERBOSE, "%s: read status=%i \n", __func__, ret);
 
@@ -564,10 +565,11 @@ static int ft100_read_flags(RIG *rig)
 {
     struct ft100_priv_data *priv = (struct ft100_priv_data *)rig->state.priv;
     int ret;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     ret = ft100_send_priv_cmd(rig, FT100_NATIVE_CAT_READ_FLAGS);
 
@@ -576,7 +578,7 @@ static int ft100_read_flags(RIG *rig)
         return ret;
     }
 
-    ret = read_block(&rig->state.rigport, (unsigned char *) &priv->flags,
+    ret = read_block(rp, (unsigned char *) &priv->flags,
                      sizeof(FT100_FLAG_INFO));
     rig_debug(RIG_DEBUG_VERBOSE, "%s: read flags=%i \n", __func__, ret);
 
@@ -605,7 +607,7 @@ int ft100_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     freq = (int) freq / 10;
     to_bcd(p_cmd, freq, 8); /* store bcd format in in p_cmd */
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 int ft100_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
@@ -731,7 +733,7 @@ int ft100_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
         else if (width <= 2400) { p_cmd[3] = 0x00; }
         else { p_cmd[3] = 0x01; }
 
-        ret = write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+        ret = write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 
         if (ret != RIG_OK)
         {
@@ -992,7 +994,7 @@ int ft100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
         return ret;
     }
 
-    ret = read_block(&rig->state.rigport, (unsigned char *) &ft100_meter,
+    ret = read_block(RIGPORT(rig), (unsigned char *) &ft100_meter,
                      sizeof(FT100_METER_INFO));
     rig_debug(RIG_DEBUG_VERBOSE, "%s: read meters=%d\n", __func__, ret);
 
@@ -1209,7 +1211,7 @@ int ft100_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
 
     p_cmd[3] = (char)pcode;
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 int ft100_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
@@ -1263,7 +1265,7 @@ int ft100_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
 
     p_cmd[3] = (char)ptone;
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 int ft100_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)

rigs/yaesu/ft1000d.c

@@ -633,7 +633,6 @@ static int ft1000d_cleanup(RIG *rig)
  */
 static int  ft1000d_open(RIG *rig)
 {
-    struct rig_state *rig_s;
     struct ft1000d_priv_data *priv;
     int err;
 
@@ -645,12 +644,11 @@ static int  ft1000d_open(RIG *rig)
     }
 
     priv = (struct ft1000d_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, RIGPORT(rig)->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, RIGPORT(rig)->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -2648,7 +2646,7 @@ static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level,
         return err;
     }
 
-    err = read_block(&rig->state.rigport, mdata, FT1000D_READ_METER_LENGTH);
+    err = read_block(RIGPORT(rig), mdata, FT1000D_READ_METER_LENGTH);
 
     if (err < 0)
     {
@@ -3451,7 +3449,7 @@ static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
 static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
                                    unsigned short ch)
 {
-    struct rig_state *rig_s;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct ft1000d_priv_data *priv;
     int n;
     int err;
@@ -3470,9 +3468,8 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
     }
 
     priv = (struct ft1000d_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
-    retry = rig_s->rigport.retry;
+    retry = rp->retry;
 
     do
     {
@@ -3541,7 +3538,7 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
             return -RIG_EINVAL;
         }
 
-        n = read_block(&rig->state.rigport, p, rl);
+        n = read_block(rp, p, rl);
 
     }
     while (n < 0 && retry-- >= 0);
@@ -3575,6 +3572,7 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
 static int ft1000d_send_static_cmd(RIG *rig, unsigned char ci)
 {
     int err;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
     rig_debug(RIG_DEBUG_TRACE, "%s: ci = 0x%02x\n", __func__, ci);
@@ -3591,15 +3589,14 @@ static int ft1000d_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq,
+    err = write_block(rp, ncmd[ci].nseq, YAESU_CMD_LENGTH);
-                      YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
         return err;
     }
 
-    hl_usleep(rig->state.rigport.write_delay * 1000);
+    hl_usleep(rp->write_delay * 1000);
     return RIG_OK;
 }
 
@@ -3621,6 +3618,7 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
                                     unsigned char p3, unsigned char p4)
 {
     struct ft1000d_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int err;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@@ -3652,15 +3650,14 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[1] = p3;
     priv->p_cmd[0] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
-                      YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
         return err;
     }
 
-    hl_usleep(rig->state.rigport.write_delay * 1000);
+    hl_usleep(rp->write_delay * 1000);
     return RIG_OK;
 }
 
@@ -3679,6 +3676,7 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
 static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
 {
     struct ft1000d_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int err;
     // cppcheck-suppress *
     char *fmt = "%s: requested freq after conversion = %"PRIll" Hz\n";
@@ -3711,15 +3709,14 @@ static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT1000D_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
-                      YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
         return err;
     }
 
-    hl_usleep(rig->state.rigport.write_delay * 1000);
+    hl_usleep(rp->write_delay * 1000);
     return RIG_OK;
 }
 
@@ -3737,6 +3734,7 @@ static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
 static int ft1000d_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
 {
     struct ft1000d_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int err;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@@ -3777,15 +3775,14 @@ static int ft1000d_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     // Store bcd format into privat command storage area
     to_bcd(priv->p_cmd, labs(rit) / 10, FT1000D_BCD_RIT);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
-                      YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
         return err;
     }
 
-    hl_usleep(rig->state.rigport.write_delay * 1000);
+    hl_usleep(rp->write_delay * 1000);
     return RIG_OK;
 }
 

rigs/yaesu/ft1000mp.c

@@ -796,6 +796,7 @@ static int ft1000mp_cleanup(RIG *rig)
 static int ft1000mp_open(RIG *rig)
 {
     struct rig_state *rig_s;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct ft1000mp_priv_data *p;
     unsigned char *cmd;           /* points to sequence to send */
 
@@ -805,10 +806,10 @@ static int ft1000mp_open(RIG *rig)
     p = (struct ft1000mp_priv_data *)rig_s->priv;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: rig_open: write_delay = %i msec \n", __func__,
-              rig_s->rigport.write_delay);
+              rp->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: rig_open: post_write_delay = %i msec \n",
               __func__,
-              rig_s->rigport.post_write_delay);
+              rp->post_write_delay);
 
     /*
      * Copy native cmd PACING  to private cmd storage area
@@ -819,7 +820,7 @@ static int ft1000mp_open(RIG *rig)
 
     /* send PACING cmd to rig  */
     cmd = p->p_cmd;
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     ft1000mp_get_vfo(rig, &rig->state.current_vfo);
     /* TODO */
@@ -881,7 +882,7 @@ static int ft1000mp_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
               (freq_t)from_bcd(p->p_cmd, 8) * 10);
 
     cmd = p->p_cmd;               /* get native sequence */
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
     RETURNFUNC(RIG_OK);
 }
@@ -1308,11 +1309,10 @@ static int ft1000mp_get_vfo(RIG *rig, vfo_t *vfo)
 static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 {
     struct ft1000mp_priv_data *priv;
-    struct rig_state *rs;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char *cmd;
 
     ENTERFUNC;
-    rs = &rig->state;
     priv = (struct ft1000mp_priv_data *)rig->state.priv;
 
     switch (func)
@@ -1329,7 +1329,7 @@ static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 
         cmd = priv->p_cmd;
 
-        write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
+        write_block(rp, cmd, YAESU_CMD_LENGTH);
         RETURNFUNC(RIG_OK);
 
     case RIG_FUNC_XIT:
@@ -1344,7 +1344,7 @@ static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 
         cmd = priv->p_cmd;
 
-        write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
+        write_block(rp, cmd, YAESU_CMD_LENGTH);
         RETURNFUNC(RIG_OK);
 
     default:
@@ -1486,7 +1486,7 @@ static int ft1000mp_set_rxit(RIG *rig, vfo_t vfo, shortfreq_t rit)
     priv->p_cmd[2] = direction;
 
     cmd = priv->p_cmd;               /* get native sequence */
-    write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
     RETURNFUNC(RIG_OK);
 }
@@ -1548,10 +1548,11 @@ static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
 {
     struct ft1000mp_priv_data *priv;
     struct rig_state *rs;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char lvl_data[YAESU_CMD_LENGTH];
     int m;
     int retval;
-    int retry = rig->state.rigport.retry;
+    int retry = rp->retry;
 
     ENTERFUNC;
     rs = &rig->state;
@@ -1611,9 +1612,9 @@ static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
 
     do
     {
-        write_block(&rs->rigport, priv->p_cmd, YAESU_CMD_LENGTH);
+        write_block(rp, priv->p_cmd, YAESU_CMD_LENGTH);
 
-        retval = read_block(&rs->rigport, lvl_data, YAESU_CMD_LENGTH);
+        retval = read_block(rp, lvl_data, YAESU_CMD_LENGTH);
     }
     while (retry-- && retval == -RIG_ETIMEOUT);
 
@@ -1688,7 +1689,7 @@ static int ft1000mp_get_update_data(RIG *rig, unsigned char ci,
     /* send UPDATE command to fetch data*/
     ft1000mp_send_priv_cmd(rig, ci);
 
-    n = read_block(&rig->state.rigport, p->update_data, rl);
+    n = read_block(RIGPORT(rig), p->update_data, rl);
 
     if (n == -RIG_ETIMEOUT)
     {
@@ -1717,7 +1718,7 @@ static int ft1000mp_send_priv_cmd(RIG *rig, unsigned char ci)
         RETURNFUNC(-RIG_EINVAL);
     }
 
-    write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     RETURNFUNC(RIG_OK);
 

rigs/yaesu/ft600.c

@@ -389,20 +389,21 @@ static int ft600_send_priv_cmd(RIG *rig, unsigned char cmd_index)
 
     if (!rig) { return -RIG_EINVAL; }
 
-    return write_block(&rig->state.rigport, (unsigned char *) &ncmd[cmd_index].nseq,
+    return write_block(RIGPORT(rig), (unsigned char *) &ncmd[cmd_index].nseq,
                        YAESU_CMD_LENGTH);
 }
 
 static int ft600_read_status(RIG *rig)
 {
     struct ft600_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int ret;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
     priv = (struct ft600_priv_data *)rig->state.priv;
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     ret = ft600_send_priv_cmd(rig, FT600_NATIVE_CAT_READ_STATUS);
 
@@ -412,8 +413,8 @@ static int ft600_read_status(RIG *rig)
     }
 
 
-    ret = read_block(&rig->state.rigport,
+    ret = read_block(rp, (unsigned char *) &priv->status,
-                     (unsigned char *) &priv->status, FT600_STATUS_UPDATE_DATA_LENGTH);
+		     FT600_STATUS_UPDATE_DATA_LENGTH);
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: read status=%i \n", __func__, ret);
 
@@ -444,7 +445,7 @@ static int ft600_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: read tx status=%i \n", __func__, ret);
 
-    ret = read_block(&rig->state.rigport, &priv->s_meter, 5);
+    ret = read_block(RIGPORT(rig), &priv->s_meter, 5);
 
     if (ret < 0)
     {
@@ -475,7 +476,7 @@ static int ft600_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     freq = (int)freq / 10;
     to_bcd(p_cmd, freq, 8); /* store bcd format in in p_cmd */
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 static int ft600_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
@@ -643,7 +644,7 @@ static int ft600_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
         else if (width <= 2400) { p_cmd[3] = 0x00; }
         else { p_cmd[3] = 0x01; }
 
-        ret = write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+        ret = write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 
         if (ret != RIG_OK)
         {

rigs/yaesu/ft736.c

@@ -240,7 +240,7 @@ int ft736_open(RIG *rig)
 
 
     /* send Ext Cntl ON: Activate CAT */
-    ret = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    ret = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
     if (ret != RIG_OK)
     {
@@ -259,7 +259,7 @@ int ft736_close(RIG *rig)
     free(rig->state.priv);
 
     /* send Ext Cntl OFF: Deactivate CAT */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
 }
 
@@ -287,7 +287,7 @@ int ft736_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
         cmd[0] = (cmd[0] & 0x0f) | 0xc0;
     }
 
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
     if (retval == RIG_OK) { rig_set_cache_freq(rig, vfo, freq); }
 
@@ -358,7 +358,7 @@ int ft736_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     cmd[0] = md;
 
     /* Mode set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -375,7 +375,7 @@ int ft736_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
      */
     cmd[4] = split == RIG_SPLIT_ON ? 0x0e : 0x8e;
 
-    ret = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    ret = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 
     if (ret == RIG_OK)
     {
@@ -403,7 +403,7 @@ int ft736_set_split_freq(RIG *rig, vfo_t vfo, freq_t freq)
     }
 
     /* Frequency set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -444,7 +444,7 @@ int ft736_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     cmd[0] = md;
 
     /* Mode set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -457,17 +457,18 @@ int ft736_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     cmd[4] = ptt == RIG_PTT_ON ? 0x08 : 0x88;
 
     /* Tx/Rx set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 int ft736_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -475,7 +476,7 @@ int ft736_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 5);
+    retval = read_block(rp, cmd, 5);
 
     if (retval < 1)
     {
@@ -494,16 +495,17 @@ int ft736_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xf7};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     if (level != RIG_LEVEL_RAWSTR)
     {
         return -RIG_EINVAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     /* send Test S-meter cmd to rig  */
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -511,7 +513,7 @@ int ft736_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 5);
+    retval = read_block(rp, cmd, 5);
 
     if (retval < 1)
     {
@@ -553,7 +555,7 @@ int ft736_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t shift)
         return -RIG_EINVAL;
     }
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 int ft736_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
@@ -564,7 +566,7 @@ int ft736_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
     to_bcd_be(cmd, offs / 10, 8);
 
     /* Offset set */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 int ft736_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
@@ -585,7 +587,7 @@ int ft736_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
         return -RIG_EINVAL;
     }
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 int ft736_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
@@ -608,7 +610,7 @@ int ft736_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
 
     cmd[0] = 0x3e - i;
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 int ft736_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)

rigs/yaesu/ft747.c

@@ -483,17 +483,17 @@ int ft747_cleanup(RIG *rig)
 int ft747_open(RIG *rig)
 {
     struct rig_state *rig_s;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct ft747_priv_data *p;
     int ret;
 
-
     rig_s = &rig->state;
     p = (struct ft747_priv_data *)rig_s->priv;
 
     rig_debug(RIG_DEBUG_VERBOSE, "ft747:rig_open: write_delay = %i msec \n",
-              rig_s->rigport.write_delay);
+              rp->write_delay);
     rig_debug(RIG_DEBUG_VERBOSE, "ft747:rig_open: post_write_delay = %i msec \n",
-              rig_s->rigport.post_write_delay);
+              rp->post_write_delay);
 
     /*
     * Copy native cmd PACING  to private cmd storage area
@@ -507,7 +507,7 @@ int ft747_open(RIG *rig)
 
     /* send PACING cmd to rig, once for all */
 
-    ret = write_block(&rig->state.rigport, p->p_cmd, YAESU_CMD_LENGTH);
+    ret = write_block(rp, p->p_cmd, YAESU_CMD_LENGTH);
 
     if (ret < 0)
     {
@@ -568,7 +568,7 @@ int ft747_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     rig_force_cache_timeout(&p->status_tv);
 
     cmd = p->p_cmd; /* get native sequence */
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -958,7 +958,7 @@ int ft747_set_mem(RIG *rig, vfo_t vfo, int ch)
 
     rig_force_cache_timeout(&p->status_tv);
 
-    return write_block(&rig->state.rigport, p->p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p->p_cmd, YAESU_CMD_LENGTH);
 }
 
 int ft747_get_mem(RIG *rig, vfo_t vfo, int *ch)
@@ -1003,7 +1003,7 @@ static int ft747_get_update_data(RIG *rig)
     //unsigned char last_byte;
 
     p = (struct ft747_priv_data *)rig->state.priv;
-    rigport = &rig->state.rigport;
+    rigport = RIGPORT(rig);
 
     if (rig->state.cache.ptt == RIG_PTT_ON
             || !rig_check_cache_timeout(&p->status_tv, FT747_CACHE_TIMEOUT))
@@ -1064,7 +1064,7 @@ static int ft747_send_priv_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    return write_block(&rig->state.rigport, ft747_ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), ft747_ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
 }
 

rigs/yaesu/ft757gx.c

@@ -465,7 +465,7 @@ static int ft757_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     to_bcd(cmd, freq / 10, BCD_LEN);
 
     priv->curfreq = freq;
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -491,7 +491,7 @@ static int ft757_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     /* fill in p1 */
     cmd[3] = mode2rig(rig, mode, width);
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -622,7 +622,7 @@ static int ft757_set_vfo(RIG *rig, vfo_t vfo)
 
     priv->current_vfo = vfo;
 
-    RETURNFUNC(write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH));
+    RETURNFUNC(write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH));
 }
 
 static int ft757gx_get_vfo(RIG *rig, vfo_t *vfo)
@@ -687,6 +687,7 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x01, 0x10};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called.\n", __func__);
 
@@ -700,10 +701,10 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
         return -RIG_EINVAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     /* send READ STATUS(Meter only) cmd to rig  */
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -711,7 +712,7 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 1);
+    retval = read_block(rp, cmd, 1);
 
     if (retval != 1)
     {
@@ -738,22 +739,23 @@ static int ft757_get_update_data(RIG *rig)
 {
     const unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x10};
     struct ft757_priv_data *priv = (struct ft757_priv_data *)rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int retval = 0;
     long nbtries;
     /* Maximum number of attempts to ask/read the data. */
-    int maxtries = rig->state.rigport.retry ;
+    int maxtries = rp->retry ;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called Timeout=%d ms, Retry=%d\n",
-              __func__, rig->state.rigport.timeout, maxtries);
+              __func__, rp->timeout, maxtries);
 
     /* At least on one model, returns erraticaly a timeout. Increasing the timeout
     does not fix things. So we restart the read from scratch, it works most of times. */
     for (nbtries = 0 ; nbtries < maxtries ; nbtries++)
     {
-        rig_flush(&rig->state.rigport);
+        rig_flush(rp);
 
         /* send READ STATUS cmd to rig  */
-        retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+        retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
         if (retval < 0)
         {
@@ -761,8 +763,7 @@ static int ft757_get_update_data(RIG *rig)
         }
 
         /* read back the 75 status bytes */
-        retval = read_block(&rig->state.rigport,
+        retval = read_block(rp, priv->update_data,
-                            priv->update_data,
                             FT757GX_STATUS_UPDATE_DATA_LENGTH);
 
         if (retval == FT757GX_STATUS_UPDATE_DATA_LENGTH)

rigs/yaesu/ft767gx.c

@@ -456,7 +456,7 @@ int ft767_open(RIG *rig)
     struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
     int retval;
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(RIGPORT(rig));
 
     /* send 0 delay PACING cmd to rig  */
     retval = ft767_enter_CAT(rig);
@@ -1232,7 +1232,7 @@ int ft767_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
             return -RIG_EINVAL;       /* sorry, wrong VFO */
         }
 
-        rig_flush(&rig->state.rigport);
+        rig_flush(RIGPORT(rig));
 
         retval = ft767_enter_CAT(rig);
 
@@ -1407,6 +1407,7 @@ int ft767_leave_CAT(RIG *rig)
 int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
 {
     struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     size_t replylen, cpycnt;
     unsigned char cmd_echo_buf[5];
     int retval;
@@ -1480,12 +1481,10 @@ int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
     }
 
     /* send the command block */
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     /* read back the command block echo */
-    retval = read_block(&rig->state.rigport,
+    retval = read_block(rp, cmd_echo_buf, YAESU_CMD_LENGTH);
-                        cmd_echo_buf,
-                        YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -1503,12 +1502,10 @@ int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
     }
 
     /* send the ACK */
-    write_block(&rig->state.rigport, priv->ack_cmd, YAESU_CMD_LENGTH);
+    write_block(rp, priv->ack_cmd, YAESU_CMD_LENGTH);
 
     /* read back the response (status bytes) */
-    retval = read_block(&rig->state.rigport,
+    retval = read_block(rp, priv->rx_data, replylen);
-                        priv->rx_data,
-                        replylen);
 
     // update data
     if (retval != replylen)
@@ -1545,7 +1542,7 @@ int ft767_get_update_data(RIG *rig)
     struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
     int retval;
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(RIGPORT(rig));
 
     /* Entering CAT updates our data structures */
     retval = ft767_enter_CAT(rig);
@@ -1576,7 +1573,7 @@ int ft767_set_split(RIG *rig, unsigned int split)
     int retval;
     unsigned int curr_split;
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(RIGPORT(rig));
 
     /* Entering CAT updates our data structures */
     retval = ft767_enter_CAT(rig);

rigs/yaesu/ft817.c

@@ -829,6 +829,7 @@ static int check_cache_timeout(struct timeval *tv)
 static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 {
     unsigned char data[YAESU_CMD_LENGTH];
+    hamlib_port_t *rp = RIGPORT(rig);
     int n;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@@ -838,9 +839,9 @@ static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
     data[0] = addr >> 8;
     data[1] = addr & 0xff;
 
-    write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
+    write_block(rp, data, YAESU_CMD_LENGTH);
 
-    if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
+    if ((n = read_block(rp, data, 2)) < 0)
     {
         return n;
     }
@@ -869,11 +870,12 @@ static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 static int ft817_get_status(RIG *rig, int status)
 {
     struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct timeval *tv;
     unsigned char *data;
     int len;
     int n;
-    int retries = rig->state.rigport.retry;
+    int retries = rp->retry;
     unsigned char result[2];
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@@ -913,10 +915,9 @@ static int ft817_get_status(RIG *rig, int status)
 
     do
     {
-        rig_flush(&rig->state.rigport);
+        rig_flush(rp);
-        write_block(&rig->state.rigport, ncmd[status].nseq,
+        write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
-                    YAESU_CMD_LENGTH);
+        n = read_block(rp, data, len);
-        n = read_block(&rig->state.rigport, data, len);
     }
     while (retries-- && n < 0);
 
@@ -987,7 +988,7 @@ static int ft817_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 {
     struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
     freq_t f1 = 0, f2 = 0;
-    int retries = rig->state.rigport.retry +
+    int retries = RIGPORT(rig)->retry +
                   1; // +1 because, because 2 steps are needed even in best scenario
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called, vfo=%s, ptt=%d, split=%d\n", __func__,
@@ -1488,16 +1489,17 @@ static int ft818_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
 int ft817_read_ack(RIG *rig)
 {
     unsigned char dummy;
+    hamlib_port_t *rp = RIGPORT(rig);
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
 
-    if (rig->state.rigport.post_write_delay == 0)
+    if (rp->post_write_delay == 0)
     {
-        if (read_block(&rig->state.rigport, &dummy, 1) < 0)
+        if (read_block(rp, &dummy, 1) < 0)
         {
             rig_debug(RIG_DEBUG_ERR, "%s: error reading ack\n", __func__);
             rig_debug(RIG_DEBUG_ERR, "%s: adjusting post_write_delay to avoid ack\n",
                       __func__);
-            rig->state.rigport.post_write_delay =
+            rp->post_write_delay =
                 10; // arbitrary choice right now of max 100 cmds/sec
             return RIG_OK; // let it continue without checking for ack now
         }
@@ -1519,6 +1521,7 @@ int ft817_read_ack(RIG *rig)
  */
 static int ft817_send_cmd(RIG *rig, int index)
 {
+    hamlib_port_t *rp = RIGPORT(rig);
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
 
     if (ncmd[index].ncomp == 0)
@@ -1527,8 +1530,8 @@ static int ft817_send_cmd(RIG *rig, int index)
         return -RIG_EINTERNAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
-    write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
+    write_block(rp, ncmd[index].nseq, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 
@@ -1550,7 +1553,7 @@ static int ft817_send_icmd(RIG *rig, int index, const unsigned char *data)
     cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
     memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
 
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 
@@ -1746,7 +1749,7 @@ static int ft817_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 {
     int index;
     ptt_t ptt_response = -1;
-    int retries = rig->state.rigport.retry;
+    int retries = RIGPORT(rig)->retry;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
 
@@ -2059,10 +2062,10 @@ int ft817_set_powerstat(RIG *rig, powerstat_t status)
 
     case RIG_POWER_ON:
         // send 5 bytes first, snooze a bit, then PWR_ON
-        write_block(&rig->state.rigport,
+        write_block(RIGPORT(rig),
                     ncmd[FT817_NATIVE_CAT_PWR_WAKE].nseq, YAESU_CMD_LENGTH);
         hl_usleep(200 * 1000);
-        write_block(&rig->state.rigport, ncmd[FT817_NATIVE_CAT_PWR_ON].nseq,
+        write_block(RIGPORT(rig), ncmd[FT817_NATIVE_CAT_PWR_ON].nseq,
                     YAESU_CMD_LENGTH);
         return RIG_OK;
 

rigs/yaesu/ft840.c

@@ -440,7 +440,6 @@ static int ft840_cleanup(RIG *rig)
 
 static int ft840_open(RIG *rig)
 {
-    struct rig_state *rig_s;
     struct ft840_priv_data *priv;
     int err;
 
@@ -452,12 +451,11 @@ static int ft840_open(RIG *rig)
     }
 
     priv = (struct ft840_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, RIGPORT(rig)->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, RIGPORT(rig)->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -1746,7 +1744,7 @@ static int ft840_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
         return err;
     }
 
-    n = read_block(&rig->state.rigport, priv->update_data, rl);
+    n = read_block(RIGPORT(rig), priv->update_data, rl);
 
     if (n < 0)
     {
@@ -1789,7 +1787,7 @@ static int ft840_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq,
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -1850,7 +1848,7 @@ static int ft840_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[P3] = p3;
     priv->p_cmd[P4] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -1911,7 +1909,7 @@ static int ft840_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT840_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -1993,7 +1991,7 @@ static int ft840_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     priv->p_cmd[P1] = p1;         /* ick */
     priv->p_cmd[P2] = p2;
 
-    err = write_block(&rig->state.rigport, (char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/ft847.c

@@ -1119,7 +1119,7 @@ static int ft847_send_priv_cmd(RIG *rig, int cmd_index)
         return -RIG_EINVAL;
     }
 
-    return write_block(&rig->state.rigport, ncmd[cmd_index].nseq,
+    return write_block(RIGPORT(rig), ncmd[cmd_index].nseq,
                        YAESU_CMD_LENGTH);
 }
 
@@ -1213,7 +1213,7 @@ static int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
         }
     }
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 #define MD_LSB  0x00
@@ -1230,7 +1230,7 @@ static int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 static int get_freq_and_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode,
                              pbwidth_t *width)
 {
-    struct rig_state *rs = &rig->state;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
     unsigned char cmd_index;  /* index of sequence to send */
     unsigned char data[8];
@@ -1270,14 +1270,14 @@ static int get_freq_and_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode,
         return n;
     }
 
-    n = write_block(&rs->rigport, p_cmd, YAESU_CMD_LENGTH);
+    n = write_block(rp, p_cmd, YAESU_CMD_LENGTH);
 
     if (n < 0)
     {
         return n;
     }
 
-    n = read_block(&rs->rigport, data, YAESU_CMD_LENGTH);
+    n = read_block(rp, data, YAESU_CMD_LENGTH);
 
     if (n != YAESU_CMD_LENGTH)
     {
@@ -1358,7 +1358,6 @@ static int ft847_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 {
     unsigned char cmd_index;  /* index of sequence to send */
-    struct rig_state *rs = &rig->state;
     unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
     int ret;
 
@@ -1467,7 +1466,7 @@ static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
         return ret;
     }
 
-    return write_block(&rs->rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 static int ft847_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
@@ -1595,6 +1594,7 @@ static int ft847_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 static int ft847_get_status(RIG *rig, int status_ci)
 {
     struct ft847_priv_data *p = (struct ft847_priv_data *) rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char *data;
     int len;
     int n;
@@ -1621,17 +1621,16 @@ static int ft847_get_status(RIG *rig, int status_ci)
         return -RIG_EINTERNAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
-    n = write_block(&rig->state.rigport, ncmd[status_ci].nseq,
+    n = write_block(rp, ncmd[status_ci].nseq, YAESU_CMD_LENGTH);
-                    YAESU_CMD_LENGTH);
 
     if (n < 0)
     {
         return n;
     }
 
-    n = read_block(&rig->state.rigport, data, len);
+    n = read_block(rp, data, len);
 
     if (n < 0)
     {
@@ -1873,7 +1872,7 @@ static int ft847_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
         return ret;
     }
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -1918,7 +1917,7 @@ static int ft847_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
     /* get associated CAT code */
     p_cmd[0] = ft847_ctcss_cat[i];
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 
 static int ft847_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
@@ -1944,7 +1943,7 @@ static int ft847_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
     /* DCS Code # (i.e. 07, 54=DCS Code 754) */
     to_bcd_be(p_cmd, code, 4); /* store bcd format in in p_cmd */
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 
 }
 
@@ -1987,6 +1986,6 @@ static int ft847_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
 
     to_bcd_be(p_cmd, rptr_offs / 10, 8); /* store bcd format in in p_cmd */
 
-    return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
 }
 

rigs/yaesu/ft857.c

@@ -470,6 +470,7 @@ static int check_cache_timeout(struct timeval *tv)
 static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 {
     unsigned char data[YAESU_CMD_LENGTH];
+    hamlib_port_t *rp = RIGPORT(rig);
     int n;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called \n", __func__);
@@ -479,9 +480,9 @@ static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
     data[0] = addr >> 8;
     data[1] = addr & 0xfe;
 
-    write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
+    write_block(rp, data, YAESU_CMD_LENGTH);
 
-    if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
+    if ((n = read_block(rp, data, 2)) < 0)
     {
         return n;
     }
@@ -499,6 +500,7 @@ static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 static int ft857_get_status(RIG *rig, int status)
 {
     struct ft857_priv_data *p = (struct ft857_priv_data *) rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct timeval *tv;
     unsigned char *data;
     int len;
@@ -531,12 +533,11 @@ static int ft857_get_status(RIG *rig, int status)
         return -RIG_EINTERNAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
-    write_block(&rig->state.rigport, ncmd[status].nseq,
+    write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
-                YAESU_CMD_LENGTH);
 
-    if ((n = read_block(&rig->state.rigport, data, len)) < 0)
+    if ((n = read_block(rp, data, len)) < 0)
     {
         return n;
     }
@@ -575,7 +576,7 @@ static int ft857_send_cmd(RIG *rig, int index)
         return -RIG_EINTERNAL;
     }
 
-    write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), ncmd[index].nseq, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 
@@ -597,7 +598,7 @@ static int ft857_send_icmd(RIG *rig, int index, const unsigned char *data)
     cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
     memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
 
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 

rigs/yaesu/ft890.c

@@ -590,7 +590,7 @@ static int ft890_cleanup(RIG *rig)
 
 static int ft890_open(RIG *rig)
 {
-    struct rig_state *rig_s;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct ft890_priv_data *priv;
     int err;
 
@@ -602,12 +602,11 @@ static int ft890_open(RIG *rig)
     }
 
     priv = (struct ft890_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, rp->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, rp->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -1899,7 +1898,7 @@ static int ft890_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
         return err;
     }
 
-    n = read_block(&rig->state.rigport, priv->update_data, rl);
+    n = read_block(RIGPORT(rig), priv->update_data, rl);
 
     if (n < 0)
     {
@@ -1942,7 +1941,7 @@ static int ft890_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -2002,7 +2001,7 @@ static int ft890_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[P3] = p3;
     priv->p_cmd[P4] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2063,7 +2062,7 @@ static int ft890_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT890_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2144,7 +2143,7 @@ static int ft890_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     priv->p_cmd[P1] = p1;         /* ick */
     priv->p_cmd[P2] = p2;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/ft891.c

@@ -357,7 +357,6 @@ struct rig_caps ft891_caps =
 static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
 {
     struct newcat_priv_data *priv;
-    struct rig_state *state;
     unsigned char ci;
     int err;
 
@@ -373,7 +372,6 @@ static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
     rig_debug(RIG_DEBUG_TRACE, "%s: passed tx_vfo = 0x%02x\n", __func__, tx_vfo);
 
     priv = (struct newcat_priv_data *)rig->state.priv;
-    state = &rig->state;
 
     // RX VFO and TX VFO cannot be the same, no support for MEM as TX VFO
     if (vfo == tx_vfo || tx_vfo == RIG_VFO_MEM)
@@ -397,7 +395,7 @@ static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
 
     SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "ST%c;", ci);
 
-    if (RIG_OK != (err = write_block(&state->rigport,
+    if (RIG_OK != (err = write_block(RIGPORT(rig),
                                      (unsigned char *) priv->cmd_str, strlen(priv->cmd_str))))
     {
         rig_debug(RIG_DEBUG_ERR, "%s: write_block err = %d\n", __func__, err);
@@ -533,7 +531,6 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
                                 pbwidth_t tx_width)
 {
     struct newcat_priv_data *priv;
-    struct rig_state *state;
     freq_t b_freq;
     int err;
 
@@ -544,8 +541,6 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
         return -RIG_EINVAL;
     }
 
-    state = &rig->state;
-
     rig_debug(RIG_DEBUG_TRACE, "%s: passed vfo = %s\n", __func__, rig_strvfo(vfo));
     rig_debug(RIG_DEBUG_TRACE, "%s: passed mode = %s\n", __func__,
               rig_strrmode(tx_mode));
@@ -569,7 +564,7 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
     // Copy A to B
     SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "AB;");
 
-    if (RIG_OK != (err = write_block(&state->rigport,
+    if (RIG_OK != (err = write_block(RIGPORT(rig),
                                      (unsigned char *) priv->cmd_str, strlen(priv->cmd_str))))
     {
         rig_debug(RIG_DEBUG_VERBOSE, "%s:%d write_block err = %d\n", __func__, __LINE__,

rigs/yaesu/ft897.c

@@ -623,6 +623,7 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 {
     unsigned char data[YAESU_CMD_LENGTH];
     int n;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
     memcpy(data, (char *)ncmd[FT897_NATIVE_CAT_EEPROM_READ].nseq,
@@ -631,9 +632,9 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
     data[0] = addr >> 8;
     data[1] = addr & 0xfe;
 
-    write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
+    write_block(rp, data, YAESU_CMD_LENGTH);
 
-    if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
+    if ((n = read_block(rp, data, 2)) < 0)
     {
         return n;
     }
@@ -651,6 +652,7 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
 static int ft897_get_status(RIG *rig, int status)
 {
     struct ft897_priv_data *p = (struct ft897_priv_data *) rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct timeval *tv;
     unsigned char *data;
     int len;
@@ -690,12 +692,11 @@ static int ft897_get_status(RIG *rig, int status)
         return -RIG_EINTERNAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
-    write_block(&rig->state.rigport, ncmd[status].nseq,
+    write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
-                YAESU_CMD_LENGTH);
 
-    if ((n = read_block(&rig->state.rigport, data, len)) < 0)
+    if ((n = read_block(rp, data, len)) < 0)
     {
         return n;
     }
@@ -1054,7 +1055,7 @@ static int ft897_send_cmd(RIG *rig, int index)
         return -RIG_EINTERNAL;
     }
 
-    write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), ncmd[index].nseq, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 
@@ -1076,7 +1077,7 @@ static int ft897_send_icmd(RIG *rig, int index, const unsigned char *data)
     cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
     memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
 
-    write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
     return ft817_read_ack(rig);
 }
 

rigs/yaesu/ft900.c

@@ -612,7 +612,6 @@ static int ft900_cleanup(RIG *rig)
 
 static int ft900_open(RIG *rig)
 {
-    struct rig_state *rig_s;
     struct ft900_priv_data *priv;
     int err;
 
@@ -624,12 +623,11 @@ static int ft900_open(RIG *rig)
     }
 
     priv = (struct ft900_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, RIGPORT(rig)->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, RIGPORT(rig)->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -1921,7 +1919,7 @@ static int ft900_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
         return err;
     }
 
-    n = read_block(&rig->state.rigport, priv->update_data, rl);
+    n = read_block(RIGPORT(rig), priv->update_data, rl);
 
     if (n < 0)
     {
@@ -1964,7 +1962,7 @@ static int ft900_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -2024,7 +2022,7 @@ static int ft900_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[P3] = p3;
     priv->p_cmd[P4] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2085,7 +2083,7 @@ static int ft900_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT900_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2166,7 +2164,7 @@ static int ft900_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     priv->p_cmd[P1] = p1;         /* ick */
     priv->p_cmd[P2] = p2;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/ft920.c

@@ -686,7 +686,7 @@ static int ft920_cleanup(RIG *rig)
 
 static int ft920_open(RIG *rig)
 {
-    struct rig_state *rig_s;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct ft920_priv_data *priv;
     int err;
 
@@ -698,12 +698,11 @@ static int ft920_open(RIG *rig)
     }
 
     priv = (struct ft920_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, rp->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, rp->post_write_delay);
 
     /* Copy native cmd PACING to private cmd storage area */
     memcpy(&priv->p_cmd, &ncmd[FT920_NATIVE_PACING].nseq, YAESU_CMD_LENGTH);
@@ -713,7 +712,7 @@ static int ft920_open(RIG *rig)
 
     rig_debug(RIG_DEBUG_TRACE, "%s: read pacing = %i\n", __func__, priv->pacing);
 
-    err = write_block(&rig->state.rigport, priv->p_cmd, YAESU_CMD_LENGTH);
+    err = write_block(rp, priv->p_cmd, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -2632,7 +2631,7 @@ static int ft920_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
         return err;
     }
 
-    n = read_block(&rig->state.rigport, priv->update_data, rl);
+    n = read_block(RIGPORT(rig), priv->update_data, rl);
 
     if (n < 0)
     {
@@ -2679,7 +2678,7 @@ static int ft920_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -2744,7 +2743,7 @@ static int ft920_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[P3] = p3;
     priv->p_cmd[P4] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2809,7 +2808,7 @@ static int ft920_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT920_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -2893,7 +2892,7 @@ static int ft920_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     priv->p_cmd[P1] = p1;               /* ick */
     priv->p_cmd[P2] = p2;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/ft980.c

@@ -560,20 +560,21 @@ int ft980_transaction(RIG *rig, const unsigned char *cmd, unsigned char *data,
                       int expected_len)
 {
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char echo_back[YAESU_CMD_LENGTH];
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
         return retval;
     }
 
-    retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
+    retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -586,14 +587,14 @@ int ft980_transaction(RIG *rig, const unsigned char *cmd, unsigned char *data,
         return -RIG_EPROTO;
     }
 
-    retval = write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
         return retval;
     }
 
-    retval = read_block(&rig->state.rigport, data, expected_len);
+    retval = read_block(rp, data, expected_len);
 
     if (retval < 0)
     {
@@ -733,6 +734,7 @@ int ft980_open(RIG *rig)
 {
     unsigned char echo_back[YAESU_CMD_LENGTH];
     struct ft980_priv_data *priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int retry_count1 = 0;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@@ -747,18 +749,17 @@ int ft980_open(RIG *rig)
 
         do
         {
-            write_block(&rig->state.rigport, cmd_ON_OFF,
+            write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH);
-                        YAESU_CMD_LENGTH);
+            retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
-            retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
         }
-        while (retval != 5 && retry_count2++ < rig->state.rigport.retry);
+        while (retval != 5 && retry_count2++ < rp->retry);
 
-        write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
+        write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
-        read_block(&rig->state.rigport, (unsigned char *) &priv->update_data,
+        read_block(rp, (unsigned char *) &priv->update_data,
                    FT980_ALL_STATUS_LENGTH);
     }
     while (!priv->update_data.ext_ctl_flag
-            && retry_count1++ < rig->state.rigport.retry);
+            && retry_count1++ < rp->retry);
 
     return RIG_OK;
 }
@@ -782,6 +783,7 @@ int ft980_close(RIG *rig)
 {
     unsigned char echo_back[YAESU_CMD_LENGTH];
     struct ft980_priv_data *priv = (struct ft980_priv_data *)rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int retry_count1 = 0;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@@ -793,18 +795,17 @@ int ft980_close(RIG *rig)
 
         do
         {
-            write_block(&rig->state.rigport, cmd_ON_OFF,
+            write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH);
-                        YAESU_CMD_LENGTH);
+            retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
-            retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
         }
-        while (retval != 5 && retry_count2++ < rig->state.rigport.retry);
+        while (retval != 5 && retry_count2++ < rp->retry);
 
-        write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
+        write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
-        read_block(&rig->state.rigport, (unsigned char *) &priv->update_data,
+        read_block(rp, (unsigned char *) &priv->update_data,
                    FT980_ALL_STATUS_LENGTH);
     }
     while (priv->update_data.ext_ctl_flag
-            && retry_count1++ < rig->state.rigport.retry);
+            && retry_count1++ < rp->retry);
 
     return RIG_OK;
 }
@@ -1217,7 +1218,7 @@ int ft980_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
      */
     cmd[4] = split == RIG_SPLIT_ON ? 0x0e : 0x8e;
 
-    return write_block(&rig->state.rigport, (char *) cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), (char *) cmd, YAESU_CMD_LENGTH);
 #endif
 }
 

rigs/yaesu/ft990.c

@@ -446,7 +446,6 @@ int ft990_cleanup(RIG *rig)
  */
 int  ft990_open(RIG *rig)
 {
-    struct rig_state *rig_s;
     struct ft990_priv_data *priv;
     int err;
 
@@ -458,12 +457,11 @@ int  ft990_open(RIG *rig)
     }
 
     priv = (struct ft990_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, RIGPORT(rig)->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, RIGPORT(rig)->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -2430,7 +2428,7 @@ int ft990_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value)
         return err;
     }
 
-    err = read_block(&rig->state.rigport, mdata, FT990_READ_METER_LENGTH);
+    err = read_block(RIGPORT(rig), mdata, FT990_READ_METER_LENGTH);
 
     if (err < 0)
     {
@@ -3297,7 +3295,7 @@ int ft990_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
         return -RIG_EINVAL;
     }
 
-    n = read_block(&rig->state.rigport, p, rl);
+    n = read_block(RIGPORT(rig), p, rl);
 
     if (n < 0)
     {
@@ -3343,7 +3341,7 @@ int ft990_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -3401,7 +3399,7 @@ int ft990_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[1] = p3;
     priv->p_cmd[0] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -3460,7 +3458,7 @@ int ft990_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT990_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -3525,7 +3523,7 @@ int ft990_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     // Store bcd format into privat command storage area
     to_bcd(priv->p_cmd, labs(rit) / 10, FT990_BCD_RIT);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/ft990v12.c

@@ -461,7 +461,6 @@ int ft990v12_cleanup(RIG *rig)
  */
 int  ft990v12_open(RIG *rig)
 {
-    struct rig_state *rig_s;
     struct ft990v12_priv_data *priv;
     int err;
 
@@ -473,12 +472,11 @@ int  ft990v12_open(RIG *rig)
     }
 
     priv = (struct ft990v12_priv_data *)rig->state.priv;
-    rig_s = &rig->state;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, RIGPORT(rig)->write_delay);
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, RIGPORT(rig)->post_write_delay);
     rig_debug(RIG_DEBUG_TRACE,
               "%s: read pacing = %i\n", __func__, priv->pacing);
 
@@ -2462,7 +2460,7 @@ int ft990v12_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value)
         return err;
     }
 
-    err = read_block(&rig->state.rigport, mdata, FT990_READ_METER_LENGTH);
+    err = read_block(RIGPORT(rig), mdata, FT990_READ_METER_LENGTH);
 
     if (err < 0)
     {
@@ -3318,7 +3316,7 @@ int ft990v12_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
                 p = (unsigned char *)
                     &priv->update_data; // K1MMI: This seems like 1492 will be saved here
 
-                n = read_block(&rig->state.rigport, p, rl); /* M0EZP: copied here from below */
+                n = read_block(RIGPORT(rig), p, rl); /* M0EZP: copied here from below */
                 return RIG_OK;
                 break;
 
@@ -3382,7 +3380,7 @@ int ft990v12_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
 
         p = (unsigned char *)&priv->update_data;
         rl = FT990_STATUS_FLAGS_LENGTH; // 5
-        n = read_block(&rig->state.rigport, (unsigned char *)&temp,
+        n = read_block(RIGPORT(rig), (unsigned char *)&temp,
                        rl); /* M0EZP: copied here from below */
 
         if (n < 0)
@@ -3437,7 +3435,7 @@ int ft990v12_send_static_cmd(RIG *rig, unsigned char ci)
         return -RIG_EINVAL;
     }
 
-    err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
+    err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
     {
@@ -3495,7 +3493,7 @@ int ft990v12_send_dynamic_cmd(RIG *rig, unsigned char ci,
     priv->p_cmd[1] = p3;
     priv->p_cmd[0] = p4;
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -3554,7 +3552,7 @@ int ft990v12_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
     rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
               FT990_BCD_DIAL) * 10);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)
@@ -3619,7 +3617,7 @@ int ft990v12_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
     // Store bcd format into privat command storage area
     to_bcd(priv->p_cmd, labs(rit) / 10, FT990_BCD_RIT);
 
-    err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
+    err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
                       YAESU_CMD_LENGTH);
 
     if (err != RIG_OK)

rigs/yaesu/newcat.c

@@ -556,6 +556,7 @@ int newcat_open(RIG *rig)
 {
     struct newcat_priv_data *priv = rig->state.priv;
     struct rig_state *rig_s = &rig->state;
+    hamlib_port_t *rp = RIGPORT(rig);
     const char *handshake[3] = {"None", "Xon/Xoff", "Hardware"};
     int err;
     int set_only = 0;
@@ -565,10 +566,10 @@ int newcat_open(RIG *rig)
     rig_debug(RIG_DEBUG_TRACE, "%s: Rig=%s, version=%s\n", __func__,
               rig->caps->model_name, rig->caps->version);
     rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
-              __func__, rig_s->rigport.write_delay);
+              __func__, rp->write_delay);
 
     rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
-              __func__, rig_s->rigport.post_write_delay);
+              __func__, rp->post_write_delay);
 
     rig_debug(RIG_DEBUG_TRACE, "%s: serial_handshake = %s \n",
               __func__, handshake[rig->caps->serial_handshake]);
@@ -586,8 +587,8 @@ int newcat_open(RIG *rig)
     priv->trn_state = -1;
 
     // for this sequence we will shorten the timeout so we can detect rig is powered off faster
-    int timeout = rig->state.rigport.timeout;
+    int timeout = rp->timeout;
-    rig->state.rigport.timeout = 100;
+    rp->timeout = 100;
     newcat_get_trn(rig, &priv->trn_state);  /* ignore errors */
 
     /* Currently we cannot cope with AI mode so turn it off in case
@@ -600,7 +601,7 @@ int newcat_open(RIG *rig)
     /* Initialize rig_id in case any subsequent commands need it */
     (void)newcat_get_rigid(rig);
     rig_debug(RIG_DEBUG_VERBOSE, "%s: rig_id=%d\n", __func__, priv->rig_id);
-    rig->state.rigport.timeout = timeout;
+    rp->timeout = timeout;
 
     // some rigs have a CAT TOT timeout that defaults to 10ms
     // so we'll increase CAT timeout to 100ms
@@ -636,8 +637,8 @@ int newcat_open(RIG *rig)
 
         SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "%s", cmd);
 
-        retry_save = rig->state.rigport.retry;
+        retry_save = rp->retry;
-        rig->state.rigport.retry = 0;
+        rp->retry = 0;
 
         if (set_only)
         {
@@ -648,7 +649,7 @@ int newcat_open(RIG *rig)
             err = newcat_get_cmd(rig);
         }
 
-        rig->state.rigport.retry = retry_save;
+        rp->retry = retry_save;
 
         if (err != RIG_OK)
         {
@@ -3671,7 +3672,7 @@ int newcat_mW2power(RIG *rig, float *power, unsigned int mwpower, freq_t freq,
 
 int newcat_set_powerstat(RIG *rig, powerstat_t status)
 {
-    struct rig_state *state = &rig->state;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
     int retval;
     int i = 0;
@@ -3694,22 +3695,22 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
         // When powering on a Yaesu rig needs dummy bytes to wake it up,
         // then wait from 1 to 2 seconds and issue the power-on command again
         HAMLIB_TRACE;
-        write_block(&state->rigport, (unsigned char *) "PS1;", 4);
+        write_block(rp, (unsigned char *) "PS1;", 4);
         hl_usleep(1200000);
-        write_block(&state->rigport, (unsigned char *) "PS1;", 4);
+        write_block(rp, (unsigned char *) "PS1;", 4);
         // some rigs reset the serial port during power up
         // so we reopen the com port  again
         HAMLIB_TRACE;
-        //oser_close(&state->rigport);
+        //oser_close(rp);
         rig_close(rig);
         hl_usleep(3000000);
-        //state->pttport.fd = ser_open(&state->rigport);
+        //PTTPORT(rig)->fd = ser_open(rp);
         rig_open(rig);
         break;
 
     case RIG_POWER_OFF:
     case RIG_POWER_STANDBY:
-        retval = write_block(&state->rigport, (unsigned char *) "PS0;", 4);
+        retval = write_block(rp, (unsigned char *) "PS0;", 4);
         priv->poweron = 0;
         RETURNFUNC(retval);
 
@@ -3719,8 +3720,8 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
 
     HAMLIB_TRACE;
 
-    retry_save = rig->state.rigport.retry;
+    retry_save = rp->retry;
-    rig->state.rigport.retry = 0;
+    rp->retry = 0;
 
     if (status == RIG_POWER_ON) // wait for wakeup only
     {
@@ -3728,25 +3729,25 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
         {
             freq_t freq;
             hl_usleep(1000000);
-            rig_flush(&state->rigport);
+            rig_flush(rp);
             retval = rig_get_freq(rig, RIG_VFO_A, &freq);
 
             if (retval == RIG_OK)
             {
-                rig->state.rigport.retry = retry_save;
+                rp->retry = retry_save;
                 priv->poweron = 1;
                 RETURNFUNC(retval);
             }
 
             rig_debug(RIG_DEBUG_TRACE, "%s: Wait #%d for power up\n", __func__, i + 1);
-            retval = write_block(&state->rigport, (unsigned char *) priv->cmd_str,
+            retval = write_block(rp, (unsigned char *) priv->cmd_str,
                                  strlen(priv->cmd_str));
 
             if (retval != RIG_OK) { RETURNFUNC(retval); }
         }
     }
 
-    rig->state.rigport.retry = retry_save;
+    rp->retry = retry_save;
 
     if (i == 9)
     {
@@ -3765,8 +3766,8 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
  */
 int newcat_get_powerstat(RIG *rig, powerstat_t *status)
 {
-    struct rig_state *state = (struct rig_state *) &rig->state;
     struct newcat_priv_data *priv = (struct newcat_priv_data *) rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     int result;
     char ps;
     char command[] = "PS";
@@ -3791,19 +3792,19 @@ int newcat_get_powerstat(RIG *rig, powerstat_t *status)
     short timeout_retry_save;
     int timeout_save;
 
-    retry_save = state->rigport.retry;
+    retry_save = rp->retry;
-    timeout_retry_save = state->rigport.timeout_retry;
+    timeout_retry_save = rp->timeout_retry;
-    timeout_save = state->rigport.timeout;
+    timeout_save = rp->timeout;
 
-    state->rigport.retry = 0;
+    rp->retry = 0;
-    state->rigport.timeout_retry = 0;
+    rp->timeout_retry = 0;
-    state->rigport.timeout = 500;
+    rp->timeout = 500;
 
     result = newcat_get_cmd(rig);
 
-    state->rigport.retry = retry_save;
+    rp->retry = retry_save;
-    state->rigport.timeout_retry = timeout_retry_save;
+    rp->timeout_retry = timeout_retry_save;
-    state->rigport.timeout = timeout_save;
+    rp->timeout = timeout_save;
 
     // Rig may respond here already
     if (result == RIG_OK)
@@ -3831,7 +3832,7 @@ int newcat_get_powerstat(RIG *rig, powerstat_t *status)
     // Yeasu rigs in powered-off state require the PS command to be sent between 1 and 2 seconds after dummy data
     hl_usleep(1100000);
     // Discard any unsolicited data
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     result = newcat_get_cmd(rig);
 
@@ -11159,6 +11160,7 @@ int newcat_vfomem_toggle(RIG *rig)
 int newcat_get_cmd(RIG *rig)
 {
     struct rig_state *state = &rig->state;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
     int retry_count = 0;
     int rc = -RIG_EPROTO;
@@ -11253,16 +11255,16 @@ int newcat_get_cmd(RIG *rig)
         priv->cache_start.tv_sec = 0;
     }
 
-    while (rc != RIG_OK && retry_count++ <= state->rigport.retry)
+    while (rc != RIG_OK && retry_count++ <= rp->retry)
     {
-        rig_flush(&state->rigport);  /* discard any unsolicited data */
+        rig_flush(rp);  /* discard any unsolicited data */
 
         if (rc != -RIG_BUSBUSY)
         {
             /* send the command */
             rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", priv->cmd_str);
 
-            rc = write_block(&state->rigport, (unsigned char *) priv->cmd_str,
+            rc = write_block(rp, (unsigned char *) priv->cmd_str,
                              strlen(priv->cmd_str));
 
             if (rc != RIG_OK)
@@ -11272,7 +11274,7 @@ int newcat_get_cmd(RIG *rig)
         }
 
         /* read the reply */
-        if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
+        if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
                               sizeof(priv->ret_data),
                               &cat_term, sizeof(cat_term), 0, 1)) <= 0)
         {
@@ -11362,7 +11364,7 @@ int newcat_get_cmd(RIG *rig)
                 }
 
                 rig_debug(RIG_DEBUG_WARN, "%s: Rig busy - retrying %d of %d: '%s'\n", __func__,
-                          retry_count, state->rigport.retry, priv->cmd_str);
+                          retry_count, rp->retry, priv->cmd_str);
                 // DX3000 was taking 1.6 seconds in certain command sequences
                 hl_usleep(600 * 1000); // 600ms wait should cover most cases hopefully
 
@@ -11407,7 +11409,6 @@ int newcat_get_cmd(RIG *rig)
  */
 int newcat_set_cmd_validate(RIG *rig)
 {
-    struct rig_state *state = &rig->state;
     struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
     char valcmd[16];
     int retries = 8;
@@ -11561,11 +11562,12 @@ int newcat_set_cmd_validate(RIG *rig)
     while (rc != RIG_OK && retry++ < retries)
     {
         int bytes;
+        hamlib_port_t *rp = RIGPORT(rig);
         char cmd[256]; // big enough
 repeat:
-        rig_flush(&state->rigport);  /* discard any unsolicited data */
+        rig_flush(rp);  /* discard any unsolicited data */
         SNPRINTF(cmd, sizeof(cmd), "%s", priv->cmd_str);
-        rc = write_block(&state->rigport, (unsigned char *) cmd, strlen(cmd));
+        rc = write_block(rp, (unsigned char *) cmd, strlen(cmd));
 
         if (rc != RIG_OK) { RETURNFUNC(-RIG_EIO); }
 
@@ -11576,11 +11578,11 @@ repeat:
         // some rigs like FT-450/Signalink need a little time before we can ask for TX status again
         if (strncmp(valcmd, "TX", 2) == 0) { hl_usleep(50 * 1000); }
 
-        rc = write_block(&state->rigport, (unsigned char *) cmd, strlen(cmd));
+        rc = write_block(rp, (unsigned char *) cmd, strlen(cmd));
 
         if (rc != RIG_OK) { RETURNFUNC(-RIG_EIO); }
 
-        bytes = read_string(&state->rigport, (unsigned char *) priv->ret_data,
+        bytes = read_string(rp, (unsigned char *) priv->ret_data,
                             sizeof(priv->ret_data),
                             &cat_term, sizeof(cat_term), 0, 1);
 
@@ -11652,7 +11654,7 @@ repeat:
  */
 int newcat_set_cmd(RIG *rig)
 {
-    struct rig_state *state = &rig->state;
+    hamlib_port_t *rp = RIGPORT(rig);
     struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
     int retry_count = 0;
     int rc = -RIG_EPROTO;
@@ -11662,9 +11664,9 @@ int newcat_set_cmd(RIG *rig)
     char const *const verify_cmd = RIG_MODEL_FT9000 == rig->caps->rig_model ?
                                    "AI;" : "ID;";
 
-    while (rc != RIG_OK && retry_count++ <= state->rigport.retry)
+    while (rc != RIG_OK && retry_count++ <= rp->retry)
     {
-        rig_flush(&state->rigport);  /* discard any unsolicited data */
+        rig_flush(rp);  /* discard any unsolicited data */
         /* send the command */
         rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", priv->cmd_str);
 
@@ -11685,8 +11687,7 @@ int newcat_set_cmd(RIG *rig)
         rig_debug(RIG_DEBUG_TRACE,
                   "%s: newcat_set_cmd_validate not implemented...continuing\n", __func__);
 
-        if (RIG_OK != (rc = write_block(&state->rigport,
+        if (RIG_OK != (rc = write_block(rp, (unsigned char *) priv->cmd_str,
-                                        (unsigned char *) priv->cmd_str,
                                         strlen(priv->cmd_str))))
         {
             RETURNFUNC(rc);
@@ -11721,14 +11722,14 @@ int newcat_set_cmd(RIG *rig)
         /* send the verification command */
         rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", verify_cmd);
 
-        if (RIG_OK != (rc = write_block(&state->rigport, (unsigned char *) verify_cmd,
+        if (RIG_OK != (rc = write_block(rp, (unsigned char *) verify_cmd,
                                         strlen(verify_cmd))))
         {
             RETURNFUNC(rc);
         }
 
         /* read the reply */
-        if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
+        if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
                               sizeof(priv->ret_data),
                               &cat_term, sizeof(cat_term), 0, 1)) <= 0)
         {
@@ -11799,7 +11800,7 @@ int newcat_set_cmd(RIG *rig)
                           priv->cmd_str);
 
                 /* read/flush the verify command reply which should still be there */
-                if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
+                if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
                                       sizeof(priv->ret_data),
                                       &cat_term, sizeof(cat_term), 0, 1)) > 0)
                 {

rigs/yaesu/vr5000.c

@@ -279,13 +279,14 @@ int vr5000_cleanup(RIG *rig)
 int vr5000_open(RIG *rig)
 {
     struct vr5000_priv_data *priv = rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     const unsigned char cmd[YAESU_CMD_LENGTH]   = { 0x00, 0x00, 0x00, 0x00, 0x00};
     const unsigned char b_off[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x31};
 
     int retval;
 
     /* CAT write command on */
-    retval =  write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval =  write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval != RIG_OK)
     {
@@ -293,7 +294,7 @@ int vr5000_open(RIG *rig)
     }
 
     /* disable RIG_VFO_B  (only on display) */
-    retval =  write_block(&rig->state.rigport, b_off, YAESU_CMD_LENGTH);
+    retval =  write_block(rp, b_off, YAESU_CMD_LENGTH);
 
     if (retval != RIG_OK)
     {
@@ -324,7 +325,7 @@ int vr5000_close(RIG *rig)
 {
     const unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x80};
 
-    return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
 }
 
 
@@ -402,16 +403,17 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
     if (level != RIG_LEVEL_RAWSTR)
     {
         return -RIG_EINVAL;
     }
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     /* send READ STATUS(Meter only) cmd to rig  */
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -419,7 +421,7 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 1);
+    retval = read_block(rp, cmd, 1);
 
     if (retval < 1)
     {
@@ -432,7 +434,6 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     val->i = cmd[0] & 0x3f;
     rig_debug(RIG_DEBUG_ERR, "Read(%x) RawValue(%x): \n", cmd[0], val->i);
 
-
     return RIG_OK;
 }
 
@@ -441,11 +442,12 @@ int vr5000_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
 {
     unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
     int retval;
+    hamlib_port_t *rp = RIGPORT(rig);
 
-    rig_flush(&rig->state.rigport);
+    rig_flush(rp);
 
     /* send READ STATUS(Meter only) cmd to rig  */
-    retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval < 0)
     {
@@ -453,7 +455,7 @@ int vr5000_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
     }
 
     /* read back the 1 byte */
-    retval = read_block(&rig->state.rigport, cmd, 1);
+    retval = read_block(rp, cmd, 1);
 
     if (retval < 1)
     {
@@ -571,6 +573,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
                shortfreq_t ts)
 {
     struct vr5000_priv_data *priv = rig->state.priv;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char cmd_mode_ts[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x07};
     unsigned char cmd_freq[YAESU_CMD_LENGTH]    = { 0x00, 0x00, 0x00, 0x00, 0x01};
     static const unsigned char steps[] =
@@ -613,8 +616,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
     /* fill in m2 */
     cmd_mode_ts[1] = steps[i];
 
-    retval =  write_block(&rig->state.rigport, cmd_mode_ts,
+    retval =  write_block(rp, cmd_mode_ts, YAESU_CMD_LENGTH);
-                          YAESU_CMD_LENGTH);
 
     if (retval != RIG_OK)
     {
@@ -633,7 +635,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
     cmd_freq[3] = frq & 0xff;
 
     /* frequency set */
-    return write_block(&rig->state.rigport, cmd_freq, YAESU_CMD_LENGTH);
+    return write_block(rp, cmd_freq, YAESU_CMD_LENGTH);
 }
 
 

rigs/yaesu/vx1700.c

@@ -336,7 +336,7 @@ static int vx1700_do_transaction(RIG *rig,
                                  const unsigned char cmd[YAESU_CMD_LENGTH],
                                  unsigned char *retbuf, size_t retbuf_len)
 {
-    struct rig_state    *rs;
+    hamlib_port_t *rp = RIGPORT(rig);
     unsigned char   default_retbuf[1];
     int         retval;
 
@@ -346,15 +346,14 @@ static int vx1700_do_transaction(RIG *rig,
         retbuf_len = sizeof(default_retbuf);
     }
 
-    rs = &rig->state;
     memset(retbuf, 0, retbuf_len);
 
-    rig_flush(&rs->rigport);
+    rig_flush(rp);
-    retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
+    retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
 
     if (retval != RIG_OK) { return retval; }
 
-    retval = read_block(&rs->rigport, retbuf, retbuf_len);
+    retval = read_block(rp, retbuf, retbuf_len);
 
     if (retval != retbuf_len)
     {