mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Replace __FUNCTION__, which is gcc specific and was deprecated 

a long time ago, with __func__, which is at least defined in C99.


git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@2617 7ae35d74-ebe9-4afe-98af-79ac388436b8
Hamlib-1.2.9
Alessandro Zummo, IZ1PRB 2009-02-03 23:22:58 +00:00
rodzic b510ceb1cb
commit e1c03296a4
12 zmienionych plików z 237 dodań i 237 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

56
kenwood/ic10.c
Wyświetl plik

@ -4,7 +4,7 @@
*
* Copyright (c) 2000-2008 by Stephane Fillod and others
*
* $Id: ic10.c,v 1.8 2009-01-23 03:24:42 n0nb Exp $
* $Id: ic10.c,v 1.9 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -88,7 +88,7 @@ static int get_ic10_if (RIG *rig, char *data)
(data_len < priv->if_len ||
data[0] != 'I' || data[1] != 'F')) {
rig_debug(RIG_DEBUG_WARN,"%s: unexpected answer %s, len=%d\n",
__FUNCTION__, data, data_len);
__func__, data, data_len);
retval = -RIG_ERJCTED;
}
}
@ -115,7 +115,7 @@ int ic10_set_vfo(RIG *rig, vfo_t vfo)
case RIG_VFO_CURR: return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
__FUNCTION__, vfo);
__func__, vfo);
return -RIG_EINVAL;
}
@ -154,7 +154,7 @@ int ic10_get_vfo(RIG *rig, vfo_t *vfo)
case '2': *vfo = RIG_VFO_MEM; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %c\n",
__FUNCTION__, c);
__func__, c);
return -RIG_EPROTO;
}
return RIG_OK;
@ -220,7 +220,7 @@ int ic10_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
case MD_NONE: *mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__, c);
__func__, c);
return -RIG_EINVAL;
}
@ -249,7 +249,7 @@ int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_RTTY : mode_letter = MD_FSK; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__FUNCTION__,mode);
__func__,mode);
return -RIG_EINVAL;
}
@ -309,7 +309,7 @@ int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
case RIG_VFO_B: vfo_letter = 'B'; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
__FUNCTION__,vfo);
__func__,vfo);
return -RIG_EINVAL;
}
@ -353,7 +353,7 @@ int ic10_get_ant(RIG *rig, vfo_t vfo, ant_t *ant)
if (info_len < 4 || infobuf[0] != 'A' || infobuf[1] != 'N') {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,info_len);
__func__,info_len);
return -RIG_ERJCTED;
}
@ -401,7 +401,7 @@ int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
case RIG_PTT_ON : ptt_letter = 'T'; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported PTT %d\n",
__FUNCTION__,ptt);
__func__,ptt);
return -RIG_EINVAL;
}
@ -474,7 +474,7 @@ int ic10_get_channel(RIG *rig, channel_t *chan)
case MD_NONE: chan->mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__,infobuf[17]);
__func__,infobuf[17]);
return -RIG_EINVAL;
}
chan->width = rig_passband_normal(rig, chan->mode);
@ -501,7 +501,7 @@ int ic10_get_channel(RIG *rig, channel_t *chan)
case MD_NONE: chan->tx_mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__,infobuf[17]);
__func__,infobuf[17]);
return -RIG_EINVAL;
}
chan->tx_width = rig_passband_normal(rig, chan->tx_mode);
@ -533,7 +533,7 @@ int ic10_set_channel(RIG *rig, const channel_t *chan)
case RIG_MODE_NONE: md = MD_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__FUNCTION__,chan->mode);
__func__,chan->mode);
return -RIG_EINVAL;
}
@ -559,7 +559,7 @@ int ic10_set_channel(RIG *rig, const channel_t *chan)
case RIG_MODE_NONE: md = MD_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__FUNCTION__,chan->tx_mode);
__func__,chan->tx_mode);
return -RIG_EINVAL;
}
@ -589,7 +589,7 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
case RIG_FUNC_LOCK: cmdlen = sprintf(cmdbuf,"LK;"); break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported get_func %#x",
__FUNCTION__,func);
__func__,func);
return -RIG_EINVAL;
}
@ -599,7 +599,7 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
if (fct_len != 4) {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,fct_len);
__func__,fct_len);
return -RIG_ERJCTED;
}
@ -622,7 +622,7 @@ int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
case RIG_FUNC_LOCK: cmdlen = sprintf(cmdbuf,"LK"); break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported set_func %#x",
__FUNCTION__,func);
__func__,func);
return -RIG_EINVAL;
}
@ -656,7 +656,7 @@ int ic10_set_parm(RIG *rig, setting_t parm, value_t val)
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported set_parm %d\n",
__FUNCTION__,parm);
__func__,parm);
return -RIG_EINVAL;
}
@ -683,7 +683,7 @@ int ic10_get_parm(RIG *rig, setting_t parm, value_t *val)
/* "CK1hhmmss;"*/
if (lvl_len != 10) {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,lvl_len);
__func__,lvl_len);
return -RIG_ERJCTED;
}
@ -697,7 +697,7 @@ int ic10_get_parm(RIG *rig, setting_t parm, value_t *val)
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported get_parm %d\n",
__FUNCTION__,parm);
__func__,parm);
return -RIG_EINVAL;
}
@ -736,7 +736,7 @@ int ic10_get_powerstat(RIG *rig, powerstat_t *status)
if (pwr_len != 4) {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,pwr_len);
__func__,pwr_len);
return -RIG_ERJCTED;
}
*status = pwrbuf[2] == '0' ? RIG_POWER_OFF : RIG_POWER_ON;
@ -776,7 +776,7 @@ int ic10_get_trn(RIG *rig, int *trn)
if (trn_len != 38) {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,trn_len);
__func__,trn_len);
return -RIG_ERJCTED;
}
*trn = trnbuf[2] != '0' ? RIG_TRN_RIG : RIG_TRN_OFF;
@ -799,7 +799,7 @@ int ic10_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
case RIG_OP_DOWN : cmd = "DN;"; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported op %#x\n",
__FUNCTION__,op);
__func__,op);
return -RIG_EINVAL;
}
@ -837,7 +837,7 @@ const char* ic10_get_info(RIG *rig)
if (firm_len != 6) {
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__,firm_len);
__func__,firm_len);
return NULL;
}
@ -863,13 +863,13 @@ int ic10_decode_event (RIG *rig)
rmode_t mode;
ptt_t ptt;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = ic10_transaction(rig, NULL, 0, asyncbuf, &async_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
@ -877,7 +877,7 @@ int ic10_decode_event (RIG *rig)
if (async_len<priv->if_len || asyncbuf[0] != 'I' || asyncbuf[1] != 'F') {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n",
__FUNCTION__, asyncbuf);
__func__, asyncbuf);
return -RIG_ENIMPL;
}
@ -891,7 +891,7 @@ int ic10_decode_event (RIG *rig)
case '2': vfo = RIG_VFO_MEM; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %c\n",
__FUNCTION__, c);
__func__, c);
return -RIG_EPROTO;
}
@ -906,7 +906,7 @@ int ic10_decode_event (RIG *rig)
case MD_NONE: mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__,c);
__func__,c);
return -RIG_EINVAL;
}

16
kenwood/kenwood.c
Wyświetl plik

