Hamlib/kenwood/ts570.c

/*
 *  Hamlib Kenwood backend - TS570 description
 *  Copyright (c) 2001-2005 by Stephane Fillod
 *
 *	$Id: ts570.c,v 1.35 2008-02-13 21:28:52 fillods 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
 *   published by the Free Software Foundation; either version 2 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Library General Public License for more details.
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <hamlib/rig.h>
#include "kenwood.h"
#include "ic10.h"


#define TS570_ALL_MODES (RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY)
#define TS570_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY)
#define TS570_AM_TX_MODES RIG_MODE_AM

#define TS570_FUNC_ALL (RIG_FUNC_FAGC|RIG_FUNC_TSQL|RIG_FUNC_TONE|RIG_FUNC_NB|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_LOCK|RIG_FUNC_BC|RIG_FUNC_TUNER)

#define TS570_LEVEL_ALL (RIG_LEVEL_PREAMP|RIG_LEVEL_ATT|RIG_LEVEL_AGC|RIG_LEVEL_SQL|RIG_LEVEL_STRENGTH|RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_RFPOWER|RIG_LEVEL_MICGAIN|RIG_LEVEL_SLOPE_LOW|RIG_LEVEL_SLOPE_HIGH)

#define TS570_VFO (RIG_VFO_A|RIG_VFO_B)
#define TS570_VFO_OP (RIG_OP_UP|RIG_OP_DOWN)
#define TS570_SCAN_OPS (RIG_SCAN_VFO)
#define TS570_ANTS (RIG_ANT_1|RIG_ANT_2)


/*
 * modes in use by the "MD" command
 */
#define MD_NONE	'0'
#define MD_LSB	'1'
#define MD_USB	'2'
#define MD_CW	'3'
#define MD_FM	'4'
#define MD_AM	'5'
#define MD_FSK	'6'
#define MD_CWR	'7'
#define MD_FSKR	'9'

static const struct kenwood_priv_caps  ts570_priv_caps  = {
		.cmdtrm =  EOM_KEN,
};


static rmode_t char_to_mode(char c)
{
        switch (c) {
            case MD_CW:     return(RIG_MODE_CW);
            case MD_CWR:    return(RIG_MODE_CWR);
            case MD_USB:    return(RIG_MODE_USB);
            case MD_LSB:    return(RIG_MODE_LSB);
            case MD_FM:     return(RIG_MODE_FM);
            case MD_AM:     return(RIG_MODE_AM);
            case MD_FSK:    return(RIG_MODE_RTTY);
            case MD_FSKR:   return(RIG_MODE_RTTYR);
            case MD_NONE:   return(RIG_MODE_NONE);
	}
        return(RIG_MODE_NONE);
}

static int ts570_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
  char buf[50];
  size_t buf_len;
  int retval;


  buf_len = 50;
  retval = kenwood_transaction (rig, "MD;", 3, buf, &buf_len);
  if (retval != RIG_OK)
    return retval;

  if (buf_len != 4 || buf[1] != 'D')
  {
    rig_debug(RIG_DEBUG_ERR,"ts570_get_mode: unexpected MD answer, len=%d\n",
      buf_len);
    return -RIG_ERJCTED;
  }

  switch (buf[2]) 
  {
    case MD_CW:         *mode = RIG_MODE_CW; break;
    case MD_CWR:	*mode = RIG_MODE_CWR; break;
    case MD_USB:	*mode = RIG_MODE_USB; break;
    case MD_LSB:	*mode = RIG_MODE_LSB; break;
    case MD_FM:	        *mode = RIG_MODE_FM; break;
    case MD_AM:	        *mode = RIG_MODE_AM; break;
    case MD_FSK:	*mode = RIG_MODE_RTTY; break;
    case MD_FSKR:	*mode = RIG_MODE_RTTYR; break;
    case MD_NONE:	*mode = RIG_MODE_NONE; break;
    default:
      rig_debug(RIG_DEBUG_ERR,"ts570_get_mode: "
        "unsupported mode '%c'\n", buf[2]);
      return -RIG_EINVAL;
  }

/* 
 * Use FW (Filter Width) for CW and RTTY, 
 * SL (dsp Slope Low cut-off)  for all the other modes.
 * This is how it works on the TS870S, which does not have SL/SH commands.
 * TODO: combine SL and SH to set/read bandwidth....
 */
  switch (*mode) 
  {
    case RIG_MODE_CW:
    case RIG_MODE_CWR:
    case RIG_MODE_RTTY:
    case RIG_MODE_RTTYR:
      buf_len = 50;
      retval = kenwood_transaction (rig, "FW;", 3, buf, &buf_len);
      if (retval != RIG_OK) return retval;
      if (buf_len != 7 || buf[1] != 'W')
      {
        rig_debug(RIG_DEBUG_ERR,
          "ts570_get_mode: unexpected FW answer, len=%d\n", buf_len);
        return -RIG_ERJCTED;
      }
      *width = atoi(&buf[2]);
      break;
    case RIG_MODE_USB:
    case RIG_MODE_LSB:
    case RIG_MODE_FM:
    case RIG_MODE_AM:
      buf_len = 50;
      retval = kenwood_transaction (rig, "SL;", 3, buf, &buf_len);
      if (retval != RIG_OK) return retval;
      if (buf_len != 5 || buf[1] != 'L')
      {
        rig_debug(RIG_DEBUG_ERR,
          "ts570_get_mode: unexpected SL answer, len=%d\n", buf_len);
        return -RIG_ERJCTED;
      }
      *width = 50 * atoi(&buf[2]);
      break;
    default:
      return -RIG_EINVAL;
  }

  return RIG_OK;
}

