From e26e6cd7f28751448e7ba26a7f8c838c8dcb42b3 Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Mon, 5 Feb 2024 11:25:06 -0500 Subject: [PATCH] Convert rigs/yaesu No more code references to raw port structures in rigs/* --- rigs/yaesu/frg100.c | 26 ++++++------ rigs/yaesu/frg8800.c | 10 ++--- rigs/yaesu/frg9600.c | 4 +- rigs/yaesu/ft100.c | 22 +++++----- rigs/yaesu/ft1000d.c | 39 ++++++++--------- rigs/yaesu/ft1000mp.c | 29 +++++++------ rigs/yaesu/ft600.c | 15 ++++--- rigs/yaesu/ft736.c | 38 +++++++++-------- rigs/yaesu/ft747.c | 16 +++---- rigs/yaesu/ft757gx.c | 25 +++++------ rigs/yaesu/ft767gx.c | 21 ++++----- rigs/yaesu/ft817.c | 37 ++++++++-------- rigs/yaesu/ft840.c | 16 +++---- rigs/yaesu/ft847.c | 29 ++++++------- rigs/yaesu/ft857.c | 17 ++++---- rigs/yaesu/ft890.c | 17 ++++---- rigs/yaesu/ft891.c | 9 +--- rigs/yaesu/ft897.c | 17 ++++---- rigs/yaesu/ft900.c | 16 +++---- rigs/yaesu/ft920.c | 19 ++++----- rigs/yaesu/ft980.c | 41 +++++++++--------- rigs/yaesu/ft990.c | 18 ++++---- rigs/yaesu/ft990v12.c | 20 ++++----- rigs/yaesu/newcat.c | 99 ++++++++++++++++++++++--------------------- rigs/yaesu/vr5000.c | 28 ++++++------ rigs/yaesu/vx1700.c | 9 ++-- 26 files changed, 315 insertions(+), 322 deletions(-) diff --git a/rigs/yaesu/frg100.c b/rigs/yaesu/frg100.c index f03702b54..ef0366302 100644 --- a/rigs/yaesu/frg100.c +++ b/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); - retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH); + rig_flush(rp); + 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) { diff --git a/rigs/yaesu/frg8800.c b/rigs/yaesu/frg8800.c index 79091efe3..2d6039072 100644 --- a/rigs/yaesu/frg8800.c +++ b/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); } diff --git a/rigs/yaesu/frg9600.c b/rigs/yaesu/frg9600.c index 376b730dc..ecf4ba7e0 100644 --- a/rigs/yaesu/frg9600.c +++ b/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); } diff --git a/rigs/yaesu/ft100.c b/rigs/yaesu/ft100.c index 082a67cdf..e243f0341 100644 --- a/rigs/yaesu/ft100.c +++ b/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) diff --git a/rigs/yaesu/ft1000d.c b/rigs/yaesu/ft1000d.c index 2c232f06c..c337b45ab 100644 --- a/rigs/yaesu/ft1000d.c +++ b/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, - YAESU_CMD_LENGTH); + err = write_block(rp, ncmd[ci].nseq, 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, - YAESU_CMD_LENGTH); + err = write_block(rp, (unsigned char *) &priv->p_cmd, 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, - YAESU_CMD_LENGTH); + err = write_block(rp, (unsigned char *) &priv->p_cmd, 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, - YAESU_CMD_LENGTH); + err = write_block(rp, (unsigned char *) &priv->p_cmd, 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; } diff --git a/rigs/yaesu/ft1000mp.c b/rigs/yaesu/ft1000mp.c index ae14a1548..e247dce0c 100644 --- a/rigs/yaesu/ft1000mp.c +++ b/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); diff --git a/rigs/yaesu/ft600.c b/rigs/yaesu/ft600.c index 2e0d3aa24..0966c37ec 100644 --- a/rigs/yaesu/ft600.c +++ b/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, - (unsigned char *) &priv->status, FT600_STATUS_UPDATE_DATA_LENGTH); + ret = read_block(rp, (unsigned char *) &priv->status, + 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) { diff --git a/rigs/yaesu/ft736.c b/rigs/yaesu/ft736.c index f4bf6f4ea..69cf8d2e6 100644 --- a/rigs/yaesu/ft736.c +++ b/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) diff --git a/rigs/yaesu/ft747.c b/rigs/yaesu/ft747.c index 5c5231606..52f951565 100644 --- a/rigs/yaesu/ft747.c +++ b/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); } diff --git a/rigs/yaesu/ft757gx.c b/rigs/yaesu/ft757gx.c index a771edc4e..e217e4840 100644 --- a/rigs/yaesu/ft757gx.c +++ b/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, - priv->update_data, + retval = read_block(rp, priv->update_data, FT757GX_STATUS_UPDATE_DATA_LENGTH); if (retval == FT757GX_STATUS_UPDATE_DATA_LENGTH) diff --git a/rigs/yaesu/ft767gx.c b/rigs/yaesu/ft767gx.c index a5df97fa0..ee5be2ecf 100644 --- a/rigs/yaesu/ft767gx.c +++ b/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, - cmd_echo_buf, - YAESU_CMD_LENGTH); + retval = read_block(rp, 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, - priv->rx_data, - replylen); + retval = read_block(rp, 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); diff --git a/rigs/yaesu/ft817.c b/rigs/yaesu/ft817.c index 5607e6bfc..950379e0b 100644 --- a/rigs/yaesu/ft817.c +++ b/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); - write_block(&rig->state.rigport, ncmd[status].nseq, - YAESU_CMD_LENGTH); - n = read_block(&rig->state.rigport, data, len); + rig_flush(rp); + write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH); + n = read_block(rp, 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); - write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH); + rig_flush(rp); + 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; diff --git a/rigs/yaesu/ft840.c b/rigs/yaesu/ft840.c index ea68c868e..29de02d3f 100644 --- a/rigs/yaesu/ft840.c +++ b/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) diff --git a/rigs/yaesu/ft847.c b/rigs/yaesu/ft847.c index 1eb4d293f..1fe50de08 100644 --- a/rigs/yaesu/ft847.c +++ b/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, - YAESU_CMD_LENGTH); + n = write_block(rp, ncmd[status_ci].nseq, 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); } diff --git a/rigs/yaesu/ft857.c b/rigs/yaesu/ft857.c index 09dbbe861..935a0b8ab 100644 --- a/rigs/yaesu/ft857.c +++ b/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, - YAESU_CMD_LENGTH); + write_block(rp, ncmd[status].nseq, 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); } diff --git a/rigs/yaesu/ft890.c b/rigs/yaesu/ft890.c index e62abe350..3b5799574 100644 --- a/rigs/yaesu/ft890.c +++ b/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) diff --git a/rigs/yaesu/ft891.c b/rigs/yaesu/ft891.c index 56d5ff125..7a576e688 100644 --- a/rigs/yaesu/ft891.c +++ b/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__, diff --git a/rigs/yaesu/ft897.c b/rigs/yaesu/ft897.c index be2144890..2d191738e 100644 --- a/rigs/yaesu/ft897.c +++ b/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, - YAESU_CMD_LENGTH); + write_block(rp, ncmd[status].nseq, 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); } diff --git a/rigs/yaesu/ft900.c b/rigs/yaesu/ft900.c index cbeddefda..35c5848d5 100644 --- a/rigs/yaesu/ft900.c +++ b/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) diff --git a/rigs/yaesu/ft920.c b/rigs/yaesu/ft920.c index fda80d7f1..06342c83d 100644 --- a/rigs/yaesu/ft920.c +++ b/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) diff --git a/rigs/yaesu/ft980.c b/rigs/yaesu/ft980.c index d8fea2167..e9395f388 100644 --- a/rigs/yaesu/ft980.c +++ b/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, - YAESU_CMD_LENGTH); - retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH); + write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH); + retval = read_block(rp, 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); - read_block(&rig->state.rigport, (unsigned char *) &priv->update_data, + write_block(rp, cmd_OK, YAESU_CMD_LENGTH); + 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, - YAESU_CMD_LENGTH); - retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH); + write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH); + retval = read_block(rp, 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); - read_block(&rig->state.rigport, (unsigned char *) &priv->update_data, + write_block(rp, cmd_OK, YAESU_CMD_LENGTH); + 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 } diff --git a/rigs/yaesu/ft990.c b/rigs/yaesu/ft990.c index ea64e44d5..63b919e5a 100755 --- a/rigs/yaesu/ft990.c +++ b/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) diff --git a/rigs/yaesu/ft990v12.c b/rigs/yaesu/ft990v12.c index 80fc2ef88..1d165ee76 100644 --- a/rigs/yaesu/ft990v12.c +++ b/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) diff --git a/rigs/yaesu/newcat.c b/rigs/yaesu/newcat.c index 28f7e2ff4..6242a8b40 100644 --- a/rigs/yaesu/newcat.c +++ b/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; - rig->state.rigport.timeout = 100; + int timeout = rp->timeout; + 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; - rig->state.rigport.retry = 0; + retry_save = rp->retry; + 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; - rig->state.rigport.retry = 0; + retry_save = rp->retry; + 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; - timeout_retry_save = state->rigport.timeout_retry; - timeout_save = state->rigport.timeout; + retry_save = rp->retry; + timeout_retry_save = rp->timeout_retry; + timeout_save = rp->timeout; - state->rigport.retry = 0; - state->rigport.timeout_retry = 0; - state->rigport.timeout = 500; + rp->retry = 0; + rp->timeout_retry = 0; + rp->timeout = 500; result = newcat_get_cmd(rig); - state->rigport.retry = retry_save; - state->rigport.timeout_retry = timeout_retry_save; - state->rigport.timeout = timeout_save; + rp->retry = retry_save; + rp->timeout_retry = timeout_retry_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, - (unsigned char *) priv->cmd_str, + if (RIG_OK != (rc = write_block(rp, (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) { diff --git a/rigs/yaesu/vr5000.c b/rigs/yaesu/vr5000.c index 5de58053d..f03fea998 100644 --- a/rigs/yaesu/vr5000.c +++ b/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, - YAESU_CMD_LENGTH); + retval = write_block(rp, cmd_mode_ts, 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); } diff --git a/rigs/yaesu/vx1700.c b/rigs/yaesu/vx1700.c index 648caf9c3..60d063286 100644 --- a/rigs/yaesu/vx1700.c +++ b/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); - retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH); + rig_flush(rp); + 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) {