/*
 *  Hamlib PRM80 backend - main file
 *  Copyright (c) 2010,2021 by Stephane Fillod
 *
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library 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
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <hamlib/config.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>  /* String function definitions */
#include <unistd.h>  /* UNIX standard function definitions */
#include <ctype.h>
#include <math.h>

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

#include "prm80.h"


#define LF "\x0a"

#define BUFSZ 64

// Channel number min and max
#define CHAN_MIN 0
#define CHAN_MAX 99

// "E" system state is cached for this time (ms)
#define PRM80_CACHE_TIMEOUT 200

// Length (in bytes) of the response to the "E" command
#define CMD_E_RSP_LEN 22

#define RX_IF_OFFSET MHz(21.4)

// The rig's PLL only deals with freq in Hz divided by this value
#define FREQ_DIV 12500.

/* V5 based on V4 commands
 * retrieved from https://github.com/f4fez/prm80
 * and https://github.com/f4fez/prm80/blob/master/doc/Computer_commands_V4.md
 * It used to be from https://sourceforge.net/projects/prm80/
 * and https://sourceforge.net/p/prm80/wiki/Computer%20commands%20V4/

MessageVersion:
IF TARGET EQ 8060
              DB   "PRM8060 V4.0"
ELSEIF TARGET EQ 8070
              DB   "PRM8070 V4.0"
ENDIF

MessageAide:  DB   "H",0Dh,0Ah
              DB   " Commandes disponibles :",0Dh,0Ah
              DB   " [0] = Reset.",0Dh,0Ah
              DB   " [1] a [5] = Show 80c552 port state P1 to P5.",0Dh,0Ah
              DB   " [C] = Print channels list.",0Dh,0Ah
              DB   " [D] = Set system byte.",0Dh,0Ah
              DB   " [E] = Show system state (Mode-Chan-Chanstate-Sql-Vol-Lock-RX freq-TX freq,RSSI).",0Dh,0Ah
              DB   " [F] = Set squelch.",0Dh,0Ah
              DB   " [H] = Print this help page.",0Dh,0Ah
              DB   " [I] = Erase and init RAM and EEPROM.",0Dh,0Ah
              DB   " [K] = Set lock byte.",0Dh,0Ah
              DB   " [L] = Print latch state.",0Dh,0Ah
              DB   " [M] = Edit external RAM manually.",0Dh,0Ah
              DB   " [N] = Set current channel.",0Dh,0Ah
              DB   " [O] = Set volume.",0Dh,0Ah
              DB   " [P] = Edit/Add channel.",0Dh,0Ah
              DB   " [Q] = Set channels number.",0Dh,0Ah
              DB   " [R] = Set synthetiser frequencies.",0Dh,0Ah
              DB   " [U] = Print 80c552 internal RAM.",0Dh,0Ah
              DB   " [S] = Copy EEPROM to external RAM.",0Dh,0Ah
              DB   " [T] = Set current channel state.",0Dh,0Ah
              DB   " [V] = Print firmware version.",0Dh,0Ah
              DB   " [X] = Copy external RAM to EEPROM.",0Dh,0Ah
              DB   " [Y] = Print first 2 kb from the EEPROM I2C 24c16.",0Dh,0Ah
              DB   " [Z] = Print external RAM ($0000 to $07FF).",0Dh,0Ah,0
*/
/*
[0] = Reset.
[C] = Print channels list.
[D] = Set system byte.

[E] = Show system state (Mode-Chan-Chanstate-Sql-Vol-Lock-RX freq-TX
                freq-RSSI).
[F] = Set squelch.
[H] = Print this help page.
[K] = Set lock byte.
[N] = Set current channel.
[O] = Set volume.
[P] = Edit/Add channel.
[Q] = Set channels number.
[R] = Set synthetiser frequencies.
[T] = Set current channel state.
[V] = Print firmware version.
*/