static char mode_to_char(rmode_t mode)
{
      switch (mode) {
         case RIG_MODE_CW:       return(MD_CW);
         case RIG_MODE_CWR:      return(MD_CWR);
         case RIG_MODE_USB:      return(MD_USB);
         case RIG_MODE_LSB:      return(MD_LSB);
         case RIG_MODE_FM:       return(MD_FM);
         case RIG_MODE_AM:       return(MD_AM);
         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);
     }
 return(RIG_MODE_NONE);
}

static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
  char buf[16],ackbuf[16];
  int buf_len, kmode, retval;
  size_t ack_len;

  if ((kmode = mode_to_char(mode)) == RIG_MODE_NONE)
     return -RIG_EINVAL;

  buf_len = sprintf(buf, "MD%c;", kmode);
  ack_len = 0;
  retval = kenwood_transaction (rig, buf, buf_len, ackbuf, &ack_len);
  if (retval != RIG_OK) return retval;

  ack_len = 0;
  switch (mode) 
  {
    case RIG_MODE_CW:
    case RIG_MODE_CWR:
    case RIG_MODE_RTTY:
    case RIG_MODE_RTTYR:
      buf_len = sprintf(buf, "FW%04d;", (int)width);
      retval = kenwood_transaction (rig, buf, buf_len, ackbuf, &ack_len);
      if (retval != RIG_OK) return retval;
      break;
    case RIG_MODE_USB:
    case RIG_MODE_LSB:
    case RIG_MODE_FM:
    case RIG_MODE_AM:
      buf_len = sprintf(buf, "SL%02d;", (int)width/50);
      retval = kenwood_transaction (rig, buf, buf_len, ackbuf, &ack_len);
      if (retval != RIG_OK) return retval;
      break;
    default:
      return -RIG_EINVAL;
  }

  return RIG_OK;
}

/*
 * ts570_set_ant
 * Assumes rig!-NULL, ptt!=NULL
 */
static int ts570_set_ant(RIG *rig, vfo_t vfo, ant_t ant)
{
	char buf[6], ackbuf[16];
	int len, retval;
	size_t ack_len;

	len = sprintf(buf,"AN%c;", ant==RIG_ANT_1?'1':'2');
	ack_len = 0;
	retval = kenwood_transaction(rig, buf, len, ackbuf, &ack_len);

	return retval;
}


/*
 * ts570_get_ant
 * Assumes rig!=NULL, ptt!=NULL
 */
static int ts570_get_ant(RIG *rig, vfo_t vfo, ant_t *ant)
{
	char infobuf[50];
	int retval;
	size_t info_len;

	info_len = 50;
	retval = kenwood_transaction (rig, "AN;", 3, infobuf, &info_len);
	if (retval != RIG_OK)
		return retval;

	if (info_len < 4 || infobuf[0] != 'A' || infobuf[1] != 'N') {
		rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
				__FUNCTION__,info_len);
		return -RIG_ERJCTED;
	}

	*ant = infobuf[2] == '1' ? RIG_ANT_1 : RIG_ANT_2;

	return RIG_OK;
}

/*
 * extends kenwood_set_func
 * Assumes rig!=NULL, val!=NULL
 */
int ts570_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
		char fctbuf[16], ackbuf[16];
		int fct_len;
		size_t ack_len;

		/* Filter unimplemented RIG_FUNC_TUNER and allow settings 0..2 for 
		 * RIG_FUNC_NR.
		 * Send all other requests to kenwood_set_func()
		 */
		ack_len = 0;
		switch (func) {

		case RIG_FUNC_NR:
			if ((status < 0) || (status >2))
				return -RIG_EINVAL;
			fct_len = sprintf(fctbuf,"NR%01d;", status);
			return kenwood_transaction (rig, fctbuf, fct_len, ackbuf, &ack_len);
		case RIG_FUNC_TUNER:
			fct_len = sprintf(fctbuf,"AC %c0;", (0==status)?'0':'1');
 			return kenwood_transaction (rig, fctbuf, fct_len, ackbuf, &ack_len);
		
		default:
			return kenwood_set_func(rig, vfo, func, status);
		}

		return RIG_OK;
}


/*
 * extends kenwood_get_func
 * Assumes rig!=NULL, val!=NULL
 */
