From 003bc93dd0ad32c8426b11301f83306e6b0a46ff Mon Sep 17 00:00:00 2001 From: Michael Black W9MDB Date: Sun, 14 Feb 2021 16:46:41 -0600 Subject: [PATCH] Add RETURNFUNC to kenwood.c https://github.com/Hamlib/Hamlib/issues/514 --- rigs/kenwood/kenwood.c | 658 ++++++++++++++++++++--------------------- 1 file changed, 327 insertions(+), 331 deletions(-) diff --git a/rigs/kenwood/kenwood.c b/rigs/kenwood/kenwood.c index 6d38b1207..48427e84c 100644 --- a/rigs/kenwood/kenwood.c +++ b/rigs/kenwood/kenwood.c @@ -245,7 +245,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, if ((!cmdstr && !datasize) || (datasize && !data)) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } rs = &rig->state; @@ -268,7 +268,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, if (data) { strncpy(data, priv->last_if_response, datasize); } - return RIG_OK; + RETURNFUNC( RIG_OK); } // else we drop through and do the real IF command @@ -554,7 +554,7 @@ transaction_quit: rs->hold_decode = 0; rig_debug(RIG_DEBUG_TRACE, "%s: returning retval=%d\n", __func__, retval); - return retval; + RETURNFUNC( retval); } @@ -585,7 +585,7 @@ int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf, if (!cmd) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } memset(buf, 0, buf_size); @@ -605,7 +605,7 @@ int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf, if (err != RIG_OK) /* return immediately on error as any retries handled at lower level */ { - return err; + RETURNFUNC( err); } length = strlen(buf); @@ -624,7 +624,7 @@ int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf, } while (err != RIG_OK && ++retry < rig->state.rigport.retry); - return err; + RETURNFUNC( err); } rmode_t kenwood2rmode(unsigned char mode, const rmode_t mode_table[]) @@ -633,10 +633,10 @@ rmode_t kenwood2rmode(unsigned char mode, const rmode_t mode_table[]) if (mode >= KENWOOD_MODE_TABLE_MAX) { - return RIG_MODE_NONE; + RETURNFUNC( RIG_MODE_NONE); } - return mode_table[mode]; + RETURNFUNC( mode_table[mode]); } char rmode2kenwood(rmode_t mode, const rmode_t mode_table[]) @@ -653,12 +653,12 @@ char rmode2kenwood(rmode_t mode, const rmode_t mode_table[]) if (mode_table[i] == mode) { rig_debug(RIG_DEBUG_VERBOSE, "%s: returning %d\n", __func__, i); - return i; + RETURNFUNC( i); } } } - return -1; + RETURNFUNC( -1); } int kenwood_init(RIG *rig) @@ -673,7 +673,7 @@ int kenwood_init(RIG *rig) if (rig->state.priv == NULL) { - return -RIG_ENOMEM; + RETURNFUNC( -RIG_ENOMEM); } priv = rig->state.priv; @@ -715,7 +715,7 @@ int kenwood_init(RIG *rig) rig_debug(RIG_DEBUG_TRACE, "%s: if_len = %d\n", __func__, caps->if_len); - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_cleanup(RIG *rig) @@ -725,7 +725,7 @@ int kenwood_cleanup(RIG *rig) free(rig->state.priv); rig->state.priv = NULL; - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_open(RIG *rig) @@ -798,7 +798,7 @@ int kenwood_open(RIG *rig) { rig_debug(RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__); rig->state.rigport.retry = retry_save; - return err; + RETURNFUNC( err); } /* store the data after the "FV" which should be a f/w version @@ -814,7 +814,7 @@ int kenwood_open(RIG *rig) { rig_debug(RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__); rig->state.rigport.retry = retry_save; - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } rig_debug(RIG_DEBUG_TRACE, "%s: found f/w version %s\n", __func__, @@ -832,7 +832,7 @@ int kenwood_open(RIG *rig) { rig_debug(RIG_DEBUG_ERR, "%s: no response from rig\n", __func__); rig->state.rigport.retry = retry_save; - return err; + RETURNFUNC( err); } /* here we know there is something that responds to FA but not @@ -849,7 +849,7 @@ int kenwood_open(RIG *rig) { rig_debug(RIG_DEBUG_ERR, "%s: cannot get identification\n", __func__); rig->state.rigport.retry = retry_save; - return err; + RETURNFUNC( err); } } @@ -858,7 +858,7 @@ int kenwood_open(RIG *rig) { rig_debug(RIG_DEBUG_ERR, "%s: unknown id type (%s)\n", __func__, id); rig->state.rigport.retry = retry_save; - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } if (!strcmp("IDID900", id) /* DDUtil in TS-2000 mode */ @@ -927,7 +927,7 @@ int kenwood_open(RIG *rig) } rig->state.rigport.retry = retry_save; - return RIG_OK; + RETURNFUNC( RIG_OK); } /* driver mismatch */ @@ -948,7 +948,7 @@ int kenwood_open(RIG *rig) // mismatched IDs can still be tested rig->state.rigport.retry = retry_save; - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -965,7 +965,7 @@ int kenwood_close(RIG *rig) it's not supported */ } - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -979,7 +979,7 @@ int kenwood_get_id(RIG *rig, char *buf) { rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return kenwood_transaction(rig, "ID", buf, KENWOOD_MAX_BUF_LEN); + RETURNFUNC( kenwood_transaction(rig, "ID", buf, KENWOOD_MAX_BUF_LEN)); } @@ -994,8 +994,8 @@ static int kenwood_get_if(RIG *rig) rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return kenwood_safe_transaction(rig, "IF", priv->info, - KENWOOD_MAX_BUF_LEN, caps->if_len); + RETURNFUNC( kenwood_safe_transaction(rig, "IF", priv->info, + KENWOOD_MAX_BUF_LEN, caps->if_len);) } @@ -1019,7 +1019,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo) * This prevents a 1.8 second delay in PowerSDR when switching VFOs * We'll do this once if curr_mode has not been set yet */ - if (priv->is_emulation && priv->curr_mode > 0) { return RIG_OK; } + if (priv->is_emulation && priv->curr_mode > 0) { RETURNFUNC( RIG_OK; )} switch (vfo) { @@ -1036,11 +1036,11 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo) break; case RIG_VFO_CURR: - return RIG_OK; + RETURNFUNC( RIG_OK); default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } //if rig=ts2000 then check Satellite mode status @@ -1054,7 +1054,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } rig_debug(RIG_DEBUG_VERBOSE, "%s: satellite mode status %s\n", __func__, @@ -1065,7 +1065,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo) { //SAT mode doesn't allow FR command (cannot select VFO) //selecting VFO is useless in SAT MODE - return RIG_OK; + RETURNFUNC( RIG_OK); } } @@ -1081,19 +1081,19 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* if FN command then there's no FT or FR */ /* If split mode on, the don't change TxVFO */ if ('N' == cmdbuf[1] || priv->split != RIG_SPLIT_OFF) { - return RIG_OK; + RETURNFUNC( RIG_OK); } /* set TX VFO */ cmdbuf[1] = 'T'; - return kenwood_transaction(rig, cmdbuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmdbuf, NULL, 0)); } @@ -1120,15 +1120,15 @@ int kenwood_set_vfo_main_sub(RIG *rig, vfo_t vfo) break; case RIG_VFO_CURR: - return RIG_OK; + RETURNFUNC( RIG_OK); default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmdbuf, sizeof(cmdbuf), "CB%c", vfo_function); - return kenwood_transaction(rig, cmdbuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmdbuf, NULL, 0)); } @@ -1145,7 +1145,7 @@ int kenwood_get_vfo_main_sub(RIG *rig, vfo_t *vfo) if (!vfo) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_OK == (rc = kenwood_safe_transaction(rig, "CB", buf, sizeof(buf), 3))) @@ -1153,7 +1153,7 @@ int kenwood_get_vfo_main_sub(RIG *rig, vfo_t *vfo) *vfo = buf[2] == '1' ? RIG_VFO_SUB : RIG_VFO_MAIN; } - return rc; + RETURNFUNC( rc); } @@ -1177,11 +1177,11 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) // Rx MAIN/Tx SUB is the only split method retval = kenwood_set_vfo_main_sub(rig, RIG_VFO_MAIN); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} } snprintf(cmdbuf, sizeof(cmdbuf), "TB%c", RIG_SPLIT_ON == split ? '1' : '0'); - return kenwood_transaction(rig, cmdbuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmdbuf, NULL, 0)); } if (vfo != RIG_VFO_CURR) @@ -1196,7 +1196,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* set RX VFO */ @@ -1205,7 +1205,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } } @@ -1220,7 +1220,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } } } @@ -1237,7 +1237,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(txvfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } priv->tx_vfo = txvfo; @@ -1249,7 +1249,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) if (RIG_OK == (retval = kenwood_safe_transaction(rig, "FT", cmdbuf, sizeof(cmdbuf), 3))) { - if (cmdbuf[2] == vfo_function) { return RIG_OK; } + if (cmdbuf[2] == vfo_function) { RETURNFUNC( RIG_OK; )} } } @@ -1259,13 +1259,13 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* Remember whether split is on, for kenwood_set_vfo */ priv->split = split; - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -1287,7 +1287,7 @@ int kenwood_set_split(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* Remember whether split is on, for kenwood_set_vfo */ @@ -1296,7 +1296,7 @@ int kenwood_set_split(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) rig_debug(RIG_DEBUG_VERBOSE, "%s: priv->tx_vfo=%s\n", __func__, rig_strvfo(priv->tx_vfo)); - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -1316,7 +1316,7 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, if (!split || !txvfo) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -1340,14 +1340,14 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, } } - return retval; + RETURNFUNC( retval); } retval = kenwood_get_if(rig); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } switch (priv->info[32]) @@ -1363,7 +1363,7 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported split %c\n", __func__, priv->info[32]); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } /* Remember whether split is on, for kenwood_set_vfo */ @@ -1391,13 +1391,13 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %c\n", __func__, priv->info[30]); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } priv->tx_vfo = *txvfo; rig_debug(RIG_DEBUG_VERBOSE, "%s: priv->tx_vfo=%s\n", __func__, rig_strvfo(priv->tx_vfo)); - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -1418,14 +1418,14 @@ int kenwood_get_vfo_if(RIG *rig, vfo_t *vfo) if (!vfo) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_get_if(rig); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* Elecraft info[30] does not track split VFO when transmitting */ @@ -1456,12 +1456,12 @@ int kenwood_get_vfo_if(RIG *rig, vfo_t *vfo) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %c\n", __func__, priv->info[30]); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } rig_debug(RIG_DEBUG_VERBOSE, "%s: priv->tx_vfo=%s\n", __func__, rig_strvfo(priv->tx_vfo)); - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -1489,7 +1489,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq) /* fetch from rig */ err = rig_get_vfo(rig, &tvfo); - if (RIG_OK != err) { return err; } + if (RIG_OK != err) { RETURNFUNC( err; )} } switch (tvfo) @@ -1521,7 +1521,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } // cppcheck-suppress * @@ -1549,7 +1549,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq) if (RIG_OK != err) { - return err; + RETURNFUNC( err); } if ('1' == priv->info[32] && priv->info[30] != ('A' == vfo_letter ? '0' : '1')) @@ -1562,14 +1562,14 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq) if (RIG_OK != err) { - return err; + RETURNFUNC( err); } err = kenwood_transaction(rig, freqbuf, NULL, 0); } } - return err; + RETURNFUNC( err); } int kenwood_get_freq_if(RIG *rig, vfo_t vfo, freq_t *freq) @@ -1582,21 +1582,21 @@ int kenwood_get_freq_if(RIG *rig, vfo_t vfo, freq_t *freq) if (!freq) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_get_if(rig); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } memcpy(freqbuf, priv->info, 15); freqbuf[14] = '\0'; sscanf(freqbuf + 2, "%"SCNfreq, freq); - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -1615,7 +1615,7 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) if (!freq) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } tvfo = (vfo == RIG_VFO_CURR @@ -1626,14 +1626,14 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) /* fetch from rig */ retval = rig_get_vfo(rig, &tvfo); - if (RIG_OK != retval) { return retval; } + if (RIG_OK != retval) { RETURNFUNC( retval; )} } /* memory frequency cannot be read with an Fx command, use IF */ if (tvfo == RIG_VFO_MEM) { - return kenwood_get_freq_if(rig, vfo, freq); + RETURNFUNC( kenwood_get_freq_if(rig, vfo, freq)); } switch (tvfo) @@ -1660,7 +1660,7 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmdbuf, sizeof(cmdbuf), "F%c", vfo_letter); @@ -1669,12 +1669,12 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } sscanf(freqbuf + 2, "%"SCNfreq, freq); - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) @@ -1687,14 +1687,14 @@ int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) if (!rit) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_get_if(rig); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } memcpy(buf, &priv->info[17], 6); @@ -1702,7 +1702,7 @@ int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) buf[6] = '\0'; *rit = atoi(buf); - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -1724,7 +1724,7 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (priv->has_rit2) // if backend shows it has the Set 2 command @@ -1739,10 +1739,10 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } - if (rit == 0) { return RIG_OK; } // we're done here + if (rit == 0) { RETURNFUNC( RIG_OK;) } // we're done her))e snprintf(buf, sizeof(buf), "R%c", (rit > 0) ? 'U' : 'D'); @@ -1755,7 +1755,7 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) } } - return retval; + RETURNFUNC( retval); } /* @@ -1765,14 +1765,14 @@ int kenwood_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *rit) { rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return kenwood_get_rit(rig, vfo, rit); + RETURNFUNC( kenwood_get_rit(rig, vfo, rit)); } int kenwood_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit) { rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return kenwood_set_rit(rig, vfo, rit); + RETURNFUNC( kenwood_set_rit(rig, vfo, rit)); } int kenwood_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) @@ -1781,12 +1781,11 @@ int kenwood_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) if (RIG_IS_TS990S) { - return kenwood_transaction(rig, scan == RIG_SCAN_STOP ? "SC00" : "SC01", NULL, - 0); + RETURNFUNC( kenwood_transaction(rig, scan == RIG_SCAN_STOP ? "SC00" : "SC01", NULL, 0)); } else { - return kenwood_transaction(rig, scan == RIG_SCAN_STOP ? "SC0" : "SC1", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, scan == RIG_SCAN_STOP ? "SC0" : "SC1", NULL, 0)); } } @@ -1828,7 +1827,7 @@ static int kenwood_set_filter(RIG *rig, pbwidth_t width) cmd = "FL002002"; } - return kenwood_transaction(rig, cmd, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmd, NULL, 0)); } /* @@ -1887,7 +1886,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { rig_debug(RIG_DEBUG_WARN, "%s: unsupported mode '%s'\n", __func__, rig_strrmode(mode)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (kmode <= 9) @@ -1912,13 +1911,13 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) vfo_t curr_vfo; err = kenwood_get_vfo_main_sub(rig, &curr_vfo); - if (err != RIG_OK) { return err; } + if (err != RIG_OK) { RETURNFUNC( err; )} if (vfo != RIG_VFO_CURR && vfo != curr_vfo) { err = kenwood_set_vfo_main_sub(rig, vfo); - if (err != RIG_OK) { return err; } + if (err != RIG_OK) { RETURNFUNC( err; )} } snprintf(buf, sizeof(buf), "OM0%c", c); /* target vfo is ignored */ @@ -1928,7 +1927,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { int err2 = kenwood_set_vfo_main_sub(rig, curr_vfo); - if (err2 != RIG_OK) { return err2; } + if (err2 != RIG_OK) { RETURNFUNC( err2; )} } } else @@ -1937,7 +1936,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) err = kenwood_transaction(rig, buf, NULL, 0); } - if (err != RIG_OK) { return err; } + if (err != RIG_OK) { RETURNFUNC( err; )} if (RIG_IS_TS590S || RIG_IS_TS590SG || RIG_IS_TS950S || RIG_IS_TS950SDX) { @@ -1958,11 +1957,11 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) snprintf(buf, sizeof(buf), "%s%c", data_cmd, data_mode); err = kenwood_transaction(rig, buf, NULL, 0); - if (err != RIG_OK) { return err; } + if (err != RIG_OK) { RETURNFUNC( err; )} } } - if (RIG_PASSBAND_NOCHANGE == width) { return RIG_OK; } + if (RIG_PASSBAND_NOCHANGE == width) { RETURNFUNC( RIG_OK; )} if (RIG_IS_TS450S || RIG_IS_TS690S || RIG_IS_TS850 || RIG_IS_TS950S || RIG_IS_TS950SDX) @@ -1977,7 +1976,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) /* non fatal */ } - return RIG_OK; + RETURNFUNC( RIG_OK); } static int kenwood_get_filter(RIG *rig, pbwidth_t *width) @@ -1989,14 +1988,14 @@ static int kenwood_get_filter(RIG *rig, pbwidth_t *width) if (!width) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } err = kenwood_safe_transaction(rig, "FL", buf, sizeof(buf), 8); if (err != RIG_OK) { - return err; + RETURNFUNC( err); } f2 = atoi(&buf[5]); @@ -2037,7 +2036,7 @@ static int kenwood_get_filter(RIG *rig, pbwidth_t *width) break; } - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -2058,7 +2057,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) if (!mode || !width) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* for emulation do not read mode from VFOB as it is copy of VFOA */ @@ -2066,7 +2065,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) /* only need to get it if it has to be initialized */ if (priv->curr_mode > 0 && priv->is_emulation && vfo == RIG_VFO_B) { - return priv->curr_mode; + RETURNFUNC( priv->curr_mode); } if (RIG_IS_TS990S) @@ -2077,7 +2076,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { if (RIG_OK != (retval = kenwood_get_vfo_main_sub(rig, &vfo))) { - return retval; + RETURNFUNC( retval); } } @@ -2089,7 +2088,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmd, sizeof(cmd), "OM%c", c); @@ -2105,7 +2104,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (modebuf[offs] <= '9') @@ -2135,7 +2134,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if ('1' == modebuf[2]) @@ -2156,7 +2155,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) /* XXX ? */ *width = rig_passband_normal(rig, *mode); - return RIG_OK; + RETURNFUNC( RIG_OK); } /* This is used when the radio does not support MD; for mode reading */ @@ -2170,14 +2169,14 @@ int kenwood_get_mode_if(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) if (!mode || !width) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } err = kenwood_get_if(rig); if (err != RIG_OK) { - return err; + RETURNFUNC( err); } *mode = kenwood2rmode(priv->info[29] - '0', caps->mode_table); @@ -2192,7 +2191,7 @@ int kenwood_get_mode_if(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) /* non fatal */ } - return RIG_OK; + RETURNFUNC( RIG_OK); } /* kenwood_get_micgain_minmax @@ -2219,7 +2218,7 @@ static int kenwood_get_micgain_minmax(RIG *rig, int *micgain_now, rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); retval = write_block(&rs->rigport, cmd, strlen(cmd)); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} retval = read_string(&rs->rigport, levelbuf, sizeof(levelbuf), NULL, 0); @@ -2229,7 +2228,7 @@ static int kenwood_get_micgain_minmax(RIG *rig, int *micgain_now, { rig_debug(RIG_DEBUG_ERR, "%s: expected 19, got %d in '%s'\n", __func__, retval, levelbuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } n = sscanf(levelbuf, "MG%d;MG%d;MG%d", micgain_now, micgain_min, micgain_max); @@ -2238,19 +2237,19 @@ static int kenwood_get_micgain_minmax(RIG *rig, int *micgain_now, { rig_debug(RIG_DEBUG_ERR, "%s: count not parse 3 values from '%s'\n", __func__, levelbuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } if (restore) { snprintf(levelbuf, sizeof(levelbuf), "MG%03d;", *micgain_now); retval = kenwood_transaction(rig, levelbuf, NULL, 0); - return retval; + RETURNFUNC( retval); } rig_debug(RIG_DEBUG_TRACE, "%s: returning now=%d, min=%d, max=%d\n", __func__, *micgain_now, *micgain_min, *micgain_max); - return RIG_OK; + RETURNFUNC( RIG_OK); } /* kenwood_get_power_minmax @@ -2309,12 +2308,12 @@ static int kenwood_get_power_minmax(RIG *rig, int *power_now, int *power_min, *power_now = rig->state.power_now; *power_min = rig->state.power_min; *power_max = rig->state.power_max; - return RIG_OK; + RETURNFUNC( RIG_OK); } retval = write_block(&rs->rigport, cmd, strlen(cmd)); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} retval = read_string(&rs->rigport, levelbuf, sizeof(levelbuf), NULL, 0); @@ -2334,7 +2333,7 @@ static int kenwood_get_power_minmax(RIG *rig, int *power_now, int *power_min, rig_debug(RIG_DEBUG_ERR, "%s: expected %d, got %d in '%s'\n", __func__, expval, retval, levelbuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } if (RIG_IS_TS890S) @@ -2345,7 +2344,7 @@ static int kenwood_get_power_minmax(RIG *rig, int *power_now, int *power_min, { rig_debug(RIG_DEBUG_ERR, "%s: count not parse 1 value from '%s'\n", __func__, levelbuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } } else @@ -2356,14 +2355,14 @@ static int kenwood_get_power_minmax(RIG *rig, int *power_now, int *power_min, { rig_debug(RIG_DEBUG_ERR, "%s: count not parse 3 values from '%s'\n", __func__, levelbuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } if (restore) // only need to restore if 3-value cmd is done { snprintf(levelbuf, sizeof(levelbuf), "PC%03d;", *power_now); retval = kenwood_transaction(rig, levelbuf, NULL, 0); - return retval; + RETURNFUNC( retval); } } @@ -2373,7 +2372,7 @@ static int kenwood_get_power_minmax(RIG *rig, int *power_now, int *power_min, rig->state.power_now = *power_now; rig->state.power_min = *power_min; rig->state.power_max = *power_max; - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) @@ -2403,7 +2402,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) // Power min/max can vary so we query to find them out every time retval = kenwood_get_power_minmax(rig, &power_now, &power_min, &power_max, 0); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} // https://github.com/Hamlib/Hamlib/issues/465 kenwood_val = val.f * power_max; @@ -2456,10 +2455,10 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) retval = kenwood_get_micgain_minmax(rig, &micgain_now, &priv->micgain_min, &priv->micgain_max, 0); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} } - if (val.f > 1.0 || val.f < 0) { return -RIG_EINVAL; } + if (val.f > 1.0 || val.f < 0) { RETURNFUNC( -RIG_EINVAL; )} // is micgain_min ever > 0 ?? kenwood_val = val.f * (priv->micgain_max - priv->micgain_min) + @@ -2472,7 +2471,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) /* XXX check level range */ // KX2 and KX3 have range -190 to 250 - if (val.f > 1.0 || val.f < 0) { return -RIG_EINVAL; } + if (val.f > 1.0 || val.f < 0) { RETURNFUNC( -RIG_EINVAL; )} kenwood_val = val.f * 255.0; snprintf(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val); @@ -2515,7 +2514,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) if (!foundit) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } @@ -2544,7 +2543,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) if (!foundit) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } @@ -2553,7 +2552,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) case RIG_LEVEL_SLOPE_HIGH: if (val.i > 20 || val.i < 0) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(levelbuf, sizeof(levelbuf), "SH%02d", (val.i)); @@ -2562,7 +2561,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) case RIG_LEVEL_SLOPE_LOW: if (val.i > 20 || val.i < 0) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(levelbuf, sizeof(levelbuf), "SL%02d", (val.i)); @@ -2571,7 +2570,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) case RIG_LEVEL_CWPITCH: if (val.i > 1000 || val.i < 400) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(levelbuf, sizeof(levelbuf), "PT%02d", (val.i / 50) - 8); @@ -2580,7 +2579,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) case RIG_LEVEL_KEYSPD: if (val.i > 50 || val.i < 5) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(levelbuf, sizeof(levelbuf), "KS%03d", val.i); @@ -2589,10 +2588,10 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported set_level %s", __func__, rig_strlevel(level)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } - return kenwood_transaction(rig, levelbuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, levelbuf, NULL, 0)); } int get_kenwood_level(RIG *rig, const char *cmd, float *fval, int *ival) @@ -2606,14 +2605,14 @@ int get_kenwood_level(RIG *rig, const char *cmd, float *fval, int *ival) if (!fval && !ival) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_safe_transaction(rig, cmd, lvlbuf, 10, len + 3); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* 000..255 */ @@ -2623,7 +2622,7 @@ int get_kenwood_level(RIG *rig, const char *cmd, float *fval, int *ival) if (fval) { *fval = lvl / 255.0; } // our default scaling of 0-255 - return RIG_OK; + RETURNFUNC( RIG_OK); }; @@ -2643,7 +2642,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (!val) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } switch (level) @@ -2666,7 +2665,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* XXX atoi ? */ @@ -2689,7 +2688,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } sscanf(lvlbuf + len, "%d", &val->i); /* rawstr */ @@ -2710,7 +2709,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } sscanf(lvlbuf + 2, "%d", &lvl); @@ -2728,13 +2727,13 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) rig_debug(RIG_DEBUG_ERR, "%s: " "unexpected att level %d\n", __func__, lvl); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } } if (i != lvl) { - return -RIG_EINTERNAL; + RETURNFUNC( -RIG_EINTERNAL); } val->i = rig->state.attenuator[i - 1]; @@ -2747,7 +2746,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (lvlbuf[2] == '0') @@ -2765,13 +2764,13 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) rig_debug(RIG_DEBUG_ERR, "%s: " "unexpected preamp level %d\n", __func__, lvl); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } } if (i != lvl) { - return -RIG_EINTERNAL; + RETURNFUNC( -RIG_EINTERNAL); } val->i = rig->state.preamp[i - 1]; @@ -2781,7 +2780,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) rig_debug(RIG_DEBUG_ERR, "%s: " "unexpected preamp char '%c'\n", __func__, lvlbuf[2]); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } break; @@ -2790,10 +2789,10 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) // Power min/max can vary so we query to find them out every time retval = kenwood_get_power_minmax(rig, &power_now, &power_min, &power_max, 1); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} val->f = (power_now - power_min) / (float)(power_max - power_min); - return RIG_OK; + RETURNFUNC( RIG_OK); case RIG_LEVEL_AF: @@ -2846,40 +2845,38 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { priv->ag_format = -1; // we'll keep trying next time rig_debug(RIG_DEBUG_WARN, "%s: Unable to set AG format?\n", __func__); - return RIG_OK; // this is non-fatal for now + RETURNFUNC( RIG_OK;) // this is non-fatal for no))w } switch (priv->ag_format) { case 0: priv->ag_format = -1; // reset to try again - return RIG_OK; + RETURNFUNC( RIG_OK); break; case 1: - return get_kenwood_level(rig, "AG", &val->f, NULL); + RETURNFUNC( get_kenwood_level(rig, "AG", &val->f, NULL)); break; case 2: - return get_kenwood_level(rig, "AG0", &val->f, NULL); + RETURNFUNC( get_kenwood_level(rig, "AG0", &val->f, NULL)); break; case 3: - return get_kenwood_level(rig, vfo == RIG_VFO_MAIN ? "AG0" : "AG1", &val->f, - NULL); + RETURNFUNC( get_kenwood_level(rig, vfo == RIG_VFO_MAIN ? "AG0" : "AG1", &val->f, NULL)); break; default: rig_debug(RIG_DEBUG_WARN, "%s: Invalid ag_format=%d?\n", __func__, priv->ag_format); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } case RIG_LEVEL_RF: - return get_kenwood_level(rig, "RG", &val->f, NULL); + RETURNFUNC( get_kenwood_level(rig, "RG", &val->f, NULL)); + - case RIG_LEVEL_SQL: - return get_kenwood_level(rig, "SQ", &val->f, NULL); case RIG_LEVEL_MICGAIN: { @@ -2890,7 +2887,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) retval = kenwood_get_micgain_minmax(rig, &micgain_now, &priv->micgain_min, &priv->micgain_max, 1); - if (retval != RIG_OK) { return retval; } + if (retval != RIG_OK) { RETURNFUNC( retval; )} } rig_debug(RIG_DEBUG_TRACE, "%s: micgain_min=%d, micgain_max=%d\n", __func__, @@ -2901,12 +2898,12 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (ret != RIG_OK) { rig_debug(RIG_DEBUG_ERR, "%s: Error getting MICGAIN\n", __func__); - return ret; + RETURNFUNC( ret); } val->f = (val->i - priv->micgain_min) / (float)(priv->micgain_max - priv->micgain_min); - return RIG_OK; + RETURNFUNC( RIG_OK); } case RIG_LEVEL_AGC: @@ -2918,14 +2915,14 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) else if (agclevel < 170) { val->i = 2; } else if (agclevel <= 255) { val->i = 3; } - return ret; + RETURNFUNC( ret); case RIG_LEVEL_SLOPE_LOW: retval = kenwood_transaction(rig, "SL", lvlbuf, sizeof(lvlbuf)); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } val->i = atoi(&lvlbuf[2]); @@ -2936,7 +2933,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } val->i = atoi(&lvlbuf[2]); @@ -2947,7 +2944,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } sscanf(lvlbuf + 2, "%d", &val->i); @@ -2959,7 +2956,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } sscanf(lvlbuf + 2, "%d", &val->i); @@ -2974,15 +2971,15 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) case RIG_LEVEL_COMP: case RIG_LEVEL_BKINDL: case RIG_LEVEL_BALANCE: - return -RIG_ENIMPL; + RETURNFUNC( -RIG_ENIMPL); default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported get_level %s", __func__, rig_strlevel(level)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) @@ -3011,7 +3008,7 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) default: rig_debug(RIG_DEBUG_ERR, "%s: expected 0,1, or 2 and got %d\n", __func__, status); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } else @@ -3019,11 +3016,11 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) snprintf(buf, sizeof(buf), "NB%c", (status == 0) ? '0' : '1'); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_ABM: snprintf(buf, sizeof(buf), "AM%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_COMP: if (RIG_IS_TS890S) @@ -3035,23 +3032,23 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) snprintf(buf, sizeof(buf), "PR%c", (status == 0) ? '0' : '1'); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_TONE: snprintf(buf, sizeof(buf), "TO%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_TSQL: snprintf(buf, sizeof(buf), "CT%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_VOX: snprintf(buf, sizeof(buf), "VX%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_FAGC: snprintf(buf, sizeof(buf), "GT00%c", (status == 0) ? '4' : '2'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_NR: if (RIG_IS_TS890S) @@ -3067,42 +3064,42 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) snprintf(buf, sizeof(buf), "NR%c", (status == 0) ? '0' : '1'); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_BC: snprintf(buf, sizeof(buf), "BC%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_BC2: snprintf(buf, sizeof(buf), "BC%c", (status == 0) ? '0' : '2'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_ANF: snprintf(buf, sizeof(buf), "NT%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_LOCK: snprintf(buf, sizeof(buf), "LK%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_AIP: snprintf(buf, sizeof(buf), "MX%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_RIT: snprintf(buf, sizeof(buf), "RT%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case RIG_FUNC_XIT: snprintf(buf, sizeof(buf), "XT%c", (status == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); default: rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %s", rig_strfunc(func)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* @@ -3120,7 +3117,7 @@ int get_kenwood_func(RIG *rig, const char *cmd, int *status) if (!cmd || !status) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (strlen(cmd) == 3) { offset = 3; } // some commands are 3 letters @@ -3129,12 +3126,12 @@ int get_kenwood_func(RIG *rig, const char *cmd, int *status) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } *status = buf[offset] - '0'; // just return whatever the rig returns - return RIG_OK; + RETURNFUNC( RIG_OK); }; /* @@ -3150,7 +3147,7 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) if (!status) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } switch (func) @@ -3160,11 +3157,11 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } *status = fctbuf[4] != '4' ? 1 : 0; - return RIG_OK; + RETURNFUNC( RIG_OK); case RIG_FUNC_NB: cmd = "NB"; @@ -3174,28 +3171,28 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) cmd = "NB1"; } - return get_kenwood_func(rig, cmd, status); + RETURNFUNC( get_kenwood_func(rig, cmd, status)); case RIG_FUNC_NB2: - return get_kenwood_func(rig, "NB2", status); + RETURNFUNC( get_kenwood_func(rig, "NB2", status)); case RIG_FUNC_ABM: - return get_kenwood_func(rig, "AM", status); + RETURNFUNC( get_kenwood_func(rig, "AM", status)); case RIG_FUNC_COMP: - return get_kenwood_func(rig, "PR", status); + RETURNFUNC( get_kenwood_func(rig, "PR", status)); case RIG_FUNC_TONE: - return get_kenwood_func(rig, "TO", status); + RETURNFUNC( get_kenwood_func(rig, "TO", status)); case RIG_FUNC_TSQL: - return get_kenwood_func(rig, "CT", status); + RETURNFUNC( get_kenwood_func(rig, "CT", status)); case RIG_FUNC_VOX: - return get_kenwood_func(rig, "VX", status); + RETURNFUNC( get_kenwood_func(rig, "VX", status)); case RIG_FUNC_NR: - return get_kenwood_func(rig, "NR", status); + RETURNFUNC( get_kenwood_func(rig, "NR", status)); /* FIXME on TS2000 */ // Check for BC #1 @@ -3207,7 +3204,7 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) *status = *status == '1' ? 1 : 0; } - return retval; + RETURNFUNC( retval); case RIG_FUNC_BC2: // TS-890 check Beat Cancel 2 we return boolean true/false retval = get_kenwood_func(rig, "BC", status); @@ -3217,26 +3214,26 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) *status = *status == '2' ? 1 : 0; } - return retval; + RETURNFUNC( retval); case RIG_FUNC_ANF: - return get_kenwood_func(rig, "NT", status); + RETURNFUNC( get_kenwood_func(rig, "NT", status)); case RIG_FUNC_LOCK: - return get_kenwood_func(rig, "LK", status); + RETURNFUNC( get_kenwood_func(rig, "LK", status)); case RIG_FUNC_AIP: - return get_kenwood_func(rig, "MX", status); + RETURNFUNC( get_kenwood_func(rig, "MX", status)); case RIG_FUNC_RIT: - return get_kenwood_func(rig, "RT", status); + RETURNFUNC( get_kenwood_func(rig, "RT", status)); default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_func %s", rig_strfunc(func)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* @@ -3266,13 +3263,13 @@ int kenwood_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) if (caps->ctcss_list[i] != tone) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* TODO: replace menu no 57 by a define */ snprintf(tonebuf, sizeof(tonebuf), "EX%03d%04d", 57, i + 1); - return kenwood_transaction(rig, tonebuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, tonebuf, NULL, 0)); } int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone) @@ -3293,7 +3290,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone) if (tone != caps->ctcss_list[i]) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -3306,7 +3303,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone) if (RIG_OK != (err = kenwood_get_vfo_main_sub(rig, &vfo))) { - return err; + RETURNFUNC( err); } } @@ -3318,7 +3315,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(buf, sizeof(buf), "TN%c%02d", c, i + 1); @@ -3328,7 +3325,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone) snprintf(buf, sizeof(buf), "TN%02d", i + 1); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); } /* @@ -3347,7 +3344,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) if (!tone) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } caps = rig->caps; @@ -3362,7 +3359,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { if (RIG_OK != (retval = kenwood_get_vfo_main_sub(rig, &vfo))) { - return retval; + RETURNFUNC( retval); } } @@ -3374,7 +3371,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmd, sizeof(cmd), "TN%c", c); @@ -3389,7 +3386,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } tonebuf[2] = '\0'; @@ -3399,7 +3396,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { rig_debug(RIG_DEBUG_ERR, "%s: CTCSS tone is zero (%s)\n", __func__, tonebuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } /* check this tone exists. That's better than nothing. */ @@ -3409,13 +3406,13 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { rig_debug(RIG_DEBUG_ERR, "%s: CTCSS NG (%04u)\n", __func__, tone_idx); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } } *tone = caps->ctcss_list[tone_idx - 1]; - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) @@ -3436,7 +3433,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) if (tone != caps->ctcss_list[i]) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -3449,7 +3446,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) if (RIG_OK != (err = kenwood_get_vfo_main_sub(rig, &vfo))) { - return err; + RETURNFUNC( err); } } @@ -3461,7 +3458,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(buf, sizeof(buf), "CN%c%02d", c, i + 1); @@ -3471,7 +3468,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) snprintf(buf, sizeof(buf), "CN%02d", i + 1); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); } int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) @@ -3487,7 +3484,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) if (!tone) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } caps = rig->caps; @@ -3500,7 +3497,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { if (RIG_OK != (retval = kenwood_get_vfo_main_sub(rig, &vfo))) { - return retval; + RETURNFUNC( retval); } } @@ -3512,7 +3509,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmd, sizeof(cmd), "CN%c", c); @@ -3528,7 +3525,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } tone_idx = atoi(tonebuf + offs); @@ -3537,7 +3534,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { rig_debug(RIG_DEBUG_ERR, "%s: CTCSS is zero (%s)\n", __func__, tonebuf); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } /* check this tone exists. That's better than nothing. */ @@ -3547,13 +3544,13 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { rig_debug(RIG_DEBUG_ERR, "%s: CTCSS NG (%04u)\n", __func__, tone_idx); - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } } *tone = caps->ctcss_list[tone_idx - 1]; - return RIG_OK; + RETURNFUNC( RIG_OK); } @@ -3578,7 +3575,7 @@ int kenwood_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) case RIG_ANT_4: a = '4'; break; default: - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -3591,7 +3588,7 @@ int kenwood_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) if (RIG_OK != (err = kenwood_get_vfo_main_sub(rig, &vfo))) { - return err; + RETURNFUNC( err); } } @@ -3603,7 +3600,7 @@ int kenwood_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmd, sizeof(cmd), "AN0%c%c99", c, a); @@ -3613,7 +3610,7 @@ int kenwood_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) snprintf(cmd, sizeof(cmd), "AN%c", a); } - return kenwood_transaction(rig, cmd, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmd, NULL, 0)); } int kenwood_set_ant_no_ack(RIG *rig, vfo_t vfo, ant_t ant, value_t option) @@ -3641,10 +3638,10 @@ int kenwood_set_ant_no_ack(RIG *rig, vfo_t vfo, ant_t ant, value_t option) break; default: - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } - return kenwood_transaction(rig, cmd, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, cmd, NULL, 0)); } /* @@ -3663,7 +3660,7 @@ int kenwood_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, if (!ant_curr) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -3679,19 +3676,19 @@ int kenwood_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (ackbuf[offs] < '1' || ackbuf[offs] > '9') { - return -RIG_EPROTO; + RETURNFUNC( -RIG_EPROTO); } *ant_curr = RIG_ANT_N(ackbuf[offs] - '1'); /* XXX check that the returned antenna is valid for the current rig */ - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -3706,19 +3703,19 @@ int kenwood_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) if (!ptt) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_get_if(rig); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } *ptt = priv->info[28] == '0' ? RIG_PTT_OFF : RIG_PTT_ON; - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) @@ -3737,10 +3734,10 @@ int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) case RIG_PTT_OFF: ptt_cmd = "RX"; break; - default: return -RIG_EINVAL; + default: RETURNFUNC( -RIG_EINVAL); } - return kenwood_transaction(rig, ptt_cmd, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, ptt_cmd, NULL, 0)); } int kenwood_set_ptt_safe(RIG *rig, vfo_t vfo, ptt_t ptt) @@ -3754,16 +3751,16 @@ int kenwood_set_ptt_safe(RIG *rig, vfo_t vfo, ptt_t ptt) if (err != RIG_OK) { - return err; + RETURNFUNC( err); } if (current_ptt == ptt) { - return RIG_OK; + RETURNFUNC( RIG_OK); } - return kenwood_transaction(rig, - (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, + (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0)); } @@ -3780,14 +3777,14 @@ int kenwood_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) if (!dcd) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_safe_transaction(rig, "BY", busybuf, 10, 3); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (RIG_IS_TS990S && RIG_VFO_SUB == vfo) @@ -3797,7 +3794,7 @@ int kenwood_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) *dcd = (busybuf[offs] == '1') ? RIG_DCD_ON : RIG_DCD_OFF; - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -3811,20 +3808,19 @@ int kenwood_set_trn(RIG *rig, int trn) switch (rig->caps->rig_model) { case RIG_MODEL_POWERSDR: // powersdr doesn't have AI command - return -RIG_ENAVAIL; + RETURNFUNC( -RIG_ENAVAIL); case RIG_MODEL_TS990S: - return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI2" : "AI0", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI2" : "AI0", NULL, 0)); break; case RIG_MODEL_THD7A: case RIG_MODEL_THD74: - return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0", buf, - sizeof buf); + RETURNFUNC( kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0", buf, sizeof buf)); break; default: - return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI1" : "AI0", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI1" : "AI0", NULL, 0)); break; } } @@ -3841,14 +3837,14 @@ int kenwood_get_trn(RIG *rig, int *trn) if (!trn) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* these rigs only have AI[0|1] set commands and no AI query */ if (RIG_IS_TS450S || RIG_IS_TS690S || RIG_IS_TS790 || RIG_IS_TS850 || RIG_IS_TS950S || RIG_IS_TS950SDX || RIG_IS_POWERSDR) { - return -RIG_ENAVAIL; + RETURNFUNC( -RIG_ENAVAIL); } if (RIG_IS_THD74 || RIG_IS_THD7A) @@ -3862,7 +3858,7 @@ int kenwood_get_trn(RIG *rig, int *trn) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } if (RIG_IS_THD74 || RIG_IS_THD7A) @@ -3874,7 +3870,7 @@ int kenwood_get_trn(RIG *rig, int *trn) *trn = trnbuf[2] != '0' ? RIG_TRN_RIG : RIG_TRN_OFF; } - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -3903,7 +3899,7 @@ int kenwood_set_powerstat(RIG *rig, powerstat_t status) if (retval == RIG_OK) { rig->state.rigport.retry = retry_save; - return retval; + RETURNFUNC( retval); } rig_debug(RIG_DEBUG_TRACE, "%s: Wait #%d for power up\n", __func__, i + 1); @@ -3920,7 +3916,7 @@ int kenwood_set_powerstat(RIG *rig, powerstat_t status) retval = -RIG_ETIMEOUT; } - return retval; + RETURNFUNC( retval); } /* @@ -3935,19 +3931,19 @@ int kenwood_get_powerstat(RIG *rig, powerstat_t *status) if (!status) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } retval = kenwood_safe_transaction(rig, "PS", pwrbuf, 6, 3); if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } *status = pwrbuf[2] == '0' ? RIG_POWER_OFF : RIG_POWER_ON; - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -3975,7 +3971,7 @@ int kenwood_reset(RIG *rig, reset_t reset) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n", __func__, reset); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } else @@ -3989,14 +3985,14 @@ int kenwood_reset(RIG *rig, reset_t reset) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n", __func__, reset); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } snprintf(rstbuf, sizeof(rstbuf), "SR%c", rst); /* this command has no answer */ - return kenwood_transaction(rig, rstbuf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, rstbuf, NULL, 0)); } /* @@ -4012,7 +4008,7 @@ int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg) if (!msg) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } p = msg; @@ -4032,7 +4028,7 @@ int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } /* @@ -4043,7 +4039,7 @@ int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg) if (!strncmp(m2, "KY0", 3)) { break; } if (!strncmp(m2, "KY1", 3)) { hl_usleep(500000); } - else { return -RIG_EINVAL; } + else { RETURNFUNC( -RIG_EINVAL; )} } buff_len = msg_len > 24 ? 24 : msg_len; @@ -4080,14 +4076,14 @@ int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } msg_len -= buff_len; p += buff_len; } - return RIG_OK; + RETURNFUNC( RIG_OK); } /* @@ -4100,21 +4096,21 @@ int kenwood_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) switch (op) { case RIG_OP_UP: - return kenwood_transaction(rig, "UP", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, "UP", NULL, 0)); case RIG_OP_DOWN: - return kenwood_transaction(rig, "DN", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, "DN", NULL, 0)); case RIG_OP_BAND_UP: - return kenwood_transaction(rig, "BU", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, "BU", NULL, 0)); case RIG_OP_BAND_DOWN: - return kenwood_transaction(rig, "BD", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, "BD", NULL, 0)); default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n", __func__, op); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } @@ -4137,7 +4133,7 @@ int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch) if (RIG_OK != (err = kenwood_get_vfo_main_sub(rig, &vfo))) { - return err; + RETURNFUNC( err); } } @@ -4149,7 +4145,7 @@ int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(buf, sizeof(buf), "MN%c%03d", c, ch); @@ -4164,7 +4160,7 @@ int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch) snprintf(buf, sizeof(buf), "MC %02d", ch); } - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); } /* @@ -4181,7 +4177,7 @@ int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch) if (!ch) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (RIG_IS_TS990S) @@ -4192,7 +4188,7 @@ int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch) { if (RIG_OK != (retval = kenwood_get_vfo_main_sub(rig, &vfo))) { - return retval; + RETURNFUNC( retval); } } @@ -4204,7 +4200,7 @@ int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch) default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } snprintf(cmd, sizeof(cmd), "MN%c", c); @@ -4225,12 +4221,12 @@ int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch) if (retval != RIG_OK) { - return retval; + RETURNFUNC( retval); } *ch = atoi(membuf + offs); - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_get_mem_if(RIG *rig, vfo_t vfo, int *ch) @@ -4243,14 +4239,14 @@ int kenwood_get_mem_if(RIG *rig, vfo_t vfo, int *ch) if (!ch) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } err = kenwood_get_if(rig); if (err != RIG_OK) { - return err; + RETURNFUNC( err); } memcpy(buf, &priv->info[26], 2); @@ -4258,7 +4254,7 @@ int kenwood_get_mem_if(RIG *rig, vfo_t vfo, int *ch) *ch = atoi(buf); - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) @@ -4273,7 +4269,7 @@ int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) if (!chan) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } /* put channel num in the command string */ @@ -4289,7 +4285,7 @@ int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) if (err != RIG_OK) { - return err; + RETURNFUNC( err); } memset(chan, 0x00, sizeof(channel_t)); @@ -4334,7 +4330,7 @@ int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) if (chan->freq == RIG_FREQ_NONE) { - return -RIG_ENAVAIL; + RETURNFUNC( -RIG_ENAVAIL); } buf[6] = '\0'; @@ -4351,7 +4347,7 @@ int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) if (err != RIG_OK) { - return err; + RETURNFUNC( err); } chan->tx_mode = kenwood2rmode(buf[17] - '0', caps->mode_table); @@ -4377,10 +4373,10 @@ int kenwood_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) "%s: please contact hamlib mailing list to implement this\n", __func__); rig_debug(RIG_DEBUG_ERR, "%s: need to know if rig updates when channel read or not\n", __func__); - return -RIG_ENIMPL; + RETURNFUNC( -RIG_ENIMPL); } - return RIG_OK; + RETURNFUNC( RIG_OK); } int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) @@ -4396,7 +4392,7 @@ int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) if (!chan) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } mode = rmode2kenwood(chan->mode, caps->mode_table); @@ -4405,7 +4401,7 @@ int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) { rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n", __func__, rig_strrmode(chan->mode)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } if (chan->split == RIG_SPLIT_ON) @@ -4416,7 +4412,7 @@ int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) { rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n", __func__, rig_strrmode(chan->tx_mode)); - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } } @@ -4459,7 +4455,7 @@ int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) if (err != RIG_OK) { - return err; + RETURNFUNC( err); } snprintf(buf, sizeof(buf), "MW1%c%02d%011"PRIll"%c%c%c%02d ", @@ -4471,7 +4467,7 @@ int kenwood_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) chan->ctcss_tone ? '1' : '0', chan->ctcss_tone ? (tone + 1) : 0); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); } int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val) @@ -4483,22 +4479,22 @@ int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val) switch (token) { case TOK_VOICE: - return kenwood_transaction(rig, "VR", NULL, 0); + RETURNFUNC( kenwood_transaction(rig, "VR", NULL, 0)); case TOK_FINE: snprintf(buf, sizeof(buf), "FS%c", (val.i == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case TOK_XIT: snprintf(buf, sizeof(buf), "XT%c", (val.i == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); case TOK_RIT: snprintf(buf, sizeof(buf), "RT%c", (val.i == 0) ? '0' : '1'); - return kenwood_transaction(rig, buf, NULL, 0); + RETURNFUNC( kenwood_transaction(rig, buf, NULL, 0)); } - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } int kenwood_get_ext_parm(RIG *rig, token_t token, value_t *val) @@ -4510,38 +4506,38 @@ int kenwood_get_ext_parm(RIG *rig, token_t token, value_t *val) if (!val) { - return -RIG_EINVAL; + RETURNFUNC( -RIG_EINVAL); } switch (token) { case TOK_FINE: - return get_kenwood_func(rig, "FS", &val->i); + RETURNFUNC( get_kenwood_func(rig, "FS", &val->i)); case TOK_XIT: err = kenwood_get_if(rig); if (err != RIG_OK) { - return err; + RETURNFUNC( err); } val->i = (priv->info[24] == '1') ? 1 : 0; - return RIG_OK; + RETURNFUNC( RIG_OK); case TOK_RIT: err = kenwood_get_if(rig); if (err != RIG_OK) { - return err; + RETURNFUNC( err); } val->i = (priv->info[23] == '1') ? 1 : 0; - return RIG_OK; + RETURNFUNC( RIG_OK); } - return -RIG_ENIMPL; + RETURNFUNC( -RIG_ENIMPL); } /* @@ -4557,25 +4553,25 @@ const char *kenwood_get_info(RIG *rig) if (!rig) { - return "*rig == NULL"; + RETURNFUNC( "*rig == NULL"); } retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 5); if (retval != RIG_OK) { - return NULL; + RETURNFUNC( NULL); } switch (firmbuf[4]) { - case '0': return "Firmware: Overseas type"; + case '0': RETURNFUNC( "Firmware: Overseas type"); - case '1': return "Firmware: Japanese 100W type"; + case '1': RETURNFUNC( "Firmware: Japanese 100W type"); - case '2': return "Firmware: Japanese 20W type"; + case '2': RETURNFUNC( "Firmware: Japanese 20W type"); - default: return "Firmware: unknown"; + default: RETURNFUNC( "Firmware: unknown"); } } @@ -4603,12 +4599,12 @@ DECLARE_PROBERIG_BACKEND(kenwood) if (!port) { - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } if (port->type.rig != RIG_PORT_SERIAL) { - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } port->write_delay = port->post_write_delay = 0; @@ -4629,7 +4625,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) { port->write_delay = write_delay; port->retry = retry; - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } retval = write_block(port, "ID;", 3); @@ -4646,7 +4642,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) { port->write_delay = write_delay; port->retry = retry; - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } /* @@ -4660,7 +4656,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) 6, id_len, idbuf); port->write_delay = write_delay; port->retry = retry; - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } @@ -4679,7 +4675,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) port->write_delay = write_delay; port->retry = retry; - return kenwood_id_string_list[i].model; + RETURNFUNC( kenwood_id_string_list[i].model); } } @@ -4696,7 +4692,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) if (retval != RIG_OK) { - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } retval = write_block(port, "K2;", 3); @@ -4705,7 +4701,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) if (retval != RIG_OK) { - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } /* @@ -4720,7 +4716,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) (*cfunc)(port, RIG_MODEL_K2, data); } - return RIG_MODEL_K2; + RETURNFUNC( RIG_MODEL_K2); } } @@ -4736,7 +4732,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) (*cfunc)(port, kenwood_id_list[i].model, data); } - return kenwood_id_list[i].model; + RETURNFUNC( kenwood_id_list[i].model); } } @@ -4750,7 +4746,7 @@ DECLARE_PROBERIG_BACKEND(kenwood) rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay=%d\n", __func__, port->post_write_delay); - return RIG_MODEL_NONE; + RETURNFUNC( RIG_MODEL_NONE); } @@ -4813,5 +4809,5 @@ DECLARE_INITRIG_BACKEND(kenwood) rig_register(&ts890s_caps); rig_register(&pt8000a_caps); - return RIG_OK; + RETURNFUNC( RIG_OK;) }