@ -3,7 +3,7 @@
* Copyright (c) 2000-2009 by Stephane Fillod
* Copyright (C) 2009 Alessandro Zummo <a.zummo@towertech.it>
*
* $Id: kenwood.c,v 1.109 2009-02-03 22:47:33 azummo Exp $
* $Id: kenwood.c,v 1.110 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -202,7 +202,7 @@ transaction_write:
/* Check that command termination is correct */
if (strchr(cmdtrm, data[strlen(data)-1])==NULL) {
rig_debug(RIG_DEBUG_ERR, "%s: Command is not correctly terminated '%s'\n", __FUNCTION__, data);
rig_debug(RIG_DEBUG_ERR, "%s: Command is not correctly terminated '%s'\n", __func__, data);
if (retry_read++ < rig->state.rigport.retry)
goto transaction_write;
retval = -RIG_EPROTO;
@ -213,22 +213,22 @@ transaction_write:
switch (data[0]) {
case 'N':
/* Command recognised by rig but invalid data entered. */
rig_debug(RIG_DEBUG_VERBOSE, "%s: NegAck for '%s'\n", __FUNCTION__, cmdstr);
rig_debug(RIG_DEBUG_VERBOSE, "%s: NegAck for '%s'\n", __func__, cmdstr);
retval = -RIG_ENAVAIL;
goto transaction_quit;
case 'O':
/* Too many characters sent without a carriage return */
rig_debug(RIG_DEBUG_VERBOSE, "%s: Overflow for '%s'\n", __FUNCTION__, cmdstr);
rig_debug(RIG_DEBUG_VERBOSE, "%s: Overflow for '%s'\n", __func__, cmdstr);
retval = -RIG_EPROTO;
goto transaction_quit;
case 'E':
/* Communication error */
rig_debug(RIG_DEBUG_VERBOSE, "%s: Communication error for '%s'\n", __FUNCTION__, cmdstr);
rig_debug(RIG_DEBUG_VERBOSE, "%s: Communication error for '%s'\n", __func__, cmdstr);
retval = -RIG_EIO;
goto transaction_quit;
case '?':
/* Command not understood by rig */
rig_debug(RIG_DEBUG_ERR, "%s: Unknown command '%s'\n", __FUNCTION__, cmdstr);
rig_debug(RIG_DEBUG_ERR, "%s: Unknown command '%s'\n", __func__, cmdstr);
retval = -RIG_ERJCTED;
goto transaction_quit;
}
@ -647,7 +647,7 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
case RIG_VFO_C: vfo_letter = 'C'; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
__FUNCTION__, vfo);
__func__, vfo);
return -RIG_EINVAL;
}
@ -1011,7 +1011,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
if (rig->state.attenuator[i] == 0) {
rig_debug(RIG_DEBUG_ERR,"%s: "
"unexpected att level %d\n",
__FUNCTION__, lvl);
__func__, lvl);
return -RIG_EPROTO;
}
if (i != lvl)

162
kenwood/th.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TH handheld primitives
* Copyright (c) 2001-2008 by Stephane Fillod
*
* $Id: th.c,v 1.37 2009-01-28 23:30:47 azummo Exp $
* $Id: th.c,v 1.38 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -58,13 +58,13 @@ th_decode_event (RIG *rig)
int retval;
size_t async_len=128;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, NULL, 0, asyncbuf, &async_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
/* --------------------------------------------------------------------- */
if (async_len> 3 && asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') {
@ -79,7 +79,7 @@ th_decode_event (RIG *rig)
&ctcss, &tonefq, &ctcssfq, &offset, &mode);
if (retval != 11) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
@ -87,7 +87,7 @@ th_decode_event (RIG *rig)
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
mode = (mode == 0) ? RIG_MODE_FM : RIG_MODE_AM;
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (vfo %d, freq %"PRIfreq" Hz, mode %d)\n", __FUNCTION__, vfo, freq, mode);
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (vfo %d, freq %"PRIfreq" Hz, mode %d)\n", __func__, vfo, freq, mode);
/* Callback execution */
if (rig->callbacks.vfo_event) {
@ -108,14 +108,14 @@ th_decode_event (RIG *rig)
int lev;
retval = sscanf(asyncbuf, "SM %d,%d", &vfo, &lev);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
/* Calibration and conversions */
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __FUNCTION__, (float)(lev / 5.0));
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __func__, (float)(lev / 5.0));
/* Callback execution */
#if STILLHAVETOADDCALLBACK
@ -132,12 +132,12 @@ th_decode_event (RIG *rig)
retval = sscanf(asyncbuf, "BY %d,%d", &vfo, &busy);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n",
__FUNCTION__, (busy == 0) ? "OFF" : "ON" );
__func__, (busy == 0) ? "OFF" : "ON" );
return -RIG_ENIMPL;
/* This event does not have a callback. */
@ -147,19 +147,19 @@ th_decode_event (RIG *rig)
vfo_t vfo;
retval = sscanf(asyncbuf, "BC %d", &vfo);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BC message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BC message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: VFO event - vfo = %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_TRACE, "%s: VFO event - vfo = %d\n", __func__, vfo);
if (rig->callbacks.vfo_event)
rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg);
/* --------------------------------------------------------------------- */
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, asyncbuf);
return -RIG_ENIMPL;
}
@ -177,10 +177,10 @@ th_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
int retval, step;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo!=RIG_VFO_CURR) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_ENTARGET;
}
@ -206,10 +206,10 @@ th_get_freq (RIG *rig, vfo_t vfo, freq_t *freq)
int retval, step;
size_t ack_len=ACKBUF_LEN;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo!=RIG_VFO_CURR) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_ENTARGET;
}
@ -222,7 +222,7 @@ th_get_freq (RIG *rig, vfo_t vfo, freq_t *freq)
retval = sscanf(ackbuf, "FQ %"SCNfreq",%x",freq,&step);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, freqbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, freqbuf);
return -RIG_ERJCTED;
}
@ -241,10 +241,10 @@ th_set_mode (RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
size_t ack_len;
const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo!=RIG_VFO_CURR) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_ENTARGET;
}
@ -253,7 +253,7 @@ th_set_mode (RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
kmode = rmode2kenwood(mode, priv->mode_table);
if (kmode == -1) {
rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n",
__FUNCTION__, rig_strrmode(mode));
__func__, rig_strrmode(mode));
return -RIG_EINVAL;
}
kmode += '0';
@ -264,7 +264,7 @@ th_set_mode (RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_FM: kmode = '0'; break; /* TH-D7A(G) modes */
case RIG_MODE_AM: kmode = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Mode %d\n", __FUNCTION__, mode);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Mode %d\n", __func__, mode);
return -RIG_EINVAL;
}
}
@ -290,10 +290,10 @@ th_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
size_t ack_len=ACKBUF_LEN;
const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo!=RIG_VFO_CURR) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_ENTARGET;
}
@ -304,7 +304,7 @@ th_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
return retval;
if (strlen(ackbuf) < 4 || ackbuf[3] < '0' || ackbuf[3] > '9') {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -313,7 +313,7 @@ th_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
*mode = kenwood2rmode(ackbuf[3]-'0', priv->mode_table);
if (*mode == RIG_MODE_NONE) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode (table)value '%c'\n",
__FUNCTION__, ackbuf[3]);
__func__, ackbuf[3]);
return -RIG_EINVAL;
}
}
@ -323,7 +323,7 @@ th_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
case '0': *mode = RIG_MODE_FM; break; /* TH-D7A(G) modes */
case '1': *mode = RIG_MODE_AM; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%c'\n", __FUNCTION__, ackbuf[3]);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%c'\n", __func__, ackbuf[3]);
return -RIG_EINVAL;
}
}
@ -345,7 +345,7 @@ th_set_vfo (RIG *rig, vfo_t vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_A:
@ -364,7 +364,7 @@ th_set_vfo (RIG *rig, vfo_t vfo)
sprintf(vfobuf, "VMC 0,2" EOM);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -403,7 +403,7 @@ th_get_vfo (RIG *rig, vfo_t *vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
ack_len=ACKBUF_LEN;
retval = kenwood_transaction (rig, "BC" EOM, 3, ackbuf, &ack_len);
@ -411,7 +411,7 @@ th_get_vfo (RIG *rig, vfo_t *vfo)
return retval;
if (ack_len < 4 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -420,7 +420,7 @@ th_get_vfo (RIG *rig, vfo_t *vfo)
case '0': *vfo = RIG_VFO_A; break;
case '1': *vfo = RIG_VFO_B; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __FUNCTION__, ackbuf[3]);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, ackbuf[3]);
return -RIG_EVFO;
}
@ -431,7 +431,7 @@ th_get_vfo (RIG *rig, vfo_t *vfo)
return retval;
if (ack_len < 8 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
switch(ackbuf[6]) {
@ -442,7 +442,7 @@ th_get_vfo (RIG *rig, vfo_t *vfo)
*vfo = RIG_VFO_MEM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __FUNCTION__, ackbuf[6]);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, ackbuf[6]);
return -RIG_EVFO;
}
@ -461,7 +461,7 @@ th_set_trn(RIG *rig, int trn)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
sprintf(trnbuf, "AI %c" EOM, (trn == RIG_TRN_RIG) ? '1' : '0');
ack_len = ACKBUF_LEN;
@ -483,14 +483,14 @@ th_get_trn (RIG *rig, int *trn)
int retval;
size_t ack_len=ACKBUF_LEN;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, "AI" EOM, 3, ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
if (ack_len < 4 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -509,14 +509,14 @@ static int th_get_kenwood_func (RIG *rig, const char *cmd, int *status)
char ackbuf[ACKBUF_LEN];
int retval;
size_t ack_len=ACKBUF_LEN;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction (rig, cmd, strlen(cmd), ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
if (ack_len < 4 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -535,7 +535,7 @@ static int th_get_kenwood_func (RIG *rig, const char *cmd, int *status)
int
th_get_func (RIG *rig, vfo_t vfo, setting_t func, int *status)
{
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __FUNCTION__, func);
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func);
/* FIXME: What about the VFO? */
@ -555,7 +555,7 @@ th_get_func (RIG *rig, vfo_t vfo, setting_t func, int *status)
case RIG_FUNC_LOCK:
return th_get_kenwood_func(rig, "LK" EOM, status);
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported function %#x", __FUNCTION__, func);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported function %#x", __func__, func);
return -RIG_EINVAL;
}
return RIG_OK;
@ -592,7 +592,7 @@ static int th_set_kenwood_func (RIG *rig, const char *cmd, int status)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
strncpy(trbuf,cmd,16);
strncat(trbuf,(status)?" 1":" 0",15);
@ -603,7 +603,7 @@ static int th_set_kenwood_func (RIG *rig, const char *cmd, int status)
return retval;
if (ack_len < 4 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
return RIG_OK;
@ -617,7 +617,7 @@ static int th_set_kenwood_func (RIG *rig, const char *cmd, int status)
int
th_set_func (RIG *rig, vfo_t vfo, setting_t func, int status)
{
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __FUNCTION__, func);
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func);
/* FIXME: What about the VFO? */
@ -639,7 +639,7 @@ th_set_func (RIG *rig, vfo_t vfo, setting_t func, int status)
case RIG_FUNC_TBURST:
return th_tburst(rig, vfo, status);
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported function %#x", __FUNCTION__, func);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported function %#x", __func__, func);
return -RIG_EINVAL;
}
return RIG_OK;
@ -655,7 +655,7 @@ th_get_parm (RIG *rig, setting_t parm, value_t *val)
int status;
int ret;
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __FUNCTION__, parm);
rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, parm);
/* Optimize:
* sort the switch cases with the most frequent first
@ -667,7 +667,7 @@ th_get_parm (RIG *rig, setting_t parm, value_t *val)
return ret;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported parm %#x", __FUNCTION__, parm);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported parm %#x", __func__, parm);
return -RIG_EINVAL;
}
return RIG_OK;
@ -686,7 +686,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
size_t ack_len=ACKBUF_LEN;
vfo_t tvfo;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo==RIG_VFO_CURR) tvfo=rig->state.current_vfo;
else tvfo=vfo;
@ -699,7 +699,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_VFO_B:
vch = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -712,7 +712,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
retval = sscanf(ackbuf, "SM %d,%d", &v, &l);
if (retval != 2 || l < rig->caps->level_gran[LVL_RAWSTR].min.i || l > rig->caps->level_gran[LVL_RAWSTR].max.i) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -727,7 +727,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
retval = sscanf(ackbuf, "SQ %d,%x", &v, &l);
if (retval != 2 || l < rig->caps->level_gran[LVL_SQL].min.i || l > rig->caps->level_gran[LVL_SQL].max.i) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -743,7 +743,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
retval = sscanf(ackbuf, "AG %d,%x", &v, &l);
if (retval != 2 || l < rig->caps->level_gran[LVL_AF].min.i || l > rig->caps->level_gran[LVL_AF].max.i) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -759,7 +759,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
retval = sscanf(ackbuf, "PC %d,%d", &v, &l);
if (retval != 2 || l < 0 || l > 3) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -791,7 +791,7 @@ th_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Level %d", __FUNCTION__, level);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Level %d", __func__, level);
return -RIG_EINVAL;
}
return RIG_OK;
@ -804,7 +804,7 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val)
size_t ack_len;
vfo_t tvfo;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo==RIG_VFO_CURR) tvfo=rig->state.current_vfo;
else tvfo=vfo;
@ -817,7 +817,7 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_VFO_B:
vch = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -845,7 +845,7 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val)
retval = kenwood_transaction (rig, lvlbuf, strlen(lvlbuf), ackbuf, &ack_len);
return retval;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Level %d", __FUNCTION__, level);
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported Level %d", __func__, level);
return -RIG_EINVAL;
}
return RIG_OK;
@ -867,7 +867,7 @@ th_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
int i, retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
caps = rig->caps;
@ -901,7 +901,7 @@ th_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
size_t ack_len=ACKBUF_LEN;
unsigned int tone_idx;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
caps = rig->caps;
@ -912,14 +912,14 @@ th_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
retval = sscanf(ackbuf, "CTN %d", (int*)&tone_idx);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR,
"%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
"%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_EPROTO;
}
/* verify tone index for TH-7DA rig */
if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS no (%04d)\n",
__FUNCTION__, tone_idx);
__func__, tone_idx);
return -RIG_EPROTO;
}
tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-7DA index anomaly */
@ -934,7 +934,7 @@ th_get_info(RIG *rig)
int retval;
size_t firm_len=50;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
memset(firmbuf, 0, sizeof(firmbuf));
retval = kenwood_transaction (rig, "ID" EOM, 3, firmbuf, &firm_len);
@ -943,7 +943,7 @@ th_get_info(RIG *rig)
if (firm_len <3 ) {
rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n",
__FUNCTION__, firmbuf, firm_len);
__func__, firmbuf, firm_len);
return NULL;
}
@ -963,7 +963,7 @@ th_set_mem(RIG *rig, vfo_t vfo, int ch)
size_t ack_len;
vfo_t tvfo;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo==RIG_VFO_CURR) tvfo=rig->state.current_vfo;
else tvfo=vfo;
@ -976,7 +976,7 @@ th_set_mem(RIG *rig, vfo_t vfo, int ch)
case RIG_VFO_B:
vsel = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
sprintf(membuf, "MC %c,%03i" EOM, vsel, ch);
@ -1001,7 +1001,7 @@ th_get_mem(RIG *rig, vfo_t vfo, int *ch)
size_t ack_len=ACKBUF_LEN;
vfo_t tvfo,cvfo;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
cvfo=rig->state.current_vfo;
if(vfo==RIG_VFO_CURR)
@ -1019,7 +1019,7 @@ th_get_mem(RIG *rig, vfo_t vfo, int *ch)
membuf = "MC 1" EOM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -1033,7 +1033,7 @@ th_get_mem(RIG *rig, vfo_t vfo, int *ch)
if (ack_len <9 ) {
rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n",
__FUNCTION__, ackbuf, ack_len);
__func__, ackbuf, ack_len);
return -RIG_ERJCTED;
}
@ -1054,7 +1054,7 @@ th_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch(ptt) {
case RIG_PTT_ON :
@ -1081,7 +1081,7 @@ th_set_powerstat(RIG *rig, powerstat_t status)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch(status) {
case RIG_POWER_ON :
@ -1139,7 +1139,7 @@ int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
membuf = "BY 1" EOM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -1150,7 +1150,7 @@ int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
if (ack_len <6 ) {
rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n",
__FUNCTION__, ackbuf, ack_len);
__func__, ackbuf, ack_len);
return -RIG_ERJCTED;
}
@ -1162,7 +1162,7 @@ int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
*dcd=RIG_DCD_ON;
return RIG_OK;
default :
rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", __FUNCTION__, ackbuf, ack_len);
rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", __func__, ackbuf, ack_len);
return -RIG_ERJCTED;
}
return -RIG_ERJCTED;
@ -1175,10 +1175,10 @@ int th_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if(vfo!=RIG_VFO_CURR) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_ENTARGET;
}
@ -1307,7 +1307,7 @@ int th_get_channel(RIG *rig, channel_t *chan)
&offset, &mode, &lockout
);
if (retval < 12) {
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __FUNCTION__, retval);
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval);
return -RIG_EPROTO;
}
}
@ -1318,7 +1318,7 @@ int th_get_channel(RIG *rig, channel_t *chan)
&freq, &step, &shift, &rev, &tone,
&ctcss, &tonefq, &ctcssfq, &offset);
if (retval != 9) {
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __FUNCTION__, retval);
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval);
}
}
@ -1332,7 +1332,7 @@ int th_get_channel(RIG *rig, channel_t *chan)
chan->mode = kenwood2rmode(mode, priv->mode_table);
if (chan->mode == RIG_MODE_NONE) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n",
__FUNCTION__, mode);
__func__, mode);
return -RIG_EPROTO;
}
}
@ -1359,7 +1359,7 @@ int th_get_channel(RIG *rig, channel_t *chan)
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n",
__FUNCTION__, shift);
__func__, shift);
chan->rptr_shift=RIG_RPT_SHIFT_NONE;
}
chan->rptr_offs=offset;
@ -1460,7 +1460,7 @@ int th_set_channel(RIG *rig, const channel_t *chan)
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n",
__FUNCTION__, chan->rptr_shift);
__func__, chan->rptr_shift);
return -RIG_EINVAL;
}
@ -1556,13 +1556,13 @@ int th_set_channel(RIG *rig, const channel_t *chan)
{
if (!priv->mode_table) {
rig_debug(RIG_DEBUG_ERR, "%s: Buggy backend, no mode_table '%d'\n",
__FUNCTION__, chan->mode);
__func__, chan->mode);
return -RIG_ENIMPL;
}
mode = rmode2kenwood(chan->mode, priv->mode_table);
if (mode == -1) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n",
__FUNCTION__, chan->mode);
__func__, chan->mode);
return -RIG_EINVAL;
}