int ts570_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
		char fctbuf[50];
		size_t fct_len;
		int retval;

		fct_len = 50;
		/* filter unimplemented RIG_FUNC_TUNER  
		 * and send all other requests to kenwood_get_func()
		 */
		switch (func) {
		case RIG_FUNC_NR:
			retval = kenwood_transaction (rig, "NR;", 3, fctbuf, &fct_len);
			if (retval != RIG_OK)
				return retval;

			if (fct_len != 4) {
				rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: " 
					"wrong answer len=%d\n", fct_len);
				return -RIG_ERJCTED;
			}
			
			*status = atoi(&fctbuf[2]);
			break;

		case RIG_FUNC_TUNER:
			retval = kenwood_transaction (rig, "AC;", 3, fctbuf, &fct_len);
			if (retval != RIG_OK)
				return retval;

			if (fct_len != 6) {
				rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: " 
					"wrong answer len=%d\n", fct_len);
				return -RIG_ERJCTED;
			}

			*status = fctbuf[3] == '0' ? 0 : 1;
			break;

		default:
			return kenwood_get_func(rig, vfo, func, status);
		}

		return RIG_OK;
}

/*
 * ts570_set_level
 * Assumes rig!=NULL
 *
 * set levels of most functions
 */
int
ts570_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
{
  char levelbuf[16], ackbuf[16];
  int level_len;
  size_t ack_len;
  int kenwood_val;
  int i;

  ack_len = 0;			/* no answer for set functions */

  switch (level)
    {
    case RIG_LEVEL_PREAMP:
        kenwood_val = val.i;
	/* set the preamplifier if a correct value is entered */
	if (kenwood_val == 0)
		level_len = sprintf(levelbuf, "PA0;");
	else
	for (i=0; i<MAXDBLSTSIZ; i++)
	    if (kenwood_val == rig->state.preamp[i])
	    {
		level_len = sprintf(levelbuf, "PA%01d;", i+1);
		break;  /* found - stop searching */
	    }
	    else
	    	return -RIG_EINVAL;
        return kenwood_transaction (rig, levelbuf, level_len, ackbuf, &ack_len);

    case RIG_LEVEL_RFPOWER:
      /* level for TS570D is from 0.. 100W in SSB and CW */
      kenwood_val = val.f * 100;	
      level_len = sprintf (levelbuf, "PC%03d;", kenwood_val);
      return kenwood_transaction (rig, levelbuf, level_len, ackbuf, &ack_len);
      
    case RIG_LEVEL_MICGAIN:
      /* level is from 0..100 */
      kenwood_val = val.f * 100;
      level_len = sprintf (levelbuf, "MG%03d;", kenwood_val);
      return kenwood_transaction (rig, levelbuf, level_len, ackbuf, &ack_len);

    default:
      return kenwood_set_level (rig, vfo, level, val);
    }
  
  return RIG_OK;		/* never reached */
}


/*
 * ts570_get_level
 * Assumes rig!=NULL, val!=NULL
 */
int
ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
{
  char ackbuf[50];
  size_t ack_len = 50;
  int levelint;
  int retval;
  int i;

  switch (level)
    {
    case RIG_LEVEL_RFPOWER:
      /* ts570d returns 5..100 measured in watt */
      retval = kenwood_transaction (rig, "PC;", 3, ackbuf, &ack_len);
      if (RIG_OK != retval)
	return retval;
      if (6 != ack_len)
	return -RIG_EPROTO;
      if (1 != sscanf (&ackbuf[2], "%d", &levelint))
	return -RIG_EPROTO;
      val->f = (float) levelint / 100.;
      return RIG_OK;

    case RIG_LEVEL_MICGAIN:
      /* reads from 0..100 */
      retval = kenwood_transaction (rig, "MG;", 3, ackbuf, &ack_len);
      if (RIG_OK != retval)
        return retval;
      if (6 != ack_len)
        return -RIG_EPROTO;
      if (1 != sscanf (&ackbuf[2], "%d", &levelint))
	return -RIG_EPROTO;
      val->f = (float) levelint / 100.;
      return RIG_OK;

    case RIG_LEVEL_PREAMP:
	retval = kenwood_transaction (rig, "PA;", 3, ackbuf, &ack_len);
	if (retval != RIG_OK)
	    return retval;

	if (4  != ack_len) {
	    rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer len=%d\n",
			__FUNCTION__, ack_len);
	    return -RIG_ERJCTED;
	}

	sscanf(ackbuf+2, "%d", &levelint);
	if (levelint == 0) {
	    val->i = 0;
	} else {
	    for (i=0; i<levelint && i<MAXDBLSTSIZ; i++)
		if (rig->state.preamp[i] == 0) {
		    rig_debug(RIG_DEBUG_ERR,"%s: "
			    "unexpected att level %d\n",
			    __FUNCTION__, levelint);
		    return -RIG_EPROTO;
		}
		if (i != levelint)
		    return -RIG_EINTERNAL;
		val->i = rig->state.preamp[i-1];
	}
	break;
    default:
 	return kenwood_get_level (rig, vfo, level, val);
    }
  
  return RIG_OK;		/* never reached */
}

/*
 * ts570_get_split_vfo
 */
int ts570_get_split_vfo(RIG * rig, vfo_t vfo, split_t * split, vfo_t * tx_vfo)
{
	char ack[10];
	size_t acklen = 10;
	char ack2[10];
	size_t ack2len = 10;
	int retval;

	retval = kenwood_transaction(rig, "FR;", 3, ack, &acklen);
	if (retval != RIG_OK)  
		return retval;


	retval = kenwood_transaction(rig, "FT;", 3, ack2, &ack2len);
	if (retval != RIG_OK)  
		return retval;

	if (ack[2] != ack2[2]) {
		*split = RIG_SPLIT_ON;
		switch (ack2[2]) {
		case '0': *tx_vfo = RIG_VFO_A; break;
		case '1': *tx_vfo = RIG_VFO_B; break;
		case '2': *tx_vfo = RIG_VFO_MEM; break;
		default: rig_debug(RIG_DEBUG_ERR, "ts570_get_split_vfo: unknown tx vfo: %d\n", ack2[2]);
			return -RIG_EINVAL;
		}

	} else {
		*split = RIG_SPLIT_OFF;
		*tx_vfo = RIG_VFO_CURR;
	}

	return RIG_OK;
}

#define cmd_trm(rig) ((struct kenwood_priv_caps *)(rig)->caps->priv)->cmdtrm

/*
 * ts570_set_split_vfo
 */
int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{
	char cmdbuf[16], ackbuf[20];
	int cmd_len, retval;
	size_t ack_len;
	unsigned char vfo_function;

	if(vfo !=RIG_VFO_CURR) {
		switch (vfo) {
		case RIG_VFO_VFO:
		case RIG_VFO_A: vfo_function = '0'; break;
		case RIG_VFO_B: vfo_function = '1'; break;
		case RIG_VFO_MEM: vfo_function = '2'; break;
		default: 
			rig_debug(RIG_DEBUG_ERR,"ts570_set_split_vfo: unsupported VFO %d\n",
							vfo);
			return -RIG_EINVAL;
		}
		/* set RX VFO */
		cmd_len = sprintf(cmdbuf, "FR%c%s", vfo_function, cmd_trm(rig));
		retval = kenwood_transaction (rig, cmdbuf, cmd_len, NULL, 0);
		if (retval != RIG_OK)
			return retval;
	}

	if(split==RIG_SPLIT_ON) {
		switch (txvfo) {
		case RIG_VFO_VFO:
		case RIG_VFO_A: vfo_function = '0'; break;
		case RIG_VFO_B: vfo_function = '1'; break;
		case RIG_VFO_MEM: vfo_function = '2'; break;
		default: 
			rig_debug(RIG_DEBUG_ERR,"ts570_set_split_vfo: unsupported VFO %d\n", txvfo);
			return -RIG_EINVAL;
		} 
		/* set TX VFO */
		cmd_len = sprintf(cmdbuf, "FT%c%s", vfo_function, cmd_trm(rig));
		retval = kenwood_transaction (rig, cmdbuf, cmd_len, NULL, 0);
		if (retval != RIG_OK)
			return retval;

	} else /* RIG_SPLIT_OFF */
		if(vfo==RIG_VFO_CURR) {
	  		/* switch to current RX VFO */
			/* first ask for it */
			ack_len = 10;
			retval = kenwood_transaction(rig, "FR;", 3, ackbuf, &ack_len);
			if (retval != RIG_OK)  
				return retval;
			/* and then set it to both vfo's */
			vfo_function = ackbuf[2];
			cmd_len = sprintf(cmdbuf, "FT%c%s", vfo_function, cmd_trm(rig));
			retval = kenwood_transaction(rig, cmdbuf, cmd_len, NULL, 0);
			if (retval != RIG_OK)
				return retval;
		}

	return RIG_OK;
}



/* memory capabilities */
#define TS570_MEM_CAP {		\
	.freq = 1,		\
	.mode = 1,		\
	.tx_freq=1,		\
	.tx_mode=1,		\
	.split=1,		\
	.ctcss_tone=1		\
}

/* 
 * read memory channel
 * Assumes: rig != NULL, chan != NULL
 * 
 * !!! memory channel remembers additional settings for antenna, attenuator and
 * !!! preamplifier and ctcss squelch. NOT SUPPORTED YET!
 */
