Hamlib/kenwood/kenwood.c

/*
 *  Hamlib Kenwood backend - main file
 *  Copyright (c) 2000-2009 by Stephane Fillod
 *  Copyright (C) 2009 Alessandro Zummo <a.zummo@towertech.it>
 *
 *	$Id: kenwood.c,v 1.114 2009-02-09 20:37:48 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
 *   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 <stdlib.h>
#include <stdio.h>
#include <string.h>  /* String function definitions */
#include <unistd.h>  /* UNIX standard function definitions */
#include <math.h>

#include "hamlib/rig.h"
#include "serial.h"
#include "misc.h"
#include "register.h"
#include "cal.h"

#include "kenwood.h"

struct kenwood_id {
	rig_model_t model;
	int id;
};

struct kenwood_id_string {
	rig_model_t model;
	const char *id;
};

#define UNKNOWN_ID -1

/*
 * Identification number as returned by "ID;"
 * Please, if the model number of your rig is listed as UNKNOWN_ID,
 * send the value to <fillods@users.sourceforge.net> for inclusion. Thanks --SF
 *
 * TODO: sort this list with most frequent rigs first.
 */
static const struct kenwood_id kenwood_id_list[] = {
	{ RIG_MODEL_TS940, 1 },
	{ RIG_MODEL_TS811, 2 },
	{ RIG_MODEL_TS711, 3 },
	{ RIG_MODEL_TS440, 4 },
	{ RIG_MODEL_R5000, 5 },
	{ RIG_MODEL_TS790, 7 },
	{ RIG_MODEL_TS950SDX, 8 },	/* reported as RIG_MODEL_TS950SD originally */
	{ RIG_MODEL_TS850, 9 },
	{ RIG_MODEL_TS450S, 10 },
	{ RIG_MODEL_TS690S, 11 },
	{ RIG_MODEL_TS870S, 15 },
	{ RIG_MODEL_TRC80, 16 },
	{ RIG_MODEL_TS570D, 17 },	/* Elecraft K2 also returns 17 */
	{ RIG_MODEL_TS570S, 18 },
	{ RIG_MODEL_TS2000, 19 },
	{ RIG_MODEL_TS480, 20 },
	{ RIG_MODEL_NONE, UNKNOWN_ID },	/* end marker */
};

/* XXX numeric ids have been tested only with the TS-450 */
static const struct kenwood_id_string kenwood_id_string_list[] = {
	{ RIG_MODEL_TS940, 	"001" },
	{ RIG_MODEL_TS811, 	"002" },
	{ RIG_MODEL_TS711, 	"003" },
	{ RIG_MODEL_TS440, 	"004" },
	{ RIG_MODEL_R5000, 	"005" },
	{ RIG_MODEL_TS790, 	"007" },
	{ RIG_MODEL_TS950SDX,	"008" },	/* reported as RIG_MODEL_TS950SD originally */
	{ RIG_MODEL_TS850,	"009" },
	{ RIG_MODEL_TS450S,	"010" },
	{ RIG_MODEL_TS690S,	"011" },
	{ RIG_MODEL_TS870S,	"015" },
	{ RIG_MODEL_TS570D,	"017" },	/* Elecraft K2 also returns 17 */
	{ RIG_MODEL_TS570S,	"018" },
	{ RIG_MODEL_TS2000,	"019" },
	{ RIG_MODEL_TS480,	"020" },
	{ RIG_MODEL_THD7A,	"TH-D7" },
	{ RIG_MODEL_THD7AG,	"TH-D7G" },
	{ RIG_MODEL_TMD700,	"TM-D700" },
	{ RIG_MODEL_TMV7,	"TM-V7" },
	{ RIG_MODEL_THF6A,	"TH-F6" },
	{ RIG_MODEL_THF7E,	"TH-F7" },
	{ RIG_MODEL_THG71,	"TH-G71" },
	{ RIG_MODEL_NONE,	NULL },	/* end marker */
};

rmode_t kenwood_mode_table[KENWOOD_MODE_TABLE_MAX] = {
	 [0] = RIG_MODE_NONE,
	 [1] = RIG_MODE_LSB,
	 [2] = RIG_MODE_USB,
	 [3] = RIG_MODE_CW,
	 [4] = RIG_MODE_FM,
	 [5] = RIG_MODE_AM,
	 [6] = RIG_MODE_RTTY,
	 [7] = RIG_MODE_CWR,
	 [8] = RIG_MODE_NONE,	/* TUNE mode */
	 [9] = RIG_MODE_RTTYR
};

/*
 * 38 CTCSS sub-audible tones
 */
/* XXX 175000 here ? */
const tone_t kenwood38_ctcss_list[] = {
	 670,  719,  744,  770,  797,  825,  854,  885,  915,  948,
	 974, 1000, 1035, 1072, 1109, 1148, 1188, 1230, 1273, 1318,
	1365, 1413, 1462, 1514, 1567, 1622, 1679, 1738, 1799, 1862,
	1928, 2035, 2107, 2181, 2257, 2336, 2418, 2503, 17500,
	0,
};

/**
 * kenwood_transaction
 * Assumes rig!=NULL rig->state!=NULL rig->caps!=NULL
 *
 * cmdstr - Command to be sent to the rig. Cmdstr can also be NULL, indicating
 *	   that only a reply is needed (nothing will be send).
 * data - Buffer for reply string.  Can be NULL, indicating that no reply is
 *	 is needed and will return with RIG_OK after command was sent.
 * datasize - in: Size of buffer. It is the caller's responsibily to provide
 *	     a large enough buffer for all possible replies for a command.
 *	     out: location where to store number of bytes read.
 *
 * returns:
 *   RIG_OK  -  if no error occured.
 *   RIG_EIO  -  if an I/O error occured while sending/receiving data.
 *   RIG_ETIMEOUT  -  if timeout expires without any characters received.
 *   RIG_REJECTED  -  if a negative acknowledge was received or command not
 *		      recognized by rig.
 */