18
kenwood/thf7.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TH-F7 description
* Copyright (c) 2001-2004 by Stephane Fillod
*
* $Id: thf7.c,v 1.16 2009-01-28 23:30:52 azummo Exp $
* $Id: thf7.c,v 1.17 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -291,7 +291,7 @@ thf7_set_vfo (RIG *rig, vfo_t vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
/*
* The band must be active before selecting VFO or MEM.
@ -312,7 +312,7 @@ thf7_set_vfo (RIG *rig, vfo_t vfo)
sprintf(vfobuf, "BC 1%c", EOM_TH);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported BC VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported BC VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -337,7 +337,7 @@ thf7_set_vfo (RIG *rig, vfo_t vfo)
sprintf(vfobuf, "VMC 0,1%c", EOM_TH);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -359,7 +359,7 @@ thf7_get_vfo (RIG *rig, vfo_t *vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
ack_len=ACKBUF_LEN;
/* XXX */
@ -368,7 +368,7 @@ thf7_get_vfo (RIG *rig, vfo_t *vfo)
return retval;
if (ack_len < 4 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
@ -377,7 +377,7 @@ thf7_get_vfo (RIG *rig, vfo_t *vfo)
case '0': *vfo = RIG_VFO_A; break;
case '1': *vfo = RIG_VFO_B; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __FUNCTION__, ackbuf[3]);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, ackbuf[3]);
return -RIG_EVFO;
}
@ -388,7 +388,7 @@ thf7_get_vfo (RIG *rig, vfo_t *vfo)
return retval;
if (ack_len < 8 ) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __FUNCTION__, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf);
return -RIG_ERJCTED;
}
switch(ackbuf[6]) {
@ -401,7 +401,7 @@ thf7_get_vfo (RIG *rig, vfo_t *vfo)
*vfo = RIG_VFO_MEM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __FUNCTION__, ackbuf[6]);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, ackbuf[6]);
return -RIG_EVFO;
}