int ts570_get_channel (RIG * rig, channel_t * chan)
{
                char cmdbuf[16], membuf[50];
                int retval, cmd_len, num;
		size_t mem_len;

		/* 
		 * first check if we shall get a memory or vfo channel
		 */
		if (chan->vfo != RIG_VFO_MEM) {
			/*
			 * At the time only memory channels are supported. 
			 */
			rig_debug(RIG_DEBUG_ERR,"kenwood_get_chan: " 
					"ts570_get_channel not implemented"
					" for VFO channels.\n");
			return -RIG_ENIMPL;
		}

		num=chan->channel_num;

                cmd_len = sprintf(cmdbuf, "MR0 %02d;", num);
                mem_len = 50;
                retval = kenwood_transaction (rig, cmdbuf, cmd_len, membuf, &mem_len);
                if (retval != RIG_OK)
                                return retval;

		memset(chan,0,sizeof(channel_t));
		chan->channel_num=num;
		

		if (membuf[19]=='0')
			chan->ctcss_tone=0;
		else {
			membuf[22]='\0';
			chan->ctcss_tone= rig->caps->ctcss_list[atoi(&membuf[20])-1];
		}

		chan->mode=char_to_mode(membuf[17]);

		membuf[17]='\0';
		chan->freq=atoi(&membuf[6]);

		/* See if channel is in use */
		if (chan->freq == RIG_FREQ_NONE)
			return -RIG_ENAVAIL;

		/* Manual says that we can read the scanning stop frequency
		 * for channel 90..99 by the following command.
		 * That seems not to be true. It returns the same information 
		 * as MR0.
		 * So we use it here only for getting the split info for
		 * channels 00..89.
		 */
                cmd_len = sprintf(cmdbuf, "MR1 %02d;", num);
                mem_len = 50;
                retval = kenwood_transaction (rig, cmdbuf, cmd_len, membuf, &mem_len);
                if (retval != RIG_OK)
                                return retval;

		chan->tx_mode=char_to_mode(membuf[17]);
		membuf[17]='\0';
		chan->tx_freq=atoi(&membuf[6]);

		if(chan->freq==chan->tx_freq &&
		   chan->mode==chan->tx_mode) {
			chan->tx_freq=RIG_FREQ_NONE;
			chan->tx_mode=RIG_MODE_NONE;
			chan->split=RIG_SPLIT_OFF;
		} else
		        chan->split=RIG_SPLIT_ON;

		return RIG_OK;
}


int ts570_set_channel (RIG * rig, const channel_t * chan)
{
                char cmdbuf[30], membuf[30];
                int retval, cmd_len;
		size_t mem_len;
		int num,freq,tx_freq,tone;
		char mode,tx_mode,split,tones;

		num=chan->channel_num;
		freq=(int)chan->freq;
		mode=mode_to_char(chan->mode);
		if(chan->split==RIG_SPLIT_ON) {
			tx_freq=(int)chan->tx_freq;
			tx_mode=mode_to_char(chan->tx_mode);
			split='1';
		} else {
			tx_freq=0;
			tx_mode='\0';
			split='0';
		}

        	for (tone = 1; rig->caps->ctcss_list[tone-1] != 0 && tone<39; tone++) {
                        if (rig->caps->ctcss_list[tone-1] == chan->ctcss_tone)
                                        break;
        	}
		if(chan->ctcss_tone!=0) {
			tones='1';
		} else {
			tones='0';
			tone=0;
		}

                cmd_len = sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ;",
		 num,freq,mode,tones,tone);
                mem_len = 0;
                retval = kenwood_transaction (rig, cmdbuf, cmd_len, membuf, &mem_len);
                if (retval != RIG_OK)
                                return retval;

                cmd_len = sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ;",
		 num,tx_freq,tx_mode,tones,tone);
                mem_len = 0;
                retval = kenwood_transaction (rig, cmdbuf, cmd_len, membuf, &mem_len);
                if (retval != RIG_OK)
                                return retval;

		return RIG_OK;
}

int ts570_get_rit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
{
	char infobuf[50];
	int retval;
	size_t info_len;

	info_len = 50;
	retval = kenwood_transaction (rig, "IF;", 3, infobuf, &info_len);
	if (retval != RIG_OK)
		return retval;

	if (info_len != 38 || infobuf[1] != 'F') {
	rig_debug(RIG_DEBUG_ERR,"kenwood_get_rit: wrong answer len=%d\n",
					info_len);
	return -RIG_ERJCTED;
	}

	if (infobuf[23] == '0') {	/* RIT off? */
		*rit = 0;
	} else {
		infobuf[23] = '\0';
		*rit = atoi(&infobuf[18]);
	}
	return RIG_OK;
}


int ts570_get_xit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
{
	char infobuf[50];
	int retval;
	size_t info_len;

	info_len = 50;
	retval = kenwood_transaction (rig, "IF;", 3, infobuf, &info_len);
	if (retval != RIG_OK)
		return retval;

	if (info_len != 38 || infobuf[1] != 'F') {
	rig_debug(RIG_DEBUG_ERR,"kenwood_get_rit: wrong answer len=%d\n",
					info_len);
	return -RIG_ERJCTED;
	}

	if (infobuf[24] == '0') {	/* RIT off? */
		*rit = 0;
	} else {
		infobuf[23] = '\0';
		*rit = atoi(&infobuf[18]);
	}
	return RIG_OK;
}