int
kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len,
				char *data, size_t *datasize)
{
    struct kenwood_priv_caps *caps = kenwood_caps(rig);
    struct rig_state *rs;
    int retval;
    char cmdtrm[2];  /* Default Command/Reply termination char */
    int retry_read = 0;

    rs = &rig->state;
    rs->hold_decode = 1;

    rig_debug(RIG_DEBUG_TRACE, "%s: %s\n", __func__, cmdstr);

    cmdtrm[0] = caps->cmdtrm;
    cmdtrm[1] = '\0';

transaction_write:

    serial_flush(&rs->rigport);

    if (cmdstr) {
	int len = strlen(cmdstr);

	retval = write_block(&rs->rigport, cmdstr, strlen(cmdstr));
	if (retval != RIG_OK)
		goto transaction_quit;

	/* XXX the if is temporary, until all invocations are fixed */
	/* XXX eventually a buffer could be used and write_block called once */
	if (cmdstr[len - 1] != ';' && cmdstr[len - 1] != '\r')
		retval = write_block(&rs->rigport, &caps->cmdtrm, 1);

	if (retval != RIG_OK)
		goto transaction_quit;
    }

    if (data == NULL || *datasize <= 0) {
	 rig->state.hold_decode = 0;
	 return RIG_OK;  /* don't want a reply */
    }

    memset(data,0,*datasize);
    retval = read_string(&rs->rigport, data, *datasize, cmdtrm, strlen(cmdtrm));
    if (retval < 0) {
	 if (retry_read++ < rig->state.rigport.retry)
	     goto transaction_write;
	 goto transaction_quit;
    }	else
  	    *datasize = retval;

    /* 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", __func__, data);
	 if (retry_read++ < rig->state.rigport.retry)
	     goto transaction_write;
	 retval = -RIG_EPROTO;
	 goto transaction_quit;
    }

    if (strlen(data) == 2) {
	switch (data[0]) {
	case 'N':
    		/* Command recognised by rig but invalid data entered. */
	 	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", __func__, cmdstr);
	 	retval = -RIG_EPROTO;
	 	goto transaction_quit;
	case 'E':
		/* Communication error */
	 	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", __func__, cmdstr);
	 	retval = -RIG_ERJCTED;
	 	goto transaction_quit;
	}
    }

#define CONFIG_STRIP_CMDTRM 1
#ifdef CONFIG_STRIP_CMDTRM
	if (strlen(data) > 0)
    	data[strlen(data)-1] = '\0';  /* not very elegant, but should work. */
	else
    	data[0] = '\0';
#endif
    /*
     * Check that received the correct reply. The first two characters
     * should be the same as command.
     */
    if (cmdstr && (data[0] != cmdstr[0] || data[1] != cmdstr[1])) {
	  /*
	   * TODO: When RIG_TRN is enabled, we can pass the string
	   *	to the decoder for callback. That way we don't ignore
	   *	any commands.
	   */
	rig_debug(RIG_DEBUG_ERR, "%s: wrong reply %c%c for command %c%c\n",
		__func__, data[0], data[1], cmdstr[0], cmdstr[1]);

	 if (retry_read++ < rig->state.rigport.retry)
	     goto transaction_write;

	 retval =  -RIG_EPROTO;
	 goto transaction_quit;
    }

    retval = RIG_OK;
transaction_quit:
    rs->hold_decode = 0;
    return retval;
}

int
kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf,
			size_t buf_size, size_t expected)
{
	int err;

	if (expected == 0)
		buf_size = 0;

	err = kenwood_transaction(rig, cmd, strlen(cmd), buf, &buf_size);
	if (err != RIG_OK)
		return err;

	if (buf_size != expected) {
		rig_debug(RIG_DEBUG_ERR, "%s: wrong answer len for cmd %s: "
					"expected = %d, got %d\n",
					__func__, cmd, expected, buf_size);
		return -RIG_EPROTO;
	}

	return RIG_OK;
}

rmode_t kenwood2rmode(unsigned char mode, const rmode_t mode_table[])
{
	if (mode >= KENWOOD_MODE_TABLE_MAX)
		return RIG_MODE_NONE;
	return mode_table[mode];
}

char rmode2kenwood(rmode_t mode, const rmode_t mode_table[])
{
	int i;
	for(i=0; i<KENWOOD_MODE_TABLE_MAX;i++) {
		if (mode_table[i] == mode)
			return i;
	}
	return -1;
}

int kenwood_init(RIG *rig)
{
	struct kenwood_priv_data *priv;
	struct kenwood_priv_caps *caps = kenwood_caps(rig);

	rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__);

	priv = malloc(sizeof(struct kenwood_priv_data));
	if (priv == NULL)
		return -RIG_ENOMEM;

	memset(priv, 0x00, sizeof(struct kenwood_priv_data));

	rig->state.priv = priv;

	/* default mode_table */
	if (caps->mode_table == NULL)
		caps->mode_table = kenwood_mode_table;

	/* default if_len */
	if (caps->if_len == 0)
		caps->if_len = 38;

	rig_debug(RIG_DEBUG_TRACE, "%s: if_len = %d\n", __func__, caps->if_len);

	return RIG_OK;
}

int kenwood_cleanup(RIG *rig)
{
	if (rig == NULL)
		return -RIG_EINVAL;

	free(rig->state.priv);
	rig->state.priv = NULL;

	return RIG_OK;
}

int kenwood_open(RIG *rig)
{
	int err, i;
	char *idptr;
	char id[KENWOOD_MAX_BUF_LEN];

	rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__);

	/* get id in buffer, will be null terminated */
	err = kenwood_get_id(rig, id);
	if (err != RIG_OK) {
		rig_debug(RIG_DEBUG_ERR, "%s: cannot get identification\n",
						__func__);
		return err;
	}

	/* id is something like 'IDXXX' or 'ID XXX' */
	if (strlen(id) < 5) {
		rig_debug(RIG_DEBUG_ERR, "%s: unknown id type (%s)\n", id);
		return -RIG_EPROTO;
	}

	/* check for a white space and skip it */
	idptr = &id[2];
	if (*idptr == ' ')
		idptr++;

	/* compare id string */
	for (i = 0; kenwood_id_string_list[i].model != RIG_MODEL_NONE; i++) {
		if (strcmp(kenwood_id_string_list[i].id, idptr) != 0)
			continue;

		/* found matching id, verify driver */
		rig_debug(RIG_DEBUG_TRACE, "%s: found match %s\n",
				__func__, kenwood_id_string_list[i].id);

		if (kenwood_id_string_list[i].model == rig->caps->rig_model)
			return RIG_OK;

		/* driver mismatch */
		rig_debug(RIG_DEBUG_ERR,
			"%s: wrong driver selected (%d instead of %d)\n",
			__func__, rig->caps->rig_model,
			kenwood_id_string_list[i].model);

		return -RIG_EINVAL;
	}

	rig_debug(RIG_DEBUG_ERR, "%s: your rig (%s) is unknown\n",
					__func__, id);

	return -RIG_EPROTO;
}

/* caller must give a buffer of KENWOOD_MAX_BUF_LEN size */
int kenwood_get_id(RIG *rig, char *buf)
{
	size_t size = KENWOOD_MAX_BUF_LEN;
	return kenwood_transaction(rig, "ID", 2, buf, &size);
}

static int kenwood_get_if(RIG *rig)
{
	struct kenwood_priv_data *priv = rig->state.priv;
	struct kenwood_priv_caps *caps = kenwood_caps(rig);
	char cmdbuf[4] = "IF;";

	cmdbuf[2] = caps->cmdtrm;
	return kenwood_safe_transaction (rig, cmdbuf, priv->info,
					KENWOOD_MAX_BUF_LEN, caps->if_len);
}

/*
 * kenwood_set_vfo
 * Assumes rig!=NULL
 */
int kenwood_set_vfo(RIG *rig, vfo_t vfo)
{
	char cmdbuf[16];
	int retval;
	char vfo_function;

	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;

	case RIG_VFO_CURR:
		return RIG_OK;

	default: 
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n",
					__func__, vfo);
		return -RIG_EINVAL;
	}

	sprintf(cmdbuf, "FR%c", vfo_function);

	/* set RX VFO */
	retval = kenwood_simple_cmd(rig, cmdbuf);
	if (retval != RIG_OK)
		return retval;

	/* set TX VFO */
	cmdbuf[1] = 'T';
	retval = kenwood_simple_cmd(rig, cmdbuf);

	return retval;
}

int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{
	char cmdbuf[6];
	int retval;
	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,"kenwood_set_split_vfo: unsupported VFO %d\n",
							vfo);
		return -RIG_EINVAL;
	}
	
	/* set RX VFO */
	sprintf(cmdbuf, "FR%c", vfo_function);
	retval = kenwood_simple_cmd(rig, cmdbuf);
	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,"kenwood_set_split_vfo: unsupported VFO %d\n", txvfo);
			return -RIG_EINVAL;
		} 
	/* set TX VFO */
	sprintf(cmdbuf, "FT%c", vfo_function);
	retval = kenwood_simple_cmd(rig, cmdbuf);
	if (retval != RIG_OK)
		return retval;
	} else
	  if(vfo==RIG_VFO_CURR)
		rig_debug(RIG_DEBUG_ERR,"kenwood_set_split_vfo: unsupported VFO %d\n", vfo);

	return RIG_OK;
}

int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, vfo_t *txvfo)
{
	int retval;
	struct kenwood_priv_data *priv = rig->state.priv;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	switch (priv->info[32]) {
	case '0':
		*split = RIG_SPLIT_OFF;
		break;

	case '1':
		*split = RIG_SPLIT_ON;
		break;

	default: 
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported split %c\n",
					__func__, priv->info[32]);
		return -RIG_EPROTO;
	}

	/* TODO: find where is the txvfo.. */

	return RIG_OK;
}


/*
 * kenwood_get_vfo_if using byte 31 of the IF information field
 * Assumes rig!=NULL, !vfo
 */
int kenwood_get_vfo_if(RIG *rig, vfo_t *vfo)
{
	int retval;
	struct kenwood_priv_data *priv = rig->state.priv;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	switch (priv->info[30]) {
	case '0':
		*vfo = RIG_VFO_A;
		break;

	case '1':
		*vfo = RIG_VFO_B;
		break;

	case '2':
		*vfo = RIG_VFO_MEM;
		break;

	default: 
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %c\n",
					__func__, priv->info[30]);
		return -RIG_EPROTO;
	}
	return RIG_OK;
}


/*
 * kenwood_set_freq
 * Assumes rig!=NULL
 */
int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
	char freqbuf[16];
	unsigned char vfo_letter;
	vfo_t tvfo;

	tvfo = vfo==RIG_VFO_CURR ? rig->state.current_vfo : vfo;

	switch (tvfo) {
	case RIG_VFO_A: vfo_letter = 'A'; break;
	case RIG_VFO_B: vfo_letter = 'B'; break;
	case RIG_VFO_C: vfo_letter = 'C'; break;
	default: 
		rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
					__func__, vfo);
		return -RIG_EINVAL;
	}
	sprintf(freqbuf,"F%c%011ld", vfo_letter, (long)freq);

	return kenwood_simple_cmd(rig, freqbuf);
}

int kenwood_get_freq_if(RIG *rig, vfo_t vfo, freq_t *freq)
{
	struct kenwood_priv_data *priv = rig->state.priv;

	char freqbuf[50];
	int retval;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	memcpy(freqbuf, priv->info, 15);
	freqbuf[14] = '\0';
	sscanf(freqbuf + 2, "%"SCNfreq, freq);

	return RIG_OK;
}

/*
 * kenwood_get_freq
 * Assumes rig!=NULL, freq!=NULL
 */
int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
	char freqbuf[50];
	char cmdbuf[4];
	int retval;
	unsigned char vfo_letter;
	vfo_t tvfo;

	tvfo = vfo == RIG_VFO_CURR ? rig->state.current_vfo : vfo;

	/* memory frequency cannot be read with an Fx command, use IF */
	if (tvfo == RIG_VFO_MEM) {

		return kenwood_get_freq_if(rig, vfo, freq);
	}

	switch (tvfo) {
	case RIG_VFO_A: vfo_letter = 'A'; break;
	case RIG_VFO_B: vfo_letter = 'B'; break;
	case RIG_VFO_C: vfo_letter = 'C'; break;
	default: 
		rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
				__func__, vfo);
		return -RIG_EINVAL;
	}

	sprintf(cmdbuf, "F%c", vfo_letter);

	retval = kenwood_safe_transaction(rig, cmdbuf, freqbuf, 50, 14);
	if (retval != RIG_OK)
		return retval;

	sscanf(freqbuf+2, "%"SCNfreq, freq);

	return RIG_OK;
}

int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
{
	int retval;
	char buf[6];
	struct kenwood_priv_data *priv = rig->state.priv;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	memcpy(buf, &priv->info[18], 5);

	buf[5] = '\0';
	*rit = atoi(buf);

	return RIG_OK;
}

/*
 * rit can only move up/down by 10 Hz, so we use a loop...
 */
int kenwood_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
	char buf[6];
	unsigned char c;
	int retval, i;
	
	if (rit == 0)
		return kenwood_simple_cmd(rig, "RC");

	if (rit > 0)
		c = 'U';
	else
		c = 'D';

	sprintf(buf, "R%c", c);

	retval = kenwood_simple_cmd(rig, "RC");
	for (i = 0; i < abs(rint(rit/10)); i++)
		retval = kenwood_simple_cmd(rig, buf);

	return retval;
}

/* 
 * rit and xit are the same
 */
int kenwood_get_xit(RIG * rig, vfo_t vfo, shortfreq_t * rit)
{
	 return kenwood_get_rit(rig, vfo, rit);
}

int kenwood_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
	 return kenwood_set_rit(rig, vfo, rit);
}

int kenwood_scan(RIG * rig, vfo_t vfo, scan_t scan, int ch)
{
	return kenwood_simple_cmd(rig,
		scan == RIG_SCAN_STOP? "SC0" : "SC1");
}

static int kenwood_set_filter(RIG *rig, pbwidth_t width)
{
	char *cmd;

 	if (width <= Hz(250))
		cmd = "FL010009";
	else if(width <= Hz(500))
		cmd = "FL009009";
	else if(width <= kHz(2.7))
		cmd = "FL007007";
	else if(width <= kHz(6))
		cmd = "FL005005";
	else
		cmd = "FL002002";

	return kenwood_simple_cmd(rig, cmd);
}

/*
 * kenwood_set_mode
 * Assumes rig!=NULL
 */
int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
	struct kenwood_priv_caps *caps = kenwood_caps(rig);
	char buf[6];
	char kmode;
	int err;

	kmode = rmode2kenwood(mode, caps->mode_table);
	if (kmode < 0 ) {
		rig_debug(RIG_DEBUG_WARN, "%s: unsupported mode '%s'\n",
				   __func__, rig_strrmode(mode));
		return -RIG_EINVAL;
	}

	sprintf(buf, "MD%c", '0' + kmode);
	err = kenwood_simple_cmd(rig, buf);
 	if (err != RIG_OK)
 		return err;

	if (rig->caps->rig_model == RIG_MODEL_TS450S
		|| rig->caps->rig_model == RIG_MODEL_TS690S
		|| rig->caps->rig_model == RIG_MODEL_TS850) {

		err = kenwood_set_filter(rig, width);
		/* non fatal */
 	}

 	return RIG_OK;
}

static int kenwood_get_filter(RIG *rig, pbwidth_t *width)
{
 	int err, f, f1, f2;
 	char buf[10];

 	err = kenwood_safe_transaction(rig, "FL", buf, sizeof(buf), 9);
 	if (err != RIG_OK)
 		return err;

 	buf[8] = '\0';
 	f2 = atoi(&buf[5]);

 	buf[5] = '\0';
 	f1 = atoi(&buf[2]);

 	if (f2 > f1)
 		f = f2;
 	else
 		f = f1;

 	switch (f) {
 	case 2:
 		*width = kHz(12);
 	break;
 	case 3:
 	case 5:
 		*width = kHz(6);
 	break;
 	case 7:
 		*width = kHz(2.7);
 	break;
 	case 9:
 		*width = Hz(500);
 	break;
 	case 10:
 		*width = Hz(250);
 	break;
 	}

 	return RIG_OK;
}

/*
 * kenwood_get_mode
 * Assumes rig!=NULL, mode!=NULL
 */
int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
	struct kenwood_priv_caps *caps = kenwood_caps(rig);
	char modebuf[10];
	int retval;

	retval = kenwood_safe_transaction(rig, "MD", modebuf, 6, 4);
	if (retval != RIG_OK)
		return retval;

	*mode = kenwood2rmode(modebuf[2] - '0', caps->mode_table);

	/* XXX */
	*width = rig_passband_normal(rig, *mode);

	return RIG_OK;
}

/* This is used when the radio does not support MD; for mode reading */
int kenwood_get_mode_if(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
	int err;
	struct kenwood_priv_caps *caps = kenwood_caps(rig);
	struct kenwood_priv_data *priv = rig->state.priv;

	err = kenwood_get_if(rig);
	if (err != RIG_OK)
		return err;

	*mode = kenwood2rmode(priv->info[29] - '0', caps->mode_table);

	*width = rig_passband_normal(rig, *mode);

	if (rig->caps->rig_model == RIG_MODEL_TS450S
		|| rig->caps->rig_model == RIG_MODEL_TS690S
		|| rig->caps->rig_model == RIG_MODEL_TS850) {

		err = kenwood_get_filter(rig, width);
		/* non fatal */
	}

	return RIG_OK;
}

int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
	char levelbuf[16];
	int i, kenwood_val;

	if (RIG_LEVEL_IS_FLOAT(level))
		kenwood_val = val.f * 255;
	else
		kenwood_val = val.i;

	switch (level) {
	case RIG_LEVEL_RFPOWER:
		/* XXX check level range */
		sprintf(levelbuf, "PC%03d", kenwood_val);
		break;

	case RIG_LEVEL_AF:
		sprintf(levelbuf, "AG%03d", kenwood_val);
		break;

	case RIG_LEVEL_RF:
		/* XXX check level range */
		sprintf(levelbuf, "RG%03d", kenwood_val);
		break;

	case RIG_LEVEL_SQL:
		sprintf(levelbuf, "SQ%03d", kenwood_val);
		break;

	case RIG_LEVEL_AGC:
		if (kenwood_val > 3)
			kenwood_val = 3; /* 0.. 255 */
		sprintf(levelbuf, "GT%03d", 84*kenwood_val);
		break;

	case RIG_LEVEL_ATT:
		/* set the attenuator if a correct value is entered */
		for (i=0; i<MAXDBLSTSIZ; i++)
			if (kenwood_val == rig->state.attenuator[i])
			{
				sprintf(levelbuf, "RA%02d", kenwood_val/6);
				break;
			}
			else
				sprintf(levelbuf, "RA00");
		break;

	case RIG_LEVEL_SLOPE_HIGH:
		if(val.i>20 || val.i < 0)
			return -RIG_EINVAL;
		sprintf(levelbuf,"SH%02d",(val.i));
		break;
		
	case RIG_LEVEL_SLOPE_LOW:
		if(val.i>20 || val.i < 0)
			return -RIG_EINVAL;
		sprintf(levelbuf,"SL%02d",(val.i));
		break;

	case RIG_LEVEL_CWPITCH:
		if(val.i > 1000 || val.i < 400)
			return -RIG_EINVAL;
		sprintf(levelbuf, "PT%02d", (val.i / 50) - 8);
		break;

	default:
		rig_debug(RIG_DEBUG_ERR,"Unsupported set_level %d", level);
		return -RIG_EINVAL;
	}

	return kenwood_simple_cmd(rig, levelbuf);
}

/* 
 * assumes f!=NULL
 */
int get_kenwood_level(RIG *rig, const char *cmd, int cmd_len, float *f)
{
	char lvlbuf[10];
	int retval;
	int lvl;

	retval = kenwood_safe_transaction(rig, cmd, lvlbuf, 10, 6);
	if (retval != RIG_OK)
		return retval;

	/*
	 * 000..255
	 */
	sscanf(lvlbuf+2, "%d", &lvl);
	*f = (float)lvl/255.0;

	return RIG_OK;
};


/*
 * kenwood_get_level
 * Assumes rig!=NULL, val!=NULL
 */