/*
 * Mode byte, which holds the state of system basic features:
    b0: Squelch mode is displayed on LCD if true. Channel mode if false.
    b1: Power level (High or Low mode)
    b2: Squelch open (Read only)
    b3: TX mode (Read only)
    b4: PLL locked (Read only)
    b5: Long key push (Internal)
    b6: Key bounce (Internal)
    b7: Force LCD refresh when set. Automatically cleared.

   Channel state byte:
    b0: Shift enable when true
    b1: Reverse mode when true
    b2: Positive shift when true. Negative if false
    b3: Scanning locked out channel if set
    b4-7: na.

   Lock byte, which disables user controls when connected to a computer
    b0: Keys disabled when true
    b1: TX disabled when true
    b2: Volume button disabled when true
    b3: RX disabled when true
    b4-b7: na.

 * *********************************************************************
 */

static void prm80_force_cache_timeout(RIG *rig)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;

    rig_force_cache_timeout(&priv->status_tv);
}

/*
 * Read a prompt terminated by delimiter, then write an optional string s.
 */
static int read_prompt_and_send(hamlib_port_t *rigport,
                                char *data, int *data_len, const char *s, const char *delimiter,
                                int space_after_delim)
{
    char buf[BUFSZ];
    char spacebuf[4];
    int buflen, retval;

    /* no data wanted? flush it anyway by reading it */
    if (data == NULL)
    {
        data = buf;
    }

    buflen = (data_len == NULL) ? sizeof(buf) : *data_len;

    retval = read_string(rigport, (unsigned char *) data, buflen, delimiter, 1, 0,
                         1);

    if (retval < 0)
    {
        return retval;
    }

    // Place an end of string
    data[(retval < buflen) ? retval : (buflen - 1)] = '\0';

    if (data_len != NULL)
    {
        *data_len = retval;
    }

    // Read one (dummy) space character after the colon
    if (space_after_delim)
    {
        retval = read_block(rigport, (unsigned char *) spacebuf, 1);

        if (retval < 0 && retval != -RIG_ETIMEOUT)
        {
            return retval;
        }
    }

    // Here is the answer to the prompt
    retval = write_block(rigport, (unsigned char *) s, strlen(s));

    return retval;
}

/*
 * Read a prompt terminated by ": ", then write an optional string s.
 */
static int read_colon_prompt_and_send(hamlib_port_t *rigport,
                                      char *data, int *data_len, const char *s)
{
    return read_prompt_and_send(rigport, data, data_len, s, ":", 1);
}

/*
 * Read a prompt terminated by "$" (without space afterwards),
 * then write an optional string s.
 */
static int read_dollar_prompt_and_send(hamlib_port_t *rigport,
                                       char *data, int *data_len, const char *s)
{
    return read_prompt_and_send(rigport, data, data_len, s, "$", 0);
}

/*
 * After each executed command, the rig generally sends "\r\n>"
 */
static int prm80_wait_for_prompt(hamlib_port_t *rigport)
{
    char buf[BUFSZ * 2];
    int retval;

    // Read up to the '>' prompt and discard content.
    retval = read_string(rigport, (unsigned char *) buf, sizeof(buf), ">", 1, 0, 1);

    if (retval < 0)
    {
        return retval;
    }

    return RIG_OK;
}

/*
 *
 * \param cmd is string of generally one letter (or digit)
 * \param arg1 is an optional string to send afterwards
 * \param wait_prompt boolean when non-nul, will wait for "\r\n>" afterwards
 */
static int prm80_transaction(RIG *rig, const char *cmd,
                             const char *arg1, int wait_prompt)
{
    int retval;
    struct rig_state *rs = &rig->state;

    // Get rid of possible prompt sent by the rig
    rig_flush(&rs->rigport);

    // Start with the command
    retval = write_block(&rs->rigport, (unsigned char *) cmd, strlen(cmd));

    if (retval != RIG_OK)
    {
        return retval;
    }

    if (arg1 != NULL)
    {
        retval = read_colon_prompt_and_send(&rs->rigport, NULL, NULL, arg1);

        if (retval < 0)
        {
            return retval;
        }
    }

    if (wait_prompt)
    {
        prm80_wait_for_prompt(&rs->rigport);
    }

    return RIG_OK;
}

int prm80_init(RIG *rig)
{
    if (!rig)
    {
        return -RIG_EINVAL;
    }

    rig->state.priv = (void *)calloc(1, sizeof(struct prm80_priv_data));

    if (!rig->state.priv)
    {
        /* whoops! memory shortage! */
        return -RIG_ENOMEM;
    }

    return RIG_OK;
}

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

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

    return RIG_OK;
}


/*
 * prm80_reset
 * Assumes rig!=NULL
 */
int prm80_reset(RIG *rig, reset_t reset)
{
    int retval;

    /*
     * Reset CPU
     */
    retval = prm80_transaction(rig, "0", NULL, 1);

    if (retval != RIG_OK)
    {
        return retval;
    }

    prm80_force_cache_timeout(rig);

    return RIG_OK;
}

/*
 * Convert freq in Hz to the RX PLL value representation with PRM08 firmware
 */
static unsigned rx_freq_to_pll_value(freq_t rx_freq)
{
    // UHF vs VHF
    if (rx_freq > MHz(300))
    {
        return (unsigned)((rx_freq - RX_IF_OFFSET) / FREQ_DIV);
    }
    else
    {
        return (unsigned)((rx_freq + RX_IF_OFFSET) / FREQ_DIV);
    }
}

static freq_t pll_value_to_rx_freq(unsigned pll_value)
{
    freq_t rx_freq;

    rx_freq = (freq_t)pll_value * FREQ_DIV;

    // UHF vs VHF
    if (rx_freq > MHz(300))
    {
        rx_freq += RX_IF_OFFSET;
    }
    else
    {
        rx_freq -= RX_IF_OFFSET;
    }

    return rx_freq;
}

/*
 * Set RX and TX freq
 *
 * See https://github.com/f4fez/prm80/blob/master/doc/Computer_control.md
 *   "Adding a new channel" regarding freq format.
 */
int prm80_set_rx_tx_freq(RIG *rig, freq_t rx_freq, freq_t tx_freq)
{
    struct rig_state *rs = &rig->state;
    char rx_freq_buf[BUFSZ];
    char tx_freq_buf[BUFSZ];
    int rc;

    // for RX, compute the PLL word without the IF
    SNPRINTF(rx_freq_buf, sizeof(rx_freq_buf), "%04X",
             rx_freq_to_pll_value(rx_freq));
    SNPRINTF(tx_freq_buf, sizeof(tx_freq_buf), "%04X",
             (unsigned)(tx_freq / FREQ_DIV));

    // The protocol is like this :
    // "RX frequency : " XXXX
    // CRLF"TX frequency : " XXXX

    rc = prm80_transaction(rig, "R", rx_freq_buf, 0);

    if (rc != RIG_OK)
    {
        return rc;
    }

    // There's a second line to process after prm80_transaction()
    rc = read_colon_prompt_and_send(&rs->rigport, NULL, NULL, tx_freq_buf);

    if (rc != RIG_OK)
    {
        return rc;
    }

    // quid timeout in trx waiting for freq ?

    // NB: the [R] command does not update the checksum of the RAM!

    prm80_wait_for_prompt(&rs->rigport);

    return rc;
}

/*
 * Set (RX) freq
 */
int prm80_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    freq_t tx_freq;
    int rc;

    if (priv->split == RIG_SPLIT_OFF)
    {
        tx_freq = freq;
    }
    else
    {
        tx_freq = (priv->tx_freq == 0.) ? freq : priv->tx_freq;
    }

    rc = prm80_set_rx_tx_freq(rig, freq, tx_freq);

    if (rc == RIG_OK)
    {
        priv->rx_freq = freq;
    }

    prm80_force_cache_timeout(rig);

    return rc;
}

/*
 * Set TX freq depending on emulated split state
 */
int prm80_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    freq_t rx_freq;
    int rc;

    rx_freq = (priv->rx_freq == 0.) ? tx_freq : priv->rx_freq;

    rc = prm80_set_rx_tx_freq(rig, rx_freq, tx_freq);

    if (rc == RIG_OK)
    {
        priv->tx_freq = tx_freq;
    }

    prm80_force_cache_timeout(rig);

    return rc;
}

/*
 * Get RX freq depending on emulated split state
 */
int prm80_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    int ret;
    channel_t chan;

    memset(&chan, 0, sizeof(chan));
    chan.vfo = RIG_VFO_CURR;

    ret = prm80_get_channel(rig, vfo, &chan, 0);

    if (ret != RIG_OK)
    {
        return ret;
    }

    *freq = chan.freq;
    priv->tx_freq = chan.tx_freq;

    return RIG_OK;
}

/*
 * Enable/disable Split
 *
 * Rem: don't care about vfo
 */
int prm80_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;

    priv->split = split;

    return RIG_OK;
}

/*
 * Get Split
 */
int prm80_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;

    *split = priv->split;
    *tx_vfo = RIG_VFO_CURR;

    return RIG_OK;
}

/*
 * Get TX freq
 */
int prm80_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    int ret;
    channel_t chan;

    memset(&chan, 0, sizeof(chan));
    chan.vfo = RIG_VFO_CURR;

    ret = prm80_get_channel(rig, vfo, &chan, 0);

    if (ret != RIG_OK)
    {
        return ret;
    }

    *tx_freq = chan.tx_freq;
    priv->rx_freq = chan.freq;

    return RIG_OK;
}

/*
 * Basic helper to ease some generic applications
 */
int prm80_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
    // Can only do FM
    *mode = RIG_MODE_FM;
    *width = rig_passband_normal(rig, *mode);

    return RIG_OK;
}


/*
 * prm80_set_mem
 * Assumes rig!=NULL
 */
int prm80_set_mem(RIG *rig, vfo_t vfo, int ch)
{
    char chbuf[BUFSZ];

    /* [N] = Set current channel. */

    if (ch < CHAN_MIN || ch > CHAN_MAX)
    {
        return -RIG_EINVAL;
    }

    SNPRINTF(chbuf, sizeof(chbuf), "%02u", (unsigned)ch);

    prm80_force_cache_timeout(rig);

    // Send command, no answer expected from rig except ">" prompt

    return prm80_transaction(rig, "N", chbuf, 1);
}

/*
 * prm80_get_mem
 * Assumes rig!=NULL
 */
int prm80_get_mem(RIG *rig, vfo_t vfo, int *ch)
{
    int ret;
    channel_t chan;

    memset(&chan, 0, sizeof(chan));
    chan.vfo = RIG_VFO_CURR;

    ret = prm80_get_channel(rig, vfo, &chan, 0);

    if (ret != RIG_OK)
    {
        return ret;
    }

    *ch = chan.channel_num;

    return RIG_OK;
}

/*
 * Convert first two hexadecimal digit to integer
 */
static unsigned hhtoi(const char *p)
{
    char buf[4];

    // it has to be hex digits
    if (!isxdigit(p[0]) || !isxdigit(p[1]))
    {
        rig_debug(RIG_DEBUG_ERR, "%s: unexpected content '%s'\n", __func__, p);
        return 0;
    }

    buf[0] = p[0];
    buf[1] = p[1];
    buf[2] = '\0';

    return (unsigned)strtol(buf, NULL, 16);
}

/**
 * Get system state [E] from rig into \a statebuf
 */
static int prm80_do_read_system_state(hamlib_port_t *rigport, char *statebuf)
{
    char *p;
    int ret;

    // Get rid of possible prompt sent by the rig
    rig_flush(rigport);

    /* [E] = Show system state */
    ret = write_block(rigport, (unsigned char *) "E", 1);

    if (ret < 0)
    {
        return (ret);
    }

    // The response length is fixed
    ret = read_block(rigport, (unsigned char *) statebuf, CMD_E_RSP_LEN);

    if (ret < 0)
    {
        return ret;
    }

    if (ret >= 0)
    {
        statebuf[ret] = '\0';
    }

    if (ret < CMD_E_RSP_LEN)
    {
        rig_debug(RIG_DEBUG_ERR, "%s: len=%d < %d, statebuf='%s'\n", __func__,
                  ret, CMD_E_RSP_LEN, statebuf);
        return (-RIG_EPROTO);
    }

    p = strchr(statebuf, '>');

    if (p)
    {
        int left_to_read = (p - statebuf) + 1;
        memmove(statebuf, p + 1, CMD_E_RSP_LEN - left_to_read);
        ret = read_block(rigport,
                         (unsigned char *) statebuf + CMD_E_RSP_LEN - left_to_read,
                         left_to_read);

        if (ret < 0)
        {
            return ret;
        }
        else
        {
            statebuf[CMD_E_RSP_LEN] = '\0';
        }

        rig_debug(RIG_DEBUG_WARN, "%s: len=%d, statebuf='%s'\n", __func__, ret,
                  statebuf);
    }

    prm80_wait_for_prompt(rigport);

    return RIG_OK;
}

/*
 * Layer to handle the cache to Get system state [E]
 */
static int prm80_read_system_state(RIG *rig, char *statebuf)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    int ret = RIG_OK;

    if (rig_check_cache_timeout(&priv->status_tv, PRM80_CACHE_TIMEOUT))
    {
        ret = prm80_do_read_system_state(&rig->state.rigport, statebuf);

        if (ret == RIG_OK)
        {
            strcpy(priv->cached_statebuf, statebuf);

            /* update cache date */
            gettimeofday(&priv->status_tv, NULL);
        }
    }
    else
    {
        strcpy(statebuf, priv->cached_statebuf);
    }

    return ret;
}

/*
 * prm80_get_channel
 * Assumes rig!=NULL
 */
int prm80_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    char statebuf[BUFSZ];
    int ret, chanstate, mode_byte, lock_byte;

    if (chan->vfo == RIG_VFO_MEM)
    {
        ret = prm80_set_mem(rig, RIG_VFO_CURR, chan->channel_num);

        if (ret != RIG_OK)
        {
            return ret;
        }
    }

    ret = prm80_read_system_state(rig, statebuf);

    if (ret != RIG_OK)
    {
        return ret;
    }

    /* (Mode-Chan-Chanstate-Sql-Vol-Lock-RX freq-TX freq-RSSI). */
    /* Examples: 1240080AFF0033F02D40__ or 14000C00FD0079708020__ */

    /* Current mode:
       ; b0: Squelch       b1: power
       ; b2: Squelch open  b3: TX
       ; b4: PLL locked    b5: Long press memorize
       ; b6: Debouncing in effect b7: LCD refresh
      */
    mode_byte = hhtoi(statebuf);

    chan->mode = RIG_MODE_FM;
    chan->width = rig_passband_normal(rig, chan->mode);
    chan->channel_num = hhtoi(statebuf + 2);
    chan->tx_mode = chan->mode;
    chan->tx_width = chan->width;

    /* Chan state:
       ; b0: shift enabled   b1: reverse
       ; b2: shift +         b3: lock out
     */
    chanstate = hhtoi(statebuf + 4) & 0x0f;
    /* is it rptr_shift or split mode ? */
    chan->rptr_shift = (chanstate & 0x01) == 0 ? RIG_RPT_SHIFT_NONE :
                       (chanstate & 0x02) ? RIG_RPT_SHIFT_MINUS :
                       (chanstate & 0x04) ? RIG_RPT_SHIFT_PLUS : RIG_RPT_SHIFT_NONE;
    chan->flags = (chanstate & 0x08) ? RIG_CHFLAG_SKIP : 0;

    // squelch is in low nibble
    chan->levels[LVL_SQL].f = ((float)(hhtoi(statebuf + 6) & 0x0F)) / 15.;
    // volume is hex "00" .. "10"
    chan->levels[LVL_AF].f  = ((float)hhtoi(statebuf + 8)) / 16.;
    chan->levels[LVL_RFPOWER].f  = (mode_byte & 0x02) ? 1.0 : 0.0;

    // new in FW V5
    chan->levels[LVL_RAWSTR].i = hhtoi(statebuf + 20);

    chan->funcs  = 0;
    chan->funcs |= (chanstate & 0x02) ? RIG_FUNC_REV : 0;

    lock_byte = hhtoi(statebuf + 10) & 0x0f;
    chan->funcs |= (lock_byte & 0x05) ? RIG_FUNC_LOCK : 0;
    chan->funcs |= (lock_byte & 0x08) ? RIG_FUNC_MUTE : 0;

    chan->freq = pll_value_to_rx_freq((hhtoi(statebuf + 12) << 8) + hhtoi(
                                          statebuf + 14));
    chan->tx_freq = ((hhtoi(statebuf + 16) << 8) + hhtoi(statebuf + 18)) * FREQ_DIV;

    if (chan->rptr_shift != RIG_RPT_SHIFT_NONE)
    {
        chan->rptr_offs = chan->tx_freq - chan->freq;
        chan->split = RIG_SPLIT_OFF;
    }
    else
    {
        chan->rptr_offs = 0;
        chan->split = priv->split; // RIG_SPLIT_ON; ?
    }

    if (!read_only)
    {
        // Set rig to channel values
        rig_debug(RIG_DEBUG_WARN,
                  "%s: please contact hamlib mailing list to implement this\n", __func__);
        rig_debug(RIG_DEBUG_WARN,
                  "%s: need to know if rig updates when channel read or not\n", __func__);
        //return -RIG_ENIMPL;
    }

    return RIG_OK;
}

/*
 * prm80_set_channel handles RIG_VFO_MEM and RIG_VFO_CURR
 */
int prm80_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
    struct prm80_priv_data *priv = (struct prm80_priv_data *)rig->state.priv;
    struct rig_state *rs = &rig->state;
    char buf[BUFSZ];
    int ret, chanstate;
    freq_t tx_freq;

    if (chan->vfo == RIG_VFO_MEM)
    {
        // setting channel without calling set_mem()

        if (chan->channel_num < CHAN_MIN || chan->channel_num > CHAN_MAX)
        {
            return -RIG_EINVAL;
        }

        /* [P] = Edit/Add channel */
        /* Example
           Channel to set : 00
           PLL value to load : $8020
           Channel state : $00

          Possibly:
            "This channel number doesn't exist. Add new channel (Y/N) ? "
           */

        SNPRINTF(buf, sizeof(buf), "%02u", (unsigned)chan->channel_num);

        ret = prm80_transaction(rig, "P", buf, 0);

        if (ret != RIG_OK)
        {
            return ret;
        }

        // Set the RX frequency as PLL word.
        SNPRINTF(buf, sizeof(buf), "%04X", rx_freq_to_pll_value(chan->freq));

        // "PLL value to load : $"
        ret = read_dollar_prompt_and_send(&rs->rigport, NULL, NULL, buf);

        if (ret != RIG_OK)
        {
            return ret;
        }

        // the channel status byte.
        switch (chan->rptr_shift)
        {
        case RIG_RPT_SHIFT_NONE : chanstate = 0x00; break;

        case RIG_RPT_SHIFT_MINUS : chanstate = 0x03; break;

        case RIG_RPT_SHIFT_PLUS : chanstate = 0x05; break;

        default: chanstate = 0x00; break;
        }

        chanstate |= (chan->flags & RIG_CHFLAG_SKIP) ? 0x08 : 0;

        SNPRINTF(buf, sizeof(buf), "%02X", chanstate);

        // "Channel state : $"
        ret = read_dollar_prompt_and_send(&rs->rigport, NULL, NULL, buf);

        if (ret != RIG_OK)
        {
            return ret;
        }

        // Determine if prompt came back (CRLF'>') or have to
        // handle the possible query from the rig:
        // "This channel number doesn't exist. Add new channel (Y/N) ? "
        ret = read_block(&rs->rigport, (unsigned char *) buf, 3);

        if (ret < 0)
        {
            RETURNFUNC(ret);
        }

        if (ret == 3 && buf[2] == 'T')
        {
            // Read the question
            ret = read_string(&rs->rigport, (unsigned char *) buf, sizeof(buf), "?", 1, 0,
                              1);

            if (ret < 0)
            {
                RETURNFUNC(ret);
            }

            // Read extra space
            ret = read_block(&rs->rigport, (unsigned char *) buf, 1);

            if (ret < 0)
            {
                RETURNFUNC(ret);
            }

            // Send confirmation
            ret = write_block(&rs->rigport, (unsigned char *) "Y", 1);

            if (ret < 0)
            {
                RETURNFUNC(ret);
            }
        }

        prm80_wait_for_prompt(&rs->rigport);
    }
    else
    {
        // assume here chan->vfo == RIG_VFO_CURR
        // that is the "RAM" VFO not backed by memory

        tx_freq = (chan->split == RIG_SPLIT_ON) ? chan->tx_freq : chan->freq;

        ret = prm80_set_rx_tx_freq(rig, chan->freq, tx_freq);

        if (ret != RIG_OK)
        {
            return ret;
        }

        priv->split = chan->split;
        priv->rx_freq = chan->freq;
        priv->tx_freq = tx_freq;

        ret = prm80_set_level(rig, vfo, RIG_LEVEL_SQL, chan->levels[LVL_SQL]);

        if (ret != RIG_OK)
        {
            return ret;
        }

        ret = prm80_set_level(rig, vfo, RIG_LEVEL_AF, chan->levels[LVL_AF]);

        if (ret != RIG_OK)
        {
            return ret;
        }

#if 0
        // Not implemented yet..
        ret = prm80_set_level(rig, vfo, RIG_LEVEL_RFPOWER, chan->levels[LVL_RFPOWER]);

        if (ret != RIG_OK)
        {
            return ret;
        }

#endif

        ret = prm80_set_func(rig, vfo, RIG_FUNC_LOCK,
                             !!(chan->funcs & RIG_FUNC_LOCK));

        if (ret != RIG_OK)
        {
            return ret;
        }
    }

    prm80_force_cache_timeout(rig);

    return RIG_OK;
}


// TODO FUNC_REV through Channel state byte ?
// TODO "Read-Modify-Write" (or shadowing in priv area) of the lock bits
int prm80_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
    int ret;

    if (func & RIG_FUNC_LOCK)
    {
        /* Lock keys(b0)/Vol(b2) */
        ret = prm80_transaction(rig, "K", (status != 0) ? "05" : "00", 1);
    }
    else if (func & RIG_FUNC_MUTE)
    {
        /* Lock RX(b3) */
        ret = prm80_transaction(rig, "K", (status != 0) ? "08" : "00", 1);
    }
    else
    {
        ret = -RIG_EINVAL;
    }

    prm80_force_cache_timeout(rig);

    return ret;
}

int prm80_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
    int ret;
    channel_t chan;

    memset(&chan, 0, sizeof(chan));
    chan.vfo = RIG_VFO_CURR;

    ret = prm80_get_channel(rig, vfo, &chan, 0);

    if (ret != RIG_OK)
    {
        return ret;
    }

    *status = !!(chan.funcs & func);

    return RIG_OK;
}

/*
 * prm80_set_level
 * Assumes rig!=NULL
 */
int prm80_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
    char buf[BUFSZ];
    int ret, mode_byte;

    // do some clamping, all levels are float values.
    if (val.f < 0.0)
    {
        val.f = 0.0;
    }
    else if (val.f > 1.0)
    {
        val.f = 1.0;
    }

    switch (level)
    {
    case RIG_LEVEL_AF:
        // Unlike system state, volume decimal
        SNPRINTF(buf, sizeof(buf), "%02u", (unsigned)(val.f * 16));

        return prm80_transaction(rig, "O", buf, 1);

    case RIG_LEVEL_SQL:
        SNPRINTF(buf, sizeof(buf), "%02u", (unsigned)(val.f * 15));

        return prm80_transaction(rig, "F", buf, 1);

    case RIG_LEVEL_RFPOWER:
        /* Current mode:
           ; b0: Squelch       b1: power
           ; b2: Squelch open  b3: TX
           ; b4: PLL locked    b5: Long press memorize
           ; b6: Debouncing in effect b7: LCD refresh
           */
        // Perform a "Read-Modify-Write" of the mode_byte
        ret = prm80_read_system_state(rig, buf);

        if (ret != RIG_OK)
        {
            return ret;
        }

        mode_byte  = hhtoi(buf);
        mode_byte &= ~0x02;
        mode_byte |= (val.f == 0.) ? 0 : 0x02;
        SNPRINTF(buf, sizeof(buf), "%02X", (unsigned)mode_byte);

        return prm80_transaction(rig, "D", buf, 1);

    default:
        rig_debug(RIG_DEBUG_ERR, "%s: unsupported set_level %s\n", __func__,
                  rig_strlevel(level));
        return -RIG_EINVAL;
    }

    prm80_force_cache_timeout(rig);

    return RIG_OK;
}

#ifdef V4_ONLY
/*
 * get_level RIG_LEVEL_RAWSTR
 */