int ts570_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
        char buf[50], infobuf[50];
	unsigned char c;
        int retval, len, i;
	size_t info_len;

        info_len = 0;
        if (rit == 0) {
        	kenwood_transaction(rig, "RT0;", 4, infobuf, &info_len);
		return RIG_OK;
	} else
        	kenwood_transaction(rig, "RT1;", 4, infobuf, &info_len);

        if (rit > 0)
                c = 'U';
        else
                c = 'D';
        len = sprintf(buf, "R%c;", c);

        info_len = 0;
        retval = kenwood_transaction(rig, "RC;", 3, infobuf, &info_len);
        for (i = 0; i < abs(rint(rit/10)); i++)
        {
                info_len = 0;
                retval = kenwood_transaction(rig, buf, len, infobuf, &info_len);
        }

        return RIG_OK;
}

int ts570_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
        char buf[50], infobuf[50];
	unsigned char c;
        int retval, len, i;
	size_t info_len;

        info_len = 0;
        if (rit == 0) {
        	kenwood_transaction(rig, "XT0;", 4, infobuf, &info_len);
		return RIG_OK;
	} else
        	kenwood_transaction(rig, "XT1;", 4, infobuf, &info_len);

        if (rit > 0)
                c = 'U';
        else
                c = 'D';
        len = sprintf(buf, "R%c;", c);

        info_len = 0;
        retval = kenwood_transaction(rig, "RC;", 3, infobuf, &info_len);
        for (i = 0; i < abs(rint(rit/10)); i++)
        {
                info_len = 0;
                retval = kenwood_transaction(rig, buf, len, infobuf, &info_len);
        }

        return RIG_OK;
}



/*
 * ts570 rig capabilities.
 * Notice that some rigs share the same functions.
 * Also this struct is READONLY!
 * RIT: Variable Range <EFBFBD>9.99 kHz
 *
 * part of infos comes from .http = //www.kenwood.net/
 */
const struct rig_caps ts570s_caps = {
.rig_model =  RIG_MODEL_TS570S,
.model_name = "TS-570S",
.mfg_name =  "Kenwood",
.version =  BACKEND_VER ".1",
.copyright =  "LGPL",
.status =  RIG_STATUS_STABLE,
.rig_type =  RIG_TYPE_TRANSCEIVER,
.ptt_type =  RIG_PTT_RIG,
.dcd_type =  RIG_DCD_RIG,
.port_type =  RIG_PORT_SERIAL,
.serial_rate_min =  1200,
.serial_rate_max =  57600,
.serial_data_bits =  8,
.serial_stop_bits =  1,
.serial_parity =  RIG_PARITY_NONE,
.serial_handshake =  RIG_HANDSHAKE_NONE,
.write_delay =  0,
.post_write_delay =  30,
.timeout = 1000,
.retry =  3,

.has_get_func =  TS570_FUNC_ALL,
.has_set_func =  TS570_FUNC_ALL,
.has_get_level =  TS570_LEVEL_ALL,
.has_set_level =  RIG_LEVEL_SET(TS570_LEVEL_ALL),
.has_get_parm =  RIG_PARM_NONE,
.has_set_parm =  RIG_PARM_NONE,    /* FIXME: parms */
.level_gran =  {},                 /* FIXME: granularity */
.parm_gran =  {},
.ctcss_list =  kenwood38_ctcss_list,
.dcs_list =  NULL,
.preamp =   { 12, RIG_DBLST_END, },
.attenuator =   { 18, RIG_DBLST_END, },
.max_rit =  Hz(9990),
.max_xit =  Hz(9990),
.max_ifshift =  Hz(0),
.vfo_ops =  TS570_VFO_OP,
.scan_ops =  TS570_SCAN_OPS,
.targetable_vfo =  RIG_TARGETABLE_FREQ,
.transceive =  RIG_TRN_RIG,
.bank_qty =   0,
.chan_desc_sz =  0,


.chan_list =  {
			{  0, 89, RIG_MTYPE_MEM,  TS570_MEM_CAP },
			{ 90, 99, RIG_MTYPE_EDGE, TS570_MEM_CAP },
		  	RIG_CHAN_END,
		   },
.rx_range_list1 =  { 
	{kHz(500),MHz(60),TS570_ALL_MODES,-1,-1,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* rx range */
.tx_range_list1 =  {
    {kHz(1810),kHz(1850)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},	/* 100W class */
    {kHz(1800),MHz(2)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},		/* 25W class */
    {kHz(3500),kHz(3800)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(3500),kHz(3800)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7100),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7100),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(50),MHz(54),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(50),MHz(54),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* tx range */

.rx_range_list2 =  {
	{kHz(500),MHz(60),TS570_ALL_MODES,-1,-1,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* rx range */
.tx_range_list2 =  {
    {kHz(1800),MHz(2)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},	/* 100W class */
    {kHz(1800),MHz(2)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},		/* 25W class */
    {kHz(3500),MHz(4)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(3500),MHz(4)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7300),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7300),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(50),MHz(54),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(50),MHz(54),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* tx range */
.tuning_steps =  {
	 {TS570_ALL_MODES,50},
	 {TS570_ALL_MODES,100},
	 {TS570_ALL_MODES,kHz(1)},
	 {TS570_ALL_MODES,kHz(5)},
	 {TS570_ALL_MODES,kHz(9)},
	 {TS570_ALL_MODES,kHz(10)},
	 {TS570_ALL_MODES,12500},
	 {TS570_ALL_MODES,kHz(20)},
	 {TS570_ALL_MODES,kHz(25)},
	 {TS570_ALL_MODES,kHz(100)},
	 {TS570_ALL_MODES,MHz(1)},
	 {TS570_ALL_MODES,0},	/* any tuning step */
	 RIG_TS_END,
	},
        /* mode/filter list, remember: order matters! */
.filters =  {
		{RIG_MODE_SSB, kHz(2.4)},
		{RIG_MODE_CW, Hz(200)},
		{RIG_MODE_RTTY, Hz(500)},
		{RIG_MODE_AM, kHz(9)},
		{RIG_MODE_FM, kHz(14)},
		RIG_FLT_END,
	},
.priv =  (void *)&ts570_priv_caps,

.set_freq =  kenwood_set_freq,
.get_freq =  ic10_get_freq,
.set_rit =  ts570_set_rit,
.get_rit =  ts570_get_rit,
.set_xit =  ts570_set_xit,
.get_xit =  ts570_get_xit,
.set_mode =  ts570_set_mode,
.get_mode =  ts570_get_mode,
.set_vfo =  kenwood_set_vfo,
.get_vfo =  kenwood_get_vfo,
.set_split_vfo = ts570_set_split_vfo,
.get_split_vfo = ts570_get_split_vfo,
.set_ctcss_tone =  kenwood_set_ctcss_tone,
.get_ctcss_tone =  kenwood_get_ctcss_tone,
.get_ptt =  kenwood_get_ptt,
.set_ptt =  kenwood_set_ptt,
.get_dcd =  kenwood_get_dcd,
.set_func =  ts570_set_func,
.get_func =  ts570_get_func,
.set_ant =  ts570_set_ant,
.get_ant =  ts570_get_ant,
.set_level =  ts570_set_level,
.get_level =  ts570_get_level,
.send_morse =  kenwood_send_morse,
.vfo_op =  kenwood_vfo_op,
.set_mem =  kenwood_set_mem,
.get_mem =  kenwood_get_mem,
.get_channel = ts570_get_channel,
.set_channel = ts570_set_channel,
.set_trn =  kenwood_set_trn,
.get_trn =  kenwood_get_trn,
.set_powerstat =  kenwood_set_powerstat,
.get_powerstat =  kenwood_get_powerstat,
.scan =  kenwood_scan,
.reset =  kenwood_reset,

};

/*
 * ts570d rig capabilities, which is basically the ts570s without 6m.
 * Notice that some rigs share the same functions.
 * Also this struct is READONLY!
 * RIT: Variable Range <EFBFBD>9.99 kHz
 *
 * part of infos comes from .http = //www.kenwood.net/
 */
const struct rig_caps ts570d_caps = {
.rig_model =  RIG_MODEL_TS570D,
.model_name = "TS-570D",
.mfg_name =  "Kenwood",
.version =  BACKEND_VER ".1",
.copyright =  "LGPL",
.status =  RIG_STATUS_STABLE,
.rig_type =  RIG_TYPE_TRANSCEIVER,
.ptt_type =  RIG_PTT_RIG,
.dcd_type =  RIG_DCD_RIG,
.port_type =  RIG_PORT_SERIAL,
.serial_rate_min =  1200,
.serial_rate_max =  57600,
.serial_data_bits =  8,
.serial_stop_bits =  1,
.serial_parity =  RIG_PARITY_NONE,
.serial_handshake =  RIG_HANDSHAKE_NONE,
.write_delay =  0,
.post_write_delay =  30,
.timeout =  1000,
.retry =  3,

.has_get_func =  TS570_FUNC_ALL,
.has_set_func =  TS570_FUNC_ALL,
.has_get_level =  TS570_LEVEL_ALL,
.has_set_level =  RIG_LEVEL_SET(TS570_LEVEL_ALL),
.has_get_parm =  RIG_PARM_NONE,
.has_set_parm =  RIG_PARM_NONE,    /* FIXME: parms */
.level_gran =  {},                 /* FIXME: granularity */
.parm_gran =  {},
.ctcss_list =  kenwood38_ctcss_list,
.dcs_list =  NULL,
.preamp =   { 12, RIG_DBLST_END, },
.attenuator =   { 18, RIG_DBLST_END, },
.max_rit =  Hz(9990),
.max_xit =  Hz(9990),
.max_ifshift =  Hz(0),
.vfo_ops =  TS570_VFO_OP,
.scan_ops =  TS570_SCAN_OPS,
.targetable_vfo =  RIG_TARGETABLE_FREQ,
.transceive =  RIG_TRN_RIG,
.bank_qty =   0,
.chan_desc_sz =  0,

.chan_list =  {
			{  0, 89, RIG_MTYPE_MEM,  TS570_MEM_CAP  },
			{ 90, 99, RIG_MTYPE_EDGE, TS570_MEM_CAP  },
		  	RIG_CHAN_END,
		   },
.rx_range_list1 =  { 
	{kHz(500),MHz(30),TS570_ALL_MODES,-1,-1,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* rx range */
.tx_range_list1 =  {
    {kHz(1810),kHz(1850)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},	/* 100W class */
    {kHz(1800),MHz(2)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},		/* 25W class */
    {kHz(3500),kHz(3800)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(3500),kHz(3800)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7100),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7100),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* tx range */

.rx_range_list2 =  {
	{kHz(500),MHz(30),TS570_ALL_MODES,-1,-1,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* rx range */
.tx_range_list2 =  {
    {kHz(1800),MHz(2)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},	/* 100W class */
    {kHz(1800),MHz(2)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},		/* 25W class */
    {kHz(3500),MHz(4)-1,TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(3500),MHz(4)-1,TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7300),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(7),kHz(7300),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(10100),kHz(10150),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(14),kHz(14350),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(18068),kHz(18168),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(21),kHz(21450),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {kHz(24890),kHz(24990),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_OTHER_TX_MODES,5000,100000,TS570_VFO,TS570_ANTS},
    {MHz(28),kHz(29700),TS570_AM_TX_MODES,5000,25000,TS570_VFO,TS570_ANTS},
	RIG_FRNG_END,
  }, /* tx range */
.tuning_steps =  {
	 {TS570_ALL_MODES,50},
	 {TS570_ALL_MODES,100},
	 {TS570_ALL_MODES,kHz(1)},
	 {TS570_ALL_MODES,kHz(5)},
	 {TS570_ALL_MODES,kHz(9)},
	 {TS570_ALL_MODES,kHz(10)},
	 {TS570_ALL_MODES,12500},
	 {TS570_ALL_MODES,kHz(20)},
	 {TS570_ALL_MODES,kHz(25)},
	 {TS570_ALL_MODES,kHz(100)},
	 {TS570_ALL_MODES,MHz(1)},
	 {TS570_ALL_MODES,0},	/* any tuning step */
	 RIG_TS_END,
	},
        /* mode/filter list, remember: order matters! */
.filters =  {
		{RIG_MODE_SSB, Hz(500)},
		{RIG_MODE_SSB, Hz(0)},
		{RIG_MODE_SSB, kHz(1)},
		{RIG_MODE_CW, Hz(400)},
		{RIG_MODE_CW, Hz(100)},
		{RIG_MODE_CW, Hz(1000)},
		{RIG_MODE_RTTY, Hz(1000)},
		{RIG_MODE_RTTY, Hz(500)},
		{RIG_MODE_RTTY, Hz(1500)},
		{RIG_MODE_AM, Hz(500)},
		{RIG_MODE_AM, Hz(0)},
		{RIG_MODE_AM, kHz(1)},
		{RIG_MODE_FM, Hz(500)},
		{RIG_MODE_FM, Hz(0)},
		{RIG_MODE_FM, kHz(1)},
		RIG_FLT_END,
	},
.priv =  (void *)&ts570_priv_caps,

.set_freq =  kenwood_set_freq,
.get_freq =  ic10_get_freq,
.set_rit =  ts570_set_rit,
.get_rit =  ts570_get_rit,
.set_xit =  ts570_set_xit,
.get_xit =  ts570_get_xit,
.set_mode =  ts570_set_mode,
.get_mode =  ts570_get_mode,
.set_vfo =  kenwood_set_vfo,
.get_vfo =  kenwood_get_vfo,
.set_split_vfo = ts570_set_split_vfo,
.get_split_vfo = ts570_get_split_vfo,
.set_ctcss_tone =  kenwood_set_ctcss_tone,
.get_ctcss_tone =  kenwood_get_ctcss_tone,
.get_ptt =  kenwood_get_ptt,
.set_ptt =  kenwood_set_ptt,
.get_dcd =  kenwood_get_dcd,
.set_func =  ts570_set_func,
.get_func =  ts570_get_func,
.set_ant =  ts570_set_ant,
.get_ant =  ts570_get_ant,
.set_level =  ts570_set_level,
.get_level =  ts570_get_level,
.send_morse =  kenwood_send_morse,
.vfo_op =  kenwood_vfo_op,
.set_mem =  kenwood_set_mem,
.get_mem =  kenwood_get_mem,
.get_channel = ts570_get_channel,
.set_channel = ts570_set_channel,
.set_trn =  kenwood_set_trn,
.get_trn =  kenwood_get_trn,
.set_powerstat =  kenwood_set_powerstat,
.get_powerstat =  kenwood_get_powerstat,
.scan =  kenwood_scan,
.reset =  kenwood_reset,

};