int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
	char lvlbuf[50];
	int retval;
	int lvl;
	int i, ret, agclevel;
	size_t lvl_len;

	switch (level) {
	case RIG_LEVEL_RAWSTR:
		retval = kenwood_safe_transaction(rig, "SM", lvlbuf, 10, 7);
		if (retval != RIG_OK)
			return retval;

		/* XXX atoi ? */
		sscanf(lvlbuf+2, "%d", &val->i);	/* rawstr */
		break;

	case RIG_LEVEL_STRENGTH:
		retval = kenwood_safe_transaction(rig, "SM", lvlbuf, 10, 7);
		if (retval != RIG_OK)
			return retval;

		sscanf(lvlbuf+2, "%d", &val->i);	/* rawstr */

		if (rig->caps->str_cal.size)
			val->i = (int) rig_raw2val(val->i, &rig->caps->str_cal);
		else
			val->i = (val->i * 4) - 54;
		break;

	case RIG_LEVEL_ATT:
		retval = kenwood_safe_transaction(rig, "RA", lvlbuf, 50, 5);
		if (retval != RIG_OK)
			return retval;

		sscanf(lvlbuf+2, "%d", &lvl);
		if (lvl == 0) {
			val->i = 0;
		} else {
			for (i=0; i<lvl && i<MAXDBLSTSIZ; i++)
				if (rig->state.attenuator[i] == 0) {
					rig_debug(RIG_DEBUG_ERR,"%s: "
							"unexpected att level %d\n",
							__func__, lvl);
					return -RIG_EPROTO;
				}
				if (i != lvl)
					return -RIG_EINTERNAL;
				val->i = rig->state.attenuator[i-1];
		}
		break;

	case RIG_LEVEL_RFPOWER:
		return get_kenwood_level(rig, "PC", 3, &val->f);

	case RIG_LEVEL_AF:
		return get_kenwood_level(rig, "AG", 3, &val->f);

	case RIG_LEVEL_RF:
		return get_kenwood_level(rig, "RG", 3, &val->f);

	case RIG_LEVEL_SQL:
		return get_kenwood_level(rig, "SQ", 3, &val->f);

	case RIG_LEVEL_MICGAIN:
		return get_kenwood_level(rig, "MG", 3, &val->f);

	case RIG_LEVEL_AGC:
		ret = get_kenwood_level(rig, "GT", 3, &val->f);
		agclevel = 255 * val->f;
		if (agclevel == 0) val->i = 0;
		else if (agclevel < 85) val->i = 1;
		else if (agclevel < 170) val->i = 2;
		else if (agclevel <= 255) val->i = 3;
		return ret;

	case RIG_LEVEL_SLOPE_LOW:
		lvl_len = 50;
		retval = kenwood_transaction (rig, "SL", 3, lvlbuf, &lvl_len);
		if (retval != RIG_OK)
			return retval;
		lvlbuf[4]='\0';
		val->i=atoi(&lvlbuf[2]);
		break;
		
	case RIG_LEVEL_SLOPE_HIGH:
		lvl_len = 50;
		retval = kenwood_transaction (rig, "SH", 3, lvlbuf, &lvl_len);
		if (retval != RIG_OK)
			return retval;
		lvlbuf[4]='\0';
		val->i=atoi(&lvlbuf[2]);
		break;

	case RIG_LEVEL_CWPITCH:
		retval = kenwood_safe_transaction(rig, "PT", lvlbuf, 50, 5);
		if (retval != RIG_OK)
			return retval;

		sscanf(lvlbuf+2, "%d", &val->i);
		val->i = (val->i * 1000) + 1000; /* 00 - 08 */
		break;

	case RIG_LEVEL_PREAMP:
	case RIG_LEVEL_IF:
	case RIG_LEVEL_APF:
	case RIG_LEVEL_NR:
	case RIG_LEVEL_PBT_IN:
	case RIG_LEVEL_PBT_OUT:
	case RIG_LEVEL_KEYSPD:
	case RIG_LEVEL_NOTCHF:
	case RIG_LEVEL_COMP:
	case RIG_LEVEL_BKINDL:
	case RIG_LEVEL_BALANCE:
		return -RIG_ENIMPL;

	default:
		rig_debug(RIG_DEBUG_ERR,"Unsupported get_level %d", level);
		return -RIG_EINVAL;
	}

	return RIG_OK;
}

