CHIRP

# melvin.terechenok@gmail.com

# modify for KG-UV980P using KG-935G, KG-UV8H, KG-UV920P drivers as resources

# Copyright 2019 Pavel Milanes CO7WT <pavelmc@gmail.com>

#

# Based on the work of Krystian Struzik <toner_82@tlen.pl>

# who figured out the crypt used and made possible the

# Wuoxun KG-UV8D Plus driver, in which this work is based.

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""Wouxun KG-UV980P radio management module"""

from pickle import FALSE, TRUE

import time

import os

import logging

from chirp import util, chirp_common, bitwise, memmap, errors, directory

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueBoolean, RadioSettingValueList, \

    RadioSettingValueInteger, RadioSettingValueString, \

    RadioSettingValueFloat, RadioSettingValueMap, RadioSettings

LOG = logging.getLogger(__name__)

CMD_ID = 128    # \x80

CMD_END = 129   # \x81

CMD_RD = 130    # \x82

CMD_WR = 131    # \x83

MEM_VALID = 0x00

TX_BLANK = 0x40

RX_BLANK = 0x80

CHARSET_NUMERIC = "0123456789"

CHARSET = "0123456789" + \

          ":;<=>?@" + \

          "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + \

          "[\]^_`" + \

          "abcdefghijklmnopqrstuvwxyz" + \

          "{|}~\x4E" + \

          " !\"#$%&'()*+,-./"

SCANNAME_CHARSET = "0123456789" + \

          ":;<=>?@" + \

          "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + \

          "[\]^_`" + \

          "abcdefghijklmnopqrstuvwxyz" + \

          "{|}~\x4E" + \

          " !\"#$%&'()*+,-./"

MUTE_MODE_MAP = [('QT',      0b01),

                 ('QT*DTMF', 0b10),

                 ('QT+DTMF', 0b11)]

STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 30.0, 50.0, 100.0]

STEP_LIST = [str(x) for x in STEPS]

SQL_LIST = [int(i) for i in range(0, 10)]

M_POWER_MAP = [('1 = 20W', 1),

               ('2 = 10W', 2)]

ROGER_LIST = ["Off", "BOT", "EOT", "Both"]

VOICE_LIST = ["Off", "Chinese", "English"]

SC_REV_MAP = [('Timeout (TO)',  1),

              ('Carrier (CO)',  2),

              ('Stop (SE)',     3)]

TOT_MAP = [('%d min' % i, int('%02d' % i, 10)) for i in range(1, 61)]

TOA_LIST = ["Off", "1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s", "10s"]

RING_LIST = ["Off", "1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s", "10s"]

DTMF_ST_LIST = ["Off", "DT-ST", "ANI-ST", "DT+ANI"]

PTT_ID_LIST = ["BOT", "EOT", "Both"]

PTT_ID_MAP = [('BOT',  1),

              ('EOT',  2),

              ('Both', 3)]

BACKLIGHT_LIST = ["Off", "Red", "Orange", "Green"]

SPEAKER_MAP = [('SPK_1',   1),

               ('SPK_2',   2),

               ('SPK_1+2', 3)]

RPT_MODE_LIST = ["Radio", "X-DIRPT", "X-TWRPT", "RPT-RX", "T-W RPT"]

APO_TIME_LIST = ["Off", "30", "60", "90", "120", "150"]

ALERT_MAP = [('1750', 1),

             ('2100', 2),

             ('1000', 3),

             ('1450', 4)]

FAN_MODE_LIST = ["TX", "Hi-Temp/TX", "Always"]

SCAN_GROUP_LIST = ["All"] + ["%s" % x for x in range(1, 11)]

WORKMODE_MAP = [('VFO',             1),

                ('Ch. No.',         2),

                ('Ch. No.+Freq.',   3),

                ('Ch. No.+Name',    4)]

VFOBAND_MAP = [("150M",0),

               ("450M",1),

               ("20M",2),

               ("50M",3),

               ("350M",4),

               ("850M",5)]              

AB_LIST = ["A", "B"]

POWER_MAP = [('Low', 0),

             ('Med', 1),

             ('Med2', 2),

             ('High', 3)]

BANDWIDTH_MAP = [('Narrow', 1),

                 ('Wide',  0)]

SCRAMBLER_LIST = ["Off", "1", "2", "3", "4", "5", "6", "7", "8"]

ANS_LIST = ["Off", "Normal", "Strong"]

DTMF_TIMES = [str(x) for x in range(80, 501, 20)]

DTMF_INTERVALS = [str(x) for x in range(60, 501, 20)]

ROGER_TIMES = [str(x) for x in range(20, 1001, 20)]

PTT_ID_DELAY_MAP = [(str(x), x/100) for x in range(100, 1001, 100)]

ROGER_INTERVALS = ROGER_TIMES

TONE_MAP = [('Off', 0x0000)] + \

           [('%.1f' % tone, int(tone * 10)) for tone in chirp_common.TONES] + \

           [('DN%d' % tone, int(0x8000 + tone))

               for tone in chirp_common.DTCS_CODES] + \

           [('DI%d' % tone, int(0xC000 + tone))

               for tone in chirp_common.DTCS_CODES]

DUPLEX_LIST = ["Off", "Plus", "Minus"]

SC_QT_MAP = [("Decoder - Rx QT/DT MEM", 1), ("Encoder- Tx QT/DT MEM", 2),

             ("All- RxTx QT/DT MEM", 3)]

HOLD_TIMES = ["Off"] + ["%s" % x for x in range(100, 5001, 100)]

PF1_SETTINGS = ["Off", "Stun", "Kill", "Monitor", "Inspection"]

ABR_LIST = ["Always", "1", "2", "3", "4", "5", "6", "7", "8",

            "9", "10", "11", "12", "13", "14", "15", "16", "17",

            "18", "19", "20", "Off"]

KEY_LIST =["Off", "B/SW", "MENCH", "H-M-L", "VFO/MR", "SET-D", "TDR",

           "SQL", "SCAN", "FM-Radio", "Scan CTCSS", "Scan DCS"]

RC_POWER_LIST = ["RC Stop", "RC Open"]

ACTIVE_AREA_LIST = ["Area A - Left", "Area B - Right"]

TDR_LIST = ["TDR ON", "TDR OFF"]

# memory slot 0 is not used, start at 1 (so need 1000 slots, not 999)

# structure elements whose name starts with x are currently unidentified

_MEM_FORMAT = """

    #seekto 0x004c;

    struct {

        u24 mode_psw;

        u8  xunk04F;

        u8  display_name[8];

    } oem;

    #seekto 0x0060;

    struct {

        u16    limit_144M_ChA_rx_start;

        u16    limit_144M_ChA_rx_stop;    

        u16    limit_70cm_rx_start;

        u16    limit_70cm_rx_stop;    

        u16    limit_10m_rx_start;

        u16    limit_10m_rx_stop;    

        u16    limit_6m_rx_start;

        u16    limit_6m_rx_stop;    

        u16    limit_350M_rx_start;

        u16    limit_350M_rx_stop;    

        u16    limit_850M_rx_start;

        u16    limit_850M_rx_stop;    

        u16    limit_144M_ChA_tx_start;

        u16    limit_144M_ChA_tx_stop;    

        u16    limit_70cm_tx_start;

        u16    limit_70cm_tx_stop;    

        u16    limit_10m_tx_start;

        u16    limit_10m_tx_stop;    

        u16    limit_6m_tx_start;

        u16    limit_6m_tx_stop;    

        u16    limit_144M_ChB_rx_start;

        u16    limit_144M_ChB_rx_stop;

    } bandlimits;

    #seekto 0x0740;

    struct {

        u16    FM_radio1;

        u16    FM_radio2;

        u16    FM_radio3;

        u16    FM_radio4;

        u16    FM_radio5;

        u16    FM_radio6;

        u16    FM_radio7;

        u16    FM_radio8;

        u16    FM_radio9;

        u16    FM_radio10;

        u16    FM_radio11;

        u16    FM_radio12;

        u16    FM_radio13;

        u16    FM_radio14;

        u16    FM_radio15;

        u16    FM_radio16;

        u16    FM_radio17;

        u16    FM_radio18;

        u16    FM_radio19;

        u16    FM_radio20;

        u16    FM_radio21;

        u16    FM_radio22;

        u8  x76c_pad[196];

        u32  vfofreq1;     // 0x0830

        u32  vfoofst1;

        u16  txtone1;

        u16  rxtone1;

        u8  xunk83C_1:3,

            mute1:2,

            xunk83C_2:3;

        u8  xunk83d_1:1,

            xunk83d_2:1,

            xunk83d_3:1,

            power1:2,

            am_mode1:1,

            xunk83d_7:1,

            narrow1:1;

        u8  xunk83e:6,

            shft_dir1:2;

        u8  xunk83F:3,

            compander1:1,

            scrambler1:4;

        u32  vfofreq2;

        u32  vfoofst2;

        u16  txtone2;

        u16  rxtone2;

        u8  xunk84C_1:3,

            mute2:2,

            xunk84C_2:3;

        u8  xunk84d_1:1,

            xunk84d_2:1,

            xunk84d_3:1,

            power2:2,

            am_mode2:1,

            xunk84d_7:1,

            narrow2:1;

        u8  xunk84e:6,

            shft_dir2:2;

        u8  xunk84F:3,

            compander2:1,

            scrambler2:4;

        u32  vfofreq3;

        u32  vfoofst3;

        u16  txtone3;

        u16  rxtone3;

        u8  xunk85C_1:3,

            mute3:2,

            xunk85C_2:3;

        u8  xunk85d_1:1,

            xunk85d_2:1,

            xunk85d_3:1,

            power3:2,

            am_mode3:1,

            xunk85d_7:1,

            narrow3:1;

        u8  xunk85e:6,

            shft_dir3:2;

        u8  xunk85F:3,

            compander3:1,

            scrambler3:4;

        u32  vfofreq4;

        u32  vfoofst4;

        u16  txtone4;

        u16  rxtone4;

        u8  xunk86C_1:3,

            mute4:2,

            xunk86C_2:3;

        u8  xunk86d_1:1,

            xunk86d_2:1,

            xunk86d_3:1,

            power4:2,

            am_mode4:1,

            xunk86d_7:1,

            narrow4:1;

        u8  xunk86e:6,

            shft_dir4:2;

        u8  xunk86F:3,

            compander4:1,

            scrambler4:4;

        u32  vfofreq5;

        u32  vfoofst5;

        u16  txtone5;

        u16  rxtone5;

        u8  xunk87C_1:3,

            mute5:2,

            xunk87C_2:3;

        u8  xunk87d_1:1,

            xunk87d_2:1,

            xunk87d_3:1,

            power5:2,

            am_mode5:1,

            xunk87d_7:1,

            narrow5:1;

        u8  xunk87e:6,

            shft_dir5:2;

        u8  xunk87F:3,

            compander5:1,

            scrambler5:4;

        u32  vfofreq6;

        u32  vfoofst6;

        u16  txtone6;

        u16  rxtone6;

        u8  xunk88C_1:3,

            mute6:2,

            xunk88C_2:3;

        u8  xunk88d_1:1,

            xunk88d_2:1,

            xunk88d_3:1,

            power6:2,

            am_mode6:1,

            xunk88d_7:1,

            narrow6:1;

        u8  xunk88e:6,

            shft_dir6:2;

        u8  xunk8F:3,

            compander6:1,

            scrambler6:4;

        u32  vfofreq7;

        u32  vfoofst7;

        u16  txtone7;

        u16  rxtone7;

        u8  xunk89C_1:3,

            mute7:2,

            xunk89C_2:3;

        u8  xunk89d_1:1,

            xunk89d_2:1,

            xunk89d_3:1,

            power7:2,

            am_mode7:1,

            xunk89d_7:1,

            narrow7:1;

        u8  xunk89e:6,

            shft_dir7:2;

        u8  xunk89F:3,

            compander7:1,

            scrambler7:4;

        u8  x8a0;

        u16  vfochan_a;

        u8  x8a3;

        u16  vfochan_b;

        u16  pri_ch;

        u8  x8a8;

        u8  x8a9;

        u8  scan_a_act;

        u8  scan_b_act;

        u8  m_pwr;

        u8  hold_time_rpt;

        u8  spk_cont;

        u8  x8af;

        u8  rc_power;

        u8  voice;

        u8  tot;

        u8  toa;

        u8  roger;

        u8  sc_rev;

        u8  dtmfsf;

        u8  ptt_id;

        u8  ring;

        u8  ani_sw;

        u8  rc_sw;

        u8  alert;

        u8  bcl_a;

        u8  prich_sw;

        u8  x8bE;

        u8  ptt_id_dly; 

        u8  menu;

        u8  x8c1;

        u8  beep;

        u8  x8c3;

        u8  x8c4;

        u8  tx_led;

        u8  wt_led;

        u8  rx_led;

        u8  act_area;

        u8  vfomode_a;

        u8  vfomode_b;

        u8  vfosquelch_a;

        u8  vfosquelch_b;

        u8  vfostep_a;

        u8  vfostep_b;

        u8  tdr_off;

        u8  rpt_spk;

        u8  rpt_ptt;

        u8  autolock;

        u8  apo_time;

        u8  low_v;

        u8  fan;

        u8  rpt_set_model;

        u8  pf1_set;

        u8  auto_am;

        u8  dtmf_time;

        u8  dtmf_int;

        u8  bcl_b;

        u8  rpt_tone;

        u8  sc_qt;

        u8  vfoband_a;

        u8  x8dF;

        u24  ani_edit;

        u8  x8e3;

        u24  mcc_edit;

        u8  x8e7;

        u24  scc_edit;

        u8  x8eB;

        u24  ctrl_edit;

        u8  x8eF;

        u8  KeyA;

        u8  KeyB;

        u8  KeyC;

        u8  ABR;

        u8  x8f4;

        u8  x8f5;

        u8  x8f6;

        u8  x8f7;

        u8  x8f8;

        u8  x8f9;

        u8  x8fA;

        u8  x8fB;

        u8  x8fC;

        u8  x8fD;

        u8  x8fE;

        u8  x8fF;

        u16  FM_radio_cur_freq;

        u8  x902;

        u8  scan_det;

        u8  x904;

        u8  thr_vol_tx;

        u16  thr_vol_lvl;

        u8  x908;

        u8  x909;

        u8  x90A;

        u8  x90B;

        u8  x90C;

        u8  x90D;

        u8  x90E;

        u8  x90F;

        u8  x910pad[48];

        u16  scanlower1; // x940

        u16  scanupper1;

        u16  scanlower2;

        u16  scanupper2;

        u16  scanlower3;

        u16  scanupper3;

        u16  scanlower4;

        u16  scanupper4;

        u16  scanlower5;

        u16  scanupper5;

        u16  scanlower6;

        u16  scanupper6;

        u16  scanlower7;

        u16  scanupper7;

        u16  scanlower8;

        u16  scanupper8;

        u16  scanlower9;

        u16  scanupper9;

        u16  scanlower10;

        u16  scanupper10;

        char  scanname0[8]; // x968

        char  scanname1[8];

        char  scanname2[8];

        char  scanname3[8];

        char  scanname4[8];

        char  scanname5[8];

        char  scanname6[8];

        char  scanname7[8];

        char  scanname8[8];

        char  scanname9[8];

        char  scanname10[8];

     } settings;

    #seekto 0x09f0;

    struct {

        u32     rxfreq;

        u32     txfreq;

        u16     txtone;

        u16     rxtone;

        u8      unknown1:3,

                mute_mode:2,

                unknown2:3;

        u8      named:1,

                scan_add:1,

                extra_power_bit:1,

                power:2,

                am_mode:1,

                unknownbit2:1,

                isnarrow:1;

        u8      unknown3:6,

                Unknown4_shft_dir:2;

        u8      unknown5:3,

                compander:1

                scrambler:4;

    } memory[1000];

    #seekto 0x48f8;

    struct {

        u8    name[8];

    } names[1000];

    #seekto 0x6fff;

    u8          valid[1000];

    """

def _freq_decode(in_freq, bytes=4):

    out_freq = 0

    for i in range(bytes*2):

        out_freq += (in_freq & 0xF) * (10 ** i)

        in_freq = in_freq >> 4

    if bytes == 4:

        return out_freq * 10

    elif bytes == 2:

        return out_freq * 100000

def _freq_encode(in_freq, bytes=4):

    if bytes == 4:

        return int('%08d' % (in_freq / 10), 16)

    elif bytes == 2:

        return int('%04d' % (in_freq / 100000), 16)

def _oem_str_decode(in_str):

    out_str = ''

    stopchar = FALSE

    for c in in_str:

        if c !=0x50 and stopchar==FALSE:

            if chr(c+48) in chirp_common.CHARSET_ASCII:

                out_str+= chr(c+48)

        else:

            out_str+=''

            stopchar = TRUE

    return out_str

def _oem_str_encode(in_str):

    out_str = ''

    LOG.debug("OEM Input String = %s", in_str)

    for c in in_str:

        try:

            out_str += chr(int(ord(c))-48)

        except ValueError:

            pass

    while len(out_str) < 8:

        out_str += chr(0x50)

    LOG.debug("OEM Ouput String = %s", out_str)

    return out_str

def _str_decode(in_str):

    out_str = ''

    stopchar = FALSE

    for c in in_str:

        if c !=0x00 and stopchar==FALSE:

            if chr(c) in chirp_common.CHARSET_ASCII:

                out_str+= chr(c)

        else:

            out_str+=''

            stopchar = TRUE

    return out_str

def _str_encode(in_str):

    out_str = ''

    for c in in_str:

        try:

            out_str += chr(ord(c))

        except ValueError:

            pass

    while len(out_str) < 8:

        out_str += chr(0x00)

    if out_str == "        " or out_str == "":

        out_str = "\x00\x00\x00\x00\x00\x00\x00\x00"

    return out_str

def _chnum_decode(in_ch):

    return int(('%04x' % in_ch)[0:3])

def _chnum_encode(in_ch):

    return int('%03d0' % in_ch, 16)

# Support for the Wouxun KG-UV980P radio

# Serial coms are at 19200 baud

# The data is passed in variable length records

# Record structure:

#  Offset   Usage

#    0      start of record (\x7c)

#    1      Command (\x80 Identify \x81 End/Reboot \x82 Read \x83 Write)

#    2      direction (\xff PC-> Radio, \x00 Radio -> PC)

#    3      length of payload (excluding header/checksum) (n)

#    4      payload (n bytes)

#    4+n+1  checksum - only lower 4 bits of byte sum (% 256) of bytes 1 -> 4+n

#

# Memory Read Records:

# the payload is 3 bytes, first 2 are offset (big endian),

# 3rd is number of bytes to read

# Memory Write Records:

# the maximum payload size (from the Wouxun software) seems to be 66 bytes

#  (2 bytes location + 64 bytes data).

class KGUV8TRadio(chirp_common.Alias):

    VENDOR = "Wouxun"

    MODEL = "KG-UV980P"

@directory.register

class KG980GRadio(chirp_common.CloneModeRadio,

                  chirp_common.ExperimentalRadio):

    """Wouxun KG-UV980P"""

    VENDOR = "Wouxun"

    MODEL = "KG-UV980P"

    _model = "KG-UV950R2"

    _file_ident = "980P"

    BAUD_RATE = 19200

    POWER_LEVELS = [chirp_common.PowerLevel("L", watts=1.0), 

                    chirp_common.PowerLevel("M", watts=20.0), 

                    chirp_common.PowerLevel("H", watts=50.0)]

    _mmap = ""

    ALIASES = [KGUV8TRadio, ]

    def _checksum(self, data):

        cs = 0

        for byte in data:

            cs += ord(byte)

        return chr(cs % 256)

    # def _write_record_id(self):

	# _header = '\xda\x80\xff\x00\x58'

    #     LOG.error("Sent:\n%s" % util.hexprint(_header))

	# self.pipe.write(_header)

    def _write_record(self, cmd, payload=None):

        # build the packet

        _header = '\xda' + chr(cmd) + '\xff'

        _length = 0

        if payload:

            _length = len(payload)

        # update the length field

        _header += chr(_length)

        if payload:

            # calculate checksum then add it with the payload

            # to the packet and encrypt

            crc = self._checksum(_header[1:] + payload)

            # Checksum is only the lower 4 bits

            crc = chr(ord(crc) & 0xf)

            payload += crc

            _header += self.encrypt(payload)

        else:

            # calculate and add encrypted checksum to the packet

            crc = self._checksum(_header[1:])

            # Checksum is only the lower 4 bits

            crc = chr(ord(crc) & 0xf)

            _header += self.strxor(crc, '\x57')

        try:

            LOG.debug("Sent:\n%s" % util.hexprint(_header))

            self.pipe.write(_header)

        except Exception, e:

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def _read_record(self):

        # read 4 chars for the header

        _header = self.pipe.read(4)

        #LOG.debug("header = " % util.hexprint(_header))

        if len(_header) != 4:

            raise errors.RadioError('Radio did not respond- header length')

        _length = ord(_header[3])

        _packet = self.pipe.read(_length)

        _rcs_xor = _packet[-1]

        _packet = self.decrypt(_packet)

        _cs = ord(self._checksum(_header[1:] + _packet))

        # It appears the checksum is only 4bits

        _cs = _cs & 0xf

        # read the checksum and decrypt it 

        _rcs = ord(self.strxor(self.pipe.read(1), _rcs_xor))

        _rcs = _rcs & 0xf

        return (_rcs != _cs, _packet)

    def decrypt(self, data):

        result = ''

        for i in range(len(data)-1, 0, -1):

            result += self.strxor(data[i], data[i - 1])

        result += self.strxor(data[0], '\x57')

        return result[::-1]

    def encrypt(self, data):

        result = self.strxor('\x57', data[0])

        for i in range(1, len(data), 1):

            result += self.strxor(result[i - 1], data[i])

        return result

    def strxor(self, xora, xorb):

        return chr(ord(xora) ^ ord(xorb))

    # Identify the radio

    #

    # A Gotcha: the first identify packet returns a bad checksum, subsequent

    # attempts return the correct checksum... (well it does on my radio!)

    #

    # The ID record returned by the radio also includes the

    # current frequency range

    # as 4 bytes big-endian in 10Hz increments

    #

    # Offset

    #  0:10     Model, zero padded 

    @classmethod

    def match_model(cls, filedata, filename):

        id = cls._file_ident

        return cls._file_ident in filedata[0x426:0x430]

    def _identify(self):

        """Do the identification dance"""

        for _i in range(0, 3):

            LOG.debug("ID try #"+str(_i))

            self._write_record(CMD_ID)

            _chksum_err, _resp = self._read_record()

            if len(_resp) == 0:

                raise Exception("Radio not responding")

            else:

                LOG.debug("Got:\n%s" % util.hexprint(_resp))

                LOG.debug("Model received is %s" % _resp[0:10])

                LOG.debug("Model expected is %s" % self._model)

                if _chksum_err:

                    LOG.error("Checksum error: retrying ident...")

                    time.sleep(0.100)

                    continue

                else:

                    LOG.debug("checksum passed")

                    if _resp[0:8] == self._model[0:8]:

                        LOG.debug("Passed identify")

                        break

                    else:

                        LOG.debug("FAILED to identify") 

    def _finish(self):

        self._write_record(CMD_END)

    def process_mmap(self):

        self._memobj = bitwise.parse(_MEM_FORMAT, self._mmap)

    def sync_in(self):

        try:

            self._mmap = self._download()

        except errors.RadioError:

            raise

        except Exception, e:

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

    def sync_out(self):

        self._upload()

    # TODO: Load all memory.

    # It would be smarter to only load the active areas and none of

    # the padding/unused areas. Padding still need to be investigated.

    def _download(self):

        """Talk to a wouxun KG-UV980P and do a download"""

        try:

            self._identify()

            return self._do_download(0, 32768, 64)

        except errors.RadioError:

            raise

        except Exception, e:

            LOG.exception('Unknown error during download process')

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def _do_download(self, start, end, blocksize):

        # allocate & fill memory

        LOG.debug("Start Download")

        image = ""

        for i in range(start, end, blocksize):

            req = chr(i / 256) + chr(i % 256) + chr(blocksize)

            self._write_record(CMD_RD, req)

            cs_error, resp = self._read_record()

            LOG.debug("Got:\n%s" % util.hexprint(resp))

            if cs_error:

                LOG.debug(util.hexprint(resp))

                raise Exception("Checksum error on read")

            # LOG.debug("Got:\n%s" % util.hexprint(resp))

            image += resp[2:]

            if self.status_fn:

                status = chirp_common.Status()

                status.cur = i

                status.max = end

                status.msg = "Cloning from radio"

                self.status_fn(status)

        self._finish()

        return memmap.MemoryMap(''.join(image))

    def _upload(self):

        """Talk to a wouxun KG-UV980P and do a upload"""

        try:

            self._identify()

            LOG.debug("Done with Upload Identify")

            # self._do_upload(0, 1856, 16)

            # LOG.debug("Done with Limits Upload")

            # self._do_upload(1856, 32768, 64)

            self._do_upload(0, 32768, 64)

            LOG.debug("Done with Mem and Settings Upload")

            self._finish()

        except errors.RadioError:

            raise

        except Exception, e:

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        return

    def _do_upload(self, start, end, blocksize):

        LOG.debug("Start of _do_upload")

        ptr = start

        LOG.debug("ptr = " + str(ptr))

        for i in range(start, end, blocksize):

            LOG.debug("Start of loop in _do_upload index = "+str(i))

            LOG.debug("Start %i End %i Size %i" % (start, end, blocksize))

            req = chr(i/ 256) + chr(i % 256)

            LOG.debug("REQ")

            chunk = self.get_mmap()[ptr:ptr + blocksize]

            LOG.debug("CHUNK")

            self._write_record(CMD_WR, req + chunk)

#            LOG.debug("Upload-- SENT : " % util.hexprint(_sent))

            cserr, ack = self._read_record()

            LOG.debug("Upload-- CSUM ERROR : " + str(cserr))

            LOG.debug("Upload-- RCVD :\n%s " % util.hexprint(ack))

            j = ord(ack[0]) * 256 + ord(ack[1])

            if cserr or j != ptr:

                raise Exception("Radio did not ack block %i" % ptr)

            ptr += blocksize

            if self.status_fn:

                status = chirp_common.Status()

                status.cur = i

                status.max = end

                status.msg = "Cloning to radio"

                self.status_fn(status)

        # self._finish()

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_ctone = True

        rf.has_rx_dtcs = True

        rf.has_cross = True

        rf.has_tuning_step = False

        rf.has_bank = False

        rf.can_odd_split = True

        rf.valid_skips = ["", "S"]

        rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]

        rf.valid_cross_modes = [

            "Tone->Tone",

            "Tone->DTCS",

            "DTCS->Tone",

            "DTCS->",

            "->Tone",

            "->DTCS",

            "DTCS->DTCS",

        ]

        rf.valid_modes = ["FM", "NFM", "AM", "NAM"]

        rf.valid_power_levels = self.POWER_LEVELS

        rf.valid_name_length = 8

        rf.valid_duplexes = ["", "-", "+", "split", "off"]

#   MRT - Open up channel memory freq range to support RxFreq limit expansion

        rf.valid_bands = [(26000000, 299999999),  # supports VHF

                          (300000000, 999999999)]  # supports UHF

        rf.valid_characters = chirp_common.CHARSET_ASCII

        rf.memory_bounds = (1, 999)  # 999 memories

        rf.valid_tuning_steps = STEPS

        return rf

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.experimental = \

            ('This driver is experimental and may contain bugs. \n'

              'USE AT YOUR OWN RISK  - '

              ' SAVE A COPY OF DOWNLOAD FROM YOUR RADIO BEFORE MAKING CHANGES\n'

              '\nAll known CPS settings are implemented \n'

              '\n Additional settings found only on radio are also included'

              '\nMute, Compander and Scrambler are defaulted to '

              'QT, OFF , OFF for all channel memories\n'

              '\n'

              'Modification of Freq Limit Interfaces is done AT YOUR OWN RISK and '

              'may affect radio performance and may violate rules, regulations '

              'or laws in your jurisdiction.\n'

             )

        return rp

    def get_raw_memory(self, number):

        return repr(self._memobj.memory[number])

# MRT - corrected the Polarity decoding to match 980P implementation

# use 0x4000 bit mask for R

# MRT - 0x4000 appears to be the bit mask for Inverted DCS tones

# MRT - n DCS Tone will be 0x8xxx values - i DCS Tones will

# be 0xCxxx values.

# MRT - Chirp Uses N for n DCS Tones and R for i DCS Tones

# MRT - 980P encodes DCS tone # in decimal -  NOT OCTAL

    def _get_tone(self, _mem, mem):

        def _get_dcs(val):

            code = int("%03d" % (val & 0x07FF))

            pol = (val & 0x4000) and "R" or "N"

            return code, pol

# MRT - Modified the function below to bitwise AND with 0x4000

# to check for 980P DCS Tone decoding

# MRT 0x8000 appears to be the bit mask for DCS tones

        tpol = False

# MRT Beta 1.1 - Fix the txtone compare to 0x8000 - was rxtone.

        if _mem.txtone != 0xFFFF and (_mem.txtone & 0x8000) == 0x8000:

            tcode, tpol = _get_dcs(_mem.txtone)

            mem.dtcs = tcode

            txmode = "DTCS"

        elif _mem.txtone != 0xFFFF and _mem.txtone != 0x0:

            mem.rtone = (_mem.txtone & 0x7fff) / 10.0

            txmode = "Tone"

        else:

            txmode = ""

# MRT - Modified the function below to bitwise AND with 0x4000

# to check for 980P DCS Tone decoding

        rpol = False

        if _mem.rxtone != 0xFFFF and (_mem.rxtone & 0x8000) == 0x8000: