diff --git a/kenwood/ic10.c b/kenwood/ic10.c
index 05af5bada..469f75b48 100644
--- a/kenwood/ic10.c
+++ b/kenwood/ic10.c
@@ -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;
 	}
 
diff --git a/kenwood/kenwood.c b/kenwood/kenwood.c
index 9da5602e1..1215e33ef 100644
--- a/kenwood/kenwood.c
+++ b/kenwood/kenwood.c
@@ -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)
diff --git a/kenwood/th.c b/kenwood/th.c
index 717b1b626..f913e55ac 100644
--- a/kenwood/th.c
+++ b/kenwood/th.c
@@ -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;
 	}
 
diff --git a/kenwood/thf7.c b/kenwood/thf7.c
index 6e70a60b3..e6772bb2c 100644
--- a/kenwood/thf7.c
+++ b/kenwood/thf7.c
@@ -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;
      }
 
diff --git a/kenwood/thg71.c b/kenwood/thg71.c
index 47901011e..841b22284 100644
--- a/kenwood/thg71.c
+++ b/kenwood/thg71.c
@@ -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;
diff --git a/kenwood/tmv7.c b/kenwood/tmv7.c
index 351954bcf..4c2fd4a2c 100644
--- a/kenwood/tmv7.c
+++ b/kenwood/tmv7.c
@@ -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;
     }
     
diff --git a/kenwood/ts2000.c b/kenwood/ts2000.c
index d1b7461ac..c38f5bfdf 100644
--- a/kenwood/ts2000.c
+++ b/kenwood/ts2000.c
@@ -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;
 			}
 
diff --git a/kenwood/ts2k.c b/kenwood/ts2k.c
index 976b03374..01831b22a 100644
--- a/kenwood/ts2k.c
+++ b/kenwood/ts2k.c
@@ -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:
diff --git a/kenwood/ts2k_menu.c b/kenwood/ts2k_menu.c
index 761edd9de..49e1e3ed7 100644
--- a/kenwood/ts2k_menu.c
+++ b/kenwood/ts2k_menu.c
@@ -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;
 	}
 
diff --git a/kenwood/ts570.c b/kenwood/ts570.c
index 9a6672e55..ee6f14367 100644
--- a/kenwood/ts570.c
+++ b/kenwood/ts570.c
@@ -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)
diff --git a/kenwood/ts850.c b/kenwood/ts850.c
index f526f30d4..83a1e59b4 100644
--- a/kenwood/ts850.c
+++ b/kenwood/ts850.c
@@ -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);
 }
diff --git a/kenwood/ts870s.c b/kenwood/ts870s.c
index cf0385390..f6901fbc2 100644
--- a/kenwood/ts870s.c
+++ b/kenwood/ts870s.c
@@ -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;
   }