int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
	char buf[6];

	switch (func) {
	case RIG_FUNC_NB:
		sprintf(buf, "NB%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_ABM:
		sprintf(buf, "AM%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_COMP:
		sprintf(buf, "PR%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_TONE:
		sprintf(buf, "TO%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_TSQL:
		sprintf(buf, "CT%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_VOX:
		sprintf(buf, "VX%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_FAGC:
		sprintf(buf, "GT00%c", (0==status)? '4':'2');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_NR:
		sprintf(buf, "NR%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_BC:
		sprintf(buf, "BC%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_ANF:
		sprintf(buf, "NT%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case RIG_FUNC_LOCK:
		sprintf(buf, "LK%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);
		
	case RIG_FUNC_AIP:
		sprintf(buf, "MX%c", (status == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	default:
		rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %#x", func);
		return -RIG_EINVAL;
	}

	return -RIG_EINVAL;
}

/* 
 * assumes status!=NULL
 * works for any 'format 1' command
 * answer is always 4 bytes: two byte command id, status and terminator
 */
static int get_kenwood_func(RIG *rig, const char *cmd, int *status)
{
	int retval;
	char buf[10];

	retval = kenwood_safe_transaction(rig, cmd, buf, 10, 4);
	if (retval != RIG_OK)
		return retval;

	*status = buf[2] == '0' ? 0 : 1;

	return RIG_OK;
};

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

	switch (func) {
	case RIG_FUNC_FAGC:
		retval = kenwood_safe_transaction(rig, "GT", fctbuf, 20, 6);
		if (retval != RIG_OK)
			return retval;

		*status = fctbuf[4] != '4' ? 1 : 0;
		return RIG_OK;

	case RIG_FUNC_NB:
		return get_kenwood_func(rig, "NB", status);

	case RIG_FUNC_ABM:
		return get_kenwood_func(rig, "AM", status);

	case RIG_FUNC_COMP:
		return get_kenwood_func(rig, "PR", status);

	case RIG_FUNC_TONE:
		return get_kenwood_func(rig, "TO", status);

	case RIG_FUNC_TSQL:
		return get_kenwood_func(rig, "CT", status);

	case RIG_FUNC_VOX:
		return get_kenwood_func(rig, "VX", status);

	case RIG_FUNC_NR:
		return get_kenwood_func(rig, "NR", status);

 	/* FIXME on TS2000 */
	case RIG_FUNC_BC:
		return get_kenwood_func(rig, "BC", status);

	case RIG_FUNC_ANF:
		return get_kenwood_func(rig, "NT", status);

	case RIG_FUNC_LOCK:
		return get_kenwood_func(rig, "LK", status);

	case RIG_FUNC_AIP:
		return get_kenwood_func(rig, "MX", status);

	default:
		rig_debug(RIG_DEBUG_ERR,"Unsupported get_func %#x", func);
		return -RIG_EINVAL;
	}

	return -RIG_EINVAL;
}

/*
 * kenwood_set_ctcss_tone
 * Assumes rig!=NULL, rig->caps->ctcss_list != NULL
 *
 * Warning! This is untested stuff! May work at least on TS-870S
 * 	Please owners report to me <fillods@users.sourceforge.net>, thanks. --SF

 * TODO: TS-2000 uses CN/CT
 */
int kenwood_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
{
	const struct rig_caps *caps;
	char tonebuf[16];
	int i;

	caps = rig->caps;

/* TODO: replace 200 by something like RIGTONEMAX */
	for (i = 0; caps->ctcss_list[i] != 0 && i<200; i++) {
		if (caps->ctcss_list[i] == tone)
			break;
	}
	if (caps->ctcss_list[i] != tone)
		return -RIG_EINVAL;

/* TODO: replace menu no 57 by a define */
	sprintf(tonebuf,"EX%03d%04d", 57, i+1);
	
	return kenwood_simple_cmd(rig, tonebuf);
}

int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone)
{
	const struct rig_caps *caps = rig->caps;
	char buf[6];
	int i;

	/* XXX 38 is a fixed constant */
	for (i = 0; caps->ctcss_list[i] != 0 && i < 38; i++) {
		if (tone == caps->ctcss_list[i])
			break;
	}

	if (tone != caps->ctcss_list[i])
		return -RIG_EINVAL;

	sprintf(buf, "TN%02d", i + 1);

	return kenwood_simple_cmd(rig, buf);
}

/*
 * kenwood_get_ctcss_tone
 * Assumes rig!=NULL, rig->state.priv!=NULL
 */
int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
{
	struct kenwood_priv_data *priv = rig->state.priv;
	const struct rig_caps *caps;
	char tonebuf[3];
	int i, retval;
	unsigned int tone_idx;
						 
	caps = rig->caps;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	memcpy(tonebuf, &priv->info[34], 2);

	tonebuf[2] = '\0';
	tone_idx = atoi(tonebuf);

	if (tone_idx == 0) {
		rig_debug(RIG_DEBUG_ERR, "%s: CTCSS tone is zero (%s)\n",
					__func__, tonebuf);
		return -RIG_EPROTO;
	}
		
	/* check this tone exists. That's better than nothing. */
	for (i = 0; i<tone_idx; i++) {
		if (caps->ctcss_list[i] == 0) {
			rig_debug(RIG_DEBUG_ERR,"kenwood_get_ctcss_tone: CTCSS NG "
					"(%04d)\n", tone_idx);
			return -RIG_EPROTO;
		}
	}
	*tone = caps->ctcss_list[tone_idx-1];

	return RIG_OK;
}

/*
 * set the aerial/antenna to use
 */
int kenwood_set_ant(RIG * rig, vfo_t vfo, ant_t ant)
{
	const char *cmd;

	switch (ant) {
	case RIG_ANT_1:
		cmd = "AN1";
		break;
	case RIG_ANT_2:
		cmd = "AN2";
		break;
	case RIG_ANT_3:
		cmd = "AN3";
		break;
	case RIG_ANT_4:
		cmd = "AN4";
		break;
	default:
		return -RIG_EINVAL;
	}

	return kenwood_simple_transaction(rig, cmd, 4);
}

int kenwood_set_ant_no_ack(RIG * rig, vfo_t vfo, ant_t ant)
{
	const char *cmd;

	switch (ant) {
	case RIG_ANT_1:
		cmd = "AN1";
		break;
	case RIG_ANT_2:
		cmd = "AN2";
		break;
	case RIG_ANT_3:
		cmd = "AN3";
		break;
	case RIG_ANT_4:
		cmd = "AN4";
		break;
	default:
		return -RIG_EINVAL;
	}

	return kenwood_simple_cmd(rig, cmd);
}

/*
 * get the aerial/antenna in use
 */
int kenwood_get_ant (RIG * rig, vfo_t vfo, ant_t * ant)
{
	char ackbuf[6];
	int retval;

	retval = kenwood_safe_transaction(rig, "AN", ackbuf, 6, 4);
	if (retval != RIG_OK)
		return retval;

	if (ackbuf[2] < '1' || ackbuf[2] > '9')
		return -RIG_EPROTO;

	*ant = RIG_ANT_N(ackbuf[2]-'1');

	/* XXX check that the returned antenna can be found on the rig */

	return RIG_OK;
}

/*
 * kenwood_get_ptt
 * Assumes rig!=NULL, ptt!=NULL
 */
int kenwood_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
	struct kenwood_priv_data *priv = rig->state.priv;
	int retval;

	retval = kenwood_get_if(rig);
	if (retval != RIG_OK)
		return retval;

	*ptt = priv->info[28] == '0' ? RIG_PTT_OFF : RIG_PTT_ON;

	return RIG_OK;
}


/*
 * kenwood_set_ptt
 * Assumes rig!=NULL
 */
int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
	return kenwood_simple_cmd(rig,
		ptt == RIG_PTT_ON ? "TX" : "RX");
}


/*
 * kenwood_get_dcd
 * Assumes rig!=NULL, dcd!=NULL
 */
int kenwood_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
	char busybuf[10];
	int retval;
								 
	retval = kenwood_safe_transaction(rig, "BY", busybuf, 10, 4);
	if (retval != RIG_OK)
		return retval;

	*dcd = (busybuf[2] == '1') ? RIG_DCD_ON : RIG_DCD_OFF;

	return RIG_OK;
}

/*
 * kenwood_set_trn
 * Assumes rig!=NULL
 */
int kenwood_set_trn(RIG *rig, int trn)
{
	return kenwood_simple_transaction(rig,
		(trn == RIG_TRN_RIG) ? "AI1" : "AI0", 4);
}

/*
 * kenwood_get_trn
 * Assumes rig!=NULL, trn!=NULL
 */
int kenwood_get_trn(RIG *rig, int *trn)
{
	char trnbuf[6];
	int retval;

	retval = kenwood_safe_transaction(rig, "AI", trnbuf, 6, 4);
	if (retval != RIG_OK)
		return retval;

	*trn = trnbuf[2] != '0' ? RIG_TRN_RIG : RIG_TRN_OFF;

	return RIG_OK;
}

/*
 * kenwood_set_powerstat
 * Assumes rig!=NULL
 */
int kenwood_set_powerstat(RIG *rig, powerstat_t status)
{
	return kenwood_simple_transaction(rig,
		(status == RIG_POWER_ON) ? "PS1" : "PS0", 4);
}

/*
 * kenwood_get_powerstat
 * Assumes rig!=NULL, trn!=NULL
 */
int kenwood_get_powerstat(RIG *rig, powerstat_t *status)
{
	char pwrbuf[6];
	int retval;

	retval = kenwood_safe_transaction(rig, "PS", pwrbuf, 6, 4);
	if (retval != RIG_OK)
		return retval;

	*status = pwrbuf[2] == '0' ? RIG_POWER_OFF : RIG_POWER_ON;

	return RIG_OK;
}

/*
 * kenwood_reset
 * Assumes rig!=NULL
 */
int kenwood_reset(RIG *rig, reset_t reset)
{
	char rstbuf[6];
	char rst;

	switch(reset) {
	case RIG_RESET_VFO:
		rst = '1';
		break;

	case RIG_RESET_MASTER:
		rst = '2';
		break;

	default:
		rig_debug(RIG_DEBUG_ERR,"%s: unsupported reset %d\n",
					__func__, reset);
		return -RIG_EINVAL;
	}

	sprintf(rstbuf,"SR%c", rst);

	/* this command has no answer */
	return kenwood_simple_cmd(rig, rstbuf);
}

/*
 * kenwood_send_morse
 * Assumes rig!=NULL
 */
int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg)
{
	char morsebuf[30], m2[30];
	int msg_len, buff_len, retval;
	const char *p;

	p = msg;
	msg_len = strlen(msg);

	while(msg_len > 0) {
		/*
		 * TODO: check with "KY" if char buffer is available.
		 * 		if not, sleep.
		 *
		 * Make the total message segments 28 characters 
		 * in length because Kenwood demands it.
		 * Spaces fill in the message end.
		 */
		buff_len = msg_len > 24 ? 24 : msg_len;

		strncpy(m2, p, 24);
		m2[24] = '\0';

		/* the command must consist of 28 bytes */
		sprintf(morsebuf,"KY %-24s", m2);
		retval = kenwood_simple_cmd(rig, morsebuf);
		if (retval != RIG_OK)
			return retval;

		msg_len -= buff_len;
		p += buff_len;
	}

	return RIG_OK;
}

/*
 * kenwood_vfo_op
 * Assumes rig!=NULL
 */
int kenwood_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
{
	char *cmd;

	switch(op) {
	case RIG_OP_UP:
		cmd="UP";
		break;

	case RIG_OP_DOWN:
		cmd="DN";
		break;

	case RIG_OP_BAND_UP:
		cmd="BD";
		break;

	case RIG_OP_BAND_DOWN:
		cmd="BU";
		break;

	default:
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n",
					__func__, op);
		return -RIG_EINVAL;
	}

	return kenwood_simple_cmd(rig, cmd);
}

/*
 * kenwood_set_mem
 * Assumes rig!=NULL
 */
int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch)
{
	char buf[8];
	/*
	 * "MCbmm;"
	 * where b is the bank number, mm the memory number.
	 * b can be a space
	 */
	sprintf(buf, "MC %02d", ch);

	return kenwood_simple_cmd(rig, buf);
}

/*
 * kenwood_get_mem
 * Assumes rig!=NULL
 */
int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch)
{
	char membuf[10];
	int retval;

	/*
	 * "MCbmm;"
	 * where b is the bank number, mm the memory number.
	 * b can be a space
	 */

	retval = kenwood_safe_transaction(rig, "MC", membuf, 10, 6);
	if (retval != RIG_OK)
		return retval;

	*ch = atoi(membuf+2);

	return RIG_OK;
}

int kenwood_get_mem_if(RIG *rig, vfo_t vfo, int *ch)
{
	int err;
	char buf[4];
	struct kenwood_priv_data *priv = rig->state.priv;

	err = kenwood_get_if(rig);
	if (err != RIG_OK)
		return err;

	memcpy(buf, &priv->info[26], 2);
	buf[2] = '\0';

	*ch = atoi(buf);

	return RIG_OK;
}

int kenwood_get_channel(RIG *rig, channel_t *chan)
{
	int err;
	char buf[26];
	char cmd[8];
	struct kenwood_priv_caps *caps = kenwood_caps(rig);

	/* put channel num in the command string */
	sprintf(cmd, "MR0 %02d", chan->channel_num);

	err = kenwood_safe_transaction(rig, cmd, buf, 26, 24);
	if (err != RIG_OK)
		return err;

	memset(chan, 0x00, sizeof(channel_t));

	chan->vfo = RIG_VFO_VFO;

	/* MR0 1700005890000510   ;
	 * MRs ccfffffffffffMLTtt ;
	 */

	/* parse from right to left */

	/* XXX based on the available documentation, there is no command
	 * to read out the filters of a given memory channel. The rig, however,
	 * stores this information.
	 */

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

	/* memory lockout */
	if (buf[18] == '1')
		chan->flags |= RIG_CHFLAG_SKIP;

	chan->mode = kenwood2rmode(buf[17] - '0', caps->mode_table);

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

	if (chan->freq == RIG_FREQ_NONE)
		return -RIG_ENAVAIL;

	buf[6] = '\0';
	chan->channel_num = atoi(&buf[4]);


	/* split freq */
	cmd[2] = '1';
	err = kenwood_safe_transaction(rig, cmd, buf, 26, 24);
	if (err != RIG_OK)
		return err;

	chan->tx_mode = kenwood2rmode(buf[17] - '0', caps->mode_table);

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

	if (chan->freq == chan->tx_freq) {
		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 kenwood_set_channel(RIG *rig, channel_t *chan)
{
	char buf[26];
	char mode, tx_mode = 0;
	int err;
	int tone = 0;

	struct kenwood_priv_caps *caps = kenwood_caps(rig);

	mode = rmode2kenwood(chan->mode, caps->mode_table);
        if (mode < 0 ) {
                rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
                                   __func__, rig_strrmode(chan->mode));
                return -RIG_EINVAL;
        }

	if (chan->split == RIG_SPLIT_ON) {
		tx_mode = rmode2kenwood(chan->tx_mode, caps->mode_table);
        	if (tx_mode < 0 ) {
	                rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
       	                           __func__, rig_strrmode(chan->tx_mode));
	                return -RIG_EINVAL;
        	}

	}

	/* find tone */
	if (chan->ctcss_tone) {

		for (tone = 0; rig->caps->ctcss_list[tone] != 0; tone++) {
			if (chan->ctcss_tone == rig->caps->ctcss_list[tone])
				break;
		}

		if (chan->ctcss_tone != rig->caps->ctcss_list[tone])
			tone = 0;
	}

	sprintf(buf, "MW0 %02d%011d%c%c%c%02d ", /* note the space at the end */
		chan->channel_num,
		(int) chan->freq,
		'0' + mode,
		(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',
		chan->ctcss_tone ? '1' : '0',
		chan->ctcss_tone ? (tone + 1) : 0);

	err = kenwood_simple_cmd(rig, buf);
	if (err != RIG_OK)
		return err;

	sprintf(buf, "MW1 %02d%011d%c%c%c%02d ",
		chan->channel_num,
		(chan->split == RIG_SPLIT_ON) ? ((int) chan->tx_freq) : 0,
		(chan->split == RIG_SPLIT_ON) ? ('0' + tx_mode) : '0',
		(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',
		chan->ctcss_tone ? '1' : '0',
		chan->ctcss_tone ? (tone + 1) : 0);

	return kenwood_simple_cmd(rig, buf);
}

int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val)
{
	char buf[4];

	switch (token) {
	case TOK_VOICE:
		return kenwood_simple_cmd(rig, "VR");

	case TOK_FINE:
		sprintf(buf, "FS%c", (val.i == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case TOK_XIT:
		sprintf(buf, "XT%c", (val.i == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);

	case TOK_RIT:
		sprintf(buf, "RT%c", (val.i == 0) ? '0' : '1');
		return kenwood_simple_cmd(rig, buf);
	}

	return -RIG_EINVAL;
}

int kenwood_get_ext_parm(RIG *rig, token_t token, value_t *val)
{
	int err;
	struct kenwood_priv_data *priv = rig->state.priv;

	switch (token) {
	case TOK_FINE:
		return get_kenwood_func(rig, "FS", &val->i);

	case TOK_XIT:
		err = kenwood_get_if(rig);
		if (err != RIG_OK)
			return err;

		val->i = (priv->info[24] == '1') ? 1 : 0;
		return RIG_OK;

	case TOK_RIT:
		err = kenwood_get_if(rig);
		if (err != RIG_OK)
			return err;

		val->i = (priv->info[23] == '1') ? 1 : 0;
		return RIG_OK;
	}

	return -RIG_ENIMPL;
}

/*
 * kenwood_get_info
 * supposed to work only for TS2000...
 * Assumes rig!=NULL
 */
const char* kenwood_get_info(RIG *rig)
{
	char firmbuf[10];
	int retval;

	retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 6);
	if (retval != RIG_OK)
		return NULL;

	switch (firmbuf[4]) {
		case '0': return "Firmware: Overseas type";
		case '1': return "Firmware: Japanese 100W type";
		case '2': return "Firmware: Japanese 20W type";
		default: return "Firmware: unknown";
	}
}

#define IDBUFSZ 16

/*
 * proberigs_kenwood
 *
 * Notes:
 * There's only one rig possible per port.
 *
 * rig_model_t probeallrigs_kenwood(port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)
 */
DECLARE_PROBERIG_BACKEND(kenwood)
{
	char idbuf[IDBUFSZ];
	int id_len=-1, i, k_id;
	int retval=-1;
	int rates[] = { 115200, 57600, 9600, 4800, 1200, 0 };	/* possible baud rates */
	int rates_idx;

	if (!port)
		return RIG_MODEL_NONE;

	if (port->type.rig != RIG_PORT_SERIAL)
		return RIG_MODEL_NONE;

	port->write_delay = port->post_write_delay = 0;
	port->parm.serial.stop_bits = 2;
	port->retry = 1;

	/*
	 * try for all different baud rates
	 */
	for (rates_idx = 0; rates[rates_idx]; rates_idx++) {
		port->parm.serial.rate = rates[rates_idx];
		port->timeout = 2*1000/rates[rates_idx] + 50;
	
		retval = serial_open(port);
		if (retval != RIG_OK)
			return RIG_MODEL_NONE;
	
		retval = write_block(port, "ID;", 3);
		id_len = read_string(port, idbuf, IDBUFSZ, ";\r", 2);
		close(port->fd);

		if (retval != RIG_OK || id_len < 0)
			continue;
	}

	if (retval != RIG_OK || id_len < 0 || !strcmp(idbuf, "ID;"))
		return RIG_MODEL_NONE;

	/* 
	 * reply should be something like 'IDxxx;'
	 */
	if (id_len != 5 || id_len != 6) {
		idbuf[7] = '\0';
		rig_debug(RIG_DEBUG_VERBOSE,"probe_kenwood: protocol error,"
					" expected %d, received %d: %s\n",
					6, id_len, idbuf);
		return RIG_MODEL_NONE;
	}


	/* first, try ID string */
	for (i=0; kenwood_id_string_list[i].model != RIG_MODEL_NONE; i++) {
		if (!strncmp(kenwood_id_string_list[i].id, idbuf+2, 16)) {
			rig_debug(RIG_DEBUG_VERBOSE,"probe_kenwood: "
							"found %s\n", idbuf+2);
			if (cfunc)
				(*cfunc)(port, kenwood_id_string_list[i].model, data);
			return kenwood_id_string_list[i].model;
		}
	}

	/* then, try ID numbers */

	k_id = atoi(idbuf+2);

	/*
	 * Elecraft K2 returns same ID as TS570
	 */
	if (k_id == 17) {
		retval = serial_open(port);
		if (retval != RIG_OK)
			return RIG_MODEL_NONE;
		retval = write_block(port, "K2;", 3);
    		id_len = read_string(port, idbuf, IDBUFSZ, ";\r", 2);
		close(port->fd);
		if (retval != RIG_OK)
			return RIG_MODEL_NONE;
		/* 
		 * reply should be something like 'K2n;'
		 */
		if (id_len == 4 || !strcmp(idbuf, "K2")) {
			rig_debug(RIG_DEBUG_VERBOSE,"probe_kenwood: found K2\n");
			if (cfunc)
				(*cfunc)(port, RIG_MODEL_K2, data);
			return RIG_MODEL_K2;
		}
	}

	for (i=0; kenwood_id_list[i].model != RIG_MODEL_NONE; i++) {
		if (kenwood_id_list[i].id == k_id) {
			rig_debug(RIG_DEBUG_VERBOSE,"probe_kenwood: "
							"found %03d\n", k_id);
			if (cfunc)
				(*cfunc)(port, kenwood_id_list[i].model, data);
			return kenwood_id_list[i].model;
		}
	}
	/*
	 * not found in known table.... 
	 * update kenwood_id_list[]!
	 */
	rig_debug(RIG_DEBUG_WARN,"probe_kenwood: found unknown device "
				"with ID %03d, please report to Hamlib "
				"developers.\n", k_id);

	return RIG_MODEL_NONE;
}


/*
 * initrigs_kenwood is called by rig_backend_load
 */
DECLARE_INITRIG_BACKEND(kenwood)
{
	rig_debug(RIG_DEBUG_VERBOSE, "kenwood: _init called\n");

	rig_register(&ts950sdx_caps);
	rig_register(&ts50s_caps);
	rig_register(&ts140_caps);
	rig_register(&ts450s_caps);
	rig_register(&ts570d_caps);
	rig_register(&ts570s_caps);
	rig_register(&ts680s_caps);
	rig_register(&ts690s_caps);
	rig_register(&ts790_caps);
	rig_register(&ts850_caps);
	rig_register(&ts870s_caps);
	rig_register(&ts930_caps);
	rig_register(&ts2000_caps);
	rig_register(&trc80_caps);
	rig_register(&k2_caps);
	rig_register(&k3_caps);

	rig_register(&ts440_caps);
	rig_register(&ts940_caps);
	rig_register(&ts711_caps);
	rig_register(&ts811_caps);
	rig_register(&r5000_caps);

	rig_register(&tmd700_caps);
	rig_register(&thd7a_caps);
	rig_register(&thf7e_caps);
	rig_register(&thg71_caps);
	rig_register(&tmv7_caps);
	
	rig_register(&ts480_caps);

	return RIG_OK;
}