static int prm80_get_rawstr_RAM(RIG *rig, value_t *val)
{
    char buf[BUFSZ];
    struct rig_state *rs = &rig->state;
    int ret, i;

    /* [U] = Print 80c552 internal RAM. */

    // Send cmd, Wait for colon prompt, but then send nothing
    ret = prm80_transaction(rig, "U", "", 0);

    if (ret < 0)
    {
        return ret;
    }

    // Read CRLF
    ret = read_string(&rs->rigport, buf, BUFSZ, "\n", 1, 0, 1);

    if (ret < 0)
    {
        return ret;
    }

    // (16 lines of 16 bytes each)

    // According to prm.a51, the rssi_hold variable is in RAM at RAM+35.
    // The RAM base is at 030h.

#define RSSI_HOLD_ADDR (0x30 + 35)  // = 0x53

    for (i = 0; i < (RSSI_HOLD_ADDR / 16) + 1; i++)
    {
        ret = read_string(&rs->rigport, buf, BUFSZ, "\n", 1, 0, 1);

        if (ret < 0)
        {
            return ret;
        }
    }

    // A line looks like this
    // "$50 : 00 01 02 53 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\r\n"

    val->i = hhtoi(buf + 6 + 3 * (RSSI_HOLD_ADDR % 16));

    // discard the remaining content of RAM print
    for (i = 0; i < (16 - RSSI_HOLD_ADDR / 16) - 1; i++)
    {
        read_string(&rs->rigport, buf, BUFSZ, "\n", 1, 0, 1);
    }

    prm80_wait_for_prompt(&rs->rigport);

    return RIG_OK;
}
#endif

/*
 * prm80_get_level
 * Assumes rig!=NULL
 */
int prm80_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
    int ret;
    channel_t chan;

    memset(&chan, 0, sizeof(chan));
    chan.vfo = RIG_VFO_CURR;

    ret = prm80_get_channel(rig, vfo, &chan, 0);

    if (ret != RIG_OK)
    {
        return ret;
    }

    switch (level)
    {
    case RIG_LEVEL_RAWSTR:
        val->i = chan.levels[LVL_RAWSTR].i;

        break;

    case RIG_LEVEL_AF:
        val->f = chan.levels[LVL_AF].f;

        break;

    case RIG_LEVEL_SQL:
        val->f = chan.levels[LVL_SQL].f;

        break;

    case RIG_LEVEL_RFPOWER:
        val->f = chan.levels[LVL_RFPOWER].f;

        break;

    default:
        rig_debug(RIG_DEBUG_ERR, "%s: unsupported set_level %s\n", __func__,
                  rig_strlevel(level));
        return -RIG_EINVAL;
    }

    return RIG_OK;
}

int prm80_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
    char statebuf[BUFSZ];
    int ret, mode_byte;

    ret = prm80_read_system_state(rig, statebuf);

    if (ret != RIG_OK)
    {
        return ret;
    }

    mode_byte = hhtoi(statebuf);

    // TX mode on?
    *ptt = (mode_byte & 0x08) ? RIG_PTT_ON : RIG_PTT_OFF;

    return RIG_OK;
}

int prm80_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
    char statebuf[BUFSZ];
    int ret, mode_byte;

    ret = prm80_read_system_state(rig, statebuf);

    if (ret != RIG_OK)
    {
        return ret;
    }

    mode_byte = hhtoi(statebuf);

    // Squelch open?
    *dcd = (mode_byte & 0x04) ? RIG_DCD_ON : RIG_DCD_OFF;

    return RIG_OK;
}

// TODO vfo_op : MCL FROM_VFO ..

/*
 * prm80_get_info
 * Assumes rig!=NULL
 */
const char *prm80_get_info(RIG *rig)
{
    static char s_buf[BUFSZ];
    struct rig_state *rs = &rig->state;
    char *p;
    int ret;

    // Get rid of possible prompt sent by the rig
    rig_flush(&rs->rigport);

    /* [V] = Print firmware version. */
    ret = write_block(&rs->rigport, (unsigned char *) "V", 1);

    if (ret < 0)
    {
        return NULL;
    }

    ret = read_string(&rs->rigport, (unsigned char *) s_buf, BUFSZ, ">", 1, 0, 1);

    if (ret < 0)
    {
        return NULL;
    }

    p = strchr(s_buf, '\r');

    if (p)
    {
        // chomp
        *p = '\0';
    }

    return s_buf;
}


/*
 * initrigs_prm80 is called by rig_backend_load
 */
DECLARE_INITRIG_BACKEND(prm80)
{
    rig_debug(RIG_DEBUG_VERBOSE, "%s: _init called\n", __func__);

    rig_register(&prm8060_caps);

    return RIG_OK;
}