34
kenwood/thg71.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TH-G71 description
* Copyright (c) 2003-2008 by Stephane Fillod
*
* $Id: thg71.c,v 1.24 2009-02-03 22:42:44 azummo Exp $
* $Id: thg71.c,v 1.25 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -189,13 +189,13 @@ int thg71_decode_event (RIG *rig)
char asyncbuf[ACKBUF_LEN];
int retval;
size_t asyncbuf_len = ACKBUF_LEN;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, NULL, 0, asyncbuf, &asyncbuf_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
if (asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') {
@ -206,11 +206,11 @@ int thg71_decode_event (RIG *rig)
&freq, &step, &shift, &rev, &tone,
&ctcss, &tonefq, &ctcssfq, &offset);
if (retval != 11) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (freq %"PRIfreq" Hz, mode %d)\n", __FUNCTION__, freq);
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (freq %"PRIfreq" Hz, mode %d)\n", __func__, freq);
/* Callback execution */
if (rig->callbacks.vfo_event) {
@ -232,11 +232,11 @@ int thg71_decode_event (RIG *rig)
int lev;
retval = sscanf(asyncbuf, "SM 0,%d", &lev);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __FUNCTION__, (float)(lev / 5.0));
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __func__, (float)(lev / 5.0));
/* Callback execution */
#if STILLHAVETOADDCALLBACK
@ -252,11 +252,11 @@ int thg71_decode_event (RIG *rig)
retval = sscanf(asyncbuf, "BY 0,%d", &busy);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n",
__FUNCTION__, (busy == 0) ? "OFF" : "ON" );
__func__, (busy == 0) ? "OFF" : "ON" );
return -RIG_ENIMPL;
/* This event does not have a callback. */
@ -267,7 +267,7 @@ int thg71_decode_event (RIG *rig)
retval = sscanf(asyncbuf, "VMC 0,%d", &bandmode);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VMC message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VMC message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
@ -277,14 +277,14 @@ int thg71_decode_event (RIG *rig)
/* case 3: bandmode = RIG_VFO_CALL; break; */
default: bandmode = RIG_VFO_CURR; break;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Mode of Band event - %d\n", __FUNCTION__, bandmode);
rig_debug(RIG_DEBUG_TRACE, "%s: Mode of Band event - %d\n", __func__, bandmode);
/* TODO: This event does not have a callback! */
return -RIG_ENIMPL;
/* --------------------------------------------------------------------- */
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, asyncbuf);
return -RIG_ENIMPL;
}
@ -300,13 +300,13 @@ int thg71_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int step;
freq_t freq;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_CURR: break;
case RIG_VFO_A: break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -335,7 +335,7 @@ int thg71_set_vfo (RIG *rig, vfo_t vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_A:
@ -346,7 +346,7 @@ int thg71_set_vfo (RIG *rig, vfo_t vfo)
sprintf(vfobuf, "VMC 0,2"EOM);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -380,7 +380,7 @@ int thg71_get_vfo (RIG *rig, vfo_t *vfo)
*vfo=RIG_VFO_MEM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
return RIG_OK;

40
kenwood/tmv7.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TM-V7 description
* Copyright (c) 2004-2008 by Stephane Fillod
*
* $Id: tmv7.c,v 1.19 2009-02-03 22:42:44 azummo Exp $
* $Id: tmv7.c,v 1.20 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -219,13 +219,13 @@ int tmv7_decode_event (RIG *rig)
char asyncbuf[ACKBUF_LEN];
int retval;
size_t asyncbuf_len = ACKBUF_LEN;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, NULL, 0, asyncbuf, &asyncbuf_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
if (asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') {
@ -236,11 +236,11 @@ int tmv7_decode_event (RIG *rig)
&freq, &step, &shift, &rev, &tone,
&ctcss, &tonefq, &ctcssfq, &offset);
if (retval != 11) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (freq %"PRIfreq" Hz, mode %d)\n", __FUNCTION__, freq);
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (freq %"PRIfreq" Hz, mode %d)\n", __func__, freq);
/* Callback execution */
if (rig->callbacks.vfo_event) {
@ -262,11 +262,11 @@ int tmv7_decode_event (RIG *rig)
int lev;
retval = sscanf(asyncbuf, "SM 0,%d", &lev);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __FUNCTION__, (float)(lev / 5.0));
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __func__, (float)(lev / 5.0));
/* Callback execution */
#if STILLHAVETOADDCALLBACK
@ -282,11 +282,11 @@ int tmv7_decode_event (RIG *rig)
retval = sscanf(asyncbuf, "BY 0,%d", &busy);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n",
__FUNCTION__, (busy == 0) ? "OFF" : "ON" );
__func__, (busy == 0) ? "OFF" : "ON" );
return -RIG_ENIMPL;
/* This event does not have a callback. */
@ -297,7 +297,7 @@ int tmv7_decode_event (RIG *rig)
retval = sscanf(asyncbuf, "VMC 0,%d", &bandmode);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VMC message '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VMC message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
@ -307,14 +307,14 @@ int tmv7_decode_event (RIG *rig)
/* case 3: bandmode = RIG_VFO_CALL; break; */
default: bandmode = RIG_VFO_CURR; break;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Mode of Band event - %d\n", __FUNCTION__, bandmode);
rig_debug(RIG_DEBUG_TRACE, "%s: Mode of Band event - %d\n", __func__, bandmode);
/* TODO: This event does not have a callback! */
return -RIG_ENIMPL;
/* --------------------------------------------------------------------- */
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __FUNCTION__, asyncbuf);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, asyncbuf);
return -RIG_ENIMPL;
}
@ -329,7 +329,7 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
int retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called %d\n", __FUNCTION__,vfo);
rig_debug(RIG_DEBUG_TRACE, "%s: called %d\n", __func__,vfo);
switch (vfo) {
case RIG_VFO_A:
@ -347,18 +347,18 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
sprintf(vfobuf, "VMC %c,2" EOM,ackbuf[3]);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
ack_len=0;
retval = kenwood_transaction(rig, vfobuf, strlen(vfobuf), ackbuf, &ack_len);
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "%s: bad return \n", __FUNCTION__);
rig_debug(RIG_DEBUG_ERR, "%s: bad return \n", __func__);
return retval;
}
rig_debug(RIG_DEBUG_TRACE, "%s: next %d\n", __FUNCTION__,vfo);
rig_debug(RIG_DEBUG_TRACE, "%s: next %d\n", __func__,vfo);
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_VFO:
@ -373,7 +373,7 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
return RIG_OK;
}
rig_debug(RIG_DEBUG_TRACE, "%s: next2\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: next2\n", __func__);
ack_len=0;
retval = kenwood_transaction(rig, vfobuf, strlen(vfobuf), ackbuf, &ack_len);
if (retval != RIG_OK)
@ -391,13 +391,13 @@ int tmv7_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int step;
freq_t freq;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_CURR: break;
case RIG_VFO_A: break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __FUNCTION__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
@ -568,7 +568,7 @@ int tmv7_set_channel(RIG *rig, const channel_t *chan)
shift=2;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: not supported shift\n", __FUNCTION__);
rig_debug(RIG_DEBUG_ERR, "%s: not supported shift\n", __func__);
return -RIG_EINVAL;
}

6
kenwood/ts2000.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TS2000 description
* Copyright (c) 2000-2008 by Stephane Fillod
*
* $Id: ts2000.c,v 1.26 2009-02-03 22:13:55 azummo Exp $
* $Id: ts2000.c,v 1.27 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -290,7 +290,7 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return retval;
if ((lvl_len != 5)){ /*TS-2000 returns 5 chars for PA; */
rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer len=%d\n",
__FUNCTION__, lvl_len);
__func__, lvl_len);
return -RIG_ERJCTED;
}
@ -509,7 +509,7 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
if (( (lvl_len !=8)) || lvlbuf[1] != 'M') {
/* TS-2000 returns 8 bytes for S meter level */
rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
__FUNCTION__, lvl_len);
__func__, lvl_len);
return -RIG_ERJCTED;
}

