From 6a3214fd43c2005b967bc049c01a5e855ba9a5ff Mon Sep 17 00:00:00 2001 From: Nate Bargmann Date: Sun, 21 Feb 2016 14:56:44 -0600 Subject: [PATCH] Apply Linux C style Update files modified to support libusb-1.0. --- kit/dwt.c | 320 +++++++------ kit/elektor507.c | 595 +++++++++++++----------- kit/fifisdr.c | 469 ++++++++++--------- kit/funcube.c | 586 ++++++++++++------------ kit/kit.c | 2 +- kit/si570avrusb.c | 1108 +++++++++++++++++++++++---------------------- src/usb_port.c | 63 ++- 7 files changed, 1669 insertions(+), 1474 deletions(-) diff --git a/kit/dwt.c b/kit/dwt.c index 7411208e9..083d13f65 100644 --- a/kit/dwt.c +++ b/kit/dwt.c @@ -58,12 +58,11 @@ /* Some type definitions needed for dll access */ -typedef enum _tFrontendMode -{ - eFrontendModeUndefined = 0, - eFrontendModeDrm = 1, - eFrontendModeAm = 2, - eFrontendModeFm = 6, +typedef enum _tFrontendMode { + eFrontendModeUndefined = 0, + eFrontendModeDrm = 1, + eFrontendModeAm = 2, + eFrontendModeFm = 6, } tFrontendMode; typedef short (__stdcall *FNCFrontendOpen)(void); @@ -132,7 +131,7 @@ static int dwtdll_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); static int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); static int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val); static int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); -static const char * dwtdll_get_info(RIG *rig); +static const char *dwtdll_get_info(RIG *rig); /* * Coding Technologies Digital World Traveller DRM tuner. @@ -143,79 +142,79 @@ static const char * dwtdll_get_info(RIG *rig); */ const struct rig_caps dwt_caps = { -.rig_model = RIG_MODEL_DWT, -.model_name = "Digital World Traveller", -.mfg_name = "Coding Technologies", -.version = "0.1.1", -.copyright = "LGPL", -.status = RIG_STATUS_STABLE, -.rig_type = RIG_TYPE_PCRECEIVER, -.ptt_type = RIG_PTT_NONE, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_NONE, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 200, -.retry = 0, + .rig_model = RIG_MODEL_DWT, + .model_name = "Digital World Traveller", + .mfg_name = "Coding Technologies", + .version = "0.1.1", + .copyright = "LGPL", + .status = RIG_STATUS_STABLE, + .rig_type = RIG_TYPE_PCRECEIVER, + .ptt_type = RIG_PTT_NONE, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_NONE, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 200, + .retry = 0, -.has_get_func = DWT_FUNC, -.has_set_func = DWT_FUNC, -.has_get_level = DWT_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL), -.has_get_parm = DWT_PARM_ALL, -.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { 20, RIG_DBLST_END, }, /* TBC */ -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = DWT_FUNC, + .has_set_func = DWT_FUNC, + .has_get_level = DWT_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL), + .has_get_parm = DWT_PARM_ALL, + .has_set_parm = RIG_PARM_SET(DWT_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { 20, RIG_DBLST_END, }, /* TBC */ + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO,DWT_ANT}, - {kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO,DWT_ANT}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO,DWT_ANT}, - {kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO,DWT_ANT}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {DWT_MODES,1}, - RIG_TS_END, + .rx_range_list1 = { + {kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO, DWT_ANT}, + {kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO, DWT_ANT}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO, DWT_ANT}, + {kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO, DWT_ANT}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {DWT_MODES, 1}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { {RIG_MODE_USB, kHz(22)}, /* FIXME */ {RIG_MODE_AM, kHz(9)}, /* FIXME */ {RIG_MODE_WFM, kHz(230)}, /* FIXME */ RIG_FLT_END, }, -.rig_init = dwtdll_init, -.rig_cleanup = dwtdll_cleanup, -.rig_open = dwtdll_open, -.rig_close = dwtdll_close, + .rig_init = dwtdll_init, + .rig_cleanup = dwtdll_cleanup, + .rig_open = dwtdll_open, + .rig_close = dwtdll_close, -.set_freq = dwtdll_set_freq, -.get_freq = dwtdll_get_freq, -.set_mode = dwtdll_set_mode, -.get_mode = dwtdll_get_mode, -.set_level = dwtdll_set_level, -.get_level = dwtdll_get_level, -.get_info = dwtdll_get_info, + .set_freq = dwtdll_set_freq, + .get_freq = dwtdll_get_freq, + .set_mode = dwtdll_set_mode, + .get_mode = dwtdll_get_mode, + .set_level = dwtdll_set_level, + .get_level = dwtdll_get_level, + .get_info = dwtdll_get_info, }; @@ -224,7 +223,8 @@ int dwtdll_init(RIG *rig) { struct dwtdll_priv_data *priv; - priv = (struct dwtdll_priv_data*)malloc(sizeof(struct dwtdll_priv_data)); + priv = (struct dwtdll_priv_data *)malloc(sizeof(struct dwtdll_priv_data)); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -235,7 +235,7 @@ int dwtdll_init(RIG *rig) if (!priv->dll) { rig_debug(RIG_DEBUG_ERR, "%s: Unable to LoadLibrary %s\n", - __func__, DWTDLL); + __func__, DWTDLL); free(priv); return -RIG_EIO; /* huh! */ } @@ -278,7 +278,7 @@ int dwtdll_init(RIG *rig) priv->FrontendGetFmMode = (FNCFrontendGetFmMode) GetProcAddress(priv->dll, "FrontendGetFmMode"); - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -290,11 +290,13 @@ int dwtdll_open(RIG *rig) /* Open DWT receiver */ ret = priv->FrontendOpen(); + if (ret < 0) return -RIG_EIO; /* huh! */ /* default to DRM mode */ ret = priv->FrontendSetMode(eFrontendModeDrm); + if (ret < 0) return -RIG_EIO; /* huh! */ @@ -308,6 +310,7 @@ int dwtdll_close(RIG *rig) /* Open DWT receiver */ ret = priv->FrontendClose(); + if (ret < 0) return -RIG_EIO; /* huh! */ @@ -323,6 +326,7 @@ int dwtdll_cleanup(RIG *rig) if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; @@ -355,8 +359,11 @@ int dwtdll_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) switch (mode) { case RIG_MODE_USB: dwtmode = eFrontendModeDrm; break; + case RIG_MODE_AM: dwtmode = eFrontendModeAm; break; + case RIG_MODE_WFM: dwtmode = eFrontendModeFm; break; + default: return -RIG_EINVAL; } @@ -375,11 +382,15 @@ int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) switch (dwtmode) { case eFrontendModeDrm: *mode = RIG_MODE_USB; break; + case eFrontendModeAm: *mode = RIG_MODE_AM; break; + case eFrontendModeFm: *mode = RIG_MODE_WFM; break; + default: return -RIG_EPROTO; } + *width = rig_passband_normal(rig, *mode); return RIG_OK; @@ -389,9 +400,9 @@ int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv; - short ret=0; + short ret = 0; - switch(level) { + switch (level) { case RIG_LEVEL_ATT: ret = priv->FrontendSetRfAttenuator(val.i ? 1 : 0); break; @@ -406,13 +417,15 @@ int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv; - signed short ret=0; + signed short ret = 0; - switch(level) { + switch (level) { case RIG_LEVEL_ATT: ret = priv->FrontendGetRfAttenuator(); + if (ret < 0) break; + /* local vs. DX mode */ val->i = ret ? 0 : rig->caps->attenuator[0]; break; @@ -420,17 +433,21 @@ int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) case RIG_LEVEL_STRENGTH: /* actual RMS signal strength in dBuV */ ret = priv->FrontendGetRfLevel(); + if (ret < 0) break; - /* return actual RMS signal strength in dBuV, -34 to get dB rel S9 */ + + /* return actual RMS signal strength in dBuV, -34 to get dB rel S9 */ val->i = ret - 34; break; case RIG_LEVEL_RAWSTR: /* actual RMS signal strength in dBuV */ ret = priv->FrontendGetRfLevel(); + if (ret < 0) break; + val->i = ret; break; @@ -442,7 +459,7 @@ int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) } -static const char* dwtdll_get_info(RIG *rig) +static const char *dwtdll_get_info(RIG *rig) { struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv; static char info[22]; @@ -485,7 +502,7 @@ static const char* dwtdll_get_info(RIG *rig) static int dwt_init(RIG *rig); static int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq); -static const char * dwt_get_info(RIG *rig); +static const char *dwt_get_info(RIG *rig); /* * Coding Technologies Digital World Traveller DRM tuner. @@ -496,77 +513,77 @@ static const char * dwt_get_info(RIG *rig); */ const struct rig_caps dwt_caps = { -.rig_model = RIG_MODEL_DWT, -.model_name = "Digital World Traveller", -.mfg_name = "Coding Technologies", -.version = "0.2", -.copyright = "LGPL", -.status = RIG_STATUS_UNTESTED, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_NONE, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.serial_rate_min = 9600, /* don't care */ -.serial_rate_max = 9600, -.serial_data_bits = 8, -.serial_stop_bits = 1, -.serial_parity = RIG_PARITY_NONE, -.serial_handshake = RIG_HANDSHAKE_NONE, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 200, -.retry = 0, + .rig_model = RIG_MODEL_DWT, + .model_name = "Digital World Traveller", + .mfg_name = "Coding Technologies", + .version = "0.2", + .copyright = "LGPL", + .status = RIG_STATUS_UNTESTED, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_NONE, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .serial_rate_min = 9600, /* don't care */ + .serial_rate_max = 9600, + .serial_data_bits = 8, + .serial_stop_bits = 1, + .serial_parity = RIG_PARITY_NONE, + .serial_handshake = RIG_HANDSHAKE_NONE, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 200, + .retry = 0, -.has_get_func = DWT_FUNC, -.has_set_func = DWT_FUNC, -.has_get_level = DWT_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL), -.has_get_parm = DWT_PARM_ALL, -.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = DWT_FUNC, + .has_set_func = DWT_FUNC, + .has_get_level = DWT_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL), + .has_get_parm = DWT_PARM_ALL, + .has_set_parm = RIG_PARM_SET(DWT_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO}, - {kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO}, - {kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {DWT_MODES,kHz(1)}, - RIG_TS_END, + .rx_range_list1 = { + {kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO}, + {kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO}, + {kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {DWT_MODES, kHz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { {RIG_MODE_USB, kHz(22)}, /* FIXME */ {RIG_MODE_AM, kHz(9)}, /* FIXME */ {RIG_MODE_WFM, kHz(230)}, /* FIXME */ RIG_FLT_END, }, -.rig_init = dwt_init, + .rig_init = dwt_init, -.set_freq = dwt_set_freq, -.get_info = dwt_get_info, + .set_freq = dwt_set_freq, + .get_info = dwt_get_info, }; @@ -591,23 +608,24 @@ int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq) int request, value, index; unsigned char buf[MSG_LEN] = { 0x4a, 0x00, 0x03, 0x00, 0xff, 0xff, 0x32 }; int requesttype, r; - int ifreq = (int)(freq/1000); + int ifreq = (int)(freq / 1000); /* FIXME */ - requesttype = 0x00; - request = 0x00; - value = 0x00; - index = 0x00; + requesttype = 0x00; + request = 0x00; + value = 0x00; + index = 0x00; buf[8] = ifreq & 0xff; - buf[7] = (ifreq>>8) & 0xff; + buf[7] = (ifreq >> 8) & 0xff; + + r = libusb_control_transfer(udh, requesttype, request, value, index, + buf, 9, 1000); - r = libusb_control_transfer (udh, requesttype, request, value, index, - buf, 9, 1000); if (r < 0) { - rig_debug (RIG_DEBUG_ERR, - "libusb_control_transfer failed: %s\n", - libusb_error_name (r)); + rig_debug(RIG_DEBUG_ERR, + "libusb_control_transfer failed: %s\n", + libusb_error_name(r)); return -RIG_EIO; } @@ -615,7 +633,7 @@ int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq) } /* Rem: not reentrant */ -const char * dwt_get_info(RIG *rig) +const char *dwt_get_info(RIG *rig) { static char buf[64]; libusb_device_handle *udh = rig->state.rigport.handle; diff --git a/kit/elektor507.c b/kit/elektor507.c index 2de6e7027..daf43daba 100644 --- a/kit/elektor507.c +++ b/kit/elektor507.c @@ -51,13 +51,13 @@ static int elektor507_set_freq(RIG *rig, vfo_t vfo, freq_t freq); static int elektor507_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); static int elektor507_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val); static int elektor507_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); -static int elektor507_set_ant(RIG * rig, vfo_t vfo, ant_t ant); -static int elektor507_get_ant(RIG * rig, vfo_t vfo, ant_t *ant); +static int elektor507_set_ant(RIG *rig, vfo_t vfo, ant_t ant); +static int elektor507_get_ant(RIG *rig, vfo_t vfo, ant_t *ant); static int elektor507_set_conf(RIG *rig, token_t token, const char *val); static int elektor507_get_conf(RIG *rig, token_t token, char *val); -static const char * elektor507_get_info(RIG *rig); +static const char *elektor507_get_info(RIG *rig); /* * I2C addresses @@ -79,7 +79,7 @@ static const char * elektor507_get_info(RIG *rig); static int cy_update_pll(RIG *rig, unsigned char IICadr); static int i2c_write_regs(RIG *rig, unsigned char IICadr, int reg_count, unsigned char reg_adr, - unsigned char reg_val1, unsigned char reg_val2, unsigned char reg_val3); + unsigned char reg_val1, unsigned char reg_val2, unsigned char reg_val3); #define i2c_write_reg(rig, IICadr, reg_adr, reg_val) \ i2c_write_regs(rig, IICadr, 1, reg_adr, reg_val, 0, 0) @@ -99,27 +99,26 @@ static int i2c_write_regs(RIG *rig, unsigned char IICadr, int reg_count, unsigne /* Some type definitions needed for dll access */ -typedef enum -{ - FT_OK = 0, - FT_INVALID_HANDLE = 1, - FT_DEVICE_NOT_FOUND = 2, - FT_DEVICE_NOT_OPENED = 3, - FT_IO_ERROR = 4, - FT_INSUFFICIENT_RESOURCES = 5, - FT_INVALID_PARAMETER = 6, - FT_SUCCESS = FT_OK, - FT_INVALID_BAUD_RATE = 7, - FT_DEVICE_NOT_OPENED_FOR_ERASE = 8, - FT_DEVICE_NOT_OPENED_FOR_WRITE = 9, - FT_FAILED_TO_WRITE_DEVICE = 10, - FT_EEPROM_READ_FAILED = 11, - FT_EEPROM_WRITE_FAILED = 12, - FT_EEPROM_ERASE_FAILED = 13, - FT_EEPROM_NOT_PRESENT = 14, - FT_EEPROM_NOT_PROGRAMMED = 15, - FT_INVALID_ARGS = 16, - FT_OTHER_ERROR = 17, +typedef enum { + FT_OK = 0, + FT_INVALID_HANDLE = 1, + FT_DEVICE_NOT_FOUND = 2, + FT_DEVICE_NOT_OPENED = 3, + FT_IO_ERROR = 4, + FT_INSUFFICIENT_RESOURCES = 5, + FT_INVALID_PARAMETER = 6, + FT_SUCCESS = FT_OK, + FT_INVALID_BAUD_RATE = 7, + FT_DEVICE_NOT_OPENED_FOR_ERASE = 8, + FT_DEVICE_NOT_OPENED_FOR_WRITE = 9, + FT_FAILED_TO_WRITE_DEVICE = 10, + FT_EEPROM_READ_FAILED = 11, + FT_EEPROM_WRITE_FAILED = 12, + FT_EEPROM_ERASE_FAILED = 13, + FT_EEPROM_NOT_PRESENT = 14, + FT_EEPROM_NOT_PROGRAMMED = 15, + FT_INVALID_ARGS = 16, + FT_OTHER_ERROR = 17, } FT_Result; typedef FT_Result (__stdcall *FNCFT_Open)(int Index, unsigned long *ftHandle); @@ -175,10 +174,12 @@ struct elektor507_extra_priv_data { #define TOK_XTALCAL TOKEN_BACKEND(2) static const struct confparams elektor507_cfg_params[] = { - { TOK_OSCFREQ, "osc_freq", "Oscillator freq", "Oscillator frequency in Hz", - "10000000", RIG_CONF_NUMERIC, { .n = { 0, MHz(30), 1 } } + { + TOK_OSCFREQ, "osc_freq", "Oscillator freq", "Oscillator frequency in Hz", + "10000000", RIG_CONF_NUMERIC, { .n = { 0, MHz(30), 1 } } }, - { TOK_XTALCAL, "xtal_cal", "Xtal Cal", "Cristal calibration", + { + TOK_XTALCAL, "xtal_cal", "Xtal Cal", "Cristal calibration", "132", RIG_CONF_NUMERIC, { .n = { 0, 255, 1 } } }, { RIG_CONF_END, NULL, } @@ -202,7 +203,7 @@ struct elektor507_priv_data { /* CY PLL stuff. * This is Qtotal & Ptotal values here. */ - int P,Q,Div1N; + int P, Q, Div1N; /* FTDI comm stuff */ unsigned char FT_port; @@ -220,11 +221,13 @@ int elektor507_init(RIG *rig) struct elektor507_priv_data *priv; struct elektor507_extra_priv_data *extra_priv; - priv = (struct elektor507_priv_data*)calloc(sizeof(struct elektor507_priv_data), 1); + priv = (struct elektor507_priv_data *)calloc(sizeof(struct elektor507_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; } + priv->xtal_cal = XTAL_CAL; priv->osc_freq = OSCFREQ; priv->ant = ANT_AUTO; @@ -241,7 +244,7 @@ int elektor507_init(RIG *rig) if (!extra_priv->dll) { rig_debug(RIG_DEBUG_ERR, "%s: Unable to LoadLibrary %s\n", - __func__, ELEKTOR507_DLL); + __func__, ELEKTOR507_DLL); free(priv); return -RIG_EIO; /* huh! */ } @@ -266,7 +269,7 @@ int elektor507_init(RIG *rig) extra_priv->FT_Write = (FNCFT_Write) GetProcAddress(extra_priv->dll, "FT_Write"); - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -278,28 +281,33 @@ int elektor507_ftdi_write_data(RIG *rig, void *FTOutBuf, unsigned long BufferSiz FT_Result ret; int Result; - rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __func__, BufferSize); + rig_debug(RIG_DEBUG_TRACE, "%s called, %d bytes\n", __func__, BufferSize); /* Open FTDI */ ret = extra_priv->FT_Open(0, &extra_priv->ftHandle); + if (ret != FT_OK) return -RIG_EIO; ret = extra_priv->FT_SetBitMode(extra_priv->ftHandle, 0xff, 1); + if (ret != FT_OK) return -RIG_EIO; ret = extra_priv->FT_SetBaudRate(extra_priv->ftHandle, 38400); + if (ret != FT_OK) return -RIG_EIO; ret = extra_priv->FT_Write(extra_priv->ftHandle, FTOutBuf, BufferSize, &Result); + if (ret != FT_OK) { - rig_debug(RIG_DEBUG_ERR,"FT_Write failed: %d, Result: %d\n", ret, Result); + rig_debug(RIG_DEBUG_ERR, "FT_Write failed: %d, Result: %d\n", ret, Result); return -RIG_EIO; } ret = extra_priv->FT_Close(extra_priv->ftHandle); + if (ret != FT_OK) return -RIG_EIO; @@ -315,12 +323,13 @@ int elektor507_cleanup(RIG *rig) if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; } -const char * elektor507_get_info(RIG *rig) +const char *elektor507_get_info(RIG *rig) { static char buf[64]; @@ -343,7 +352,8 @@ int elektor507_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct elektor507_priv_data *priv; - priv = (struct elektor507_priv_data*)calloc(sizeof(struct elektor507_priv_data), 1); + priv = (struct elektor507_priv_data *)calloc(sizeof(struct elektor507_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -364,7 +374,7 @@ int elektor507_init(RIG *rig) rp->parm.usb.iface = 0; rp->parm.usb.alt = 0; /* necessary ? */ - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -376,13 +386,14 @@ int elektor507_cleanup(RIG *rig) if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; } /* Rem: not reentrant */ -const char * elektor507_get_info(RIG *rig) +const char *elektor507_get_info(RIG *rig) { static char buf[64]; libusb_device_handle *udh = rig->state.rigport.handle; @@ -400,19 +411,21 @@ int elektor507_libusb_setup(RIG *rig) { libusb_device_handle *udh = rig->state.rigport.handle; int ret; - unsigned short index=0, usb_val; + unsigned short index = 0, usb_val; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); /* Reset the ftdi device */ #if 1 ret = libusb_control_transfer(udh, 0x40, 0, 0, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT); + if (ret != 0) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer reset failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer reset failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } + #endif /* @@ -422,10 +435,11 @@ int elektor507_libusb_setup(RIG *rig) usb_val |= (0x01 << 8); /* Basic bitbang_mode: 0x01 */ ret = libusb_control_transfer(udh, 0x40, 0x0B, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT); + if (ret != 0) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer bitbangmode failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer bitbangmode failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } @@ -436,10 +450,11 @@ int elektor507_libusb_setup(RIG *rig) usb_val = 49230; /* magic value for 38400 bauds */ index = 0; ret = libusb_control_transfer(udh, 0x40, 3, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT); + if (ret != 0) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer baudrate failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer baudrate failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } @@ -451,13 +466,14 @@ int elektor507_ftdi_write_data(RIG *rig, void *FTOutBuf, unsigned long BufferSiz libusb_device_handle *udh = rig->state.rigport.handle; int ret, actual_length; - rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __func__, BufferSize); + rig_debug(RIG_DEBUG_TRACE, "%s called, %d bytes\n", __func__, BufferSize); ret = libusb_bulk_transfer(udh, FTDI_IN_EP, FTOutBuf, BufferSize, &actual_length, FTDI_USB_WRITE_TIMEOUT); + if (ret < 0) { - rig_debug (RIG_DEBUG_ERR, - "usb_bulk_write failed: %s\n", - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, + "usb_bulk_write failed: %s\n", + libusb_error_name(ret)); return -RIG_EIO; } @@ -499,88 +515,88 @@ int elektor507_ftdi_write_data(RIG *rig, void *FTOutBuf, unsigned long BufferSiz */ const struct rig_caps elektor507_caps = { -.rig_model = RIG_MODEL_ELEKTOR507, -.model_name = "Elektor SDR-USB", -.mfg_name = "Elektor", -.version = "0.3.2", -.copyright = "LGPL", -.status = RIG_STATUS_STABLE, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_NONE, -.dcd_type = RIG_DCD_NONE, + .rig_model = RIG_MODEL_ELEKTOR507, + .model_name = "Elektor SDR-USB", + .mfg_name = "Elektor", + .version = "0.3.2", + .copyright = "LGPL", + .status = RIG_STATUS_STABLE, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_NONE, + .dcd_type = RIG_DCD_NONE, #ifdef USE_LIBUSB -.port_type = RIG_PORT_USB, + .port_type = RIG_PORT_USB, #else -.port_type = RIG_PORT_NONE, + .port_type = RIG_PORT_NONE, #endif -.serial_rate_min = 9600, -.serial_rate_max = 9600, -.serial_data_bits = 8, -.serial_stop_bits = 1, -.serial_parity = RIG_PARITY_NONE, -.serial_handshake = RIG_HANDSHAKE_NONE, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 200, -.retry = 0, + .serial_rate_min = 9600, + .serial_rate_max = 9600, + .serial_data_bits = 8, + .serial_stop_bits = 1, + .serial_parity = RIG_PARITY_NONE, + .serial_handshake = RIG_HANDSHAKE_NONE, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 200, + .retry = 0, -.has_get_func = ELEKTOR507_FUNC, -.has_set_func = ELEKTOR507_FUNC, -.has_get_level = ELEKTOR507_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(ELEKTOR507_LEVEL_ALL), -.has_get_parm = ELEKTOR507_PARM_ALL, -.has_set_parm = RIG_PARM_SET(ELEKTOR507_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { 10, 20, RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = ELEKTOR507_FUNC, + .has_set_func = ELEKTOR507_FUNC, + .has_get_level = ELEKTOR507_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(ELEKTOR507_LEVEL_ALL), + .has_get_parm = ELEKTOR507_PARM_ALL, + .has_set_parm = RIG_PARM_SET(ELEKTOR507_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { 10, 20, RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {kHz(30),MHz(30)-kHz(1),ELEKTOR507_MODES,-1,-1,ELEKTOR507_VFO, ELEKTOR507_ANT}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(30),MHz(30)-kHz(1),ELEKTOR507_MODES,-1,-1,ELEKTOR507_VFO, ELEKTOR507_ANT}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {ELEKTOR507_MODES,kHz(1)}, - RIG_TS_END, + .rx_range_list1 = { + {kHz(30), MHz(30) - kHz(1), ELEKTOR507_MODES, -1, -1, ELEKTOR507_VFO, ELEKTOR507_ANT}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(30), MHz(30) - kHz(1), ELEKTOR507_MODES, -1, -1, ELEKTOR507_VFO, ELEKTOR507_ANT}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {ELEKTOR507_MODES, kHz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { {RIG_MODE_USB, kHz(24)}, /* bandpass may be more */ RIG_FLT_END, }, -.cfgparams = elektor507_cfg_params, + .cfgparams = elektor507_cfg_params, -.rig_init = elektor507_init, -.rig_cleanup = elektor507_cleanup, -.rig_open = elektor507_open, -.set_conf = elektor507_set_conf, -.get_conf = elektor507_get_conf, + .rig_init = elektor507_init, + .rig_cleanup = elektor507_cleanup, + .rig_open = elektor507_open, + .set_conf = elektor507_set_conf, + .get_conf = elektor507_get_conf, -.set_freq = elektor507_set_freq, -.get_freq = elektor507_get_freq, -.set_level = elektor507_set_level, -.get_level = elektor507_get_level, -.set_ant = elektor507_set_ant, -.get_ant = elektor507_get_ant, -.get_info = elektor507_get_info, + .set_freq = elektor507_set_freq, + .get_freq = elektor507_get_freq, + .set_level = elektor507_set_level, + .get_level = elektor507_get_level, + .set_ant = elektor507_set_ant, + .get_ant = elektor507_get_ant, + .get_info = elektor507_get_info, }; @@ -590,19 +606,22 @@ int elektor507_set_conf(RIG *rig, token_t token, const char *val) struct elektor507_priv_data *priv; freq_t freq; - priv = (struct elektor507_priv_data*)rig->state.priv; + priv = (struct elektor507_priv_data *)rig->state.priv; - switch(token) { - case TOK_OSCFREQ: - sscanf(val, "%"SCNfreq, &freq); - priv->osc_freq = freq / kHz(1); - break; - case TOK_XTALCAL: - sscanf(val, "%u", &priv->xtal_cal); - break; - default: - return -RIG_EINVAL; + switch (token) { + case TOK_OSCFREQ: + sscanf(val, "%"SCNfreq, &freq); + priv->osc_freq = freq / kHz(1); + break; + + case TOK_XTALCAL: + sscanf(val, "%u", &priv->xtal_cal); + break; + + default: + return -RIG_EINVAL; } + return RIG_OK; } @@ -610,18 +629,21 @@ int elektor507_get_conf(RIG *rig, token_t token, char *val) { struct elektor507_priv_data *priv; - priv = (struct elektor507_priv_data*)rig->state.priv; + priv = (struct elektor507_priv_data *)rig->state.priv; - switch(token) { - case TOK_OSCFREQ: - sprintf(val, "%"PRIfreq, priv->osc_freq*kHz(1)); - break; - case TOK_XTALCAL: - sprintf(val, "%u", priv->xtal_cal); - break; - default: - return -RIG_EINVAL; + switch (token) { + case TOK_OSCFREQ: + sprintf(val, "%"PRIfreq, priv->osc_freq * kHz(1)); + break; + + case TOK_XTALCAL: + sprintf(val, "%u", priv->xtal_cal); + break; + + default: + return -RIG_EINVAL; } + return RIG_OK; } @@ -632,15 +654,17 @@ int elektor507_open(RIG *rig) struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; int ret; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); /* * Setup the FT232R. */ #ifdef USE_LIBUSB ret = elektor507_libusb_setup(rig); + if (ret != RIG_OK) return ret; + #endif /* Init the FT232R port to SCL/SDA high, Mux A0, Att 0 */ @@ -653,33 +677,40 @@ int elektor507_open(RIG *rig) /* Enable only CLOCK5. CLOCK3 will be on demand in set_ant() */ ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, CLKOE_REG, 0x20); + if (ret != 0) return ret; /* DIV1N set to safe default */ priv->Div1N = 8; ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, DIV1_REG, priv->Div1N); + if (ret != 0) return ret; #if 0 /* Xtal gain setting */ ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, XTALCTL_REG, 0x32); + if (ret != 0) return ret; /* CapLoad set to middle */ ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, CAPLOAD_REG, priv->xtal_cal); + if (ret != 0) return ret; + #endif /* CLKSRC: CLOCK3=DIV2CLK/2, CLOCK5=DIV1CLK/DIV1N */ ret = i2c_write_regs(rig, CY_I2C_RAM_ADR, 3, CLKSRC_REG, 0x02, 0x8e, 0x47); + if (ret != 0) return ret; /* DIV2SRC from REF */ ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, DIV2_REG, 0x88); + if (ret != 0) return ret; @@ -698,40 +729,28 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) Freq = freq / kHz(1); - if (Freq > 19 && Freq < 60) - { - priv->Div1N = (2500 + Freq/2) / Freq + 128; + if (Freq > 19 && Freq < 60) { + priv->Div1N = (2500 + Freq / 2) / Freq + 128; priv->P = 1000; priv->Q = 40; return; - } - else - if (Freq > 59 && Freq < 801) - { + } else if (Freq > 59 && Freq < 801) { priv->Div1N = 125; priv->P = Freq * 2; priv->Q = 40; return; - } - else - if (Freq > 800 && Freq < 2001) - { + } else if (Freq > 800 && Freq < 2001) { priv->Div1N = 50; priv->P = Freq; priv->Q = 50; return; - } - else - if (Freq > 2000 && Freq < 4001) + } else if (Freq > 2000 && Freq < 4001) priv->Div1N = 25; - else - if (Freq > 4000 && Freq < 10001) + else if (Freq > 4000 && Freq < 10001) priv->Div1N = 10; - else - if (Freq > 10000 && Freq < 20001) + else if (Freq > 10000 && Freq < 20001) priv->Div1N = 5; - else - if (Freq > 20000 && Freq < 30001) + else if (Freq > 20000 && Freq < 30001) priv->Div1N = 4; Min = priv->osc_freq; @@ -746,26 +765,28 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) + P*(REF/Qtotal) must not be above 400 MHz or below 100 MHz */ #if 1 - q_max = priv->osc_freq/250; + q_max = priv->osc_freq / 250; #else q_max = 100; #endif + for (q = q_max; q >= 10; q--) { for (p = 500; p <= 2000; p++) { - VCO = ((double)priv->osc_freq/q)*p; + VCO = ((double)priv->osc_freq / q) * p; - if (fabs(4*freq-VCO/priv->Div1N) < Min) { - Min = fabs(4*freq - VCO/priv->Div1N); + if (fabs(4 * freq - VCO / priv->Div1N) < Min) { + Min = fabs(4 * freq - VCO / priv->Div1N); priv->Q = q; priv->P = p; } } } - VCO = ((double)priv->osc_freq/priv->Q)*priv->P; + VCO = ((double)priv->osc_freq / priv->Q) * priv->P; + if (VCO < 100e3 || VCO > 400e3) rig_debug(RIG_DEBUG_VERBOSE, "%s: Unstable parameters for VCO=%.1f\n", - __func__, VCO); + __func__, VCO); } #endif /* ORIG_ALGORITHM */ @@ -777,7 +798,7 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) int p, q, div1n, q_max; Min = priv->osc_freq; - freq4 = freq*4/kHz(1); + freq4 = freq * 4 / kHz(1); #define vco_min 100e3 #define vco_max 500e3 @@ -790,16 +811,19 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) + P*(REF/Qtotal) must not be above 400 MHz or below 100 MHz */ #if 1 - q_max = priv->osc_freq/250; + q_max = priv->osc_freq / 250; #else q_max = 100; #endif - div1n_min = vco_min/freq4; + div1n_min = vco_min / freq4; + if (div1n_min < 2) div1n_min = 2; else if (div1n_min > 127) div1n_min = 127; - div1n_max = vco_max/freq4; + + div1n_max = vco_max / freq4; + if (div1n_max > 127) div1n_max = 127; else if (div1n_max < 2) @@ -810,19 +834,24 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) // P/Qtotal = FREQ4*DIV1N/REF // (Q*int(r) + frac(r)*Q)/Q for (q = q_max; q >= 2; q--) { - p = q*freq4*div1n/priv->osc_freq; + p = q * freq4 * div1n / priv->osc_freq; #if 1 + if (p < 16 || p > 1023) continue; + #endif - VCO = ((double)priv->osc_freq/q)*p; + VCO = ((double)priv->osc_freq / q) * p; #if 1 + if (VCO < vco_min || VCO > vco_max) continue; + #endif - if (fabs(freq4-VCO/div1n) < Min) { - Min = fabs(freq4 - VCO/div1n); + + if (fabs(freq4 - VCO / div1n) < Min) { + Min = fabs(freq4 - VCO / div1n); priv->Div1N = div1n; priv->Q = q; priv->P = p; @@ -830,10 +859,11 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) } } - VCO = ((double)priv->osc_freq/priv->Q)*priv->P; + VCO = ((double)priv->osc_freq / priv->Q) * priv->P; + if (VCO < vco_min || VCO > 400e3) rig_debug(RIG_DEBUG_VERBOSE, "%s: Unstable parameters for VCO=%.1f\n", - __func__, VCO); + __func__, VCO); } #endif /* default alternative to ORIG_ALGORITHM */ @@ -842,7 +872,7 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq) static void find_P_Q_DIV1N( struct elektor507_priv_data *priv, freq_t freq) - { +{ #define VCO_MIN 100000000 #define VCO_MAX 400000000 int Ptotal, Pmin, Pmax; @@ -855,41 +885,43 @@ static void find_P_Q_DIV1N( /* For stable operation: Ref/Qtotal must not fall below 250kHz */ /* Qmax = (int) ( Ref / 250000); */ - for (Qtotal = 2; Qtotal <= Qmax; Qtotal++) - { - REFdivQ = ( Ref / Qtotal); + for (Qtotal = 2; Qtotal <= Qmax; Qtotal++) { + REFdivQ = (Ref / Qtotal); /* For stable operation: Ptotal*(Ref/Qtotal) must be ... */ - Pmin = (int) ( VCO_MIN / REFdivQ); /* ... >= 100mHz */ - Pmax = (int) ( VCO_MAX / REFdivQ); /* ... <= 400mHz */ - for (Ptotal = Pmin; Ptotal <= Pmax; Ptotal++) - { + Pmin = (int)(VCO_MIN / REFdivQ); /* ... >= 100mHz */ + Pmax = (int)(VCO_MAX / REFdivQ); /* ... <= 400mHz */ + + for (Ptotal = Pmin; Ptotal <= Pmax; Ptotal++) { PmulREFdivQ = Ptotal * REFdivQ; - Div1N = (int) ((PmulREFdivQ + freq4 / 2) / freq4); + Div1N = (int)((PmulREFdivQ + freq4 / 2) / freq4); + if (Div1N < 2) Div1N = 2; + if (Div1N > 127) Div1N = 127; newdelta = fabs((PmulREFdivQ / Div1N) - freq4); - if (newdelta < delta) - { /* save best (P,Q,N) */ + + if (newdelta < delta) { + /* save best (P,Q,N) */ delta = newdelta; priv->P = Ptotal; priv->Q = Qtotal; priv->Div1N = Div1N; - } } } } +} #endif /* AC6SL version 5-Aug-2010 */ int elektor507_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; freq_t final_freq; - int ret=0; + int ret = 0; int Mux; if (priv->ant == ANT_AUTO) { @@ -901,6 +933,7 @@ int elektor507_set_freq(RIG *rig, vfo_t vfo, freq_t freq) /* Select A2, high pass */ Mux = 2; } + priv->FT_port &= 0x63; //0,1 = I2C, 2,3,4=MUX, 5,6=Attenuator priv->FT_port |= Mux << 2; } @@ -909,12 +942,12 @@ int elektor507_set_freq(RIG *rig, vfo_t vfo, freq_t freq) elektor507_get_freq(rig, vfo, &final_freq); rig_debug(RIG_DEBUG_VERBOSE, "%s: Freq=%.0f kHz, delta=%d Hz, Div1N=%d, P=%d, Q=%d, FREQ_ALGORITHM=%d\n", - __func__, freq/kHz(1), (int)(final_freq-freq), priv->Div1N, priv->P, priv->Q, FREQ_ALGORITHM); + __func__, freq / kHz(1), (int)(final_freq - freq), priv->Div1N, priv->P, priv->Q, FREQ_ALGORITHM); - if ((double)priv->osc_freq/priv->Q < 250) + if ((double)priv->osc_freq / priv->Q < 250) rig_debug(RIG_DEBUG_WARN, - "%s: Unstable parameters for REF/Qtotal=%.1f\n", - __func__, (double)priv->osc_freq/priv->Q); + "%s: Unstable parameters for REF/Qtotal=%.1f\n", + __func__, (double)priv->osc_freq / priv->Q); ret = cy_update_pll(rig, CY_I2C_RAM_ADR); @@ -937,23 +970,27 @@ int elektor507_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) int elektor507_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; - int ret=0; - int att=0; + int ret = 0; + int att = 0; - switch(level) { + switch (level) { case RIG_LEVEL_ATT: + /* val.i */ /* FTDI: DSR, DCD */ switch (val.i) { - case 0: att = 0; break; - case 10: att = 1; break; - case 20: att = 2; break; - default: return -RIG_EINVAL; + case 0: att = 0; break; + + case 10: att = 1; break; + + case 20: att = 2; break; + + default: return -RIG_EINVAL; } priv->FT_port &= 0x1f; - priv->FT_port |= (att&0x3) << 5; + priv->FT_port |= (att & 0x3) << 5; ret = elektor507_ftdi_write_data(rig, &priv->FT_port, 1); @@ -969,17 +1006,20 @@ int elektor507_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) int elektor507_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; - int ret=0; + int ret = 0; - switch(level) { + switch (level) { case RIG_LEVEL_ATT: switch ((priv->FT_port >> 5) & 3) { - case 0: val->i = 0; break; - case 1: val->i = 10; break; - case 2: val->i = 20; break; - default: - ret = -RIG_EINVAL; + case 0: val->i = 0; break; + + case 1: val->i = 10; break; + + case 2: val->i = 20; break; + + default: + ret = -RIG_EINVAL; } break; @@ -992,12 +1032,12 @@ int elektor507_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) } -int elektor507_set_ant(RIG * rig, vfo_t vfo, ant_t ant) +int elektor507_set_ant(RIG *rig, vfo_t vfo, ant_t ant) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; int ret, Mux; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); /* * FTDI: RTS, CTS, DTR @@ -1007,13 +1047,17 @@ int elektor507_set_ant(RIG * rig, vfo_t vfo, ant_t ant) * ANT1->A1/A2, ANT2->A3, ANT3->A7 */ - switch(ant) { + switch (ant) { case RIG_ANT_1: Mux = 0; break; /* Mux will be updated upon next set_freq */ + case RIG_ANT_2: Mux = 3; break; /* ANT_EXT */ + case RIG_ANT_3: Mux = 7; break; /* ANT_TEST_CLK */ + default: - return -RIG_EINVAL; + return -RIG_EINVAL; } + priv->ant = ant; priv->FT_port &= 0x63; //0,1 = I2C, 2,3,4=MUX, 5,6=Attenuator @@ -1023,13 +1067,13 @@ int elektor507_set_ant(RIG * rig, vfo_t vfo, ant_t ant) ret = elektor507_ftdi_write_data(rig, &priv->FT_port, 1); #else /* Enable CLOCK3 on demand */ - ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, CLKOE_REG, 0x20 | (ant==RIG_ANT_3 ? 0x04 : 0)); + ret = i2c_write_reg(rig, CY_I2C_RAM_ADR, CLKOE_REG, 0x20 | (ant == RIG_ANT_3 ? 0x04 : 0)); #endif return (ret != 0) ? -RIG_EIO : RIG_OK; } -int elektor507_get_ant(RIG * rig, vfo_t vfo, ant_t *ant) +int elektor507_get_ant(RIG *rig, vfo_t vfo, ant_t *ant) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; @@ -1054,53 +1098,55 @@ static int cy_update_pll(RIG *rig, unsigned char IICadr) /* * PLL Pump setting according to table 9 */ - if (priv->P < 45) + if (priv->P < 45) Pump = 0; - else - if (priv->P < 480) + else if (priv->P < 480) Pump = 1; - else - if (priv->P < 640) + else if (priv->P < 640) Pump = 2; - else - if (priv->P < 800) + else if (priv->P < 800) Pump = 3; else Pump = 4; P0 = priv->P & 0x01; R40 = (((priv->P >> 1) - 4) >> 8) | (Pump << 2) | 0xc0; - R41 = ((priv->P >> 1) - 4) & 0xff; - R42 = (priv->Q - 2) | (P0<<7); + R41 = ((priv->P >> 1) - 4) & 0xff; + R42 = (priv->Q - 2) | (P0 << 7); ret = i2c_write_regs(rig, IICadr, 3, PUMPCOUNTERS_REG, R40, R41, R42); + if (ret != 0) return ret; switch (priv->Div1N) { - case 2: - /* Fixed /2 divider option */ - Clk3_src = 0x80; - Div1N = 8; - break; - case 3: - /* Fixed /3 divider option */ - Clk3_src = 0xc0; - Div1N = 6; - break; - default: - Div1N = priv->Div1N; - Clk3_src = 0x40; + case 2: + /* Fixed /2 divider option */ + Clk3_src = 0x80; + Div1N = 8; + break; + + case 3: + /* Fixed /3 divider option */ + Clk3_src = 0xc0; + Div1N = 6; + break; + + default: + Div1N = priv->Div1N; + Clk3_src = 0x40; } ret = i2c_write_reg(rig, IICadr, DIV1_REG, Div1N); + if (ret != 0) return ret; /* Set 2 low bits of CLKSRC for CLOCK5. DIV1CLK is set already */ - ret = i2c_write_reg(rig, IICadr, CLKSRC_REG+2, Clk3_src|0x07); + ret = i2c_write_reg(rig, IICadr, CLKSRC_REG + 2, Clk3_src | 0x07); + if (ret != 0) return ret; @@ -1114,6 +1160,7 @@ static void ftdi_SCL(RIG *rig, int d) if (priv->Buf_adr >= FT_OUT_BUFFER_MAX) return; + /* * FTDI RXD->SCL */ @@ -1132,6 +1179,7 @@ static void ftdi_SDA(RIG *rig, int d) if (priv->Buf_adr >= FT_OUT_BUFFER_MAX) return; + /* * FTDI TXD->SDA */ @@ -1178,13 +1226,13 @@ static void ftdi_I2C_Write_Byte(RIG *rig, unsigned char c) { int i; - for (i=7; i>=0; i--) - { - ftdi_SDA(rig, c & (1<= 0; i--) { + ftdi_SDA(rig, c & (1 << i)); /* SDA value */ ftdi_SCL(rig, 1); ftdi_SCL(rig, 0); } + ftdi_SDA(rig, 1); ftdi_SCL(rig, 1); ftdi_SCL(rig, 0); @@ -1192,7 +1240,7 @@ static void ftdi_I2C_Write_Byte(RIG *rig, unsigned char c) int i2c_write_regs(RIG *rig, unsigned char IICadr, int reg_count, unsigned char reg_adr, - unsigned char reg_val1, unsigned char reg_val2, unsigned char reg_val3) + unsigned char reg_val1, unsigned char reg_val2, unsigned char reg_val3) { struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv; int ret; @@ -1202,15 +1250,17 @@ int i2c_write_regs(RIG *rig, unsigned char IICadr, int reg_count, unsigned char ftdi_I2C_Init(rig); ftdi_I2C_Start(rig); - ftdi_I2C_Write_Byte (rig, IICadr); - ftdi_I2C_Write_Byte (rig, reg_adr); + ftdi_I2C_Write_Byte(rig, IICadr); + ftdi_I2C_Write_Byte(rig, reg_adr); if (reg_count >= 1) - ftdi_I2C_Write_Byte (rig, reg_val1); + ftdi_I2C_Write_Byte(rig, reg_val1); + if (reg_count >= 2) - ftdi_I2C_Write_Byte (rig, reg_val2); + ftdi_I2C_Write_Byte(rig, reg_val2); + if (reg_count >= 3) - ftdi_I2C_Write_Byte (rig, reg_val3); + ftdi_I2C_Write_Byte(rig, reg_val3); ftdi_I2C_Stop(rig); //usleep(10000); @@ -1219,26 +1269,27 @@ int i2c_write_regs(RIG *rig, unsigned char IICadr, int reg_count, unsigned char if (ret != 0) return -RIG_EIO; + return 0; } #if 0 static const unsigned char ftdi_code[256] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x34, 0x08, 0x5a, 0x24/*0x6f*/, 0x00, 0x14, 0x0a, 0x00, 0x08, 0x88, - 0x50, 0x04, 0x32, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xd1, 0x2b, 0x17, 0x00, 0xfe, 0xfe, 0x7f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, - 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x34, 0x08, 0x5a, 0x24/*0x6f*/, 0x00, 0x14, 0x0a, 0x00, 0x08, 0x88, + 0x50, 0x04, 0x32, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xd1, 0x2b, 0x17, 0x00, 0xfe, 0xfe, 0x7f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, + 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32, 0x10, 0x32 }; int load_ftdi_code(RIG *rig, unsigned char IICadr, const unsigned char code[]) @@ -1247,24 +1298,24 @@ int load_ftdi_code(RIG *rig, unsigned char IICadr, const unsigned char code[]) int ret; int i, j; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); - for (i = 0; i<16; i++) - { + for (i = 0; i < 16; i++) { /* Start with a new buffer */ priv->Buf_adr = 0; ftdi_I2C_Init(rig); ftdi_I2C_Start(rig); - ftdi_I2C_Write_Byte (rig, IICadr); - ftdi_I2C_Write_Byte (rig, i*16); + ftdi_I2C_Write_Byte(rig, IICadr); + ftdi_I2C_Write_Byte(rig, i * 16); - for (j = 0; j<16; j++) - { - ftdi_I2C_Write_Byte (rig, code[i*16+j]); + for (j = 0; j < 16; j++) { + ftdi_I2C_Write_Byte(rig, code[i * 16 + j]); } + ftdi_I2C_Stop(rig); ret = elektor507_ftdi_write_data(rig, priv->FT_Out_Buffer, priv->Buf_adr); + if (ret != 0) return -RIG_EIO; } diff --git a/kit/fifisdr.c b/kit/fifisdr.c index c551a8e4c..d6cbf71a6 100644 --- a/kit/fifisdr.c +++ b/kit/fifisdr.c @@ -91,7 +91,7 @@ static int fifisdr_set_freq(RIG *rig, vfo_t vfo, freq_t freq); static int fifisdr_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); static const char *fifisdr_get_info(RIG *rig); static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); -static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * width); +static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); static int fifisdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val); static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *val); @@ -105,7 +105,8 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va /* Extra levels definitions */ static const struct confparams fifisdr_ext_levels[] = { - { TOK_LVL_FMCENTER, "fmcenter", "FM center", "Center frequency deviation of FM signal", + { + TOK_LVL_FMCENTER, "fmcenter", "FM center", "Center frequency deviation of FM signal", NULL, RIG_CONF_NUMERIC, { .n = { -kHz(5), kHz(5), Hz(1) } } }, { RIG_CONF_END, NULL, } @@ -169,18 +170,22 @@ const struct rig_caps fifisdr_caps = { }, .rx_range_list1 = { - {.start = kHz(39.1), .end = MHz(175.0), - .modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM, - .low_power = -1, .high_power = -1, - .vfo = RIG_VFO_A, .ant = RIG_ANT_1}, + { + .start = kHz(39.1), .end = MHz(175.0), + .modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM, + .low_power = -1, .high_power = -1, + .vfo = RIG_VFO_A, .ant = RIG_ANT_1 + }, RIG_FRNG_END, }, .tx_range_list1 = { RIG_FRNG_END, }, .rx_range_list2 = { - {.start = kHz(39.1), .end = MHz(175.0), - .modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM, - .low_power = -1, .high_power = -1, - .vfo = RIG_VFO_A, .ant = RIG_ANT_1}, + { + .start = kHz(39.1), .end = MHz(175.0), + .modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM, + .low_power = -1, .high_power = -1, + .vfo = RIG_VFO_A, .ant = RIG_ANT_1 + }, RIG_FRNG_END, }, .tx_range_list2 = { RIG_FRNG_END, }, @@ -239,7 +244,7 @@ const struct rig_caps fifisdr_caps = { /** Convert from host endianness to FiFi-SDR little endian. */ -static uint32_t fifisdr_tole32 (uint32_t x) +static uint32_t fifisdr_tole32(uint32_t x) { return (((((x) / 1ul) % 256ul) << 0) | @@ -251,7 +256,7 @@ static uint32_t fifisdr_tole32 (uint32_t x) /** Convert FiFi-SDR little endian to host endianness. */ -static uint32_t fifisdr_fromle32 (uint32_t x) +static uint32_t fifisdr_fromle32(uint32_t x) { return (((((x) >> 24) & 0xFF) * 16777216ul) + @@ -263,22 +268,22 @@ static uint32_t fifisdr_fromle32 (uint32_t x) /** USB OUT transfer via vendor device command. */ -static int fifisdr_usb_write (RIG *rig, - int request, int value, int index, - unsigned char *bytes, int size) +static int fifisdr_usb_write(RIG *rig, + int request, int value, int index, + unsigned char *bytes, int size) { int ret; libusb_device_handle *udh = rig->state.rigport.handle; ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT, - request, value, index, - bytes, size, rig->state.rigport.timeout); + request, value, index, + bytes, size, rig->state.rigport.timeout); if (ret != size) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n", - __func__, - request, value, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n", + __func__, + request, value, + libusb_error_name(ret)); return -RIG_EIO; } @@ -288,22 +293,22 @@ static int fifisdr_usb_write (RIG *rig, /** USB IN transfer via vendor device command. */ -static int fifisdr_usb_read (RIG *rig, - int request, int value, int index, - unsigned char *bytes, int size) +static int fifisdr_usb_read(RIG *rig, + int request, int value, int index, + unsigned char *bytes, int size) { int ret; libusb_device_handle *udh = rig->state.rigport.handle; ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN, - request, value, index, - bytes, size, rig->state.rigport.timeout); + request, value, index, + bytes, size, rig->state.rigport.timeout); if (ret != size) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n", - __func__, - request, value, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n", + __func__, + request, value, + libusb_error_name(ret)); return -RIG_EIO; } @@ -312,12 +317,13 @@ static int fifisdr_usb_read (RIG *rig, -int fifisdr_init (RIG *rig) +int fifisdr_init(RIG *rig) { hamlib_port_t *rp = &rig->state.rigport; struct fifisdr_priv_instance_data *priv; - priv = (struct fifisdr_priv_instance_data*)calloc(sizeof(struct fifisdr_priv_instance_data), 1); + priv = (struct fifisdr_priv_instance_data *)calloc(sizeof(struct fifisdr_priv_instance_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -336,20 +342,21 @@ int fifisdr_init (RIG *rig) rp->parm.usb.vendor_name = FIFISDR_VENDOR_NAME; rp->parm.usb.product = FIFISDR_PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } -int fifisdr_cleanup (RIG *rig) +int fifisdr_cleanup(RIG *rig) { if (!rig) return -RIG_EINVAL; if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; @@ -357,19 +364,20 @@ int fifisdr_cleanup (RIG *rig) -int fifisdr_open (RIG *rig) +int fifisdr_open(RIG *rig) { int ret; uint32_t multiply; struct fifisdr_priv_instance_data *priv; - priv = (struct fifisdr_priv_instance_data*)rig->state.priv; + priv = (struct fifisdr_priv_instance_data *)rig->state.priv; /* The VCO is a multiple of the RX frequency. Typically 4 */ ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 11, /* Read virtual VCO factor */ - (unsigned char *)&multiply, sizeof(multiply)); + 11, /* Read virtual VCO factor */ + (unsigned char *)&multiply, sizeof(multiply)); + if (ret == RIG_OK) { priv->multiplier = fifisdr_fromle32(multiply); } @@ -379,13 +387,14 @@ int fifisdr_open (RIG *rig) -const char * fifisdr_get_info (RIG *rig) +const char *fifisdr_get_info(RIG *rig) { static char buf[64]; int ret; uint32_t svn_version; ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, 0, (unsigned char *)&svn_version, sizeof(svn_version)); + if (ret != RIG_OK) { return NULL; } @@ -397,7 +406,7 @@ const char * fifisdr_get_info (RIG *rig) -int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq) +int fifisdr_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { struct fifisdr_priv_instance_data *priv = (struct fifisdr_priv_instance_data *)rig->state.priv; int ret; @@ -410,7 +419,8 @@ int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq) freq1121 = fifisdr_tole32(round(mhz * 2097152.0)); ret = fifisdr_usb_write(rig, REQUEST_SET_FREQ_BY_VALUE, 0, 0, - (unsigned char *)&freq1121, sizeof(freq1121)); + (unsigned char *)&freq1121, sizeof(freq1121)); + if (ret != RIG_OK) { return -RIG_EIO; } @@ -420,7 +430,7 @@ int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq) -int fifisdr_get_freq (RIG *rig, vfo_t vfo, freq_t *freq) +int fifisdr_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { struct fifisdr_priv_instance_data *priv = (struct fifisdr_priv_instance_data *)rig->state.priv; int ret; @@ -447,25 +457,32 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) /* Translate mode into FiFi-SDR language */ fifi_mode = 0; + switch (mode) { - case RIG_MODE_AM: - fifi_mode = 2; - break; - case RIG_MODE_LSB: - fifi_mode = 0; - break; - case RIG_MODE_USB: - fifi_mode = 1; - break; - case RIG_MODE_FM: - fifi_mode = 3; - break; - default: - return -RIG_EINVAL; + case RIG_MODE_AM: + fifi_mode = 2; + break; + + case RIG_MODE_LSB: + fifi_mode = 0; + break; + + case RIG_MODE_USB: + fifi_mode = 1; + break; + + case RIG_MODE_FM: + fifi_mode = 3; + break; + + default: + return -RIG_EINVAL; } + ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 15, /* Demodulator mode */ - (unsigned char *)&fifi_mode, sizeof(fifi_mode)); + 15, /* Demodulator mode */ + (unsigned char *)&fifi_mode, sizeof(fifi_mode)); + if (ret != RIG_OK) { return -RIG_EIO; } @@ -473,8 +490,9 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) /* Set filter width */ fifi_width = fifisdr_tole32(width); ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 16, /* Filter width */ - (unsigned char *)&fifi_width, sizeof(fifi_width)); + 16, /* Filter width */ + (unsigned char *)&fifi_width, sizeof(fifi_width)); + if (ret != RIG_OK) { return -RIG_EIO; } @@ -484,7 +502,7 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) -static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * width) +static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { int ret; uint8_t fifi_mode; @@ -493,8 +511,8 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt /* Read current mode */ ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 15, /* Demodulator mode */ - (unsigned char *)&fifi_mode, sizeof(fifi_mode)); + 15, /* Demodulator mode */ + (unsigned char *)&fifi_mode, sizeof(fifi_mode)); if (ret != RIG_OK) { return -RIG_EIO; @@ -502,25 +520,30 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt /* Translate mode coding */ *mode = RIG_MODE_NONE; + switch (fifi_mode) { - case 0: - *mode = RIG_MODE_LSB; - break; - case 1: - *mode = RIG_MODE_USB; - break; - case 2: - *mode = RIG_MODE_AM; - break; - case 3: - *mode = RIG_MODE_FM; - break; + case 0: + *mode = RIG_MODE_LSB; + break; + + case 1: + *mode = RIG_MODE_USB; + break; + + case 2: + *mode = RIG_MODE_AM; + break; + + case 3: + *mode = RIG_MODE_FM; + break; } /* Read current filter width */ ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 16, /* Filter width */ - (unsigned char *)&fifi_width, sizeof(fifi_width)); + 16, /* Filter width */ + (unsigned char *)&fifi_width, sizeof(fifi_width)); + if (ret != RIG_OK) { return -RIG_EIO; } @@ -532,7 +555,7 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt -static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val) +static int fifisdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { int ret = RIG_OK; uint8_t fifi_preamp; @@ -542,69 +565,85 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val switch (level) { - /* Preamplifier (ADC 0/+6dB switch) */ - case RIG_LEVEL_PREAMP: - /* Value can be 0 (0 dB) or 1 (+6 dB) */ - fifi_preamp = 0; - if (val.i == 6) { - fifi_preamp = 1; - } - ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 19, /* Preamp */ - (unsigned char *)&fifi_preamp, sizeof(fifi_preamp)); + /* Preamplifier (ADC 0/+6dB switch) */ + case RIG_LEVEL_PREAMP: + /* Value can be 0 (0 dB) or 1 (+6 dB) */ + fifi_preamp = 0; + + if (val.i == 6) { + fifi_preamp = 1; + } + + ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, + 19, /* Preamp */ + (unsigned char *)&fifi_preamp, sizeof(fifi_preamp)); break; - /* RX volume control */ - case RIG_LEVEL_AF: - /* Transform Hamlib value (float: 0...1) to an integer range (0...100) */ - fifi_volume = (int16_t)(val.f * 100.0f); - if (fifi_volume < 0) { - fifi_volume = 0; - } - if (fifi_volume > 100) { - fifi_volume = 100; - } - ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 14, /* Demodulator volume */ - (unsigned char *)&fifi_volume, sizeof(fifi_volume)); + /* RX volume control */ + case RIG_LEVEL_AF: + /* Transform Hamlib value (float: 0...1) to an integer range (0...100) */ + fifi_volume = (int16_t)(val.f * 100.0f); + + if (fifi_volume < 0) { + fifi_volume = 0; + } + + if (fifi_volume > 100) { + fifi_volume = 100; + } + + ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, + 14, /* Demodulator volume */ + (unsigned char *)&fifi_volume, sizeof(fifi_volume)); break; - /* Squelch level */ - case RIG_LEVEL_SQL: - /* Transform Hamlib value (float: 0...1) to an integer range (0...100) */ - fifi_squelch = (uint8_t)(val.f * 100.0f); - if (fifi_squelch < 0) { - fifi_squelch = 0; - } - if (fifi_squelch > 100) { - fifi_squelch = 100; - } - ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 20, /* Squelch control */ - (unsigned char *)&fifi_squelch, sizeof(fifi_squelch)); + /* Squelch level */ + case RIG_LEVEL_SQL: + /* Transform Hamlib value (float: 0...1) to an integer range (0...100) */ + fifi_squelch = (uint8_t)(val.f * 100.0f); + + if (fifi_squelch < 0) { + fifi_squelch = 0; + } + + if (fifi_squelch > 100) { + fifi_squelch = 100; + } + + ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, + 20, /* Squelch control */ + (unsigned char *)&fifi_squelch, sizeof(fifi_squelch)); break; - /* AGC */ - case RIG_LEVEL_AGC: - /* Transform Hamlib enum value to FiFi-SDR selector */ - fifi_agc = 0; - switch ((enum agc_level_e)val.i) { - case RIG_AGC_OFF: fifi_agc = 0; break; - case RIG_AGC_SUPERFAST: fifi_agc = 1; break; - case RIG_AGC_FAST: fifi_agc = 2; break; - case RIG_AGC_SLOW: fifi_agc = 3; break; - case RIG_AGC_USER: fifi_agc = 4; break; - case RIG_AGC_MEDIUM: fifi_agc = 5; break; - case RIG_AGC_AUTO: fifi_agc = 6; break; - } - ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, - 21, /* AGC template */ - (unsigned char *)&fifi_agc, sizeof(fifi_agc)); + /* AGC */ + case RIG_LEVEL_AGC: + /* Transform Hamlib enum value to FiFi-SDR selector */ + fifi_agc = 0; + + switch ((enum agc_level_e)val.i) { + case RIG_AGC_OFF: fifi_agc = 0; break; + + case RIG_AGC_SUPERFAST: fifi_agc = 1; break; + + case RIG_AGC_FAST: fifi_agc = 2; break; + + case RIG_AGC_SLOW: fifi_agc = 3; break; + + case RIG_AGC_USER: fifi_agc = 4; break; + + case RIG_AGC_MEDIUM: fifi_agc = 5; break; + + case RIG_AGC_AUTO: fifi_agc = 6; break; + } + + ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0, + 21, /* AGC template */ + (unsigned char *)&fifi_agc, sizeof(fifi_agc)); break; - /* Unsupported option */ - default: - ret = -RIG_ENIMPL; + /* Unsupported option */ + default: + ret = -RIG_ENIMPL; } return ret; @@ -623,80 +662,100 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) switch (level) { - /* Preamplifier (ADC 0/+6dB switch) */ - case RIG_LEVEL_PREAMP: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 19, /* Preamp */ - (unsigned char *)&fifi_preamp, sizeof(fifi_preamp)); - if (ret == RIG_OK) { - /* Value can be 0 (0 dB) or 1 (+6 dB) */ - val->i = 0; - if (fifi_preamp != 0) { - val->i = 6; - } + /* Preamplifier (ADC 0/+6dB switch) */ + case RIG_LEVEL_PREAMP: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 19, /* Preamp */ + (unsigned char *)&fifi_preamp, sizeof(fifi_preamp)); + + if (ret == RIG_OK) { + /* Value can be 0 (0 dB) or 1 (+6 dB) */ + val->i = 0; + + if (fifi_preamp != 0) { + val->i = 6; } + } + break; - /* RX volume control */ - case RIG_LEVEL_AF: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 14, /* Demodulator volume */ - (unsigned char *)&fifi_volume, sizeof(fifi_volume)); - if (ret == RIG_OK) { - /* Value is in % (0...100) */ - val->f = 0.0f; - if ((fifi_volume >=0) && (fifi_volume <= 100)) { - val->f = (float)fifi_volume / 100.0f; - } + /* RX volume control */ + case RIG_LEVEL_AF: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 14, /* Demodulator volume */ + (unsigned char *)&fifi_volume, sizeof(fifi_volume)); + + if (ret == RIG_OK) { + /* Value is in % (0...100) */ + val->f = 0.0f; + + if ((fifi_volume >= 0) && (fifi_volume <= 100)) { + val->f = (float)fifi_volume / 100.0f; } + } + break; - /* Squelch level */ - case RIG_LEVEL_SQL: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 20, /* Squelch control */ - (unsigned char *)&fifi_squelch, sizeof(fifi_squelch)); - if (ret == RIG_OK) { - /* Value is in % (0...100) */ - val->f = 0.0f; - if (fifi_squelch <= 100) { - val->f = (float)fifi_squelch / 100.0f; - } + /* Squelch level */ + case RIG_LEVEL_SQL: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 20, /* Squelch control */ + (unsigned char *)&fifi_squelch, sizeof(fifi_squelch)); + + if (ret == RIG_OK) { + /* Value is in % (0...100) */ + val->f = 0.0f; + + if (fifi_squelch <= 100) { + val->f = (float)fifi_squelch / 100.0f; } + } + break; - /* AGC */ - case RIG_LEVEL_AGC: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 21, /* AGC template */ - (unsigned char *)&fifi_agc, sizeof(fifi_agc)); - if (ret == RIG_OK) { - val->i = 0; - switch (fifi_agc) { - case 0: val->i = RIG_AGC_OFF; break; - case 1: val->i = RIG_AGC_SUPERFAST; break; - case 2: val->i = RIG_AGC_FAST; break; - case 3: val->i = RIG_AGC_SLOW; break; - case 4: val->i = RIG_AGC_USER; break; - case 5: val->i = RIG_AGC_MEDIUM; break; - case 6: val->i = RIG_AGC_AUTO; break; - } + /* AGC */ + case RIG_LEVEL_AGC: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 21, /* AGC template */ + (unsigned char *)&fifi_agc, sizeof(fifi_agc)); + + if (ret == RIG_OK) { + val->i = 0; + + switch (fifi_agc) { + case 0: val->i = RIG_AGC_OFF; break; + + case 1: val->i = RIG_AGC_SUPERFAST; break; + + case 2: val->i = RIG_AGC_FAST; break; + + case 3: val->i = RIG_AGC_SLOW; break; + + case 4: val->i = RIG_AGC_USER; break; + + case 5: val->i = RIG_AGC_MEDIUM; break; + + case 6: val->i = RIG_AGC_AUTO; break; } + } + break; - /* Signal strength */ - case RIG_LEVEL_STRENGTH: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 17, /* S-Meter */ - (unsigned char *)&fifi_meter, sizeof(fifi_meter)); - if (ret == RIG_OK) { - val->i = fifisdr_fromle32(fifi_meter); - } + /* Signal strength */ + case RIG_LEVEL_STRENGTH: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 17, /* S-Meter */ + (unsigned char *)&fifi_meter, sizeof(fifi_meter)); + + if (ret == RIG_OK) { + val->i = fifisdr_fromle32(fifi_meter); + } + break; - /* Unsupported option */ - default: - ret = -RIG_ENIMPL; + /* Unsupported option */ + default: + ret = -RIG_ENIMPL; } return ret; @@ -711,19 +770,21 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va switch (token) { - /* FM center frequency deviation */ - case TOK_LVL_FMCENTER: - ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, - 18, /* FM center frequency */ - (unsigned char *)&u32, sizeof(u32)); - if (ret == RIG_OK) { - val->f = Hz((int32_t)fifisdr_fromle32(u32)); - } + /* FM center frequency deviation */ + case TOK_LVL_FMCENTER: + ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, + 18, /* FM center frequency */ + (unsigned char *)&u32, sizeof(u32)); + + if (ret == RIG_OK) { + val->f = Hz((int32_t)fifisdr_fromle32(u32)); + } + break; - /* Unsupported option */ - default: - ret = -RIG_ENIMPL; + /* Unsupported option */ + default: + ret = -RIG_ENIMPL; } return ret; diff --git a/kit/funcube.c b/kit/funcube.c index 69ee68317..73ab0f73d 100644 --- a/kit/funcube.c +++ b/kit/funcube.c @@ -88,126 +88,126 @@ struct funcube_priv_data { */ const struct rig_caps funcube_caps = { -.rig_model = RIG_MODEL_FUNCUBEDONGLE, -.model_name = "FUNcube Dongle", -.mfg_name = "AMSAT-UK", -.version = "0.3", -.copyright = "GPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 1000, -.retry = 0, + .rig_model = RIG_MODEL_FUNCUBEDONGLE, + .model_name = "FUNcube Dongle", + .mfg_name = "AMSAT-UK", + .version = "0.3", + .copyright = "GPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 1000, + .retry = 0, -.has_get_func = RIG_FUNC_NONE, -.has_set_func = RIG_FUNC_NONE, -.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP, -.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP, -.has_get_parm = RIG_PARM_NONE, -.has_set_parm = RIG_PARM_NONE, -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, }, -.attenuator = { 2, 5, RIG_DBLST_END, }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = RIG_FUNC_NONE, + .has_set_func = RIG_FUNC_NONE, + .has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP, + .has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP, + .has_get_parm = RIG_PARM_NONE, + .has_set_parm = RIG_PARM_NONE, + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, }, + .attenuator = { 2, 5, RIG_DBLST_END, }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {MHz(50),MHz(2500),RIG_MODE_USB,-1,-1,RIG_VFO_A}, - RIG_FRNG_END, - }, -.tuning_steps = { - {RIG_MODE_USB,kHz(1)}, - RIG_TS_END, + .rx_range_list1 = { + {MHz(50), MHz(2500), RIG_MODE_USB, -1, -1, RIG_VFO_A}, + RIG_FRNG_END, }, -.filters = { - {RIG_MODE_USB, kHz(192)}, - RIG_FLT_END, - }, -.cfgparams = funcube_cfg_params, + .tuning_steps = { + {RIG_MODE_USB, kHz(1)}, + RIG_TS_END, + }, + .filters = { + {RIG_MODE_USB, kHz(192)}, + RIG_FLT_END, + }, + .cfgparams = funcube_cfg_params, -.rig_init = funcube_init, -.rig_cleanup = funcube_cleanup, -.set_freq = funcube_set_freq, -.get_freq = funcube_get_freq, -.get_level = funcube_get_level, -.set_level = funcube_set_level, -.get_info = funcube_get_info, + .rig_init = funcube_init, + .rig_cleanup = funcube_cleanup, + .set_freq = funcube_set_freq, + .get_freq = funcube_get_freq, + .get_level = funcube_get_level, + .set_level = funcube_set_level, + .get_info = funcube_get_info, }; const struct rig_caps funcubeplus_caps = { -.rig_model = RIG_MODEL_FUNCUBEDONGLEPLUS, -.model_name = "FUNcube Dongle Pro+", -.mfg_name = "AMSAT-UK", -.version = "0.3", -.copyright = "GPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 1000, -.retry = 0, + .rig_model = RIG_MODEL_FUNCUBEDONGLEPLUS, + .model_name = "FUNcube Dongle Pro+", + .mfg_name = "AMSAT-UK", + .version = "0.3", + .copyright = "GPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 1000, + .retry = 0, -.has_get_func = RIG_FUNC_NONE, -.has_set_func = RIG_FUNC_NONE, -.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP, -.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP, -.has_get_parm = RIG_PARM_NONE, -.has_set_parm = RIG_PARM_NONE, -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, }, -.attenuator = { 2, 5, RIG_DBLST_END, }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = RIG_FUNC_NONE, + .has_set_func = RIG_FUNC_NONE, + .has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP, + .has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP, + .has_get_parm = RIG_PARM_NONE, + .has_set_parm = RIG_PARM_NONE, + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, }, + .attenuator = { 2, 5, RIG_DBLST_END, }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {kHz(150),MHz(1900),RIG_MODE_USB,-1,-1,RIG_VFO_A}, - RIG_FRNG_END, - }, -.tuning_steps = { - {RIG_MODE_USB,kHz(1)}, - RIG_TS_END, + .rx_range_list1 = { + {kHz(150), MHz(1900), RIG_MODE_USB, -1, -1, RIG_VFO_A}, + RIG_FRNG_END, }, -.filters = { - {RIG_MODE_USB, kHz(192)}, - RIG_FLT_END, - }, -.cfgparams = funcube_cfg_params, + .tuning_steps = { + {RIG_MODE_USB, kHz(1)}, + RIG_TS_END, + }, + .filters = { + {RIG_MODE_USB, kHz(192)}, + RIG_FLT_END, + }, + .cfgparams = funcube_cfg_params, -.rig_init = funcubeplus_init, -.rig_cleanup = funcube_cleanup, -.set_freq = funcube_set_freq, -.get_freq = funcube_get_freq, -.get_level = funcube_get_level, -.set_level = funcube_set_level, -.get_info = funcube_get_info, + .rig_init = funcubeplus_init, + .rig_cleanup = funcube_cleanup, + .set_freq = funcube_set_freq, + .get_freq = funcube_get_freq, + .get_level = funcube_get_level, + .set_level = funcube_set_level, + .get_info = funcube_get_info, }; int funcube_init(RIG *rig) @@ -215,7 +215,8 @@ int funcube_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct funcube_priv_data *priv; - priv = (struct funcube_priv_data*)calloc(sizeof(struct funcube_priv_data), 1); + priv = (struct funcube_priv_data *)calloc(sizeof(struct funcube_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -232,7 +233,7 @@ int funcube_init(RIG *rig) rp->parm.usb.vendor_name = VENDOR_NAME; rp->parm.usb.product = PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -242,7 +243,8 @@ int funcubeplus_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct funcube_priv_data *priv; - priv = (struct funcube_priv_data*)calloc(sizeof(struct funcube_priv_data), 1); + priv = (struct funcube_priv_data *)calloc(sizeof(struct funcube_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -259,7 +261,7 @@ int funcubeplus_init(RIG *rig) rp->parm.usb.vendor_name = VENDOR_NAME; rp->parm.usb.product = PRODUCT_NAMEPLUS; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -271,13 +273,14 @@ int funcube_cleanup(RIG *rig) if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; } /* Rem: not reentrant */ -const char * funcube_get_info(RIG *rig) +const char *funcube_get_info(RIG *rig) { static char buf[64]; libusb_device_handle *udh = rig->state.rigport.handle; @@ -302,38 +305,36 @@ int set_freq_v0(libusb_device_handle *udh, unsigned int f, int timeout) // frequency is in Hz, while the dongle expects it in kHz f = f / 1000; - au8BufOut[0]=REQUEST_SET_FREQ; // Command to Set Frequency on dongle - au8BufOut[1]=(unsigned char)f; - au8BufOut[2]=(unsigned char)(f>>8); - au8BufOut[3]=(unsigned char)(f>>16); + au8BufOut[0] = REQUEST_SET_FREQ; // Command to Set Frequency on dongle + au8BufOut[1] = (unsigned char)f; + au8BufOut[2] = (unsigned char)(f >> 8); + au8BufOut[3] = (unsigned char)(f >> 16); rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n", - __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); + __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); - ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout); + ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout); - if( ret < 0 ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__,ret, libusb_error_name (ret)); + if (ret < 0) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, libusb_error_name(ret)); return -RIG_EIO; - } + } - ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout); + ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout); - if( ret < 0 || actual_length != sizeof(au8BufIn) ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__, ret, libusb_error_name (ret)); + if (ret < 0 || actual_length != sizeof(au8BufIn)) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, libusb_error_name(ret)); return -RIG_EIO; - } + } rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n", - __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF); + __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF); if (au8BufIn[1] != FUNCUBE_SUCCESS) { - rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ not supported\n", - __func__); + rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ not supported\n", + __func__); return -RIG_EIO; } @@ -348,43 +349,41 @@ int set_freq_v1(libusb_device_handle *udh, unsigned int f, int timeout) unsigned char au8BufOut[64]; // endpoint size unsigned char au8BufIn[64]; // endpoint size - au8BufOut[0]=REQUEST_SET_FREQ_HZ; // Command to Set Frequency in Hz on dongle - au8BufOut[1]=(unsigned char)f; - au8BufOut[2]=(unsigned char)(f>>8); - au8BufOut[3]=(unsigned char)(f>>16); - au8BufOut[4]=(unsigned char)(f>>24); + au8BufOut[0] = REQUEST_SET_FREQ_HZ; // Command to Set Frequency in Hz on dongle + au8BufOut[1] = (unsigned char)f; + au8BufOut[2] = (unsigned char)(f >> 8); + au8BufOut[3] = (unsigned char)(f >> 16); + au8BufOut[4] = (unsigned char)(f >> 24); rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x%02x\n", - __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF, - au8BufOut[4] & 0xFF); + __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF, + au8BufOut[4] & 0xFF); - ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout); + ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout); - if( ret < 0 ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__,ret, - libusb_error_name (ret)); + if (ret < 0) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); return -RIG_EIO; - } + } - ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout); + ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout); - if( ret < 0 || actual_length != sizeof(au8BufIn) ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__, ret, - libusb_error_name (ret)); + if (ret < 0 || actual_length != sizeof(au8BufIn)) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); return -RIG_EIO; - } + } rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n", - __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF, - au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF); + __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF, + au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF); if (au8BufIn[1] != FUNCUBE_SUCCESS) { - rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ_HZ not supported\n", - __func__); + rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ_HZ not supported\n", + __func__); return -RIG_EIO; } @@ -401,8 +400,7 @@ int funcube_set_freq(RIG *rig, vfo_t vfo, freq_t freq) if ((ret = set_freq_v0(udh, freq, rig->state.rigport.timeout)) == RIG_OK) { priv->freq = freq; } - } - else { + } else { priv->freq = freq; } @@ -413,7 +411,7 @@ int get_freq_v0(RIG *rig, vfo_t vfo, freq_t *freq) { struct funcube_priv_data *priv = (struct funcube_priv_data *)rig->state.priv; - rig_debug(RIG_DEBUG_TRACE, "%s: frequency is not read from the device, the value shown is the last successfully set.\n",__func__); + rig_debug(RIG_DEBUG_TRACE, "%s: frequency is not read from the device, the value shown is the last successfully set.\n", __func__); *freq = priv->freq; return RIG_OK; @@ -429,43 +427,41 @@ int get_freq_v1(RIG *rig, vfo_t vfo, freq_t *freq) unsigned char au8BufOut[64]; // endpoint size unsigned char au8BufIn[64]; // endpoint size - au8BufOut[0]=REQUEST_GET_FREQ_HZ; // Command to Set Frequency on dongle + au8BufOut[0] = REQUEST_GET_FREQ_HZ; // Command to Set Frequency on dongle rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n", - __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); + __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); - ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); - if( ret < 0 ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__,ret, - libusb_error_name (ret)); - } + if (ret < 0) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } - ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); - if( ret < 0 || actual_length != sizeof(au8BufIn) ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__, ret, - libusb_error_name (ret)); - } + if (ret < 0 || actual_length != sizeof(au8BufIn)) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n", - __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF, - au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF); + __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF, + au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF); if (au8BufIn[1] != FUNCUBE_SUCCESS) { - rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", - __func__); + rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", + __func__); return -RIG_EIO; } f = (au8BufIn[2] & 0xFF) | ((au8BufIn[3] & 0xFF) << 8) | - ((au8BufIn[4] & 0xFF) << 16) | ((au8BufIn[5] & 0xFF) << 24), + ((au8BufIn[4] & 0xFF) << 16) | ((au8BufIn[5] & 0xFF) << 24), - *freq = f; + *freq = f; return RIG_OK; } @@ -491,79 +487,87 @@ int funcube_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) switch (level) { case RIG_LEVEL_PREAMP: - au8BufOut[0]=REQUEST_SET_LNA_GAIN; // Command to Set LNA gain + au8BufOut[0] = REQUEST_SET_LNA_GAIN; // Command to Set LNA gain switch (val.i) { - case 5: - au8BufOut[1]=6; + case 5: + au8BufOut[1] = 6; break; - case 10: - au8BufOut[1]=8; + + case 10: + au8BufOut[1] = 8; break; - case 15: - au8BufOut[1]=10; + + case 15: + au8BufOut[1] = 10; break; - case 20: - au8BufOut[1]=12; + + case 20: + au8BufOut[1] = 12; break; - case 25: - au8BufOut[1]=13; + + case 25: + au8BufOut[1] = 13; break; - case 30: - au8BufOut[1]=14; + + case 30: + au8BufOut[1] = 14; break; - default: - au8BufOut[1]=4; + + default: + au8BufOut[1] = 4; } - break; + + break; case RIG_LEVEL_ATT: - au8BufOut[0]=REQUEST_SET_LNA_GAIN; // Command to Set LNA gain + au8BufOut[0] = REQUEST_SET_LNA_GAIN; // Command to Set LNA gain switch (val.i) { - case 2: - au8BufOut[1]=1; + case 2: + au8BufOut[1] = 1; break; - case 5: - au8BufOut[1]=0; + + case 5: + au8BufOut[1] = 0; break; - default: - au8BufOut[1]=4; + + default: + au8BufOut[1] = 4; } - break; + + break; default: - rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level); + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level); return -RIG_EINVAL; } rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n", - __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); + __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); - ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); - if( ret < 0 ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__,ret, - libusb_error_name (ret)); - } + if (ret < 0) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } - ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); - if( ret < 0 || actual_length != sizeof(au8BufIn) ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__, ret, - libusb_error_name (ret)); - } + if (ret < 0 || actual_length != sizeof(au8BufIn)) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n", - __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF); + __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF); if (au8BufIn[1] != FUNCUBE_SUCCESS) { - rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", - __func__); + rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", + __func__); return -RIG_EIO; } @@ -580,94 +584,102 @@ int funcube_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) switch (level) { case RIG_LEVEL_ATT: case RIG_LEVEL_PREAMP: - au8BufOut[0]=REQUEST_GET_LNA_GAIN; // Command to Get LNA / ATT gain - break; + au8BufOut[0] = REQUEST_GET_LNA_GAIN; // Command to Get LNA / ATT gain + break; case RIG_LEVEL_STRENGTH: - au8BufOut[0]=REQUEST_GET_RSSI; + au8BufOut[0] = REQUEST_GET_RSSI; break; default: - rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level); + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level); return -RIG_EINVAL; } rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n", - __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); + __func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF); - ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout); - if( ret < 0 ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__,ret, - libusb_error_name (ret)); - } + if (ret < 0) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } - ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); + ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout); - if( ret < 0 || actual_length != sizeof(au8BufIn) ) - { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", - __func__, ret, - libusb_error_name (ret)); - } + if (ret < 0 || actual_length != sizeof(au8BufIn)) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n", + __func__, ret, + libusb_error_name(ret)); + } rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x\n", - __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF); + __func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF); if (au8BufIn[1] != FUNCUBE_SUCCESS) { - rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", - __func__); + rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n", + __func__); return -RIG_EIO; } switch (level) { - case RIG_LEVEL_PREAMP: - switch (au8BufIn[2]) { - case 6: - val->i = 5; - break; - case 8: - val->i = 10; - break; - case 10: - val->i = 15; - break; - case 12: - val->i = 20; - break; - case 13: - val->i = 25; - break; - case 14: - val->i = 30; - break; - default: - val->i = 0; - } - break; + case RIG_LEVEL_PREAMP: + switch (au8BufIn[2]) { + case 6: + val->i = 5; + break; - case RIG_LEVEL_ATT: - switch (au8BufIn[2]) { - case 0: - val->i = 5; - break; - case 1: - val->i = 2; - break; - default: - val->i = 0; - } - break; + case 8: + val->i = 10; + break; - case RIG_LEVEL_STRENGTH: - val->i = (int)((float)au8BufIn[2] * 2.8 - 35); - break; + case 10: + val->i = 15; + break; + + case 12: + val->i = 20; + break; + + case 13: + val->i = 25; + break; + + case 14: + val->i = 30; + break; default: - rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level); - return -RIG_EINVAL; + val->i = 0; + } + + break; + + case RIG_LEVEL_ATT: + switch (au8BufIn[2]) { + case 0: + val->i = 5; + break; + + case 1: + val->i = 2; + break; + + default: + val->i = 0; + } + + break; + + case RIG_LEVEL_STRENGTH: + val->i = (int)((float)au8BufIn[2] * 2.8 - 35); + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level); + return -RIG_EINVAL; } return RIG_OK; diff --git a/kit/kit.c b/kit/kit.c index aaaa27df0..138c3ed27 100644 --- a/kit/kit.c +++ b/kit/kit.c @@ -57,7 +57,7 @@ DECLARE_INITRIG_BACKEND(kit) rig_register(&funcubeplus_caps); #endif #if (defined(HAVE_LIBUSB) && (defined(HAVE_LIBUSB_H) || defined(HAVE_LIBUSB_1_0_LIBUSB_H))) || defined(_WIN32) - /* rigs with alternate DLL support on Win32 */ + /* rigs with alternate DLL support on Win32 */ rig_register(&dwt_caps); rig_register(&elektor507_caps); #endif diff --git a/kit/si570avrusb.c b/kit/si570avrusb.c index 6fda2f096..2a584828c 100644 --- a/kit/si570avrusb.c +++ b/kit/si570avrusb.c @@ -65,7 +65,7 @@ static int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq); static int si570xxxusb_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); static int si570xxxusb_set_freq_by_value(RIG *rig, vfo_t vfo, freq_t freq); static int si570xxxusb_get_freq_by_value(RIG *rig, vfo_t vfo, freq_t *freq); -static int si570xxxusb_set_ptt(RIG * rig, vfo_t vfo, ptt_t ptt); +static int si570xxxusb_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt); static int si570xxxusb_set_conf(RIG *rig, token_t token, const char *val); static int si570xxxusb_get_conf(RIG *rig, token_t token, char *val); static const char *si570xxxusb_get_info(RIG *rig); @@ -94,16 +94,20 @@ static const char *si570xxxusb_get_info(RIG *rig); #define F_CRYST 2 //4 byte static const struct confparams si570xxxusb_cfg_params[] = { - { TOK_OSCFREQ, "osc_freq", "Oscillator freq", "Oscillator frequency in Hz", - "114285000", RIG_CONF_NUMERIC, { .n = { 1, MHz(300), 1 } } + { + TOK_OSCFREQ, "osc_freq", "Oscillator freq", "Oscillator frequency in Hz", + "114285000", RIG_CONF_NUMERIC, { .n = { 1, MHz(300), 1 } } }, - { TOK_MULTIPLIER, "multiplier", "Freq Multiplier", "Frequency multiplier", + { + TOK_MULTIPLIER, "multiplier", "Freq Multiplier", "Frequency multiplier", "4", RIG_CONF_NUMERIC, { .n = { 0.000001, 100 } } }, - { TOK_I2C_ADDR, "i2c_addr", "I2C Address", "Si570 I2C Address", + { + TOK_I2C_ADDR, "i2c_addr", "I2C Address", "Si570 I2C Address", "55", RIG_CONF_NUMERIC, { .n = { 0, 512 } } }, - { TOK_BPF, "bpf", "BPF", "Enable Band Pass Filter", + { + TOK_BPF, "bpf", "BPF", "Enable Band Pass Filter", "0", RIG_CONF_CHECKBUTTON, { } }, { RIG_CONF_END, NULL, } @@ -130,7 +134,7 @@ struct si570xxxusb_priv_data { #define SI570AVRUSB_LEVEL_ALL (RIG_LEVEL_NONE) - /* TODO: BPF as a parm or ext_level? */ +/* TODO: BPF as a parm or ext_level? */ #define SI570AVRUSB_PARM_ALL (RIG_PARM_NONE) #define SI570AVRUSB_VFO (RIG_VFO_A) @@ -148,74 +152,74 @@ struct si570xxxusb_priv_data { */ const struct rig_caps si570avrusb_caps = { -.rig_model = RIG_MODEL_SI570AVRUSB, -.model_name = "Si570 AVR-USB", -.mfg_name = "SoftRock", -.version = "0.3", -.copyright = "LGPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 0, + .rig_model = RIG_MODEL_SI570AVRUSB, + .model_name = "Si570 AVR-USB", + .mfg_name = "SoftRock", + .version = "0.3", + .copyright = "LGPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 0, -.has_get_func = SI570AVRUSB_FUNC, -.has_set_func = SI570AVRUSB_FUNC, -.has_get_level = SI570AVRUSB_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), -.has_get_parm = SI570AVRUSB_PARM_ALL, -.has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = SI570AVRUSB_FUNC, + .has_set_func = SI570AVRUSB_FUNC, + .has_get_level = SI570AVRUSB_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), + .has_get_parm = SI570AVRUSB_PARM_ALL, + .has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {SI570AVRUSB_MODES,Hz(1)}, - RIG_TS_END, + .rx_range_list1 = { + /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {SI570AVRUSB_MODES, Hz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { RIG_FLT_END, }, -.cfgparams = si570xxxusb_cfg_params, + .cfgparams = si570xxxusb_cfg_params, -.rig_init = si570avrusb_init, -.rig_cleanup = si570xxxusb_cleanup, -.rig_open = si570xxxusb_open, -.set_conf = si570xxxusb_set_conf, -.get_conf = si570xxxusb_get_conf, + .rig_init = si570avrusb_init, + .rig_cleanup = si570xxxusb_cleanup, + .rig_open = si570xxxusb_open, + .set_conf = si570xxxusb_set_conf, + .get_conf = si570xxxusb_get_conf, -.set_freq = si570xxxusb_set_freq, -.get_freq = si570xxxusb_get_freq, -.set_ptt = si570xxxusb_set_ptt, -.get_info = si570xxxusb_get_info, + .set_freq = si570xxxusb_set_freq, + .get_freq = si570xxxusb_get_freq, + .set_ptt = si570xxxusb_set_ptt, + .get_info = si570xxxusb_get_info, }; @@ -224,74 +228,74 @@ const struct rig_caps si570avrusb_caps = { * http://www.ae9rb.com */ const struct rig_caps si570peaberry1_caps = { -.rig_model = RIG_MODEL_SI570PEABERRY1, -.model_name = "Si570 Peaberry V1", -.mfg_name = "AE9RB", -.version = "0.3", -.copyright = "GPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 0, + .rig_model = RIG_MODEL_SI570PEABERRY1, + .model_name = "Si570 Peaberry V1", + .mfg_name = "AE9RB", + .version = "0.3", + .copyright = "GPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 0, -.has_get_func = SI570AVRUSB_FUNC, -.has_set_func = SI570AVRUSB_FUNC, -.has_get_level = SI570AVRUSB_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), -.has_get_parm = SI570AVRUSB_PARM_ALL, -.has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = SI570AVRUSB_FUNC, + .has_set_func = SI570AVRUSB_FUNC, + .has_get_level = SI570AVRUSB_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), + .has_get_parm = SI570AVRUSB_PARM_ALL, + .has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {SI570AVRUSB_MODES,Hz(1)}, - RIG_TS_END, + .rx_range_list1 = { + /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {SI570AVRUSB_MODES, Hz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { RIG_FLT_END, }, -.cfgparams = si570xxxusb_cfg_params, + .cfgparams = si570xxxusb_cfg_params, -.rig_init = si570peaberry1_init, -.rig_cleanup = si570xxxusb_cleanup, -.rig_open = si570xxxusb_open, -.set_conf = si570xxxusb_set_conf, -.get_conf = si570xxxusb_get_conf, + .rig_init = si570peaberry1_init, + .rig_cleanup = si570xxxusb_cleanup, + .rig_open = si570xxxusb_open, + .set_conf = si570xxxusb_set_conf, + .get_conf = si570xxxusb_get_conf, -.set_freq = si570xxxusb_set_freq, -.get_freq = si570xxxusb_get_freq, -.set_ptt = si570xxxusb_set_ptt, -.get_info = si570xxxusb_get_info, + .set_freq = si570xxxusb_set_freq, + .get_freq = si570xxxusb_get_freq, + .set_ptt = si570xxxusb_set_ptt, + .get_info = si570xxxusb_get_info, }; @@ -300,74 +304,74 @@ const struct rig_caps si570peaberry1_caps = { * http://www.ae9rb.com */ const struct rig_caps si570peaberry2_caps = { -.rig_model = RIG_MODEL_SI570PEABERRY2, -.model_name = "Si570 Peaberry V2", -.mfg_name = "AE9RB", -.version = "0.2", -.copyright = "GPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 0, + .rig_model = RIG_MODEL_SI570PEABERRY2, + .model_name = "Si570 Peaberry V2", + .mfg_name = "AE9RB", + .version = "0.2", + .copyright = "GPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 0, -.has_get_func = SI570AVRUSB_FUNC, -.has_set_func = SI570AVRUSB_FUNC, -.has_get_level = SI570AVRUSB_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), -.has_get_parm = SI570AVRUSB_PARM_ALL, -.has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = SI570AVRUSB_FUNC, + .has_set_func = SI570AVRUSB_FUNC, + .has_get_level = SI570AVRUSB_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), + .has_get_parm = SI570AVRUSB_PARM_ALL, + .has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(800),MHz(53.7),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {SI570AVRUSB_MODES,Hz(1)}, - RIG_TS_END, + .rx_range_list1 = { + /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(800), MHz(53.7), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {SI570AVRUSB_MODES, Hz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { RIG_FLT_END, }, -.cfgparams = si570xxxusb_cfg_params, + .cfgparams = si570xxxusb_cfg_params, -.rig_init = si570peaberry2_init, -.rig_cleanup = si570xxxusb_cleanup, -.rig_open = si570xxxusb_open, -.set_conf = si570xxxusb_set_conf, -.get_conf = si570xxxusb_get_conf, + .rig_init = si570peaberry2_init, + .rig_cleanup = si570xxxusb_cleanup, + .rig_open = si570xxxusb_open, + .set_conf = si570xxxusb_set_conf, + .get_conf = si570xxxusb_get_conf, -.set_freq = si570xxxusb_set_freq, -.get_freq = si570xxxusb_get_freq, -.set_ptt = si570xxxusb_set_ptt, -.get_info = si570xxxusb_get_info, + .set_freq = si570xxxusb_set_freq, + .get_freq = si570xxxusb_get_freq, + .set_ptt = si570xxxusb_set_ptt, + .get_info = si570xxxusb_get_info, }; @@ -381,72 +385,72 @@ const struct rig_caps si570peaberry2_caps = { * http://home.kpn.nl/rw.engberts/sdr_kth.htm */ const struct rig_caps si570picusb_caps = { -.rig_model = RIG_MODEL_SI570PICUSB, -.model_name = "Si570 PIC-USB", -.mfg_name = "KTH-SDR kit", -.version = "0.3", -.copyright = "LGPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_TUNER, -.ptt_type = RIG_PTT_NONE, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 0, + .rig_model = RIG_MODEL_SI570PICUSB, + .model_name = "Si570 PIC-USB", + .mfg_name = "KTH-SDR kit", + .version = "0.3", + .copyright = "LGPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_TUNER, + .ptt_type = RIG_PTT_NONE, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 0, -.has_get_func = SI570AVRUSB_FUNC, -.has_set_func = SI570AVRUSB_FUNC, -.has_get_level = SI570AVRUSB_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), -.has_get_parm = SI570AVRUSB_PARM_ALL, -.has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, /* TODO */ -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_OFF, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = SI570AVRUSB_FUNC, + .has_set_func = SI570AVRUSB_FUNC, + .has_get_level = SI570AVRUSB_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), + .has_get_parm = SI570AVRUSB_PARM_ALL, + .has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, /* TODO */ + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - {kHz(800),MHz(550),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(800),MHz(550),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {SI570AVRUSB_MODES,Hz(1)}, - RIG_TS_END, + .rx_range_list1 = { + {kHz(800), MHz(550), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, }, - /* mode/filter list, remember: order matters! */ -.filters = { + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(800), MHz(550), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {SI570AVRUSB_MODES, Hz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { RIG_FLT_END, }, -.cfgparams = si570xxxusb_cfg_params, + .cfgparams = si570xxxusb_cfg_params, -.rig_init = si570picusb_init, -.rig_cleanup = si570xxxusb_cleanup, -.rig_open = si570xxxusb_open, -.set_conf = si570xxxusb_set_conf, -.get_conf = si570xxxusb_get_conf, + .rig_init = si570picusb_init, + .rig_cleanup = si570xxxusb_cleanup, + .rig_open = si570xxxusb_open, + .set_conf = si570xxxusb_set_conf, + .get_conf = si570xxxusb_get_conf, -.set_freq = si570xxxusb_set_freq, -.get_freq = si570xxxusb_get_freq, -.get_info = si570xxxusb_get_info, + .set_freq = si570xxxusb_set_freq, + .get_freq = si570xxxusb_get_freq, + .get_info = si570xxxusb_get_info, }; @@ -461,74 +465,74 @@ const struct rig_caps si570picusb_caps = { */ const struct rig_caps fasdr_caps = { -.rig_model = RIG_MODEL_FASDR, -.model_name = "FA-SDR", -.mfg_name = "Funkamatuer", -.version = "0.2", -.copyright = "LGPL", -.status = RIG_STATUS_ALPHA, -.rig_type = RIG_FLAG_TUNER|RIG_FLAG_TRANSMITTER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_NONE, -.port_type = RIG_PORT_USB, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 0, + .rig_model = RIG_MODEL_FASDR, + .model_name = "FA-SDR", + .mfg_name = "Funkamatuer", + .version = "0.2", + .copyright = "LGPL", + .status = RIG_STATUS_ALPHA, + .rig_type = RIG_FLAG_TUNER | RIG_FLAG_TRANSMITTER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_NONE, + .port_type = RIG_PORT_USB, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 0, -.has_get_func = SI570AVRUSB_FUNC, -.has_set_func = SI570AVRUSB_FUNC, -.has_get_level = SI570AVRUSB_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), -.has_get_parm = SI570AVRUSB_PARM_ALL, -.has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), -.level_gran = {}, -.parm_gran = {}, -.ctcss_list = NULL, -.dcs_list = NULL, -.preamp = { RIG_DBLST_END }, -.attenuator = { RIG_DBLST_END }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.targetable_vfo = 0, -.transceive = RIG_TRN_RIG, -.bank_qty = 0, -.chan_desc_sz = 0, + .has_get_func = SI570AVRUSB_FUNC, + .has_set_func = SI570AVRUSB_FUNC, + .has_get_level = SI570AVRUSB_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(SI570AVRUSB_LEVEL_ALL), + .has_get_parm = SI570AVRUSB_PARM_ALL, + .has_set_parm = RIG_PARM_SET(SI570AVRUSB_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { RIG_DBLST_END }, + .attenuator = { RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_RIG, + .bank_qty = 0, + .chan_desc_sz = 0, -.chan_list = { RIG_CHAN_END, }, + .chan_list = { RIG_CHAN_END, }, -.rx_range_list1 = { - /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ - {kHz(1800),MHz(30),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {kHz(1800),MHz(30),SI570AVRUSB_MODES,-1,-1,SI570AVRUSB_VFO}, - RIG_FRNG_END, - }, -.tx_range_list2 = { RIG_FRNG_END, }, -.tuning_steps = { - {SI570AVRUSB_MODES,Hz(1)}, - RIG_TS_END, - }, - /* mode/filter list, remember: order matters! */ -.filters = { - RIG_FLT_END, - }, -.cfgparams = si570xxxusb_cfg_params, + .rx_range_list1 = { + /* probably higher upper range, depending on type (CMOS, LVDS, ..) */ + {kHz(1800), MHz(30), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(1800), MHz(30), SI570AVRUSB_MODES, -1, -1, SI570AVRUSB_VFO}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + .tuning_steps = { + {SI570AVRUSB_MODES, Hz(1)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { + RIG_FLT_END, + }, + .cfgparams = si570xxxusb_cfg_params, -.rig_init = fasdr_init, -.rig_cleanup = si570xxxusb_cleanup, -.rig_open = fasdr_open, -.set_conf = si570xxxusb_set_conf, -.get_conf = si570xxxusb_get_conf, + .rig_init = fasdr_init, + .rig_cleanup = si570xxxusb_cleanup, + .rig_open = fasdr_open, + .set_conf = si570xxxusb_set_conf, + .get_conf = si570xxxusb_get_conf, -.set_freq = si570xxxusb_set_freq, -.get_freq = si570xxxusb_get_freq, -.set_ptt = si570xxxusb_set_ptt, -.get_info = si570xxxusb_get_info, + .set_freq = si570xxxusb_set_freq, + .get_freq = si570xxxusb_get_freq, + .set_ptt = si570xxxusb_set_ptt, + .get_info = si570xxxusb_get_info, }; @@ -544,14 +548,15 @@ int si570avrusb_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)calloc(sizeof(struct si570xxxusb_priv_data), 1); + priv = (struct si570xxxusb_priv_data *)calloc(sizeof(struct si570xxxusb_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; } priv->osc_freq = SI570_NOMINAL_XTALL_FREQ; - /* QSD/QSE */ + /* QSD/QSE */ priv->multiplier = 4; priv->i2c_addr = SI570_I2C_ADDR; @@ -569,7 +574,7 @@ int si570avrusb_init(RIG *rig) rp->parm.usb.vendor_name = VENDOR_NAME; rp->parm.usb.product = AVR_PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -582,7 +587,8 @@ int si570peaberry1_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)calloc(sizeof(struct si570xxxusb_priv_data), 1); + priv = (struct si570xxxusb_priv_data *)calloc(sizeof(struct si570xxxusb_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -607,7 +613,7 @@ int si570peaberry1_init(RIG *rig) rp->parm.usb.vendor_name = PEABERRY_VENDOR_NAME; rp->parm.usb.product = PEABERRY_PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -620,7 +626,8 @@ int si570peaberry2_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)calloc(sizeof(struct si570xxxusb_priv_data), 1); + priv = (struct si570xxxusb_priv_data *)calloc(sizeof(struct si570xxxusb_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; @@ -645,7 +652,7 @@ int si570peaberry2_init(RIG *rig) rp->parm.usb.vendor_name = VENDOR_NAME; rp->parm.usb.product = PEABERRY_PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -658,18 +665,19 @@ int si570picusb_init(RIG *rig) hamlib_port_t *rp = &rig->state.rigport; struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)calloc(sizeof(struct si570xxxusb_priv_data), 1); + priv = (struct si570xxxusb_priv_data *)calloc(sizeof(struct si570xxxusb_priv_data), 1); + if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; } priv->osc_freq = SI570_NOMINAL_XTALL_FREQ; - /* QSD/QSE */ + /* QSD/QSE */ priv->multiplier = 2; priv->i2c_addr = SI570_I2C_ADDR; - /* enable BPF, because this is kit is receiver only */ + /* enable BPF, because this is kit is receiver only */ priv->bpf = 1; rp->parm.usb.vid = USBDEV_SHARED_VID; @@ -681,9 +689,9 @@ int si570picusb_init(RIG *rig) rp->parm.usb.alt = 0; /* necessary ? */ rp->parm.usb.vendor_name = VENDOR_NAME; - rp->parm.usb.product = PIC_PRODUCT_NAME; + rp->parm.usb.product = PIC_PRODUCT_NAME; - rig->state.priv = (void*)priv; + rig->state.priv = (void *)priv; return RIG_OK; } @@ -693,107 +701,110 @@ int si570picusb_init(RIG *rig) int fasdr_init(RIG *rig) { - hamlib_port_t *rp = &rig->state.rigport; - struct si570xxxusb_priv_data *priv; + hamlib_port_t *rp = &rig->state.rigport; + struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)calloc(sizeof(struct si570xxxusb_priv_data), 1); - if (!priv) { - /* whoops! memory shortage! */ - return -RIG_ENOMEM; - } + priv = (struct si570xxxusb_priv_data *)calloc(sizeof(struct si570xxxusb_priv_data), 1); - priv->osc_freq = SI570_NOMINAL_XTALL_FREQ; - /* QSD/QSE */ - priv->multiplier = 4; + if (!priv) { + /* whoops! memory shortage! */ + return -RIG_ENOMEM; + } - priv->i2c_addr = SI570_I2C_ADDR; - /* disable BPF, because it may share PTT I/O line */ - priv->bpf = 0; + priv->osc_freq = SI570_NOMINAL_XTALL_FREQ; + /* QSD/QSE */ + priv->multiplier = 4; - rp->parm.usb.vid = USBDEV_SHARED_VID; - rp->parm.usb.pid = USBDEV_SHARED_PID; + priv->i2c_addr = SI570_I2C_ADDR; + /* disable BPF, because it may share PTT I/O line */ + priv->bpf = 0; - /* no usb_set_configuration() and usb_claim_interface() */ - rp->parm.usb.iface = -1; - rp->parm.usb.conf = 1; - rp->parm.usb.alt = 0; /* necessary ? */ + rp->parm.usb.vid = USBDEV_SHARED_VID; + rp->parm.usb.pid = USBDEV_SHARED_PID; - rp->parm.usb.vendor_name = VENDOR_NAME; - rp->parm.usb.product = AVR_PRODUCT_NAME; + /* no usb_set_configuration() and usb_claim_interface() */ + rp->parm.usb.iface = -1; + rp->parm.usb.conf = 1; + rp->parm.usb.alt = 0; /* necessary ? */ - rig->state.priv = (void*)priv; + rp->parm.usb.vendor_name = VENDOR_NAME; + rp->parm.usb.product = AVR_PRODUCT_NAME; - return RIG_OK; + rig->state.priv = (void *)priv; + + return RIG_OK; } int fasdr_open(RIG *rig) { - struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv; - libusb_device_handle *udh = rig->state.rigport.handle; - int ret,i; - double f; - unsigned char buffer[4]; - unsigned short version; + struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv; + libusb_device_handle *udh = rig->state.rigport.handle; + int ret, i; + double f; + unsigned char buffer[4]; + unsigned short version; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); - ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_READ_VERSION, 0x0E00, 0, - (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); + ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, + REQUEST_READ_VERSION, 0x0E00, 0, + (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); - if (ret != 2) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); - return -RIG_EIO; - } + if (ret != 2) { + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); + return -RIG_EIO; + } // Does version needs endianess ordering ? - priv->version = version; // Unsure how to get firmware version + priv->version = version; // Unsure how to get firmware version - ret=libusb_control_transfer(udh, - REQUEST_TYPE_IN, - REQUEST_READ_EEPROM,F_CAL_STATUS,0, buffer,1, - rig->state.rigport.timeout); - if( ret !=1) - return -RIG_EIO; + ret = libusb_control_transfer(udh, + REQUEST_TYPE_IN, + REQUEST_READ_EEPROM, F_CAL_STATUS, 0, buffer, 1, + rig->state.rigport.timeout); + + if (ret != 1) + return -RIG_EIO; - rig_debug(RIG_DEBUG_VERBOSE,"%s: calibration byte %x", __func__,buffer[0]); + rig_debug(RIG_DEBUG_VERBOSE, "%s: calibration byte %x", __func__, buffer[0]); // ret = libusb_control_transfer(udh, // REQUEST_TYPE_IN, // REQUEST_READ_XTALL, 0, 0, (unsigned char *) &iFreq, sizeof(iFreq), // rig->state.rigport.timeout); - if(buffer[0] == 0xFF ) - { - rig_debug(RIG_DEBUG_VERBOSE,"%s: Device not calibrated",__func__); - return RIG_OK; - } - for(i=0; i<4; i++) - { - ret = libusb_control_transfer(udh, - REQUEST_TYPE_IN, - REQUEST_READ_EEPROM,F_CRYST + i, 0, &buffer[i], 1, - rig->state.rigport.timeout); - if (ret != 1) - return -RIG_EIO; - } - priv->osc_freq= buffer[0]; - f=buffer[1]; - priv->osc_freq +=f/256.; - f=buffer[2]; - priv->osc_freq +=f/(256.*256.); - f=buffer[3]; - priv->osc_freq +=f/(256.*256.*256.); + if (buffer[0] == 0xFF) { + rig_debug(RIG_DEBUG_VERBOSE, "%s: Device not calibrated", __func__); + return RIG_OK; + } - rig_debug(RIG_DEBUG_VERBOSE,"%s: using Xtall at %.3f MHz\n", - __func__, priv->osc_freq); + for (i = 0; i < 4; i++) { + ret = libusb_control_transfer(udh, + REQUEST_TYPE_IN, + REQUEST_READ_EEPROM, F_CRYST + i, 0, &buffer[i], 1, + rig->state.rigport.timeout); - return RIG_OK; + if (ret != 1) + return -RIG_EIO; + } + + priv->osc_freq = buffer[0]; + f = buffer[1]; + priv->osc_freq += f / 256.; + f = buffer[2]; + priv->osc_freq += f / (256.*256.); + f = buffer[3]; + priv->osc_freq += f / (256.*256.*256.); + + rig_debug(RIG_DEBUG_VERBOSE, "%s: using Xtall at %.3f MHz\n", + __func__, priv->osc_freq); + + return RIG_OK; } @@ -804,6 +815,7 @@ int si570xxxusb_cleanup(RIG *rig) if (rig->state.priv) free(rig->state.priv); + rig->state.priv = NULL; return RIG_OK; @@ -816,35 +828,46 @@ int si570xxxusb_set_conf(RIG *rig, token_t token, const char *val) double multiplier; int i2c_addr; - priv = (struct si570xxxusb_priv_data*)rig->state.priv; + priv = (struct si570xxxusb_priv_data *)rig->state.priv; - switch(token) { - case TOK_OSCFREQ: - if (sscanf(val, "%"SCNfreq, &freq) != 1) - return -RIG_EINVAL; - priv->osc_freq = (double)freq/1e6; - break; - case TOK_MULTIPLIER: - if (sscanf(val, "%lf", &multiplier) != 1) - return -RIG_EINVAL; - if (multiplier == 0.) - return -RIG_EINVAL; - priv->multiplier = multiplier; - break; - case TOK_I2C_ADDR: - if (sscanf(val, "%x", &i2c_addr) != 1) - return -RIG_EINVAL; - if (i2c_addr < 0 || i2c_addr >= (1<<9)) - return -RIG_EINVAL; - priv->i2c_addr = i2c_addr; - break; - case TOK_BPF: - if (sscanf(val, "%d", &priv->bpf) != 1) - return -RIG_EINVAL; - break; - default: + switch (token) { + case TOK_OSCFREQ: + if (sscanf(val, "%"SCNfreq, &freq) != 1) return -RIG_EINVAL; + + priv->osc_freq = (double)freq / 1e6; + break; + + case TOK_MULTIPLIER: + if (sscanf(val, "%lf", &multiplier) != 1) + return -RIG_EINVAL; + + if (multiplier == 0.) + return -RIG_EINVAL; + + priv->multiplier = multiplier; + break; + + case TOK_I2C_ADDR: + if (sscanf(val, "%x", &i2c_addr) != 1) + return -RIG_EINVAL; + + if (i2c_addr < 0 || i2c_addr >= (1 << 9)) + return -RIG_EINVAL; + + priv->i2c_addr = i2c_addr; + break; + + case TOK_BPF: + if (sscanf(val, "%d", &priv->bpf) != 1) + return -RIG_EINVAL; + + break; + + default: + return -RIG_EINVAL; } + return RIG_OK; } @@ -852,24 +875,29 @@ int si570xxxusb_get_conf(RIG *rig, token_t token, char *val) { struct si570xxxusb_priv_data *priv; - priv = (struct si570xxxusb_priv_data*)rig->state.priv; + priv = (struct si570xxxusb_priv_data *)rig->state.priv; - switch(token) { - case TOK_OSCFREQ: - sprintf(val, "%"PRIfreq, (freq_t)(priv->osc_freq*1e6)); - break; - case TOK_MULTIPLIER: - sprintf(val, "%f", priv->multiplier); - break; - case TOK_I2C_ADDR: - sprintf(val, "%x", priv->i2c_addr); - break; - case TOK_BPF: - sprintf(val, "%d", priv->bpf); - break; - default: - return -RIG_EINVAL; + switch (token) { + case TOK_OSCFREQ: + sprintf(val, "%"PRIfreq, (freq_t)(priv->osc_freq * 1e6)); + break; + + case TOK_MULTIPLIER: + sprintf(val, "%f", priv->multiplier); + break; + + case TOK_I2C_ADDR: + sprintf(val, "%x", priv->i2c_addr); + break; + + case TOK_BPF: + sprintf(val, "%d", priv->bpf); + break; + + default: + return -RIG_EINVAL; } + return RIG_OK; } @@ -877,7 +905,7 @@ int si570xxxusb_get_conf(RIG *rig, token_t token, char *val) static int setBPF(RIG *rig, int enable) { libusb_device_handle *udh = rig->state.rigport.handle; - /* allocate enough space for up to 16 filters */ + /* allocate enough space for up to 16 filters */ unsigned short FilterCrossOver[16]; int nBytes, i; @@ -885,31 +913,35 @@ static int setBPF(RIG *rig, int enable) // first find out how may cross over points there are for the 1st bank, use 255 for index nBytes = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_FILTERS, 0, 255, - (unsigned char *) FilterCrossOver, sizeof(FilterCrossOver), - rig->state.rigport.timeout); + REQUEST_FILTERS, 0, 255, + (unsigned char *) FilterCrossOver, sizeof(FilterCrossOver), + rig->state.rigport.timeout); - if (nBytes < 0) - return -RIG_EIO; + if (nBytes < 0) + return -RIG_EIO; if (nBytes > 2) { nBytes = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_FILTERS, enable, (nBytes / 2) - 1, - (unsigned char *) FilterCrossOver, sizeof(FilterCrossOver), - rig->state.rigport.timeout); - if (nBytes < 0) - return -RIG_EIO; + REQUEST_FILTERS, enable, (nBytes / 2) - 1, + (unsigned char *) FilterCrossOver, sizeof(FilterCrossOver), + rig->state.rigport.timeout); + + if (nBytes < 0) + return -RIG_EIO; + + rig_debug(RIG_DEBUG_TRACE, "Filter Bank 1:\n"); - rig_debug (RIG_DEBUG_TRACE, "Filter Bank 1:\n"); for (i = 0; i < (nBytes / 2) - 1; i++) { - rig_debug (RIG_DEBUG_TRACE, " CrossOver[%d] = %f\n", - i, (double) FilterCrossOver[i] / (1UL << 5)); + rig_debug(RIG_DEBUG_TRACE, " CrossOver[%d] = %f\n", + i, (double) FilterCrossOver[i] / (1UL << 5)); } - rig_debug (RIG_DEBUG_TRACE, " BPF Enabled: %d\n", - FilterCrossOver[(nBytes / 2) - 1]); + + rig_debug(RIG_DEBUG_TRACE, " BPF Enabled: %d\n", + FilterCrossOver[(nBytes / 2) - 1]); } - return RIG_OK; + + return RIG_OK; } int si570xxxusb_open(RIG *rig) @@ -919,71 +951,72 @@ int si570xxxusb_open(RIG *rig) int ret; unsigned short version; - rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); /* * Determine firmware */ ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_READ_VERSION, 0x0E00, 0, - (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); + REQUEST_READ_VERSION, 0x0E00, 0, + (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); if (ret != 2) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } priv->version = version; - if (version >= 0x0F00 || rig->caps->rig_model == RIG_MODEL_SI570PICUSB) - { + + if (version >= 0x0F00 || rig->caps->rig_model == RIG_MODEL_SI570PICUSB) { unsigned int iFreq; - rig_debug(RIG_DEBUG_VERBOSE,"%s: detected PE0FKO-like firmware\n", __func__); + rig_debug(RIG_DEBUG_VERBOSE, "%s: detected PE0FKO-like firmware\n", __func__); ret = libusb_control_transfer(udh, - REQUEST_TYPE_IN, - REQUEST_READ_XTALL, 0, 0, (unsigned char *) &iFreq, sizeof(iFreq), - rig->state.rigport.timeout); + REQUEST_TYPE_IN, + REQUEST_READ_XTALL, 0, 0, (unsigned char *) &iFreq, sizeof(iFreq), + rig->state.rigport.timeout); if (ret != 4) return -RIG_EIO; - priv->osc_freq = (double)iFreq / (1UL<<24); + priv->osc_freq = (double)iFreq / (1UL << 24); if (priv->bpf) { ret = setBPF(rig, 1); + if (ret != RIG_OK) return ret; } } - rig_debug(RIG_DEBUG_VERBOSE,"%s: using Xtall at %.3f MHz\n", - __func__, priv->osc_freq); + rig_debug(RIG_DEBUG_VERBOSE, "%s: using Xtall at %.3f MHz\n", + __func__, priv->osc_freq); return RIG_OK; } /* Rem: not reentrant */ -const char * si570xxxusb_get_info(RIG *rig) +const char *si570xxxusb_get_info(RIG *rig) { static char buf[64]; libusb_device_handle *udh = rig->state.rigport.handle; struct libusb_device_descriptor desc; - int ret; + int ret; unsigned short version; ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_READ_VERSION, 0x0E00, 0, - (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); + REQUEST_READ_VERSION, 0x0E00, 0, + (unsigned char *) &version, sizeof(version), rig->state.rigport.timeout); if (ret != 2) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return NULL; } @@ -991,14 +1024,14 @@ const char * si570xxxusb_get_info(RIG *rig) libusb_get_device_descriptor(libusb_get_device(udh), &desc); sprintf(buf, "USB dev %04d, version: %d.%d", desc.bcdDevice, - (version & 0xFF00) >> 8, version & 0xFF); + (version & 0xFF00) >> 8, version & 0xFF); return buf; } -static const int HS_DIV_MAP[] = {4,5,6,7,-1,9,-1,11}; +static const int HS_DIV_MAP[] = {4, 5, 6, 7, -1, 9, -1, 11}; -static int calcDividers(RIG *rig, double f, struct solution* solution) +static int calcDividers(RIG *rig, double f, struct solution *solution) { struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv; struct solution sols[8]; @@ -1008,30 +1041,34 @@ static int calcDividers(RIG *rig, double f, struct solution* solution) double y; // Count down through the dividers - for (i=7;i >= 0;i--) { + for (i = 7; i >= 0; i--) { if (HS_DIV_MAP[i] > 0) { sols[i].HS_DIV = i; y = (SI570_DCO_HIGH + SI570_DCO_LOW) / (2 * f); y = y / HS_DIV_MAP[i]; + if (y < 1.5) { y = 1.0; } else { - y = 2 * round ( y / 2.0); + y = 2 * round(y / 2.0); } + if (y > 128) { y = 128; } + sols[i].N1 = trunc(y) - 1; sols[i].f0 = f * y * HS_DIV_MAP[i]; } else { sols[i].f0 = 10000000000000000.0; } } + imin = -1; fmin = 10000000000000000.0; - for (i=0; i < 8; i++) { + for (i = 0; i < 8; i++) { if ((sols[i].f0 >= SI570_DCO_LOW) && (sols[i].f0 <= SI570_DCO_HIGH)) { if (sols[i].f0 < fmin) { fmin = sols[i].f0; @@ -1046,8 +1083,8 @@ static int calcDividers(RIG *rig, double f, struct solution* solution) solution->f0 = sols[imin].f0; solution->RFREQ = sols[imin].f0 / priv->osc_freq; - rig_debug(RIG_DEBUG_TRACE, "%s: solution: HS_DIV = %d, N1 = %d, f0 = %f, RFREQ = %f\n", - __func__, solution->HS_DIV, solution->N1, solution->f0, solution->RFREQ); + rig_debug(RIG_DEBUG_TRACE, "%s: solution: HS_DIV = %d, N1 = %d, f0 = %f, RFREQ = %f\n", + __func__, solution->HS_DIV, solution->N1, solution->f0, solution->RFREQ); return 1; } else { @@ -1055,12 +1092,12 @@ static int calcDividers(RIG *rig, double f, struct solution* solution) solution->N1 = 0; solution->f0 = 0; solution->RFREQ = 0; - rig_debug(RIG_DEBUG_TRACE, "%s: No solution\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: No solution\n", __func__); return 0; } } -static void setLongWord(uint32_t value, unsigned char * bytes) +static void setLongWord(uint32_t value, unsigned char *bytes) { bytes[0] = value & 0xff; bytes[1] = ((value & 0xff00) >> 8) & 0xff; @@ -1086,15 +1123,15 @@ int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq) unsigned char intBuffer[4]; if (priv->version >= 0x0f00 || rig->caps->rig_model == RIG_MODEL_SI570PICUSB || - rig->caps->rig_model == RIG_MODEL_SI570PEABERRY1 || rig->caps->rig_model == RIG_MODEL_SI570PEABERRY2) + rig->caps->rig_model == RIG_MODEL_SI570PEABERRY1 || rig->caps->rig_model == RIG_MODEL_SI570PEABERRY2) return si570xxxusb_set_freq_by_value(rig, vfo, freq); - f = (freq * priv->multiplier)/1e6; + f = (freq * priv->multiplier) / 1e6; calcDividers(rig, f, &theSolution); RFREQ_int = trunc(theSolution.RFREQ); - RFREQ_frac = round((theSolution.RFREQ - RFREQ_int)*268435456); + RFREQ_frac = round((theSolution.RFREQ - RFREQ_int) * 268435456); setLongWord(RFREQ_int, intBuffer); setLongWord(RFREQ_frac, fracBuffer); @@ -1109,22 +1146,22 @@ int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq) buffer[0] = buffer[0] + (theSolution.HS_DIV << 5); ret = libusb_control_transfer(udh, REQUEST_TYPE_OUT, - request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout); + request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout); rig_debug(RIG_DEBUG_TRACE, "%s: Freq=%.6f MHz, Real=%.6f MHz, buf=%02x%02x%02x%02x%02x%02x\n", - __func__, freq/1e6, f, - buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]); + __func__, freq / 1e6, f, + buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]); if (!ret) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } rig_debug(RIG_DEBUG_TRACE, "%s: Result buf=%02x%02x\n", - __func__, buffer[0], buffer[1]); + __func__, buffer[0], buffer[1]); return RIG_OK; } @@ -1141,55 +1178,55 @@ int si570xxxusb_set_freq_by_value(RIG *rig, vfo_t vfo, freq_t freq) int index = 0; double f; - f = (freq * priv->multiplier)/1e6; + f = (freq * priv->multiplier) / 1e6; setLongWord(round(f * 2097152.0), buffer); rig_debug(RIG_DEBUG_TRACE, "%s: Freq=%.6f MHz, Real=%.6f MHz, buf=%02x%02x%02x%02x\n", - __func__, freq/1e6, f, - buffer[0], buffer[1], buffer[2], buffer[3]); + __func__, freq / 1e6, f, + buffer[0], buffer[1], buffer[2], buffer[3]); ret = libusb_control_transfer(udh, REQUEST_TYPE_OUT, - request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout); + request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout); if (!ret) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } rig_debug(RIG_DEBUG_TRACE, "%s: Result buf=%02x%02x\n", - __func__, buffer[0], buffer[1]); + __func__, buffer[0], buffer[1]); return RIG_OK; } -static double calculateFrequency(RIG *rig, const unsigned char * buffer) +static double calculateFrequency(RIG *rig, const unsigned char *buffer) { struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv; int RFREQ_int = ((buffer[2] & 0xf0) >> 4) + ((buffer[1] & 0x3f) * 16); int RFREQ_frac = (256 * 256 * 256 * (buffer[2] & 0xf)) + (256 * 256 * buffer[3]) + (256 * buffer[4]) + (buffer[5]); double RFREQ = RFREQ_int + (RFREQ_frac / 268435456.0); - int N1 = ((buffer[1] & 0xc0 ) >> 6) + ((buffer[0] & 0x1f) * 4); + int N1 = ((buffer[1] & 0xc0) >> 6) + ((buffer[0] & 0x1f) * 4); int HS_DIV = (buffer[0] & 0xE0) >> 5; double fout = priv->osc_freq * RFREQ / ((N1 + 1) * HS_DIV_MAP[HS_DIV]); - rig_debug (RIG_DEBUG_VERBOSE, - "%s: Registers 7..13: %02x%02x%02x%02x%02x%02x\n", - __func__, - buffer[0], - buffer[1], - buffer[2], - buffer[3], - buffer[4], - buffer[5]); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: Registers 7..13: %02x%02x%02x%02x%02x%02x\n", + __func__, + buffer[0], + buffer[1], + buffer[2], + buffer[3], + buffer[4], + buffer[5]); - rig_debug (RIG_DEBUG_VERBOSE, - "%s: RFREQ = %f, N1 = %d, HS_DIV = %d, nHS_DIV = %d, fout = %f\n", - __func__, - RFREQ, N1, HS_DIV, HS_DIV_MAP[HS_DIV], fout); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: RFREQ = %f, N1 = %d, HS_DIV = %d, nHS_DIV = %d, fout = %f\n", + __func__, + RFREQ, N1, HS_DIV, HS_DIV_MAP[HS_DIV], fout); return fout; } @@ -1202,21 +1239,21 @@ int si570xxxusb_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) int ret; if (priv->version >= 0x0f00 || rig->caps->rig_model == RIG_MODEL_SI570PICUSB || - rig->caps->rig_model == RIG_MODEL_SI570PEABERRY1 || rig->caps->rig_model == RIG_MODEL_SI570PEABERRY2) + rig->caps->rig_model == RIG_MODEL_SI570PEABERRY1 || rig->caps->rig_model == RIG_MODEL_SI570PEABERRY2) return si570xxxusb_get_freq_by_value(rig, vfo, freq); ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_READ_REGISTERS, priv->i2c_addr, 0, - buffer, sizeof(buffer), rig->state.rigport.timeout); + REQUEST_READ_REGISTERS, priv->i2c_addr, 0, + buffer, sizeof(buffer), rig->state.rigport.timeout); if (ret <= 0) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } - *freq = (calculateFrequency(rig, buffer) / priv->multiplier)*1e6; + *freq = (calculateFrequency(rig, buffer) / priv->multiplier) * 1e6; return RIG_OK; } @@ -1231,41 +1268,42 @@ int si570xxxusb_get_freq_by_value(RIG *rig, vfo_t vfo, freq_t *freq) // Does iFreq needs endianess ordering ? ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_READ_FREQUENCY, 0, 0, - (unsigned char *)&iFreq, sizeof(iFreq), rig->state.rigport.timeout); + REQUEST_READ_FREQUENCY, 0, 0, + (unsigned char *)&iFreq, sizeof(iFreq), rig->state.rigport.timeout); if (ret != 4) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } - *freq = (((double)iFreq / (1UL<<21)) / priv->multiplier)*1e6; + *freq = (((double)iFreq / (1UL << 21)) / priv->multiplier) * 1e6; return RIG_OK; } -int si570xxxusb_set_ptt(RIG * rig, vfo_t vfo, ptt_t ptt) +int si570xxxusb_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) { libusb_device_handle *udh = rig->state.rigport.handle; int ret; unsigned char buffer[3]; - rig_debug(RIG_DEBUG_TRACE,"%s called: %d\n", __func__, ptt); + rig_debug(RIG_DEBUG_TRACE, "%s called: %d\n", __func__, ptt); buffer[0] = 0; buffer[1] = 0; buffer[2] = 0; ret = libusb_control_transfer(udh, REQUEST_TYPE_IN, - REQUEST_SET_PTT, (ptt == RIG_PTT_ON) ? 1 : 0, 0, - buffer, sizeof(buffer), rig->state.rigport.timeout); + REQUEST_SET_PTT, (ptt == RIG_PTT_ON) ? 1 : 0, 0, + buffer, sizeof(buffer), rig->state.rigport.timeout); + if (ret < 0) { - rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", - __func__, - libusb_error_name (ret)); + rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n", + __func__, + libusb_error_name(ret)); return -RIG_EIO; } diff --git a/src/usb_port.c b/src/usb_port.c index b7a0f8f05..0bf19985c 100644 --- a/src/usb_port.c +++ b/src/usb_port.c @@ -75,30 +75,32 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port) int i, r; rig_debug(RIG_DEBUG_VERBOSE, "%s: looking for device %04x:%04x...", - __func__, port->parm.usb.vid, port->parm.usb.pid); + __func__, port->parm.usb.vid, port->parm.usb.pid); r = libusb_get_device_list(NULL, &devs); + if (r < 0) { rig_debug(RIG_DEBUG_ERR, "%s: failed getting usb device list: %s", - __func__, libusb_error_name(r)); + __func__, libusb_error_name(r)); return NULL; } - for (i=0; (dev=devs[i]) != NULL; i++) { + for (i = 0; (dev = devs[i]) != NULL; i++) { libusb_get_device_descriptor(dev, &desc); rig_debug(RIG_DEBUG_VERBOSE, " %04x:%04x,", - desc.idVendor, desc.idProduct); + desc.idVendor, desc.idProduct); if (desc.idVendor == port->parm.usb.vid && - desc.idProduct == port->parm.usb.pid) { + desc.idProduct == port->parm.usb.pid) { /* we need to open the device in order to query strings */ r = libusb_open(dev, &udh); + if (r < 0) { rig_debug(RIG_DEBUG_WARN, "%s: Warning: Cannot open USB device: %s\n", - __func__, libusb_error_name(r)); + __func__, libusb_error_name(r)); continue; } @@ -107,6 +109,7 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port) string[0] = '\0'; r = libusb_get_string_descriptor_ascii(udh, desc.iManufacturer, (unsigned char *)string, sizeof(string)); + if (r < 0) { rig_debug(RIG_DEBUG_WARN, "Warning: cannot query manufacturer for USB device: %s\n", libusb_error_name(r)); libusb_close(udh); @@ -126,6 +129,7 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port) string[0] = '\0'; r = libusb_get_string_descriptor_ascii(udh, desc.iProduct, (unsigned char *)string, sizeof(string)); + if (r < 0) { rig_debug(RIG_DEBUG_WARN, "Warning: cannot query product for USB device: %s\n", libusb_error_name(r)); libusb_close(udh); @@ -176,10 +180,11 @@ int usb_port_open(hamlib_port_t *port) int r; /* init defaut libusb-1.0 library contexte, if needed */ - r = libusb_init (NULL); + r = libusb_init(NULL); + if (r < 0) { rig_debug(RIG_DEBUG_ERR, "%s: libusb_init failed: %s\n", - __func__, libusb_error_name(r)); + __func__, libusb_error_name(r)); return -RIG_EIO; } @@ -188,25 +193,29 @@ int usb_port_open(hamlib_port_t *port) /* Extract VID/PID/Vendor/Product name from pathname. */ /* Duplicate the string since we may modify it. */ strncpy(pathname, port->pathname, sizeof pathname); - pathname[FILPATHLEN-1] = '\0'; + pathname[FILPATHLEN - 1] = '\0'; p = pathname; q = strchr(p, ':'); + if (q) { ++q; port->parm.usb.vid = strtol(q, NULL, 16); p = q; q = strchr(p, ':'); + if (q) { ++q; port->parm.usb.pid = strtol(q, NULL, 16); p = q; q = strchr(p, ':'); + if (q) { ++q; port->parm.usb.vendor_name = q; p = q; q = strchr(p, ':'); + if (q) { *q++ = '\0'; port->parm.usb.product = q; @@ -216,8 +225,9 @@ int usb_port_open(hamlib_port_t *port) } udh = find_and_open_device(port); + if (udh == 0) { - libusb_exit (NULL); + libusb_exit(NULL); return -RIG_EIO; } @@ -231,43 +241,48 @@ int usb_port_open(hamlib_port_t *port) if (port->parm.usb.iface >= 0) { #ifdef _WIN32 + /* Is it still needed with libusb-1.0 ? */ if (port->parm.usb.conf >= 0 && - (r=libusb_set_configuration (udh, port->parm.usb.conf)) < 0) { + (r = libusb_set_configuration(udh, port->parm.usb.conf)) < 0) { rig_debug(RIG_DEBUG_ERR, "%s: libusb_set_configuration: failed conf %d: %s\n", - __func__, port->parm.usb.conf, libusb_error_name(r)); - libusb_close (udh); - libusb_exit (NULL); + __func__, port->parm.usb.conf, libusb_error_name(r)); + libusb_close(udh); + libusb_exit(NULL); return -RIG_EIO; } + #endif rig_debug(RIG_DEBUG_VERBOSE, "%s: claiming %d\n", __func__, port->parm.usb.iface); - r = libusb_claim_interface (udh, port->parm.usb.iface); + r = libusb_claim_interface(udh, port->parm.usb.iface); + if (r < 0) { rig_debug(RIG_DEBUG_ERR, "%s:libusb_claim_interface: failed interface %d: %s\n", - __func__,port->parm.usb.iface, libusb_error_name(r)); - libusb_close (udh); - libusb_exit (NULL); + __func__, port->parm.usb.iface, libusb_error_name(r)); + libusb_close(udh); + libusb_exit(NULL); return -RIG_EIO; } #if 0 r = libusb_set_interface_alt_setting(udh, port->parm.usb.iface, port->parm.usb.alt); + if (r < 0) { - fprintf (stderr, "%s:usb_set_alt_interface: failed: %s\n", __func__, + fprintf(stderr, "%s:usb_set_alt_interface: failed: %s\n", __func__, libusb_error_name(r)); - libusb_release_interface (udh, port->parm.usb.iface); - libusb_close (udh); - libusb_exit (NULL); + libusb_release_interface(udh, port->parm.usb.iface); + libusb_close(udh); + libusb_exit(NULL); return -RIG_EIO; } + #endif } - port->handle = (void*) udh; + port->handle = (void *) udh; return RIG_OK; } @@ -285,7 +300,7 @@ int usb_port_close(hamlib_port_t *port) libusb_close(udh); - libusb_exit (NULL); + libusb_exit(NULL); return RIG_OK; }