114
kenwood/ts2k.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TS2000 description
* Copyright (c) 2000-2002 by Stephane Fillod
*
* $Id: ts2k.c,v 1.7 2009-01-23 03:24:42 n0nb Exp $
* $Id: ts2k.c,v 1.8 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -63,7 +63,7 @@
* Hamlib Kenwood backend - main file
* Copyright (c) 2000-2002 by Stephane Fillod
*
* $Id: ts2k.c,v 1.7 2009-01-23 03:24:42 n0nb Exp $
* $Id: ts2k.c,v 1.8 2009-02-03 23:22:58 azummo Exp $
*/
@ -193,13 +193,13 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
cmdtrm = cmd_trm(rig);
if (cmdstr != NULL) {
// rig_debug(RIG_DEBUG_ERR, __FUNCTION__": 1) sending '%s'\n\n", cmdstr);
// rig_debug(RIG_DEBUG_ERR, __func__": 1) sending '%s'\n\n", cmdstr);
retval = write_block(&rs->rigport, cmdstr, strlen(cmdstr));
if (retval != RIG_OK)
{ ta_quit; }
#undef TH_ADD_CMDTRM
#ifdef TH_ADD_CMDTRM
// rig_debug(RIG_DEBUG_ERR, __FUNCTION__": 2) sending '%s'\n\n", cmdtrm);
// rig_debug(RIG_DEBUG_ERR, __func__": 2) sending '%s'\n\n", cmdtrm);
retval = write_block(&rs->rigport, cmdtrm, strlen(cmdtrm));
if (retval != RIG_OK)
{ ta_quit; }
@ -215,14 +215,14 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
transaction_read:
/* FIXME : TS-2000 gets alot of 'timedout' on read_string()! */
//rig_debug(RIG_DEBUG_ERR, __FUNCTION__": 3a) reading %u bytes...\n", *datasize);
//rig_debug(RIG_DEBUG_ERR, __func__": 3a) reading %u bytes...\n", *datasize);
retval =
read_string(&rs->rigport, data, *datasize, cmdtrm,
strlen(cmdtrm));
//rig_debug(RIG_DEBUG_ERR, __FUNCTION__": 3b) read '%s', retval=%u\n\n", data, retval);
//rig_debug(RIG_DEBUG_ERR, __func__": 3b) read '%s', retval=%u\n\n", data, retval);
*datasize = retval;
if (retval > 0) {
//rig_debug(RIG_DEBUG_ERR, __FUNCTION__": 3b) read cmd '%s', retval=%u\n\n", data, retval);
//rig_debug(RIG_DEBUG_ERR, __func__": 3b) read cmd '%s', retval=%u\n\n", data, retval);
retval = RIG_OK;
goto transaction_check;
}
@ -232,7 +232,7 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
if (retry_read++ < MAX_RETRY_READ)
goto transaction_read;
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__
__func__
": Command is not correctly terminated '%s'\n",
data);
retval = -RIG_EPROTO;
@ -244,28 +244,28 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
switch (data[0]) {
case 'E':
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
case 'O':
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
case '?':
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
default:
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__ ": Hamlib Error for '%s'\n",
__func__ ": Hamlib Error for '%s'\n",
cmdstr);
break;
@ -296,7 +296,7 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
goto transaction_read;
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__ ": Unexpected reply '%s'\n", data);
__func__ ": Unexpected reply '%s'\n", data);
retval = -RIG_EPROTO;
{ ta_quit; }
}
@ -326,7 +326,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
// trivial case, but needs checked if enabled
/*// if( (vfo == RIG_CTRL_MODE(RIG_CTRL_MAIN,RIG_VFO_ALL))
// || (vfo == RIG_CTRL_MODE(RIG_CTRL_SUB,RIG_VFO_ALL)) ) {
// rig_debug(RIG_DEBUG_ERR, __FUNCTION__ \
// rig_debug(RIG_DEBUG_ERR, __func__ \
// ": Geez, you can't set *all* VFO's!\n");
// return -RIG_EINVAL;
// }
@ -377,7 +377,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
|| (vfo & RIG_CTRL_SAT) // "fr...;", "ft...;" won't do!
;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__ \
rig_debug(RIG_DEBUG_ERR, __func__ \
": starting check.... vfo = 0x%X, v=%d\n", vfo, v);
if (!v) { // start check
@ -411,7 +411,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
break;
default:
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
": unsupported VFO %u\n", vfo);
return -RIG_EINVAL;
break;
@ -448,7 +448,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
break;
default:
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
": unsupported VFO %u\n",
vfo);
return -RIG_EINVAL;
@ -473,7 +473,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
return retval;
sat_on = 1;
} else {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__ \
rig_debug(RIG_DEBUG_ERR, __func__ \
": VFO not changed, only PTT/CTRL\n");
}
}
@ -539,7 +539,7 @@ int ts2k_sat_on(RIG *rig, vfo_t vfo)
ack[5] = '0'; // sat CTRL on main
STest:
rig_debug(RIG_DEBUG_ERR, __FUNCTION__ \
rig_debug(RIG_DEBUG_ERR, __func__ \
": sat = %s, vfo = 0x%X\n", cmd, vfo);
// of coure, this is *required* too!
return ts2k_transaction(rig, ack, acklen, NULL, NULL);
@ -588,18 +588,18 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
/* query RX VFO */
vfo_len = 50;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
": sending fr; cmd/checking SAT. Expect TIMEDOUT if in SAT mode!\n");
retval = ts2k_transaction(rig, "fr;", 3, vfobuf, &vfo_len);
/* "fr;" fails in satellite mode; interesting... */
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": kenwood/ts2k.c\n"
rig_debug(RIG_DEBUG_ERR, __func__": kenwood/ts2k.c\n"
"FIXME: ts2k.c,\tThis is timeout cannot be prevented.\n");
tmp = retval;
retval = ts2k_transaction(rig, "sa;", 3, vfobuf, &vfo_len);
if (retval == RIG_OK) {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": SAT=%s\n", vfobuf);
rig_debug(RIG_DEBUG_ERR, __func__": SAT=%s\n", vfobuf);
if(vfobuf[2] == '1') {
/* yes, we're in satellite mode! */
*vfo = RIG_CTRL_SAT; // FIXME: set the rest!
@ -610,24 +610,24 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
return tmp; // return original "fr;" error!
}
// rig_debug(RIG_DEBUG_ERR, __FUNCTION__": checking fr; cmd.\n");
// rig_debug(RIG_DEBUG_ERR, __func__": checking fr; cmd.\n");
r_vfo = vfobuf[2];
//if (vfo_len != 4 || vfobuf[1] != 'R') {
if (vfobuf[1] != 'R') {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
": unexpected answer %s, "
"len=%u\n", vfobuf, vfo_len);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": sending ft; cmd.\n");
rig_debug(RIG_DEBUG_ERR, __func__": sending ft; cmd.\n");
vfo_len = 50;
retval = ts2k_transaction(rig, "ft;", 3, vfobuf, &vfo_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": checking ft; cmd.\n");
rig_debug(RIG_DEBUG_ERR, __func__": checking ft; cmd.\n");
if (vfobuf[2] == r_vfo) { // check most common first
rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: Non-Split.\n");
@ -686,7 +686,7 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
*vfo = RIG_VFO_BA;
else { // FIXME: need vfo <--> mem split
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__
__func__
":FIXME: vfo<->mem split! -kd7eni!\n");
return -RIG_EPROTO;
}
@ -771,7 +771,7 @@ int ts2k_get_freq(RIG * rig, vfo_t vfo, freq_t * freq)
break;
default:
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": unsupported VFO %u\n", vfo);
__func__": unsupported VFO %u\n", vfo);
return -RIG_EPROTO;
}
@ -780,14 +780,14 @@ int ts2k_get_freq(RIG * rig, vfo_t vfo, freq_t * freq)
freq_len = 15;
retval =
ts2k_transaction(rig, cmdbuf, cmd_len, freqbuf, &freq_len);
//rig_debug(RIG_DEBUG_ERR,"__FUNCTION__: received %s\n", cmdbuf);
//rig_debug(RIG_DEBUG_ERR,"__func__: received %s\n", cmdbuf);
if (retval != RIG_OK)
return retval;
//if (freq_len != 14 || freqbuf[0] != 'F') {
if (freqbuf[0] != 'F') {
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": unexpected answer '%s', "
__func__": unexpected answer '%s', "
"len=%u\n", freqbuf, freq_len);
return -RIG_ERJCTED;
}
@ -1283,7 +1283,7 @@ get_ts2k_func(RIG * rig, const char *cmd, int cmd_len, int *status)
if (fct_len != 4) {
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": wrong answer len=%u\n", fct_len);
__func__": wrong answer len=%u\n", fct_len);
return -RIG_ERJCTED;
}
@ -1404,7 +1404,7 @@ int ts2k_set_Tones(RIG * rig, vfo_t vfo, tone_t tone, const char ct)
ack_len = 16;
return ts2k_transaction(rig, tonebuf, tone_len, NULL, NULL);
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": sent %s", tonebuf);
rig_debug(RIG_DEBUG_ERR, __func__": sent %s", tonebuf);
}
/*
@ -1437,7 +1437,7 @@ int ts2k_get_Tones(RIG * rig, vfo_t vfo, tone_t * tone, const char *ct)
if (tone_len != 5) {
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": unexpected reply "
__func__": unexpected reply "
"'%s', len=%u\n", tonebuf, tone_len);
return -RIG_ERJCTED;
}
@ -1446,7 +1446,7 @@ int ts2k_get_Tones(RIG * rig, vfo_t vfo, tone_t * tone, const char *ct)
if (tone_idx == 0) {
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": Unexpected Tone "
__func__": Unexpected Tone "
"no (%04d)\n", tone_idx);
return -RIG_EPROTO;
}
@ -1455,7 +1455,7 @@ int ts2k_get_Tones(RIG * rig, vfo_t vfo, tone_t * tone, const char *ct)
for (i = 0; i < tone_idx; i++) {
if (caps->ctcss_list[i] == 0) {
rig_debug(RIG_DEBUG_ERR,
__FUNCTION__": Tone NG "
__func__": Tone NG "
"(%04d)\n", tone_idx);
return -RIG_EPROTO;
}
@ -1873,7 +1873,7 @@ int ts2k_init(RIG * rig)
{
const struct rig_caps *caps;
const struct ts2k_priv_caps *priv_caps;
rig_debug(RIG_DEBUG_TRACE, __FUNCTION__ ": called\n");
rig_debug(RIG_DEBUG_TRACE, __func__ ": called\n");
if (!rig || !rig->caps)
return -RIG_EINVAL;
@ -1905,7 +1905,7 @@ int ts2k_init(RIG * rig)
*/
int ts2k_cleanup(RIG * rig)
{
rig_debug(RIG_DEBUG_TRACE, __FUNCTION__ ": called\n");
rig_debug(RIG_DEBUG_TRACE, __func__ ": called\n");
if (!rig)
return -RIG_EINVAL;
@ -2007,11 +2007,11 @@ int ts2k_set_ctrl(RIG * rig, int ptt, int ctrl)
buf = ts2k_get_ctrl(rig);
if(buf==NULL) {
rig_debug(RIG_DEBUG_VERBOSE, __FUNCTION__ \
rig_debug(RIG_DEBUG_VERBOSE, __func__ \
": returned NULL!\n");
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_VERBOSE, __FUNCTION__": curr='%s',"
rig_debug(RIG_DEBUG_VERBOSE, __func__": curr='%s',"
"ptt=%u, ctrl=%u\n", buf, ptt, ctrl);
if (ptt != 0)
@ -2117,7 +2117,7 @@ int ts2k_get_ts(RIG * rig, vfo_t vfo, shortfreq_t * ts)
ack[4] = '\0';
s = atoi(&ack[2]);
rig_debug(RIG_DEBUG_VERBOSE, __FUNCTION__": received: '%s', %u\n", ack, s);
rig_debug(RIG_DEBUG_VERBOSE, __func__": received: '%s', %u\n", ack, s);
retval = ts2k_transaction(rig, "MD;", 5, ack, &acklen);
CHKERR(retval);
@ -2125,7 +2125,7 @@ int ts2k_get_ts(RIG * rig, vfo_t vfo, shortfreq_t * ts)
// fm or am mode selects 1
m = (ack[2] == '4' || ack[2] == '5') ? 1 : 0;
rig_debug(RIG_DEBUG_VERBOSE, __FUNCTION__": received: '%s', %u\n", ack, m);
rig_debug(RIG_DEBUG_VERBOSE, __func__": received: '%s', %u\n", ack, m);
*ts = ts2k_steps[m][s];
return RIG_OK;
@ -2399,7 +2399,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
v = vfo;
// check the memory bit
if( !(v & RIG_VFO_MEM) ) {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
": Non Memory VFO='%u', v=%u\n", vfo, v);
return -RIG_EINVAL; // not a channel!
}
@ -2407,7 +2407,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
// get needed info if rig's mem pointers used
if( ( vfo == RIG_VFO_MEM_A
|| vfo == RIG_VFO_MEM_C ) ) {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": using rig's ptr\n");
rig_debug(RIG_DEBUG_ERR, __func__": using rig's ptr\n");
retval = ts2k_get_vfo(rig, &curr_vfo);
CHKERR(retval);
retval = ts2k_get_mem(rig, curr_vfo, &curr_mem);
@ -2430,7 +2430,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
retval = ts2k_transaction(rig, mrcmd, mrcmd_len, ack, &ack_len);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": read \n\t'%s'\n", ack);
rig_debug(RIG_DEBUG_ERR, __func__": read \n\t'%s'\n", ack);
ack[50] = '\0'; // May be too far, but helps.
@ -2441,7 +2441,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
check |= (ack[2] != ((i == 0)? '0' : '1'));
check |= (chan->channel_num != int_n(tmp, &ack[3], 3));
if( check ) {
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
rig_debug(RIG_DEBUG_ERR, __func__
":check failed!\n");
return -RIG_EINVAL; // correct error type?
}
@ -2452,7 +2452,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
// FIXME: handle mem split
// final check on data. (if RX!=TX mem split, or limit!)
if( strncmp( &mrtxt[0][3], &mrtxt[1][3], 41-3) != 0 ) {
rig_debug(RIG_DEBUG_ERR, "\n"__FUNCTION__
rig_debug(RIG_DEBUG_ERR, "\n"__func__
": MEM split and band limits not yet supported!\n");
return -RIG_EINVAL; // FIXME: sending proper error?
}
@ -2516,7 +2516,7 @@ int ts2k_get_channel(RIG * rig, channel_t *chan)
|| vfo == RIG_VFO_MEM_C ) ) {
}
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": restoring mem=%i\n", curr_mem);
rig_debug(RIG_DEBUG_ERR, __func__": restoring mem=%i\n", curr_mem);
retval = ts2k_set_mem(rig, curr_vfo, curr_mem);
CHKERR(retval);
#endif
@ -2752,7 +2752,7 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
int retval;
vfo_t v;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": starting...\n");
rig_debug(RIG_DEBUG_ERR, __func__": starting...\n");
if(vfo==RIG_VFO_CURR) {
retval = ts2k_get_vfo(rig, &v);
@ -2764,7 +2764,7 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
retval = ts2k_scan_off(rig);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": got VFO = %x\n", v);
rig_debug(RIG_DEBUG_ERR, __func__": got VFO = %x\n", v);
// set proper vfo first (already done?)
switch(v) {
case RIG_VFO_MEM: // Currently selected Main/Sub
@ -2783,11 +2783,11 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
case RIG_VFO_CALL_A: //
case RIG_VFO_CALL_C:
default:
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": vfo 'defaulted'\n");
rig_debug(RIG_DEBUG_ERR, __func__": vfo 'defaulted'\n");
return -RIG_ENIMPL; // unimplemented, but valid scan
}
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": VFO set!\n");
rig_debug(RIG_DEBUG_ERR, __func__": VFO set!\n");
retval = ts2k_scan_off(rig);
CHKERR(retval);
@ -2814,7 +2814,7 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
case RIG_SCAN_PRIO:
/* nobreak */
default:
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": scan 'defaulted'\n");
rig_debug(RIG_DEBUG_ERR, __func__": scan 'defaulted'\n");
return -RIG_ENIMPL; // unimplemented, but valid scan
}
}
@ -2824,12 +2824,12 @@ int ts2k_scan_on(RIG *rig, char sc)
char cmd[]="sc0;", ack[10];
int retval, cmdlen, acklen, i;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": turning scan on\n");
rig_debug(RIG_DEBUG_ERR, __func__": turning scan on\n");
cmd[2] = sc;
retval = ts2k_transaction(rig, cmd, 4, NULL, NULL);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": turned scan on\n");
rig_debug(RIG_DEBUG_ERR, __func__": turned scan on\n");
// force reply when turning scan on
if(sc != '0') {
cmd[2] = ';'; cmd[3] = '\0';
@ -2845,7 +2845,7 @@ int ts2k_scan_on(RIG *rig, char sc)
int ts2k_scan_off(RIG *rig)
{
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": turning scan off\n");
rig_debug(RIG_DEBUG_ERR, __func__": turning scan off\n");
return ts2k_scan_on(rig, '0');
}
@ -2897,8 +2897,8 @@ int ts2k_set_parm(RIG *rig, setting_t parm, value_t val)
char cmd[30];
int retval, cmdlen, i;
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": val.i = %u\n", val.i);
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": val.f = %f\n", val.f);
rig_debug(RIG_DEBUG_ERR, __func__": val.i = %u\n", val.i);
rig_debug(RIG_DEBUG_ERR, __func__": val.f = %f\n", val.f);
switch( parm ) {
case RIG_PARM_APO:

2
kenwood/ts2k_menu.c
Wyświetl plik

@ -99,7 +99,7 @@ int ts2k_menu_init(RIG *rig, ts2k_menu_t *menu[])
ts2k_menu_t *m, *mref;
if(menu == NULL || menu == ts2k_menus) {
rig_debug(rig, __FUNCTION__": invalid menu pointer\n");
rig_debug(rig, __func__": invalid menu pointer\n");
return -RIG_EINVAL;
}

8
kenwood/ts570.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TS570 description
* Copyright (c) 2001-2005 by Stephane Fillod
*
* $Id: ts570.c,v 1.41 2009-02-03 22:56:06 azummo Exp $
* $Id: ts570.c,v 1.42 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -144,7 +144,7 @@ static char mode_to_char(rmode_t mode)
case RIG_MODE_RTTY: return(MD_FSK);
case RIG_MODE_RTTYR: return(MD_FSKR);
default:
rig_debug(RIG_DEBUG_WARN,"ts570_mode_to_char %s: unsupported mode %d\n", __FUNCTION__,mode);
rig_debug(RIG_DEBUG_WARN,"ts570_mode_to_char %s: unsupported mode %d\n", __func__,mode);
}
return(RIG_MODE_NONE);
}
@ -364,7 +364,7 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
if (4 != ack_len) {
rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer len=%d\n",
__FUNCTION__, ack_len);
__func__, ack_len);
return -RIG_ERJCTED;
}
@ -376,7 +376,7 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
if (rig->state.preamp[i] == 0) {
rig_debug(RIG_DEBUG_ERR,"%s: "
"unexpected att level %d\n",
__FUNCTION__, levelint);
__func__, levelint);
return -RIG_EPROTO;
}
if (i != levelint)

4
kenwood/ts850.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TS850 description
* Copyright (c) 2000-2004 by Stephane Fillod
*
* $Id: ts850.c,v 1.30 2009-02-03 22:56:06 azummo Exp $
* $Id: ts850.c,v 1.31 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -300,7 +300,7 @@ static char mode_to_char(rmode_t mode)
case RIG_MODE_RTTY: return(MD_FSK);
case RIG_MODE_RTTYR: return(MD_FSKR);
default:
rig_debug(RIG_DEBUG_WARN,"%s: unsupported mode %d\n", __FUNCTION__,mode);
rig_debug(RIG_DEBUG_WARN,"%s: unsupported mode %d\n", __func__,mode);
}
return(RIG_MODE_NONE);
}

14
kenwood/ts870s.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Kenwood backend - TS870S description
* Copyright (c) 2000-2008 by Stephane Fillod
*
* $Id: ts870s.c,v 1.53 2009-02-03 22:56:07 azummo Exp $
* $Id: ts870s.c,v 1.54 2009-02-03 23:22:58 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -75,7 +75,7 @@ static int ts870s_get_vfo(RIG *rig, vfo_t *vfo)
if (vfo_len != 4 || vfobuf[1] != 'R') {
rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer %s, "
"len=%d\n",__FUNCTION__,vfobuf, vfo_len);
"len=%d\n",__func__,vfobuf, vfo_len);
return -RIG_ERJCTED;
}
@ -86,7 +86,7 @@ static int ts870s_get_vfo(RIG *rig, vfo_t *vfo)
case '2': *vfo = RIG_VFO_MEM; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %c\n",
__FUNCTION__,vfobuf[2]);
__func__,vfobuf[2]);
return -RIG_EPROTO;
}
return RIG_OK;
@ -106,7 +106,7 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
if (buf_len != 4 || buf[1] != 'D')
{
rig_debug(RIG_DEBUG_ERR,"%s: unexpected MD answer, len=%d\n",
__FUNCTION__,buf_len);
__func__,buf_len);
return -RIG_ERJCTED;
}
@ -123,7 +123,7 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
case MD_NONE: *mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__,buf[2]);
__func__,buf[2]);
return -RIG_EINVAL;
}
@ -135,7 +135,7 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
if (buf_len != 7 || buf[1] != 'W')
{
rig_debug(RIG_DEBUG_ERR,"%s: unexpected FW answer, len=%d\n",
__FUNCTION__,buf_len);
__func__,buf_len);
return -RIG_ERJCTED;
}
@ -161,7 +161,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_RTTYR: kmode = MD_FSKR; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__FUNCTION__,mode);
__func__,mode);
return -RIG_EINVAL;
}