diff --git a/src/cal.c b/src/cal.c index e387c032e..852551c08 100644 --- a/src/cal.c +++ b/src/cal.c @@ -39,6 +39,7 @@ /* add rig_set_cal(cal_table), rig_get_calstat(rawmin,rawmax,cal_table), */ + /** * \brief Convert raw S-meter data to calibated value, according to table * \param rawval input value @@ -52,48 +53,55 @@ * If a value is greater or equal to cal_table_t.table[cal_table_t.size-1].raw, * rig_raw2val() will return cal_table_t.table[cal_table_t.size-1].val */ - float HAMLIB_API rig_raw2val(int rawval, const cal_table_t *cal) { #ifdef WANT_CHEAP_WNO_FP - int interpolation; + int interpolation; #else - float interpolation; + float interpolation; #endif - int i; + int i; - /* ASSERT(cal != NULL) */ - /* ASSERT(cal->size <= MAX_CAL_LENGTH) */ + /* ASSERT(cal != NULL) */ + /* ASSERT(cal->size <= MAX_CAL_LENGTH) */ - if (cal->size == 0) - return rawval; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; isize; i++) - if (rawval < cal->table[i].raw) - break; + if (cal->size == 0) { + return rawval; + } - if (i==0) - return cal->table[0].val; + for (i = 0; i < cal->size; i++) + if (rawval < cal->table[i].raw) { + break; + } - if (i>=cal->size) - return cal->table[i-1].val; + if (i == 0) { + return cal->table[0].val; + } - if (cal->table[i].raw == cal->table[i-1].raw) /* catch divide by 0 error */ - return cal->table[i].val; + if (i >= cal->size) { + return cal->table[i - 1].val; + } + + /* catch divide by 0 error */ + if (cal->table[i].raw == cal->table[i - 1].raw) { + return cal->table[i].val; + } #ifdef WANT_CHEAP_WNO_FP - /* cheap, less accurate, but no fp needed */ - interpolation = ((cal->table[i].raw - rawval) * - (cal->table[i].val - cal->table[i-1].val)) / - (cal->table[i].raw - cal->table[i-1].raw); + /* cheap, less accurate, but no fp needed */ + interpolation = ((cal->table[i].raw - rawval) + * (cal->table[i].val - cal->table[i - 1].val)) + / (cal->table[i].raw - cal->table[i - 1].raw); - return cal->table[i].val - interpolation; + return cal->table[i].val - interpolation; #else - interpolation = ((cal->table[i].raw - rawval) * - (float)(cal->table[i].val - cal->table[i-1].val)) / - (float)(cal->table[i].raw - cal->table[i-1].raw); + interpolation = ((cal->table[i].raw - rawval) + * (float)(cal->table[i].val - cal->table[i - 1].val)) + / (float)(cal->table[i].raw - cal->table[i - 1].raw); #endif - return cal->table[i].val - interpolation; + return cal->table[i].val - interpolation; } /** @} */ diff --git a/src/cm108.c b/src/cm108.c index 554806d09..112046608 100644 --- a/src/cm108.c +++ b/src/cm108.c @@ -65,7 +65,7 @@ #include #endif -#include "hamlib/rig.h" +#include #include "cm108.h" @@ -74,73 +74,78 @@ * \param port * \return file descriptor */ - int cm108_open(hamlib_port_t *port) { - int fd; + int fd; - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_open called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + if (!port->pathname[0]) { + return -RIG_EINVAL; + } - if (!port->pathname[0]) - return -RIG_EINVAL; + fd = open(port->pathname, O_RDWR); - fd = open(port->pathname, O_RDWR); - - if (fd < 0) { - rig_debug(RIG_DEBUG_ERR, "cm108:Opening device \"%s\": %s\n", port->pathname, strerror(errno)); - return -RIG_EIO; - } + if (fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: opening device \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + return -RIG_EIO; + } #ifdef HAVE_LINUX_HIDRAW_H - // CM108 detection copied from Thomas Sailer's soundmodem code + // CM108 detection copied from Thomas Sailer's soundmodem code - rig_debug(RIG_DEBUG_VERBOSE,"cm108:Checking for cm108 (or compatible) device \n"); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: checking for cm108 (or compatible) device\n", + __func__); - struct hidraw_devinfo hiddevinfo; + struct hidraw_devinfo hiddevinfo; + + if (!ioctl(fd, HIDIOCGRAWINFO, &hiddevinfo) + && ((hiddevinfo.vendor == 0x0d8c + // CM108/109/119/119A + && ((hiddevinfo.product >= 0x0008 + && hiddevinfo.product <= 0x000f) + || hiddevinfo.product == 0x013a)) + // SSS1621/23 + || (hiddevinfo.vendor == 0x0c76 + && (hiddevinfo.product == 0x1605 + || hiddevinfo.product == 0x1607 + || hiddevinfo.product == 0x160b)))) + { + rig_debug(RIG_DEBUG_VERBOSE, + "%s: cm108 compatible device detected\n", + __func__); + } else { + close(fd); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: no cm108 (or compatible) device detected\n", + __func__); + return -RIG_EINVAL; + } - if (!ioctl(fd, HIDIOCGRAWINFO, &hiddevinfo) - && - ( - (hiddevinfo.vendor == 0x0d8c && // CM108/109/119/119A - ((hiddevinfo.product >= 0x0008 && - hiddevinfo.product <= 0x000f) || - hiddevinfo.product == 0x013a) - ) - || - (hiddevinfo.vendor == 0x0c76 && // SSS1621/23 - (hiddevinfo.product == 0x1605 || - hiddevinfo.product == 0x1607 || - hiddevinfo.product == 0x160b) - ) - ) - ) - { - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108 compatible device detected \n"); - } - else - { - close(fd); - rig_debug(RIG_DEBUG_VERBOSE,"cm108:No cm108 (or compatible) device detected \n"); - return -RIG_EINVAL; - } #endif - port->fd = fd; - return fd; + port->fd = fd; + return fd; } + /** * \brief Close CM108 HID port * \param port */ int cm108_close(hamlib_port_t *port) { - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_close called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return close(port->fd); + return close(port->fd); } + /** * \brief Set or unset Push to talk bit on CM108 GPIO * \param p @@ -149,62 +154,70 @@ int cm108_close(hamlib_port_t *port) */ int cm108_ptt_set(hamlib_port_t *p, ptt_t pttx) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_ptt_set called \n"); + // For a CM108 USB audio device PTT is wired up to one of the GPIO + // pins. Usually this is GPIO3 (bit 2 of the GPIO register) because it + // is on the corner of the chip package (pin 13) so it's easily accessible. + // Some CM108 chips are epoxy-blobbed onto the PCB, so no GPIO + // pins are accessible. The SSS1623 chips have a different pinout, so + // we make the GPIO bit number configurable. - // For a CM108 USB audio device PTT is wired up to one of the GPIO - // pins. Usually this is GPIO3 (bit 2 of the GPIO register) because it - // is on the corner of the chip package (pin 13) so it's easily accessible. - // Some CM108 chips are epoxy-blobbed onto the PCB, so no GPIO - // pins are accessible. The SSS1623 chips have a different pinout, so - // we make the GPIO bit number configurable. + switch (p->type.ptt) { + case RIG_PTT_CM108: { - switch(p->type.ptt) { - case RIG_PTT_CM108: - { + // Build a packet for CM108 HID to turn GPIO bit on or off. + // Packet is 4 bytes, preceded by a 'report number' byte + // 0x00 report number + // Write data packet (from CM108 documentation) + // byte 0: 00xx xxxx Write GPIO + // byte 1: xxxx dcba GPIO3-0 output values (1=high) + // byte 2: xxxx dcba GPIO3-0 data-direction register (1=output) + // byte 3: xxxx xxxx SPDIF - // Build a packet for CM108 HID to turn GPIO bit on or off. - // Packet is 4 bytes, preceded by a 'report number' byte - // 0x00 report number - // Write data packet (from CM108 documentation) - // byte 0: 00xx xxxx Write GPIO - // byte 1: xxxx dcba GPIO3-0 output values (1=high) - // byte 2: xxxx dcba GPIO3-0 data-direction register (1=output) - // byte 3: xxxx xxxx SPDIF + rig_debug(RIG_DEBUG_VERBOSE, + "%s: bit number %d to state %d\n", + __func__, + p->parm.cm108.ptt_bitnum, + (pttx == RIG_PTT_ON) ? 1 : 0); - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_ptt_set bit number %d to state %d\n", - p->parm.cm108.ptt_bitnum, (pttx == RIG_PTT_ON) ? 1 : 0); + char out_rep[] = { + 0x00, // report number + // HID output report + 0x00, + (pttx == RIG_PTT_ON) ? (1 << p->parm.cm108.ptt_bitnum) : 0, // set GPIO + 1 << p->parm.cm108.ptt_bitnum, // Data direction register (1=output) + 0x00 + }; - char out_rep[] = { - 0x00, // report number - // HID output report - 0x00, - (pttx == RIG_PTT_ON) ? (1 << p->parm.cm108.ptt_bitnum) : 0, // set GPIO - 1 << p->parm.cm108.ptt_bitnum, // Data direction register (1=output) - 0x00 - }; + ssize_t nw; - ssize_t nw; + if (p->fd == -1) { + return -RIG_EINVAL; + } - if (p->fd == -1) - return -RIG_EINVAL; + // Send the HID packet + nw = write(p->fd, out_rep, sizeof(out_rep)); - // Send the HID packet - nw = write(p->fd, out_rep, sizeof(out_rep)); - if (nw < 0) { - return -RIG_EIO; - } + if (nw < 0) { + return -RIG_EIO; + } - return RIG_OK; - } - default: - rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n", - p->type.ptt); - return -RIG_EINVAL; - } - return RIG_OK; + return RIG_OK; + } + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported PTT type %d\n", + __func__, + p->type.ptt); + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief Get state of Push to Talk from CM108 GPIO * \param p @@ -213,21 +226,24 @@ int cm108_ptt_set(hamlib_port_t *p, ptt_t pttx) */ int cm108_ptt_get(hamlib_port_t *p, ptt_t *pttx) { - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_ptt_get called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - switch(p->type.ptt) { - case RIG_PTT_CM108: - { - int status; - return -RIG_ENIMPL; - return status; - } - default: - rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n", - p->type.ptt); - return -RIG_ENAVAIL; - } - return RIG_OK; + switch (p->type.ptt) { + case RIG_PTT_CM108: { + int status; + return -RIG_ENIMPL; + return status; + } + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported PTT type %d\n", + __func__, + p->type.ptt); + return -RIG_ENAVAIL; + } + + return RIG_OK; } /** @@ -238,26 +254,29 @@ int cm108_ptt_get(hamlib_port_t *p, ptt_t *pttx) */ int cm108_dcd_get(hamlib_port_t *p, dcd_t *dcdx) { - rig_debug(RIG_DEBUG_VERBOSE,"cm108:cm108_dcd_get called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - // On the CM108 and compatible chips the squelch line on the radio is - // wired to Volume Down input pin. The state of this pin is reported - // in HID messages from the CM108 device, but I am not sure how - // to query this state on demand. + // On the CM108 and compatible chips the squelch line on the radio is + // wired to Volume Down input pin. The state of this pin is reported + // in HID messages from the CM108 device, but I am not sure how + // to query this state on demand. - switch(p->type.dcd) { - case RIG_DCD_CM108: - { - int status; - return -RIG_ENIMPL; - return status; - } - default: - rig_debug(RIG_DEBUG_ERR,"Unsupported DCD type %d\n", - p->type.dcd); - return -RIG_ENAVAIL; - } - return RIG_OK; + switch (p->type.dcd) { + case RIG_DCD_CM108: { + int status; + return -RIG_ENIMPL; + return status; + } + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported DCD type %d\n", + __func__, + p->type.dcd); + return -RIG_ENAVAIL; + } + + return RIG_OK; } /** @} */ diff --git a/src/cm108.h b/src/cm108.h index 94d7c74cb..66e1db4be 100644 --- a/src/cm108.h +++ b/src/cm108.h @@ -36,12 +36,23 @@ int cm108_ptt_set(hamlib_port_t *p, ptt_t pttx); int cm108_ptt_get(hamlib_port_t *p, ptt_t *pttx); int cm108_dcd_get(hamlib_port_t *p, dcd_t *dcdx); -extern HAMLIB_EXPORT(int) cm108_write_data(hamlib_port_t *p, unsigned char data); -extern HAMLIB_EXPORT(int) cm108_write_control(hamlib_port_t *p, unsigned char control); -extern HAMLIB_EXPORT(int) cm108_read_data(hamlib_port_t *p, unsigned char *data); -extern HAMLIB_EXPORT(int) cm108_read_control(hamlib_port_t *p, unsigned char *control); -extern HAMLIB_EXPORT(int) cm108_read_status(hamlib_port_t *p, unsigned char *status); +extern HAMLIB_EXPORT(int) cm108_write_data(hamlib_port_t *p, + unsigned char data); + +extern HAMLIB_EXPORT(int) cm108_write_control(hamlib_port_t *p, + unsigned char control); + +extern HAMLIB_EXPORT(int) cm108_read_data(hamlib_port_t *p, + unsigned char *data); + +extern HAMLIB_EXPORT(int) cm108_read_control(hamlib_port_t *p, + unsigned char *control); + +extern HAMLIB_EXPORT(int) cm108_read_status(hamlib_port_t *p, + unsigned char *status); + extern HAMLIB_EXPORT(int) cm108_lock(hamlib_port_t *p); + extern HAMLIB_EXPORT(int) cm108_unlock(hamlib_port_t *p); __END_DECLS diff --git a/src/conf.c b/src/conf.c index edac0c342..6ac5788f4 100644 --- a/src/conf.c +++ b/src/conf.c @@ -43,468 +43,661 @@ #include #include "token.h" + /* * Configuration options available in the rig->state struct. */ static const struct confparams frontend_cfg_params[] = { - { TOK_PATHNAME, "rig_pathname", "Rig path name", - "Path name to the device file of the rig", - "/dev/rig", RIG_CONF_STRING, - }, - { TOK_WRITE_DELAY, "write_delay", "Write delay", - "Delay in ms between each byte sent out", - "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } - }, - { TOK_POST_WRITE_DELAY, "post_write_delay", "Post write delay", - "Delay in ms between each command sent out", - "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } - }, - { TOK_TIMEOUT, "timeout", "Timeout", "Timeout in ms", - "0", RIG_CONF_NUMERIC, { .n = { 0, 10000, 1 } } - }, - { TOK_RETRY, "retry", "Retry", "Max number of retry", - "0", RIG_CONF_NUMERIC, { .n = { 0, 10, 1 } } - }, - { TOK_ITU_REGION, "itu_region", "ITU region", - "ITU region this rig has been manufactured for (freq. band plan)", - "0", RIG_CONF_NUMERIC, { .n = { 1, 3, 1 } } - }, + { + TOK_PATHNAME, "rig_pathname", "Rig path name", + "Path name to the device file of the rig", + "/dev/rig", RIG_CONF_STRING, + }, + { + TOK_WRITE_DELAY, "write_delay", "Write delay", + "Delay in ms between each byte sent out", + "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } + }, + { + TOK_POST_WRITE_DELAY, "post_write_delay", "Post write delay", + "Delay in ms between each command sent out", + "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } + }, + { + TOK_TIMEOUT, "timeout", "Timeout", "Timeout in ms", + "0", RIG_CONF_NUMERIC, { .n = { 0, 10000, 1 } } + }, + { + TOK_RETRY, "retry", "Retry", "Max number of retry", + "0", RIG_CONF_NUMERIC, { .n = { 0, 10, 1 } } + }, + { + TOK_ITU_REGION, "itu_region", "ITU region", + "ITU region this rig has been manufactured for (freq. band plan)", + "0", RIG_CONF_NUMERIC, { .n = { 1, 3, 1 } } + }, - { TOK_VFO_COMP, "vfo_comp", "VFO compensation", - "VFO compensation in ppm", - "0", RIG_CONF_NUMERIC, { .n = { 0.0, 1000.0, .001 } } - }, - { TOK_POLL_INTERVAL, "poll_interval", "Polling interval", - "Polling interval in millisecond for transceive emulation", - "500", RIG_CONF_NUMERIC, { .n = { 0, 1000000, 1 } } - }, - { TOK_PTT_TYPE, "ptt_type", "PTT type", - "Push-To-Talk interface type override", - "RIG", RIG_CONF_COMBO, { .c = {{ "RIG", "DTR", "RTS", "Parallel", "CM108", "None", NULL }} } - }, - { TOK_PTT_PATHNAME, "ptt_pathname", "PTT path name", - "Path name to the device file of the Push-To-Talk", - "/dev/rig", RIG_CONF_STRING, - }, - { TOK_PTT_BITNUM, "ptt_bitnum", "PTT bit [0-7]", - "Push-To-Talk GPIO bit number", - "2", RIG_CONF_NUMERIC, { .n = { 0, 7, 1 } } - }, - { TOK_DCD_TYPE, "dcd_type", "DCD type", - "Data Carrier Detect (or squelch) interface type override", - "RIG", RIG_CONF_COMBO, { .c = {{ "RIG", "DSR", "CTS", "CD", "Parallel", "CM108", "None", NULL }} } - }, - { TOK_DCD_PATHNAME, "dcd_pathname", "DCD path name", - "Path name to the device file of the Data Carrier Detect (or squelch)", - "/dev/rig", RIG_CONF_STRING, - }, + { + TOK_VFO_COMP, "vfo_comp", "VFO compensation", + "VFO compensation in ppm", + "0", RIG_CONF_NUMERIC, { .n = { 0.0, 1000.0, .001 } } + }, + { + TOK_POLL_INTERVAL, "poll_interval", "Polling interval", + "Polling interval in millisecond for transceive emulation", + "500", RIG_CONF_NUMERIC, { .n = { 0, 1000000, 1 } } + }, + { + TOK_PTT_TYPE, "ptt_type", "PTT type", + "Push-To-Talk interface type override", + "RIG", RIG_CONF_COMBO, { .c = {{ "RIG", "DTR", "RTS", "Parallel", "CM108", "None", NULL }} } + }, + { + TOK_PTT_PATHNAME, "ptt_pathname", "PTT path name", + "Path name to the device file of the Push-To-Talk", + "/dev/rig", RIG_CONF_STRING, + }, + { + TOK_PTT_BITNUM, "ptt_bitnum", "PTT bit [0-7]", + "Push-To-Talk GPIO bit number", + "2", RIG_CONF_NUMERIC, { .n = { 0, 7, 1 } } + }, + { + TOK_DCD_TYPE, "dcd_type", "DCD type", + "Data Carrier Detect (or squelch) interface type override", + "RIG", RIG_CONF_COMBO, { .c = {{ "RIG", "DSR", "CTS", "CD", "Parallel", "CM108", "None", NULL }} } + }, + { + TOK_DCD_PATHNAME, "dcd_pathname", "DCD path name", + "Path name to the device file of the Data Carrier Detect (or squelch)", + "/dev/rig", RIG_CONF_STRING, + }, - { RIG_CONF_END, NULL, } + { RIG_CONF_END, NULL, } }; static const struct confparams frontend_serial_cfg_params[] = { - { TOK_SERIAL_SPEED, "serial_speed", "Serial speed", - "Serial port baud rate", - "0", RIG_CONF_NUMERIC, { .n = { 300, 115200, 1 } } - }, - { TOK_DATA_BITS, "data_bits", "Serial data bits", - "Serial port data bits", - "8", RIG_CONF_NUMERIC, { .n = { 5, 8, 1 } } - }, - { TOK_STOP_BITS, "stop_bits", "Serial stop bits", - "Serial port stop bits", - "1", RIG_CONF_NUMERIC, { .n = { 0, 3, 1 } } - }, - { TOK_PARITY, "serial_parity", "Serial parity", - "Serial port parity", - "None", RIG_CONF_COMBO, { .c = {{ "None", "Odd", "Even", "Mark", "Space", NULL }} } - }, - { TOK_HANDSHAKE, "serial_handshake", "Serial handshake", - "Serial port handshake", - "None", RIG_CONF_COMBO, { .c = {{ "None", "XONXOFF", "Hardware", NULL }} } - }, + { + TOK_SERIAL_SPEED, "serial_speed", "Serial speed", + "Serial port baud rate", + "0", RIG_CONF_NUMERIC, { .n = { 300, 115200, 1 } } + }, + { + TOK_DATA_BITS, "data_bits", "Serial data bits", + "Serial port data bits", + "8", RIG_CONF_NUMERIC, { .n = { 5, 8, 1 } } + }, + { + TOK_STOP_BITS, "stop_bits", "Serial stop bits", + "Serial port stop bits", + "1", RIG_CONF_NUMERIC, { .n = { 0, 3, 1 } } + }, + { + TOK_PARITY, "serial_parity", "Serial parity", + "Serial port parity", + "None", RIG_CONF_COMBO, { .c = {{ "None", "Odd", "Even", "Mark", "Space", NULL }} } + }, + { + TOK_HANDSHAKE, "serial_handshake", "Serial handshake", + "Serial port handshake", + "None", RIG_CONF_COMBO, { .c = {{ "None", "XONXOFF", "Hardware", NULL }} } + }, - { TOK_RTS_STATE, "rts_state", "RTS state", - "Serial port set state of RTS signal for external powering", - "Unset", RIG_CONF_COMBO, { .c = {{ "Unset", "ON", "OFF", NULL }} } - }, - { TOK_DTR_STATE, "dtr_state", "DTR state", - "Serial port set state of DTR signal for external powering", - "Unset", RIG_CONF_COMBO, { .c = {{ "Unset", "ON", "OFF", NULL }} } - }, + { + TOK_RTS_STATE, "rts_state", "RTS state", + "Serial port set state of RTS signal for external powering", + "Unset", RIG_CONF_COMBO, { .c = {{ "Unset", "ON", "OFF", NULL }} } + }, + { + TOK_DTR_STATE, "dtr_state", "DTR state", + "Serial port set state of DTR signal for external powering", + "Unset", RIG_CONF_COMBO, { .c = {{ "Unset", "ON", "OFF", NULL }} } + }, - { RIG_CONF_END, NULL, } + { RIG_CONF_END, NULL, } }; + /* * frontend_set_conf * assumes rig!=NULL, val!=NULL */ static int frontend_set_conf(RIG *rig, token_t token, const char *val) { - const struct rig_caps *caps; - struct rig_state *rs; - int val_i; + const struct rig_caps *caps; + struct rig_state *rs; + int val_i; - caps = rig->caps; - rs = &rig->state; + caps = rig->caps; + rs = &rig->state; - switch(token) { - case TOK_PATHNAME: - strncpy(rs->rigport.pathname, val, FILPATHLEN-1); - break; - case TOK_WRITE_DELAY: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.write_delay = val_i; - break; - case TOK_POST_WRITE_DELAY: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.post_write_delay = val_i; - break; - case TOK_TIMEOUT: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.timeout = val_i; - break; - case TOK_RETRY: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.retry = val_i; - break; + switch (token) { + case TOK_PATHNAME: + strncpy(rs->rigport.pathname, val, FILPATHLEN - 1); + break; - case TOK_SERIAL_SPEED: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.parm.serial.rate = val_i; - break; - case TOK_DATA_BITS: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.parm.serial.data_bits = val_i; - break; - case TOK_STOP_BITS: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->rigport.parm.serial.stop_bits = val_i; - break; - case TOK_PARITY: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "None")) - rs->rigport.parm.serial.parity = RIG_PARITY_NONE; - else if (!strcmp(val, "Odd")) - rs->rigport.parm.serial.parity = RIG_PARITY_ODD; - else if (!strcmp(val, "Even")) - rs->rigport.parm.serial.parity = RIG_PARITY_EVEN; - else if (!strcmp(val, "Mark")) - rs->rigport.parm.serial.parity = RIG_PARITY_MARK; - else if (!strcmp(val, "Space")) - rs->rigport.parm.serial.parity = RIG_PARITY_SPACE; - else - return -RIG_EINVAL; - break; - case TOK_HANDSHAKE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "None")) - rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE; - else if (!strcmp(val, "XONXOFF")) - rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF; - else if (!strcmp(val, "Hardware")) - rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE; - else - return -RIG_EINVAL; - break; + case TOK_WRITE_DELAY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } - case TOK_RTS_STATE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "Unset")) - rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET; - else if (!strcmp(val, "ON")) - rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON; - else if (!strcmp(val, "OFF")) - rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF; - else - return -RIG_EINVAL; - break; + rs->rigport.write_delay = val_i; + break; - case TOK_DTR_STATE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "Unset")) - rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET; - else if (!strcmp(val, "ON")) - rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON; - else if (!strcmp(val, "OFF")) - rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF; - else - return -RIG_EINVAL; - break; + case TOK_POST_WRITE_DELAY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } - case TOK_ITU_REGION: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - switch(val_i) { - case RIG_ITU_REGION1: - rs->itu_region = val_i; - memcpy(rs->tx_range_list, caps->tx_range_list1, - sizeof(struct freq_range_list)*FRQRANGESIZ); - memcpy(rs->rx_range_list, caps->rx_range_list1, - sizeof(struct freq_range_list)*FRQRANGESIZ); - break; - case RIG_ITU_REGION2: - case RIG_ITU_REGION3: - rs->itu_region = val_i; - memcpy(rs->tx_range_list, caps->tx_range_list2, - sizeof(struct freq_range_list)*FRQRANGESIZ); - memcpy(rs->rx_range_list, caps->rx_range_list2, - sizeof(struct freq_range_list)*FRQRANGESIZ); - break; - default: - return -RIG_EINVAL; - } - break; + rs->rigport.post_write_delay = val_i; + break; - case TOK_PTT_TYPE: - if (!strcmp(val, "RIG")) - rs->pttport.type.ptt = RIG_PTT_RIG; - else if (!strcmp(val, "RIGMICDATA")) - rs->pttport.type.ptt = RIG_PTT_RIG_MICDATA; - else if (!strcmp(val, "DTR")) - rs->pttport.type.ptt = RIG_PTT_SERIAL_DTR; - else if (!strcmp(val, "RTS")) - rs->pttport.type.ptt = RIG_PTT_SERIAL_RTS; - else if (!strcmp(val, "Parallel")) - rs->pttport.type.ptt = RIG_PTT_PARALLEL; - else if (!strcmp(val, "CM108")) - rs->pttport.type.ptt = RIG_PTT_CM108; - else if (!strcmp(val, "None")) - rs->pttport.type.ptt = RIG_PTT_NONE; - else - return -RIG_EINVAL; - break; + case TOK_TIMEOUT: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } - case TOK_PTT_PATHNAME: - strncpy(rs->pttport.pathname, val, FILPATHLEN-1); - break; + rs->rigport.timeout = val_i; + break; - case TOK_PTT_BITNUM: - if (1 != sscanf(val, "%d", &val_i)){ - return -RIG_EINVAL;//value format error - } - rs->pttport.parm.cm108.ptt_bitnum=val_i; - break; + case TOK_RETRY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } - case TOK_DCD_TYPE: - if (!strcmp(val, "RIG")) - rs->dcdport.type.dcd = RIG_DCD_RIG; - else if (!strcmp(val, "DSR")) - rs->dcdport.type.dcd = RIG_DCD_SERIAL_DSR; - else if (!strcmp(val, "CTS")) - rs->dcdport.type.dcd = RIG_DCD_SERIAL_CTS; - else if (!strcmp(val, "CD")) - rs->dcdport.type.dcd = RIG_DCD_SERIAL_CAR; - else if (!strcmp(val, "Parallel")) - rs->dcdport.type.dcd = RIG_DCD_PARALLEL; - else if (!strcmp(val, "CM108")) - rs->dcdport.type.dcd = RIG_DCD_CM108; - else if (!strcmp(val, "None")) - rs->dcdport.type.dcd = RIG_DCD_NONE; - else - return -RIG_EINVAL; - break; + rs->rigport.retry = val_i; + break; - case TOK_DCD_PATHNAME: - strncpy(rs->dcdport.pathname, val, FILPATHLEN-1); - break; + case TOK_SERIAL_SPEED: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } - case TOK_VFO_COMP: - rs->vfo_comp = atof(val); - break; - case TOK_POLL_INTERVAL: - rs->poll_interval = atof(val); - break; + rs->rigport.parm.serial.rate = val_i; + break; + case TOK_DATA_BITS: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } + + rs->rigport.parm.serial.data_bits = val_i; + break; + + case TOK_STOP_BITS: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } + + rs->rigport.parm.serial.stop_bits = val_i; + break; + + case TOK_PARITY: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "None")) { + rs->rigport.parm.serial.parity = RIG_PARITY_NONE; + } else if (!strcmp(val, "Odd")) { + rs->rigport.parm.serial.parity = RIG_PARITY_ODD; + } else if (!strcmp(val, "Even")) { + rs->rigport.parm.serial.parity = RIG_PARITY_EVEN; + } else if (!strcmp(val, "Mark")) { + rs->rigport.parm.serial.parity = RIG_PARITY_MARK; + } else if (!strcmp(val, "Space")) { + rs->rigport.parm.serial.parity = RIG_PARITY_SPACE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_HANDSHAKE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "None")) { + rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE; + } else if (!strcmp(val, "XONXOFF")) { + rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF; + } else if (!strcmp(val, "Hardware")) { + rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_RTS_STATE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "Unset")) { + rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET; + } else if (!strcmp(val, "ON")) { + rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON; + } else if (!strcmp(val, "OFF")) { + rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_DTR_STATE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "Unset")) { + rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET; + } else if (!strcmp(val, "ON")) { + rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON; + } else if (!strcmp(val, "OFF")) { + rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_ITU_REGION: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } + + switch (val_i) { + case RIG_ITU_REGION1: + rs->itu_region = val_i; + memcpy(rs->tx_range_list, caps->tx_range_list1, + sizeof(struct freq_range_list)*FRQRANGESIZ); + memcpy(rs->rx_range_list, caps->rx_range_list1, + sizeof(struct freq_range_list)*FRQRANGESIZ); + break; + + case RIG_ITU_REGION2: + case RIG_ITU_REGION3: + rs->itu_region = val_i; + memcpy(rs->tx_range_list, caps->tx_range_list2, + sizeof(struct freq_range_list)*FRQRANGESIZ); + memcpy(rs->rx_range_list, caps->rx_range_list2, + sizeof(struct freq_range_list)*FRQRANGESIZ); + break; default: - return -RIG_EINVAL; + return -RIG_EINVAL; } - return RIG_OK; + + break; + + case TOK_PTT_TYPE: + if (!strcmp(val, "RIG")) { + rs->pttport.type.ptt = RIG_PTT_RIG; + } else if (!strcmp(val, "RIGMICDATA")) { + rs->pttport.type.ptt = RIG_PTT_RIG_MICDATA; + } else if (!strcmp(val, "DTR")) { + rs->pttport.type.ptt = RIG_PTT_SERIAL_DTR; + } else if (!strcmp(val, "RTS")) { + rs->pttport.type.ptt = RIG_PTT_SERIAL_RTS; + } else if (!strcmp(val, "Parallel")) { + rs->pttport.type.ptt = RIG_PTT_PARALLEL; + } else if (!strcmp(val, "CM108")) { + rs->pttport.type.ptt = RIG_PTT_CM108; + } else if (!strcmp(val, "None")) { + rs->pttport.type.ptt = RIG_PTT_NONE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_PTT_PATHNAME: + strncpy(rs->pttport.pathname, val, FILPATHLEN - 1); + break; + + case TOK_PTT_BITNUM: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL;//value format error + } + + rs->pttport.parm.cm108.ptt_bitnum = val_i; + break; + + case TOK_DCD_TYPE: + if (!strcmp(val, "RIG")) { + rs->dcdport.type.dcd = RIG_DCD_RIG; + } else if (!strcmp(val, "DSR")) { + rs->dcdport.type.dcd = RIG_DCD_SERIAL_DSR; + } else if (!strcmp(val, "CTS")) { + rs->dcdport.type.dcd = RIG_DCD_SERIAL_CTS; + } else if (!strcmp(val, "CD")) { + rs->dcdport.type.dcd = RIG_DCD_SERIAL_CAR; + } else if (!strcmp(val, "Parallel")) { + rs->dcdport.type.dcd = RIG_DCD_PARALLEL; + } else if (!strcmp(val, "CM108")) { + rs->dcdport.type.dcd = RIG_DCD_CM108; + } else if (!strcmp(val, "None")) { + rs->dcdport.type.dcd = RIG_DCD_NONE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_DCD_PATHNAME: + strncpy(rs->dcdport.pathname, val, FILPATHLEN - 1); + break; + + + case TOK_VFO_COMP: + rs->vfo_comp = atof(val); + break; + + case TOK_POLL_INTERVAL: + rs->poll_interval = atof(val); + break; + + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /* * frontend_get_conf * assumes rig!=NULL, val!=NULL */ static int frontend_get_conf(RIG *rig, token_t token, char *val) { - struct rig_state *rs; - const char *s = ""; + struct rig_state *rs; + const char *s = ""; - rs = &rig->state; + rs = &rig->state; - switch(token) { - case TOK_PATHNAME: - strcpy(val, rs->rigport.pathname); - break; - case TOK_WRITE_DELAY: - sprintf(val, "%d", rs->rigport.write_delay); - break; - case TOK_POST_WRITE_DELAY: - sprintf(val, "%d", rs->rigport.post_write_delay); - break; - case TOK_TIMEOUT: - sprintf(val, "%d", rs->rigport.timeout); - break; - case TOK_RETRY: - sprintf(val, "%d", rs->rigport.retry); - break; - case TOK_ITU_REGION: - sprintf(val, "%d", - rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2); - break; - case TOK_SERIAL_SPEED: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rigport.parm.serial.rate); - break; - case TOK_DATA_BITS: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rigport.parm.serial.data_bits); - break; - case TOK_STOP_BITS: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rigport.parm.serial.stop_bits); - break; - case TOK_PARITY: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rigport.parm.serial.parity) { - case RIG_PARITY_NONE: s = "None"; break; - case RIG_PARITY_ODD: s = "Odd"; break; - case RIG_PARITY_EVEN: s = "Even"; break; - case RIG_PARITY_MARK: s = "Mark"; break; - case RIG_PARITY_SPACE: s = "Space"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; - case TOK_HANDSHAKE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rigport.parm.serial.handshake) { - case RIG_HANDSHAKE_NONE: s = "None"; break; - case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break; - case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; + switch (token) { + case TOK_PATHNAME: + strcpy(val, rs->rigport.pathname); + break; - case TOK_RTS_STATE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rigport.parm.serial.rts_state) { - case RIG_SIGNAL_UNSET: s = "Unset"; break; - case RIG_SIGNAL_ON: s = "ON"; break; - case RIG_SIGNAL_OFF: s = "OFF"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; + case TOK_WRITE_DELAY: + sprintf(val, "%d", rs->rigport.write_delay); + break; - case TOK_DTR_STATE: - if (rs->rigport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rigport.parm.serial.dtr_state) { - case RIG_SIGNAL_UNSET: s = "Unset"; break; - case RIG_SIGNAL_ON: s = "ON"; break; - case RIG_SIGNAL_OFF: s = "OFF"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; + case TOK_POST_WRITE_DELAY: + sprintf(val, "%d", rs->rigport.post_write_delay); + break; - case TOK_VFO_COMP: - sprintf(val, "%f", rs->vfo_comp); - break; - case TOK_POLL_INTERVAL: - sprintf(val, "%d", rs->poll_interval); - break; + case TOK_TIMEOUT: + sprintf(val, "%d", rs->rigport.timeout); + break; - case TOK_PTT_TYPE: - switch(rs->pttport.type.ptt) { - case RIG_PTT_RIG: s = "RIG"; break; - case RIG_PTT_RIG_MICDATA: s = "RIGMICDATA"; break; - case RIG_PTT_SERIAL_DTR: s = "DTR"; break; - case RIG_PTT_SERIAL_RTS: s = "RTS"; break; - case RIG_PTT_PARALLEL: s = "Parallel"; break; - case RIG_PTT_CM108: s = "CM108"; break; - case RIG_PTT_NONE: s = "None"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; + case TOK_RETRY: + sprintf(val, "%d", rs->rigport.retry); + break; - case TOK_PTT_PATHNAME: - strcpy(val, rs->pttport.pathname); - break; + case TOK_ITU_REGION: + sprintf(val, "%d", + rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2); + break; - case TOK_PTT_BITNUM: - sprintf(val, "%d", rs->pttport.parm.cm108.ptt_bitnum); - break; + case TOK_SERIAL_SPEED: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } - case TOK_DCD_TYPE: - switch(rs->dcdport.type.dcd) { - case RIG_DCD_RIG: s = "RIG"; break; - case RIG_DCD_SERIAL_DSR: s = "DSR"; break; - case RIG_DCD_SERIAL_CTS: s = "CTS"; break; - case RIG_DCD_SERIAL_CAR: s = "CD"; break; - case RIG_DCD_PARALLEL: s = "Parallel"; break; - case RIG_DCD_CM108: s = "CM108"; break; - case RIG_DCD_NONE: s = "None"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; + sprintf(val, "%d", rs->rigport.parm.serial.rate); + break; - case TOK_DCD_PATHNAME: - strcpy(val, rs->dcdport.pathname); - break; + case TOK_DATA_BITS: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } - default: - return -RIG_EINVAL; - } + sprintf(val, "%d", rs->rigport.parm.serial.data_bits); + break; - return RIG_OK; + case TOK_STOP_BITS: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + sprintf(val, "%d", rs->rigport.parm.serial.stop_bits); + break; + + case TOK_PARITY: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rigport.parm.serial.parity) { + case RIG_PARITY_NONE: + s = "None"; + break; + + case RIG_PARITY_ODD: + s = "Odd"; + break; + + case RIG_PARITY_EVEN: + s = "Even"; + break; + + case RIG_PARITY_MARK: + s = "Mark"; + break; + + case RIG_PARITY_SPACE: + s = "Space"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_HANDSHAKE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rigport.parm.serial.handshake) { + case RIG_HANDSHAKE_NONE: + s = "None"; + break; + + case RIG_HANDSHAKE_XONXOFF: + s = "XONXOFF"; + break; + + case RIG_HANDSHAKE_HARDWARE: + s = "Hardware"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_RTS_STATE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rigport.parm.serial.rts_state) { + case RIG_SIGNAL_UNSET: + s = "Unset"; + break; + + case RIG_SIGNAL_ON: + s = "ON"; + break; + + case RIG_SIGNAL_OFF: + s = "OFF"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_DTR_STATE: + if (rs->rigport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rigport.parm.serial.dtr_state) { + case RIG_SIGNAL_UNSET: + s = "Unset"; + break; + + case RIG_SIGNAL_ON: + s = "ON"; + break; + + case RIG_SIGNAL_OFF: + s = "OFF"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_VFO_COMP: + sprintf(val, "%f", rs->vfo_comp); + break; + + case TOK_POLL_INTERVAL: + sprintf(val, "%d", rs->poll_interval); + break; + + case TOK_PTT_TYPE: + switch (rs->pttport.type.ptt) { + case RIG_PTT_RIG: + s = "RIG"; + break; + + case RIG_PTT_RIG_MICDATA: + s = "RIGMICDATA"; + break; + + case RIG_PTT_SERIAL_DTR: + s = "DTR"; + break; + + case RIG_PTT_SERIAL_RTS: + s = "RTS"; + break; + + case RIG_PTT_PARALLEL: + s = "Parallel"; + break; + + case RIG_PTT_CM108: + s = "CM108"; + break; + + case RIG_PTT_NONE: + s = "None"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_PTT_PATHNAME: + strcpy(val, rs->pttport.pathname); + break; + + case TOK_PTT_BITNUM: + sprintf(val, "%d", rs->pttport.parm.cm108.ptt_bitnum); + break; + + case TOK_DCD_TYPE: + switch (rs->dcdport.type.dcd) { + case RIG_DCD_RIG: + s = "RIG"; + break; + + case RIG_DCD_SERIAL_DSR: + s = "DSR"; + break; + + case RIG_DCD_SERIAL_CTS: + s = "CTS"; + break; + + case RIG_DCD_SERIAL_CAR: + s = "CD"; + break; + + case RIG_DCD_PARALLEL: + s = "Parallel"; + break; + + case RIG_DCD_CM108: + s = "CM108"; + break; + + case RIG_DCD_NONE: + s = "None"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_DCD_PATHNAME: + strcpy(val, rs->dcdport.pathname); + break; + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief call a function against each configuration token of a rig - * \param rig The rig handle - * \param cfunc The function to perform on each token - * \param data Any data to be passed to cfunc + * \param rig The rig handle + * \param cfunc The function to perform on each token + * \param data Any data to be passed to cfunc * * Executes \a cfunc on all the elements stored in the conf table. * rig_token_foreach starts first with backend conf table, then finish @@ -514,72 +707,88 @@ static int frontend_get_conf(RIG *rig, token_t token, char *val) * a negative value if an error occured (in which case, cause is * set appropriately). */ -int HAMLIB_API rig_token_foreach(RIG *rig, int (*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data) +int HAMLIB_API rig_token_foreach(RIG *rig, + int (*cfunc)(const struct confparams *, rig_ptr_t), + rig_ptr_t data) { - const struct confparams *cfp; + const struct confparams *cfp; - if (!rig || !rig->caps || !cfunc) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = frontend_cfg_params; cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; + if (!rig || !rig->caps || !cfunc) { + return -RIG_EINVAL; + } - if (rig->caps->port_type == RIG_PORT_SERIAL) { - for (cfp = frontend_serial_cfg_params; cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; - } + for (cfp = frontend_cfg_params; cfp->name; cfp++) + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } - for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; + if (rig->caps->port_type == RIG_PORT_SERIAL) { + for (cfp = frontend_serial_cfg_params; cfp->name; cfp++) + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } + } - return RIG_OK; + for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++) + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } + + return RIG_OK; } /** * \brief lookup a confparam struct - * \param rig The rig handle - * \param name The name of the configuration parameter + * \param rig The rig handle + * \param name The name of the configuration parameter * * Lookup conf token by its name. * * \return a pointer to the confparams struct if found, otherwise NULL. */ -const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *name) +const struct confparams *HAMLIB_API rig_confparam_lookup(RIG *rig, + const char *name) { - const struct confparams *cfp; + const struct confparams *cfp; token_t token; - if (!rig || !rig->caps) - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* 0 returned for invalid format */ - token = strtol(name, NULL, 0); + if (!rig || !rig->caps) { + return NULL; + } - for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; + /* 0 returned for invalid format */ + token = strtol(name, NULL, 0); - for (cfp = frontend_cfg_params; cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; + for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++) + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } - if (rig->caps->port_type == RIG_PORT_SERIAL) { - for (cfp = frontend_serial_cfg_params; cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; - } + for (cfp = frontend_cfg_params; cfp->name; cfp++) + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } - return NULL; + if (rig->caps->port_type == RIG_PORT_SERIAL) { + for (cfp = frontend_serial_cfg_params; cfp->name; cfp++) + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } + } + + return NULL; } + /** * \brief lookup a token id - * \param rig The rig handle - * \param name The name of the configuration parameter + * \param rig The rig handle + * \param name The name of the configuration parameter * * Simple lookup returning token id assicated with name. * @@ -587,20 +796,25 @@ const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char * */ token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name) { - const struct confparams *cfp; + const struct confparams *cfp; - cfp = rig_confparam_lookup(rig, name); - if (!cfp) - return RIG_CONF_END; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return cfp->token; + cfp = rig_confparam_lookup(rig, name); + + if (!cfp) { + return RIG_CONF_END; + } + + return cfp->token; } + /** * \brief set a radio configuration parameter - * \param rig The rig handle - * \param token The parameter - * \param val The value to set the parameter to + * \param rig The rig handle + * \param token The parameter + * \param val The value to set the parameter to * * Sets a configuration parameter. * @@ -612,33 +826,42 @@ token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name) */ int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val) { - if (!rig || !rig->caps) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + if (!rig || !rig->caps) { + return -RIG_EINVAL; + } if (rig_need_debug(RIG_DEBUG_VERBOSE)) { - const struct confparams *cfp; + const struct confparams *cfp; char tokenstr[12]; sprintf(tokenstr, "%ld", token); cfp = rig_confparam_lookup(rig, tokenstr); - if (!cfp) + + if (!cfp) { return -RIG_EINVAL; + } + rig_debug(RIG_DEBUG_VERBOSE, "%s: %s='%s'\n", __func__, cfp->name, val); } - if (IS_TOKEN_FRONTEND(token)) - return frontend_set_conf(rig, token, val); + if (IS_TOKEN_FRONTEND(token)) { + return frontend_set_conf(rig, token, val); + } - if (rig->caps->set_conf == NULL) - return -RIG_ENAVAIL; + if (rig->caps->set_conf == NULL) { + return -RIG_ENAVAIL; + } - return rig->caps->set_conf(rig, token, val); + return rig->caps->set_conf(rig, token, val); } + /** * \brief get the value of a configuration parameter - * \param rig The rig handle - * \param token The parameter - * \param val The location where to store the value of config \a token + * \param rig The rig handle + * \param token The parameter + * \param val The location where to store the value of config \a token * * Retrieves the value of a configuration paramter associated with \a token. * The location pointed to by val must be large enough to hold the value of the config. @@ -651,16 +874,21 @@ int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val) */ int HAMLIB_API rig_get_conf(RIG *rig, token_t token, char *val) { - if (!rig || !rig->caps || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (IS_TOKEN_FRONTEND(token)) - return frontend_get_conf(rig, token, val); + if (!rig || !rig->caps || !val) { + return -RIG_EINVAL; + } - if (rig->caps->get_conf == NULL) - return -RIG_ENAVAIL; + if (IS_TOKEN_FRONTEND(token)) { + return frontend_get_conf(rig, token, val); + } - return rig->caps->get_conf(rig, token, val); + if (rig->caps->get_conf == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->get_conf(rig, token, val); } /*! @} */ diff --git a/src/debug.c b/src/debug.c index 3feae137b..bd43c6248 100644 --- a/src/debug.c +++ b/src/debug.c @@ -35,11 +35,11 @@ #include #include -#include /* Standard input/output definitions */ -#include /* String function definitions */ -#include /* UNIX standard function definitions */ -#include /* File control definitions */ -#include /* Error number definitions */ +#include /* Standard input/output definitions */ +#include /* String function definitions */ +#include /* UNIX standard function definitions */ +#include /* File control definitions */ +#include /* Error number definitions */ #include #include @@ -48,16 +48,17 @@ #endif #include - #include "misc.h" +#define DUMP_HEX_WIDTH 16 + + static int rig_debug_level = RIG_DEBUG_TRACE; static FILE *rig_debug_stream; static vprintf_cb_t rig_vprintf_cb; static rig_ptr_t rig_vprintf_arg; -#define DUMP_HEX_WIDTH 16 /** * \param ptr Pointer to memory area * \param size Number of chars to words to dump @@ -65,39 +66,42 @@ static rig_ptr_t rig_vprintf_arg; */ void dump_hex(const unsigned char ptr[], size_t size) { - /* example - * 0000 4b 30 30 31 34 35 30 30 30 30 30 30 30 35 30 32 K001450000000502 - * 0010 30 30 0d 0a 00.. - */ - char line[4 + 4 + 3 * DUMP_HEX_WIDTH + 4 + DUMP_HEX_WIDTH + 1]; - unsigned char c; - int i; + /* example + * 0000 4b 30 30 31 34 35 30 30 30 30 30 30 30 35 30 32 K001450000000502 + * 0010 30 30 0d 0a 00.. + */ + char line[4 + 4 + 3 * DUMP_HEX_WIDTH + 4 + DUMP_HEX_WIDTH + 1]; + unsigned char c; + int i; - if (!rig_need_debug(RIG_DEBUG_TRACE)) - return; + if (!rig_need_debug(RIG_DEBUG_TRACE)) { + return; + } - line[sizeof(line) - 1] = '\0'; + line[sizeof(line) - 1] = '\0'; - for (i = 0; i < size; ++i) { - if (i % DUMP_HEX_WIDTH == 0) { - /* new line */ - sprintf(line + 0, "%04x", i); - memset(line + 4, ' ', sizeof(line) - 4 - 1); - } + for (i = 0; i < size; ++i) { + if (i % DUMP_HEX_WIDTH == 0) { + /* new line */ + sprintf(line + 0, "%04x", i); + memset(line + 4, ' ', sizeof(line) - 4 - 1); + } - c = ptr[i]; + c = ptr[i]; - /* hex print */ - sprintf(line + 8 + 3 * (i % DUMP_HEX_WIDTH), "%02x", c); - line[8 + 3 * (i % DUMP_HEX_WIDTH) + 2] = ' '; /* no \0 */ + /* hex print */ + sprintf(line + 8 + 3 * (i % DUMP_HEX_WIDTH), "%02x", c); + line[8 + 3 * (i % DUMP_HEX_WIDTH) + 2] = ' '; /* no \0 */ - /* ascii print */ - line[8 + 3 * DUMP_HEX_WIDTH + 4 + (i % DUMP_HEX_WIDTH)] = (c >= ' ' && c < 0x7f) ? c : '.'; + /* ascii print */ + line[8 + 3 * DUMP_HEX_WIDTH + 4 + (i % DUMP_HEX_WIDTH)] = (c >= ' ' + && c < 0x7f) ? c : '.'; - /* actually print the line */ - if (i + 1 == size || (i && i % DUMP_HEX_WIDTH == DUMP_HEX_WIDTH - 1)) - rig_debug(RIG_DEBUG_TRACE, "%s\n", line); - } + /* actually print the line */ + if (i + 1 == size || (i && i % DUMP_HEX_WIDTH == DUMP_HEX_WIDTH - 1)) { + rig_debug(RIG_DEBUG_TRACE, "%s\n", line); + } + } } @@ -107,97 +111,114 @@ void dump_hex(const unsigned char ptr[], size_t size) */ void HAMLIB_API rig_set_debug(enum rig_debug_level_e debug_level) { - rig_debug_level = debug_level; + rig_debug_level = debug_level; } + /** * \param debug_level * \brief Useful for dump_hex, etc. */ int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level) { - return (debug_level <= rig_debug_level); + return (debug_level <= rig_debug_level); } + /** * \param debug_level * \param fmt * \brief Default is debugging messages are done through stderr */ -void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, ...) +void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, + const char *fmt, ...) { - va_list ap; + va_list ap; - if (!rig_need_debug(debug_level)) - return; + if (!rig_need_debug(debug_level)) { + return; + } - va_start(ap, fmt); + va_start(ap, fmt); - if (rig_vprintf_cb) { + if (rig_vprintf_cb) { + rig_vprintf_cb(debug_level, rig_vprintf_arg, fmt, ap); + } else { + if (!rig_debug_stream) { + rig_debug_stream = stderr; + } - rig_vprintf_cb(debug_level, rig_vprintf_arg, fmt, ap); + vfprintf(rig_debug_stream, fmt, ap); + fflush(rig_debug_stream); + } - } else { - if (!rig_debug_stream) - rig_debug_stream = stderr; - - vfprintf (rig_debug_stream, fmt, ap); - fflush(rig_debug_stream); - } - - va_end(ap); + va_end(ap); #ifdef ANDROID int a; va_start(ap, fmt); - switch (debug_level){ + + switch (debug_level) { // case RIG_DEBUG_NONE: - case RIG_DEBUG_BUG: - a = ANDROID_LOG_FATAL; break; - case RIG_DEBUG_ERR: - a = ANDROID_LOG_ERROR; break; - case RIG_DEBUG_WARN: - a = ANDROID_LOG_WARN; break; - case RIG_DEBUG_VERBOSE: - a = ANDROID_LOG_VERBOSE; break; - case RIG_DEBUG_TRACE: - a = ANDROID_LOG_VERBOSE; break; - default: - a = ANDROID_LOG_DEBUG; break; + case RIG_DEBUG_BUG: + a = ANDROID_LOG_FATAL; + break; + + case RIG_DEBUG_ERR: + a = ANDROID_LOG_ERROR; + break; + + case RIG_DEBUG_WARN: + a = ANDROID_LOG_WARN; + break; + + case RIG_DEBUG_VERBOSE: + a = ANDROID_LOG_VERBOSE; + break; + + case RIG_DEBUG_TRACE: + a = ANDROID_LOG_VERBOSE; + break; + + default: + a = ANDROID_LOG_DEBUG; + break; } + __android_log_vprint(a, PACKAGE_NAME, fmt, ap); - va_end(ap); + va_end(ap); #endif } + /** * \brief set callback to handle debug messages - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for \a rig_debug messages. \code int -rig_message_cb (enum rig_debug_level_e debug_level, - rig_ptr_t user_data, - const char *fmt, - va_list ap) +rig_message_cb(enum rig_debug_level_e debug_level, + rig_ptr_t user_data, + const char *fmt, + va_list ap) { - char buf[1024]; + char buf[1024]; - sprintf (buf, "Message(%s) ", (char*)user_data); - syslog (LOG_USER, buf); - vsprintf (buf, fmt, ap); - syslog (LOG_USER, buf); + sprintf (buf, "Message(%s) ", (char*)user_data); + syslog (LOG_USER, buf); + vsprintf (buf, fmt, ap); + syslog (LOG_USER, buf); - return RIG_OK; + return RIG_OK; } - . . . + . . . - char *cookie = "Foo"; - rig_set_debug_callback (rig_message_cb, (rig_ptr_t)cookie); + char *cookie = "Foo"; + rig_set_debug_callback (rig_message_cb, (rig_ptr_t)cookie); \endcode * * \return RIG_OK if the operation has been sucessful, otherwise @@ -208,25 +229,26 @@ rig_message_cb (enum rig_debug_level_e debug_level, */ vprintf_cb_t HAMLIB_API rig_set_debug_callback(vprintf_cb_t cb, rig_ptr_t arg) { - vprintf_cb_t prev_cb = rig_vprintf_cb; + vprintf_cb_t prev_cb = rig_vprintf_cb; - rig_vprintf_cb = cb; - rig_vprintf_arg = arg; + rig_vprintf_cb = cb; + rig_vprintf_arg = arg; - return prev_cb; + return prev_cb; } + /** * \brief change stderr to some different output * \param stream The stream to set output to */ -FILE* HAMLIB_API rig_set_debug_file(FILE *stream) +FILE * HAMLIB_API rig_set_debug_file(FILE *stream) { - FILE *prev_stream = rig_debug_stream; + FILE *prev_stream = rig_debug_stream; - rig_debug_stream = stream; + rig_debug_stream = stream; - return prev_stream; + return prev_stream; } /** @} */ diff --git a/src/event.c b/src/event.c index 5a940055e..a30f18185 100644 --- a/src/event.c +++ b/src/event.c @@ -53,7 +53,6 @@ #include - #include "event.h" #if defined(WIN32) && !defined(HAVE_TERMIOS_H) @@ -78,8 +77,10 @@ static void sa_sigalrmhandler(int signum); #endif #endif + /* This one should be in an include file */ -extern int foreach_opened_rig(int (*cfunc)(RIG *, rig_ptr_t),rig_ptr_t data); +extern int foreach_opened_rig(int (*cfunc)(RIG *, rig_ptr_t), rig_ptr_t data); + /* * add_trn_rig @@ -89,61 +90,80 @@ extern int foreach_opened_rig(int (*cfunc)(RIG *, rig_ptr_t),rig_ptr_t data); int add_trn_rig(RIG *rig) { #ifdef HAVE_SIGACTION - struct sigaction act; - int status; + struct sigaction act; + int status; - /* - * FIXME: multiple open will register several time SIGIO hndlr - */ - memset(&act, 0, sizeof(act)); + /* + * FIXME: multiple open will register several time SIGIO hndlr + */ + memset(&act, 0, sizeof(act)); #ifdef HAVE_SIGINFO_T - act.sa_sigaction = sa_sigioaction; + act.sa_sigaction = sa_sigioaction; #else - act.sa_handler = sa_sigiohandler; + act.sa_handler = sa_sigiohandler; #endif - sigemptyset(&act.sa_mask); + sigemptyset(&act.sa_mask); #if defined(HAVE_SIGINFO_T) && defined(SA_SIGINFO) - act.sa_flags = SA_SIGINFO|SA_RESTART; + act.sa_flags = SA_SIGINFO | SA_RESTART; #else - act.sa_flags = SA_RESTART; + act.sa_flags = SA_RESTART; #endif - status = sigaction(SIGIO, &act, &hamlib_trn_oldact); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: sigaction failed: %s\n", - __func__, strerror(errno)); + status = sigaction(SIGIO, &act, &hamlib_trn_oldact); - status = fcntl(rig->state.rigport.fd, F_SETOWN, getpid()); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: fcntl SETOWN failed: %s\n", - __func__, strerror(errno)); + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: sigaction failed: %s\n", + __func__, + strerror(errno)); + } + + status = fcntl(rig->state.rigport.fd, F_SETOWN, getpid()); + + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: fcntl SETOWN failed: %s\n", + __func__, + strerror(errno)); + } #if defined(HAVE_SIGINFO_T) && defined(O_ASYNC) #ifdef F_SETSIG - status = fcntl(rig->state.rigport.fd, F_SETSIG, SIGIO); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: fcntl SETSIG failed: %s\n", - __func__, strerror(errno)); + status = fcntl(rig->state.rigport.fd, F_SETSIG, SIGIO); + + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: fcntl SETSIG failed: %s\n", + __func__, + strerror(errno)); + } + #endif - status = fcntl(rig->state.rigport.fd, F_SETFL, O_ASYNC); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: fcntl SETASYNC failed: %s\n", - __func__, strerror(errno)); + status = fcntl(rig->state.rigport.fd, F_SETFL, O_ASYNC); + + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: fcntl SETASYNC failed: %s\n", + __func__, + strerror(errno)); + } + #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif - return RIG_OK; + return RIG_OK; #else - return -RIG_ENIMPL; -#endif /* !HAVE_SIGACTION */ + return -RIG_ENIMPL; +#endif /* !HAVE_SIGACTION */ } + /* * remove_trn_rig * not exported in Hamlib API. @@ -152,31 +172,41 @@ int add_trn_rig(RIG *rig) int remove_trn_rig(RIG *rig) { #ifdef HAVE_SIGACTION - int status; + int status; /* assert(rig->caps->transceive == RIG_TRN_RIG); */ #if defined(HAVE_SIGINFO_T) && defined(O_ASYNC) - status = fcntl(rig->state.rigport.fd, F_SETFL, 0); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: fcntl SETASYNC failed: %s\n", - __func__, strerror(errno)); + status = fcntl(rig->state.rigport.fd, F_SETFL, 0); + + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: fcntl SETASYNC failed: %s\n", + __func__, + strerror(errno)); + } + #endif - status = sigaction(SIGIO, &hamlib_trn_oldact, NULL); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s: sigaction failed: %s\n", - __func__, strerror(errno)); + status = sigaction(SIGIO, &hamlib_trn_oldact, NULL); - return RIG_OK; + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: sigaction failed: %s\n", + __func__, + strerror(errno)); + } + + return RIG_OK; #else - return -RIG_ENIMPL; -#endif /* !HAVE_SIGACTION */ + return -RIG_ENIMPL; +#endif /* !HAVE_SIGACTION */ } #ifdef HAVE_SIGACTION + /* * add_trn_poll_rig * not exported in Hamlib API. @@ -184,36 +214,40 @@ int remove_trn_rig(RIG *rig) static int add_trn_poll_rig(RIG *rig) { #ifdef HAVE_SIGACTION - struct sigaction act; - int status; + struct sigaction act; + int status; - /* - * FIXME: multiple open will register several time SIGALRM hndlr - */ - memset(&act, 0, sizeof(act)); + /* + * FIXME: multiple open will register several time SIGALRM hndlr + */ + memset(&act, 0, sizeof(act)); #ifdef HAVE_SIGINFO_T - act.sa_sigaction = sa_sigalrmaction; + act.sa_sigaction = sa_sigalrmaction; #else - act.sa_handler = sa_sigalrmhandler; + act.sa_handler = sa_sigalrmhandler; #endif - act.sa_flags = SA_RESTART; + act.sa_flags = SA_RESTART; - sigemptyset(&act.sa_mask); + sigemptyset(&act.sa_mask); - status = sigaction(SIGALRM, &act, &hamlib_trn_poll_oldact); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s sigaction failed: %s\n", - __func__, - strerror(errno)); + status = sigaction(SIGALRM, &act, &hamlib_trn_poll_oldact); - return RIG_OK; + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s sigaction failed: %s\n", + __func__, + strerror(errno)); + } + + return RIG_OK; #else - return -RIG_ENIMPL; -#endif /* !HAVE_SIGINFO */ + return -RIG_ENIMPL; +#endif /* !HAVE_SIGINFO */ } + /* * remove_trn_poll_rig * not exported in Hamlib API. @@ -221,19 +255,22 @@ static int add_trn_poll_rig(RIG *rig) static int remove_trn_poll_rig(RIG *rig) { #ifdef HAVE_SIGINFO - int status; + int status; - status = sigaction(SIGALRM, &hamlib_trn_poll_oldact, NULL); - if (status < 0) - rig_debug(RIG_DEBUG_ERR,"%s sigaction failed: %s\n", - __func__, - strerror(errno)); + status = sigaction(SIGALRM, &hamlib_trn_poll_oldact, NULL); - return RIG_OK; + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s sigaction failed: %s\n", + __func__, + strerror(errno)); + } + + return RIG_OK; #else - return -RIG_ENIMPL; -#endif /* !HAVE_SIGINFO */ + return -RIG_ENIMPL; +#endif /* !HAVE_SIGINFO */ } @@ -246,54 +283,64 @@ static int remove_trn_poll_rig(RIG *rig) */ static int search_rig_and_decode(RIG *rig, rig_ptr_t data) { - fd_set rfds; - struct timeval tv; - int retval; + fd_set rfds; + struct timeval tv; + int retval; - /* - * so far, only file oriented ports have event reporting support - */ - if (rig->state.rigport.type.rig != RIG_PORT_SERIAL || - rig->state.rigport.fd == -1) - return -1; + /* + * so far, only file oriented ports have event reporting support + */ + if (rig->state.rigport.type.rig != RIG_PORT_SERIAL + || rig->state.rigport.fd == -1) { + return -1; + } - /* FIXME: siginfo is not portable, however use it where available */ + /* FIXME: siginfo is not portable, however use it where available */ #if 0&&defined(HAVE_SIGINFO_T) - siginfo_t *si = (siginfo_t*)data; + siginfo_t *si = (siginfo_t *)data; + + if (rig->state.rigport.fd != si->si_fd) { + return -1; + } - if (rig->state.rigport.fd != si->si_fd) - return -1; #else - FD_ZERO(&rfds); - FD_SET(rig->state.rigport.fd, &rfds); - /* Read status immediately. */ - tv.tv_sec = 0; - tv.tv_usec = 0; + FD_ZERO(&rfds); + FD_SET(rig->state.rigport.fd, &rfds); + /* Read status immediately. */ + tv.tv_sec = 0; + tv.tv_usec = 0; + + /* don't use FIONREAD to detect activity + * since it is less portable than select + * REM: EINTR possible with 0sec timeout? retval==0? + */ + retval = select(rig->state.rigport.fd + 1, &rfds, NULL, NULL, &tv); + + if (retval < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: select: %s\n", + __func__, + strerror(errno)); + return -1; + } - /* don't use FIONREAD to detect activity - * since it is less portable than select - * REM: EINTR possible with 0sec timeout? retval==0? - */ - retval = select(rig->state.rigport.fd+1, &rfds, NULL, NULL, &tv); - if (retval < 0) { - rig_debug(RIG_DEBUG_ERR, "search_rig_and_decode: select: %s\n", - strerror(errno)); - return -1; - } #endif - /* - * Do not disturb, the backend is currently receiving data - */ - if (rig->state.hold_decode) - return -1; + /* + * Do not disturb, the backend is currently receiving data + */ + if (rig->state.hold_decode) { + return -1; + } - if (rig->caps->decode_event) - rig->caps->decode_event(rig); + if (rig->caps->decode_event) { + rig->caps->decode_event(rig); + } - return 1; /* process each opened rig */ + return 1; /* process each opened rig */ } + /* * This is used by sa_sigio, the SIGALRM handler * to poll each RIG in RIG_TRN_POLL mode. @@ -302,60 +349,71 @@ static int search_rig_and_decode(RIG *rig, rig_ptr_t data) */ static int search_rig_and_poll(RIG *rig, rig_ptr_t data) { - struct rig_state *rs = &rig->state; - int retval; + struct rig_state *rs = &rig->state; + int retval; - if (rig->state.transceive != RIG_TRN_POLL) - return -1; - /* - * Do not disturb, the backend is currently receiving data - */ - if (rig->state.hold_decode) - return -1; + if (rig->state.transceive != RIG_TRN_POLL) { + return -1; + } - rig->state.hold_decode = 2; + /* + * Do not disturb, the backend is currently receiving data + */ + if (rig->state.hold_decode) { + return -1; + } - if (rig->caps->get_vfo && rig->callbacks.vfo_event) { - vfo_t vfo = RIG_VFO_CURR; + rig->state.hold_decode = 2; - retval = rig->caps->get_vfo(rig, &vfo); - if (retval == RIG_OK) { - if (vfo != rs->current_vfo) { - rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); - } - rs->current_vfo = vfo; - } - } - if (rig->caps->get_freq && rig->callbacks.freq_event) { - freq_t freq; + if (rig->caps->get_vfo && rig->callbacks.vfo_event) { + vfo_t vfo = RIG_VFO_CURR; - retval = rig->caps->get_freq(rig, RIG_VFO_CURR, &freq); - if (retval == RIG_OK) { - if (freq != rs->current_freq) { - rig->callbacks.freq_event(rig, RIG_VFO_CURR, - freq, rig->callbacks.freq_arg); - } - rs->current_freq = freq; - } - } - if (rig->caps->get_mode && rig->callbacks.mode_event) { - rmode_t rmode; - pbwidth_t width; + retval = rig->caps->get_vfo(rig, &vfo); - retval = rig->caps->get_mode(rig, RIG_VFO_CURR, &rmode, &width); - if (retval == RIG_OK) { - if (rmode != rs->current_mode || width != rs->current_width) { - rig->callbacks.mode_event(rig, RIG_VFO_CURR, - rmode, width, rig->callbacks.mode_arg); - } - rs->current_mode = rmode; - rs->current_width = width; - } - } + if (retval == RIG_OK) { + if (vfo != rs->current_vfo) { + rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); + } - rig->state.hold_decode = 0; + rs->current_vfo = vfo; + } + } - return 1; /* process each opened rig */ + if (rig->caps->get_freq && rig->callbacks.freq_event) { + freq_t freq; + + retval = rig->caps->get_freq(rig, RIG_VFO_CURR, &freq); + + if (retval == RIG_OK) { + if (freq != rs->current_freq) { + rig->callbacks.freq_event(rig, RIG_VFO_CURR, + freq, rig->callbacks.freq_arg); + } + + rs->current_freq = freq; + } + } + + if (rig->caps->get_mode && rig->callbacks.mode_event) { + rmode_t rmode; + pbwidth_t width; + + retval = rig->caps->get_mode(rig, RIG_VFO_CURR, &rmode, &width); + + if (retval == RIG_OK) { + if (rmode != rs->current_mode || width != rs->current_width) { + rig->callbacks.mode_event(rig, RIG_VFO_CURR, + rmode, width, rig->callbacks.mode_arg); + } + + rs->current_mode = rmode; + rs->current_width = width; + } + } + + rig->state.hold_decode = 0; + + return 1; /* process each opened rig */ } @@ -369,18 +427,18 @@ static int search_rig_and_poll(RIG *rig, rig_ptr_t data) #ifdef HAVE_SIGINFO_T static void sa_sigioaction(int signum, siginfo_t *si, rig_ptr_t data) { - rig_debug(RIG_DEBUG_VERBOSE, "sa_sigioaction: activity detected\n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s: activity detected\n", __func__); - foreach_opened_rig(search_rig_and_decode, si); + foreach_opened_rig(search_rig_and_decode, si); } #else static void sa_sigiohandler(int signum) { - rig_debug(RIG_DEBUG_VERBOSE, "sa_sigiohandler: activity detected\n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s: activity detected\n", __func__); - foreach_opened_rig(search_rig_and_decode, NULL); + foreach_opened_rig(search_rig_and_decode, NULL); } #endif @@ -396,31 +454,32 @@ static void sa_sigiohandler(int signum) #ifdef HAVE_SIGINFO_T static void sa_sigalrmaction(int signum, siginfo_t *si, rig_ptr_t data) { - rig_debug(RIG_DEBUG_TRACE, "sa_sigalrmaction entered\n"); + rig_debug(RIG_DEBUG_TRACE, "%s entered\n", __func__); - foreach_opened_rig(search_rig_and_poll, si); + foreach_opened_rig(search_rig_and_poll, si); } #else static void sa_sigalrmhandler(int signum) { - rig_debug(RIG_DEBUG_TRACE, "sa_sigalrmhandler entered\n"); + rig_debug(RIG_DEBUG_TRACE, "%s entered\n", __func__); - foreach_opened_rig(search_rig_and_poll, NULL); + foreach_opened_rig(search_rig_and_poll, NULL); } #endif /* !HAVE_SIGINFO_T */ #endif /* HAVE_SIGINFO */ -#endif /* !DOC_HIDDEN */ +#endif /* !DOC_HIDDEN */ + /** * \brief set the callback for freq events - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for freq events, to be called when in transceive mode. * @@ -430,23 +489,26 @@ static void sa_sigalrmhandler(int signum) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_freq_callback(RIG *rig, freq_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.freq_event = cb; - rig->callbacks.freq_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.freq_event = cb; + rig->callbacks.freq_arg = arg; + + return RIG_OK; } + /** * \brief set the callback for mode events - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for mode events, to be called when in transceive mode. * @@ -456,23 +518,26 @@ int HAMLIB_API rig_set_freq_callback(RIG *rig, freq_cb_t cb, rig_ptr_t arg) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_mode_callback(RIG *rig, mode_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.mode_event = cb; - rig->callbacks.mode_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.mode_event = cb; + rig->callbacks.mode_arg = arg; + + return RIG_OK; } + /** * \brief set the callback for vfo events - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for vfo events, to be called when in transceive mode. * @@ -482,23 +547,26 @@ int HAMLIB_API rig_set_mode_callback(RIG *rig, mode_cb_t cb, rig_ptr_t arg) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_vfo_callback(RIG *rig, vfo_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.vfo_event = cb; - rig->callbacks.vfo_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.vfo_event = cb; + rig->callbacks.vfo_arg = arg; + + return RIG_OK; } + /** * \brief set the callback for ptt events - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for ptt events, to be called when in transceive mode. * @@ -508,23 +576,26 @@ int HAMLIB_API rig_set_vfo_callback(RIG *rig, vfo_cb_t cb, rig_ptr_t arg) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_ptt_callback(RIG *rig, ptt_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.ptt_event = cb; - rig->callbacks.ptt_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.ptt_event = cb; + rig->callbacks.ptt_arg = arg; + + return RIG_OK; } + /** * \brief set the callback for dcd events - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * * Install a callback for dcd events, to be called when in transceive mode. * @@ -534,23 +605,26 @@ int HAMLIB_API rig_set_ptt_callback(RIG *rig, ptt_cb_t cb, rig_ptr_t arg) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_dcd_callback(RIG *rig, dcd_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.dcd_event = cb; - rig->callbacks.dcd_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.dcd_event = cb; + rig->callbacks.dcd_arg = arg; + + return RIG_OK; } + /** * \brief set the callback for pipelined tuning module - * \param rig The rig handle - * \param cb The callback to install - * \param arg A Pointer to some private data to pass later on to the callback + * \param rig The rig handle + * \param cb The callback to install + * \param arg A Pointer to some private data to pass later on to the callback * used to maintain state during pipelined tuning. * * Install a callback for pipelined tuning module, to be called when the @@ -562,22 +636,25 @@ int HAMLIB_API rig_set_dcd_callback(RIG *rig, dcd_cb_t cb, rig_ptr_t arg) * * \sa rig_set_trn() */ - int HAMLIB_API rig_set_pltune_callback(RIG *rig, pltune_cb_t cb, rig_ptr_t arg) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig->callbacks.pltune = cb; - rig->callbacks.pltune_arg = arg; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return RIG_OK; + rig->callbacks.pltune = cb; + rig->callbacks.pltune_arg = arg; + + return RIG_OK; } + /** * \brief control the transceive mode - * \param rig The rig handle - * \param trn The transceive status to set to + * \param rig The rig handle + * \param trn The transceive status to set to * * Enable/disable the transceive handling of a rig and kick off async mode. * @@ -587,111 +664,127 @@ int HAMLIB_API rig_set_pltune_callback(RIG *rig, pltune_cb_t cb, rig_ptr_t arg) * * \sa rig_get_trn() */ - int HAMLIB_API rig_set_trn(RIG *rig, int trn) { - const struct rig_caps *caps; - int retcode = RIG_OK; + const struct rig_caps *caps; + int retcode = RIG_OK; #ifdef HAVE_SETITIMER - struct itimerval value; + struct itimerval value; #endif - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - /* detect whether tranceive is active already */ - if (trn != RIG_TRN_OFF && rig->state.transceive != RIG_TRN_OFF) { - if (trn == rig->state.transceive) { - return RIG_OK; - } else { - /* when going POLL<->RIG, transtition to OFF */ - retcode = rig_set_trn(rig, RIG_TRN_OFF); - if (retcode != RIG_OK) - return retcode; - } - } + caps = rig->caps; - switch (trn) { - case RIG_TRN_RIG: - if (caps->transceive != RIG_TRN_RIG) - return -RIG_ENAVAIL; + /* detect whether tranceive is active already */ + if (trn != RIG_TRN_OFF && rig->state.transceive != RIG_TRN_OFF) { + if (trn == rig->state.transceive) { + return RIG_OK; + } else { + /* when going POLL<->RIG, transtition to OFF */ + retcode = rig_set_trn(rig, RIG_TRN_OFF); - retcode = add_trn_rig(rig); - /* some protocols (e.g. CI-V's) offer no way - * to turn on/off the transceive mode */ - if (retcode == RIG_OK && caps->set_trn) { - retcode = caps->set_trn(rig, RIG_TRN_RIG); - } - break; + if (retcode != RIG_OK) { + return retcode; + } + } + } - case RIG_TRN_POLL: + switch (trn) { + case RIG_TRN_RIG: + if (caps->transceive != RIG_TRN_RIG) { + return -RIG_ENAVAIL; + } + + retcode = add_trn_rig(rig); + + /* some protocols (e.g. CI-V's) offer no way + * to turn on/off the transceive mode */ + if (retcode == RIG_OK && caps->set_trn) { + retcode = caps->set_trn(rig, RIG_TRN_RIG); + } + + break; + + case RIG_TRN_POLL: #ifdef HAVE_SETITIMER - add_trn_poll_rig(rig); + add_trn_poll_rig(rig); + + /* install handler here */ + value.it_value.tv_sec = 0; + value.it_value.tv_usec = rig->state.poll_interval * 1000; + value.it_interval.tv_sec = 0; + value.it_interval.tv_usec = rig->state.poll_interval * 1000; + retcode = setitimer(ITIMER_REAL, &value, NULL); + + if (retcode == -1) { + rig_debug(RIG_DEBUG_ERR, + "%s: setitimer: %s\n", + __func__, + strerror(errno)); + remove_trn_poll_rig(rig); + return -RIG_EINTERNAL; + } - /* install handler here */ - value.it_value.tv_sec = 0; - value.it_value.tv_usec = rig->state.poll_interval*1000; - value.it_interval.tv_sec = 0; - value.it_interval.tv_usec = rig->state.poll_interval*1000; - retcode = setitimer(ITIMER_REAL, &value, NULL); - if (retcode == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: setitimer: %s\n", - __func__, - strerror(errno)); - remove_trn_poll_rig(rig); - return -RIG_EINTERNAL; - } #else - return -RIG_ENAVAIL; + return -RIG_ENAVAIL; #endif - break; + break; - case RIG_TRN_OFF: - if (rig->state.transceive == RIG_TRN_POLL) { + case RIG_TRN_OFF: + if (rig->state.transceive == RIG_TRN_POLL) { #ifdef HAVE_SETITIMER - retcode = remove_trn_poll_rig(rig); + retcode = remove_trn_poll_rig(rig); - value.it_value.tv_sec = 0; - value.it_value.tv_usec = 0; - value.it_interval.tv_sec = 0; - value.it_interval.tv_usec = 0; + value.it_value.tv_sec = 0; + value.it_value.tv_usec = 0; + value.it_interval.tv_sec = 0; + value.it_interval.tv_usec = 0; + + retcode = setitimer(ITIMER_REAL, &value, NULL); + + if (retcode == -1) { + rig_debug(RIG_DEBUG_ERR, "%s: setitimer: %s\n", + __func__, + strerror(errno)); + return -RIG_EINTERNAL; + } - retcode = setitimer(ITIMER_REAL, &value, NULL); - if (retcode == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: setitimer: %s\n", - __func__, - strerror(errno)); - return -RIG_EINTERNAL; - } #else - return -RIG_ENAVAIL; + return -RIG_ENAVAIL; #endif - } else if (rig->state.transceive == RIG_TRN_RIG) { - retcode = remove_trn_rig(rig); - if (caps->set_trn && caps->transceive == RIG_TRN_RIG) { - retcode = caps->set_trn(rig, RIG_TRN_OFF); - } - } - break; + } else if (rig->state.transceive == RIG_TRN_RIG) { + retcode = remove_trn_rig(rig); - default: - return -RIG_EINVAL; - } + if (caps->set_trn && caps->transceive == RIG_TRN_RIG) { + retcode = caps->set_trn(rig, RIG_TRN_OFF); + } + } - if (retcode == RIG_OK) - rig->state.transceive = trn; + break; - return retcode; + default: + return -RIG_EINVAL; + } + + if (retcode == RIG_OK) { + rig->state.transceive = trn; + } + + return retcode; } + /** * \brief get the current transceive mode - * \param rig The rig handle - * \param trn The location where to store the current transceive mode + * \param rig The rig handle + * \param trn The location where to store the current transceive mode * * Retrieves the current status of the transceive mode, i.e. if radio * sends new status automatically when some changes happened on the radio. @@ -704,14 +797,18 @@ int HAMLIB_API rig_set_trn(RIG *rig, int trn) */ int HAMLIB_API rig_get_trn(RIG *rig, int *trn) { - if (CHECK_RIG_ARG(rig) || !trn) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->get_trn != NULL) - return rig->caps->get_trn(rig, trn); + if (CHECK_RIG_ARG(rig) || !trn) { + return -RIG_EINVAL; + } - *trn = rig->state.transceive; - return RIG_OK; + if (rig->caps->get_trn != NULL) { + return rig->caps->get_trn(rig, trn); + } + + *trn = rig->state.transceive; + return RIG_OK; } /** @} */ diff --git a/src/ext.c b/src/ext.c index 2cd844288..6f4ad5ca9 100644 --- a/src/ext.c +++ b/src/ext.c @@ -18,6 +18,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ + /** * \addtogroup rig * @{ @@ -48,7 +49,6 @@ #include "token.h" - /** * \param rig The rig handle * \param cfunc callback function of each extlevel @@ -58,25 +58,37 @@ * A zero value means a normal end of iteration, and a negative value an abnormal end, * which will be the return value of rig_ext_level_foreach. */ -int HAMLIB_API rig_ext_level_foreach(RIG *rig, int (*cfunc)(RIG *, const struct confparams *, rig_ptr_t), rig_ptr_t data) +int HAMLIB_API rig_ext_level_foreach(RIG *rig, + int (*cfunc)(RIG *, + const struct confparams *, + rig_ptr_t), + rig_ptr_t data) { - const struct confparams *cfp; - int ret; + const struct confparams *cfp; + int ret; - if (!rig || !rig->caps || !cfunc) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = rig->caps->extlevels; cfp && cfp->name; cfp++) { - ret = (*cfunc)(rig, cfp, data); - if (ret == 0) - return RIG_OK; - if (ret < 0) - return ret; - } + if (!rig || !rig->caps || !cfunc) { + return -RIG_EINVAL; + } - return RIG_OK; + for (cfp = rig->caps->extlevels; cfp && cfp->name; cfp++) { + ret = (*cfunc)(rig, cfp, data); + + if (ret == 0) { + return RIG_OK; + } + + if (ret < 0) { + return ret; + } + } + + return RIG_OK; } + /** * \param rig The rig handle * \param cfunc callback function of each extparm @@ -86,25 +98,37 @@ int HAMLIB_API rig_ext_level_foreach(RIG *rig, int (*cfunc)(RIG *, const struct * A zero value means a normal end of iteration, and a negative value an abnormal end, * which will be the return value of rig_ext_parm_foreach. */ -int HAMLIB_API rig_ext_parm_foreach(RIG *rig, int (*cfunc)(RIG *, const struct confparams *, rig_ptr_t), rig_ptr_t data) +int HAMLIB_API rig_ext_parm_foreach(RIG *rig, + int (*cfunc)(RIG *, + const struct confparams *, + rig_ptr_t), + rig_ptr_t data) { - const struct confparams *cfp; - int ret; + const struct confparams *cfp; + int ret; - if (!rig || !rig->caps || !cfunc) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = rig->caps->extparms; cfp && cfp->name; cfp++) { - ret = (*cfunc)(rig, cfp, data); - if (ret == 0) - return RIG_OK; - if (ret < 0) - return ret; - } + if (!rig || !rig->caps || !cfunc) { + return -RIG_EINVAL; + } - return RIG_OK; + for (cfp = rig->caps->extparms; cfp && cfp->name; cfp++) { + ret = (*cfunc)(rig, cfp, data); + + if (ret == 0) { + return RIG_OK; + } + + if (ret < 0) { + return ret; + } + } + + return RIG_OK; } + /** * \param rig * \param name @@ -118,20 +142,28 @@ int HAMLIB_API rig_ext_parm_foreach(RIG *rig, int (*cfunc)(RIG *, const struct c */ const struct confparams * HAMLIB_API rig_ext_lookup(RIG *rig, const char *name) { - const struct confparams *cfp; + const struct confparams *cfp; - if (!rig || !rig->caps) - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = rig->caps->extlevels; cfp && cfp->name; cfp++) - if (!strcmp(cfp->name, name)) - return cfp; - for (cfp = rig->caps->extparms; cfp && cfp->name; cfp++) - if (!strcmp(cfp->name, name)) - return cfp; - return NULL; + if (!rig || !rig->caps) { + return NULL; + } + + for (cfp = rig->caps->extlevels; cfp && cfp->name; cfp++) + if (!strcmp(cfp->name, name)) { + return cfp; + } + + for (cfp = rig->caps->extparms; cfp && cfp->name; cfp++) + if (!strcmp(cfp->name, name)) { + return cfp; + } + + return NULL; } + /** * \param rig * \param token @@ -143,20 +175,28 @@ const struct confparams * HAMLIB_API rig_ext_lookup(RIG *rig, const char *name) */ const struct confparams * HAMLIB_API rig_ext_lookup_tok(RIG *rig, token_t token) { - const struct confparams *cfp; + const struct confparams *cfp; - if (!rig || !rig->caps) - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = rig->caps->extlevels; cfp && cfp->token; cfp++) - if (cfp->token == token) - return cfp; - for (cfp = rig->caps->extparms; cfp && cfp->token; cfp++) - if (cfp->token == token) - return cfp; - return NULL; + if (!rig || !rig->caps) { + return NULL; + } + + for (cfp = rig->caps->extlevels; cfp && cfp->token; cfp++) + if (cfp->token == token) { + return cfp; + } + + for (cfp = rig->caps->extparms; cfp && cfp->token; cfp++) + if (cfp->token == token) { + return cfp; + } + + return NULL; } + /** * \param rig * \param name @@ -164,13 +204,17 @@ const struct confparams * HAMLIB_API rig_ext_lookup_tok(RIG *rig, token_t token) */ token_t HAMLIB_API rig_ext_token_lookup(RIG *rig, const char *name) { - const struct confparams *cfp; + const struct confparams *cfp; - cfp = rig_ext_lookup(rig, name); - if (!cfp) - return RIG_CONF_END; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return cfp->token; + cfp = rig_ext_lookup(rig, name); + + if (!cfp) { + return RIG_CONF_END; + } + + return cfp->token; } /** @} */ diff --git a/src/gpio.c b/src/gpio.c index d787ab5fb..cccec6dd4 100644 --- a/src/gpio.c +++ b/src/gpio.c @@ -19,8 +19,6 @@ * */ -#include "gpio.h" - #include #include #include @@ -28,74 +26,101 @@ #include #include +#include "gpio.h" + int gpio_open(hamlib_port_t *port, int on_value) { - char pathname[FILPATHLEN]; - FILE *fexp, *fdir; - int fd; + char pathname[FILPATHLEN]; + FILE *fexp, *fdir; + int fd; - port->parm.gpio.on_value = on_value; - - snprintf(pathname, FILPATHLEN, "/sys/class/gpio/export"); - fexp = fopen(pathname, "w"); - if (!fexp) { - rig_debug(RIG_DEBUG_ERR, "Export GPIO%s (using %s): %s\n", - port->pathname, pathname, strerror(errno)); - return -RIG_EIO; - } - fprintf(fexp, "%s\n", port->pathname); - fclose(fexp); + port->parm.gpio.on_value = on_value; - snprintf(pathname, FILPATHLEN, "/sys/class/gpio/gpio%s/direction", port->pathname); - fdir = fopen(pathname, "w"); - if (!fdir) { - rig_debug(RIG_DEBUG_ERR, "GPIO%s direction (using %s): %s\n", - port->pathname, pathname, strerror(errno)); - return -RIG_EIO; - } - fprintf(fdir, "out\n"); - fclose(fdir); + snprintf(pathname, FILPATHLEN, "/sys/class/gpio/export"); + fexp = fopen(pathname, "w"); - snprintf(pathname, FILPATHLEN, "/sys/class/gpio/gpio%s/value", port->pathname); - fd = open(pathname, O_WRONLY); - if (fd < 0) { - rig_debug(RIG_DEBUG_ERR, "GPIO%s opening value file %s: %s\n", - port->pathname, pathname, strerror(errno)); - return -RIG_EIO; - } + if (!fexp) { + rig_debug(RIG_DEBUG_ERR, + "Export GPIO%s (using %s): %s\n", + port->pathname, + pathname, + strerror(errno)); + return -RIG_EIO; + } - port->fd = fd; - return fd; + fprintf(fexp, "%s\n", port->pathname); + fclose(fexp); + + snprintf(pathname, + FILPATHLEN, + "/sys/class/gpio/gpio%s/direction", + port->pathname); + fdir = fopen(pathname, "w"); + + if (!fdir) { + rig_debug(RIG_DEBUG_ERR, + "GPIO%s direction (using %s): %s\n", + port->pathname, + pathname, + strerror(errno)); + return -RIG_EIO; + } + + fprintf(fdir, "out\n"); + fclose(fdir); + + snprintf(pathname, + FILPATHLEN, + "/sys/class/gpio/gpio%s/value", + port->pathname); + fd = open(pathname, O_WRONLY); + + if (fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "GPIO%s opening value file %s: %s\n", + port->pathname, + pathname, + strerror(errno)); + return -RIG_EIO; + } + + port->fd = fd; + return fd; } + int gpio_close(hamlib_port_t *port) { - return close(port->fd); + return close(port->fd); } + int gpio_ptt_set(hamlib_port_t *port, ptt_t pttx) { - char *val; - port->parm.gpio.value = pttx != RIG_PTT_OFF; + char *val; + port->parm.gpio.value = pttx != RIG_PTT_OFF; - if ((port->parm.gpio.value && port->parm.gpio.on_value) || - (!port->parm.gpio.value && !port->parm.gpio.on_value)) { - val = "1\n"; - } else { - val = "0\n"; - } - - if (write(port->fd, val, strlen(val)) <= 0) - return -RIG_EIO; - return RIG_OK; + if ((port->parm.gpio.value && port->parm.gpio.on_value) + || (!port->parm.gpio.value && !port->parm.gpio.on_value)) { + val = "1\n"; + } else { + val = "0\n"; + } + + if (write(port->fd, val, strlen(val)) <= 0) { + return -RIG_EIO; + } + + return RIG_OK; } + int gpio_ptt_get(hamlib_port_t *port, ptt_t *pttx) { - if (port->parm.gpio.value) - return RIG_PTT_ON; - else - return RIG_PTT_OFF; + if (port->parm.gpio.value) { + return RIG_PTT_ON; + } else { + return RIG_PTT_OFF; + } } - diff --git a/src/idx_builtin.h b/src/idx_builtin.h index bb098d9ef..826f7d79d 100644 --- a/src/idx_builtin.h +++ b/src/idx_builtin.h @@ -31,86 +31,86 @@ * everything at compile time. * * struct rig_caps foo = { - * .level_gran = { [LVL_PREAMP] = { .min = 0, .max = 20, .step = 10 } }, + * .level_gran = { [LVL_PREAMP] = { .min = 0, .max = 20, .step = 10 } }, * } * * Of course, it can't work with setting2idx_builtin(RIG_LEVEL_XX|RIG_LEVEL_YY) */ -#define setting2idx_builtin(s) ((s)==(1<<0)?0: \ - (s)==(1<<1)?1: \ - (s)==(1<<2)?2: \ - (s)==(1<<3)?3: \ - (s)==(1<<4)?4: \ - (s)==(1<<5)?5: \ - (s)==(1<<6)?6: \ - (s)==(1<<7)?7: \ - (s)==(1<<8)?8: \ - (s)==(1<<9)?9: \ - (s)==(1<<10)?10: \ - (s)==(1<<11)?11: \ - (s)==(1<<12)?12: \ - (s)==(1<<13)?13: \ - (s)==(1<<14)?14: \ - (s)==(1<<15)?15: \ - (s)==(1<<16)?16: \ - (s)==(1<<17)?17: \ - (s)==(1<<18)?18: \ - (s)==(1<<19)?19: \ - (s)==(1<<20)?20: \ - (s)==(1<<21)?21: \ - (s)==(1<<22)?22: \ - (s)==(1<<23)?23: \ - (s)==(1<<24)?24: \ - (s)==(1<<25)?25: \ - (s)==(1<<26)?26: \ - (s)==(1<<27)?27: \ - (s)==(1<<28)?28: \ - (s)==(1<<29)?29: \ - (s)==(1<<30)?30: \ - (s)==(1<<31)?31: \ - 0 \ - ) +#define setting2idx_builtin(s) ((s)==(1<<0)?0: \ + (s)==(1<<1)?1: \ + (s)==(1<<2)?2: \ + (s)==(1<<3)?3: \ + (s)==(1<<4)?4: \ + (s)==(1<<5)?5: \ + (s)==(1<<6)?6: \ + (s)==(1<<7)?7: \ + (s)==(1<<8)?8: \ + (s)==(1<<9)?9: \ + (s)==(1<<10)?10: \ + (s)==(1<<11)?11: \ + (s)==(1<<12)?12: \ + (s)==(1<<13)?13: \ + (s)==(1<<14)?14: \ + (s)==(1<<15)?15: \ + (s)==(1<<16)?16: \ + (s)==(1<<17)?17: \ + (s)==(1<<18)?18: \ + (s)==(1<<19)?19: \ + (s)==(1<<20)?20: \ + (s)==(1<<21)?21: \ + (s)==(1<<22)?22: \ + (s)==(1<<23)?23: \ + (s)==(1<<24)?24: \ + (s)==(1<<25)?25: \ + (s)==(1<<26)?26: \ + (s)==(1<<27)?27: \ + (s)==(1<<28)?28: \ + (s)==(1<<29)?29: \ + (s)==(1<<30)?30: \ + (s)==(1<<31)?31: \ + 0 \ + ) -#define LVL_PREAMP setting2idx_builtin(RIG_LEVEL_PREAMP) -#define LVL_ATT setting2idx_builtin(RIG_LEVEL_ATT) -#define LVL_VOX setting2idx_builtin(RIG_LEVEL_VOX) -#define LVL_AF setting2idx_builtin(RIG_LEVEL_AF) -#define LVL_RF setting2idx_builtin(RIG_LEVEL_RF) -#define LVL_SQL setting2idx_builtin(RIG_LEVEL_SQL) -#define LVL_IF setting2idx_builtin(RIG_LEVEL_IF) -#define LVL_APF setting2idx_builtin(RIG_LEVEL_APF) -#define LVL_NR setting2idx_builtin(RIG_LEVEL_NR) -#define LVL_PBT_IN setting2idx_builtin(RIG_LEVEL_PBT_IN) -#define LVL_PBT_OUT setting2idx_builtin(RIG_LEVEL_PBT_OUT) -#define LVL_CWPITCH setting2idx_builtin(RIG_LEVEL_CWPITCH) -#define LVL_RFPOWER setting2idx_builtin(RIG_LEVEL_RFPOWER) -#define LVL_MICGAIN setting2idx_builtin(RIG_LEVEL_MICGAIN) -#define LVL_KEYSPD setting2idx_builtin(RIG_LEVEL_KEYSPD) -#define LVL_NOTCHF setting2idx_builtin(RIG_LEVEL_NOTCHF) -#define LVL_COMP setting2idx_builtin(RIG_LEVEL_COMP) -#define LVL_AGC setting2idx_builtin(RIG_LEVEL_AGC) -#define LVL_BKINDL setting2idx_builtin(RIG_LEVEL_BKINDL) -#define LVL_BALANCE setting2idx_builtin(RIG_LEVEL_BALANCE) -#define LVL_METER setting2idx_builtin(RIG_LEVEL_METER) -#define LVL_VOXGAIN setting2idx_builtin(RIG_LEVEL_VOXGAIN) -#define LVL_VOXDELAY setting2idx_builtin(RIG_LEVEL_VOXDELAY) -#define LVL_ANTIVOX setting2idx_builtin(RIG_LEVEL_ANTIVOX) +#define LVL_PREAMP setting2idx_builtin(RIG_LEVEL_PREAMP) +#define LVL_ATT setting2idx_builtin(RIG_LEVEL_ATT) +#define LVL_VOX setting2idx_builtin(RIG_LEVEL_VOX) +#define LVL_AF setting2idx_builtin(RIG_LEVEL_AF) +#define LVL_RF setting2idx_builtin(RIG_LEVEL_RF) +#define LVL_SQL setting2idx_builtin(RIG_LEVEL_SQL) +#define LVL_IF setting2idx_builtin(RIG_LEVEL_IF) +#define LVL_APF setting2idx_builtin(RIG_LEVEL_APF) +#define LVL_NR setting2idx_builtin(RIG_LEVEL_NR) +#define LVL_PBT_IN setting2idx_builtin(RIG_LEVEL_PBT_IN) +#define LVL_PBT_OUT setting2idx_builtin(RIG_LEVEL_PBT_OUT) +#define LVL_CWPITCH setting2idx_builtin(RIG_LEVEL_CWPITCH) +#define LVL_RFPOWER setting2idx_builtin(RIG_LEVEL_RFPOWER) +#define LVL_MICGAIN setting2idx_builtin(RIG_LEVEL_MICGAIN) +#define LVL_KEYSPD setting2idx_builtin(RIG_LEVEL_KEYSPD) +#define LVL_NOTCHF setting2idx_builtin(RIG_LEVEL_NOTCHF) +#define LVL_COMP setting2idx_builtin(RIG_LEVEL_COMP) +#define LVL_AGC setting2idx_builtin(RIG_LEVEL_AGC) +#define LVL_BKINDL setting2idx_builtin(RIG_LEVEL_BKINDL) +#define LVL_BALANCE setting2idx_builtin(RIG_LEVEL_BALANCE) +#define LVL_METER setting2idx_builtin(RIG_LEVEL_METER) +#define LVL_VOXGAIN setting2idx_builtin(RIG_LEVEL_VOXGAIN) +#define LVL_VOXDELAY setting2idx_builtin(RIG_LEVEL_VOXDELAY) +#define LVL_ANTIVOX setting2idx_builtin(RIG_LEVEL_ANTIVOX) -#define LVL_RAWSTR setting2idx_builtin(RIG_LEVEL_RAWSTR) -#define LVL_SQLSTAT setting2idx_builtin(RIG_LEVEL_SQLSTAT) -#define LVL_SWR setting2idx_builtin(RIG_LEVEL_SWR) -#define LVL_ALC setting2idx_builtin(RIG_LEVEL_ALC) -#define LVL_STRENGTH setting2idx_builtin(RIG_LEVEL_STRENGTH) -/*#define LVL_BWC setting2idx_builtin(RIG_LEVEL_BWC)*/ +#define LVL_RAWSTR setting2idx_builtin(RIG_LEVEL_RAWSTR) +#define LVL_SQLSTAT setting2idx_builtin(RIG_LEVEL_SQLSTAT) +#define LVL_SWR setting2idx_builtin(RIG_LEVEL_SWR) +#define LVL_ALC setting2idx_builtin(RIG_LEVEL_ALC) +#define LVL_STRENGTH setting2idx_builtin(RIG_LEVEL_STRENGTH) +/*#define LVL_BWC setting2idx_builtin(RIG_LEVEL_BWC)*/ -#define PARM_ANN setting2idx_builtin(RIG_PARM_ANN) -#define PARM_APO setting2idx_builtin(RIG_PARM_APO) -#define PARM_BACKLIGHT setting2idx_builtin(RIG_PARM_BACKLIGHT) -#define PARM_BEEP setting2idx_builtin(RIG_PARM_BEEP) -#define PARM_TIME setting2idx_builtin(RIG_PARM_TIME) -#define PARM_BAT setting2idx_builtin(RIG_PARM_BAT) -#define PARM_KEYLIGHT setting2idx_builtin(RIG_PARM_KEYLIGHT) +#define PARM_ANN setting2idx_builtin(RIG_PARM_ANN) +#define PARM_APO setting2idx_builtin(RIG_PARM_APO) +#define PARM_BACKLIGHT setting2idx_builtin(RIG_PARM_BACKLIGHT) +#define PARM_BEEP setting2idx_builtin(RIG_PARM_BEEP) +#define PARM_TIME setting2idx_builtin(RIG_PARM_TIME) +#define PARM_BAT setting2idx_builtin(RIG_PARM_BAT) +#define PARM_KEYLIGHT setting2idx_builtin(RIG_PARM_KEYLIGHT) -#endif /* _IDX_BUILTIN_H */ +#endif /* _IDX_BUILTIN_H */ diff --git a/src/iofunc.c b/src/iofunc.c index 2396bf523..7a5a689af 100644 --- a/src/iofunc.c +++ b/src/iofunc.c @@ -44,7 +44,7 @@ #include #include -#include "hamlib/rig.h" +#include #include "iofunc.h" #include "misc.h" @@ -61,84 +61,112 @@ */ int HAMLIB_API port_open(hamlib_port_t *p) { - int status; - int want_state_delay = 0; + int status; + int want_state_delay = 0; - p->fd = -1; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - switch(p->type.rig) { - case RIG_PORT_SERIAL: - status = serial_open(p); - if (status < 0) - return status; - if (p->parm.serial.rts_state != RIG_SIGNAL_UNSET && - p->parm.serial.handshake != RIG_HANDSHAKE_HARDWARE) { - status = ser_set_rts(p, - p->parm.serial.rts_state == RIG_SIGNAL_ON); - want_state_delay = 1; - } - if (status != 0) - return status; - if (p->parm.serial.dtr_state != RIG_SIGNAL_UNSET) { - status = ser_set_dtr(p, - p->parm.serial.dtr_state == RIG_SIGNAL_ON); - want_state_delay = 1; - } - if (status != 0) - return status; - /* - * Wait whatever electrolytics in the circuit come up to voltage. - * Is 100ms enough? Too much? - */ - if (want_state_delay) - usleep(100*1000); + p->fd = -1; - break; + switch (p->type.rig) { + case RIG_PORT_SERIAL: + status = serial_open(p); - case RIG_PORT_PARALLEL: - status = par_open(p); - if (status < 0) - return status; - break; + if (status < 0) { + return status; + } - case RIG_PORT_CM108: - status = cm108_open(p); - if (status < 0) - return status; - break; + if (p->parm.serial.rts_state != RIG_SIGNAL_UNSET + && p->parm.serial.handshake != RIG_HANDSHAKE_HARDWARE) { + status = ser_set_rts(p, + p->parm.serial.rts_state == RIG_SIGNAL_ON); + want_state_delay = 1; + } - case RIG_PORT_DEVICE: - status = open(p->pathname, O_RDWR, 0); - if (status < 0) - return -RIG_EIO; - p->fd = status; - break; + if (status != 0) { + return status; + } - case RIG_PORT_USB: - status = usb_port_open(p); - if (status < 0) - return status; - break; + if (p->parm.serial.dtr_state != RIG_SIGNAL_UNSET) { + status = ser_set_dtr(p, + p->parm.serial.dtr_state == RIG_SIGNAL_ON); + want_state_delay = 1; + } - case RIG_PORT_NONE: - case RIG_PORT_RPC: - break; /* ez :) */ + if (status != 0) { + return status; + } - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: + /* + * Wait whatever electrolytics in the circuit come up to voltage. + * Is 100ms enough? Too much? + */ + if (want_state_delay) { + usleep(100 * 1000); + } + + break; + + case RIG_PORT_PARALLEL: + status = par_open(p); + + if (status < 0) { + return status; + } + + break; + + case RIG_PORT_CM108: + status = cm108_open(p); + + if (status < 0) { + return status; + } + + break; + + case RIG_PORT_DEVICE: + status = open(p->pathname, O_RDWR, 0); + + if (status < 0) { + return -RIG_EIO; + } + + p->fd = status; + break; + + case RIG_PORT_USB: + status = usb_port_open(p); + + if (status < 0) { + return status; + } + + break; + + case RIG_PORT_NONE: + case RIG_PORT_RPC: + break; /* ez :) */ + + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: /* FIXME: hardcoded network port */ - status = network_open(p, 4532); - if (status < 0) - return status; - break; + status = network_open(p, 4532); - default: - return -RIG_EINVAL; - } + if (status < 0) { + return status; + } - return RIG_OK; + break; + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief Close a hamlib_port * \param p rig port descriptor @@ -151,93 +179,119 @@ int HAMLIB_API port_close(hamlib_port_t *p, rig_port_t port_type) { int ret = RIG_OK; - if (p->fd != -1) { - switch (port_type) { - case RIG_PORT_SERIAL: - ret = ser_close(p); - break; - case RIG_PORT_PARALLEL: - ret = par_close(p); - break; - case RIG_PORT_CM108: - ret = cm108_close(p); - break; - case RIG_PORT_USB: - ret = usb_port_close(p); - break; - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: - ret = network_close(p); - break; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - default: - rig_debug(RIG_DEBUG_ERR, "%s(): Unknown port type %d\n", - __func__, port_type); - /* fall through */ - case RIG_PORT_DEVICE: - ret = close(p->fd); - } - p->fd = -1; - } + if (p->fd != -1) { + switch (port_type) { + case RIG_PORT_SERIAL: + ret = ser_close(p); + break; - return ret; + case RIG_PORT_PARALLEL: + ret = par_close(p); + break; + + case RIG_PORT_CM108: + ret = cm108_close(p); + break; + + case RIG_PORT_USB: + ret = usb_port_close(p); + break; + + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: + ret = network_close(p); + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s(): Unknown port type %d\n", + __func__, port_type); + + /* fall through */ + case RIG_PORT_DEVICE: + ret = close(p->fd); + } + + p->fd = -1; + } + + return ret; } + #if defined(WIN32) && !defined(HAVE_TERMIOS_H) #include "win32termios.h" + /* On MinGW32/MSVC/.. the appropriate accessor must be used * depending on the port type, sigh. */ static ssize_t port_read(hamlib_port_t *p, void *buf, size_t count) { - int i; - ssize_t ret; + int i; + ssize_t ret; - if (p->type.rig == RIG_PORT_SERIAL) { - ret = win32_serial_read(p->fd, buf, count); - if (p->parm.serial.data_bits == 7) { - unsigned char *pbuf = buf; - /* clear MSB */ - for (i=0; itype.rig == RIG_PORT_SERIAL) { + ret = win32_serial_read(p->fd, buf, count); + + if (p->parm.serial.data_bits == 7) { + unsigned char *pbuf = buf; + + /* clear MSB */ + for (i = 0; i < ret; i++) { + pbuf[i] &= ~0x80; + } } + + return ret; + } else if (p->type.rig == RIG_PORT_NETWORK + || p->type.rig == RIG_PORT_UDP_NETWORK) { + return recv(p->fd, buf, count, 0); + } else { + return read(p->fd, buf, count); } - return ret; - } else if (p->type.rig == RIG_PORT_NETWORK || p->type.rig == RIG_PORT_UDP_NETWORK) - return recv(p->fd, buf, count, 0); - else - return read(p->fd, buf, count); } static ssize_t port_write(hamlib_port_t *p, const void *buf, size_t count) { - if (p->type.rig == RIG_PORT_SERIAL) - return win32_serial_write(p->fd, buf, count); - else if (p->type.rig == RIG_PORT_NETWORK || p->type.rig == RIG_PORT_UDP_NETWORK) - return send(p->fd, buf, count, 0); - else - return write(p->fd, buf, count); + if (p->type.rig == RIG_PORT_SERIAL) { + return win32_serial_write(p->fd, buf, count); + } else if (p->type.rig == RIG_PORT_NETWORK + || p->type.rig == RIG_PORT_UDP_NETWORK) { + return send(p->fd, buf, count, 0); + } else { + return write(p->fd, buf, count); + } } -static int port_select(hamlib_port_t *p, int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) + +static int port_select(hamlib_port_t *p, int n, fd_set *readfds, + fd_set *writefds, fd_set *exceptfds, + struct timeval *timeout) { #if 1 - /* select does not work very well with writefds/exceptfds - * So let's pretend there's none of them - */ - if (exceptfds) - FD_ZERO(exceptfds); - if (writefds) - FD_ZERO(writefds); - writefds = NULL; - exceptfds = NULL; + + /* select does not work very well with writefds/exceptfds + * So let's pretend there's none of them + */ + if (exceptfds) { + FD_ZERO(exceptfds); + } + + if (writefds) { + FD_ZERO(writefds); + } + + writefds = NULL; + exceptfds = NULL; #endif - if (p->type.rig == RIG_PORT_SERIAL) - return win32_serial_select(n, readfds, writefds, exceptfds, timeout); - else - return select(n, readfds, writefds, exceptfds, timeout); + if (p->type.rig == RIG_PORT_SERIAL) { + return win32_serial_select(n, readfds, writefds, exceptfds, timeout); + } else { + return select(n, readfds, writefds, exceptfds, timeout); + } } @@ -247,21 +301,23 @@ static int port_select(hamlib_port_t *p, int n, fd_set *readfds, fd_set *writefd static ssize_t port_read(hamlib_port_t *p, void *buf, size_t count) { - int i; - ssize_t ret; + int i; + ssize_t ret; - if (p->type.rig == RIG_PORT_SERIAL && p->parm.serial.data_bits == 7) { - unsigned char *pbuf = buf; + if (p->type.rig == RIG_PORT_SERIAL && p->parm.serial.data_bits == 7) { + unsigned char *pbuf = buf; - ret = read(p->fd, buf, count); - /* clear MSB */ - for (i=0; ifd, buf, count); + + /* clear MSB */ + for (i = 0; i < ret; i++) { + pbuf[i] &= ~0x80; + } + + return ret; + } else { + return read(p->fd, buf, count); } - return ret; - } else { - return read(p->fd, buf, count); - } } #define port_write(p,b,c) write((p)->fd,(b),(c)) @@ -300,67 +356,77 @@ static ssize_t port_read(hamlib_port_t *p, void *buf, size_t count) int HAMLIB_API write_block(hamlib_port_t *p, const char *txbuffer, size_t count) { - int i, ret; + int i, ret; + + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); #ifdef WANT_NON_ACTIVE_POST_WRITE_DELAY - if (p->post_write_date.tv_sec != 0) { - signed int date_delay; /* in us */ - struct timeval tv; - /* FIXME in Y2038 ... */ - gettimeofday(&tv, NULL); - date_delay = p->post_write_delay*1000 - - ((tv.tv_sec - p->post_write_date.tv_sec)*1000000 + - (tv.tv_usec - p->post_write_date.tv_usec)); - if (date_delay > 0) { - /* - * optional delay after last write - */ - usleep(date_delay); - } - p->post_write_date.tv_sec = 0; - } + if (p->post_write_date.tv_sec != 0) { + signed int date_delay; /* in us */ + struct timeval tv; + + /* FIXME in Y2038 ... */ + gettimeofday(&tv, NULL); + date_delay = p->post_write_delay * 1000 - + ((tv.tv_sec - p->post_write_date.tv_sec) * 1000000 + + (tv.tv_usec - p->post_write_date.tv_usec)); + + if (date_delay > 0) { + /* + * optional delay after last write + */ + usleep(date_delay); + } + + p->post_write_date.tv_sec = 0; + } + #endif - if (p->write_delay > 0) { - for (i=0; i < count; i++) { - ret = port_write(p, txbuffer+i, 1); - if (ret != 1) { - rig_debug(RIG_DEBUG_ERR,"%s():%d failed %d - %s\n", - __func__, __LINE__, ret, strerror(errno)); - return -RIG_EIO; - } - usleep(p->write_delay*1000); - } - } else { - ret = port_write(p, txbuffer, count); - if (ret != count) { - rig_debug(RIG_DEBUG_ERR,"%s():%d failed %d - %s\n", - __func__, __LINE__, ret, strerror(errno)); - return -RIG_EIO; - } - } + if (p->write_delay > 0) { + for (i = 0; i < count; i++) { + ret = port_write(p, txbuffer + i, 1); - if (p->post_write_delay > 0) { + if (ret != 1) { + rig_debug(RIG_DEBUG_ERR, "%s():%d failed %d - %s\n", + __func__, __LINE__, ret, strerror(errno)); + return -RIG_EIO; + } + + usleep(p->write_delay * 1000); + } + } else { + ret = port_write(p, txbuffer, count); + + if (ret != count) { + rig_debug(RIG_DEBUG_ERR, "%s():%d failed %d - %s\n", + __func__, __LINE__, ret, strerror(errno)); + return -RIG_EIO; + } + } + + if (p->post_write_delay > 0) { #ifdef WANT_NON_ACTIVE_POST_WRITE_DELAY #define POST_WRITE_DELAY_TRSHLD 10 - if (p->post_write_delay > POST_WRITE_DELAY_TRSHLD) { - struct timeval tv; - gettimeofday(&tv, NULL); - p->post_write_date.tv_sec = tv.tv_sec; - p->post_write_date.tv_usec = tv.tv_usec; - } - else + if (p->post_write_delay > POST_WRITE_DELAY_TRSHLD) { + struct timeval tv; + gettimeofday(&tv, NULL); + p->post_write_date.tv_sec = tv.tv_sec; + p->post_write_date.tv_usec = tv.tv_usec; + } else #endif - usleep(p->post_write_delay*1000); /* optional delay after last write */ - /* otherwise some yaesu rigs get confused */ - /* with sequential fast writes*/ - } - rig_debug(RIG_DEBUG_TRACE,"%s(): TX %d bytes\n", __func__, count); - dump_hex((unsigned char *) txbuffer,count); + usleep(p->post_write_delay * 1000); /* optional delay after last write */ - return RIG_OK; + /* otherwise some yaesu rigs get confused */ + /* with sequential fast writes*/ + } + + rig_debug(RIG_DEBUG_TRACE, "%s(): TX %d bytes\n", __func__, count); + dump_hex((unsigned char *) txbuffer, count); + + return RIG_OK; } @@ -384,73 +450,90 @@ int HAMLIB_API write_block(hamlib_port_t *p, const char *txbuffer, size_t count) int HAMLIB_API read_block(hamlib_port_t *p, char *rxbuffer, size_t count) { - fd_set rfds, efds; - struct timeval tv, tv_timeout, start_time, end_time, elapsed_time; - int rd_count, total_count = 0; - int retval; + fd_set rfds, efds; + struct timeval tv, tv_timeout, start_time, end_time, elapsed_time; + int rd_count, total_count = 0; + int retval; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* - * Wait up to timeout ms. - */ - tv_timeout.tv_sec = p->timeout/1000; - tv_timeout.tv_usec = (p->timeout%1000)*1000; + /* + * Wait up to timeout ms. + */ + tv_timeout.tv_sec = p->timeout / 1000; + tv_timeout.tv_usec = (p->timeout % 1000) * 1000; - /* Store the time of the read loop start */ - gettimeofday(&start_time, NULL); + /* Store the time of the read loop start */ + gettimeofday(&start_time, NULL); - while (count > 0) { - tv = tv_timeout; /* select may have updated it */ + while (count > 0) { + tv = tv_timeout; /* select may have updated it */ - FD_ZERO(&rfds); - FD_SET(p->fd, &rfds); - efds = rfds; + FD_ZERO(&rfds); + FD_SET(p->fd, &rfds); + efds = rfds; - retval = port_select(p, p->fd+1, &rfds, NULL, &efds, &tv); - if (retval == 0) { - /* Record timeout time and caculate elapsed time */ - gettimeofday(&end_time, NULL); - timersub(&end_time, &start_time, &elapsed_time); + retval = port_select(p, p->fd + 1, &rfds, NULL, &efds, &tv); - dump_hex((unsigned char *) rxbuffer, total_count); - rig_debug(RIG_DEBUG_WARN, "%s(): Timed out %d.%d seconds after %d chars\n", - __func__, elapsed_time.tv_sec, elapsed_time.tv_usec, total_count); + if (retval == 0) { + /* Record timeout time and caculate elapsed time */ + gettimeofday(&end_time, NULL); + timersub(&end_time, &start_time, &elapsed_time); - return -RIG_ETIMEOUT; - } - if (retval < 0) { - dump_hex((unsigned char *) rxbuffer, total_count); - rig_debug(RIG_DEBUG_ERR,"%s(): select() error after %d chars: %s\n", - __func__, total_count, strerror(errno)); + dump_hex((unsigned char *) rxbuffer, total_count); + rig_debug(RIG_DEBUG_WARN, + "%s(): Timed out %d.%d seconds after %d chars\n", + __func__, + elapsed_time.tv_sec, + elapsed_time.tv_usec, + total_count); - return -RIG_EIO; - } - if (FD_ISSET(p->fd, &efds)) { - rig_debug(RIG_DEBUG_ERR, "%s(): fd error after %d chars\n", - __func__, total_count); + return -RIG_ETIMEOUT; + } - return -RIG_EIO; - } + if (retval < 0) { + dump_hex((unsigned char *) rxbuffer, total_count); + rig_debug(RIG_DEBUG_ERR, + "%s(): select() error after %d chars: %s\n", + __func__, + total_count, + strerror(errno)); - /* - * grab bytes from the rig - * The file descriptor must have been set up non blocking. - */ - rd_count = port_read(p, rxbuffer+total_count, count); - if (rd_count < 0) { - rig_debug(RIG_DEBUG_ERR, "%s(): read() failed - %s\n", - __func__, strerror(errno)); + return -RIG_EIO; + } - return -RIG_EIO; - } - total_count += rd_count; - count -= rd_count; - } + if (FD_ISSET(p->fd, &efds)) { + rig_debug(RIG_DEBUG_ERR, + "%s(): fd error after %d chars\n", + __func__, + total_count); - rig_debug(RIG_DEBUG_TRACE,"%s(): RX %d bytes\n", __func__, total_count); - dump_hex((unsigned char *) rxbuffer, total_count); + return -RIG_EIO; + } - return total_count; /* return bytes count read */ + /* + * grab bytes from the rig + * The file descriptor must have been set up non blocking. + */ + rd_count = port_read(p, rxbuffer + total_count, count); + + if (rd_count < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s(): read() failed - %s\n", + __func__, + strerror(errno)); + + return -RIG_EIO; + } + + total_count += rd_count; + count -= rd_count; + } + + rig_debug(RIG_DEBUG_TRACE, "%s(): RX %d bytes\n", __func__, total_count); + dump_hex((unsigned char *) rxbuffer, total_count); + + return total_count; /* return bytes count read */ } @@ -479,89 +562,119 @@ int HAMLIB_API read_block(hamlib_port_t *p, char *rxbuffer, size_t count) * * Assumes rxbuffer!=NULL */ -int HAMLIB_API read_string(hamlib_port_t *p, char *rxbuffer, size_t rxmax, const char *stopset, - int stopset_len) +int HAMLIB_API read_string(hamlib_port_t *p, char *rxbuffer, size_t rxmax, + const char *stopset, + int stopset_len) { - fd_set rfds, efds; - struct timeval tv, tv_timeout, start_time, end_time, elapsed_time; - int rd_count, total_count = 0; - int retval; + fd_set rfds, efds; + struct timeval tv, tv_timeout, start_time, end_time, elapsed_time; + int rd_count, total_count = 0; + int retval; - if (!p || !rxbuffer) return -RIG_EINVAL; - if (rxmax < 1) return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* - * Wait up to timeout ms. - */ - tv_timeout.tv_sec = p->timeout/1000; - tv_timeout.tv_usec = (p->timeout%1000)*1000; - - /* Store the time of the read loop start */ - gettimeofday(&start_time, NULL); - - while (total_count < rxmax-1) { - tv = tv_timeout; /* select may have updated it */ - - FD_ZERO(&rfds); - FD_SET(p->fd, &rfds); - efds = rfds; - - retval = port_select(p, p->fd+1, &rfds, NULL, &efds, &tv); - if (retval == 0) { - if (0 == total_count) { - /* Record timeout time and caculate elapsed time */ - gettimeofday(&end_time, NULL); - timersub(&end_time, &start_time, &elapsed_time); - - dump_hex((unsigned char *) rxbuffer, total_count); - rig_debug(RIG_DEBUG_WARN, "%s(): Timed out %d.%d seconds after %d chars\n", - __func__, elapsed_time.tv_sec, elapsed_time.tv_usec, total_count); - - return -RIG_ETIMEOUT; + if (!p || !rxbuffer) { + return -RIG_EINVAL; } - break; /* return what we have read */ - } - if (retval < 0) { - dump_hex((unsigned char *) rxbuffer, total_count); - rig_debug(RIG_DEBUG_ERR, "%s(): select() error after %d chars: %s\n", - __func__, total_count, strerror(errno)); + if (rxmax < 1) { + return 0; + } - return -RIG_EIO; - } - if (FD_ISSET(p->fd, &efds)) { - rig_debug(RIG_DEBUG_ERR, "%s(): fd error after %d chars\n", - __func__, total_count); + /* + * Wait up to timeout ms. + */ + tv_timeout.tv_sec = p->timeout / 1000; + tv_timeout.tv_usec = (p->timeout % 1000) * 1000; - return -RIG_EIO; - } + /* Store the time of the read loop start */ + gettimeofday(&start_time, NULL); - /* - * read 1 character from the rig, (check if in stop set) - * The file descriptor must have been set up non blocking. - */ + while (total_count < rxmax - 1) { + tv = tv_timeout; /* select may have updated it */ + + FD_ZERO(&rfds); + FD_SET(p->fd, &rfds); + efds = rfds; + + retval = port_select(p, p->fd + 1, &rfds, NULL, &efds, &tv); + + if (retval == 0) { + if (0 == total_count) { + /* Record timeout time and caculate elapsed time */ + gettimeofday(&end_time, NULL); + timersub(&end_time, &start_time, &elapsed_time); + + dump_hex((unsigned char *) rxbuffer, total_count); + rig_debug(RIG_DEBUG_WARN, + "%s(): Timed out %d.%d seconds after %d chars\n", + __func__, + elapsed_time.tv_sec, + elapsed_time.tv_usec, + total_count); + + return -RIG_ETIMEOUT; + } + + break; /* return what we have read */ + } + + if (retval < 0) { + dump_hex((unsigned char *) rxbuffer, total_count); + rig_debug(RIG_DEBUG_ERR, + "%s(): select() error after %d chars: %s\n", + __func__, + total_count, + strerror(errno)); + + return -RIG_EIO; + } + + if (FD_ISSET(p->fd, &efds)) { + rig_debug(RIG_DEBUG_ERR, + "%s(): fd error after %d chars\n", + __func__, + total_count); + + return -RIG_EIO; + } + + /* + * read 1 character from the rig, (check if in stop set) + * The file descriptor must have been set up non blocking. + */ rd_count = port_read(p, &rxbuffer[total_count], 1); - if (rd_count < 0) { - dump_hex((unsigned char *) rxbuffer, total_count); - rig_debug(RIG_DEBUG_ERR, "%s(): read() failed - %s\n", - __func__, strerror(errno)); - return -RIG_EIO; - } + if (rd_count < 0) { + dump_hex((unsigned char *) rxbuffer, total_count); + rig_debug(RIG_DEBUG_ERR, + "%s(): read() failed - %s\n", + __func__, + strerror(errno)); + + return -RIG_EIO; + } + ++total_count; - if (stopset && memchr(stopset, rxbuffer[total_count-1], stopset_len)) - break; - } - /* - * Doesn't hurt anyway. But be aware, some binary protocols may have - * null chars within th received buffer. - */ - rxbuffer[total_count] = '\000'; - rig_debug(RIG_DEBUG_TRACE,"%s(): RX %d characters\n", __func__, total_count); - dump_hex((unsigned char *) rxbuffer, total_count); + if (stopset && memchr(stopset, rxbuffer[total_count - 1], stopset_len)) { + break; + } + } - return total_count; /* return bytes count read */ + /* + * Doesn't hurt anyway. But be aware, some binary protocols may have + * null chars within th received buffer. + */ + rxbuffer[total_count] = '\000'; + + rig_debug(RIG_DEBUG_TRACE, + "%s(): RX %d characters\n", + __func__, + total_count); + dump_hex((unsigned char *) rxbuffer, total_count); + + return total_count; /* return bytes count read */ } /** @} */ diff --git a/src/iofunc.h b/src/iofunc.h index 3926e7cc6..b423fed34 100644 --- a/src/iofunc.h +++ b/src/iofunc.h @@ -29,9 +29,19 @@ extern HAMLIB_EXPORT(int) port_open(hamlib_port_t *p); extern HAMLIB_EXPORT(int) port_close(hamlib_port_t *p, rig_port_t port_type); -extern HAMLIB_EXPORT(int) read_block(hamlib_port_t *p, char *rxbuffer, size_t count); -extern HAMLIB_EXPORT(int) write_block(hamlib_port_t *p, const char *txbuffer, size_t count); -extern HAMLIB_EXPORT(int) read_string(hamlib_port_t *p, char *rxbuffer, size_t rxmax, const char *stopset, int stopset_len); + +extern HAMLIB_EXPORT(int) read_block(hamlib_port_t *p, + char *rxbuffer, + size_t count); + +extern HAMLIB_EXPORT(int) write_block(hamlib_port_t *p, + const char *txbuffer, + size_t count); + +extern HAMLIB_EXPORT(int) read_string(hamlib_port_t *p, + char *rxbuffer, + size_t rxmax, + const char *stopset, + int stopset_len); #endif /* _IOFUNC_H */ - diff --git a/src/locator.c b/src/locator.c index 863850f5c..4f2046557 100644 --- a/src/locator.c +++ b/src/locator.c @@ -28,7 +28,7 @@ * taken from wwl, by IK0ZSN Mirko Caserta. * * New bearing code added by N0NB was found at: - * http://williams.best.vwh.net/avform.htm#Crs + * http://williams.best.vwh.net/avform.htm#Crs * * * This library is free software; you can redistribute it and/or @@ -88,7 +88,7 @@ * locators described in section 3L of "The IARU region 1 VHF managers * handbook". Values of 5 and 6 will extent the format even more, to the * longest definition I have seen for locators, see - * http://www.btinternet.com/~g8yoa/geog/non-ra.html + * http://www.btinternet.com/~g8yoa/geog/non-ra.html * Beware that there seems to be no universally accepted standard for 10 & 12 * character locators. * @@ -115,14 +115,15 @@ const static int loc_char_range[] = { 18, 10, 24, 10, 24, 10 }; /* end dph */ -#endif /* !DOC_HIDDEN */ +#endif /* !DOC_HIDDEN */ + /** * \brief Convert DMS to decimal degrees - * \param degrees Degrees, whole degrees - * \param minutes Minutes, whole minutes - * \param seconds Seconds, decimal seconds - * \param sw South or West + * \param degrees Degrees, whole degrees + * \param minutes Minutes, whole minutes + * \param seconds Seconds, decimal seconds + * \param sw South or West * * Convert degree/minute/second angle to decimal degrees angle. * \a degrees >360, \a minutes > 60, and \a seconds > 60.0 are allowed, @@ -137,30 +138,39 @@ const static int loc_char_range[] = { 18, 10, 24, 10, 24, 10 }; * * \sa dec2dms() */ +double HAMLIB_API dms2dec(int degrees, int minutes, double seconds, int sw) +{ + double st; -double HAMLIB_API dms2dec(int degrees, int minutes, double seconds, int sw) { - double st; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (degrees < 0) - degrees = abs(degrees); - if (minutes < 0) - minutes = abs(minutes); - if (seconds < 0) - seconds = fabs(seconds); + if (degrees < 0) { + degrees = abs(degrees); + } - st = (double)degrees + (double)minutes / 60. + seconds / 3600.; + if (minutes < 0) { + minutes = abs(minutes); + } - if (sw == 1) - return -st; - else - return st; + if (seconds < 0) { + seconds = fabs(seconds); + } + + st = (double)degrees + (double)minutes / 60. + seconds / 3600.; + + if (sw == 1) { + return -st; + } else { + return st; + } } + /** * \brief Convert D M.MMM notation to decimal degrees - * \param degrees Degrees, whole degrees - * \param minutes Minutes, decimal minutes - * \param sw South or West + * \param degrees Degrees, whole degrees + * \param minutes Minutes, decimal minutes + * \param sw South or West * * Convert a degrees, decimal minutes notation common on * many GPS units to its decimal degrees value. @@ -177,30 +187,37 @@ double HAMLIB_API dms2dec(int degrees, int minutes, double seconds, int sw) { * * \sa dec2dmmm() */ +double HAMLIB_API dmmm2dec(int degrees, double minutes, int sw) +{ + double st; -double HAMLIB_API dmmm2dec(int degrees, double minutes, int sw) { - double st; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (degrees < 0) - degrees = abs(degrees); - if (minutes < 0) - minutes = fabs(minutes); + if (degrees < 0) { + degrees = abs(degrees); + } - st = (double)degrees + minutes / 60.; + if (minutes < 0) { + minutes = fabs(minutes); + } - if (sw == 1) - return -st; - else - return st; + st = (double)degrees + minutes / 60.; + + if (sw == 1) { + return -st; + } else { + return st; + } } + /** * \brief Convert decimal degrees angle into DMS notation - * \param dec Decimal degrees - * \param degrees Pointer for the calculated whole Degrees - * \param minutes Pointer for the calculated whole Minutes - * \param seconds Pointer for the calculated decimal Seconds - * \param sw Pointer for the calculated SW flag + * \param dec Decimal degrees + * \param degrees Pointer for the calculated whole Degrees + * \param minutes Pointer for the calculated whole Minutes + * \param seconds Pointer for the calculated decimal Seconds + * \param sw Pointer for the calculated SW flag * * Convert decimal degrees angle into its degree/minute/second * notation. @@ -221,62 +238,69 @@ double HAMLIB_API dmmm2dec(int degrees, double minutes, int sw) { * * \sa dms2dec() */ +int HAMLIB_API dec2dms(double dec, int *degrees, int *minutes, double *seconds, + int *sw) +{ + int deg, min; + double st; -int HAMLIB_API dec2dms(double dec, int *degrees, int *minutes, double *seconds, int *sw) { - int deg, min; - double st; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* bail if NULL pointers passed */ - if (!degrees || !minutes || !seconds || !sw) - return -RIG_EINVAL; + /* bail if NULL pointers passed */ + if (!degrees || !minutes || !seconds || !sw) { + return -RIG_EINVAL; + } - /* reverse the sign if dec has a magnitude greater - * than 180 and factor out multiples of 360. - * e.g. when passed 270 st will be set to -90 - * and when passed -270 st will be set to 90. If - * passed 361 st will be set to 1, etc. If passed - * a value > -180 || < 180, value will be unchanged. - */ - if (dec >= 0.0) - st = fmod(dec + 180, 360) - 180; - else - st = fmod(dec - 180, 360) + 180; + /* reverse the sign if dec has a magnitude greater + * than 180 and factor out multiples of 360. + * e.g. when passed 270 st will be set to -90 + * and when passed -270 st will be set to 90. If + * passed 361 st will be set to 1, etc. If passed + * a value > -180 || < 180, value will be unchanged. + */ + if (dec >= 0.0) { + st = fmod(dec + 180, 360) - 180; + } else { + st = fmod(dec - 180, 360) + 180; + } - /* if after all of that st is negative, we want deg - * to be negative as well except for 180 which we want - * to be positive. - */ - if (st < 0.0 && st != -180) - *sw = 1; - else - *sw = 0; + /* if after all of that st is negative, we want deg + * to be negative as well except for 180 which we want + * to be positive. + */ + if (st < 0.0 && st != -180) { + *sw = 1; + } else { + *sw = 0; + } - /* work on st as a positive value to remove a - * bug introduced by the effect of floor() when - * passed a negative value. e.g. when passed - * -96.8333 floor() returns -95! Also avoids - * a rounding error introduced on negative values. - */ - st = fabs(st); + /* work on st as a positive value to remove a + * bug introduced by the effect of floor() when + * passed a negative value. e.g. when passed + * -96.8333 floor() returns -95! Also avoids + * a rounding error introduced on negative values. + */ + st = fabs(st); - deg = (int)floor(st); - st = 60. * (st - (double)deg); - min = (int)floor(st); - st = 60. * (st - (double)min); + deg = (int)floor(st); + st = 60. * (st - (double)deg); + min = (int)floor(st); + st = 60. * (st - (double)min); - *degrees = deg; - *minutes = min; - *seconds = st; + *degrees = deg; + *minutes = min; + *seconds = st; - return RIG_OK; + return RIG_OK; } + /** * \brief Convert a decimal angle into D M.MMM notation - * \param dec Decimal degrees - * \param degrees Pointer for the calculated whole Degrees - * \param minutes Pointer for the calculated decimal Minutes - * \param sw Pointer for the calculated SW flag + * \param dec Decimal degrees + * \param degrees Pointer for the calculated whole Degrees + * \param minutes Pointer for the calculated decimal Minutes + * \param sw Pointer for the calculated SW flag * * Convert a decimal angle into its degree, decimal minute * notation common on many GPS units. @@ -297,29 +321,35 @@ int HAMLIB_API dec2dms(double dec, int *degrees, int *minutes, double *seconds, * * \sa dmmm2dec() */ +int HAMLIB_API dec2dmmm(double dec, int *degrees, double *minutes, int *sw) +{ + int r, min; + double sec; -int HAMLIB_API dec2dmmm(double dec, int *degrees, double *minutes, int *sw) { - int r, min; - double sec; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* bail if NULL pointers passed */ - if (!degrees || !minutes || !sw) - return -RIG_EINVAL; + /* bail if NULL pointers passed */ + if (!degrees || !minutes || !sw) { + return -RIG_EINVAL; + } - r = dec2dms(dec, degrees, &min, &sec, sw); - if (r != RIG_OK) - return r; + r = dec2dms(dec, degrees, &min, &sec, sw); - *minutes = (double)min + sec / 60; + if (r != RIG_OK) { + return r; + } - return RIG_OK; + *minutes = (double)min + sec / 60; + + return RIG_OK; } + /** * \brief Convert Maidenhead grid locator to Longitude/Latitude - * \param longitude Pointer for the calculated Longitude - * \param latitude Pointer for the calculated Latitude - * \param locator The Maidenhead grid locator--2 through 12 char + nul string + * \param longitude Pointer for the calculated Longitude + * \param latitude Pointer for the calculated Latitude + * \param locator The Maidenhead grid locator--2 through 12 char + nul string * * Convert Maidenhead grid locator to Longitude/Latitude (decimal degrees). * The locator should be in 2 through 12 chars long format. @@ -342,63 +372,71 @@ int HAMLIB_API dec2dmmm(double dec, int *degrees, double *minutes, int *sw) { */ /* begin dph */ +int HAMLIB_API locator2longlat(double *longitude, double *latitude, + const char *locator) +{ + int x_or_y, paircount; + int locvalue, pair; + int divisions; + double xy[2], ordinate; -int HAMLIB_API locator2longlat(double *longitude, double *latitude, const char *locator) { - int x_or_y, paircount; - int locvalue, pair; - int divisions; - double xy[2], ordinate; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* bail if NULL pointers passed */ - if (!longitude || !latitude) - return -RIG_EINVAL; + /* bail if NULL pointers passed */ + if (!longitude || !latitude) { + return -RIG_EINVAL; + } - paircount = strlen(locator) / 2; + paircount = strlen(locator) / 2; - /* verify paircount is within limits */ - if (paircount > MAX_LOCATOR_PAIRS) - paircount = MAX_LOCATOR_PAIRS; - else if (paircount < MIN_LOCATOR_PAIRS) - return -RIG_EINVAL; + /* verify paircount is within limits */ + if (paircount > MAX_LOCATOR_PAIRS) { + paircount = MAX_LOCATOR_PAIRS; + } else if (paircount < MIN_LOCATOR_PAIRS) { + return -RIG_EINVAL; + } - /* For x(=longitude) and y(=latitude) */ - for (x_or_y = 0; x_or_y < 2; ++x_or_y) { - ordinate = -90.0; - divisions = 1; + /* For x(=longitude) and y(=latitude) */ + for (x_or_y = 0; x_or_y < 2; ++x_or_y) { + ordinate = -90.0; + divisions = 1; - for (pair = 0; pair < paircount; ++pair) { - locvalue = locator[pair*2 + x_or_y]; + for (pair = 0; pair < paircount; ++pair) { + locvalue = locator[pair * 2 + x_or_y]; - /* Value of digit or letter */ - locvalue -= (loc_char_range[pair] == 10) ? '0' : - (isupper(locvalue)) ? 'A' : 'a'; + /* Value of digit or letter */ + locvalue -= (loc_char_range[pair] == 10) ? '0' : + (isupper(locvalue)) ? 'A' : 'a'; - /* Check range for non-letter/digit or out of range */ - if ((locvalue < 0) || (locvalue >= loc_char_range[pair])) - return -RIG_EINVAL; + /* Check range for non-letter/digit or out of range */ + if ((locvalue < 0) || (locvalue >= loc_char_range[pair])) { + return -RIG_EINVAL; + } - divisions *= loc_char_range[pair]; - ordinate += locvalue * 180.0 / divisions; - } - /* Center ordinate in the Maidenhead "square" or "subsquare" */ - ordinate += 90.0 / divisions; + divisions *= loc_char_range[pair]; + ordinate += locvalue * 180.0 / divisions; + } - xy[x_or_y] = ordinate; - } + /* Center ordinate in the Maidenhead "square" or "subsquare" */ + ordinate += 90.0 / divisions; - *longitude = xy[0] * 2.0; - *latitude = xy[1]; + xy[x_or_y] = ordinate; + } - return RIG_OK; + *longitude = xy[0] * 2.0; + *latitude = xy[1]; + + return RIG_OK; } /* end dph */ + /** * \brief Convert longitude/latitude to Maidenhead grid locator - * \param longitude Longitude, decimal degrees - * \param latitude Latitude, decimal degrees - * \param locator Pointer for the Maidenhead Locator - * \param pair_count Precision expressed as lon/lat pairs in the locator + * \param longitude Longitude, decimal degrees + * \param latitude Latitude, decimal degrees + * \param locator Pointer for the Maidenhead Locator + * \param pair_count Precision expressed as lon/lat pairs in the locator * * Convert longitude/latitude (decimal degrees) to Maidenhead grid locator. * \a locator must point to an array at least \a pair_count * 2 char + '\\0'. @@ -416,55 +454,62 @@ int HAMLIB_API locator2longlat(double *longitude, double *latitude, const char * */ /* begin dph */ +int HAMLIB_API longlat2locator(double longitude, double latitude, char *locator, + int pair_count) +{ + int x_or_y, pair, locvalue, divisions; + double square_size, ordinate; -int HAMLIB_API longlat2locator(double longitude, double latitude, char *locator, int pair_count) { - int x_or_y, pair, locvalue, divisions; - double square_size, ordinate; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!locator) - return -RIG_EINVAL; + if (!locator) { + return -RIG_EINVAL; + } - if (pair_count < MIN_LOCATOR_PAIRS || pair_count > MAX_LOCATOR_PAIRS) - return -RIG_EINVAL; + if (pair_count < MIN_LOCATOR_PAIRS || pair_count > MAX_LOCATOR_PAIRS) { + return -RIG_EINVAL; + } - for (x_or_y = 0; x_or_y < 2; ++x_or_y) { - ordinate = (x_or_y == 0) ? longitude / 2.0 : latitude; - divisions = 1; + for (x_or_y = 0; x_or_y < 2; ++x_or_y) { + ordinate = (x_or_y == 0) ? longitude / 2.0 : latitude; + divisions = 1; - /* The 1e-6 here guards against floating point rounding errors */ - ordinate = fmod(ordinate + 270.000001, 180.0); - for (pair = 0; pair < pair_count; ++pair) { - divisions *= loc_char_range[pair]; - square_size = 180.0 / divisions; + /* The 1e-6 here guards against floating point rounding errors */ + ordinate = fmod(ordinate + 270.000001, 180.0); - locvalue = (int) (ordinate / square_size); - ordinate -= square_size * locvalue; - locvalue += (loc_char_range[pair] == 10) ? '0':'A'; - locator[pair * 2 + x_or_y] = locvalue; - } - } - locator[pair_count * 2] = '\0'; + for (pair = 0; pair < pair_count; ++pair) { + divisions *= loc_char_range[pair]; + square_size = 180.0 / divisions; - return RIG_OK; + locvalue = (int)(ordinate / square_size); + ordinate -= square_size * locvalue; + locvalue += (loc_char_range[pair] == 10) ? '0' : 'A'; + locator[pair * 2 + x_or_y] = locvalue; + } + } + + locator[pair_count * 2] = '\0'; + + return RIG_OK; } - /* end dph */ + /** * \brief Calculate the distance and bearing between two points. - * \param lon1 The local Longitude, decimal degrees - * \param lat1 The local Latitude, decimal degrees - * \param lon2 The remote Longitude, decimal degrees - * \param lat2 The remote Latitude, decimal degrees - * \param distance Pointer for the distance, km - * \param azimuth Pointer for the bearing, decimal degrees + * \param lon1 The local Longitude, decimal degrees + * \param lat1 The local Latitude, decimal degrees + * \param lon2 The remote Longitude, decimal degrees + * \param lat2 The remote Latitude, decimal degrees + * \param distance Pointer for the distance, km + * \param azimuth Pointer for the bearing, decimal degrees * * Calculate the QRB between \a lon1, \a lat1 and \a lon2, \a lat2. * - * This version will calculate the QRB to a precision sufficient - * for 12 character locators. Antipodal points, which are easily - * calculated, are considered equidistant and the bearing is - * simply resolved to be true north (0.0°). + * This version will calculate the QRB to a precision sufficient + * for 12 character locators. Antipodal points, which are easily + * calculated, are considered equidistant and the bearing is + * simply resolved to be true north (0.0°). * * \retval -RIG_EINVAL if NULL pointer passed or lat and lon values * exceed -90 to 90 or -180 to 180. @@ -475,90 +520,99 @@ int HAMLIB_API longlat2locator(double longitude, double latitude, char *locator, * * \sa distance_long_path(), azimuth_long_path() */ +int HAMLIB_API qrb(double lon1, double lat1, double lon2, double lat2, + double *distance, double *azimuth) +{ + double delta_long, tmp, arc, az; -int HAMLIB_API qrb(double lon1, double lat1, double lon2, double lat2, double *distance, double *azimuth) { - double delta_long, tmp, arc, az; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* bail if NULL pointers passed */ - if (!distance || !azimuth) - return -RIG_EINVAL; + /* bail if NULL pointers passed */ + if (!distance || !azimuth) { + return -RIG_EINVAL; + } - if ((lat1 > 90.0 || lat1 < -90.0) || (lat2 > 90.0 || lat2 < -90.0)) - return -RIG_EINVAL; + if ((lat1 > 90.0 || lat1 < -90.0) || (lat2 > 90.0 || lat2 < -90.0)) { + return -RIG_EINVAL; + } - if ((lon1 > 180.0 || lon1 < -180.0) || (lon2 > 180.0 || lon2 < -180.0)) - return -RIG_EINVAL; + if ((lon1 > 180.0 || lon1 < -180.0) || (lon2 > 180.0 || lon2 < -180.0)) { + return -RIG_EINVAL; + } - /* Prevent ACOS() Domain Error */ - if (lat1 == 90.0) - lat1 = 89.999999999; - else if (lat1 == -90.0) - lat1 = -89.999999999; + /* Prevent ACOS() Domain Error */ + if (lat1 == 90.0) { + lat1 = 89.999999999; + } else if (lat1 == -90.0) { + lat1 = -89.999999999; + } - if (lat2 == 90.0) - lat2 = 89.999999999; - else if (lat2 == -90.0) - lat2 = -89.999999999; + if (lat2 == 90.0) { + lat2 = 89.999999999; + } else if (lat2 == -90.0) { + lat2 = -89.999999999; + } - /* Convert variables to Radians */ - lat1 /= RADIAN; - lon1 /= RADIAN; - lat2 /= RADIAN; - lon2 /= RADIAN; + /* Convert variables to Radians */ + lat1 /= RADIAN; + lon1 /= RADIAN; + lat2 /= RADIAN; + lon2 /= RADIAN; - delta_long = lon2 - lon1; + delta_long = lon2 - lon1; - tmp = sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(delta_long); + tmp = sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(delta_long); - if (tmp > .999999999999999) { - /* Station points coincide, use an Omni! */ - *distance = 0.0; - *azimuth = 0.0; - return RIG_OK; - } + if (tmp > .999999999999999) { + /* Station points coincide, use an Omni! */ + *distance = 0.0; + *azimuth = 0.0; + return RIG_OK; + } - if (tmp < -.999999) { - /* - * points are antipodal, it's straight down. - * Station is equal distance in all Azimuths. - * So take 180 Degrees of arc times 60 nm, - * and you get 10800 nm, or whatever units... - */ - *distance = 180.0 * ARC_IN_KM; - *azimuth = 0.0; - return RIG_OK; - } + if (tmp < -.999999) { + /* + * points are antipodal, it's straight down. + * Station is equal distance in all Azimuths. + * So take 180 Degrees of arc times 60 nm, + * and you get 10800 nm, or whatever units... + */ + *distance = 180.0 * ARC_IN_KM; + *azimuth = 0.0; + return RIG_OK; + } - arc = acos(tmp); + arc = acos(tmp); - /* - * One degree of arc is 60 Nautical miles - * at the surface of the earth, 111.2 km, or 69.1 sm - * This method is easier than the one in the handbook - */ + /* + * One degree of arc is 60 Nautical miles + * at the surface of the earth, 111.2 km, or 69.1 sm + * This method is easier than the one in the handbook + */ + *distance = ARC_IN_KM * RADIAN * arc; + /* Short Path */ + /* Change to azimuth computation by Dave Freese, W1HKJ */ + az = RADIAN * atan2(sin(lon2 - lon1) * cos(lat2), + (cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(lon2 - lon1))); - *distance = ARC_IN_KM * RADIAN * arc; + az = fmod(360.0 + az, 360.0); - /* Short Path */ - /* Change to azimuth computation by Dave Freese, W1HKJ */ + if (az < 0.0) { + az += 360.0; + } else if (az >= 360.0) { + az -= 360.0; + } - az = RADIAN * atan2(sin(lon2 - lon1) * cos(lat2), - (cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(lon2 - lon1))); + *azimuth = floor(az + 0.5); - az = fmod(360.0 + az, 360.0); - if (az < 0.0) - az += 360.0; - else if (az >= 360.0) - az -= 360.0; - - *azimuth = floor(az + 0.5); - return RIG_OK; + return RIG_OK; } + /** * \brief Calculate the long path distance between two points. - * \param distance The shortpath distance + * \param distance The shortpath distance * * Calculate the long path (respective of the short path) * of a given distance. @@ -567,14 +621,17 @@ int HAMLIB_API qrb(double lon1, double lat1, double lon2, double lat2, double *d * * \sa qrb() */ +double HAMLIB_API distance_long_path(double distance) +{ + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); -double HAMLIB_API distance_long_path(double distance) { - return (ARC_IN_KM * 360.0) - distance; + return (ARC_IN_KM * 360.0) - distance; } + /** * \brief Calculate the long path bearing between two points. - * \param azimuth The shortpath bearing--0.0 to 360.0 degrees + * \param azimuth The shortpath bearing--0.0 to 360.0 degrees * * Calculate the long path (respective of the short path) * of a given bearing. @@ -584,18 +641,21 @@ double HAMLIB_API distance_long_path(double distance) { * * \sa qrb() */ +double HAMLIB_API azimuth_long_path(double azimuth) +{ + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); -double HAMLIB_API azimuth_long_path(double azimuth) { - if (azimuth == 0.0 || azimuth == 360.0) + if (azimuth == 0.0 || azimuth == 360.0) { return 180.0; - else if (azimuth > 0.0 && azimuth < 180.0) + } else if (azimuth > 0.0 && azimuth < 180.0) { return 180.0 + azimuth; - else if (azimuth == 180.0) + } else if (azimuth == 180.0) { return 0.0; - else if (azimuth > 180.0 && azimuth < 360.0) + } else if (azimuth > 180.0 && azimuth < 360.0) { return (180.0 - azimuth) * -1.0; - else + } else { return -RIG_EINVAL; + } } /*! @} */ diff --git a/src/mem.c b/src/mem.c index c4f24ef73..fd3076e86 100644 --- a/src/mem.c +++ b/src/mem.c @@ -55,9 +55,9 @@ /** * \brief set the current memory channel number - * \param rig The rig handle - * \param vfo The target VFO - * \param ch The memory channel number + * \param rig The rig handle + * \param vfo The target VFO + * \param ch The memory channel number * * Sets the current memory channel number. * It is not mandatory for the radio to be in memory mode. Actually @@ -69,42 +69,53 @@ * * \sa rig_get_mem() */ - int HAMLIB_API rig_set_mem(RIG *rig, vfo_t vfo, int ch) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_mem == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_mem(rig, vfo, ch); + if (caps->set_mem == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_mem(rig, vfo, ch); + } - retcode = caps->set_mem(rig, vfo, ch); - caps->set_vfo(rig, curr_vfo); - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_mem(rig, vfo, ch); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the current memory channel number - * \param rig The rig handle - * \param vfo The target VFO - * \param ch The location where to store the current memory channel number + * \param rig The rig handle + * \param vfo The target VFO + * \param ch The location where to store the current memory channel number * * Retrieves the current memory channel number. * It is not mandatory for the radio to be in memory mode. Actually @@ -118,40 +129,50 @@ int HAMLIB_API rig_set_mem(RIG *rig, vfo_t vfo, int ch) */ int HAMLIB_API rig_get_mem(RIG *rig, vfo_t vfo, int *ch) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !ch) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !ch) { + return -RIG_EINVAL; + } - if (caps->get_mem == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_mem(rig, vfo, ch); + if (caps->get_mem == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_mem(rig, vfo, ch); + } - retcode = caps->get_mem(rig, vfo, ch); - caps->set_vfo(rig, curr_vfo); - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_mem(rig, vfo, ch); + caps->set_vfo(rig, curr_vfo); + return retcode; } /** * \brief set the current memory bank - * \param rig The rig handle - * \param vfo The target VFO - * \param bank The memory bank + * \param rig The rig handle + * \param vfo The target VFO + * \param bank The memory bank * * Sets the current memory bank number. * It is not mandatory for the radio to be in memory mode. Actually @@ -163,326 +184,415 @@ int HAMLIB_API rig_get_mem(RIG *rig, vfo_t vfo, int *ch) * * \sa rig_set_mem() */ - int HAMLIB_API rig_set_bank(RIG *rig, vfo_t vfo, int bank) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_bank == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_bank(rig, vfo, bank); + if (caps->set_bank == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_bank(rig, vfo, bank); + } - retcode = caps->set_bank(rig, vfo, bank); - caps->set_vfo(rig, curr_vfo); - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_bank(rig, vfo, bank); + caps->set_vfo(rig, curr_vfo); + + return retcode; } #ifndef DOC_HIDDEN + + /* * call on every ext_levels of a rig */ -static int generic_retr_extl(RIG *rig, const struct confparams *cfp, rig_ptr_t ptr) +static int generic_retr_extl(RIG *rig, + const struct confparams *cfp, + rig_ptr_t ptr) { - channel_t *chan = (channel_t *)ptr; - struct ext_list *p; - unsigned el_size = 0; + channel_t *chan = (channel_t *)ptr; + struct ext_list *p; + unsigned el_size = 0; - if (chan->ext_levels == NULL) - p = chan->ext_levels = malloc(2*sizeof(struct ext_list)); - else { - for (p = chan->ext_levels; !RIG_IS_EXT_END(*p); p++) - el_size += sizeof(struct ext_list); - chan->ext_levels = realloc(chan->ext_levels, - el_size+sizeof(struct ext_list)); - } + if (chan->ext_levels == NULL) { + p = chan->ext_levels = malloc(2 * sizeof(struct ext_list)); + } else { + for (p = chan->ext_levels; !RIG_IS_EXT_END(*p); p++) { + el_size += sizeof(struct ext_list); + } - if (!chan->ext_levels) { - rig_debug(RIG_DEBUG_ERR, "%s:%d memory allocation error!\n", - __FUNCTION__, __LINE__); - return -RIG_ENOMEM; - } + chan->ext_levels = realloc(chan->ext_levels, + el_size + sizeof(struct ext_list)); + } - p->token = cfp->token; - rig_get_ext_level(rig, RIG_VFO_CURR, p->token, &p->val); - p++; - p->token = 0; /* RIG_EXT_END */ + if (!chan->ext_levels) { + rig_debug(RIG_DEBUG_ERR, + "%s: %d memory allocation error!\n", + __func__, + __LINE__); + return -RIG_ENOMEM; + } - return 1; /* process them all */ + p->token = cfp->token; + rig_get_ext_level(rig, RIG_VFO_CURR, p->token, &p->val); + p++; + p->token = 0; /* RIG_EXT_END */ + + return 1; /* process them all */ } + static const channel_cap_t mem_cap_all = { - .bank_num = 1, - .vfo = 1, - .ant = 1, - .freq = 1, - .mode = 1, - .width = 1, - .tx_freq = 1, - .tx_mode = 1, - .tx_width = 1, - .split = 1, - .tx_vfo = 1, - .rptr_shift = 1, - .rptr_offs = 1, - .tuning_step = 1, - .rit = 1, - .xit = 1, - .funcs = (setting_t)-1, - .levels = (setting_t)-1, - .ctcss_tone = 1, - .ctcss_sql = 1, - .dcs_code = 1, - .dcs_sql = 1, - .scan_group = 1, - .flags = 1, - .channel_desc = 1, - .ext_levels = 1, + .bank_num = 1, + .vfo = 1, + .ant = 1, + .freq = 1, + .mode = 1, + .width = 1, + .tx_freq = 1, + .tx_mode = 1, + .tx_width = 1, + .split = 1, + .tx_vfo = 1, + .rptr_shift = 1, + .rptr_offs = 1, + .tuning_step = 1, + .rit = 1, + .xit = 1, + .funcs = (setting_t) - 1, + .levels = (setting_t) - 1, + .ctcss_tone = 1, + .ctcss_sql = 1, + .dcs_code = 1, + .dcs_sql = 1, + .scan_group = 1, + .flags = 1, + .channel_desc = 1, + .ext_levels = 1, }; + static int rig_mem_caps_empty(const channel_cap_t *mem_cap) { - return !( - mem_cap->bank_num || - mem_cap->vfo || - mem_cap->ant || - mem_cap->freq || - mem_cap->mode || - mem_cap->width || - mem_cap->tx_freq || - mem_cap->tx_mode || - mem_cap->tx_width || - mem_cap->split || - mem_cap->tx_vfo || - mem_cap->rptr_shift || - mem_cap->rptr_offs || - mem_cap->tuning_step || - mem_cap->rit || - mem_cap->xit || - mem_cap->funcs || - mem_cap->levels || - mem_cap->ctcss_tone || - mem_cap->ctcss_sql || - mem_cap->dcs_code || - mem_cap->dcs_sql || - mem_cap->scan_group || - mem_cap->flags || - mem_cap->channel_desc || - mem_cap->ext_levels - ); + return !( + mem_cap->bank_num || + mem_cap->vfo || + mem_cap->ant || + mem_cap->freq || + mem_cap->mode || + mem_cap->width || + mem_cap->tx_freq || + mem_cap->tx_mode || + mem_cap->tx_width || + mem_cap->split || + mem_cap->tx_vfo || + mem_cap->rptr_shift || + mem_cap->rptr_offs || + mem_cap->tuning_step || + mem_cap->rit || + mem_cap->xit || + mem_cap->funcs || + mem_cap->levels || + mem_cap->ctcss_tone || + mem_cap->ctcss_sql || + mem_cap->dcs_code || + mem_cap->dcs_sql || + mem_cap->scan_group || + mem_cap->flags || + mem_cap->channel_desc || + mem_cap->ext_levels + ); } + /* * stores current VFO state into chan by emulating rig_get_channel */ static int generic_save_channel(RIG *rig, channel_t *chan) { - int i, retval; - int chan_num; - vfo_t vfo; - setting_t setting; - const channel_cap_t *mem_cap = NULL; + int i, retval; + int chan_num; + vfo_t vfo; + setting_t setting; + const channel_cap_t *mem_cap = NULL; - chan_num = chan->channel_num; - vfo = chan->vfo; - memset(chan, 0, sizeof(channel_t)); - chan->channel_num = chan_num; - chan->vfo = vfo; + chan_num = chan->channel_num; + vfo = chan->vfo; + memset(chan, 0, sizeof(channel_t)); + chan->channel_num = chan_num; + chan->vfo = vfo; - if (vfo == RIG_VFO_MEM) - { - const chan_t *chan_cap; - chan_cap = rig_lookup_mem_caps(rig, chan_num); - if (chan_cap) mem_cap = &chan_cap->mem_caps; - } - /* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */ - if (mem_cap == NULL || rig_mem_caps_empty(mem_cap)) - { - mem_cap = &mem_cap_all; - } + if (vfo == RIG_VFO_MEM) { + const chan_t *chan_cap; + chan_cap = rig_lookup_mem_caps(rig, chan_num); - if (mem_cap->freq) { - retval = rig_get_freq(rig, RIG_VFO_CURR, &chan->freq); - /* empty channel ? */ - if (retval == -RIG_ENAVAIL || chan->freq == RIG_FREQ_NONE) - return -RIG_ENAVAIL; - } + if (chan_cap) { + mem_cap = &chan_cap->mem_caps; + } + } - if (mem_cap->vfo) - rig_get_vfo(rig, &chan->vfo); - if (mem_cap->mode || mem_cap->width) - rig_get_mode(rig, RIG_VFO_CURR, &chan->mode, &chan->width); + /* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */ + if (mem_cap == NULL || rig_mem_caps_empty(mem_cap)) { + mem_cap = &mem_cap_all; + } - chan->split = RIG_SPLIT_OFF; + if (mem_cap->freq) { + retval = rig_get_freq(rig, RIG_VFO_CURR, &chan->freq); - if (mem_cap->split) - rig_get_split_vfo(rig, RIG_VFO_CURR, &chan->split, &chan->tx_vfo); - if (chan->split != RIG_SPLIT_OFF) { - if (mem_cap->tx_freq) - rig_get_split_freq(rig, RIG_VFO_CURR, &chan->tx_freq); - if (mem_cap->tx_mode || mem_cap->tx_width) - rig_get_split_mode(rig, RIG_VFO_CURR, &chan->tx_mode, &chan->tx_width); - } else { - chan->tx_freq = chan->freq; - chan->tx_mode = chan->mode; - chan->tx_width = chan->width; - } - if (mem_cap->rptr_shift) - rig_get_rptr_shift(rig, RIG_VFO_CURR, &chan->rptr_shift); - if (mem_cap->rptr_offs) - rig_get_rptr_offs(rig, RIG_VFO_CURR, &chan->rptr_offs); + /* empty channel ? */ + if (retval == -RIG_ENAVAIL || chan->freq == RIG_FREQ_NONE) { + return -RIG_ENAVAIL; + } + } - if (mem_cap->ant) - rig_get_ant(rig, RIG_VFO_CURR, &chan->ant); - if (mem_cap->tuning_step) - rig_get_ts(rig, RIG_VFO_CURR, &chan->tuning_step); - if (mem_cap->rit) - rig_get_rit(rig, RIG_VFO_CURR, &chan->rit); - if (mem_cap->xit) - rig_get_xit(rig, RIG_VFO_CURR, &chan->xit); + if (mem_cap->vfo) { + rig_get_vfo(rig, &chan->vfo); + } - for (i=0; ilevels) && RIG_LEVEL_SET(setting)) - rig_get_level(rig, RIG_VFO_CURR, setting, &chan->levels[i]); - } + if (mem_cap->mode || mem_cap->width) { + rig_get_mode(rig, RIG_VFO_CURR, &chan->mode, &chan->width); + } - for (i=0; ifuncs) && - (rig_get_func(rig, RIG_VFO_CURR, setting, &fstatus) == RIG_OK)) - chan->funcs |= fstatus ? setting : 0; - } + chan->split = RIG_SPLIT_OFF; - if (mem_cap->ctcss_tone) - rig_get_ctcss_tone(rig, RIG_VFO_CURR, &chan->ctcss_tone); - if (mem_cap->ctcss_sql) - rig_get_ctcss_sql(rig, RIG_VFO_CURR, &chan->ctcss_sql); - if (mem_cap->dcs_code) - rig_get_dcs_code(rig, RIG_VFO_CURR, &chan->dcs_code); - if (mem_cap->dcs_sql) - rig_get_dcs_sql(rig, RIG_VFO_CURR, &chan->dcs_sql); - /* - * TODO: (missing calls) - * - channel_desc - * - bank_num - * - scan_group - * - flags - */ + if (mem_cap->split) { + rig_get_split_vfo(rig, RIG_VFO_CURR, &chan->split, &chan->tx_vfo); + } - rig_ext_level_foreach(rig, generic_retr_extl, (rig_ptr_t)chan); + if (chan->split != RIG_SPLIT_OFF) { + if (mem_cap->tx_freq) { + rig_get_split_freq(rig, RIG_VFO_CURR, &chan->tx_freq); + } - return RIG_OK; + if (mem_cap->tx_mode || mem_cap->tx_width) { + rig_get_split_mode(rig, RIG_VFO_CURR, &chan->tx_mode, &chan->tx_width); + } + } else { + chan->tx_freq = chan->freq; + chan->tx_mode = chan->mode; + chan->tx_width = chan->width; + } + + if (mem_cap->rptr_shift) { + rig_get_rptr_shift(rig, RIG_VFO_CURR, &chan->rptr_shift); + } + + if (mem_cap->rptr_offs) { + rig_get_rptr_offs(rig, RIG_VFO_CURR, &chan->rptr_offs); + } + + if (mem_cap->ant) { + rig_get_ant(rig, RIG_VFO_CURR, &chan->ant); + } + + if (mem_cap->tuning_step) { + rig_get_ts(rig, RIG_VFO_CURR, &chan->tuning_step); + } + + if (mem_cap->rit) { + rig_get_rit(rig, RIG_VFO_CURR, &chan->rit); + } + + if (mem_cap->xit) { + rig_get_xit(rig, RIG_VFO_CURR, &chan->xit); + } + + for (i = 0; i < RIG_SETTING_MAX; i++) { + setting = rig_idx2setting(i); + + if ((setting & mem_cap->levels) && RIG_LEVEL_SET(setting)) { + rig_get_level(rig, RIG_VFO_CURR, setting, &chan->levels[i]); + } + } + + for (i = 0; i < RIG_SETTING_MAX; i++) { + int fstatus; + setting = rig_idx2setting(i); + + if ((setting & mem_cap->funcs) + && (rig_get_func(rig, RIG_VFO_CURR, setting, &fstatus) == RIG_OK)) { + chan->funcs |= fstatus ? setting : 0; + } + } + + if (mem_cap->ctcss_tone) { + rig_get_ctcss_tone(rig, RIG_VFO_CURR, &chan->ctcss_tone); + } + + if (mem_cap->ctcss_sql) { + rig_get_ctcss_sql(rig, RIG_VFO_CURR, &chan->ctcss_sql); + } + + if (mem_cap->dcs_code) { + rig_get_dcs_code(rig, RIG_VFO_CURR, &chan->dcs_code); + } + + if (mem_cap->dcs_sql) { + rig_get_dcs_sql(rig, RIG_VFO_CURR, &chan->dcs_sql); + } + + /* + * TODO: (missing calls) + * - channel_desc + * - bank_num + * - scan_group + * - flags + */ + + rig_ext_level_foreach(rig, generic_retr_extl, (rig_ptr_t)chan); + + return RIG_OK; } + /* * Restores chan into current VFO state by emulating rig_set_channel */ static int generic_restore_channel(RIG *rig, const channel_t *chan) { - int i; - struct ext_list *p; - setting_t setting; - const channel_cap_t *mem_cap = NULL; + int i; + struct ext_list *p; + setting_t setting; + const channel_cap_t *mem_cap = NULL; - if (chan->vfo == RIG_VFO_MEM) - { - const chan_t *chan_cap; - chan_cap = rig_lookup_mem_caps(rig, chan->channel_num); - if (chan_cap) mem_cap = &chan_cap->mem_caps; - } - /* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */ - if (mem_cap == NULL || rig_mem_caps_empty(mem_cap)) - { - mem_cap = &mem_cap_all; - } + if (chan->vfo == RIG_VFO_MEM) { + const chan_t *chan_cap; + chan_cap = rig_lookup_mem_caps(rig, chan->channel_num); - rig_set_vfo(rig, chan->vfo); - if (mem_cap->freq) - rig_set_freq(rig, RIG_VFO_CURR, chan->freq); - if (mem_cap->mode || mem_cap->width) - rig_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); + if (chan_cap) { + mem_cap = &chan_cap->mem_caps; + } + } - rig_set_split_vfo(rig, RIG_VFO_CURR, chan->split, chan->tx_vfo); - if (chan->split != RIG_SPLIT_OFF) { - if (mem_cap->tx_freq) - rig_set_split_freq(rig, RIG_VFO_CURR, chan->tx_freq); - if (mem_cap->tx_mode || mem_cap->tx_width) - rig_set_split_mode(rig, RIG_VFO_CURR, chan->tx_mode, chan->tx_width); - } + /* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */ + if (mem_cap == NULL || rig_mem_caps_empty(mem_cap)) { + mem_cap = &mem_cap_all; + } - if (mem_cap->rptr_shift) - rig_set_rptr_shift(rig, RIG_VFO_CURR, chan->rptr_shift); - if (mem_cap->rptr_offs) - rig_set_rptr_offs(rig, RIG_VFO_CURR, chan->rptr_offs); + rig_set_vfo(rig, chan->vfo); - for (i=0; ilevels) - rig_set_level(rig, RIG_VFO_CURR, setting, chan->levels[i]); - } + if (mem_cap->freq) { + rig_set_freq(rig, RIG_VFO_CURR, chan->freq); + } - if (mem_cap->ant) - rig_set_ant(rig, RIG_VFO_CURR, chan->ant); - if (mem_cap->tuning_step) - rig_set_ts(rig, RIG_VFO_CURR, chan->tuning_step); - if (mem_cap->rit) - rig_set_rit(rig, RIG_VFO_CURR, chan->rit); - if (mem_cap->xit) - rig_set_xit(rig, RIG_VFO_CURR, chan->xit); + if (mem_cap->mode || mem_cap->width) { + rig_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); + } - for (i=0; ifuncs) - rig_set_func(rig, RIG_VFO_CURR, setting, - chan->funcs & rig_idx2setting(i)); - } + rig_set_split_vfo(rig, RIG_VFO_CURR, chan->split, chan->tx_vfo); - if (mem_cap->ctcss_tone) - rig_set_ctcss_tone(rig, RIG_VFO_CURR, chan->ctcss_tone); - if (mem_cap->ctcss_sql) - rig_set_ctcss_sql(rig, RIG_VFO_CURR, chan->ctcss_sql); - if (mem_cap->dcs_code) - rig_set_dcs_code(rig, RIG_VFO_CURR, chan->dcs_code); - if (mem_cap->dcs_sql) - rig_set_dcs_sql(rig, RIG_VFO_CURR, chan->dcs_sql); + if (chan->split != RIG_SPLIT_OFF) { + if (mem_cap->tx_freq) { + rig_set_split_freq(rig, RIG_VFO_CURR, chan->tx_freq); + } - /* - * TODO: (missing calls) - * - channel_desc - * - bank_num - * - scan_group - * - flags - */ + if (mem_cap->tx_mode || mem_cap->tx_width) { + rig_set_split_mode(rig, RIG_VFO_CURR, chan->tx_mode, chan->tx_width); + } + } - for (p = chan->ext_levels; p && !RIG_IS_EXT_END(*p); p++) - rig_set_ext_level(rig, RIG_VFO_CURR, p->token, p->val); + if (mem_cap->rptr_shift) { + rig_set_rptr_shift(rig, RIG_VFO_CURR, chan->rptr_shift); + } - return RIG_OK; + if (mem_cap->rptr_offs) { + rig_set_rptr_offs(rig, RIG_VFO_CURR, chan->rptr_offs); + } + + for (i = 0; i < RIG_SETTING_MAX; i++) { + setting = rig_idx2setting(i); + + if (setting & mem_cap->levels) { + rig_set_level(rig, RIG_VFO_CURR, setting, chan->levels[i]); + } + } + + if (mem_cap->ant) { + rig_set_ant(rig, RIG_VFO_CURR, chan->ant); + } + + if (mem_cap->tuning_step) { + rig_set_ts(rig, RIG_VFO_CURR, chan->tuning_step); + } + + if (mem_cap->rit) { + rig_set_rit(rig, RIG_VFO_CURR, chan->rit); + } + + if (mem_cap->xit) { + rig_set_xit(rig, RIG_VFO_CURR, chan->xit); + } + + for (i = 0; i < RIG_SETTING_MAX; i++) { + setting = rig_idx2setting(i); + + if (setting & mem_cap->funcs) + rig_set_func(rig, RIG_VFO_CURR, setting, + chan->funcs & rig_idx2setting(i)); + } + + if (mem_cap->ctcss_tone) { + rig_set_ctcss_tone(rig, RIG_VFO_CURR, chan->ctcss_tone); + } + + if (mem_cap->ctcss_sql) { + rig_set_ctcss_sql(rig, RIG_VFO_CURR, chan->ctcss_sql); + } + + if (mem_cap->dcs_code) { + rig_set_dcs_code(rig, RIG_VFO_CURR, chan->dcs_code); + } + + if (mem_cap->dcs_sql) { + rig_set_dcs_sql(rig, RIG_VFO_CURR, chan->dcs_sql); + } + + /* + * TODO: (missing calls) + * - channel_desc + * - bank_num + * - scan_group + * - flags + */ + + for (p = chan->ext_levels; p && !RIG_IS_EXT_END(*p); p++) { + rig_set_ext_level(rig, RIG_VFO_CURR, p->token, p->val); + } + + return RIG_OK; } -#endif /* !DOC_HIDDEN */ +#endif /* !DOC_HIDDEN */ + /** * \brief set channel data - * \param rig The rig handle - * \param chan The location of data to set for this channel + * \param rig The rig handle + * \param chan The location of data to set for this channel * * Sets the data associated with a channel. This channel can either * be the state of a VFO specified by \a chan->vfo, or a memory channel @@ -499,97 +609,112 @@ static int generic_restore_channel(RIG *rig, const channel_t *chan) * * \sa rig_get_channel() */ - int HAMLIB_API rig_set_channel(RIG *rig, const channel_t *chan) { - struct rig_caps *rc; - int curr_chan_num, get_mem_status = RIG_OK; - vfo_t curr_vfo; - vfo_t vfo; /* requested vfo */ - int retcode; - int can_emulate_by_vfo_mem, can_emulate_by_vfo_op; + struct rig_caps *rc; + int curr_chan_num, get_mem_status = RIG_OK; + vfo_t curr_vfo; + vfo_t vfo; /* requested vfo */ + int retcode; + int can_emulate_by_vfo_mem, can_emulate_by_vfo_op; #ifdef PARANOID_CHANNEL_HANDLING - channel_t curr_chan; + channel_t curr_chan; #endif - if (CHECK_RIG_ARG(rig) || !chan) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* - * TODO: check validity of chan->channel_num - */ + if (CHECK_RIG_ARG(rig) || !chan) { + return -RIG_EINVAL; + } - rc = rig->caps; + /* + * TODO: check validity of chan->channel_num + */ - if (rc->set_channel) - return rc->set_channel(rig, chan); + rc = rig->caps; - /* - * if not available, emulate it - * Optional: get_vfo, set_vfo, - */ + if (rc->set_channel) { + return rc->set_channel(rig, chan); + } - vfo = chan->vfo; + /* + * if not available, emulate it + * Optional: get_vfo, set_vfo, + */ - if (vfo == RIG_VFO_CURR) - return generic_restore_channel(rig, chan); + vfo = chan->vfo; - /* any emulation requires set_mem() */ - if (vfo == RIG_VFO_MEM && !rc->set_mem) - return -RIG_ENAVAIL; + if (vfo == RIG_VFO_CURR) { + return generic_restore_channel(rig, chan); + } - can_emulate_by_vfo_mem = rc->set_vfo && - ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); + /* any emulation requires set_mem() */ + if (vfo == RIG_VFO_MEM && !rc->set_mem) { + return -RIG_ENAVAIL; + } - can_emulate_by_vfo_op = rc->vfo_op && - rig_has_vfo_op(rig, RIG_OP_FROM_VFO); + can_emulate_by_vfo_mem = rc->set_vfo && + ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); - if (!can_emulate_by_vfo_mem && !can_emulate_by_vfo_op) - return -RIG_ENTARGET; + can_emulate_by_vfo_op = rc->vfo_op && + rig_has_vfo_op(rig, RIG_OP_FROM_VFO); - curr_vfo = rig->state.current_vfo; - /* may be needed if the restore_channel has some side effects */ + if (!can_emulate_by_vfo_mem && !can_emulate_by_vfo_op) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + /* may be needed if the restore_channel has some side effects */ #ifdef PARANOID_CHANNEL_HANDLING - generic_save_channel(rig, &curr_chan); + generic_save_channel(rig, &curr_chan); #endif - if (vfo == RIG_VFO_MEM) - get_mem_status = rig_get_mem(rig, RIG_VFO_CURR, &curr_chan_num); + if (vfo == RIG_VFO_MEM) { + get_mem_status = rig_get_mem(rig, RIG_VFO_CURR, &curr_chan_num); + } - if (can_emulate_by_vfo_mem && curr_vfo != vfo) { - retcode = rig_set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - } + if (can_emulate_by_vfo_mem && curr_vfo != vfo) { + retcode = rig_set_vfo(rig, vfo); - if (vfo == RIG_VFO_MEM) - rig_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + if (retcode != RIG_OK) { + return retcode; + } + } - retcode = generic_restore_channel(rig, chan); + if (vfo == RIG_VFO_MEM) { + rig_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + } - if (!can_emulate_by_vfo_mem && can_emulate_by_vfo_op) { - retcode = rig_vfo_op(rig, RIG_VFO_CURR, RIG_OP_FROM_VFO); - if (retcode != RIG_OK) - return retcode; - } + retcode = generic_restore_channel(rig, chan); - /* restore current memory number */ - if (vfo == RIG_VFO_MEM && get_mem_status == RIG_OK) - rig_set_mem(rig, RIG_VFO_CURR, curr_chan_num); + if (!can_emulate_by_vfo_mem && can_emulate_by_vfo_op) { + retcode = rig_vfo_op(rig, RIG_VFO_CURR, RIG_OP_FROM_VFO); - if (can_emulate_by_vfo_mem) - rig_set_vfo(rig, curr_vfo); + if (retcode != RIG_OK) { + return retcode; + } + } + + /* restore current memory number */ + if (vfo == RIG_VFO_MEM && get_mem_status == RIG_OK) { + rig_set_mem(rig, RIG_VFO_CURR, curr_chan_num); + } + + if (can_emulate_by_vfo_mem) { + rig_set_vfo(rig, curr_vfo); + } #ifdef PARANOID_CHANNEL_HANDLING - generic_restore_channel(rig, &curr_chan); + generic_restore_channel(rig, &curr_chan); #endif - return retcode; + return retcode; } + /** * \brief get channel data - * \param rig The rig handle - * \param chan The location where to store the channel data + * \param rig The rig handle + * \param chan The location where to store the channel data * * Retrieves the data associated with a channel. This channel can either * be the state of a VFO specified by \a chan->vfo, or a memory channel @@ -605,7 +730,7 @@ int HAMLIB_API rig_set_channel(RIG *rig, const channel_t *chan) chan->channel_num = 10; err = rig_get_channel(rig, &chan); if (err != RIG_OK) - error("get_channel failed: %s", rigerror(err)); + error("get_channel failed: %s", rigerror(err)); \endcode * @@ -625,193 +750,223 @@ int HAMLIB_API rig_set_channel(RIG *rig, const channel_t *chan) */ int HAMLIB_API rig_get_channel(RIG *rig, channel_t *chan) { - struct rig_caps *rc; - int curr_chan_num, get_mem_status = RIG_OK; - vfo_t curr_vfo; - vfo_t vfo; /* requested vfo */ - int retcode; - int can_emulate_by_vfo_mem, can_emulate_by_vfo_op; + struct rig_caps *rc; + int curr_chan_num, get_mem_status = RIG_OK; + vfo_t curr_vfo; + vfo_t vfo; /* requested vfo */ + int retcode; + int can_emulate_by_vfo_mem, can_emulate_by_vfo_op; #ifdef PARANOID_CHANNEL_HANDLING - channel_t curr_chan; + channel_t curr_chan; #endif - if (CHECK_RIG_ARG(rig) || !chan) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* - * TODO: check validity of chan->channel_num - */ + if (CHECK_RIG_ARG(rig) || !chan) { + return -RIG_EINVAL; + } - rc = rig->caps; + /* + * TODO: check validity of chan->channel_num + */ - if (rc->get_channel) - return rc->get_channel(rig, chan); + rc = rig->caps; - /* - * if not available, emulate it - * Optional: get_vfo, set_vfo - * TODO: check return codes - */ - vfo = chan->vfo; - if (vfo == RIG_VFO_CURR) - return generic_save_channel(rig, chan); + if (rc->get_channel) { + return rc->get_channel(rig, chan); + } - /* any emulation requires set_mem() */ - if (vfo == RIG_VFO_MEM && !rc->set_mem) - return -RIG_ENAVAIL; + /* + * if not available, emulate it + * Optional: get_vfo, set_vfo + * TODO: check return codes + */ + vfo = chan->vfo; - can_emulate_by_vfo_mem = rc->set_vfo && - ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); + if (vfo == RIG_VFO_CURR) { + return generic_save_channel(rig, chan); + } - can_emulate_by_vfo_op = rc->vfo_op && - rig_has_vfo_op(rig, RIG_OP_TO_VFO); + /* any emulation requires set_mem() */ + if (vfo == RIG_VFO_MEM && !rc->set_mem) { + return -RIG_ENAVAIL; + } - if (!can_emulate_by_vfo_mem && !can_emulate_by_vfo_op) - return -RIG_ENTARGET; + can_emulate_by_vfo_mem = rc->set_vfo && + ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); - curr_vfo = rig->state.current_vfo; - /* may be needed if the restore_channel has some side effects */ + can_emulate_by_vfo_op = rc->vfo_op && + rig_has_vfo_op(rig, RIG_OP_TO_VFO); + + if (!can_emulate_by_vfo_mem && !can_emulate_by_vfo_op) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + /* may be needed if the restore_channel has some side effects */ #ifdef PARANOID_CHANNEL_HANDLING - generic_save_channel(rig, &curr_chan); + generic_save_channel(rig, &curr_chan); #endif - if (vfo == RIG_VFO_MEM) - get_mem_status = rig_get_mem(rig, RIG_VFO_CURR, &curr_chan_num); + if (vfo == RIG_VFO_MEM) { + get_mem_status = rig_get_mem(rig, RIG_VFO_CURR, &curr_chan_num); + } - if (can_emulate_by_vfo_mem && curr_vfo != vfo) { - retcode = rig_set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - } + if (can_emulate_by_vfo_mem && curr_vfo != vfo) { + retcode = rig_set_vfo(rig, vfo); - if (vfo == RIG_VFO_MEM) - rig_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + if (retcode != RIG_OK) { + return retcode; + } + } - if (!can_emulate_by_vfo_mem && can_emulate_by_vfo_op) { - retcode = rig_vfo_op(rig, RIG_VFO_CURR, RIG_OP_TO_VFO); - if (retcode != RIG_OK) - return retcode; - } + if (vfo == RIG_VFO_MEM) { + rig_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + } - retcode = generic_save_channel(rig, chan); + if (!can_emulate_by_vfo_mem && can_emulate_by_vfo_op) { + retcode = rig_vfo_op(rig, RIG_VFO_CURR, RIG_OP_TO_VFO); - /* restore current memory number */ - if (vfo == RIG_VFO_MEM && get_mem_status == RIG_OK) - rig_set_mem(rig, RIG_VFO_CURR, curr_chan_num); + if (retcode != RIG_OK) { + return retcode; + } + } - if (can_emulate_by_vfo_mem) - rig_set_vfo(rig, curr_vfo); + retcode = generic_save_channel(rig, chan); + + /* restore current memory number */ + if (vfo == RIG_VFO_MEM && get_mem_status == RIG_OK) { + rig_set_mem(rig, RIG_VFO_CURR, curr_chan_num); + } + + if (can_emulate_by_vfo_mem) { + rig_set_vfo(rig, curr_vfo); + } #ifdef PARANOID_CHANNEL_HANDLING - generic_restore_channel(rig, &curr_chan); + generic_restore_channel(rig, &curr_chan); #endif - return retcode; + return retcode; } #ifndef DOC_HIDDEN -int get_chan_all_cb_generic (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) +int get_chan_all_cb_generic(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) { - int i,j,retval; - chan_t *chan_list = rig->state.chan_list; - channel_t *chan; + int i, j, retval; + chan_t *chan_list = rig->state.chan_list; + channel_t *chan; - for (i=0; !RIG_IS_CHAN_END(chan_list[i]) && i < CHANLSTSIZ; i++) { + for (i = 0; !RIG_IS_CHAN_END(chan_list[i]) && i < CHANLSTSIZ; i++) { - /* - * setting chan to NULL means the application - * has to provide a struct where to store data - * future data for channel channel_num - */ - chan = NULL; - retval = chan_cb(rig, &chan, chan_list[i].start, chan_list, arg); - if (retval != RIG_OK) - return retval; - if (chan == NULL) - return -RIG_ENOMEM; + /* + * setting chan to NULL means the application + * has to provide a struct where to store data + * future data for channel channel_num + */ + chan = NULL; + retval = chan_cb(rig, &chan, chan_list[i].start, chan_list, arg); - for (j = chan_list[i].start; j <= chan_list[i].end; j++) { - int chan_next; + if (retval != RIG_OK) { + return retval; + } - chan->vfo = RIG_VFO_MEM; - chan->channel_num = j; + if (chan == NULL) { + return -RIG_ENOMEM; + } - /* - * TODO: if doesn't have rc->get_channel, special generic - */ - retval = rig_get_channel(rig, chan); + for (j = chan_list[i].start; j <= chan_list[i].end; j++) { + int chan_next; - if (retval == -RIG_ENAVAIL) { - /* - * empty channel - * - * Should it continue or call chan_cb with special arg? - */ - continue; - } + chan->vfo = RIG_VFO_MEM; + chan->channel_num = j; - if (retval != RIG_OK) - return retval; + /* + * TODO: if doesn't have rc->get_channel, special generic + */ + retval = rig_get_channel(rig, chan); - chan_next = j < chan_list[i].end ? j+1 : j; + if (retval == -RIG_ENAVAIL) { + /* + * empty channel + * + * Should it continue or call chan_cb with special arg? + */ + continue; + } - chan_cb(rig, &chan, chan_next, chan_list, arg); - } - } + if (retval != RIG_OK) { + return retval; + } - return RIG_OK; + chan_next = j < chan_list[i].end ? j + 1 : j; + + chan_cb(rig, &chan, chan_next, chan_list, arg); + } + } + + return RIG_OK; } -int set_chan_all_cb_generic (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) + +int set_chan_all_cb_generic(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) { - int i,j,retval; - chan_t *chan_list = rig->state.chan_list; - channel_t *chan; + int i, j, retval; + chan_t *chan_list = rig->state.chan_list; + channel_t *chan; - for (i=0; !RIG_IS_CHAN_END(chan_list[i]) && i < CHANLSTSIZ; i++) { + for (i = 0; !RIG_IS_CHAN_END(chan_list[i]) && i < CHANLSTSIZ; i++) { - for (j = chan_list[i].start; j <= chan_list[i].end; j++) { + for (j = chan_list[i].start; j <= chan_list[i].end; j++) { - chan_cb(rig, &chan, j, chan_list, arg); - chan->vfo = RIG_VFO_MEM; + chan_cb(rig, &chan, j, chan_list, arg); + chan->vfo = RIG_VFO_MEM; - retval = rig_set_channel(rig, chan); + retval = rig_set_channel(rig, chan); - if (retval != RIG_OK) - return retval; - } - } + if (retval != RIG_OK) { + return retval; + } + } + } - return RIG_OK; + return RIG_OK; } + struct map_all_s { - channel_t *chans; - const struct confparams *cfgps; - value_t *vals; + channel_t *chans; + const struct confparams *cfgps; + value_t *vals; }; + /* * chan_cb_t to be used for non cb get/set_all */ -static int map_chan (RIG *rig, channel_t **chan, int channel_num, const chan_t *chan_list, rig_ptr_t arg) +static int map_chan(RIG *rig, + channel_t **chan, + int channel_num, + const chan_t *chan_list, + rig_ptr_t arg) { - struct map_all_s *map_arg = (struct map_all_s*)arg; + struct map_all_s *map_arg = (struct map_all_s *)arg; - /* TODO: check channel_num within start-end of chan_list */ + /* TODO: check channel_num within start-end of chan_list */ - *chan = &map_arg->chans[channel_num]; + *chan = &map_arg->chans[channel_num]; - return RIG_OK; + return RIG_OK; } -#endif /* DOC_HIDDEN */ +#endif /* DOC_HIDDEN */ + /** * \brief set all channel data, by callback - * \param rig The rig handle - * \param chan_cb Pointer to a callback function to provide channel data - * \param arg Arbitrary argument passed back to \a chan_cb + * \param rig The rig handle + * \param chan_cb Pointer to a callback function to provide channel data + * \param arg Arbitrary argument passed back to \a chan_cb * * Write the data associated with a all the memory channels. * This is the preferred method to support clonable rigs. @@ -822,31 +977,35 @@ static int map_chan (RIG *rig, channel_t **chan, int channel_num, const chan_t * * * \sa rig_set_chan_all(), rig_get_chan_all_cb() */ -int HAMLIB_API rig_set_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) +int HAMLIB_API rig_set_chan_all_cb(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) { - struct rig_caps *rc; - int retval; + struct rig_caps *rc; + int retval; - if (CHECK_RIG_ARG(rig) || !chan_cb) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; + if (CHECK_RIG_ARG(rig) || !chan_cb) { + return -RIG_EINVAL; + } - if (rc->set_chan_all_cb) - return rc->set_chan_all_cb(rig, chan_cb, arg); + rc = rig->caps; + if (rc->set_chan_all_cb) { + return rc->set_chan_all_cb(rig, chan_cb, arg); + } - /* if not available, emulate it */ - retval = set_chan_all_cb_generic (rig, chan_cb, arg); + /* if not available, emulate it */ + retval = set_chan_all_cb_generic(rig, chan_cb, arg); - return retval; + return retval; } + /** * \brief get all channel data, by callback - * \param rig The rig handle - * \param chan_cb Pointer to a callback function to retrieve channel data - * \param arg Arbitrary argument passed back to \a chan_cb + * \param rig The rig handle + * \param chan_cb Pointer to a callback function to retrieve channel data + * \param arg Arbitrary argument passed back to \a chan_cb * * Retrieves the data associated with a all the memory channels. * This is the preferred method to support clonable rigs. @@ -862,31 +1021,35 @@ int HAMLIB_API rig_set_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) * * \sa rig_get_chan_all(), rig_set_chan_all_cb() */ -int HAMLIB_API rig_get_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) +int HAMLIB_API rig_get_chan_all_cb(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) { - struct rig_caps *rc; - int retval; + struct rig_caps *rc; + int retval; - if (CHECK_RIG_ARG(rig) || !chan_cb) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; + if (CHECK_RIG_ARG(rig) || !chan_cb) { + return -RIG_EINVAL; + } - if (rc->get_chan_all_cb) - return rc->get_chan_all_cb(rig, chan_cb, arg); + rc = rig->caps; + + if (rc->get_chan_all_cb) { + return rc->get_chan_all_cb(rig, chan_cb, arg); + } - /* if not available, emulate it */ - retval = get_chan_all_cb_generic (rig, chan_cb, arg); + /* if not available, emulate it */ + retval = get_chan_all_cb_generic(rig, chan_cb, arg); - return retval; + return retval; } /** * \brief set all channel data - * \param rig The rig handle - * \param chans The location of data to set for all channels + * \param rig The rig handle + * \param chans The location of data to set for all channels * * Write the data associated with all the memory channels. * @@ -896,33 +1059,37 @@ int HAMLIB_API rig_get_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) * * \sa rig_set_chan_all_cb(), rig_get_chan_all() */ -int HAMLIB_API rig_set_chan_all (RIG *rig, const channel_t chans[]) +int HAMLIB_API rig_set_chan_all(RIG *rig, const channel_t chans[]) { - struct rig_caps *rc; - struct map_all_s map_arg; - int retval; + struct rig_caps *rc; + struct map_all_s map_arg; + int retval; - if (CHECK_RIG_ARG(rig) || !chans) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; - map_arg.chans = (channel_t *) chans; + if (CHECK_RIG_ARG(rig) || !chans) { + return -RIG_EINVAL; + } - if (rc->set_chan_all_cb) - return rc->set_chan_all_cb(rig, map_chan, (rig_ptr_t)&map_arg); + rc = rig->caps; + map_arg.chans = (channel_t *) chans; + + if (rc->set_chan_all_cb) { + return rc->set_chan_all_cb(rig, map_chan, (rig_ptr_t)&map_arg); + } - /* if not available, emulate it */ - retval = set_chan_all_cb_generic (rig, map_chan, (rig_ptr_t)&map_arg); + /* if not available, emulate it */ + retval = set_chan_all_cb_generic(rig, map_chan, (rig_ptr_t)&map_arg); - return retval; + return retval; } /** * \brief get all channel data - * \param rig The rig handle - * \param chans The location where to store all the channel data + * \param rig The rig handle + * \param chans The location where to store all the channel data * * Retrieves the data associated with all the memory channels. * @@ -932,76 +1099,90 @@ int HAMLIB_API rig_set_chan_all (RIG *rig, const channel_t chans[]) * * \sa rig_get_chan_all_cb(), rig_set_chan_all() */ -int HAMLIB_API rig_get_chan_all (RIG *rig, channel_t chans[]) +int HAMLIB_API rig_get_chan_all(RIG *rig, channel_t chans[]) { - struct rig_caps *rc; - struct map_all_s map_arg; - int retval; + struct rig_caps *rc; + struct map_all_s map_arg; + int retval; - if (CHECK_RIG_ARG(rig) || !chans) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; - map_arg.chans = chans; + if (CHECK_RIG_ARG(rig) || !chans) { + return -RIG_EINVAL; + } - if (rc->get_chan_all_cb) - return rc->get_chan_all_cb(rig, map_chan, (rig_ptr_t)&map_arg); + rc = rig->caps; + map_arg.chans = chans; - /* - * if not available, emulate it - * - * TODO: save_current_state, restore_current_state - */ - retval = get_chan_all_cb_generic (rig, map_chan, (rig_ptr_t)&map_arg); + if (rc->get_chan_all_cb) { + return rc->get_chan_all_cb(rig, map_chan, (rig_ptr_t)&map_arg); + } - return retval; + /* + * if not available, emulate it + * + * TODO: save_current_state, restore_current_state + */ + retval = get_chan_all_cb_generic(rig, map_chan, (rig_ptr_t)&map_arg); + + return retval; } -int HAMLIB_API rig_copy_channel(RIG *rig, channel_t *dest, const channel_t *src) + +int HAMLIB_API rig_copy_channel(RIG *rig, + channel_t *dest, + const channel_t *src) { - struct ext_list *saved_ext_levels; - int i; + struct ext_list *saved_ext_levels; + int i; - /* TODO: ext_levels[] of different sizes */ - for (i=0; !RIG_IS_EXT_END(src->ext_levels[i]) && - !RIG_IS_EXT_END(dest->ext_levels[i]); i++) { - dest->ext_levels[i] = src->ext_levels[i]; - } + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - saved_ext_levels = dest->ext_levels; - memcpy(dest, src, sizeof(channel_t)); - dest->ext_levels = saved_ext_levels; + /* TODO: ext_levels[] of different sizes */ + for (i = 0; !RIG_IS_EXT_END(src->ext_levels[i]) + && !RIG_IS_EXT_END(dest->ext_levels[i]); i++) { + dest->ext_levels[i] = src->ext_levels[i]; + } - return RIG_OK; + saved_ext_levels = dest->ext_levels; + memcpy(dest, src, sizeof(channel_t)); + dest->ext_levels = saved_ext_levels; + + return RIG_OK; } #ifndef DOC_HIDDEN -static int map_parm (RIG *rig, const struct confparams *cfgps, value_t *value, - rig_ptr_t arg) + + +static int map_parm(RIG *rig, const struct confparams *cfgps, value_t *value, + rig_ptr_t arg) { - return -RIG_ENIMPL; + return -RIG_ENIMPL; } -int get_parm_all_cb_generic (RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, - rig_ptr_t vals) + +int get_parm_all_cb_generic(RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, + rig_ptr_t vals) { - return -RIG_ENIMPL; + return -RIG_ENIMPL; } -int set_parm_all_cb_generic (RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, - rig_ptr_t vals) + +int set_parm_all_cb_generic(RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, + rig_ptr_t vals) { - return -RIG_ENIMPL; + return -RIG_ENIMPL; } -#endif /* DOC_HIDDEN */ +#endif /* DOC_HIDDEN */ + /** * \brief set all channel and non-channel data by call-back - * \param rig The rig handle - * \param chan_cb The callback for channel data - * \param parm_cb The callback for non-channel(aka parm) data - * \param arg Cookie passed to \a chan_cb and \a parm_cb + * \param rig The rig handle + * \param chan_cb The callback for channel data + * \param parm_cb The callback for non-channel(aka parm) data + * \param arg Cookie passed to \a chan_cb and \a parm_cb * * Writes the data associated with all the memory channels, * and rigs memory parameters, by callback. @@ -1014,42 +1195,55 @@ int set_parm_all_cb_generic (RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, * \sa rig_get_mem_all_cb(), rig_set_mem_all() * \todo finish coding and testing of mem_all functions */ -int HAMLIB_API rig_set_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t arg) +int HAMLIB_API rig_set_mem_all_cb(RIG *rig, + chan_cb_t chan_cb, + confval_cb_t parm_cb, + rig_ptr_t arg) { - struct rig_caps *rc; - int retval; + struct rig_caps *rc; + int retval; - if (CHECK_RIG_ARG(rig) || !chan_cb) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; + if (CHECK_RIG_ARG(rig) || !chan_cb) { + return -RIG_EINVAL; + } - if (rc->set_mem_all_cb) - return rc->set_mem_all_cb(rig, chan_cb, parm_cb, arg); + rc = rig->caps; + + if (rc->set_mem_all_cb) { + return rc->set_mem_all_cb(rig, chan_cb, parm_cb, arg); + } - /* if not available, emulate it */ - retval = rig_set_chan_all_cb (rig, chan_cb, arg); - if (retval != RIG_OK) - return retval; + /* if not available, emulate it */ + retval = rig_set_chan_all_cb(rig, chan_cb, arg); + + if (retval != RIG_OK) { + return retval; + } #if 0 - retval = rig_set_parm_all_cb (rig, parm_cb, arg); - if (retval != RIG_OK) - return retval; + retval = rig_set_parm_all_cb(rig, parm_cb, arg); + + if (retval != RIG_OK) { + return retval; + } + #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif - return retval; + return retval; } + /** * \brief get all channel and non-channel data by call-back - * \param rig The rig handle - * \param chan_cb The callback for channel data - * \param parm_cb The callback for non-channel(aka parm) data - * \param arg Cookie passed to \a chan_cb and \a parm_cb + * \param rig The rig handle + * \param chan_cb The callback for channel data + * \param parm_cb The callback for non-channel(aka parm) data + * \param arg Cookie passed to \a chan_cb and \a parm_cb * * Retrieves the data associated with all the memory channels, * and rigs memory parameters, by callback. @@ -1064,42 +1258,54 @@ int HAMLIB_API rig_set_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t par * \todo get all parm's * \todo finish coding and testing of mem_all functions */ -int HAMLIB_API rig_get_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t arg) +int HAMLIB_API rig_get_mem_all_cb(RIG *rig, + chan_cb_t chan_cb, + confval_cb_t parm_cb, + rig_ptr_t arg) { - struct rig_caps *rc; - int retval; + struct rig_caps *rc; + int retval; - if (CHECK_RIG_ARG(rig) || !chan_cb) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; + if (CHECK_RIG_ARG(rig) || !chan_cb) { + return -RIG_EINVAL; + } - if (rc->get_mem_all_cb) - return rc->get_mem_all_cb(rig, chan_cb, parm_cb, arg); + rc = rig->caps; + if (rc->get_mem_all_cb) { + return rc->get_mem_all_cb(rig, chan_cb, parm_cb, arg); + } - /* if not available, emulate it */ - retval = rig_get_chan_all_cb (rig, chan_cb, arg); - if (retval != RIG_OK) - return retval; + /* if not available, emulate it */ + retval = rig_get_chan_all_cb(rig, chan_cb, arg); + + if (retval != RIG_OK) { + return retval; + } #if 0 - retval = rig_get_parm_cb (rig, parm_cb, arg); - if (retval != RIG_OK) - return retval; + retval = rig_get_parm_cb(rig, parm_cb, arg); + + if (retval != RIG_OK) { + return retval; + } + #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif - return retval; + return retval; } + /** * \brief set all channel and non-channel data - * \param rig The rig handle - * \param chans Channel data - * \param cfgps ?? - * \param vals ?? + * \param rig The rig handle + * \param chans Channel data + * \param cfgps ?? + * \param vals ?? * * Writes the data associated with all the memory channels, * and rigs memory parameters. @@ -1113,46 +1319,58 @@ int HAMLIB_API rig_get_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t par * \todo set all parm's * \todo finish coding and testing of mem_all functions */ -int HAMLIB_API rig_set_mem_all (RIG *rig, const channel_t chans[], const struct confparams cfgps[], const value_t vals[]) +int HAMLIB_API rig_set_mem_all(RIG *rig, + const channel_t chans[], + const struct confparams cfgps[], + const value_t vals[]) { - struct rig_caps *rc; - int retval; - struct map_all_s mem_all_arg; + struct rig_caps *rc; + int retval; + struct map_all_s mem_all_arg; - if (CHECK_RIG_ARG(rig) || !chans || !cfgps || !vals) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; - mem_all_arg.chans = (channel_t *) chans; - mem_all_arg.cfgps = cfgps; - mem_all_arg.vals = (value_t *) vals; + if (CHECK_RIG_ARG(rig) || !chans || !cfgps || !vals) { + return -RIG_EINVAL; + } - if (rc->set_mem_all_cb) - return rc->set_mem_all_cb(rig, map_chan, map_parm, - (rig_ptr_t)&mem_all_arg); + rc = rig->caps; + mem_all_arg.chans = (channel_t *) chans; + mem_all_arg.cfgps = cfgps; + mem_all_arg.vals = (value_t *) vals; - /* if not available, emulate it */ - retval = rig_set_chan_all (rig, chans); - if (retval != RIG_OK) - return retval; + if (rc->set_mem_all_cb) + return rc->set_mem_all_cb(rig, map_chan, map_parm, + (rig_ptr_t)&mem_all_arg); + + /* if not available, emulate it */ + retval = rig_set_chan_all(rig, chans); + + if (retval != RIG_OK) { + return retval; + } #if 0 - retval = rig_set_parm_all (rig, parms); - if (retval != RIG_OK) - return retval; + retval = rig_set_parm_all(rig, parms); + + if (retval != RIG_OK) { + return retval; + } + #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif - return retval; + return retval; } + /** * \brief get all channel and non-channel data - * \param rig The rig handle - * \param chans Array of channels where to store the data - * \param cfgps Array of config parameters to retrieve - * \param vals Array of values where to store the data + * \param rig The rig handle + * \param chans Array of channels where to store the data + * \param cfgps Array of config parameters to retrieve + * \param vals Array of values where to store the data * * Retrieves the data associated with all the memory channels, * and rigs memory parameters. @@ -1165,43 +1383,53 @@ int HAMLIB_API rig_set_mem_all (RIG *rig, const channel_t chans[], const struct * \sa rig_get_mem_all(), rig_set_mem_all_cb() * \todo finish coding and testing of mem_all functions */ -int HAMLIB_API rig_get_mem_all (RIG *rig, channel_t chans[], const struct confparams cfgps[], value_t vals[]) +int HAMLIB_API rig_get_mem_all(RIG *rig, + channel_t chans[], + const struct confparams cfgps[], + value_t vals[]) { - struct rig_caps *rc; - int retval; - struct map_all_s mem_all_arg; + struct rig_caps *rc; + int retval; + struct map_all_s mem_all_arg; - if (CHECK_RIG_ARG(rig) || !chans || !cfgps || !vals) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rc = rig->caps; - mem_all_arg.chans = chans; - mem_all_arg.cfgps = cfgps; - mem_all_arg.vals = vals; + if (CHECK_RIG_ARG(rig) || !chans || !cfgps || !vals) { + return -RIG_EINVAL; + } - if (rc->get_mem_all_cb) - return rc->get_mem_all_cb(rig, map_chan, map_parm, - (rig_ptr_t)&mem_all_arg); + rc = rig->caps; + mem_all_arg.chans = chans; + mem_all_arg.cfgps = cfgps; + mem_all_arg.vals = vals; - /* - * if not available, emulate it - * - * TODO: save_current_state, restore_current_state - */ - retval = rig_get_chan_all (rig, chans); - if (retval != RIG_OK) - return retval; + if (rc->get_mem_all_cb) + return rc->get_mem_all_cb(rig, map_chan, map_parm, + (rig_ptr_t)&mem_all_arg); - retval = get_parm_all_cb_generic (rig, map_parm, (rig_ptr_t)cfgps, - (rig_ptr_t)vals); + /* + * if not available, emulate it + * + * TODO: save_current_state, restore_current_state + */ + retval = rig_get_chan_all(rig, chans); - return retval; + if (retval != RIG_OK) { + return retval; + } + + retval = get_parm_all_cb_generic(rig, map_parm, + (rig_ptr_t)cfgps, + (rig_ptr_t)vals); + + return retval; } + /** * \brief lookup the memory type and capabilities - * \param rig The rig handle - * \param ch The memory channel number + * \param rig The rig handle + * \param ch The memory channel number * * Lookup the memory type and capabilities associated with a channel number. * If \a ch equals RIG_MEM_CAPS_ALL, then a union of all the mem_caps sets @@ -1211,54 +1439,59 @@ int HAMLIB_API rig_get_mem_all (RIG *rig, channel_t chans[], const struct confpa * otherwise a NULL pointer, most probably because of incorrect channel number * or buggy backend. */ - -const chan_t * HAMLIB_API rig_lookup_mem_caps(RIG *rig, int ch) +const chan_t *HAMLIB_API rig_lookup_mem_caps(RIG *rig, int ch) { - chan_t *chan_list; - static chan_t chan_list_all; - int i, j; + chan_t *chan_list; + static chan_t chan_list_all; + int i, j; - if (CHECK_RIG_ARG(rig)) - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (ch == RIG_MEM_CAPS_ALL) - { - memset (&chan_list_all, 0, sizeof(chan_list_all)); - chan_list = rig->state.chan_list; - chan_list_all.start = chan_list[0].start; - chan_list_all.type = RIG_MTYPE_NONE; /* meaningless */ - for (i=0; istate.chan_list; + chan_list_all.start = chan_list[0].start; + chan_list_all.type = RIG_MTYPE_NONE; /* meaningless */ - /* til the end, most probably meaningless */ - chan_list_all.end = chan_list[i].end; - } + for (i = 0; i < CHANLSTSIZ && !RIG_IS_CHAN_END(chan_list[i]); i++) { - return &chan_list_all; - } + unsigned char *p1, *p2; + p1 = (unsigned char *)&chan_list_all.mem_caps; + p2 = (unsigned char *)&chan_list[i].mem_caps; - chan_list = rig->state.chan_list; - for (i=0; i= chan_list[i].start && ch <= chan_list[i].end) { - return &chan_list[i]; - } - } + /* It's kind of hackish, we just want to do update set with: + * chan_list_all.mem_caps |= chan_list[i].mem_caps + */ + for (j = 0; j < sizeof(channel_cap_t); j++) { + p1[j] |= p2[j]; + } - return NULL; + /* til the end, most probably meaningless */ + chan_list_all.end = chan_list[i].end; + } + + return &chan_list_all; + } + + chan_list = rig->state.chan_list; + + for (i = 0; i < CHANLSTSIZ && !RIG_IS_CHAN_END(chan_list[i]); i++) { + if (ch >= chan_list[i].start && ch <= chan_list[i].end) { + return &chan_list[i]; + } + } + + return NULL; } + /** * \brief get memory channel count - * \param rig The rig handle + * \param rig The rig handle * * Get the total memory channel count, computed from the rig caps * @@ -1266,20 +1499,23 @@ const chan_t * HAMLIB_API rig_lookup_mem_caps(RIG *rig, int ch) */ int HAMLIB_API rig_mem_count(RIG *rig) { - const chan_t *chan_list; - int i, count; + const chan_t *chan_list; + int i, count; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - chan_list = rig->state.chan_list; - count = 0; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - for (i=0; istate.chan_list; + count = 0; - return count; + for (i = 0; i < CHANLSTSIZ && !RIG_IS_CHAN_END(chan_list[i]); i++) { + count += chan_list[i].end - chan_list[i].start + 1; + } + + return count; } /*! @} */ diff --git a/src/misc.c b/src/misc.c index 813aa89dd..b11da8cae 100644 --- a/src/misc.c +++ b/src/misc.c @@ -51,6 +51,7 @@ #include "misc.h" + /** * \brief Convert from binary to 4-bit BCD digits, little-endian * \param bcd_data @@ -71,29 +72,35 @@ * * \sa to_bcd_be */ -unsigned char * HAMLIB_API to_bcd(unsigned char bcd_data[], unsigned long long freq, unsigned bcd_len) +unsigned char *HAMLIB_API to_bcd(unsigned char bcd_data[], + unsigned long long freq, + unsigned bcd_len) { - int i; - unsigned char a; + int i; + unsigned char a; - /* '450'/4-> 5,0;0,4 */ - /* '450'/3-> 5,0;x,4 */ + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; i < bcd_len/2; i++) { - a = freq%10; - freq /= 10; - a |= (freq%10)<<4; - freq /= 10; - bcd_data[i] = a; - } - if (bcd_len&1) { - bcd_data[i] &= 0xf0; - bcd_data[i] |= freq%10; /* NB: high nibble is left uncleared */ - } + /* '450'/4-> 5,0;0,4 */ + /* '450'/3-> 5,0;x,4 */ - return bcd_data; + for (i = 0; i < bcd_len / 2; i++) { + a = freq % 10; + freq /= 10; + a |= (freq % 10) << 4; + freq /= 10; + bcd_data[i] = a; + } + + if (bcd_len & 1) { + bcd_data[i] &= 0xf0; + bcd_data[i] |= freq % 10; /* NB: high nibble is left uncleared */ + } + + return bcd_data; } + /** * \brief Convert BCD digits, little-endian, to a long long (e.g. frequency in Hz) * \param bcd_data @@ -111,24 +118,29 @@ unsigned char * HAMLIB_API to_bcd(unsigned char bcd_data[], unsigned long long f * * \sa from_bcd_be */ -unsigned long long HAMLIB_API from_bcd(const unsigned char bcd_data[], unsigned bcd_len) +unsigned long long HAMLIB_API from_bcd(const unsigned char bcd_data[], + unsigned bcd_len) { - int i; - freq_t f = 0; + int i; + freq_t f = 0; - if (bcd_len&1) - f = bcd_data[bcd_len/2] & 0x0f; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=(bcd_len/2)-1; i >= 0; i--) { - f *= 10; - f += bcd_data[i]>>4; - f *= 10; - f += bcd_data[i] & 0x0f; - } + if (bcd_len & 1) { + f = bcd_data[bcd_len / 2] & 0x0f; + } - return f; + for (i = (bcd_len / 2) - 1; i >= 0; i--) { + f *= 10; + f += bcd_data[i] >> 4; + f *= 10; + f += bcd_data[i] & 0x0f; + } + + return f; } + /** * \brief Convert from binary to 4-bit BCD digits, big-endian * \param bcd_data @@ -141,30 +153,37 @@ unsigned long long HAMLIB_API from_bcd(const unsigned char bcd_data[], unsigned * * \sa to_bcd */ -unsigned char * HAMLIB_API to_bcd_be(unsigned char bcd_data[], unsigned long long freq, unsigned bcd_len) +unsigned char *HAMLIB_API to_bcd_be(unsigned char bcd_data[], + unsigned long long freq, + unsigned bcd_len) { - int i; - unsigned char a; + int i; + unsigned char a; - /* '450'/4 -> 0,4;5,0 */ - /* '450'/3 -> 4,5;0,x */ + /* '450'/4 -> 0,4;5,0 */ + /* '450'/3 -> 4,5;0,x */ - if (bcd_len&1) { - bcd_data[bcd_len/2] &= 0x0f; - bcd_data[bcd_len/2] |= (freq%10)<<4; /* NB: low nibble is left uncleared */ - freq /= 10; - } - for (i=(bcd_len/2)-1; i >= 0; i--) { - a = freq%10; - freq /= 10; - a |= (freq%10)<<4; - freq /= 10; - bcd_data[i] = a; - } + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return bcd_data; + if (bcd_len & 1) { + bcd_data[bcd_len / 2] &= 0x0f; + bcd_data[bcd_len / 2] |= (freq % 10) << + 4; /* NB: low nibble is left uncleared */ + freq /= 10; + } + + for (i = (bcd_len / 2) - 1; i >= 0; i--) { + a = freq % 10; + freq /= 10; + a |= (freq % 10) << 4; + freq /= 10; + bcd_data[i] = a; + } + + return bcd_data; } + /** * \brief Convert 4-bit BCD digits to binary, big-endian * \param bcd_data @@ -176,23 +195,27 @@ unsigned char * HAMLIB_API to_bcd_be(unsigned char bcd_data[], unsigned long lon * * \sa from_bcd */ -unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], unsigned bcd_len) +unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], + unsigned bcd_len) { - int i; - freq_t f = 0; + int i; + freq_t f = 0; - for (i=0; i < bcd_len/2; i++) { - f *= 10; - f += bcd_data[i]>>4; - f *= 10; - f += bcd_data[i] & 0x0f; - } - if (bcd_len&1) { - f *= 10; - f += bcd_data[bcd_len/2]>>4; - } + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return f; + for (i = 0; i < bcd_len / 2; i++) { + f *= 10; + f += bcd_data[i] >> 4; + f *= 10; + f += bcd_data[i] & 0x0f; + } + + if (bcd_len & 1) { + f *= 10; + f += bcd_data[bcd_len / 2] >> 4; + } + + return f; } @@ -200,6 +223,7 @@ unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], unsign #define llabs(a) ((a)<0?-(a):(a)) #endif + /** * \brief Pretty print a frequency * \param str for result (may need up to 17 char) @@ -211,26 +235,29 @@ unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], unsign */ int HAMLIB_API sprintf_freq(char *str, freq_t freq) { - double f; - char *hz; + double f; + char *hz; - if (llabs(freq) >= GHz(1)) { - hz = "GHz"; - f = (double)freq/GHz(1); - } else if (llabs(freq) >= MHz(1)) { - hz = "MHz"; - f = (double)freq/MHz(1); - } else if (llabs(freq) >= kHz(1)) { - hz = "kHz"; - f = (double)freq/kHz(1); - } else { - hz = "Hz"; - f = (double)freq; - } + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return sprintf (str, "%g %s", f, hz); + if (llabs(freq) >= GHz(1)) { + hz = "GHz"; + f = (double)freq / GHz(1); + } else if (llabs(freq) >= MHz(1)) { + hz = "MHz"; + f = (double)freq / MHz(1); + } else if (llabs(freq) >= kHz(1)) { + hz = "kHz"; + f = (double)freq / kHz(1); + } else { + hz = "Hz"; + f = (double)freq; + } + + return sprintf(str, "%g %s", f, hz); } + /** * \brief Convert enum RIG_STATUS_... to printable string * \param status RIG_STATUS_?? @@ -238,49 +265,57 @@ int HAMLIB_API sprintf_freq(char *str, freq_t freq) */ const char * HAMLIB_API rig_strstatus(enum rig_status_e status) { - switch (status) { - case RIG_STATUS_ALPHA: - return "Alpha"; - case RIG_STATUS_UNTESTED: - return "Untested"; - case RIG_STATUS_BETA: - return "Beta"; - case RIG_STATUS_STABLE: - return "Stable"; - case RIG_STATUS_BUGGY: - return "Buggy"; - } - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + switch (status) { + case RIG_STATUS_ALPHA: + return "Alpha"; + + case RIG_STATUS_UNTESTED: + return "Untested"; + + case RIG_STATUS_BETA: + return "Beta"; + + case RIG_STATUS_STABLE: + return "Stable"; + + case RIG_STATUS_BUGGY: + return "Buggy"; + } + + return ""; } static struct { - rmode_t mode; - const char *str; + rmode_t mode; + const char *str; } mode_str[] = { - { RIG_MODE_AM, "AM" }, - { RIG_MODE_CW, "CW" }, - { RIG_MODE_USB, "USB" }, - { RIG_MODE_LSB, "LSB" }, - { RIG_MODE_RTTY, "RTTY" }, - { RIG_MODE_FM, "FM" }, - { RIG_MODE_WFM, "WFM" }, - { RIG_MODE_CWR, "CWR" }, - { RIG_MODE_RTTYR, "RTTYR" }, - { RIG_MODE_AMS, "AMS" }, - { RIG_MODE_PKTLSB, "PKTLSB" }, - { RIG_MODE_PKTUSB, "PKTUSB" }, - { RIG_MODE_PKTFM, "PKTFM" }, - { RIG_MODE_ECSSUSB, "ECSSUSB" }, - { RIG_MODE_ECSSLSB, "ECSSLSB" }, - { RIG_MODE_FAX, "FAX" }, - { RIG_MODE_SAM, "SAM" }, - { RIG_MODE_SAL, "SAL" }, - { RIG_MODE_SAH, "SAH" }, - { RIG_MODE_DSB, "DSB"}, - { RIG_MODE_NONE, "" }, + { RIG_MODE_AM, "AM" }, + { RIG_MODE_CW, "CW" }, + { RIG_MODE_USB, "USB" }, + { RIG_MODE_LSB, "LSB" }, + { RIG_MODE_RTTY, "RTTY" }, + { RIG_MODE_FM, "FM" }, + { RIG_MODE_WFM, "WFM" }, + { RIG_MODE_CWR, "CWR" }, + { RIG_MODE_RTTYR, "RTTYR" }, + { RIG_MODE_AMS, "AMS" }, + { RIG_MODE_PKTLSB, "PKTLSB" }, + { RIG_MODE_PKTUSB, "PKTUSB" }, + { RIG_MODE_PKTFM, "PKTFM" }, + { RIG_MODE_ECSSUSB, "ECSSUSB" }, + { RIG_MODE_ECSSLSB, "ECSSLSB" }, + { RIG_MODE_FAX, "FAX" }, + { RIG_MODE_SAM, "SAM" }, + { RIG_MODE_SAL, "SAL" }, + { RIG_MODE_SAH, "SAH" }, + { RIG_MODE_DSB, "DSB"}, + { RIG_MODE_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_MODE * \param s input alpha string @@ -290,14 +325,19 @@ static struct { */ rmode_t HAMLIB_API rig_parse_mode(const char *s) { - int i; + int i; - for (i=0 ; mode_str[i].str[0] != '\0'; i++) - if (!strcmp(s, mode_str[i].str)) - return mode_str[i].mode; - return RIG_MODE_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (i = 0 ; mode_str[i].str[0] != '\0'; i++) + if (!strcmp(s, mode_str[i].str)) { + return mode_str[i].mode; + } + + return RIG_MODE_NONE; } + /** * \brief Convert enum RIG_MODE to alpha string * \param mode RIG_MODE_... @@ -307,35 +347,41 @@ rmode_t HAMLIB_API rig_parse_mode(const char *s) */ const char * HAMLIB_API rig_strrmode(rmode_t mode) { - int i; + int i; - if (mode == RIG_MODE_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0 ; mode_str[i].str[0] != '\0'; i++) - if (mode == mode_str[i].mode) - return mode_str[i].str; + if (mode == RIG_MODE_NONE) { + return ""; + } - return ""; + for (i = 0 ; mode_str[i].str[0] != '\0'; i++) + if (mode == mode_str[i].mode) { + return mode_str[i].str; + } + + return ""; } + static struct { - vfo_t vfo; - const char *str; + vfo_t vfo; + const char *str; } vfo_str[] = { - { RIG_VFO_A, "VFOA" }, - { RIG_VFO_B, "VFOB" }, - { RIG_VFO_C, "VFOC" }, - { RIG_VFO_CURR, "currVFO" }, - { RIG_VFO_MEM, "MEM" }, - { RIG_VFO_VFO, "VFO" }, - { RIG_VFO_TX, "TX" }, - { RIG_VFO_RX, "RX" }, - { RIG_VFO_MAIN, "Main" }, - { RIG_VFO_SUB, "Sub" }, - { RIG_VFO_NONE, "" }, + { RIG_VFO_A, "VFOA" }, + { RIG_VFO_B, "VFOB" }, + { RIG_VFO_C, "VFOC" }, + { RIG_VFO_CURR, "currVFO" }, + { RIG_VFO_MEM, "MEM" }, + { RIG_VFO_VFO, "VFO" }, + { RIG_VFO_TX, "TX" }, + { RIG_VFO_RX, "RX" }, + { RIG_VFO_MAIN, "Main" }, + { RIG_VFO_SUB, "Sub" }, + { RIG_VFO_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_VFO_... * \param s input alpha string @@ -345,14 +391,19 @@ static struct { */ vfo_t HAMLIB_API rig_parse_vfo(const char *s) { - int i; + int i; - for (i=0 ; vfo_str[i].str[0] != '\0'; i++) - if (!strcmp(s, vfo_str[i].str)) - return vfo_str[i].vfo; - return RIG_VFO_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (i = 0 ; vfo_str[i].str[0] != '\0'; i++) + if (!strcmp(s, vfo_str[i].str)) { + return vfo_str[i].vfo; + } + + return RIG_VFO_NONE; } + /** * \brief Convert enum RIG_VFO_... to alpha string * \param vfo RIG_VFO_... @@ -362,57 +413,63 @@ vfo_t HAMLIB_API rig_parse_vfo(const char *s) */ const char * HAMLIB_API rig_strvfo(vfo_t vfo) { - int i; + int i; - if (vfo == RIG_VFO_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0 ; vfo_str[i].str[0] != '\0'; i++) - if (vfo == vfo_str[i].vfo) - return vfo_str[i].str; + if (vfo == RIG_VFO_NONE) { + return ""; + } - return ""; + for (i = 0 ; vfo_str[i].str[0] != '\0'; i++) + if (vfo == vfo_str[i].vfo) { + return vfo_str[i].str; + } + + return ""; } + static struct { - setting_t func; - const char *str; + setting_t func; + const char *str; } func_str[] = { - { RIG_FUNC_FAGC, "FAGC" }, - { RIG_FUNC_NB, "NB" }, - { RIG_FUNC_COMP, "COMP" }, - { RIG_FUNC_VOX, "VOX" }, - { RIG_FUNC_TONE, "TONE" }, - { RIG_FUNC_TSQL, "TSQL" }, - { RIG_FUNC_SBKIN, "SBKIN" }, - { RIG_FUNC_FBKIN, "FBKIN" }, - { RIG_FUNC_ANF, "ANF" }, - { RIG_FUNC_NR, "NR" }, - { RIG_FUNC_AIP, "AIP" }, - { RIG_FUNC_APF, "APF" }, - { RIG_FUNC_MON, "MON" }, - { RIG_FUNC_MN, "MN" }, - { RIG_FUNC_RF, "RF" }, - { RIG_FUNC_ARO, "ARO" }, - { RIG_FUNC_LOCK, "LOCK" }, - { RIG_FUNC_MUTE, "MUTE" }, - { RIG_FUNC_VSC, "VSC" }, - { RIG_FUNC_REV, "REV" }, - { RIG_FUNC_SQL, "SQL" }, - { RIG_FUNC_ABM, "ABM" }, - { RIG_FUNC_BC, "BC" }, - { RIG_FUNC_MBC, "MBC" }, - { RIG_FUNC_RIT, "RIT" }, - { RIG_FUNC_AFC, "AFC" }, - { RIG_FUNC_SATMODE, "SATMODE" }, - { RIG_FUNC_SCOPE, "SCOPE" }, - { RIG_FUNC_RESUME, "RESUME" }, - { RIG_FUNC_TBURST, "TBURST" }, - { RIG_FUNC_TUNER, "TUNER" }, - { RIG_FUNC_XIT, "XIT" }, - { RIG_FUNC_NONE, "" }, + { RIG_FUNC_FAGC, "FAGC" }, + { RIG_FUNC_NB, "NB" }, + { RIG_FUNC_COMP, "COMP" }, + { RIG_FUNC_VOX, "VOX" }, + { RIG_FUNC_TONE, "TONE" }, + { RIG_FUNC_TSQL, "TSQL" }, + { RIG_FUNC_SBKIN, "SBKIN" }, + { RIG_FUNC_FBKIN, "FBKIN" }, + { RIG_FUNC_ANF, "ANF" }, + { RIG_FUNC_NR, "NR" }, + { RIG_FUNC_AIP, "AIP" }, + { RIG_FUNC_APF, "APF" }, + { RIG_FUNC_MON, "MON" }, + { RIG_FUNC_MN, "MN" }, + { RIG_FUNC_RF, "RF" }, + { RIG_FUNC_ARO, "ARO" }, + { RIG_FUNC_LOCK, "LOCK" }, + { RIG_FUNC_MUTE, "MUTE" }, + { RIG_FUNC_VSC, "VSC" }, + { RIG_FUNC_REV, "REV" }, + { RIG_FUNC_SQL, "SQL" }, + { RIG_FUNC_ABM, "ABM" }, + { RIG_FUNC_BC, "BC" }, + { RIG_FUNC_MBC, "MBC" }, + { RIG_FUNC_RIT, "RIT" }, + { RIG_FUNC_AFC, "AFC" }, + { RIG_FUNC_SATMODE, "SATMODE" }, + { RIG_FUNC_SCOPE, "SCOPE" }, + { RIG_FUNC_RESUME, "RESUME" }, + { RIG_FUNC_TBURST, "TBURST" }, + { RIG_FUNC_TUNER, "TUNER" }, + { RIG_FUNC_XIT, "XIT" }, + { RIG_FUNC_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_FUNC_... * \param s input alpha string @@ -422,15 +479,19 @@ static struct { */ setting_t HAMLIB_API rig_parse_func(const char *s) { - int i; + int i; - for (i=0 ; func_str[i].str[0] != '\0'; i++) - if (!strcmp(s, func_str[i].str)) - return func_str[i].func; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return RIG_FUNC_NONE; + for (i = 0 ; func_str[i].str[0] != '\0'; i++) + if (!strcmp(s, func_str[i].str)) { + return func_str[i].func; + } + + return RIG_FUNC_NONE; } + /** * \brief Convert enum RIG_FUNC_... to alpha string * \param func RIG_FUNC_... @@ -440,56 +501,62 @@ setting_t HAMLIB_API rig_parse_func(const char *s) */ const char * HAMLIB_API rig_strfunc(setting_t func) { - int i; + int i; - if (func == RIG_FUNC_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; func_str[i].str[0] != '\0'; i++) - if (func == func_str[i].func) - return func_str[i].str; + if (func == RIG_FUNC_NONE) { + return ""; + } - return ""; + for (i = 0; func_str[i].str[0] != '\0'; i++) + if (func == func_str[i].func) { + return func_str[i].str; + } + + return ""; } + static struct { - setting_t level; - const char *str; + setting_t level; + const char *str; } level_str[] = { - { RIG_LEVEL_PREAMP, "PREAMP" }, - { RIG_LEVEL_ATT, "ATT" }, - { RIG_LEVEL_VOX, "VOX" }, - { RIG_LEVEL_AF, "AF" }, - { RIG_LEVEL_RF, "RF" }, - { RIG_LEVEL_SQL, "SQL" }, - { RIG_LEVEL_IF, "IF" }, - { RIG_LEVEL_APF, "APF" }, - { RIG_LEVEL_NR, "NR" }, - { RIG_LEVEL_PBT_IN, "PBT_IN" }, - { RIG_LEVEL_PBT_OUT, "PBT_OUT" }, - { RIG_LEVEL_CWPITCH, "CWPITCH" }, - { RIG_LEVEL_RFPOWER, "RFPOWER" }, - { RIG_LEVEL_MICGAIN, "MICGAIN" }, - { RIG_LEVEL_KEYSPD, "KEYSPD" }, - { RIG_LEVEL_NOTCHF, "NOTCHF" }, - { RIG_LEVEL_COMP, "COMP" }, - { RIG_LEVEL_AGC, "AGC" }, - { RIG_LEVEL_BKINDL, "BKINDL" }, - { RIG_LEVEL_BALANCE, "BAL" }, - { RIG_LEVEL_METER, "METER" }, - { RIG_LEVEL_VOXGAIN, "VOXGAIN" }, - { RIG_LEVEL_ANTIVOX, "ANTIVOX" }, - { RIG_LEVEL_SLOPE_LOW, "SLOPE_LOW" }, - { RIG_LEVEL_SLOPE_HIGH, "SLOPE_HIGH" }, - { RIG_LEVEL_BKIN_DLYMS, "BKIN_DLYMS" }, - { RIG_LEVEL_RAWSTR, "RAWSTR" }, - { RIG_LEVEL_SQLSTAT, "SQLSTAT" }, - { RIG_LEVEL_SWR, "SWR" }, - { RIG_LEVEL_ALC, "ALC" }, - { RIG_LEVEL_STRENGTH, "STRENGTH" }, - { RIG_LEVEL_NONE, "" }, + { RIG_LEVEL_PREAMP, "PREAMP" }, + { RIG_LEVEL_ATT, "ATT" }, + { RIG_LEVEL_VOX, "VOX" }, + { RIG_LEVEL_AF, "AF" }, + { RIG_LEVEL_RF, "RF" }, + { RIG_LEVEL_SQL, "SQL" }, + { RIG_LEVEL_IF, "IF" }, + { RIG_LEVEL_APF, "APF" }, + { RIG_LEVEL_NR, "NR" }, + { RIG_LEVEL_PBT_IN, "PBT_IN" }, + { RIG_LEVEL_PBT_OUT, "PBT_OUT" }, + { RIG_LEVEL_CWPITCH, "CWPITCH" }, + { RIG_LEVEL_RFPOWER, "RFPOWER" }, + { RIG_LEVEL_MICGAIN, "MICGAIN" }, + { RIG_LEVEL_KEYSPD, "KEYSPD" }, + { RIG_LEVEL_NOTCHF, "NOTCHF" }, + { RIG_LEVEL_COMP, "COMP" }, + { RIG_LEVEL_AGC, "AGC" }, + { RIG_LEVEL_BKINDL, "BKINDL" }, + { RIG_LEVEL_BALANCE, "BAL" }, + { RIG_LEVEL_METER, "METER" }, + { RIG_LEVEL_VOXGAIN, "VOXGAIN" }, + { RIG_LEVEL_ANTIVOX, "ANTIVOX" }, + { RIG_LEVEL_SLOPE_LOW, "SLOPE_LOW" }, + { RIG_LEVEL_SLOPE_HIGH, "SLOPE_HIGH" }, + { RIG_LEVEL_BKIN_DLYMS, "BKIN_DLYMS" }, + { RIG_LEVEL_RAWSTR, "RAWSTR" }, + { RIG_LEVEL_SQLSTAT, "SQLSTAT" }, + { RIG_LEVEL_SWR, "SWR" }, + { RIG_LEVEL_ALC, "ALC" }, + { RIG_LEVEL_STRENGTH, "STRENGTH" }, + { RIG_LEVEL_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_LEVEL_... * \param s input alpha string @@ -499,15 +566,19 @@ static struct { */ setting_t HAMLIB_API rig_parse_level(const char *s) { - int i; + int i; - for (i=0 ; level_str[i].str[0] != '\0'; i++) - if (!strcmp(s, level_str[i].str)) - return level_str[i].level; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return RIG_LEVEL_NONE; + for (i = 0 ; level_str[i].str[0] != '\0'; i++) + if (!strcmp(s, level_str[i].str)) { + return level_str[i].level; + } + + return RIG_LEVEL_NONE; } + /** * \brief Convert enum RIG_LEVEL_... to alpha string * \param level RIG_LEVEL_... @@ -517,32 +588,38 @@ setting_t HAMLIB_API rig_parse_level(const char *s) */ const char * HAMLIB_API rig_strlevel(setting_t level) { - int i; + int i; - if (level == RIG_LEVEL_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; level_str[i].str[0] != '\0'; i++) - if (level == level_str[i].level) - return level_str[i].str; + if (level == RIG_LEVEL_NONE) { + return ""; + } - return ""; + for (i = 0; level_str[i].str[0] != '\0'; i++) + if (level == level_str[i].level) { + return level_str[i].str; + } + + return ""; } + static struct { - setting_t parm; - const char *str; + setting_t parm; + const char *str; } parm_str[] = { - { RIG_PARM_ANN, "ANN" }, - { RIG_PARM_APO, "APO" }, - { RIG_PARM_BACKLIGHT, "BACKLIGHT" }, - { RIG_PARM_BEEP, "BEEP" }, - { RIG_PARM_TIME, "TIME" }, - { RIG_PARM_BAT, "BAT" }, - { RIG_PARM_KEYLIGHT, "KEYLIGHT"}, - { RIG_PARM_NONE, "" }, + { RIG_PARM_ANN, "ANN" }, + { RIG_PARM_APO, "APO" }, + { RIG_PARM_BACKLIGHT, "BACKLIGHT" }, + { RIG_PARM_BEEP, "BEEP" }, + { RIG_PARM_TIME, "TIME" }, + { RIG_PARM_BAT, "BAT" }, + { RIG_PARM_KEYLIGHT, "KEYLIGHT"}, + { RIG_PARM_NONE, "" }, }; + /** * \brief Convert alpha string to RIG_PARM_... * \param s input alpha string @@ -552,15 +629,19 @@ static struct { */ setting_t HAMLIB_API rig_parse_parm(const char *s) { - int i; + int i; - for (i=0 ; parm_str[i].str[0] != '\0'; i++) - if (!strcmp(s, parm_str[i].str)) - return parm_str[i].parm; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return RIG_PARM_NONE; + for (i = 0 ; parm_str[i].str[0] != '\0'; i++) + if (!strcmp(s, parm_str[i].str)) { + return parm_str[i].parm; + } + + return RIG_PARM_NONE; } + /** * \brief Convert enum RIG_PARM_... to alpha string * \param parm RIG_PARM_... @@ -570,38 +651,44 @@ setting_t HAMLIB_API rig_parse_parm(const char *s) */ const char * HAMLIB_API rig_strparm(setting_t parm) { - int i; + int i; - if (parm == RIG_PARM_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; parm_str[i].str[0] != '\0'; i++) - if (parm == parm_str[i].parm) - return parm_str[i].str; + if (parm == RIG_PARM_NONE) { + return ""; + } - return ""; + for (i = 0; parm_str[i].str[0] != '\0'; i++) + if (parm == parm_str[i].parm) { + return parm_str[i].str; + } + + return ""; } + static struct { - vfo_op_t vfo_op; - const char *str; + vfo_op_t vfo_op; + const char *str; } vfo_op_str[] = { - { RIG_OP_CPY, "CPY" }, - { RIG_OP_XCHG, "XCHG" }, - { RIG_OP_FROM_VFO, "FROM_VFO" }, - { RIG_OP_TO_VFO, "TO_VFO" }, - { RIG_OP_MCL, "MCL" }, - { RIG_OP_UP, "UP" }, - { RIG_OP_DOWN, "DOWN" }, - { RIG_OP_BAND_UP, "BAND_UP" }, - { RIG_OP_BAND_DOWN, "BAND_DOWN" }, - { RIG_OP_LEFT, "LEFT" }, - { RIG_OP_RIGHT, "RIGHT" }, - { RIG_OP_TUNE, "TUNE" }, - { RIG_OP_TOGGLE, "TOGGLE" }, - { RIG_OP_NONE, "" }, + { RIG_OP_CPY, "CPY" }, + { RIG_OP_XCHG, "XCHG" }, + { RIG_OP_FROM_VFO, "FROM_VFO" }, + { RIG_OP_TO_VFO, "TO_VFO" }, + { RIG_OP_MCL, "MCL" }, + { RIG_OP_UP, "UP" }, + { RIG_OP_DOWN, "DOWN" }, + { RIG_OP_BAND_UP, "BAND_UP" }, + { RIG_OP_BAND_DOWN, "BAND_DOWN" }, + { RIG_OP_LEFT, "LEFT" }, + { RIG_OP_RIGHT, "RIGHT" }, + { RIG_OP_TUNE, "TUNE" }, + { RIG_OP_TOGGLE, "TOGGLE" }, + { RIG_OP_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_OP_... * \param s alpha string @@ -611,15 +698,19 @@ static struct { */ vfo_op_t HAMLIB_API rig_parse_vfo_op(const char *s) { - int i; + int i; - for (i=0 ; vfo_op_str[i].str[0] != '\0'; i++) - if (!strcmp(s, vfo_op_str[i].str)) - return vfo_op_str[i].vfo_op; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return RIG_OP_NONE; + for (i = 0 ; vfo_op_str[i].str[0] != '\0'; i++) + if (!strcmp(s, vfo_op_str[i].str)) { + return vfo_op_str[i].vfo_op; + } + + return RIG_OP_NONE; } + /** * \brief Convert enum RIG_OP_... to alpha string * \param op RIG_OP_... @@ -629,34 +720,40 @@ vfo_op_t HAMLIB_API rig_parse_vfo_op(const char *s) */ const char * HAMLIB_API rig_strvfop(vfo_op_t op) { - int i; + int i; - if (op == RIG_OP_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; vfo_op_str[i].str[0] != '\0'; i++) - if (op == vfo_op_str[i].vfo_op) - return vfo_op_str[i].str; + if (op == RIG_OP_NONE) { + return ""; + } - return ""; + for (i = 0; vfo_op_str[i].str[0] != '\0'; i++) + if (op == vfo_op_str[i].vfo_op) { + return vfo_op_str[i].str; + } + + return ""; } + static struct { - scan_t rscan; - const char *str; + scan_t rscan; + const char *str; } scan_str[] = { - { RIG_SCAN_STOP, "STOP" }, - { RIG_SCAN_MEM, "MEM" }, - { RIG_SCAN_SLCT, "SLCT" }, - { RIG_SCAN_PRIO, "PRIO" }, - { RIG_SCAN_PROG, "PROG" }, - { RIG_SCAN_DELTA, "DELTA" }, - { RIG_SCAN_VFO, "VFO" }, - { RIG_SCAN_PLT, "PLT" }, - { RIG_SCAN_NONE, "" }, - { -1, NULL } + { RIG_SCAN_STOP, "STOP" }, + { RIG_SCAN_MEM, "MEM" }, + { RIG_SCAN_SLCT, "SLCT" }, + { RIG_SCAN_PRIO, "PRIO" }, + { RIG_SCAN_PROG, "PROG" }, + { RIG_SCAN_DELTA, "DELTA" }, + { RIG_SCAN_VFO, "VFO" }, + { RIG_SCAN_PLT, "PLT" }, + { RIG_SCAN_NONE, "" }, + { -1, NULL } }; + /** * \brief Convert alpha string to enum RIG_SCAN_... * \param s alpha string @@ -666,16 +763,20 @@ static struct { */ scan_t HAMLIB_API rig_parse_scan(const char *s) { - int i; + int i; - for (i=0 ; scan_str[i].str[0] != '\0'; i++) { - if (strcmp(s, scan_str[i].str) == 0) { - return scan_str[i].rscan; - } - } - return RIG_SCAN_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (i = 0 ; scan_str[i].str[0] != '\0'; i++) { + if (strcmp(s, scan_str[i].str) == 0) { + return scan_str[i].rscan; + } + } + + return RIG_SCAN_NONE; } + /** * \brief Convert enum RIG_SCAN_... to alpha string * \param rscan RIG_SCAN_... @@ -685,17 +786,23 @@ scan_t HAMLIB_API rig_parse_scan(const char *s) */ const char * HAMLIB_API rig_strscan(scan_t rscan) { - int i; + int i; - if (rscan == RIG_SCAN_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; scan_str[i].str[0] != '\0'; i++) - if (rscan == scan_str[i].rscan) - return scan_str[i].str; - return ""; + if (rscan == RIG_SCAN_NONE) { + return ""; + } + + for (i = 0; scan_str[i].str[0] != '\0'; i++) + if (rscan == scan_str[i].rscan) { + return scan_str[i].str; + } + + return ""; } + /** * \brief convert enum RIG_RPT_SHIFT_... to printable character * \param shift RIG_RPT_SHIFT_?? @@ -703,14 +810,23 @@ const char * HAMLIB_API rig_strscan(scan_t rscan) */ const char * HAMLIB_API rig_strptrshift(rptr_shift_t shift) { - switch (shift) { - case RIG_RPT_SHIFT_MINUS: return "-"; - case RIG_RPT_SHIFT_PLUS: return "+"; - case RIG_RPT_SHIFT_NONE: return "None"; - } - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + switch (shift) { + case RIG_RPT_SHIFT_MINUS: + return "-"; + + case RIG_RPT_SHIFT_PLUS: + return "+"; + + case RIG_RPT_SHIFT_NONE: + return "None"; + } + + return NULL; } + /** * \brief Convert alpha char to enum RIG_RPT_SHIFT_... * \param s alpha char @@ -718,28 +834,33 @@ const char * HAMLIB_API rig_strptrshift(rptr_shift_t shift) */ rptr_shift_t HAMLIB_API rig_parse_rptr_shift(const char *s) { - if (strcmp(s, "+") == 0) - return RIG_RPT_SHIFT_PLUS; - else if (strcmp(s, "-") == 0) - return RIG_RPT_SHIFT_MINUS; - else - return RIG_RPT_SHIFT_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + if (strcmp(s, "+") == 0) { + return RIG_RPT_SHIFT_PLUS; + } else if (strcmp(s, "-") == 0) { + return RIG_RPT_SHIFT_MINUS; + } else { + return RIG_RPT_SHIFT_NONE; + } } + static struct { - chan_type_t mtype; - const char *str; + chan_type_t mtype; + const char *str; } mtype_str[] = { - { RIG_MTYPE_MEM, "MEM" }, - { RIG_MTYPE_EDGE, "EDGE" }, - { RIG_MTYPE_CALL, "CALL" }, - { RIG_MTYPE_MEMOPAD, "MEMOPAD" }, - { RIG_MTYPE_SAT, "SAT" }, - { RIG_MTYPE_BAND, "BAND" }, - { RIG_MTYPE_PRIO, "PRIO" }, - { RIG_MTYPE_NONE, "" }, + { RIG_MTYPE_MEM, "MEM" }, + { RIG_MTYPE_EDGE, "EDGE" }, + { RIG_MTYPE_CALL, "CALL" }, + { RIG_MTYPE_MEMOPAD, "MEMOPAD" }, + { RIG_MTYPE_SAT, "SAT" }, + { RIG_MTYPE_BAND, "BAND" }, + { RIG_MTYPE_PRIO, "PRIO" }, + { RIG_MTYPE_NONE, "" }, }; + /** * \brief Convert alpha string to enum RIG_MTYPE_... * \param s alpha string @@ -749,16 +870,20 @@ static struct { */ chan_type_t HAMLIB_API rig_parse_mtype(const char *s) { - int i; + int i; - for (i=0 ; mtype_str[i].str[0] != '\0'; i++) { - if (strcmp(s, mtype_str[i].str) == 0) { - return mtype_str[i].mtype; - } - } - return RIG_MTYPE_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (i = 0 ; mtype_str[i].str[0] != '\0'; i++) { + if (strcmp(s, mtype_str[i].str) == 0) { + return mtype_str[i].mtype; + } + } + + return RIG_MTYPE_NONE; } + /** * \brief Convert enum RIG_MTYPE_... to alpha string * \param mtype RIG_MTYPE_... @@ -768,28 +893,34 @@ chan_type_t HAMLIB_API rig_parse_mtype(const char *s) */ const char * HAMLIB_API rig_strmtype(chan_type_t mtype) { - int i; + int i; - if (mtype == RIG_MTYPE_NONE) - return ""; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (i=0; mtype_str[i].str[0] != '\0'; i++) - if (mtype == mtype_str[i].mtype) - return mtype_str[i].str; - return ""; + if (mtype == RIG_MTYPE_NONE) { + return ""; + } + + for (i = 0; mtype_str[i].str[0] != '\0'; i++) + if (mtype == mtype_str[i].mtype) { + return mtype_str[i].str; + } + + return ""; } static long timediff(const struct timeval *tv1, const struct timeval *tv2) { - struct timeval tv; + struct timeval tv; - tv.tv_usec = tv1->tv_usec - tv2->tv_usec; - tv.tv_sec = tv1->tv_sec - tv2->tv_sec; + tv.tv_usec = tv1->tv_usec - tv2->tv_usec; + tv.tv_sec = tv1->tv_sec - tv2->tv_sec; - return ((tv.tv_sec * 1000L) + (tv.tv_usec / 1000L)); + return ((tv.tv_sec * 1000L) + (tv.tv_usec / 1000L)); } + /** * \brief Helper for checking cache timeout * \param tv pointer to timeval, date of cache @@ -801,25 +932,35 @@ int HAMLIB_API rig_check_cache_timeout(const struct timeval *tv, int timeout) struct timeval curr; long t; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + if (tv->tv_sec == 0 && tv->tv_usec == 0) { - rig_debug(RIG_DEBUG_VERBOSE, "forced cache timeout\n"); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: forced cache timeout\n", + __func__); return 1; } gettimeofday(&curr, NULL); t = timediff(&curr, tv); + if (t < timeout) { - rig_debug(RIG_DEBUG_VERBOSE, "%s: using cache (%ld ms)\n", - __func__, t); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: using cache (%ld ms)\n", + __func__, + t); return 0; } else { - rig_debug(RIG_DEBUG_VERBOSE, "%s: cache timed out (%ld ms)\n", - __func__, t); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: cache timed out (%ld ms)\n", + __func__, + t); return 1; } } + /** * \brief Helper for forcing cache timeout next call * @@ -838,15 +979,21 @@ int HAMLIB_API rig_check_cache_timeout(const struct timeval *tv, int timeout) */ void HAMLIB_API rig_force_cache_timeout(struct timeval *tv) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + tv->tv_sec = 0; tv->tv_usec = 0; } + int no_restore_ai; + void HAMLIB_API rig_no_restore_ai() { - no_restore_ai = -1; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + no_restore_ai = -1; } /** @} */ diff --git a/src/misc.h b/src/misc.h index c1748221b..768feaac7 100644 --- a/src/misc.h +++ b/src/misc.h @@ -26,7 +26,7 @@ /* - * Carefull!! These marcos are NOT reentrant! + * Carefull!! These macros are NOT reentrant! * ie. they may not be executed atomically, * thus not ensure mutual exclusion. * Fix it when making Hamlib reentrant! --SF @@ -44,20 +44,31 @@ void dump_hex(const unsigned char ptr[], size_t size); /* * BCD conversion routines. - * to_bcd converts a long long int to a little endian BCD array, - * and return a pointer to this array. - * from_bcd converts a little endian BCD array to long long int + * + * to_bcd() converts a long long int to a little endian BCD array, + * and return a pointer to this array. + * + * from_bcd() converts a little endian BCD array to long long int * reprensentation, and return it. + * * bcd_len is the number of digits in the BCD array. */ -extern HAMLIB_EXPORT(unsigned char *) to_bcd(unsigned char bcd_data[], unsigned long long freq, unsigned bcd_len); -extern HAMLIB_EXPORT(unsigned long long) from_bcd(const unsigned char bcd_data[], unsigned bcd_len); +extern HAMLIB_EXPORT(unsigned char *) to_bcd(unsigned char bcd_data[], + unsigned long long freq, + unsigned bcd_len); + +extern HAMLIB_EXPORT(unsigned long long) from_bcd(const unsigned char bcd_data[], + unsigned bcd_len); /* - * same as to_bcd and from_bcd, but in Big Endian mode + * same as to_bcd() and from_bcd(), but in Big Endian mode */ -extern HAMLIB_EXPORT(unsigned char *) to_bcd_be(unsigned char bcd_data[], unsigned long long freq, unsigned bcd_len); -extern HAMLIB_EXPORT(unsigned long long) from_bcd_be(const unsigned char bcd_data[], unsigned bcd_len); +extern HAMLIB_EXPORT(unsigned char *) to_bcd_be(unsigned char bcd_data[], + unsigned long long freq, + unsigned bcd_len); + +extern HAMLIB_EXPORT(unsigned long long) from_bcd_be(const unsigned char bcd_data[], + unsigned bcd_len); extern HAMLIB_EXPORT(int) sprintf_freq(char *str, freq_t); @@ -77,7 +88,9 @@ extern int no_restore_ai; #include #endif -extern HAMLIB_EXPORT(int) rig_check_cache_timeout(const struct timeval *tv, int timeout); +extern HAMLIB_EXPORT(int) rig_check_cache_timeout(const struct timeval *tv, + int timeout); + extern HAMLIB_EXPORT(void) rig_force_cache_timeout(struct timeval *tv); diff --git a/src/network.c b/src/network.c index 9b1464a13..f7e1faf34 100644 --- a/src/network.c +++ b/src/network.c @@ -60,12 +60,12 @@ #include #elif HAVE_WS2TCPIP_H #include -# if defined(HAVE_WSPIAPI_H) -# include -# endif +# if defined(HAVE_WSPIAPI_H) +# include +# endif #endif -#include "hamlib/rig.h" +#include #include "network.h" #include "misc.h" @@ -76,36 +76,37 @@ static int wsstarted; #define NET_BUFFER_SIZE 64 -static void handle_error (enum rig_debug_level_e lvl, const char *msg) +static void handle_error(enum rig_debug_level_e lvl, const char *msg) { - int e; + int e; #ifdef __MINGW32__ - LPVOID lpMsgBuf; + LPVOID lpMsgBuf; + + lpMsgBuf = (LPVOID)"Unknown error"; + e = WSAGetLastError(); + + if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER + | FORMAT_MESSAGE_FROM_SYSTEM + | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, e, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + // Default language + (LPTSTR)&lpMsgBuf, + 0, + NULL)) { + rig_debug(lvl, "%s: Network error %d: %s\n", msg, e, lpMsgBuf); + LocalFree(lpMsgBuf); + } else { + rig_debug(lvl, "%s: Network error %d\n", msg, e); + } - lpMsgBuf = (LPVOID)"Unknown error"; - e = WSAGetLastError(); - if (FormatMessage( - FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, e, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - // Default language - (LPTSTR)&lpMsgBuf, 0, NULL)) - { - rig_debug (lvl, "%s: Network error %d: %s\n", msg, e, lpMsgBuf); - LocalFree(lpMsgBuf); - } - else - { - rig_debug (lvl, "%s: Network error %d\n", msg, e); - } #else - e = errno; - rig_debug (lvl, "%s: Network error %d: %s\n", msg, e, strerror (e)); + e = errno; + rig_debug(lvl, "%s: Network error %d: %s\n", msg, e, strerror(e)); #endif } + /** * \brief Open network port using rig.state data * @@ -118,157 +119,184 @@ static void handle_error (enum rig_debug_level_e lvl, const char *msg) */ int network_open(hamlib_port_t *rp, int default_port) { - int fd; /* File descriptor for the port */ - int status; - struct addrinfo hints, *res, *saved_res; - char *hoststr = NULL, *portstr = NULL, *bracketstr1, *bracketstr2; - char hostname[FILPATHLEN]; - char defaultportstr[8]; + int fd; /* File descriptor for the port */ + int status; + struct addrinfo hints, *res, *saved_res; + char *hoststr = NULL, *portstr = NULL, *bracketstr1, *bracketstr2; + char hostname[FILPATHLEN]; + char defaultportstr[8]; + + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); #ifdef __MINGW32__ - WSADATA wsadata; - if (!(wsstarted++) && WSAStartup(MAKEWORD(1,1), &wsadata) == SOCKET_ERROR) { - rig_debug(RIG_DEBUG_ERR, "Error creating socket\n"); - return -RIG_EIO; - } + WSADATA wsadata; + + if (!(wsstarted++) && WSAStartup(MAKEWORD(1, 1), &wsadata) == SOCKET_ERROR) { + rig_debug(RIG_DEBUG_ERR, "%s: error creating socket\n", __func__); + return -RIG_EIO; + } + #endif - if (!rp) - return -RIG_EINVAL; + if (!rp) { + return -RIG_EINVAL; + } - memset(&hints, 0, sizeof(hints)); - hints.ai_family = PF_UNSPEC; - if (rp->type.rig == RIG_PORT_UDP_NETWORK) - hints.ai_socktype = SOCK_DGRAM; - else - hints.ai_socktype = SOCK_STREAM; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = PF_UNSPEC; - hoststr = NULL; /* default of all local interfaces */ - if (rp->pathname[0] == ':') - { - portstr = rp->pathname + 1; - } - else - { - if (strlen (rp->pathname)) - { - strncpy(hostname, rp->pathname, FILPATHLEN-1); - hoststr = hostname; - /* look for IPv6 numeric form [] */ - bracketstr1 = strchr(hoststr, '['); - bracketstr2 = strrchr(hoststr, ']'); - if (bracketstr1 && bracketstr2 && bracketstr2 > bracketstr1) - { - hoststr = bracketstr1 + 1; - *bracketstr2 = '\0'; - portstr = bracketstr2 + 1; /* possible port after ]: */ - } - else - { - bracketstr2 = NULL; - portstr = hoststr; /* possible port after : */ - } - /* search last ':' */ - portstr = strrchr(portstr, ':'); - if (portstr) - { - *portstr++ = '\0'; - } - } - if (!portstr) - { - sprintf(defaultportstr, "%d", default_port); - portstr = defaultportstr; - } - } + if (rp->type.rig == RIG_PORT_UDP_NETWORK) { + hints.ai_socktype = SOCK_DGRAM; + } else { + hints.ai_socktype = SOCK_STREAM; + } - status=getaddrinfo(hoststr, portstr, &hints, &res); - if (status != 0) { - rig_debug(RIG_DEBUG_ERR, "Cannot get host \"%s\": %s\n", - rp->pathname, gai_strerror(errno)); - return -RIG_ECONF; - } - saved_res = res; + /* default of all local interfaces */ + hoststr = NULL; - /* we don't want a signal when connection get broken */ + if (rp->pathname[0] == ':') { + portstr = rp->pathname + 1; + } else { + if (strlen(rp->pathname)) { + strncpy(hostname, rp->pathname, FILPATHLEN - 1); + hoststr = hostname; + /* look for IPv6 numeric form [] */ + bracketstr1 = strchr(hoststr, '['); + bracketstr2 = strrchr(hoststr, ']'); + + if (bracketstr1 && bracketstr2 && bracketstr2 > bracketstr1) { + hoststr = bracketstr1 + 1; + *bracketstr2 = '\0'; + portstr = bracketstr2 + 1; /* possible port after ]: */ + } else { + bracketstr2 = NULL; + portstr = hoststr; /* possible port after : */ + } + + /* search last ':' */ + portstr = strrchr(portstr, ':'); + + if (portstr) { + *portstr++ = '\0'; + } + } + + if (!portstr) { + sprintf(defaultportstr, "%d", default_port); + portstr = defaultportstr; + } + } + + status = getaddrinfo(hoststr, portstr, &hints, &res); + + if (status != 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot get host \"%s\": %s\n", + __func__, + rp->pathname, + gai_strerror(errno)); + return -RIG_ECONF; + } + + saved_res = res; + + /* we don't want a signal when connection get broken */ #ifdef SIGPIPE - signal(SIGPIPE, SIG_IGN); + signal(SIGPIPE, SIG_IGN); #endif - do - { - fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); - if (fd < 0) - { - handle_error (RIG_DEBUG_ERR, "socket"); - freeaddrinfo (saved_res); - return -RIG_EIO; - } + do { + fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); - if ((status = connect(fd, res->ai_addr, res->ai_addrlen)) == 0) - { - break; - } - handle_error (RIG_DEBUG_WARN, "connect (trying next interface)"); + if (fd < 0) { + handle_error(RIG_DEBUG_ERR, "socket"); + freeaddrinfo(saved_res); + return -RIG_EIO; + } + + if ((status = connect(fd, res->ai_addr, res->ai_addrlen)) == 0) { + break; + } + + handle_error(RIG_DEBUG_WARN, "connect (trying next interface)"); #ifdef __MINGW32__ - closesocket (fd); + closesocket(fd); #else - close (fd); + close(fd); #endif - } while ((res = res->ai_next) != NULL); + } while ((res = res->ai_next) != NULL); - freeaddrinfo (saved_res); + freeaddrinfo(saved_res); - if (NULL == res) { - rig_debug (RIG_DEBUG_ERR, "Failed to connect to %s\n" , rp->pathname); - return -RIG_EIO; - } + if (NULL == res) { + rig_debug(RIG_DEBUG_ERR, + "%s: failed to connect to %s\n", + __func__, + rp->pathname); + return -RIG_EIO; + } - rp->fd = fd; - return RIG_OK; + rp->fd = fd; + + return RIG_OK; } + /** * \brief Clears any data in the read buffer of the socket * * \param rp Port data structure */ -void network_flush(hamlib_port_t* rp) +void network_flush(hamlib_port_t *rp) { #ifdef __MINGW32__ - ULONG len = 0; + ULONG len = 0; #else - uint len = 0; + uint len = 0; #endif - char buffer[NET_BUFFER_SIZE] = { 0 }; - for (;;) { + char buffer[NET_BUFFER_SIZE] = { 0 }; + + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (;;) { #ifdef __MINGW32__ - ioctlsocket (rp->fd, FIONREAD, &len); + ioctlsocket(rp->fd, FIONREAD, &len); #else - ioctl(rp->fd, FIONREAD, &len); + ioctl(rp->fd, FIONREAD, &len); #endif - if (len > 0) { - len = read(rp->fd, &buffer, len < NET_BUFFER_SIZE ? len : NET_BUFFER_SIZE); - rig_debug(RIG_DEBUG_WARN, "Network data cleared: %s\n", buffer); - } else { - break; + + if (len > 0) { + len = read(rp->fd, &buffer, len < NET_BUFFER_SIZE ? len : NET_BUFFER_SIZE); + rig_debug(RIG_DEBUG_WARN, + "%s: network data cleared: %s\n", + __func__, + buffer); + } else { + break; + } } - } } + int network_close(hamlib_port_t *rp) { - int ret; + int ret; + + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef __MINGW32__ - ret = closesocket(rp->fd); - if (--wsstarted) - WSACleanup(); + ret = closesocket(rp->fd); + + if (--wsstarted) { + WSACleanup(); + } + #else - ret = close(rp->fd); + ret = close(rp->fd); #endif - return ret; + return ret; } /** @} */ diff --git a/src/par_nt.h b/src/par_nt.h index 6fe5f8143..8a96104e4 100644 --- a/src/par_nt.h +++ b/src/par_nt.h @@ -1,12 +1,12 @@ /* NT Parport Access stuff - Matthew Duggan (2002) */ -/* - * ParallelVdm Device (0x2C) is mostly undocumented, used by VDM for parallel +/* + * ParallelVdm Device (0x2C) is mostly undocumented, used by VDM for parallel * port compatibility. */ -/* - * Different from CTL_CODE in DDK, limited to ParallelVdm but makes this +/* + * Different from CTL_CODE in DDK, limited to ParallelVdm but makes this * code cleaner. */ @@ -28,28 +28,26 @@ */ /* The status pin functions operate in terms of these bits: */ -enum ieee1284_status_bits -{ - S1284_NFAULT = 0x08, - S1284_SELECT = 0x10, - S1284_PERROR = 0x20, - S1284_NACK = 0x40, - S1284_BUSY = 0x80, - /* To convert those values into PC-style register values, use this: */ - S1284_INVERTED = S1284_BUSY +enum ieee1284_status_bits { + S1284_NFAULT = 0x08, + S1284_SELECT = 0x10, + S1284_PERROR = 0x20, + S1284_NACK = 0x40, + S1284_BUSY = 0x80, + /* To convert those values into PC-style register values, use this: */ + S1284_INVERTED = S1284_BUSY }; /* The control pin functions operate in terms of these bits: */ -enum ieee1284_control_bits -{ - C1284_NSTROBE = 0x01, - C1284_NAUTOFD = 0x02, - C1284_NINIT = 0x04, - C1284_NSELECTIN = 0x08, - /* To convert those values into PC-style register values, use this: */ - C1284_INVERTED = (C1284_NSTROBE| - C1284_NAUTOFD| - C1284_NSELECTIN) +enum ieee1284_control_bits { + C1284_NSTROBE = 0x01, + C1284_NAUTOFD = 0x02, + C1284_NINIT = 0x04, + C1284_NSELECTIN = 0x08, + /* To convert those values into PC-style register values, use this: */ + C1284_INVERTED = (C1284_NSTROBE + | C1284_NAUTOFD + | C1284_NSELECTIN) }; -#endif /* _PAR_NT_H */ +#endif /* _PAR_NT_H */ diff --git a/src/parallel.c b/src/parallel.c index 1137d5c87..4160333ca 100644 --- a/src/parallel.c +++ b/src/parallel.c @@ -60,7 +60,7 @@ #include #endif -#include "hamlib/rig.h" +#include #include "parallel.h" #ifdef HAVE_LINUX_PPDEV_H @@ -78,14 +78,14 @@ * We toggle them so that this weirdness doesn't get propagated * through our interface. */ -#define CP_ACTIVE_LOW_BITS 0x0B +#define CP_ACTIVE_LOW_BITS 0x0B /* * These status port bits are active low. * We toggle them so that this weirdness doesn't get propagated * through our interface. */ -#define SP_ACTIVE_LOW_BITS 0x80 +#define SP_ACTIVE_LOW_BITS 0x80 /* Pinout table of parallel port from http://en.wikipedia.org/wiki/Parallel_port#Pinouts @@ -112,6 +112,7 @@ * means low true, e.g., *Strobe. */ + /** * \brief Open Parallel Port * \param port @@ -120,85 +121,107 @@ * TODO: to be called before exiting: atexit(parport_cleanup) * void parport_cleanup() { ioctl(fd, PPRELEASE); } */ - int par_open(hamlib_port_t *port) { - int fd; + int fd; + + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int mode; + int mode; #endif #if defined (__WIN64__) || defined(__WIN32__) - HANDLE handle; + HANDLE handle; #endif - if (!port->pathname[0]) - return -RIG_EINVAL; + if (!port->pathname[0]) { + return -RIG_EINVAL; + } #ifdef HAVE_LINUX_PPDEV_H - /* TODO: open with O_NONBLOCK ? */ - fd = open(port->pathname, O_RDWR); + /* TODO: open with O_NONBLOCK ? */ + fd = open(port->pathname, O_RDWR); - if (fd < 0) { - rig_debug(RIG_DEBUG_ERR, "Opening device \"%s\": %s\n", port->pathname, strerror(errno)); - return -RIG_EIO; - } + if (fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: opening device \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + return -RIG_EIO; + } - mode = IEEE1284_MODE_COMPAT; + mode = IEEE1284_MODE_COMPAT; - if (ioctl(fd, PPSETMODE, &mode) != 0) { - rig_debug(RIG_DEBUG_ERR, "PPSETMODE \"%s\": %s\n", port->pathname, strerror(errno)); - close(fd); - return -RIG_EIO; - } + if (ioctl(fd, PPSETMODE, &mode) != 0) { + rig_debug(RIG_DEBUG_ERR, "%s: PPSETMODE \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + close(fd); + return -RIG_EIO; + } #elif defined(HAVE_DEV_PPBUS_PPI_H) - fd = open(port->pathname, O_RDWR); + fd = open(port->pathname, O_RDWR); - if (fd < 0) { - rig_debug(RIG_DEBUG_ERR, "Opening device \"%s\": %s\n", port->pathname, strerror(errno)); - return -RIG_EIO; - } + if (fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: opening device \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + return -RIG_EIO; + } #elif defined(__WIN64__) || defined(__WIN32__) - handle = CreateFile(port->pathname, GENERIC_READ | GENERIC_WRITE, - 0, NULL, OPEN_EXISTING, 0, NULL); + handle = CreateFile(port->pathname, GENERIC_READ | GENERIC_WRITE, + 0, NULL, OPEN_EXISTING, 0, NULL); - if (handle == INVALID_HANDLE_VALUE) { - rig_debug(RIG_DEBUG_ERR, "Opening device \"%s\"\n", port->pathname); - CloseHandle(handle); - return -RIG_EIO; - } else { - fd = _open_osfhandle((intptr_t)handle, _O_APPEND | _O_RDONLY); + if (handle == INVALID_HANDLE_VALUE) { + rig_debug(RIG_DEBUG_ERR, + "%s: opening device \"%s\"\n", + __func__, + port->pathname); + CloseHandle(handle); + return -RIG_EIO; + } else { + fd = _open_osfhandle((intptr_t)handle, _O_APPEND | _O_RDONLY); - if (fd == -1) - return -RIG_EIO; - } + if (fd == -1) { + return -RIG_EIO; + } + } #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif - port->fd = fd; - return fd; + port->fd = fd; + return fd; } + /** * \brief Close Parallel Port * \param port */ int par_close(hamlib_port_t *port) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H #elif defined(HAVE_DEV_PPBUS_PPI_H) #elif defined(__WIN64__) || defined(__WIN32__) - _close(port->fd); + _close(port->fd); - return RIG_OK; + return RIG_OK; #endif - return close(port->fd); + return close(port->fd); } + /** * \brief Send data on Parallel port * \param port @@ -206,35 +229,38 @@ int par_close(hamlib_port_t *port) */ int HAMLIB_API par_write_data(hamlib_port_t *port, unsigned char data) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int status; - status = ioctl(port->fd, PPWDATA, &data); - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + status = ioctl(port->fd, PPWDATA, &data); + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(HAVE_DEV_PPBUS_PPI_H) - int status; - status = ioctl(port->fd, PPISDATA, &data); - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + status = ioctl(port->fd, PPISDATA, &data); + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(__WIN64__) || defined(__WIN32__) - unsigned int dummy; + unsigned int dummy; - intptr_t handle; + intptr_t handle; - handle = _get_osfhandle(port->fd); + handle = _get_osfhandle(port->fd); - if (handle != (intptr_t)INVALID_HANDLE_VALUE) { - if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_DATA, &data, sizeof(data), - NULL, 0, (LPDWORD)&dummy, NULL))) { - rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __FUNCTION__); - return -RIG_EIO; - } - } + if (handle != (intptr_t)INVALID_HANDLE_VALUE) { + if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_DATA, &data, sizeof(data), + NULL, 0, (LPDWORD)&dummy, NULL))) { + rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __func__); + return -RIG_EIO; + } + } - return RIG_OK; + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Receive data on Parallel port * \param port @@ -242,37 +268,40 @@ int HAMLIB_API par_write_data(hamlib_port_t *port, unsigned char data) */ int HAMLIB_API par_read_data(hamlib_port_t *port, unsigned char *data) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int status; - status = ioctl(port->fd, PPRDATA, data); - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + status = ioctl(port->fd, PPRDATA, data); + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(HAVE_DEV_PPBUS_PPI_H) - int status; - status = ioctl(port->fd, PPIGDATA, &data); - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + status = ioctl(port->fd, PPIGDATA, &data); + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(__WIN64__) || defined(__WIN32__) - unsigned char ret; - unsigned int dummy; + unsigned char ret; + unsigned int dummy; - intptr_t handle; + intptr_t handle; - handle = _get_osfhandle(port->fd); + handle = _get_osfhandle(port->fd); - if (handle != (intptr_t)INVALID_HANDLE_VALUE) { - if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_STATUS, NULL, 0, &ret, - sizeof(ret), (LPDWORD)&dummy, NULL))) { - rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __FUNCTION__); - return -RIG_EIO; - } - } + if (handle != (intptr_t)INVALID_HANDLE_VALUE) { + if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_STATUS, NULL, 0, &ret, + sizeof(ret), (LPDWORD)&dummy, NULL))) { + rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __func__); + return -RIG_EIO; + } + } - *data = ret ^ S1284_INVERTED; - return RIG_OK; + *data = ret ^ S1284_INVERTED; + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Set control data for Parallel Port * \param port @@ -280,54 +309,71 @@ int HAMLIB_API par_read_data(hamlib_port_t *port, unsigned char *data) */ int HAMLIB_API par_write_control(hamlib_port_t *port, unsigned char control) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int status; - unsigned char ctrl = control ^ CP_ACTIVE_LOW_BITS; - status = ioctl(port->fd, PPWCONTROL, &ctrl); + int status; + unsigned char ctrl = control ^ CP_ACTIVE_LOW_BITS; + status = ioctl(port->fd, PPWCONTROL, &ctrl); - if (status < 0) - rig_debug(RIG_DEBUG_ERR, "ioctl(PPWCONTROL) failed: %s\n", strerror(errno)); + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: ioctl(PPWCONTROL) failed: %s\n", + __func__, + strerror(errno)); + } - return status == 0 ? RIG_OK : -RIG_EIO; + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(HAVE_DEV_PPBUS_PPI_H) - int status; - unsigned char ctrl = control ^ CP_ACTIVE_LOW_BITS; - status = ioctl(port->fd, PPISCTRL, &ctrl); - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + unsigned char ctrl = control ^ CP_ACTIVE_LOW_BITS; + status = ioctl(port->fd, PPISCTRL, &ctrl); + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(__WIN64__) || defined(__WIN32__) - unsigned char ctr = control; - unsigned char dummyc; - unsigned int dummy; - const unsigned char wm = (C1284_NSTROBE | - C1284_NAUTOFD | - C1284_NINIT | - C1284_NSELECTIN); - intptr_t handle; + unsigned char ctr = control; + unsigned char dummyc; + unsigned int dummy; + const unsigned char wm = (C1284_NSTROBE + | C1284_NAUTOFD + | C1284_NINIT + | C1284_NSELECTIN); + intptr_t handle; - if (ctr & 0x20) { - rig_debug(RIG_DEBUG_WARN, "use ieee1284_data_dir to change data line direction!\n"); - } + if (ctr & 0x20) { + rig_debug(RIG_DEBUG_WARN, + "%s: use ieee1284_data_dir to change data line direction!\n", + __func__); + } - /* Deal with inversion issues. */ - ctr ^= wm & C1284_INVERTED; - ctr = (ctr & ~wm) ^ (ctr & wm); + /* Deal with inversion issues. */ + ctr ^= wm & C1284_INVERTED; + ctr = (ctr & ~wm) ^ (ctr & wm); - handle = _get_osfhandle(port->fd); + handle = _get_osfhandle(port->fd); - if (handle != (intptr_t)INVALID_HANDLE_VALUE) { - if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_CONTROL, &ctr, - sizeof(ctr), &dummyc, sizeof(dummyc), (LPDWORD)&dummy, NULL))) { - rig_debug(RIG_DEBUG_ERR, "frob_control: DeviceIoControl failed!\n"); - return -RIG_EIO; - } - } + if (handle != (intptr_t)INVALID_HANDLE_VALUE) { + if (!(DeviceIoControl((HANDLE)handle, + NT_IOCTL_CONTROL, + &ctr, + sizeof(ctr), + &dummyc, + sizeof(dummyc), + (LPDWORD)&dummy, + NULL))) { + rig_debug(RIG_DEBUG_ERR, + "%s: frob_control: DeviceIoControl failed!\n", + __func__); + return -RIG_EIO; + } + } - return RIG_OK; + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Read control data for Parallel Port * \param port @@ -335,45 +381,53 @@ int HAMLIB_API par_write_control(hamlib_port_t *port, unsigned char control) */ int HAMLIB_API par_read_control(hamlib_port_t *port, unsigned char *control) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int status; - unsigned char ctrl; - status = ioctl(port->fd, PPRCONTROL, &ctrl); + int status; + unsigned char ctrl; + status = ioctl(port->fd, PPRCONTROL, &ctrl); - if (status < 0) - rig_debug(RIG_DEBUG_ERR, "ioctl(PPRCONTROL) failed: %s\n", strerror(errno)); + if (status < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: ioctl(PPRCONTROL) failed: %s\n", + __func__, + strerror(errno)); + } - *control = ctrl ^ CP_ACTIVE_LOW_BITS; - return status == 0 ? RIG_OK : -RIG_EIO; + *control = ctrl ^ CP_ACTIVE_LOW_BITS; + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(HAVE_DEV_PPBUS_PPI_H) - int status; - unsigned char ctrl; - status = ioctl(port->fd, PPIGCTRL, &ctrl); - *control = ctrl ^ CP_ACTIVE_LOW_BITS; - return status == 0 ? RIG_OK : -RIG_EIO; + int status; + unsigned char ctrl; + status = ioctl(port->fd, PPIGCTRL, &ctrl); + *control = ctrl ^ CP_ACTIVE_LOW_BITS; + return status == 0 ? RIG_OK : -RIG_EIO; #elif defined(__WIN64__) || defined(__WIN32__) - unsigned char ret; - unsigned int dummy; + unsigned char ret; + unsigned int dummy; - intptr_t handle; + intptr_t handle; - handle = _get_osfhandle(port->fd); + handle = _get_osfhandle(port->fd); - if (handle != (intptr_t)INVALID_HANDLE_VALUE) { - if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_CONTROL, NULL, 0, &ret, - sizeof(ret), (LPDWORD)&dummy, NULL))) { - rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __FUNCTION__); - return -RIG_EIO; - } - } + if (handle != (intptr_t)INVALID_HANDLE_VALUE) { + if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_CONTROL, NULL, 0, &ret, + sizeof(ret), (LPDWORD)&dummy, NULL))) { + rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __func__); + return -RIG_EIO; + } + } - *control = ret ^ S1284_INVERTED; - return RIG_OK; + *control = ret ^ S1284_INVERTED; + + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Get parallel port status * \param port @@ -382,41 +436,45 @@ int HAMLIB_API par_read_control(hamlib_port_t *port, unsigned char *control) */ int HAMLIB_API par_read_status(hamlib_port_t *port, unsigned char *status) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - int ret; - unsigned char sta; - ret = ioctl(port->fd, PPRSTATUS, &sta); - *status = sta ^ SP_ACTIVE_LOW_BITS; - return ret == 0 ? RIG_OK : -RIG_EIO; + int ret; + unsigned char sta; + ret = ioctl(port->fd, PPRSTATUS, &sta); + *status = sta ^ SP_ACTIVE_LOW_BITS; + return ret == 0 ? RIG_OK : -RIG_EIO; #elif defined(HAVE_DEV_PPBUS_PPI_H) - int ret; - unsigned char sta; - ret = ioctl(port->fd, PPIGSTATUS, &sta); - *status = sta ^ SP_ACTIVE_LOW_BITS; - return ret == 0 ? RIG_OK : -RIG_EIO; + int ret; + unsigned char sta; + ret = ioctl(port->fd, PPIGSTATUS, &sta); + *status = sta ^ SP_ACTIVE_LOW_BITS; + return ret == 0 ? RIG_OK : -RIG_EIO; #elif defined(__WIN64__) || defined(__WIN32__) - unsigned char ret; - unsigned int dummy; + unsigned char ret; + unsigned int dummy; - intptr_t handle; + intptr_t handle; - handle = _get_osfhandle(port->fd); + handle = _get_osfhandle(port->fd); - if (handle != (intptr_t)INVALID_HANDLE_VALUE) { - if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_STATUS, NULL, 0, &ret, - sizeof(ret), (LPDWORD)&dummy, NULL))) { - rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __FUNCTION__); - return -RIG_EIO; - } - } + if (handle != (intptr_t)INVALID_HANDLE_VALUE) { + if (!(DeviceIoControl((HANDLE)handle, NT_IOCTL_STATUS, NULL, 0, &ret, + sizeof(ret), (LPDWORD)&dummy, NULL))) { + rig_debug(RIG_DEBUG_ERR, "%s: DeviceIoControl failed!\n", __func__); + return -RIG_EIO; + } + } - *status = ret ^ S1284_INVERTED; - return RIG_OK; + *status = ret ^ S1284_INVERTED; + + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Get a lock on the Parallel Port * \param port @@ -424,23 +482,30 @@ int HAMLIB_API par_read_status(hamlib_port_t *port, unsigned char *status) */ int HAMLIB_API par_lock(hamlib_port_t *port) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - if (ioctl(port->fd, PPCLAIM) < 0) { - rig_debug(RIG_DEBUG_ERR, "Claiming device \"%s\": %s\n", port->pathname, strerror(errno)); - return -RIG_EIO; - } + if (ioctl(port->fd, PPCLAIM) < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: claiming device \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + return -RIG_EIO; + } - return RIG_OK; + return RIG_OK; #elif defined(HAVE_DEV_PPBUS_PPI_H) - return RIG_OK; + return RIG_OK; #elif defined(__WIN64__) || defined(__WIN32__) - return RIG_OK; + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Release lock on Parallel Port * \param port @@ -448,23 +513,30 @@ int HAMLIB_API par_lock(hamlib_port_t *port) */ int HAMLIB_API par_unlock(hamlib_port_t *port) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #ifdef HAVE_LINUX_PPDEV_H - if (ioctl(port->fd, PPRELEASE) < 0) { - rig_debug(RIG_DEBUG_ERR, "Releasing device \"%s\": %s\n", port->pathname, strerror(errno)); - return -RIG_EIO; - } + if (ioctl(port->fd, PPRELEASE) < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: releasing device \"%s\": %s\n", + __func__, + port->pathname, + strerror(errno)); + return -RIG_EIO; + } - return RIG_OK; + return RIG_OK; #elif defined(HAVE_DEV_PPBUS_PPI_H) - return RIG_OK; + return RIG_OK; #elif defined(__WIN64__) || defined(__WIN32__) - return RIG_OK; + return RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + #ifndef PARPORT_CONTROL_STROBE #define PARPORT_CONTROL_STROBE 0x1 #endif @@ -472,6 +544,7 @@ int HAMLIB_API par_unlock(hamlib_port_t *port) #define PARPORT_CONTROL_INIT 0x4 #endif + /** * \brief Set or unset Push to talk bit on Parallel Port * \param p @@ -480,42 +553,49 @@ int HAMLIB_API par_unlock(hamlib_port_t *port) */ int par_ptt_set(hamlib_port_t *p, ptt_t pttx) { - switch (p->type.ptt) { - case RIG_PTT_PARALLEL: { - unsigned char ctl; - int status; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - par_lock(p); - status = par_read_control(p, &ctl); + switch (p->type.ptt) { + case RIG_PTT_PARALLEL: { + unsigned char ctl; + int status; - if (status != RIG_OK) - return status; + par_lock(p); + status = par_read_control(p, &ctl); - /* Enable CW & PTT - /STROBE bit (pin 1) */ - ctl &= ~PARPORT_CONTROL_STROBE; + if (status != RIG_OK) { + return status; + } - /* TODO: kill parm.parallel.pin? */ + /* Enable CW & PTT - /STROBE bit (pin 1) */ + ctl &= ~PARPORT_CONTROL_STROBE; - /* PTT keying - /INIT bit (pin 16) (inverted) */ - if (pttx == RIG_PTT_ON) - ctl |= PARPORT_CONTROL_INIT; - else - ctl &= ~PARPORT_CONTROL_INIT; + /* TODO: kill parm.parallel.pin? */ - status = par_write_control(p, ctl); - par_unlock(p); - return status; - } + /* PTT keying - /INIT bit (pin 16) (inverted) */ + if (pttx == RIG_PTT_ON) { + ctl |= PARPORT_CONTROL_INIT; + } else { + ctl &= ~PARPORT_CONTROL_INIT; + } - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported PTT type %d\n", - p->type.ptt); - return -RIG_EINVAL; - } + status = par_write_control(p, ctl); + par_unlock(p); + return status; + } - return RIG_OK; + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported PTT type %d\n", + __func__, + p->type.ptt); + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief Get state of Push to Talk from Parallel Port * \param p @@ -524,30 +604,35 @@ int par_ptt_set(hamlib_port_t *p, ptt_t pttx) */ int par_ptt_get(hamlib_port_t *p, ptt_t *pttx) { - switch (p->type.ptt) { - case RIG_PTT_PARALLEL: { - unsigned char ctl; - int status; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - par_lock(p); - status = par_read_control(p, &ctl); - par_unlock(p); + switch (p->type.ptt) { + case RIG_PTT_PARALLEL: { + unsigned char ctl; + int status; - *pttx = (ctl & PARPORT_CONTROL_INIT) && - !(ctl & PARPORT_CONTROL_STROBE) ? - RIG_PTT_ON : RIG_PTT_OFF; - return status; - } + par_lock(p); + status = par_read_control(p, &ctl); + par_unlock(p); - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported PTT type %d\n", - p->type.ptt); - return -RIG_ENAVAIL; - } + *pttx = (ctl & PARPORT_CONTROL_INIT) && + !(ctl & PARPORT_CONTROL_STROBE) ? + RIG_PTT_ON : RIG_PTT_OFF; + return status; + } - return RIG_OK; + default: + rig_debug(RIG_DEBUG_ERR, + "Unsupported PTT type %d\n", + __func__, + p->type.ptt); + return -RIG_ENAVAIL; + } + + return RIG_OK; } + /** * \brief get Data Carrier Detect (squelch) from Parallel Port * \param p @@ -556,24 +641,28 @@ int par_ptt_get(hamlib_port_t *p, ptt_t *pttx) */ int par_dcd_get(hamlib_port_t *p, dcd_t *dcdx) { - switch (p->type.dcd) { - case RIG_DCD_PARALLEL: { - unsigned char reg; - int status; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - status = par_read_data(p, ®); - *dcdx = reg & (1 << p->parm.parallel.pin) ? - RIG_DCD_ON : RIG_DCD_OFF; - return status; - } + switch (p->type.dcd) { + case RIG_DCD_PARALLEL: { + unsigned char reg; + int status; - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported DCD type %d\n", - p->type.dcd); - return -RIG_ENAVAIL; - } + status = par_read_data(p, ®); + *dcdx = reg & (1 << p->parm.parallel.pin) ? + RIG_DCD_ON : RIG_DCD_OFF; + return status; + } - return RIG_OK; + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported DCD type %d\n", + __func__, + p->type.dcd); + return -RIG_ENAVAIL; + } + + return RIG_OK; } /** @} */ diff --git a/src/parallel.h b/src/parallel.h index 265ee8f7d..0bf6cba31 100644 --- a/src/parallel.h +++ b/src/parallel.h @@ -69,10 +69,16 @@ int par_ptt_get(hamlib_port_t *p, ptt_t *pttx); int par_dcd_get(hamlib_port_t *p, dcd_t *dcdx); extern HAMLIB_EXPORT(int) par_write_data(hamlib_port_t *p, unsigned char data); -extern HAMLIB_EXPORT(int) par_write_control(hamlib_port_t *p, unsigned char control); +extern HAMLIB_EXPORT(int) par_write_control(hamlib_port_t *p, + unsigned char control); + extern HAMLIB_EXPORT(int) par_read_data(hamlib_port_t *p, unsigned char *data); -extern HAMLIB_EXPORT(int) par_read_control(hamlib_port_t *p, unsigned char *control); -extern HAMLIB_EXPORT(int) par_read_status(hamlib_port_t *p, unsigned char *status); +extern HAMLIB_EXPORT(int) par_read_control(hamlib_port_t *p, + unsigned char *control); + +extern HAMLIB_EXPORT(int) par_read_status(hamlib_port_t *p, + unsigned char *status); + extern HAMLIB_EXPORT(int) par_lock(hamlib_port_t *p); extern HAMLIB_EXPORT(int) par_unlock(hamlib_port_t *p); diff --git a/src/register.c b/src/register.c index dd78889d3..6c502697c 100644 --- a/src/register.c +++ b/src/register.c @@ -48,8 +48,8 @@ #define RIG_BACKEND_MAX 32 #define DEFINE_INITRIG_BACKEND(backend) \ - int MAKE_VERSIONED_FN(PREFIX_INITRIG, ABI_VERSION, backend(void *be_handle)); \ - rig_model_t MAKE_VERSIONED_FN(PREFIX_PROBERIG, ABI_VERSION, backend(hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)) + int MAKE_VERSIONED_FN(PREFIX_INITRIG, ABI_VERSION, backend(void *be_handle)); \ + rig_model_t MAKE_VERSIONED_FN(PREFIX_PROBERIG, ABI_VERSION, backend(hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)) #define RIG_FUNCNAMA(backend) MAKE_VERSIONED_FN(PREFIX_INITRIG, ABI_VERSION, backend) #define RIG_FUNCNAMB(backend) MAKE_VERSIONED_FN(PREFIX_PROBERIG, ABI_VERSION, backend) @@ -57,11 +57,8 @@ #define RIG_FUNCNAM(backend) RIG_FUNCNAMA(backend),RIG_FUNCNAMB(backend) /* - * RIG_BACKEND_LIST is defined here, please keep it up to data, - * ie. each time you give birth to a new backend - * Also, it should be possible to register "external" backend, - * that is backend that were not known by Hamlib at compile time. - * Maybe, riglist.h should reserve some numbers for them? --SF + * RIG_BACKEND_LIST is defined here, please keep it up to date, + * i.e. each time you implement a new backend. */ DEFINE_INITRIG_BACKEND(dummy); DEFINE_INITRIG_BACKEND(yaesu); @@ -104,95 +101,109 @@ DEFINE_INITRIG_BACKEND(winradio); * and the branch name, which is a character string. */ static struct { - int be_num; - const char *be_name; - int (* be_init_all)(void * handle); - rig_model_t (* be_probe_all)(hamlib_port_t*, rig_probe_func_t, rig_ptr_t); -} rig_backend_list[RIG_BACKEND_MAX] = -{ - { RIG_DUMMY, RIG_BACKEND_DUMMY, RIG_FUNCNAMA(dummy) }, - { RIG_YAESU, RIG_BACKEND_YAESU, RIG_FUNCNAM(yaesu) }, - { RIG_KENWOOD, RIG_BACKEND_KENWOOD, RIG_FUNCNAM(kenwood) }, - { RIG_ICOM, RIG_BACKEND_ICOM, RIG_FUNCNAM(icom) }, - { RIG_ICMARINE, RIG_BACKEND_ICMARINE, RIG_FUNCNAMA(icmarine) }, - { RIG_PCR, RIG_BACKEND_PCR, RIG_FUNCNAMA(pcr) }, - { RIG_AOR, RIG_BACKEND_AOR, RIG_FUNCNAMA(aor) }, - { RIG_JRC, RIG_BACKEND_JRC, RIG_FUNCNAMA(jrc) }, - { RIG_UNIDEN, RIG_BACKEND_UNIDEN, RIG_FUNCNAM(uniden) }, - { RIG_DRAKE, RIG_BACKEND_DRAKE, RIG_FUNCNAM(drake) }, - { RIG_LOWE, RIG_BACKEND_LOWE, RIG_FUNCNAM(lowe) }, - { RIG_RACAL, RIG_BACKEND_RACAL, RIG_FUNCNAMA(racal) }, - { RIG_WJ, RIG_BACKEND_WJ, RIG_FUNCNAMA(wj) }, - { RIG_SKANTI, RIG_BACKEND_SKANTI, RIG_FUNCNAMA(skanti) }, + int be_num; + const char *be_name; + int (* be_init_all)(void *handle); + rig_model_t (* be_probe_all)(hamlib_port_t *, rig_probe_func_t, rig_ptr_t); +} rig_backend_list[RIG_BACKEND_MAX] = { + { RIG_DUMMY, RIG_BACKEND_DUMMY, RIG_FUNCNAMA(dummy) }, + { RIG_YAESU, RIG_BACKEND_YAESU, RIG_FUNCNAM(yaesu) }, + { RIG_KENWOOD, RIG_BACKEND_KENWOOD, RIG_FUNCNAM(kenwood) }, + { RIG_ICOM, RIG_BACKEND_ICOM, RIG_FUNCNAM(icom) }, + { RIG_ICMARINE, RIG_BACKEND_ICMARINE, RIG_FUNCNAMA(icmarine) }, + { RIG_PCR, RIG_BACKEND_PCR, RIG_FUNCNAMA(pcr) }, + { RIG_AOR, RIG_BACKEND_AOR, RIG_FUNCNAMA(aor) }, + { RIG_JRC, RIG_BACKEND_JRC, RIG_FUNCNAMA(jrc) }, + { RIG_UNIDEN, RIG_BACKEND_UNIDEN, RIG_FUNCNAM(uniden) }, + { RIG_DRAKE, RIG_BACKEND_DRAKE, RIG_FUNCNAM(drake) }, + { RIG_LOWE, RIG_BACKEND_LOWE, RIG_FUNCNAM(lowe) }, + { RIG_RACAL, RIG_BACKEND_RACAL, RIG_FUNCNAMA(racal) }, + { RIG_WJ, RIG_BACKEND_WJ, RIG_FUNCNAMA(wj) }, + { RIG_SKANTI, RIG_BACKEND_SKANTI, RIG_FUNCNAMA(skanti) }, #ifdef HAVE_WINRADIO - { RIG_WINRADIO, RIG_BACKEND_WINRADIO, RIG_FUNCNAMA(winradio) }, + { RIG_WINRADIO, RIG_BACKEND_WINRADIO, RIG_FUNCNAMA(winradio) }, #endif /* HAVE_WINRADIO */ - { RIG_TENTEC, RIG_BACKEND_TENTEC, RIG_FUNCNAMA(tentec) }, - { RIG_ALINCO, RIG_BACKEND_ALINCO, RIG_FUNCNAMA(alinco) }, - { RIG_KACHINA, RIG_BACKEND_KACHINA, RIG_FUNCNAMA(kachina) }, - { RIG_TAPR, RIG_BACKEND_TAPR, RIG_FUNCNAMA(tapr) }, - { RIG_FLEXRADIO, RIG_BACKEND_FLEXRADIO, RIG_FUNCNAMA(flexradio) }, - { RIG_RFT, RIG_BACKEND_RFT, RIG_FUNCNAMA(rft) }, - { RIG_KIT, RIG_BACKEND_KIT, RIG_FUNCNAMA(kit) }, - { RIG_TUNER, RIG_BACKEND_TUNER, RIG_FUNCNAMA(tuner) }, - { RIG_RS, RIG_BACKEND_RS, RIG_FUNCNAMA(rs) }, - { RIG_PRM80, RIG_BACKEND_PRM80, RIG_FUNCNAMA(prm80) }, - { RIG_ADAT, RIG_BACKEND_ADAT, RIG_FUNCNAM(adat) }, - { RIG_DORJI, RIG_BACKEND_DORJI, RIG_FUNCNAMA(dorji) }, - { RIG_BARRETT, RIG_BACKEND_BARRETT, RIG_FUNCNAMA(barrett) }, - { 0, NULL }, /* end */ + { RIG_TENTEC, RIG_BACKEND_TENTEC, RIG_FUNCNAMA(tentec) }, + { RIG_ALINCO, RIG_BACKEND_ALINCO, RIG_FUNCNAMA(alinco) }, + { RIG_KACHINA, RIG_BACKEND_KACHINA, RIG_FUNCNAMA(kachina) }, + { RIG_TAPR, RIG_BACKEND_TAPR, RIG_FUNCNAMA(tapr) }, + { RIG_FLEXRADIO, RIG_BACKEND_FLEXRADIO, RIG_FUNCNAMA(flexradio) }, + { RIG_RFT, RIG_BACKEND_RFT, RIG_FUNCNAMA(rft) }, + { RIG_KIT, RIG_BACKEND_KIT, RIG_FUNCNAMA(kit) }, + { RIG_TUNER, RIG_BACKEND_TUNER, RIG_FUNCNAMA(tuner) }, + { RIG_RS, RIG_BACKEND_RS, RIG_FUNCNAMA(rs) }, + { RIG_PRM80, RIG_BACKEND_PRM80, RIG_FUNCNAMA(prm80) }, + { RIG_ADAT, RIG_BACKEND_ADAT, RIG_FUNCNAM(adat) }, + { RIG_DORJI, RIG_BACKEND_DORJI, RIG_FUNCNAMA(dorji) }, + { RIG_BARRETT, RIG_BACKEND_BARRETT, RIG_FUNCNAMA(barrett) }, + { 0, NULL }, /* end */ }; + /* * This struct to keep track of known rig models. * It is chained, and used in a hash table, see below. */ struct rig_list { - const struct rig_caps *caps; - struct rig_list *next; + const struct rig_caps *caps; + struct rig_list *next; }; + #define RIGLSTHASHSZ 16 #define HASH_FUNC(a) ((a)%RIGLSTHASHSZ) + /* * The rig_hash_table is a hash table pointing to a list of next==NULL - * terminated caps. + * terminated caps. */ static struct rig_list *rig_hash_table[RIGLSTHASHSZ] = { NULL, }; static int rig_lookup_backend(rig_model_t rig_model); + /* * Basically, this is a hash insert function that doesn't check for dup! */ int HAMLIB_API rig_register(const struct rig_caps *caps) { - int hval; - struct rig_list *p; + int hval; + struct rig_list *p; - if (!caps) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model); + if (!caps) { + return -RIG_EINVAL; + } + + rig_debug(RIG_DEBUG_VERBOSE, + "%s: rig_register (%d)\n", + __func__, + caps->rig_model); #ifndef DONT_WANT_DUP_CHECK - if (rig_get_caps(caps->rig_model)!=NULL) - return -RIG_EINVAL; + + if (rig_get_caps(caps->rig_model) != NULL) { + return -RIG_EINVAL; + } + #endif - p = (struct rig_list*)malloc(sizeof(struct rig_list)); - if (!p) - return -RIG_ENOMEM; + p = (struct rig_list *)malloc(sizeof(struct rig_list)); - hval = HASH_FUNC(caps->rig_model); - p->caps = caps; - // p->handle = NULL; - p->next = rig_hash_table[hval]; - rig_hash_table[hval] = p; + if (!p) { + return -RIG_ENOMEM; + } - return RIG_OK; + hval = HASH_FUNC(caps->rig_model); + p->caps = caps; + // p->handle = NULL; + p->next = rig_hash_table[hval]; + rig_hash_table[hval] = p; + + return RIG_OK; } /* @@ -200,16 +211,17 @@ int HAMLIB_API rig_register(const struct rig_caps *caps) * ie. rig_hash_table lookup */ -const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model) +const struct rig_caps *HAMLIB_API rig_get_caps(rig_model_t rig_model) { - struct rig_list *p; + struct rig_list *p; - for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p=p->next) { - if (p->caps->rig_model == rig_model) - return p->caps; - } + for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p = p->next) { + if (p->caps->rig_model == rig_model) { + return p->caps; + } + } - return NULL; /* sorry, caps not registered! */ + return NULL; /* sorry, caps not registered! */ } /* @@ -219,15 +231,16 @@ const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model) */ static int rig_lookup_backend(rig_model_t rig_model) { - int i; + int i; - for (i=0; inext) { - if (p->caps->rig_model == rig_model) { - if (q == NULL) - rig_hash_table[hval] = p->next; - else - q->next = p->next; + hval = HASH_FUNC(rig_model); + q = NULL; - free(p); - return RIG_OK; - } - q = p; - } + for (p = rig_hash_table[hval]; p; p = p->next) { + if (p->caps->rig_model == rig_model) { + if (q == NULL) { + rig_hash_table[hval] = p->next; + } else { + q->next = p->next; + } - return -RIG_EINVAL; /* sorry, caps not registered! */ + free(p); + return RIG_OK; + } + + q = p; + } + + return -RIG_EINVAL; /* sorry, caps not registered! */ } /* * rig_list_foreach * executes cfunc on all the elements stored in the rig hash list */ -int HAMLIB_API rig_list_foreach(int (*cfunc)(const struct rig_caps*, rig_ptr_t),rig_ptr_t data) +int HAMLIB_API rig_list_foreach(int (*cfunc)(const struct rig_caps *, + rig_ptr_t), rig_ptr_t data) { - struct rig_list *p; - int i; + struct rig_list *p; + int i; - if (!cfunc) - return -RIG_EINVAL; - - for (i=0; inext; /* read before call in case it is unregistered */ - if ((*cfunc)(p->caps,data) == 0) - return RIG_OK; + if (!cfunc) { + return -RIG_EINVAL; } - } - return RIG_OK; + for (i = 0; i < RIGLSTHASHSZ; i++) { + struct rig_list *next = NULL; + + for (p = rig_hash_table[i]; p; p = next) { + next = p->next; /* read before call in case it is unregistered */ + + if ((*cfunc)(p->caps, data) == 0) { + return RIG_OK; + } + } + } + + return RIG_OK; } -static int dummy_rig_probe(const hamlib_port_t *p, rig_model_t model, rig_ptr_t data) +static int dummy_rig_probe(const hamlib_port_t *p, rig_model_t model, + rig_ptr_t data) { - rig_debug(RIG_DEBUG_TRACE, "Found rig, model %d\n", model); - return RIG_OK; + rig_debug(RIG_DEBUG_TRACE, "Found rig, model %d\n", model); + return RIG_OK; } /* @@ -325,46 +349,52 @@ static int dummy_rig_probe(const hamlib_port_t *p, rig_model_t model, rig_ptr_t */ rig_model_t rig_probe_first(hamlib_port_t *p) { - int i; - rig_model_t model; + int i; + rig_model_t model; - for (i=0; i @@ -60,7 +60,7 @@ #include -#include "hamlib/rig.h" +#include #include "serial.h" #include "parallel.h" #include "usb_port.h" @@ -86,94 +86,97 @@ const char *hamlib_version2 = "Hamlib " PACKAGE_VERSION; * \brief Hamlib copyright notice */ const char *hamlib_copyright2 = - "Copyright (C) 2000-2012 Stephane Fillod\n" - "Copyright (C) 2000-2003 Frank Singleton\n" - "This is free software; see the source for copying conditions. There is NO\n" - "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."; + "Copyright (C) 2000-2012 Stephane Fillod\n" + "Copyright (C) 2000-2003 Frank Singleton\n" + "This is free software; see the source for copying conditions. There is NO\n" + "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."; const char hamlib_copyright[231] = /* hamlib 1.2 ABI specifies 231 bytes */ - "Copyright (C) 2000-2012 Stephane Fillod\n" - "Copyright (C) 2000-2003 Frank Singleton\n" - "This is free software; see the source for copying conditions. There is NO\n" - "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."; + "Copyright (C) 2000-2012 Stephane Fillod\n" + "Copyright (C) 2000-2003 Frank Singleton\n" + "This is free software; see the source for copying conditions. There is NO\n" + "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."; #ifndef DOC_HIDDEN #if defined(WIN32) && !defined(__CYGWIN__) -#define DEFAULT_SERIAL_PORT "\\\\.\\COM1" +# define DEFAULT_SERIAL_PORT "\\\\.\\COM1" #elif BSD -#define DEFAULT_SERIAL_PORT "/dev/cuaa0" +# define DEFAULT_SERIAL_PORT "/dev/cuaa0" #elif MACOSX -#define DEFAULT_SERIAL_PORT "/dev/cu.usbserial" +# define DEFAULT_SERIAL_PORT "/dev/cu.usbserial" #else -#define DEFAULT_SERIAL_PORT "/dev/ttyS0" +# define DEFAULT_SERIAL_PORT "/dev/ttyS0" #endif #if defined(WIN32) -#define DEFAULT_PARALLEL_PORT "\\\\.\\$VDMLPT1" +# define DEFAULT_PARALLEL_PORT "\\\\.\\$VDMLPT1" #elif defined(HAVE_DEV_PPBUS_PPI_H) -#define DEFAULT_PARALLEL_PORT "/dev/ppi0" +# define DEFAULT_PARALLEL_PORT "/dev/ppi0" #else -#define DEFAULT_PARALLEL_PORT "/dev/parport0" +# define DEFAULT_PARALLEL_PORT "/dev/parport0" #endif #if defined(WIN32) && !defined(__CYGWIN__) -#define DEFAULT_CM108_PORT "fixme" +# define DEFAULT_CM108_PORT "fixme" #elif BSD -#define DEFAULT_CM108_PORT "fixme" +# define DEFAULT_CM108_PORT "fixme" #else -#define DEFAULT_CM108_PORT "/dev/hidraw0" +# define DEFAULT_CM108_PORT "/dev/hidraw0" #endif #if defined(WIN32) && !defined(__CYGWIN__) /* FIXME: Determine correct GPIO bit number for W32 using MinGW. */ -#define DEFAULT_CM108_PTT_BITNUM 2 +# define DEFAULT_CM108_PTT_BITNUM 2 #elif BSD /* FIXME: Determine correct GPIO bit number for *BSD. */ -#define DEFAULT_CM108_PTT_BITNUM 2 +# define DEFAULT_CM108_PTT_BITNUM 2 #else -#define DEFAULT_CM108_PTT_BITNUM 2 +# define DEFAULT_CM108_PTT_BITNUM 2 #endif #define DEFAULT_GPIO_PORT "0" #define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) + /* * Data structure to track the opened rig (by rig_open) */ struct opened_rig_l { - RIG *rig; - struct opened_rig_l *next; + RIG *rig; + struct opened_rig_l *next; }; static struct opened_rig_l *opened_rig_list = { NULL }; + /* * Careful, the order must be the same as their RIG_E* counterpart! * TODO: localise the messages.. */ static const char *rigerror_table[] = { - "Command completed successfully", - "Invalid parameter", - "Invalid configuration", - "Memory shortage", - "Feature not implemented", - "Communication timed out", - "IO error", - "Internal Hamlib error", - "Protocol error", - "Command rejected by the rig", - "Command performed, but arg truncated, result not guaranteed", - "Feature not available", - "Target VFO unaccessible", - "Communication bus error", - "Communication bus collision", - "NULL RIG handle or invalid pointer parameter", - "Invalid VFO", - "Argument out of domain of func", - NULL, + "Command completed successfully", + "Invalid parameter", + "Invalid configuration", + "Memory shortage", + "Feature not implemented", + "Communication timed out", + "IO error", + "Internal Hamlib error", + "Protocol error", + "Command rejected by the rig", + "Command performed, but arg truncated, result not guaranteed", + "Feature not available", + "Target VFO unaccessible", + "Communication bus error", + "Communication bus collision", + "NULL RIG handle or invalid pointer parameter", + "Invalid VFO", + "Argument out of domain of func", + NULL, }; + #define ERROR_TBL_SZ (sizeof(rigerror_table)/sizeof(char *)) /* @@ -182,42 +185,50 @@ static const char *rigerror_table[] = { */ static int add_opened_rig(RIG *rig) { - struct opened_rig_l *p; + struct opened_rig_l *p; - p = (struct opened_rig_l *)malloc(sizeof(struct opened_rig_l)); - if (!p) - return -RIG_ENOMEM; - p->rig = rig; - p->next = opened_rig_list; - opened_rig_list = p; + p = (struct opened_rig_l *)malloc(sizeof(struct opened_rig_l)); - return RIG_OK; + if (!p) { + return -RIG_ENOMEM; + } + + p->rig = rig; + p->next = opened_rig_list; + opened_rig_list = p; + + return RIG_OK; } + static int remove_opened_rig(RIG *rig) { - struct opened_rig_l *p,*q; - q = NULL; + struct opened_rig_l *p, *q; + q = NULL; - for (p=opened_rig_list; p; p=p->next) { - if (p->rig == rig) { - if (q == NULL) { - opened_rig_list = opened_rig_list->next; - } else { - q->next = p->next; - } - free(p); - return RIG_OK; - } - q = p; - } - return -RIG_EINVAL; /* Not found in list ! */ + for (p = opened_rig_list; p; p = p->next) { + if (p->rig == rig) { + if (q == NULL) { + opened_rig_list = opened_rig_list->next; + } else { + q->next = p->next; + } + + free(p); + return RIG_OK; + } + + q = p; + } + + return -RIG_EINVAL; /* Not found in list ! */ } + /** * \brief execs cfunc() on each opened rig - * \param cfunc The function to be executed on each rig - * \param data Data pointer to be passed to cfunc() + * \param cfunc The function to be executed on each rig + * \param data Data pointer to be passed to cfunc() * * Calls cfunc() function for each opened rig. * The contents of the opened rig table @@ -232,23 +243,25 @@ static int remove_opened_rig(RIG *rig) * * \return always RIG_OK. */ - int foreach_opened_rig(int (*cfunc)(RIG *, rig_ptr_t), rig_ptr_t data) { - struct opened_rig_l *p; + struct opened_rig_l *p; - for (p=opened_rig_list; p; p=p->next) { - if ((*cfunc)(p->rig,data) == 0) - return RIG_OK; - } - return RIG_OK; + for (p = opened_rig_list; p; p = p->next) { + if ((*cfunc)(p->rig, data) == 0) { + return RIG_OK; + } + } + + return RIG_OK; } #endif /* !DOC_HIDDEN */ + /** * \brief get string describing the error code - * \param errnum The error code + * \param errnum The error code * \return the appropriate description string, otherwise a NULL pointer * if the error code is unknown. * @@ -256,17 +269,21 @@ int foreach_opened_rig(int (*cfunc)(RIG *, rig_ptr_t), rig_ptr_t data) * * \todo support gettext/localization */ -const char * HAMLIB_API rigerror(int errnum) +const char *HAMLIB_API rigerror(int errnum) { - errnum = abs(errnum); - if (errnum > ERROR_TBL_SZ) - return NULL; - return rigerror_table[errnum]; + errnum = abs(errnum); + + if (errnum > ERROR_TBL_SZ) { + return NULL; + } + + return rigerror_table[errnum]; } + /** * \brief allocate a new RIG handle - * \param rig_model The rig model for this new handle + * \param rig_model The rig model for this new handle * * Allocates a new RIG handle and initializes the associated data * for \a rig_model. @@ -276,184 +293,193 @@ const char * HAMLIB_API rigerror(int errnum) * * \sa rig_cleanup(), rig_open() */ - -RIG * HAMLIB_API rig_init(rig_model_t rig_model) +RIG *HAMLIB_API rig_init(rig_model_t rig_model) { - RIG *rig; - const struct rig_caps *caps; - struct rig_state *rs; - int i, retcode; + RIG *rig; + const struct rig_caps *caps; + struct rig_state *rs; + int i, retcode; - rig_debug(RIG_DEBUG_VERBOSE,"rig:rig_init called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rig_check_backend(rig_model); + rig_check_backend(rig_model); - caps = rig_get_caps(rig_model); - if (!caps) - return NULL; + caps = rig_get_caps(rig_model); - /* - * okay, we've found it. Allocate some memory and set it to zeros, - * and especially the callbacks - */ - rig = calloc(1, sizeof(RIG)); - if (rig == NULL) { - /* - * FIXME: how can the caller know it's a memory shortage, - * and not "rig not found" ? - */ - return NULL; - } + if (!caps) { + return NULL; + } - /* caps is const, so we need to tell compiler - that we now what we are doing */ - rig->caps = (struct rig_caps *) caps; + /* + * okay, we've found it. Allocate some memory and set it to zeros, + * and especially the callbacks + */ + rig = calloc(1, sizeof(RIG)); - /* - * populate the rig->state - * TODO: read the Preferences here! - */ + if (rig == NULL) { + /* + * FIXME: how can the caller know it's a memory shortage, + * and not "rig not found" ? + */ + return NULL; + } - rs = &rig->state; + /* caps is const, so we need to tell compiler + that we know what we are doing */ + rig->caps = (struct rig_caps *) caps; - rs->rigport.fd = -1; - rs->pttport.fd = -1; - rs->pttport.fd = -1; - rs->comm_state = 0; - rs->rigport.type.rig = caps->port_type; /* default from caps */ + /* + * populate the rig->state + * TODO: read the Preferences here! + */ + rs = &rig->state; - switch (caps->port_type) { - case RIG_PORT_SERIAL: - strncpy(rs->rigport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN - 1); - rs->rigport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */ - rs->rigport.parm.serial.data_bits = caps->serial_data_bits; - rs->rigport.parm.serial.stop_bits = caps->serial_stop_bits; - rs->rigport.parm.serial.parity = caps->serial_parity; - rs->rigport.parm.serial.handshake = caps->serial_handshake; - break; + rs->rigport.fd = -1; + rs->pttport.fd = -1; + rs->pttport.fd = -1; + rs->comm_state = 0; + rs->rigport.type.rig = caps->port_type; /* default from caps */ - case RIG_PORT_PARALLEL: - strncpy(rs->rigport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN - 1); - break; + switch (caps->port_type) { + case RIG_PORT_SERIAL: + strncpy(rs->rigport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN - 1); + rs->rigport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */ + rs->rigport.parm.serial.data_bits = caps->serial_data_bits; + rs->rigport.parm.serial.stop_bits = caps->serial_stop_bits; + rs->rigport.parm.serial.parity = caps->serial_parity; + rs->rigport.parm.serial.handshake = caps->serial_handshake; + break; - /* Adding support for CM108 GPIO. This is compatible with CM108 series - * USB audio chips from CMedia and SSS1623 series USB audio chips from 3S - */ - case RIG_PORT_CM108: - strncpy(rs->rigport.pathname, DEFAULT_CM108_PORT, FILPATHLEN); - rs->rigport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM; - break; - - case RIG_PORT_GPIO: - strncpy(rs->rigport.pathname, DEFAULT_GPIO_PORT, FILPATHLEN); - break; + case RIG_PORT_PARALLEL: + strncpy(rs->rigport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN - 1); + break; - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: - strncpy(rs->rigport.pathname, "127.0.0.1:4532", FILPATHLEN - 1); - break; + /* Adding support for CM108 GPIO. This is compatible with CM108 series + * USB audio chips from CMedia and SSS1623 series USB audio chips from 3S + */ + case RIG_PORT_CM108: + strncpy(rs->rigport.pathname, DEFAULT_CM108_PORT, FILPATHLEN); + rs->rigport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM; + break; - default: - strncpy(rs->rigport.pathname, "", FILPATHLEN - 1); - } + case RIG_PORT_GPIO: + strncpy(rs->rigport.pathname, DEFAULT_GPIO_PORT, FILPATHLEN); + break; - rs->rigport.write_delay = caps->write_delay; - rs->rigport.post_write_delay = caps->post_write_delay; - rs->rigport.timeout = caps->timeout; - rs->rigport.retry = caps->retry; - rs->pttport.type.ptt = caps->ptt_type; - rs->dcdport.type.dcd = caps->dcd_type; + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: + strncpy(rs->rigport.pathname, "127.0.0.1:4532", FILPATHLEN - 1); + break; - rs->vfo_comp = 0.0; /* override it with preferences */ - rs->current_vfo = RIG_VFO_CURR; /* we don't know yet! */ - rs->tx_vfo = RIG_VFO_CURR; /* we don't know yet! */ - rs->transceive = RIG_TRN_OFF; - rs->poll_interval = 500; - /* should it be a parameter to rig_init ? --SF */ - rs->itu_region = RIG_ITU_REGION2; + default: + strncpy(rs->rigport.pathname, "", FILPATHLEN - 1); + } - switch(rs->itu_region) { - case RIG_ITU_REGION1: - memcpy(rs->tx_range_list, caps->tx_range_list1, - sizeof(struct freq_range_list)*FRQRANGESIZ); - memcpy(rs->rx_range_list, caps->rx_range_list1, - sizeof(struct freq_range_list)*FRQRANGESIZ); - break; - case RIG_ITU_REGION2: - case RIG_ITU_REGION3: - default: - memcpy(rs->tx_range_list, caps->tx_range_list2, - sizeof(struct freq_range_list)*FRQRANGESIZ); - memcpy(rs->rx_range_list, caps->rx_range_list2, - sizeof(struct freq_range_list)*FRQRANGESIZ); - break; - } + rs->rigport.write_delay = caps->write_delay; + rs->rigport.post_write_delay = caps->post_write_delay; + rs->rigport.timeout = caps->timeout; + rs->rigport.retry = caps->retry; + rs->pttport.type.ptt = caps->ptt_type; + rs->dcdport.type.dcd = caps->dcd_type; - rs->vfo_list = 0; - rs->mode_list = 0; - for (i=0; irx_range_list[i]); i++) { - rs->vfo_list |= rs->rx_range_list[i].vfo; - rs->mode_list |= rs->rx_range_list[i].modes; - } - for (i=0; itx_range_list[i]); i++) { - rs->vfo_list |= rs->tx_range_list[i].vfo; - rs->mode_list |= rs->tx_range_list[i].modes; - } + rs->vfo_comp = 0.0; /* override it with preferences */ + rs->current_vfo = RIG_VFO_CURR; /* we don't know yet! */ + rs->tx_vfo = RIG_VFO_CURR; /* we don't know yet! */ + rs->transceive = RIG_TRN_OFF; + rs->poll_interval = 500; + /* should it be a parameter to rig_init ? --SF */ + rs->itu_region = RIG_ITU_REGION2; - memcpy(rs->preamp, caps->preamp, sizeof(int)*MAXDBLSTSIZ); - memcpy(rs->attenuator, caps->attenuator, sizeof(int)*MAXDBLSTSIZ); - memcpy(rs->tuning_steps, caps->tuning_steps, - sizeof(struct tuning_step_list)*TSLSTSIZ); - memcpy(rs->filters, caps->filters, - sizeof(struct filter_list)*FLTLSTSIZ); - memcpy(&rs->str_cal, &caps->str_cal, - sizeof(cal_table_t)); + switch (rs->itu_region) { + case RIG_ITU_REGION1: + memcpy(rs->tx_range_list, caps->tx_range_list1, + sizeof(struct freq_range_list)*FRQRANGESIZ); + memcpy(rs->rx_range_list, caps->rx_range_list1, + sizeof(struct freq_range_list)*FRQRANGESIZ); + break; - memcpy(rs->chan_list, caps->chan_list, sizeof(chan_t)*CHANLSTSIZ); + case RIG_ITU_REGION2: + case RIG_ITU_REGION3: + default: + memcpy(rs->tx_range_list, caps->tx_range_list2, + sizeof(struct freq_range_list)*FRQRANGESIZ); + memcpy(rs->rx_range_list, caps->rx_range_list2, + sizeof(struct freq_range_list)*FRQRANGESIZ); + break; + } - rs->has_get_func = caps->has_get_func; - rs->has_set_func = caps->has_set_func; - rs->has_get_level = caps->has_get_level; - rs->has_set_level = caps->has_set_level; - rs->has_get_parm = caps->has_get_parm; - rs->has_set_parm = caps->has_set_parm; + rs->vfo_list = 0; + rs->mode_list = 0; - /* emulation by frontend */ - if ((caps->has_get_level & RIG_LEVEL_STRENGTH) == 0 && - (caps->has_get_level & RIG_LEVEL_RAWSTR) == RIG_LEVEL_RAWSTR) - rs->has_get_level |= RIG_LEVEL_STRENGTH; + for (i = 0; i < FRQRANGESIZ && !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++) { + rs->vfo_list |= rs->rx_range_list[i].vfo; + rs->mode_list |= rs->rx_range_list[i].modes; + } - memcpy(rs->level_gran, caps->level_gran, sizeof(gran_t)*RIG_SETTING_MAX); - memcpy(rs->parm_gran, caps->parm_gran, sizeof(gran_t)*RIG_SETTING_MAX); + for (i = 0; i < FRQRANGESIZ && !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++) { + rs->vfo_list |= rs->tx_range_list[i].vfo; + rs->mode_list |= rs->tx_range_list[i].modes; + } - rs->max_rit = caps->max_rit; - rs->max_xit = caps->max_xit; - rs->max_ifshift = caps->max_ifshift; - rs->announces = caps->announces; + memcpy(rs->preamp, caps->preamp, sizeof(int)*MAXDBLSTSIZ); + memcpy(rs->attenuator, caps->attenuator, sizeof(int)*MAXDBLSTSIZ); + memcpy(rs->tuning_steps, caps->tuning_steps, + sizeof(struct tuning_step_list)*TSLSTSIZ); + memcpy(rs->filters, caps->filters, + sizeof(struct filter_list)*FLTLSTSIZ); + memcpy(&rs->str_cal, &caps->str_cal, + sizeof(cal_table_t)); - rs->rigport.fd = rs->pttport.fd = rs->dcdport.fd = -1; + memcpy(rs->chan_list, caps->chan_list, sizeof(chan_t)*CHANLSTSIZ); - /* - * let the backend a chance to setup his private data - * This must be done only once defaults are setup, - * so the backend init can override rig_state. - */ - if (caps->rig_init != NULL) { - retcode = caps->rig_init(rig); - if (retcode != RIG_OK) { - rig_debug(RIG_DEBUG_VERBOSE,"rig:backend_init failed!\n"); - /* cleanup and exit */ - free(rig); - return NULL; - } - } + rs->has_get_func = caps->has_get_func; + rs->has_set_func = caps->has_set_func; + rs->has_get_level = caps->has_get_level; + rs->has_set_level = caps->has_set_level; + rs->has_get_parm = caps->has_get_parm; + rs->has_set_parm = caps->has_set_parm; - return rig; + /* emulation by frontend */ + if ((caps->has_get_level & RIG_LEVEL_STRENGTH) == 0 + && (caps->has_get_level & RIG_LEVEL_RAWSTR) == RIG_LEVEL_RAWSTR) { + rs->has_get_level |= RIG_LEVEL_STRENGTH; + } + + memcpy(rs->level_gran, caps->level_gran, sizeof(gran_t)*RIG_SETTING_MAX); + memcpy(rs->parm_gran, caps->parm_gran, sizeof(gran_t)*RIG_SETTING_MAX); + + rs->max_rit = caps->max_rit; + rs->max_xit = caps->max_xit; + rs->max_ifshift = caps->max_ifshift; + rs->announces = caps->announces; + + rs->rigport.fd = rs->pttport.fd = rs->dcdport.fd = -1; + + /* + * let the backend a chance to setup his private data + * This must be done only once defaults are setup, + * so the backend init can override rig_state. + */ + if (caps->rig_init != NULL) { + retcode = caps->rig_init(rig); + + if (retcode != RIG_OK) { + rig_debug(RIG_DEBUG_VERBOSE, + "%s: backend_init failed!\n", + __func__); + /* cleanup and exit */ + free(rig); + return NULL; + } + } + + return rig; } + /** * \brief open the communication to the rig - * \param rig The #RIG handle of the radio to be opened + * \param rig The #RIG handle of the radio to be opened * * Opens communication to a radio which \a RIG handle has been passed * by argument. @@ -462,239 +488,292 @@ RIG * HAMLIB_API rig_init(rig_model_t rig_model) * a negative value if an error occured (in which case, cause is * set appropriately). * - * \retval RIG_EINVAL \a rig is NULL or unconsistent. - * \retval RIG_ENIMPL port type communication is not implemented yet. + * \retval RIG_EINVAL \a rig is NULL or unconsistent. + * \retval RIG_ENIMPL port type communication is not implemented yet. * * \sa rig_init(), rig_close() */ - int HAMLIB_API rig_open(RIG *rig) { - const struct rig_caps *caps; - struct rig_state *rs; - int status = RIG_OK; + const struct rig_caps *caps; + struct rig_state *rs; + int status = RIG_OK; - rig_debug(RIG_DEBUG_VERBOSE,"rig:rig_open called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rig || !rig->caps) - return -RIG_EINVAL; + if (!rig || !rig->caps) { + return -RIG_EINVAL; + } - caps = rig->caps; - rs = &rig->state; + caps = rig->caps; + rs = &rig->state; - if (rs->comm_state) - return -RIG_EINVAL; + if (rs->comm_state) { + return -RIG_EINVAL; + } - rs->rigport.fd = -1; + rs->rigport.fd = -1; - if (rs->rigport.type.rig == RIG_PORT_SERIAL) - { - if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET && - rs->rigport.parm.serial.handshake == RIG_HANDSHAKE_HARDWARE) - { - rig_debug(RIG_DEBUG_ERR, "Cannot set RTS with hardware handshake \"%s\"\n", - rs->rigport.pathname); - return -RIG_ECONF; + if (rs->rigport.type.rig == RIG_PORT_SERIAL) { + if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET + && rs->rigport.parm.serial.handshake == RIG_HANDSHAKE_HARDWARE) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot set RTS with hardware handshake \"%s\"\n", + __func__, + rs->rigport.pathname); + return -RIG_ECONF; } - if ('\0' == rs->pttport.pathname[0] - || !strcmp(rs->pttport.pathname, rs->rigport.pathname)) - { - /* check for control line conflicts */ - if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET && - rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS) - { - rig_debug(RIG_DEBUG_ERR, "Cannot set RTS with PTT by RTS \"%s\"\n", - rs->rigport.pathname); - return -RIG_ECONF; - } - if (rs->rigport.parm.serial.dtr_state != RIG_SIGNAL_UNSET && - rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR) - { - rig_debug(RIG_DEBUG_ERR, "Cannot set DTR with PTT by DTR \"%s\"\n", - rs->rigport.pathname); - return -RIG_ECONF; - } + + if ('\0' == rs->pttport.pathname[0] + || !strcmp(rs->pttport.pathname, rs->rigport.pathname)) { + /* check for control line conflicts */ + if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET + && rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot set RTS with PTT by RTS \"%s\"\n", + __func__, + rs->rigport.pathname); + return -RIG_ECONF; + } + + if (rs->rigport.parm.serial.dtr_state != RIG_SIGNAL_UNSET + && rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot set DTR with PTT by DTR \"%s\"\n", + __func__, + rs->rigport.pathname); + return -RIG_ECONF; + } } } - status = port_open(&rs->rigport); - if (status < 0) - return status; + status = port_open(&rs->rigport); - switch(rs->pttport.type.ptt) { - case RIG_PTT_NONE: - case RIG_PTT_RIG: - case RIG_PTT_RIG_MICDATA: - break; - case RIG_PTT_SERIAL_RTS: - case RIG_PTT_SERIAL_DTR: - if (rs->pttport.pathname[0] == '\0' && - rs->rigport.type.rig == RIG_PORT_SERIAL) - strcpy(rs->pttport.pathname, rs->rigport.pathname); - if (!strcmp(rs->pttport.pathname, rs->rigport.pathname)) - { - rs->pttport.fd = rs->rigport.fd; + if (status < 0) { + return status; + } - /* Needed on Linux because the serial port driver sets RTS/DTR - on open - only need to address the PTT line as we offer - config parameters to control the other (dtr_state & - rts_state) */ - if (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR) - status = ser_set_dtr(&rs->pttport, 0); - if (rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS) - status = ser_set_rts(&rs->pttport, 0); - } - else - { - rs->pttport.fd = ser_open(&rs->pttport); - if (rs->pttport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open PTT device \"%s\"\n", + switch (rs->pttport.type.ptt) { + case RIG_PTT_NONE: + case RIG_PTT_RIG: + case RIG_PTT_RIG_MICDATA: + break; + + case RIG_PTT_SERIAL_RTS: + case RIG_PTT_SERIAL_DTR: + if (rs->pttport.pathname[0] == '\0' + && rs->rigport.type.rig == RIG_PORT_SERIAL) { + strcpy(rs->pttport.pathname, rs->rigport.pathname); + } + + if (!strcmp(rs->pttport.pathname, rs->rigport.pathname)) { + rs->pttport.fd = rs->rigport.fd; + + /* Needed on Linux because the serial port driver sets RTS/DTR + on open - only need to address the PTT line as we offer + config parameters to control the other (dtr_state & + rts_state) */ + if (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR) { + status = ser_set_dtr(&rs->pttport, 0); + } + + if (rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS) { + status = ser_set_rts(&rs->pttport, 0); + } + } else { + rs->pttport.fd = ser_open(&rs->pttport); + + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + status = -RIG_EIO; + } + + if (RIG_OK == status + && (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR + || rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS)) { + /* Needed on Linux because the serial port driver sets + RTS/DTR high on open - set both low since we offer no + control of the non-PTT line and low is better than + high */ + status = ser_set_dtr(&rs->pttport, 0); + + if (RIG_OK == status) { + status = ser_set_rts(&rs->pttport, 0); + } + } + + ser_close(&rs->pttport); + } + + break; + + case RIG_PTT_PARALLEL: + rs->pttport.fd = par_open(&rs->pttport); + + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, rs->pttport.pathname); status = -RIG_EIO; - } - if (RIG_OK == status - && (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR - || rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS)) - { - /* Needed on Linux because the serial port driver sets - RTS/DTR high on open - set both low since we offer no - control of the non-PTT line and low is better than - high */ - status = ser_set_dtr(&rs->pttport, 0); - if (RIG_OK == status) - { - status = ser_set_rts(&rs->pttport, 0); - } - } - ser_close(&rs->pttport); - } - break; - case RIG_PTT_PARALLEL: - rs->pttport.fd = par_open(&rs->pttport); - if (rs->pttport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - status = -RIG_EIO; - } - else - par_ptt_set(&rs->pttport, RIG_PTT_OFF); - break; - case RIG_PTT_CM108: - rs->pttport.fd = cm108_open(&rs->pttport); - if (rs->pttport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - status = -RIG_EIO; - } - else - cm108_ptt_set(&rs->pttport, RIG_PTT_OFF); - break; - case RIG_PTT_GPIO: - rs->pttport.fd = gpio_open(&rs->pttport, 1); - if (rs->pttport.fd < 0) { - rig_debug(RIG_DEBUG_ERR, - "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - status = -RIG_EIO; - } else - gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); - break; - case RIG_PTT_GPION: - rs->pttport.fd = gpio_open(&rs->pttport, 0); - if (rs->pttport.fd < 0) { - rig_debug(RIG_DEBUG_ERR, - "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - status = -RIG_EIO; - } else - gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); - break; - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported PTT type %d\n", - rs->pttport.type.ptt); - status = -RIG_ECONF; - } + } else { + par_ptt_set(&rs->pttport, RIG_PTT_OFF); + } - switch(rs->dcdport.type.dcd) { - case RIG_DCD_NONE: - case RIG_DCD_RIG: - break; - case RIG_DCD_SERIAL_DSR: - case RIG_DCD_SERIAL_CTS: - case RIG_DCD_SERIAL_CAR: - if (rs->dcdport.pathname[0] == '\0' && - rs->rigport.type.rig == RIG_PORT_SERIAL) - strcpy(rs->dcdport.pathname, rs->rigport.pathname); - rs->dcdport.fd = ser_open(&rs->dcdport); - if (rs->dcdport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open DCD device \"%s\"\n", - rs->dcdport.pathname); - status = -RIG_EIO; - } - break; - case RIG_DCD_PARALLEL: - rs->dcdport.fd = par_open(&rs->dcdport); - if (rs->dcdport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open DCD device \"%s\"\n", - rs->dcdport.pathname); - status = -RIG_EIO; - } - break; - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported DCD type %d\n", - rs->dcdport.type.dcd); - status = -RIG_ECONF; - } + break; - if (status < 0) - { - port_close (&rs->rigport, rs->rigport.type.rig); - return status; - } + case RIG_PTT_CM108: + rs->pttport.fd = cm108_open(&rs->pttport); - add_opened_rig(rig); + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + status = -RIG_EIO; + } else { + cm108_ptt_set(&rs->pttport, RIG_PTT_OFF); + } - rs->comm_state = 1; + break; - /* - * Maybe the backend has something to initialize - * In case of failure, just close down and report error code. - */ - if (caps->rig_open != NULL) { - status = caps->rig_open(rig); - if (status != RIG_OK) { - return status; - } - } + case RIG_PTT_GPIO: + rs->pttport.fd = gpio_open(&rs->pttport, 1); - /* - * trigger state->current_vfo first retrieval - */ - if (rig_get_vfo(rig, &rs->current_vfo) == RIG_OK) - rs->tx_vfo = rs->current_vfo; + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + status = -RIG_EIO; + } else { + gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); + } + + break; + + case RIG_PTT_GPION: + rs->pttport.fd = gpio_open(&rs->pttport, 0); + + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + status = -RIG_EIO; + } else { + gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); + } + + break; + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported PTT type %d\n", + __func__, + rs->pttport.type.ptt); + status = -RIG_ECONF; + } + + switch (rs->dcdport.type.dcd) { + case RIG_DCD_NONE: + case RIG_DCD_RIG: + break; + + case RIG_DCD_SERIAL_DSR: + case RIG_DCD_SERIAL_CTS: + case RIG_DCD_SERIAL_CAR: + if (rs->dcdport.pathname[0] == '\0' + && rs->rigport.type.rig == RIG_PORT_SERIAL) { + strcpy(rs->dcdport.pathname, rs->rigport.pathname); + } + + rs->dcdport.fd = ser_open(&rs->dcdport); + + if (rs->dcdport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open DCD device \"%s\"\n", + __func__, + rs->dcdport.pathname); + status = -RIG_EIO; + } + + break; + + case RIG_DCD_PARALLEL: + rs->dcdport.fd = par_open(&rs->dcdport); + + if (rs->dcdport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open DCD device \"%s\"\n", + __func__, + rs->dcdport.pathname); + status = -RIG_EIO; + } + + break; + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported DCD type %d\n", + __func__, + rs->dcdport.type.dcd); + status = -RIG_ECONF; + } + + if (status < 0) { + port_close(&rs->rigport, rs->rigport.type.rig); + return status; + } + + add_opened_rig(rig); + + rs->comm_state = 1; + + /* + * Maybe the backend has something to initialize + * In case of failure, just close down and report error code. + */ + if (caps->rig_open != NULL) { + status = caps->rig_open(rig); + + if (status != RIG_OK) { + return status; + } + } + + /* + * trigger state->current_vfo first retrieval + */ + if (rig_get_vfo(rig, &rs->current_vfo) == RIG_OK) { + rs->tx_vfo = rs->current_vfo; + } #if 0 - /* - * Check the current tranceive state of the rig - */ - if (rs->transceive == RIG_TRN_RIG) { - int retval, trn; - retval = rig_get_trn(rig, &trn); - if (retval == RIG_OK && trn == RIG_TRN_RIG) - add_trn_rig(rig); - } + + /* + * Check the current tranceive state of the rig + */ + if (rs->transceive == RIG_TRN_RIG) { + int retval, trn; + retval = rig_get_trn(rig, &trn); + + if (retval == RIG_OK && trn == RIG_TRN_RIG) { + add_trn_rig(rig); + } + } + #endif - return RIG_OK; + return RIG_OK; } + /** * \brief close the communication to the rig - * \param rig The #RIG handle of the radio to be closed + * \param rig The #RIG handle of the radio to be closed * * Closes communication to a radio which \a RIG handle has been passed * by argument that was previously open with rig_open(). @@ -705,109 +784,129 @@ int HAMLIB_API rig_open(RIG *rig) * * \sa rig_cleanup(), rig_open() */ - int HAMLIB_API rig_close(RIG *rig) { - const struct rig_caps *caps; - struct rig_state *rs; + const struct rig_caps *caps; + struct rig_state *rs; - rig_debug(RIG_DEBUG_VERBOSE,"rig:rig_close called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rig || !rig->caps) - return -RIG_EINVAL; + if (!rig || !rig->caps) { + return -RIG_EINVAL; + } - caps = rig->caps; - rs = &rig->state; + caps = rig->caps; + rs = &rig->state; - if (!rs->comm_state) - return -RIG_EINVAL; + if (!rs->comm_state) { + return -RIG_EINVAL; + } - if (rs->transceive != RIG_TRN_OFF) { - rig_set_trn(rig, RIG_TRN_OFF); - } + if (rs->transceive != RIG_TRN_OFF) { + rig_set_trn(rig, RIG_TRN_OFF); + } - /* - * Let the backend say 73s to the rig. - * and ignore the return code. - */ - if (caps->rig_close) - caps->rig_close(rig); + /* + * Let the backend say 73s to the rig. + * and ignore the return code. + */ + if (caps->rig_close) { + caps->rig_close(rig); + } - /* - * FIXME: what happens if PTT and rig ports are the same? - * (eg. ptt_type = RIG_PTT_SERIAL) - */ - switch(rs->pttport.type.ptt) { - case RIG_PTT_NONE: - case RIG_PTT_RIG: - case RIG_PTT_RIG_MICDATA: - break; - case RIG_PTT_SERIAL_RTS: - // If port is already closed, do nothing - if (rs->pttport.fd > -1) { - ser_set_rts(&rs->pttport, 0); - if (rs->pttport.fd != rs->rigport.fd) { - port_close(&rs->pttport, RIG_PORT_SERIAL); - } - } - break; - case RIG_PTT_SERIAL_DTR: - // If port is already closed, do nothing - if (rs->pttport.fd > -1) { - ser_set_dtr(&rs->pttport, 0); - if (rs->pttport.fd != rs->rigport.fd) { - port_close(&rs->pttport, RIG_PORT_SERIAL); - } - } - break; - case RIG_PTT_PARALLEL: + /* + * FIXME: what happens if PTT and rig ports are the same? + * (eg. ptt_type = RIG_PTT_SERIAL) + */ + switch (rs->pttport.type.ptt) { + case RIG_PTT_NONE: + case RIG_PTT_RIG: + case RIG_PTT_RIG_MICDATA: + break; + + case RIG_PTT_SERIAL_RTS: + // If port is already closed, do nothing + if (rs->pttport.fd > -1) { + ser_set_rts(&rs->pttport, 0); + + if (rs->pttport.fd != rs->rigport.fd) { + port_close(&rs->pttport, RIG_PORT_SERIAL); + } + } + + break; + + case RIG_PTT_SERIAL_DTR: + // If port is already closed, do nothing + if (rs->pttport.fd > -1) { + ser_set_dtr(&rs->pttport, 0); + + if (rs->pttport.fd != rs->rigport.fd) { + port_close(&rs->pttport, RIG_PORT_SERIAL); + } + } + + break; + + case RIG_PTT_PARALLEL: par_ptt_set(&rs->pttport, RIG_PTT_OFF); port_close(&rs->pttport, RIG_PORT_PARALLEL); - break; - case RIG_PTT_CM108: - cm108_ptt_set(&rs->pttport, RIG_PTT_OFF); - port_close(&rs->pttport, RIG_PORT_CM108); - break; - case RIG_PTT_GPIO: - case RIG_PTT_GPION: - gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); - port_close(&rs->pttport, RIG_PORT_GPIO); - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported PTT type %d\n", - rs->pttport.type.ptt); - } + break; - switch(rs->dcdport.type.dcd) { - case RIG_DCD_NONE: - case RIG_DCD_RIG: - break; - case RIG_DCD_SERIAL_DSR: - case RIG_DCD_SERIAL_CTS: - case RIG_DCD_SERIAL_CAR: + case RIG_PTT_CM108: + cm108_ptt_set(&rs->pttport, RIG_PTT_OFF); + port_close(&rs->pttport, RIG_PORT_CM108); + break; + + case RIG_PTT_GPIO: + case RIG_PTT_GPION: + gpio_ptt_set(&rs->pttport, RIG_PTT_OFF); + port_close(&rs->pttport, RIG_PORT_GPIO); + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported PTT type %d\n", + __func__, + rs->pttport.type.ptt); + } + + switch (rs->dcdport.type.dcd) { + case RIG_DCD_NONE: + case RIG_DCD_RIG: + break; + + case RIG_DCD_SERIAL_DSR: + case RIG_DCD_SERIAL_CTS: + case RIG_DCD_SERIAL_CAR: port_close(&rs->dcdport, RIG_PORT_SERIAL); - break; - case RIG_DCD_PARALLEL: - port_close(&rs->dcdport, RIG_PORT_PARALLEL); - break; - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported DCD type %d\n", - rs->dcdport.type.dcd); - } + break; - rs->dcdport.fd = rs->pttport.fd = -1; + case RIG_DCD_PARALLEL: + port_close(&rs->dcdport, RIG_PORT_PARALLEL); + break; + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported DCD type %d\n", + __func__, + rs->dcdport.type.dcd); + } + + rs->dcdport.fd = rs->pttport.fd = -1; port_close(&rs->rigport, rs->rigport.type.rig); - remove_opened_rig(rig); + remove_opened_rig(rig); - rs->comm_state = 0; + rs->comm_state = 0; - return RIG_OK; + return RIG_OK; } + /** * \brief release a rig handle and free associated memory - * \param rig The #RIG handle of the radio to be closed + * \param rig The #RIG handle of the radio to be closed * * Releases a rig struct which port has eventualy been closed already * with rig_close(). @@ -818,37 +917,39 @@ int HAMLIB_API rig_close(RIG *rig) * * \sa rig_init(), rig_close() */ - int HAMLIB_API rig_cleanup(RIG *rig) { - rig_debug(RIG_DEBUG_VERBOSE,"rig:rig_cleanup called \n"); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rig || !rig->caps) - return -RIG_EINVAL; + if (!rig || !rig->caps) { + return -RIG_EINVAL; + } - /* - * check if they forgot to close the rig - */ - if (rig->state.comm_state) - rig_close(rig); + /* + * check if they forgot to close the rig + */ + if (rig->state.comm_state) { + rig_close(rig); + } - /* - * basically free up the priv struct - */ - if (rig->caps->rig_cleanup) - rig->caps->rig_cleanup(rig); + /* + * basically free up the priv struct + */ + if (rig->caps->rig_cleanup) { + rig->caps->rig_cleanup(rig); + } - free(rig); + free(rig); - return RIG_OK; + return RIG_OK; } /** * \brief set the frequency of the target VFO - * \param rig The rig handle - * \param vfo The target VFO - * \param freq The frequency to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param freq The frequency to set to * * Sets the frequency of the target VFO. * @@ -858,59 +959,72 @@ int HAMLIB_API rig_cleanup(RIG *rig) * * \sa rig_get_freq() */ - int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (rig->state.vfo_comp != 0.0) - freq += (freq_t)((double)rig->state.vfo_comp * freq); + caps = rig->caps; - if (caps->set_freq == NULL) - return -RIG_ENAVAIL; + if (rig->state.vfo_comp != 0.0) { + freq += (freq_t)((double)rig->state.vfo_comp * freq); + } - if ((caps->targetable_vfo&RIG_TARGETABLE_FREQ) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { - retcode = caps->set_freq(rig, vfo, freq); - } else { - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if (caps->set_freq == NULL) { + return -RIG_ENAVAIL; + } - retcode = caps->set_freq(rig, vfo, freq); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } - } - if (retcode == RIG_OK && - (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) - rig->state.current_freq = freq; + if ((caps->targetable_vfo & RIG_TARGETABLE_FREQ) + || vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { + retcode = caps->set_freq(rig, vfo, freq); + } else { + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - return retcode; + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_freq(rig, vfo, freq); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + } + + if (retcode == RIG_OK + && (vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo)) { + rig->state.current_freq = freq; + } + + return retcode; } + /** * \brief get the frequency of the target VFO - * \param rig The rig handle - * \param vfo The target VFO - * \param freq The location where to store the current frequency + * \param rig The rig handle + * \param vfo The target VFO + * \param freq The location where to store the current frequency * * Retrieves the frequency of the target VFO. - * The value stored at \a freq location equals RIG_FREQ_NONE when the current - * frequency of the VFO is not defined (e.g. blank memory). + * The value stored at \a freq location equals RIG_FREQ_NONE when the current + * frequency of the VFO is not defined (e.g. blank memory). * * \return RIG_OK if the operation has been sucessful, otherwise * a negative value if an error occured (in which case, cause is @@ -918,57 +1032,69 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) * * \sa rig_set_freq() */ - int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !freq) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !freq) { + return -RIG_EINVAL; + } - if (caps->get_freq == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_FREQ) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { - retcode = caps->get_freq(rig, vfo, freq); - } else { - if (!caps->set_vfo) - return -RIG_ENAVAIL; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - retcode = caps->get_freq(rig, vfo, freq); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } - } - /* VFO compensation */ - if (rig->state.vfo_comp != 0.0) - *freq += (freq_t)(rig->state.vfo_comp * (*freq)); + if (caps->get_freq == NULL) { + return -RIG_ENAVAIL; + } - if (retcode == RIG_OK && - (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) - rig->state.current_freq = *freq; + if ((caps->targetable_vfo & RIG_TARGETABLE_FREQ) + || vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { + retcode = caps->get_freq(rig, vfo, freq); + } else { + if (!caps->set_vfo) { + return -RIG_ENAVAIL; + } - return retcode; + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_freq(rig, vfo, freq); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + } + + /* VFO compensation */ + if (rig->state.vfo_comp != 0.0) { + *freq += (freq_t)(rig->state.vfo_comp * (*freq)); + } + + if (retcode == RIG_OK + && (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) { + rig->state.current_freq = *freq; + } + + return retcode; } /** * \brief set the mode of the target VFO - * \param rig The rig handle - * \param vfo The target VFO - * \param mode The mode to set to - * \param width The passband width to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param mode The mode to set to + * \param width The passband width to set to * * Sets the mode and associated passband of the target VFO. The * passband \a width must be supported by the backend of the rig or @@ -982,63 +1108,72 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) * * \sa rig_get_mode() */ - int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_mode == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_MODE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { - retcode = caps->set_mode(rig, vfo, mode, width); - } else { + if (caps->set_mode == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_MODE) + || vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { + retcode = caps->set_mode(rig, vfo, mode, width); + } else { - retcode = caps->set_mode(rig, vfo, mode, width); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } - } + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - if (retcode == RIG_OK && - (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) { - rig->state.current_mode = mode; - rig->state.current_width = width; - } + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); - return retcode; + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_mode(rig, vfo, mode, width); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + /* return the first error code */ + if (RIG_OK == retcode) { + retcode = rc2; + } + } + + if (retcode == RIG_OK + && (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) { + rig->state.current_mode = mode; + rig->state.current_width = width; + } + + return retcode; } + /** * \brief get the mode of the target VFO - * \param rig The rig handle - * \param vfo The target VFO - * \param mode The location where to store the current mode - * \param width The location where to store the current passband width + * \param rig The rig handle + * \param vfo The target VFO + * \param mode The location where to store the current mode + * \param width The location where to store the current passband width * * Retrieves the mode and passband of the target VFO. * If the backend is unable to determine the width, the \a width * will be set to RIG_PASSBAND_NORMAL as a default. - * The value stored at \a mode location equals RIG_MODE_NONE when the current - * mode of the VFO is not defined (e.g. blank memory). + * The value stored at \a mode location equals RIG_MODE_NONE when the current + * mode of the VFO is not defined (e.g. blank memory). * * \return RIG_OK if the operation has been sucessful, otherwise * a negative value if an error occured (in which case, cause is @@ -1046,58 +1181,70 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) * * \sa rig_set_mode() */ - -int HAMLIB_API rig_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) +int HAMLIB_API rig_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, + pbwidth_t *width) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !mode || !width) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !mode || !width) { + return -RIG_EINVAL; + } - if (caps->get_mode == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_MODE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { - retcode = caps->get_mode(rig, vfo, mode, width); - } else { + if (caps->get_mode == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_MODE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + retcode = caps->get_mode(rig, vfo, mode, width); + } else { - retcode = caps->get_mode(rig, vfo, mode, width); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } - } + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - if (retcode == RIG_OK && - (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) { - rig->state.current_mode = *mode; - rig->state.current_width = *width; - } + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); - if (*width == RIG_PASSBAND_NORMAL && *mode != RIG_MODE_NONE) - *width = rig_passband_normal (rig, *mode); + if (retcode != RIG_OK) { + return retcode; + } - return retcode; + retcode = caps->get_mode(rig, vfo, mode, width); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + } + + if (retcode == RIG_OK + && (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) { + rig->state.current_mode = *mode; + rig->state.current_width = *width; + } + + if (*width == RIG_PASSBAND_NORMAL && *mode != RIG_MODE_NONE) { + *width = rig_passband_normal(rig, *mode); + } + + return retcode; } + /** * \brief get the normal passband of a mode - * \param rig The rig handle - * \param mode The mode to get the passband + * \param rig The rig handle + * \param mode The mode to get the passband * * Returns the normal (default) passband for the given \a mode. * @@ -1106,114 +1253,127 @@ int HAMLIB_API rig_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width * * \sa rig_passband_narrow(), rig_passband_wide() */ - pbwidth_t HAMLIB_API rig_passband_normal(RIG *rig, rmode_t mode) { - const struct rig_state *rs; - int i; + const struct rig_state *rs; + int i; - if (!rig) - return RIG_PASSBAND_NORMAL; /* huhu! */ + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rs = &rig->state; + if (!rig) { + return RIG_PASSBAND_NORMAL; /* huhu! */ + } - for (i=0; ifilters[i].modes; i++) { - if (rs->filters[i].modes & mode) { - return rs->filters[i].width; - } - } + rs = &rig->state; - return RIG_PASSBAND_NORMAL; + for (i = 0; i < FLTLSTSIZ && rs->filters[i].modes; i++) { + if (rs->filters[i].modes & mode) { + return rs->filters[i].width; + } + } + + return RIG_PASSBAND_NORMAL; } + /** * \brief get the narrow passband of a mode - * \param rig The rig handle - * \param mode The mode to get the passband + * \param rig The rig handle + * \param mode The mode to get the passband * * Returns the narrow (closest) passband for the given \a mode. - * EXAMPLE: rig_set_mode(my_rig, RIG_MODE_LSB, - * rig_passband_narrow(my_rig, RIG_MODE_LSB) ); + * EXAMPLE: rig_set_mode(my_rig, RIG_MODE_LSB, + * rig_passband_narrow(my_rig, RIG_MODE_LSB) ); * * \return the passband in Hz if the operation has been sucessful, * or a 0 if an error occured (passband not found, whatever). * * \sa rig_passband_normal(), rig_passband_wide() */ - pbwidth_t HAMLIB_API rig_passband_narrow(RIG *rig, rmode_t mode) { - const struct rig_state *rs; - pbwidth_t normal; - int i; + const struct rig_state *rs; + pbwidth_t normal; + int i; - if (!rig) - return 0; /* huhu! */ + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rs = &rig->state; + if (!rig) { + return 0; /* huhu! */ + } - for (i=0; ifilters[i].modes; i++) { - if (rs->filters[i].modes & mode) { - normal = rs->filters[i].width; - for (i++; ifilters[i].modes; i++) { - if ((rs->filters[i].modes & mode) && - (rs->filters[i].width < normal)) { - return rs->filters[i].width; - } - } - return 0; - } - } + rs = &rig->state; - return 0; + for (i = 0; i < FLTLSTSIZ - 1 && rs->filters[i].modes; i++) { + if (rs->filters[i].modes & mode) { + normal = rs->filters[i].width; + + for (i++; i < FLTLSTSIZ && rs->filters[i].modes; i++) { + if ((rs->filters[i].modes & mode) && + (rs->filters[i].width < normal)) { + return rs->filters[i].width; + } + } + + return 0; + } + } + + return 0; } + /** * \brief get the wide passband of a mode - * \param rig The rig handle - * \param mode The mode to get the passband + * \param rig The rig handle + * \param mode The mode to get the passband * * Returns the wide (default) passband for the given \a mode. - * EXAMPLE: rig_set_mode(my_rig, RIG_MODE_AM, - * rig_passband_wide(my_rig, RIG_MODE_AM) ); + * EXAMPLE: rig_set_mode(my_rig, RIG_MODE_AM, + * rig_passband_wide(my_rig, RIG_MODE_AM) ); * * \return the passband in Hz if the operation has been sucessful, * or a 0 if an error occured (passband not found, whatever). * * \sa rig_passband_narrow(), rig_passband_normal() */ - pbwidth_t HAMLIB_API rig_passband_wide(RIG *rig, rmode_t mode) { - const struct rig_state *rs; - pbwidth_t normal; - int i; + const struct rig_state *rs; + pbwidth_t normal; + int i; - if (!rig) - return 0; /* huhu! */ + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rs = &rig->state; + if (!rig) { + return 0; /* huhu! */ + } - for (i=0; ifilters[i].modes; i++) { - if (rs->filters[i].modes & mode) { - normal = rs->filters[i].width; - for (i++; ifilters[i].modes; i++) { - if ((rs->filters[i].modes & mode) && - (rs->filters[i].width > normal)) { - return rs->filters[i].width; - } - } - return 0; - } - } + rs = &rig->state; - return 0; + for (i = 0; i < FLTLSTSIZ - 1 && rs->filters[i].modes; i++) { + if (rs->filters[i].modes & mode) { + normal = rs->filters[i].width; + + for (i++; i < FLTLSTSIZ && rs->filters[i].modes; i++) { + if ((rs->filters[i].modes & mode) && + (rs->filters[i].width > normal)) { + return rs->filters[i].width; + } + } + + return 0; + } + } + + return 0; } + /** * \brief set the current VFO - * \param rig The rig handle - * \param vfo The VFO to set to + * \param rig The rig handle + * \param vfo The VFO to set to * * Sets the current VFO. The VFO can be RIG_VFO_A, RIG_VFO_B, RIG_VFO_C * for VFOA, VFOB, VFOC respectively or RIG_VFO_MEM for Memory mode. @@ -1225,30 +1385,37 @@ pbwidth_t HAMLIB_API rig_passband_wide(RIG *rig, rmode_t mode) * * \sa rig_get_vfo() */ - int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) { - const struct rig_caps *caps; - int retcode; + const struct rig_caps *caps; + int retcode; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_vfo == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - retcode= caps->set_vfo(rig, vfo); - if (retcode == RIG_OK) - rig->state.current_vfo = vfo; - return retcode; + if (caps->set_vfo == NULL) { + return -RIG_ENAVAIL; + } + + retcode = caps->set_vfo(rig, vfo); + + if (retcode == RIG_OK) { + rig->state.current_vfo = vfo; + } + + return retcode; } + /** * \brief get the current VFO - * \param rig The rig handle - * \param vfo The location where to store the current VFO + * \param rig The rig handle + * \param vfo The location where to store the current VFO * * Retrieves the current VFO. The VFO can be RIG_VFO_A, RIG_VFO_B, RIG_VFO_C * for VFOA, VFOB, VFOC respectively or RIG_VFO_MEM for Memory mode. @@ -1260,31 +1427,38 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) * * \sa rig_set_vfo() */ - int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) { - const struct rig_caps *caps; - int retcode; + const struct rig_caps *caps; + int retcode; - if (CHECK_RIG_ARG(rig) || !vfo) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !vfo) { + return -RIG_EINVAL; + } - if (caps->get_vfo == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - retcode= caps->get_vfo(rig, vfo); - if (retcode == RIG_OK) - rig->state.current_vfo = *vfo; - return retcode; + if (caps->get_vfo == NULL) { + return -RIG_ENAVAIL; + } + + retcode = caps->get_vfo(rig, vfo); + + if (retcode == RIG_OK) { + rig->state.current_vfo = *vfo; + } + + return retcode; } + /** * \brief set PTT on/off - * \param rig The rig handle - * \param vfo The target VFO - * \param ptt The PTT status to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param ptt The PTT status to set to * * Sets "Push-To-Talk" on/off. * @@ -1296,132 +1470,171 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) */ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) { - const struct rig_caps *caps; - struct rig_state * rs = &rig->state; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + struct rig_state *rs = &rig->state; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - switch (rig->state.pttport.type.ptt) { - case RIG_PTT_RIG: - if (ptt == RIG_PTT_ON_MIC || ptt == RIG_PTT_ON_DATA) - ptt = RIG_PTT_ON; - /* fall through */ - case RIG_PTT_RIG_MICDATA: - if (caps->set_ptt == NULL) - return -RIG_ENIMPL; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ptt(rig, vfo, ptt); + caps = rig->caps; - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + switch (rig->state.pttport.type.ptt) { + case RIG_PTT_RIG: + if (ptt == RIG_PTT_ON_MIC || ptt == RIG_PTT_ON_DATA) { + ptt = RIG_PTT_ON; + } - retcode = caps->set_ptt(rig, vfo, ptt); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } - return retcode; + /* fall through */ + case RIG_PTT_RIG_MICDATA: + if (caps->set_ptt == NULL) { + return -RIG_ENIMPL; + } - break; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_ptt(rig, vfo, ptt); + } - case RIG_PTT_SERIAL_DTR: - /* when the PTT port is not the control port we want to free the - port when PTT is reset and seize the port when PTT is set, - this allows limited sharing of the PTT port between - applications so long as there is no contention */ - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && rs->pttport.fd < 0) - { - if (RIG_PTT_OFF == ptt) return RIG_OK; /* nothing to do here */ - rs->pttport.fd = ser_open(&rs->pttport); - if (rs->pttport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - return -RIG_EIO; - } - /* Needed on Linux because the serial port driver sets RTS/DTR - high on open - set both low since we offer no control of - the non-PTT line and low is better than high */ - retcode = ser_set_rts(&rs->pttport, 0); - if (RIG_OK != retcode) return retcode; - } - retcode = ser_set_dtr(&rig->state.pttport, ptt!=RIG_PTT_OFF); - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && ptt==RIG_PTT_OFF) - { - /* free the port */ - ser_close(&rs->pttport); - } - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - case RIG_PTT_SERIAL_RTS: - /* when the PTT port is not the control port we want to free the - port when PTT is reset and seize the port when PTT is set, - this allows limited sharing of the PTT port between - applications so long as there is no contention */ - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && rs->pttport.fd < 0) - { - if (RIG_PTT_OFF == ptt) return RIG_OK; /* nothing to do here */ - rs->pttport.fd = ser_open(&rs->pttport); - if (rs->pttport.fd < 0) - { - rig_debug(RIG_DEBUG_ERR, "Cannot open PTT device \"%s\"\n", - rs->pttport.pathname); - return -RIG_EIO; - } - /* Needed on Linux because the serial port driver sets RTS/DTR - high on open - set both low since we offer no control of - the non-PTT line and low is better than high */ - retcode = ser_set_dtr(&rs->pttport, 0); - if (RIG_OK != retcode) return retcode; - } - retcode = ser_set_rts(&rig->state.pttport, ptt!=RIG_PTT_OFF); - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && ptt==RIG_PTT_OFF) - { - /* free the port */ - ser_close(&rs->pttport); - } - return retcode; + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); - case RIG_PTT_PARALLEL: - return par_ptt_set(&rig->state.pttport, ptt); + if (retcode != RIG_OK) { + return retcode; + } - case RIG_PTT_CM108: - return cm108_ptt_set(&rig->state.pttport, ptt); + retcode = caps->set_ptt(rig, vfo, ptt); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); - case RIG_PTT_GPIO: - case RIG_PTT_GPION: - return gpio_ptt_set(&rig->state.pttport, ptt); + /* return the first error code */ + if (RIG_OK == retcode) { + retcode = rc2; + } - case RIG_PTT_NONE: - return -RIG_ENAVAIL; /* not available */ - default: - return -RIG_EINVAL; - } + return retcode; - return RIG_OK; + break; + + case RIG_PTT_SERIAL_DTR: + + /* when the PTT port is not the control port we want to free the + port when PTT is reset and seize the port when PTT is set, + this allows limited sharing of the PTT port between + applications so long as there is no contention */ + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && rs->pttport.fd < 0) { + if (RIG_PTT_OFF == ptt) { + return RIG_OK; /* nothing to do here */ + } + + rs->pttport.fd = ser_open(&rs->pttport); + + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + return -RIG_EIO; + } + + /* Needed on Linux because the serial port driver sets RTS/DTR + high on open - set both low since we offer no control of + the non-PTT line and low is better than high */ + retcode = ser_set_rts(&rs->pttport, 0); + + if (RIG_OK != retcode) { + return retcode; + } + } + + retcode = ser_set_dtr(&rig->state.pttport, ptt != RIG_PTT_OFF); + + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && ptt == RIG_PTT_OFF) { + /* free the port */ + ser_close(&rs->pttport); + } + + return retcode; + + case RIG_PTT_SERIAL_RTS: + + /* when the PTT port is not the control port we want to free the + port when PTT is reset and seize the port when PTT is set, + this allows limited sharing of the PTT port between + applications so long as there is no contention */ + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && rs->pttport.fd < 0) { + if (RIG_PTT_OFF == ptt) { + return RIG_OK; /* nothing to do here */ + } + + rs->pttport.fd = ser_open(&rs->pttport); + + if (rs->pttport.fd < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: cannot open PTT device \"%s\"\n", + __func__, + rs->pttport.pathname); + return -RIG_EIO; + } + + /* Needed on Linux because the serial port driver sets RTS/DTR + high on open - set both low since we offer no control of + the non-PTT line and low is better than high */ + retcode = ser_set_dtr(&rs->pttport, 0); + + if (RIG_OK != retcode) { + return retcode; + } + } + + retcode = ser_set_rts(&rig->state.pttport, ptt != RIG_PTT_OFF); + + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && ptt == RIG_PTT_OFF) { + /* free the port */ + ser_close(&rs->pttport); + } + + return retcode; + + case RIG_PTT_PARALLEL: + return par_ptt_set(&rig->state.pttport, ptt); + + case RIG_PTT_CM108: + return cm108_ptt_set(&rig->state.pttport, ptt); + + case RIG_PTT_GPIO: + case RIG_PTT_GPION: + return gpio_ptt_set(&rig->state.pttport, ptt); + + case RIG_PTT_NONE: + return -RIG_ENAVAIL; /* not available */ + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief get the status of the PTT - * \param rig The rig handle - * \param vfo The target VFO - * \param ptt The location where to store the status of the PTT + * \param rig The rig handle + * \param vfo The target VFO + * \param ptt The location where to store the status of the PTT * * Retrieves the status of PTT (are we on the air?). * @@ -1433,114 +1646,127 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) */ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) { - const struct rig_caps *caps; - struct rig_state * rs = &rig->state; - int retcode = RIG_OK; - int rc2, status; - vfo_t curr_vfo; + const struct rig_caps *caps; + struct rig_state *rs = &rig->state; + int retcode = RIG_OK; + int rc2, status; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !ptt) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !ptt) { + return -RIG_EINVAL; + } - switch (rig->state.pttport.type.ptt) { - case RIG_PTT_RIG: - case RIG_PTT_RIG_MICDATA: - if (caps->get_ptt == NULL) - return -RIG_ENIMPL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ptt(rig, vfo, ptt); + switch (rig->state.pttport.type.ptt) { + case RIG_PTT_RIG: + case RIG_PTT_RIG_MICDATA: + if (caps->get_ptt == NULL) { + return -RIG_ENIMPL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_ptt(rig, vfo, ptt); + } - retcode = caps->get_ptt(rig, vfo, ptt); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - return retcode; + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); - break; + if (retcode != RIG_OK) { + return retcode; + } - case RIG_PTT_SERIAL_RTS: - if (caps->get_ptt) - return caps->get_ptt(rig, vfo, ptt); + retcode = caps->get_ptt(rig, vfo, ptt); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && rs->pttport.fd < 0) - { - /* port is closed so assume PTT off */ - *ptt = RIG_PTT_OFF; - } - else - { - retcode = ser_get_rts(&rig->state.pttport, &status); - *ptt = status ? RIG_PTT_ON : RIG_PTT_OFF; - } - return retcode; + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } - case RIG_PTT_SERIAL_DTR: - if (caps->get_ptt) - return caps->get_ptt(rig, vfo, ptt); + return retcode; - if (strcmp(rs->pttport.pathname, rs->rigport.pathname) - && rs->pttport.fd < 0) - { - /* port is closed so assume PTT off */ - *ptt = RIG_PTT_OFF; - } - else - { - retcode = ser_get_dtr(&rig->state.pttport, &status); - *ptt = status ? RIG_PTT_ON : RIG_PTT_OFF; - } - return retcode; + break; - case RIG_PTT_PARALLEL: - if (caps->get_ptt) - return caps->get_ptt(rig, vfo, ptt); + case RIG_PTT_SERIAL_RTS: + if (caps->get_ptt) { + return caps->get_ptt(rig, vfo, ptt); + } - return par_ptt_get(&rig->state.pttport, ptt); + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && rs->pttport.fd < 0) { + /* port is closed so assume PTT off */ + *ptt = RIG_PTT_OFF; + } else { + retcode = ser_get_rts(&rig->state.pttport, &status); + *ptt = status ? RIG_PTT_ON : RIG_PTT_OFF; + } - case RIG_PTT_CM108: - if (caps->get_ptt) - return caps->get_ptt(rig, vfo, ptt); + return retcode; - return cm108_ptt_get(&rig->state.pttport, ptt); + case RIG_PTT_SERIAL_DTR: + if (caps->get_ptt) { + return caps->get_ptt(rig, vfo, ptt); + } - case RIG_PTT_GPIO: - case RIG_PTT_GPION: - if (caps->get_ptt) - return caps->get_ptt(rig, vfo, ptt); + if (strcmp(rs->pttport.pathname, rs->rigport.pathname) + && rs->pttport.fd < 0) { + /* port is closed so assume PTT off */ + *ptt = RIG_PTT_OFF; + } else { + retcode = ser_get_dtr(&rig->state.pttport, &status); + *ptt = status ? RIG_PTT_ON : RIG_PTT_OFF; + } - return gpio_ptt_get(&rig->state.pttport, ptt); + return retcode; - case RIG_PTT_NONE: - return -RIG_ENAVAIL; /* not available */ + case RIG_PTT_PARALLEL: + if (caps->get_ptt) { + return caps->get_ptt(rig, vfo, ptt); + } - default: - return -RIG_EINVAL; - } + return par_ptt_get(&rig->state.pttport, ptt); - return RIG_OK; + case RIG_PTT_CM108: + if (caps->get_ptt) { + return caps->get_ptt(rig, vfo, ptt); + } + + return cm108_ptt_get(&rig->state.pttport, ptt); + + case RIG_PTT_GPIO: + case RIG_PTT_GPION: + if (caps->get_ptt) { + return caps->get_ptt(rig, vfo, ptt); + } + + return gpio_ptt_get(&rig->state.pttport, ptt); + + case RIG_PTT_NONE: + return -RIG_ENAVAIL; /* not available */ + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief get the status of the DCD - * \param rig The rig handle - * \param vfo The target VFO - * \param dcd The location where to store the status of the DCD + * \param rig The rig handle + * \param vfo The target VFO + * \param dcd The location where to store the status of the DCD * * Retrieves the status of DCD (is squelch open?). * @@ -1551,78 +1777,89 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) */ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) { - const struct rig_caps *caps; - int retcode, rc2, status; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2, status; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !dcd) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !dcd) { + return -RIG_EINVAL; + } - switch (rig->state.dcdport.type.dcd) { - case RIG_DCD_RIG: - if (caps->get_dcd == NULL) - return -RIG_ENIMPL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_dcd(rig, vfo, dcd); + switch (rig->state.dcdport.type.dcd) { + case RIG_DCD_RIG: + if (caps->get_dcd == NULL) { + return -RIG_ENIMPL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_dcd(rig, vfo, dcd); + } - retcode = caps->get_dcd(rig, vfo, dcd); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we - had an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ - } + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } - return retcode; + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); - break; + if (retcode != RIG_OK) { + return retcode; + } - case RIG_DCD_SERIAL_CTS: - retcode = ser_get_cts(&rig->state.dcdport, &status); - *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; - return retcode; + retcode = caps->get_dcd(rig, vfo, dcd); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); - case RIG_DCD_SERIAL_DSR: - retcode = ser_get_dsr(&rig->state.dcdport, &status); - *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; - return retcode; + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } - case RIG_DCD_SERIAL_CAR: - retcode = ser_get_car(&rig->state.dcdport, &status); - *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; - return retcode; + return retcode; + + break; + + case RIG_DCD_SERIAL_CTS: + retcode = ser_get_cts(&rig->state.dcdport, &status); + *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; + return retcode; + + case RIG_DCD_SERIAL_DSR: + retcode = ser_get_dsr(&rig->state.dcdport, &status); + *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; + return retcode; + + case RIG_DCD_SERIAL_CAR: + retcode = ser_get_car(&rig->state.dcdport, &status); + *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; + return retcode; - case RIG_DCD_PARALLEL: - return par_dcd_get(&rig->state.dcdport, dcd); + case RIG_DCD_PARALLEL: + return par_dcd_get(&rig->state.dcdport, dcd); - case RIG_DCD_NONE: - return -RIG_ENAVAIL; /* not available */ + case RIG_DCD_NONE: + return -RIG_ENAVAIL; /* not available */ - default: - return -RIG_EINVAL; - } + default: + return -RIG_EINVAL; + } - return RIG_OK; + return RIG_OK; } /** * \brief set the repeater shift - * \param rig The rig handle - * \param vfo The target VFO - * \param rptr_shift The repeater shift to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param rptr_shift The repeater shift to set to * * Sets the current repeater shift. * @@ -1634,45 +1871,57 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) */ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_rptr_shift == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_rptr_shift(rig, vfo, rptr_shift); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_rptr_shift(rig, vfo, rptr_shift); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_rptr_shift == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_rptr_shift(rig, vfo, rptr_shift); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_rptr_shift(rig, vfo, rptr_shift); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current repeater shift - * \param rig The rig handle - * \param vfo The target VFO - * \param rptr_shift The location where to store the current repeater shift + * \param rig The rig handle + * \param vfo The target VFO + * \param rptr_shift The location where to store the current repeater shift * * Retrieves the current repeater shift. * @@ -1684,45 +1933,57 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift) */ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !rptr_shift) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_rptr_shift == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_rptr_shift(rig, vfo, rptr_shift); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_rptr_shift(rig, vfo, rptr_shift); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !rptr_shift) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_rptr_shift == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_rptr_shift(rig, vfo, rptr_shift); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_rptr_shift(rig, vfo, rptr_shift); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief set the repeater offset - * \param rig The rig handle - * \param vfo The target VFO - * \param rptr_offs The VFO to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param rptr_offs The VFO to set to * * Sets the current repeater offset. * @@ -1732,48 +1993,59 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift) * * \sa rig_get_rptr_offs() */ - int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_rptr_offs == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_rptr_offs(rig, vfo, rptr_offs); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_rptr_offs(rig, vfo, rptr_offs); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_rptr_offs == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_rptr_offs(rig, vfo, rptr_offs); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_rptr_offs(rig, vfo, rptr_offs); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current repeater offset - * \param rig The rig handle - * \param vfo The target VFO - * \param rptr_offs The location where to store the current repeater offset + * \param rig The rig handle + * \param vfo The target VFO + * \param rptr_offs The location where to store the current repeater offset * * Retrieves the current repeater offset. * @@ -1783,49 +2055,59 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs) * * \sa rig_set_rptr_offs() */ - int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !rptr_offs) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_rptr_offs == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_rptr_offs(rig, vfo, rptr_offs); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_rptr_offs(rig, vfo, rptr_offs); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !rptr_offs) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_rptr_offs == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_rptr_offs(rig, vfo, rptr_offs); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_rptr_offs(rig, vfo, rptr_offs); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } /** * \brief set the split frequencies - * \param rig The rig handle - * \param vfo The target VFO - * \param tx_freq The transmit split frequency to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param tx_freq The transmit split frequency to set to * * Sets the split(TX) frequency. * @@ -1835,71 +2117,82 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs) * * \sa rig_get_split_freq(), rig_set_split_vfo() */ - int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo, tx_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo, tx_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_split_freq && - ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX || - vfo == rig->state.current_vfo)) - return caps->set_split_freq(rig, vfo, tx_freq); - - /* Assisted mode */ - - curr_vfo = rig->state.current_vfo; - - /* Use previously setup TxVFO */ - if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) - tx_vfo = rig->state.tx_vfo; - else - tx_vfo = vfo; - - if (caps->set_freq && (caps->targetable_vfo&RIG_TARGETABLE_FREQ)) - return caps->set_freq(rig, tx_vfo, tx_freq); - - - if (caps->set_vfo) { - retcode = caps->set_vfo(rig, tx_vfo); - } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { - retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } else { - return -RIG_ENAVAIL; - } - if (retcode != RIG_OK) - return retcode; - - if (caps->set_split_freq) - retcode = caps->set_split_freq(rig, vfo, tx_freq); - else - retcode = caps->set_freq(rig, RIG_VFO_CURR, tx_freq); - - /* try and revert even if we had an error above */ - if (caps->set_vfo) { - rc2 = caps->set_vfo(rig, curr_vfo); - } else { - rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + + caps = rig->caps; + + if (caps->set_split_freq + && ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == RIG_VFO_TX + || vfo == rig->state.current_vfo)) { + return caps->set_split_freq(rig, vfo, tx_freq); + } + + /* Assisted mode */ + curr_vfo = rig->state.current_vfo; + + /* Use previously setup TxVFO */ + if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) { + tx_vfo = rig->state.tx_vfo; + } else { + tx_vfo = vfo; + } + + if (caps->set_freq && (caps->targetable_vfo & RIG_TARGETABLE_FREQ)) { + return caps->set_freq(rig, tx_vfo, tx_freq); + } + + + if (caps->set_vfo) { + retcode = caps->set_vfo(rig, tx_vfo); + } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { + retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } else { + return -RIG_ENAVAIL; + } + + if (retcode != RIG_OK) { + return retcode; + } + + if (caps->set_split_freq) { + retcode = caps->set_split_freq(rig, vfo, tx_freq); + } else { + retcode = caps->set_freq(rig, RIG_VFO_CURR, tx_freq); + } + + /* try and revert even if we had an error above */ + if (caps->set_vfo) { + rc2 = caps->set_vfo(rig, curr_vfo); + } else { + rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current split frequencies - * \param rig The rig handle - * \param vfo The target VFO - * \param tx_freq The location where to store the current transmit split frequency + * \param rig The rig handle + * \param vfo The target VFO + * \param tx_freq The location where to store the current transmit split frequency * * Retrieves the current split(TX) frequency. * @@ -1911,69 +2204,80 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq) */ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo, tx_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo, tx_vfo; - if (CHECK_RIG_ARG(rig) || !tx_freq) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_split_freq && - ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX || - vfo == rig->state.current_vfo)) - return caps->get_split_freq(rig, vfo, tx_freq); - - /* Assisted mode */ - - curr_vfo = rig->state.current_vfo; - - /* Use previously setup TxVFO */ - if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) - tx_vfo = rig->state.tx_vfo; - else - tx_vfo = vfo; - - if (caps->get_freq && (caps->targetable_vfo&RIG_TARGETABLE_FREQ)) - return caps->get_freq(rig, tx_vfo, tx_freq); - - - if (caps->set_vfo) { - retcode = caps->set_vfo(rig, tx_vfo); - } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { - retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } else { - return -RIG_ENAVAIL; - } - if (retcode != RIG_OK) - return retcode; - - if (caps->get_split_freq) - retcode = caps->get_split_freq(rig, vfo, tx_freq); - else - retcode = caps->get_freq(rig, RIG_VFO_CURR, tx_freq); - - /* try and revert even if we had an error above */ - if (caps->set_vfo) { - rc2 = caps->set_vfo(rig, curr_vfo); - } else { - rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !tx_freq) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_split_freq + && ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == RIG_VFO_TX + || vfo == rig->state.current_vfo)) { + return caps->get_split_freq(rig, vfo, tx_freq); + } + + /* Assisted mode */ + curr_vfo = rig->state.current_vfo; + + /* Use previously setup TxVFO */ + if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) { + tx_vfo = rig->state.tx_vfo; + } else { + tx_vfo = vfo; + } + + if (caps->get_freq && (caps->targetable_vfo & RIG_TARGETABLE_FREQ)) { + return caps->get_freq(rig, tx_vfo, tx_freq); + } + + + if (caps->set_vfo) { + retcode = caps->set_vfo(rig, tx_vfo); + } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { + retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } else { + return -RIG_ENAVAIL; + } + + if (retcode != RIG_OK) { + return retcode; + } + + if (caps->get_split_freq) { + retcode = caps->get_split_freq(rig, vfo, tx_freq); + } else { + retcode = caps->get_freq(rig, RIG_VFO_CURR, tx_freq); + } + + /* try and revert even if we had an error above */ + if (caps->set_vfo) { + rc2 = caps->set_vfo(rig, curr_vfo); + } else { + rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief set the split modes - * \param rig The rig handle - * \param vfo The target VFO - * \param tx_mode The transmit split mode to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param tx_mode The transmit split mode to set to * \param tx_width The transmit split width to set to or the special * value RIG_PASSBAND_NOCHANGE which leaves the passband unchanged * from the current value or default for the mode determined by the @@ -1987,73 +2291,84 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq) * * \sa rig_get_split_mode() */ - -int HAMLIB_API rig_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width) +int HAMLIB_API rig_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, + pbwidth_t tx_width) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo, tx_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo, tx_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_split_mode && - ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX || - vfo == rig->state.current_vfo)) - return caps->set_split_mode(rig, vfo, tx_mode, tx_width); - - /* Assisted mode */ - - curr_vfo = rig->state.current_vfo; - - /* Use previously setup TxVFO */ - if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) - tx_vfo = rig->state.tx_vfo; - else - tx_vfo = vfo; - - if (caps->set_mode && (caps->targetable_vfo&RIG_TARGETABLE_MODE)) - return caps->set_mode(rig, tx_vfo, tx_mode, tx_width); - - - if (caps->set_vfo) { - retcode = caps->set_vfo(rig, tx_vfo); - } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { - retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } else { - return -RIG_ENAVAIL; - } - if (retcode != RIG_OK) - return retcode; - - if (caps->set_split_mode) - retcode = caps->set_split_mode(rig, vfo, tx_mode, tx_width); - else - retcode = caps->set_mode(rig, RIG_VFO_CURR, tx_mode, tx_width); - - /* try and revert even if we had an error above */ - if (caps->set_vfo) { - rc2 = caps->set_vfo(rig, curr_vfo); - } else { - rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_split_mode + && ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == RIG_VFO_TX + || vfo == rig->state.current_vfo)) { + return caps->set_split_mode(rig, vfo, tx_mode, tx_width); + } + + /* Assisted mode */ + curr_vfo = rig->state.current_vfo; + + /* Use previously setup TxVFO */ + if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) { + tx_vfo = rig->state.tx_vfo; + } else { + tx_vfo = vfo; + } + + if (caps->set_mode && (caps->targetable_vfo & RIG_TARGETABLE_MODE)) { + return caps->set_mode(rig, tx_vfo, tx_mode, tx_width); + } + + + if (caps->set_vfo) { + retcode = caps->set_vfo(rig, tx_vfo); + } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { + retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } else { + return -RIG_ENAVAIL; + } + + if (retcode != RIG_OK) { + return retcode; + } + + if (caps->set_split_mode) { + retcode = caps->set_split_mode(rig, vfo, tx_mode, tx_width); + } else { + retcode = caps->set_mode(rig, RIG_VFO_CURR, tx_mode, tx_width); + } + + /* try and revert even if we had an error above */ + if (caps->set_vfo) { + rc2 = caps->set_vfo(rig, curr_vfo); + } else { + rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current split modes - * \param rig The rig handle - * \param vfo The target VFO - * \param tx_mode The location where to store the current transmit split mode - * \param tx_width The location where to store the current transmit split width + * \param rig The rig handle + * \param vfo The target VFO + * \param tx_mode The location where to store the current transmit split mode + * \param tx_width The location where to store the current transmit split width * * Retrieves the current split(TX) mode and passband. * If the backend is unable to determine the width, the \a tx_width @@ -2067,76 +2382,88 @@ int HAMLIB_API rig_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_ * * \sa rig_set_split_mode() */ -int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width) +int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, + pbwidth_t *tx_width) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo, tx_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo, tx_vfo; - if (CHECK_RIG_ARG(rig) || !tx_mode || !tx_width) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_split_mode && - ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX || - vfo == rig->state.current_vfo)) - return caps->get_split_mode(rig, vfo, tx_mode, tx_width); - - /* Assisted mode */ - - curr_vfo = rig->state.current_vfo; - - /* Use previously setup TxVFO */ - if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) - tx_vfo = rig->state.tx_vfo; - else - tx_vfo = vfo; - - if (caps->get_mode && (caps->targetable_vfo&RIG_TARGETABLE_MODE)) - return caps->get_mode(rig, tx_vfo, tx_mode, tx_width); - - - if (caps->set_vfo) { - retcode = caps->set_vfo(rig, tx_vfo); - } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { - retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } else { - return -RIG_ENAVAIL; - } - if (retcode != RIG_OK) - return retcode; - - if (caps->get_split_mode) - retcode = caps->get_split_mode(rig, vfo, tx_mode, tx_width); - else - retcode = caps->get_mode(rig, RIG_VFO_CURR, tx_mode, tx_width); - - /* try and revert even if we had an error above */ - if (caps->set_vfo) { - rc2 = caps->set_vfo(rig, curr_vfo); - } else { - rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); - } - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !tx_mode || !tx_width) { + return -RIG_EINVAL; } - if (*tx_width == RIG_PASSBAND_NORMAL && *tx_mode != RIG_MODE_NONE) - *tx_width = rig_passband_normal (rig, *tx_mode); + caps = rig->caps; - return retcode; + if (caps->get_split_mode + && ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == RIG_VFO_TX + || vfo == rig->state.current_vfo)) { + return caps->get_split_mode(rig, vfo, tx_mode, tx_width); + } + + /* Assisted mode */ + curr_vfo = rig->state.current_vfo; + + /* Use previously setup TxVFO */ + if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX) { + tx_vfo = rig->state.tx_vfo; + } else { + tx_vfo = vfo; + } + + if (caps->get_mode && (caps->targetable_vfo & RIG_TARGETABLE_MODE)) { + return caps->get_mode(rig, tx_vfo, tx_mode, tx_width); + } + + + if (caps->set_vfo) { + retcode = caps->set_vfo(rig, tx_vfo); + } else if (rig_has_vfo_op(rig, RIG_OP_TOGGLE) && caps->vfo_op) { + retcode = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } else { + return -RIG_ENAVAIL; + } + + if (retcode != RIG_OK) { + return retcode; + } + + if (caps->get_split_mode) { + retcode = caps->get_split_mode(rig, vfo, tx_mode, tx_width); + } else { + retcode = caps->get_mode(rig, RIG_VFO_CURR, tx_mode, tx_width); + } + + /* try and revert even if we had an error above */ + if (caps->set_vfo) { + rc2 = caps->set_vfo(rig, curr_vfo); + } else { + rc2 = caps->vfo_op(rig, vfo, RIG_OP_TOGGLE); + } + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + if (*tx_width == RIG_PASSBAND_NORMAL && *tx_mode != RIG_MODE_NONE) { + *tx_width = rig_passband_normal(rig, *tx_mode); + } + + return retcode; } /** * \brief set the split frequency and mode - * \param rig The rig handle - * \param vfo The target VFO + * \param rig The rig handle + * \param vfo The target VFO * \param tx_freq The transmit frequency to set to - * \param tx_mode The transmit split mode to set to + * \param tx_mode The transmit split mode to set to * \param tx_width The transmit split width to set to or the special * value RIG_PASSBAND_NOCHANGE which leaves the passband unchanged * from the current value or default for the mode determined by the @@ -2155,36 +2482,41 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth * * \sa rig_set_split_freq(), rig_set_split_mode(), rig_get_split_freq_mode() */ - -int HAMLIB_API rig_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t tx_freq, rmode_t tx_mode, pbwidth_t tx_width) +int HAMLIB_API rig_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t tx_freq, + rmode_t tx_mode, pbwidth_t tx_width) { - const struct rig_caps *caps; - int retcode; + const struct rig_caps *caps; + int retcode; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_split_freq_mode) { - return caps->set_split_freq_mode (rig, vfo, tx_freq, tx_mode, tx_width); - } + caps = rig->caps; - retcode = rig_set_split_freq (rig, vfo, tx_freq); - if (RIG_OK == retcode) { - retcode = rig_set_split_mode (rig, vfo, tx_mode, tx_width); - } + if (caps->set_split_freq_mode) { + return caps->set_split_freq_mode(rig, vfo, tx_freq, tx_mode, tx_width); + } - return retcode; + retcode = rig_set_split_freq(rig, vfo, tx_freq); + + if (RIG_OK == retcode) { + retcode = rig_set_split_mode(rig, vfo, tx_mode, tx_width); + } + + return retcode; } + /** * \brief get the current split frequency and mode - * \param rig The rig handle - * \param vfo The target VFO + * \param rig The rig handle + * \param vfo The target VFO * \param tx_freq The location where to store the current transmit frequency - * \param tx_mode The location where to store the current transmit split mode - * \param tx_width The location where to store the current transmit split width + * \param tx_mode The location where to store the current transmit split mode + * \param tx_width The location where to store the current transmit split width * * Retrieves the current split(TX) frequency, mode and passband. * If the backend is unable to determine the width, the \a tx_width @@ -2203,34 +2535,40 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t tx_freq, rmod * * \sa rig_get_split_freq(), rig_get_split_mode(), rig_set_split_freq_mode() */ -int HAMLIB_API rig_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *tx_freq, rmode_t *tx_mode, pbwidth_t *tx_width) +int HAMLIB_API rig_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *tx_freq, + rmode_t *tx_mode, pbwidth_t *tx_width) { - const struct rig_caps *caps; - int retcode; + const struct rig_caps *caps; + int retcode; - if (CHECK_RIG_ARG(rig) || !tx_freq || !tx_mode || !tx_width) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !tx_freq || !tx_mode || !tx_width) { + return -RIG_EINVAL; + } - if (caps->get_split_freq_mode) { - return caps->get_split_freq_mode (rig, vfo, tx_freq, tx_mode, tx_width); - } + caps = rig->caps; - retcode = rig_get_split_freq (rig, vfo, tx_freq); - if (RIG_OK == retcode) { - retcode = rig_get_split_mode (rig, vfo, tx_mode, tx_width); - } + if (caps->get_split_freq_mode) { + return caps->get_split_freq_mode(rig, vfo, tx_freq, tx_mode, tx_width); + } - return retcode; + retcode = rig_get_split_freq(rig, vfo, tx_freq); + + if (RIG_OK == retcode) { + retcode = rig_get_split_mode(rig, vfo, tx_mode, tx_width); + } + + return retcode; } + /** * \brief set the split mode - * \param rig The rig handle - * \param vfo The target VFO - * \param split The split mode to set to - * \param tx_vfo The transmit VFO + * \param rig The rig handle + * \param vfo The target VFO + * \param split The split mode to set to + * \param tx_vfo The transmit VFO * * Sets the current split mode. * @@ -2240,56 +2578,72 @@ int HAMLIB_API rig_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *tx_freq, rmo * * \sa rig_get_split_vfo() */ -int HAMLIB_API rig_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo) +int HAMLIB_API rig_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, + vfo_t tx_vfo) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_split_vfo == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - { - retcode = caps->set_split_vfo(rig, vfo, split, tx_vfo); - if (retcode == RIG_OK) - rig->state.tx_vfo = tx_vfo; - return retcode; - } - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_split_vfo(rig, vfo, split, tx_vfo); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - if (retcode == RIG_OK) - rig->state.tx_vfo = tx_vfo; + caps = rig->caps; - return retcode; + if (caps->set_split_vfo == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + retcode = caps->set_split_vfo(rig, vfo, split, tx_vfo); + + if (retcode == RIG_OK) { + rig->state.tx_vfo = tx_vfo; + } + + return retcode; + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_split_vfo(rig, vfo, split, tx_vfo); + + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + if (retcode == RIG_OK) { + rig->state.tx_vfo = tx_vfo; + } + + return retcode; } + /** * \brief get the current split mode - * \param rig The rig handle - * \param vfo The target VFO - * \param split The location where to store the current split mode - * \param tx_vfo The transmit VFO + * \param rig The rig handle + * \param vfo The target VFO + * \param split The location where to store the current split mode + * \param tx_vfo The transmit VFO * * Retrieves the current split mode. * @@ -2299,50 +2653,63 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vf * * \sa rig_set_split_vfo() */ -int HAMLIB_API rig_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo) +int HAMLIB_API rig_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, + vfo_t *tx_vfo) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !split || !tx_vfo) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_split_vfo == NULL) - return -RIG_ENAVAIL; - - /* overidden by backend at will */ - *tx_vfo = rig->state.tx_vfo; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_split_vfo(rig, vfo, split, tx_vfo); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_split_vfo(rig, vfo, split, tx_vfo); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !split || !tx_vfo) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_split_vfo == NULL) { + return -RIG_ENAVAIL; + } + + /* overidden by backend at will */ + *tx_vfo = rig->state.tx_vfo; + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_split_vfo(rig, vfo, split, tx_vfo); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_split_vfo(rig, vfo, split, tx_vfo); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief set the RIT - * \param rig The rig handle - * \param vfo The target VFO - * \param rit The RIT offset to adjust to + * \param rig The rig handle + * \param vfo The target VFO + * \param rit The RIT offset to adjust to * * Sets the current RIT offset. A value of 0 for \a rit disables RIT. * @@ -2352,48 +2719,59 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_ * * \sa rig_get_rit() */ - int HAMLIB_API rig_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_rit == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_rit(rig, vfo, rit); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_rit(rig, vfo, rit); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_rit == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_rit(rig, vfo, rit); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_rit(rig, vfo, rit); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current RIT offset - * \param rig The rig handle - * \param vfo The target VFO - * \param rit The location where to store the current RIT offset + * \param rig The rig handle + * \param vfo The target VFO + * \param rit The location where to store the current RIT offset * * Retrieves the current RIT offset. * @@ -2403,48 +2781,59 @@ int HAMLIB_API rig_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) * * \sa rig_set_rit() */ - int HAMLIB_API rig_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !rit) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_rit == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_rit(rig, vfo, rit); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_rit(rig, vfo, rit); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !rit) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_rit == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_rit(rig, vfo, rit); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_rit(rig, vfo, rit); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief set the XIT - * \param rig The rig handle - * \param vfo The target VFO - * \param xit The XIT offset to adjust to + * \param rig The rig handle + * \param vfo The target VFO + * \param xit The XIT offset to adjust to * * Sets the current XIT offset. A value of 0 for \a xit disables XIT. * @@ -2454,48 +2843,59 @@ int HAMLIB_API rig_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) * * \sa rig_get_xit() */ - int HAMLIB_API rig_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_xit == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_xit(rig, vfo, xit); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_xit(rig, vfo, xit); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_xit == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_xit(rig, vfo, xit); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_xit(rig, vfo, xit); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current XIT offset - * \param rig The rig handle - * \param vfo The target VFO - * \param xit The location where to store the current XIT offset + * \param rig The rig handle + * \param vfo The target VFO + * \param xit The location where to store the current XIT offset * * Retrieves the current XIT offset. * @@ -2505,50 +2905,59 @@ int HAMLIB_API rig_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit) * * \sa rig_set_xit() */ - int HAMLIB_API rig_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !xit) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_xit == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_xit(rig, vfo, xit); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_xit(rig, vfo, xit); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !xit) { + return -RIG_EINVAL; } - return retcode; -} + caps = rig->caps; + if (caps->get_xit == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_xit(rig, vfo, xit); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_xit(rig, vfo, xit); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; +} /** * \brief set the Tuning Step - * \param rig The rig handle - * \param vfo The target VFO - * \param ts The tuning step to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param ts The tuning step to set to * * Sets the Tuning Step. * @@ -2558,48 +2967,59 @@ int HAMLIB_API rig_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit) * * \sa rig_get_ts() */ - int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_ts == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ts(rig, vfo, ts); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_ts(rig, vfo, ts); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_ts == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_ts(rig, vfo, ts); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_ts(rig, vfo, ts); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current Tuning Step - * \param rig The rig handle - * \param vfo The target VFO - * \param ts The location where to store the current tuning step + * \param rig The rig handle + * \param vfo The target VFO + * \param ts The location where to store the current tuning step * * Retrieves the current tuning step. * @@ -2609,53 +3029,64 @@ int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) * * \sa rig_set_ts() */ - int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !ts) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_ts == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ts(rig, vfo, ts); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_ts(rig, vfo, ts); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !ts) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->get_ts == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_ts(rig, vfo, ts); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_ts(rig, vfo, ts); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief set the antenna - * \param rig The rig handle - * \param vfo The target VFO - * \param ant The anntena to select + * \param rig The rig handle + * \param vfo The target VFO + * \param ant The anntena to select * * Select the antenna connector. \code - rig_set_ant(rig, RIG_VFO_CURR, RIG_ANT_1); // apply to both TX&RX - rig_set_ant(rig, RIG_VFO_RX, RIG_ANT_2); + rig_set_ant(rig, RIG_VFO_CURR, RIG_ANT_1); // apply to both TX&RX + rig_set_ant(rig, RIG_VFO_RX, RIG_ANT_2); \endcode * * \return RIG_OK if the operation has been sucessful, otherwise @@ -2664,48 +3095,59 @@ int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts) * * \sa rig_get_ant() */ - int HAMLIB_API rig_set_ant(RIG *rig, vfo_t vfo, ant_t ant) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->set_ant == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ant(rig, vfo, ant); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->set_ant(rig, vfo, ant); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->set_ant == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_ant(rig, vfo, ant); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_ant(rig, vfo, ant); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief get the current antenna - * \param rig The rig handle - * \param vfo The target VFO - * \param ant The location where to store the current antenna + * \param rig The rig handle + * \param vfo The target VFO + * \param ant The location where to store the current antenna * * Retrieves the current antenna. * @@ -2715,52 +3157,61 @@ int HAMLIB_API rig_set_ant(RIG *rig, vfo_t vfo, ant_t ant) * * \sa rig_set_ant() */ - int HAMLIB_API rig_get_ant(RIG *rig, vfo_t vfo, ant_t *ant) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !ant) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->get_ant == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ant(rig, vfo, ant); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->get_ant(rig, vfo, ant); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !ant) { + return -RIG_EINVAL; } - return retcode; -} + caps = rig->caps; + if (caps->get_ant == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->get_ant(rig, vfo, ant); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_ant(rig, vfo, ant); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; +} /** * \brief conversion utility from relative range to absolute in mW - * \param rig The rig handle - * \param mwpower The location where to store the converted power in mW - * \param power The relative power - * \param freq The frequency where the conversion should take place - * \param mode The mode where the conversion should take place + * \param rig The rig handle + * \param mwpower The location where to store the converted power in mW + * \param power The relative power + * \param freq The frequency where the conversion should take place + * \param mode The mode where the conversion should take place * * Converts a power value expressed in a range on a [0.0 .. 1.0] relative * scale to the real transmit power in milli Watts the radio would emit. @@ -2774,34 +3225,43 @@ int HAMLIB_API rig_get_ant(RIG *rig, vfo_t vfo, ant_t *ant) * * \sa rig_mW2power() */ -int HAMLIB_API rig_power2mW(RIG *rig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode) +int HAMLIB_API rig_power2mW(RIG *rig, unsigned int *mwpower, float power, + freq_t freq, rmode_t mode) { - const freq_range_t *txrange; + const freq_range_t *txrange; - if (!rig || !rig->caps || !mwpower || power<0.0 || power>1.0) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->power2mW != NULL) - return rig->caps->power2mW(rig, mwpower, power, freq, mode); + if (!rig || !rig->caps || !mwpower || power < 0.0 || power > 1.0) { + return -RIG_EINVAL; + } - txrange = rig_get_range(rig->state.tx_range_list, freq, mode); - if (!txrange) { - /* - * freq is not on the tx range! - */ - return -RIG_ECONF; /* could be RIG_EINVAL ? */ - } - *mwpower = (unsigned int)(power * txrange->high_power); - return RIG_OK; + if (rig->caps->power2mW != NULL) { + return rig->caps->power2mW(rig, mwpower, power, freq, mode); + } + + txrange = rig_get_range(rig->state.tx_range_list, freq, mode); + + if (!txrange) { + /* + * freq is not on the tx range! + */ + return -RIG_ECONF; /* could be RIG_EINVAL ? */ + } + + *mwpower = (unsigned int)(power * txrange->high_power); + + return RIG_OK; } + /** * \brief conversion utility from absolute in mW to relative range - * \param rig The rig handle - * \param power The location where to store the converted relative power - * \param mwpower The power in mW - * \param freq The frequency where the conversion should take place - * \param mode The mode where the conversion should take place + * \param rig The rig handle + * \param power The location where to store the converted relative power + * \param mwpower The power in mW + * \param freq The frequency where the conversion should take place + * \param mode The mode where the conversion should take place * * Converts a power value expressed in the real transmit power in milli Watts * the radio would emit to a range on a [0.0 .. 1.0] relative scale. @@ -2815,37 +3275,49 @@ int HAMLIB_API rig_power2mW(RIG *rig, unsigned int *mwpower, float power, freq_t * * \sa rig_power2mW() */ -int HAMLIB_API rig_mW2power(RIG *rig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode) +int HAMLIB_API rig_mW2power(RIG *rig, float *power, unsigned int mwpower, + freq_t freq, rmode_t mode) { - const freq_range_t *txrange; + const freq_range_t *txrange; - if (!rig || !rig->caps || !power || mwpower<=0) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->mW2power != NULL) - return rig->caps->mW2power(rig, power, mwpower, freq, mode); + if (!rig || !rig->caps || !power || mwpower <= 0) { + return -RIG_EINVAL; + } - txrange = rig_get_range(rig->state.tx_range_list, freq, mode); - if (!txrange) { - /* - * freq is not on the tx range! - */ - return -RIG_ECONF; /* could be RIG_EINVAL ? */ - } - if (txrange->high_power == 0) { - *power = 0.0; - return RIG_OK; - } - *power = (float)mwpower / txrange->high_power; - if (*power > 1.0) - *power = 1.0; - return (mwpower>txrange->high_power? RIG_OK : -RIG_ETRUNC); + if (rig->caps->mW2power != NULL) { + return rig->caps->mW2power(rig, power, mwpower, freq, mode); + } + + txrange = rig_get_range(rig->state.tx_range_list, freq, mode); + + if (!txrange) { + /* + * freq is not on the tx range! + */ + return -RIG_ECONF; /* could be RIG_EINVAL ? */ + } + + if (txrange->high_power == 0) { + *power = 0.0; + return RIG_OK; + } + + *power = (float)mwpower / txrange->high_power; + + if (*power > 1.0) { + *power = 1.0; + } + + return (mwpower > txrange->high_power ? RIG_OK : -RIG_ETRUNC); } + /** * \brief get the best frequency resolution of the rig - * \param rig The rig handle - * \param mode The mode where the conversion should take place + * \param rig The rig handle + * \param mode The mode where the conversion should take place * * Returns the best frequency resolution of the rig, for a given \a mode. * @@ -2855,27 +3327,31 @@ int HAMLIB_API rig_mW2power(RIG *rig, float *power, unsigned int mwpower, freq_t */ shortfreq_t HAMLIB_API rig_get_resolution(RIG *rig, rmode_t mode) { - const struct rig_state *rs; - int i; + const struct rig_state *rs; + int i; - if (!rig || !rig->caps || !mode) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rs = &rig->state; + if (!rig || !rig->caps || !mode) { + return -RIG_EINVAL; + } - for (i=0; ituning_steps[i].ts; i++) { - if (rs->tuning_steps[i].modes & mode) - return rs->tuning_steps[i].ts; - } + rs = &rig->state; - return -RIG_EINVAL; + for (i = 0; i < TSLSTSIZ && rs->tuning_steps[i].ts; i++) { + if (rs->tuning_steps[i].modes & mode) { + return rs->tuning_steps[i].ts; + } + } + + return -RIG_EINVAL; } /** * \brief turn on/off the radio - * \param rig The rig handle - * \param status The status to set to + * \param rig The rig handle + * \param status The status to set to * * turns on/off the radio. * See #RIG_POWER_ON, #RIG_POWER_OFF and #RIG_POWER_STANDBY defines @@ -2887,22 +3363,26 @@ shortfreq_t HAMLIB_API rig_get_resolution(RIG *rig, rmode_t mode) * * \sa rig_get_powerstat() */ - int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->set_powerstat == NULL) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return rig->caps->set_powerstat(rig, status); + if (rig->caps->set_powerstat == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->set_powerstat(rig, status); } + /** * \brief get the on/off status of the radio - * \param rig The rig handle - * \param status The locatation where to store the current status + * \param rig The rig handle + * \param status The locatation where to store the current status * * Retrieve the status of the radio. See RIG_POWER_ON, RIG_POWER_OFF and * RIG_POWER_STANDBY defines for the \a status. @@ -2913,22 +3393,26 @@ int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status) * * \sa rig_set_powerstat() */ - int HAMLIB_API rig_get_powerstat(RIG *rig, powerstat_t *status) { - if (CHECK_RIG_ARG(rig) || !status) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->get_powerstat == NULL) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig) || !status) { + return -RIG_EINVAL; + } - return rig->caps->get_powerstat(rig, status); + if (rig->caps->get_powerstat == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->get_powerstat(rig, status); } + /** * \brief reset the radio - * \param rig The rig handle - * \param reset The reset operation to perform + * \param rig The rig handle + * \param reset The reset operation to perform * * Resets the radio. * See RIG_RESET_NONE, RIG_RESET_SOFT and RIG_RESET_MCALL defines @@ -2939,23 +3423,30 @@ int HAMLIB_API rig_get_powerstat(RIG *rig, powerstat_t *status) * set appropriately). * */ - int HAMLIB_API rig_reset(RIG *rig, reset_t reset) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->reset == NULL) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return rig->caps->reset(rig, reset); + if (rig->caps->reset == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->reset(rig, reset); } + extern int rig_probe_first(hamlib_port_t *p); -extern int rig_probe_all_backends(hamlib_port_t *p, rig_probe_func_t cfunc, rig_ptr_t data); +extern int rig_probe_all_backends(hamlib_port_t *p, rig_probe_func_t cfunc, + rig_ptr_t data); + + /** * \brief try to guess a rig - * \param port A pointer describing a port linking the host to the rig + * \param port A pointer describing a port linking the host to the rig * * Try to guess what is the model of the first rig attached to the port. * It can be very buggy, and mess up the radio at the other end. @@ -2969,17 +3460,21 @@ extern int rig_probe_all_backends(hamlib_port_t *p, rig_probe_func_t cfunc, rig_ */ rig_model_t HAMLIB_API rig_probe(hamlib_port_t *port) { - if (!port) - return RIG_MODEL_NONE; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return rig_probe_first(port); + if (!port) { + return RIG_MODEL_NONE; + } + + return rig_probe_first(port); } + /** * \brief try to guess rigs - * \param port A pointer describing a port linking the host to the rigs - * \param cfunc Function to be called each time a rig is found - * \param data Arbitrary data passed to cfunc + * \param port A pointer describing a port linking the host to the rigs + * \param cfunc Function to be called each time a rig is found + * \param data Arbitrary data passed to cfunc * * Try to guess what are the model of all rigs attached to the port. * It can be very buggy, and mess up the radio at the other end. @@ -2992,24 +3487,29 @@ rig_model_t HAMLIB_API rig_probe(hamlib_port_t *port) * a negative value if an error occured (in which case, cause is * set appropriately). */ -int HAMLIB_API rig_probe_all(hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data) +int HAMLIB_API rig_probe_all(hamlib_port_t *port, rig_probe_func_t cfunc, + rig_ptr_t data) { - if (!port) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return rig_probe_all_backends(port, cfunc, data); + if (!port) { + return -RIG_EINVAL; + } + + return rig_probe_all_backends(port, cfunc, data); } + /** * \brief check retrieval ability of VFO operations - * \param rig The rig handle - * \param op The VFO op + * \param rig The rig handle + * \param op The VFO op * * Checks if a rig is capable of executing a VFO operation. * Since the \a op is an OR'ed bitmap argument, more than * one op can be checked at the same time. * - * EXAMPLE: if (rig_has_vfo_op(my_rig, RIG_OP_CPY)) disp_VFOcpy_btn(); + * EXAMPLE: if (rig_has_vfo_op(my_rig, RIG_OP_CPY)) disp_VFOcpy_btn(); * * \return a bit map mask of supported op settings that can be retrieved, * otherwise 0 if none supported. @@ -3018,17 +3518,21 @@ int HAMLIB_API rig_probe_all(hamlib_port_t *port, rig_probe_func_t cfunc, rig_pt */ vfo_op_t HAMLIB_API rig_has_vfo_op(RIG *rig, vfo_op_t op) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->caps->vfo_ops & op); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->caps->vfo_ops & op); } + /** * \brief perform Memory/VFO operations - * \param rig The rig handle - * \param vfo The target VFO - * \param op The Memory/VFO operation to perform + * \param rig The rig handle + * \param vfo The target VFO + * \param op The Memory/VFO operation to perform * * Performs Memory/VFO operation. * See #vfo_op_t for more information. @@ -3039,53 +3543,64 @@ vfo_op_t HAMLIB_API rig_has_vfo_op(RIG *rig, vfo_op_t op) * * \sa rig_has_vfo_op() */ - int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->vfo_op == NULL || !rig_has_vfo_op(rig,op)) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->vfo_op(rig, vfo, op); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->vfo_op(rig, vfo, op); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->vfo_op == NULL || !rig_has_vfo_op(rig, op)) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->vfo_op(rig, vfo, op); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->vfo_op(rig, vfo, op); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief check availability of scanning functions - * \param rig The rig handle - * \param scan The scan op + * \param rig The rig handle + * \param scan The scan op * * Checks if a rig is capable of performing a scan operation. * Since the \a scan parameter is an OR'ed bitmap argument, more than * one op can be checked at the same time. * - * EXAMPLE: if (rig_has_scan(my_rig, RIG_SCAN_PRIO)) disp_SCANprio_btn(); + * EXAMPLE: if (rig_has_scan(my_rig, RIG_SCAN_PRIO)) disp_SCANprio_btn(); * * \return a bit map of supported scan settings that can be retrieved, * otherwise 0 if none supported. @@ -3094,18 +3609,22 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) */ scan_t HAMLIB_API rig_has_scan(RIG *rig, scan_t scan) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->caps->scan_ops & scan); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->caps->scan_ops & scan); } + /** * \brief perform Memory/VFO operations - * \param rig The rig handle - * \param vfo The target VFO - * \param scan The scanning operation to perform - * \param ch Optional channel argument used for the scan. + * \param rig The rig handle + * \param vfo The target VFO + * \param scan The scanning operation to perform + * \param ch Optional channel argument used for the scan. * * Performs scanning operation. * See #scan_t for more information. @@ -3116,49 +3635,60 @@ scan_t HAMLIB_API rig_has_scan(RIG *rig, scan_t scan) * * \sa rig_has_scan() */ - int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->scan == NULL || - (scan!=RIG_SCAN_STOP && !rig_has_scan(rig, scan))) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->scan(rig, vfo, scan, ch); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->scan(rig, vfo, scan, ch); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->scan == NULL + || (scan != RIG_SCAN_STOP && !rig_has_scan(rig, scan))) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->scan(rig, vfo, scan, ch); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->scan(rig, vfo, scan, ch); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief send DTMF digits - * \param rig The rig handle - * \param vfo The target VFO - * \param digits Digits to be send + * \param rig The rig handle + * \param vfo The target VFO + * \param digits Digits to be send * * Sends DTMF digits. * See DTMF change speed, etc. (TODO). @@ -3168,49 +3698,60 @@ int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) * set appropriately). * */ - int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !digits) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->send_dtmf == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->send_dtmf(rig, vfo, digits); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->send_dtmf(rig, vfo, digits); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !digits) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->send_dtmf == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + ||vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->send_dtmf(rig, vfo, digits); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->send_dtmf(rig, vfo, digits); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief receive DTMF digits - * \param rig The rig handle - * \param vfo The target VFO - * \param digits Location where the digits are to be stored - * \param length in: max length of buffer, out: number really read. + * \param rig The rig handle + * \param vfo The target VFO + * \param digits Location where the digits are to be stored + * \param length in: max length of buffer, out: number really read. * * Receives DTMF digits (not blocking). * See DTMF change speed, etc. (TODO). @@ -3220,48 +3761,59 @@ int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits) * set appropriately). * */ - int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !digits || !length) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->recv_dtmf == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->recv_dtmf(rig, vfo, digits, length); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->recv_dtmf(rig, vfo, digits, length); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !digits || !length) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->recv_dtmf == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->recv_dtmf(rig, vfo, digits, length); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->recv_dtmf(rig, vfo, digits, length); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } + /** * \brief send morse code - * \param rig The rig handle - * \param vfo The target VFO - * \param msg Message to be sent + * \param rig The rig handle + * \param vfo The target VFO + * \param msg Message to be sent * * Sends morse message. * See keyer change speed, etc. (TODO). @@ -3271,49 +3823,59 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length) * set appropriately). * */ - int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) { - const struct rig_caps *caps; - int retcode, rc2; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode, rc2; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !msg) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; - - if (caps->send_morse == NULL) - return -RIG_ENAVAIL; - - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->send_morse(rig, vfo, msg); - - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; - - retcode = caps->send_morse(rig, vfo, msg); - rc2 = caps->set_vfo(rig, curr_vfo); /* try and revert even if we had - an error above */ - if (RIG_OK == retcode) - { - retcode = rc2; /* return the first error code */ + if (CHECK_RIG_ARG(rig) || !msg) { + return -RIG_EINVAL; } - return retcode; + caps = rig->caps; + + if (caps->send_morse == NULL) { + return -RIG_ENAVAIL; + } + + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->send_morse(rig, vfo, msg); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->send_morse(rig, vfo, msg); + /* try and revert even if we had an error above */ + rc2 = caps->set_vfo(rig, curr_vfo); + + if (RIG_OK == retcode) { + /* return the first error code */ + retcode = rc2; + } + + return retcode; } /** * \brief find the freq_range of freq/mode - * \param range_list The range list to search from - * \param freq The frequency that will be part of this range - * \param mode The mode that will be part of this range + * \param range_list The range list to search from + * \param freq The frequency that will be part of this range + * \param mode The mode that will be part of this range * * Returns a pointer to the #freq_range_t including \a freq and \a mode. * Works for rx and tx range list as well. @@ -3323,26 +3885,31 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) * */ const freq_range_t * -HAMLIB_API rig_get_range(const freq_range_t range_list[], freq_t freq, rmode_t mode) +HAMLIB_API rig_get_range(const freq_range_t range_list[], freq_t freq, + rmode_t mode) { - int i; + int i; - for (i=0; i= range_list[i].start && freq <= range_list[i].end && - (range_list[i].modes & mode)) { - return &range_list[i]; - } - } - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (i = 0; i < FRQRANGESIZ; i++) { + if (range_list[i].start == 0 && range_list[i].end == 0) { + return NULL; + } + + if (freq >= range_list[i].start && freq <= range_list[i].end && + (range_list[i].modes & mode)) { + return &range_list[i]; + } + } + + return NULL; } /** * \brief get general information from the radio - * \param rig The rig handle + * \param rig The rig handle * * Retrieves some general information from the radio. * This can include firmware revision, exact model name, or just nothing. @@ -3351,30 +3918,37 @@ HAMLIB_API rig_get_range(const freq_range_t range_list[], freq_t freq, rmode_t m * if the operation has been sucessful, otherwise NULL if an error occured * or get_info not part of capabilities. */ -const char* HAMLIB_API rig_get_info(RIG *rig) +const char *HAMLIB_API rig_get_info(RIG *rig) { - if (CHECK_RIG_ARG(rig)) - return NULL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->get_info == NULL) - return NULL; + if (CHECK_RIG_ARG(rig)) { + return NULL; + } - return rig->caps->get_info(rig); + if (rig->caps->get_info == NULL) { + return NULL; + } + + return rig->caps->get_info(rig); } -const char* HAMLIB_API rig_license() + +const char *HAMLIB_API rig_license() { - return hamlib_license; + return hamlib_license; } -const char* HAMLIB_API rig_version() + +const char *HAMLIB_API rig_version() { - return hamlib_version2; + return hamlib_version2; } -const char* HAMLIB_API rig_copyright() + +const char *HAMLIB_API rig_copyright() { - return hamlib_copyright2; + return hamlib_copyright2; } /*! @} */ diff --git a/src/rot_conf.c b/src/rot_conf.c index 21b35ec2f..2e2d4a42f 100644 --- a/src/rot_conf.c +++ b/src/rot_conf.c @@ -49,70 +49,86 @@ * Configuration options available in the rot->state struct. */ static const struct confparams rotfrontend_cfg_params[] = { - { TOK_PATHNAME, "rot_pathname", "Rig path name", - "Path name to the device file of the rotator", - "/dev/rotator", RIG_CONF_STRING, - }, - { TOK_WRITE_DELAY, "write_delay", "Write delay", - "Delay in ms between each byte sent out", - "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } - }, - { TOK_POST_WRITE_DELAY, "post_write_delay", "Post write delay", - "Delay in ms between each command sent out", - "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } - }, - { TOK_TIMEOUT, "timeout", "Timeout", "Timeout in ms", - "0", RIG_CONF_NUMERIC, { .n = { 0, 10000, 1 } } - }, - { TOK_RETRY, "retry", "Retry", "Max number of retry", - "0", RIG_CONF_NUMERIC, { .n = { 0, 10, 1 } } - }, + { + TOK_PATHNAME, "rot_pathname", "Rig path name", + "Path name to the device file of the rotator", + "/dev/rotator", RIG_CONF_STRING, + }, + { + TOK_WRITE_DELAY, "write_delay", "Write delay", + "Delay in ms between each byte sent out", + "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } + }, + { + TOK_POST_WRITE_DELAY, "post_write_delay", "Post write delay", + "Delay in ms between each command sent out", + "0", RIG_CONF_NUMERIC, { .n = { 0, 1000, 1 } } + }, + { + TOK_TIMEOUT, "timeout", "Timeout", "Timeout in ms", + "0", RIG_CONF_NUMERIC, { .n = { 0, 10000, 1 } } + }, + { + TOK_RETRY, "retry", "Retry", "Max number of retry", + "0", RIG_CONF_NUMERIC, { .n = { 0, 10, 1 } } + }, - { TOK_MIN_AZ, "min_az", "Minimum azimuth", - "Minimum rotator azimuth in degrees", - "-180", RIG_CONF_NUMERIC, { .n = { -360, 360, .001 } } - }, - { TOK_MAX_AZ, "max_az", "Maximum azimuth", - "Maximum rotator azimuth in degrees", - "180", RIG_CONF_NUMERIC, { .n = { -360, 360, .001 } } - }, - { TOK_MIN_EL, "min_el", "Minimum elevation", - "Minimum rotator elevation in degrees", - "0", RIG_CONF_NUMERIC, { .n = { -90, 180, .001 } } - }, - { TOK_MAX_EL, "max_el", "Maximum elevation", - "Maximum rotator elevation in degrees", - "90", RIG_CONF_NUMERIC, { .n = { -90, 180, .001 } } - }, + { + TOK_MIN_AZ, "min_az", "Minimum azimuth", + "Minimum rotator azimuth in degrees", + "-180", RIG_CONF_NUMERIC, { .n = { -360, 360, .001 } } + }, + { + TOK_MAX_AZ, "max_az", "Maximum azimuth", + "Maximum rotator azimuth in degrees", + "180", RIG_CONF_NUMERIC, { .n = { -360, 360, .001 } } + }, + { + TOK_MIN_EL, "min_el", "Minimum elevation", + "Minimum rotator elevation in degrees", + "0", RIG_CONF_NUMERIC, { .n = { -90, 180, .001 } } + }, + { + TOK_MAX_EL, "max_el", "Maximum elevation", + "Maximum rotator elevation in degrees", + "90", RIG_CONF_NUMERIC, { .n = { -90, 180, .001 } } + }, - { RIG_CONF_END, NULL, } + { RIG_CONF_END, NULL, } }; + static const struct confparams rotfrontend_serial_cfg_params[] = { - { TOK_SERIAL_SPEED, "serial_speed", "Serial speed", - "Serial port baud rate", - "0", RIG_CONF_NUMERIC, { .n = { 300, 115200, 1 } } - }, - { TOK_DATA_BITS, "data_bits", "Serial data bits", - "Serial port data bits", - "8", RIG_CONF_NUMERIC, { .n = { 5, 8, 1 } } - }, - { TOK_STOP_BITS, "stop_bits", "Serial stop bits", - "Serial port stop bits", - "1", RIG_CONF_NUMERIC, { .n = { 0, 3, 1 } } - }, - { TOK_PARITY, "serial_parity", "Serial parity", - "Serial port parity", - "None", RIG_CONF_COMBO, { .c = {{ "None", "Odd", "Even", "Mark", "Space", NULL }} } - }, - { TOK_HANDSHAKE, "serial_handshake", "Serial handshake", - "Serial port handshake", - "None", RIG_CONF_COMBO, { .c = {{ "None", "XONXOFF", "Hardware", NULL }} } - }, + { + TOK_SERIAL_SPEED, "serial_speed", "Serial speed", + "Serial port baud rate", + "0", RIG_CONF_NUMERIC, { .n = { 300, 115200, 1 } } + }, + { + TOK_DATA_BITS, "data_bits", "Serial data bits", + "Serial port data bits", + "8", RIG_CONF_NUMERIC, { .n = { 5, 8, 1 } } + }, + { + TOK_STOP_BITS, "stop_bits", "Serial stop bits", + "Serial port stop bits", + "1", RIG_CONF_NUMERIC, { .n = { 0, 3, 1 } } + }, + { + TOK_PARITY, "serial_parity", "Serial parity", + "Serial port parity", + "None", RIG_CONF_COMBO, { .c = {{ "None", "Odd", "Even", "Mark", "Space", NULL }} } + }, + { + TOK_HANDSHAKE, "serial_handshake", "Serial handshake", + "Serial port handshake", + "None", RIG_CONF_COMBO, { .c = {{ "None", "XONXOFF", "Hardware", NULL }} } + }, - { RIG_CONF_END, NULL, } + { RIG_CONF_END, NULL, } }; + /** * \brief Set rotator state info from alpha input * \param rot @@ -124,105 +140,148 @@ static const struct confparams rotfrontend_serial_cfg_params[] = { */ int frontrot_set_conf(ROT *rot, token_t token, const char *val) { - struct rot_state *rs; - int val_i; + struct rot_state *rs; + int val_i; - rs = &rot->state; + rs = &rot->state; - switch(token) { - case TOK_PATHNAME: - strncpy(rs->rotport.pathname, val, FILPATHLEN-1); - break; - case TOK_WRITE_DELAY: - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.write_delay = val_i; - break; - case TOK_POST_WRITE_DELAY: - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.post_write_delay = val_i; - break; - case TOK_TIMEOUT: - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.timeout = val_i; - break; - case TOK_RETRY: - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.retry = val_i; - break; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - case TOK_SERIAL_SPEED: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.parm.serial.rate = val_i; - break; - case TOK_DATA_BITS: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.parm.serial.data_bits = val_i; - break; - case TOK_STOP_BITS: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (1 != sscanf(val, "%d", &val_i)) - return -RIG_EINVAL; - rs->rotport.parm.serial.stop_bits = val_i; - break; - case TOK_PARITY: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "None")) - rs->rotport.parm.serial.parity = RIG_PARITY_NONE; - else if (!strcmp(val, "Odd")) - rs->rotport.parm.serial.parity = RIG_PARITY_ODD; - else if (!strcmp(val, "Even")) - rs->rotport.parm.serial.parity = RIG_PARITY_EVEN; - else if (!strcmp(val, "Mark")) - rs->rotport.parm.serial.parity = RIG_PARITY_MARK; - else if (!strcmp(val, "Space")) - rs->rotport.parm.serial.parity = RIG_PARITY_SPACE; - else - return -RIG_EINVAL; - break; - case TOK_HANDSHAKE: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - if (!strcmp(val, "None")) - rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE; - else if (!strcmp(val, "XONXOFF")) - rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF; - else if (!strcmp(val, "Hardware")) - rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE; - else - return -RIG_EINVAL; - break; + switch (token) { + case TOK_PATHNAME: + strncpy(rs->rotport.pathname, val, FILPATHLEN - 1); + break; - case TOK_MIN_AZ: - rs->min_az = atof(val); - break; - case TOK_MAX_AZ: - rs->max_az = atof(val); - break; - case TOK_MIN_EL: - rs->min_el = atof(val); - break; - case TOK_MAX_EL: - rs->max_el = atof(val); - break; + case TOK_WRITE_DELAY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } - default: - return -RIG_EINVAL; - } - return RIG_OK; + rs->rotport.write_delay = val_i; + break; + + case TOK_POST_WRITE_DELAY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.post_write_delay = val_i; + break; + + case TOK_TIMEOUT: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.timeout = val_i; + break; + + case TOK_RETRY: + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.retry = val_i; + break; + + case TOK_SERIAL_SPEED: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.parm.serial.rate = val_i; + break; + + case TOK_DATA_BITS: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.parm.serial.data_bits = val_i; + break; + + case TOK_STOP_BITS: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (1 != sscanf(val, "%d", &val_i)) { + return -RIG_EINVAL; + } + + rs->rotport.parm.serial.stop_bits = val_i; + break; + + case TOK_PARITY: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "None")) { + rs->rotport.parm.serial.parity = RIG_PARITY_NONE; + } else if (!strcmp(val, "Odd")) { + rs->rotport.parm.serial.parity = RIG_PARITY_ODD; + } else if (!strcmp(val, "Even")) { + rs->rotport.parm.serial.parity = RIG_PARITY_EVEN; + } else if (!strcmp(val, "Mark")) { + rs->rotport.parm.serial.parity = RIG_PARITY_MARK; + } else if (!strcmp(val, "Space")) { + rs->rotport.parm.serial.parity = RIG_PARITY_SPACE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_HANDSHAKE: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + if (!strcmp(val, "None")) { + rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE; + } else if (!strcmp(val, "XONXOFF")) { + rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF; + } else if (!strcmp(val, "Hardware")) { + rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE; + } else { + return -RIG_EINVAL; + } + + break; + + case TOK_MIN_AZ: + rs->min_az = atof(val); + break; + + case TOK_MAX_AZ: + rs->max_az = atof(val); + break; + + case TOK_MIN_EL: + rs->min_el = atof(val); + break; + + case TOK_MAX_EL: + rs->max_el = atof(val); + break; + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief Get data from rotator state in alpha form * \param rot non-null @@ -232,84 +291,140 @@ int frontrot_set_conf(ROT *rot, token_t token, const char *val) */ int frontrot_get_conf(ROT *rot, token_t token, char *val) { - struct rot_state *rs; - const char *s; + struct rot_state *rs; + const char *s; - rs = &rot->state; + rs = &rot->state; - switch(token) { - case TOK_PATHNAME: - strcpy(val, rs->rotport.pathname); - break; - case TOK_WRITE_DELAY: - sprintf(val, "%d", rs->rotport.write_delay); - break; - case TOK_POST_WRITE_DELAY: - sprintf(val, "%d", rs->rotport.post_write_delay); - break; - case TOK_TIMEOUT: - sprintf(val, "%d", rs->rotport.timeout); - break; - case TOK_RETRY: - sprintf(val, "%d", rs->rotport.retry); - break; - case TOK_SERIAL_SPEED: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rotport.parm.serial.rate); - break; - case TOK_DATA_BITS: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rotport.parm.serial.data_bits); - break; - case TOK_STOP_BITS: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - sprintf(val, "%d", rs->rotport.parm.serial.stop_bits); - break; - case TOK_PARITY: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rotport.parm.serial.parity) { - case RIG_PARITY_NONE: s = "None"; break; - case RIG_PARITY_ODD: s = "Odd"; break; - case RIG_PARITY_EVEN: s = "Even"; break; - case RIG_PARITY_MARK: s = "Mark"; break; - case RIG_PARITY_SPACE: s = "Space"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; - case TOK_HANDSHAKE: - if (rs->rotport.type.rig != RIG_PORT_SERIAL) - return -RIG_EINVAL; - switch (rs->rotport.parm.serial.handshake) { - case RIG_HANDSHAKE_NONE: s = "None"; break; - case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break; - case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break; - default: return -RIG_EINVAL; - } - strcpy(val, s); - break; - case TOK_MIN_AZ: - sprintf(val, "%f", rs->min_az); - break; - case TOK_MAX_AZ: - sprintf(val, "%f", rs->max_az); - break; - case TOK_MIN_EL: - sprintf(val, "%f", rs->min_el); - break; - case TOK_MAX_EL: - sprintf(val, "%f", rs->max_el); - break; - default: - return -RIG_EINVAL; - } - return RIG_OK; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + switch (token) { + case TOK_PATHNAME: + strcpy(val, rs->rotport.pathname); + break; + + case TOK_WRITE_DELAY: + sprintf(val, "%d", rs->rotport.write_delay); + break; + + case TOK_POST_WRITE_DELAY: + sprintf(val, "%d", rs->rotport.post_write_delay); + break; + + case TOK_TIMEOUT: + sprintf(val, "%d", rs->rotport.timeout); + break; + + case TOK_RETRY: + sprintf(val, "%d", rs->rotport.retry); + break; + + case TOK_SERIAL_SPEED: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + sprintf(val, "%d", rs->rotport.parm.serial.rate); + break; + + case TOK_DATA_BITS: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + sprintf(val, "%d", rs->rotport.parm.serial.data_bits); + break; + + case TOK_STOP_BITS: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + sprintf(val, "%d", rs->rotport.parm.serial.stop_bits); + break; + + case TOK_PARITY: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rotport.parm.serial.parity) { + case RIG_PARITY_NONE: + s = "None"; + break; + + case RIG_PARITY_ODD: + s = "Odd"; + break; + + case RIG_PARITY_EVEN: + s = "Even"; + break; + + case RIG_PARITY_MARK: + s = "Mark"; + break; + + case RIG_PARITY_SPACE: + s = "Space"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_HANDSHAKE: + if (rs->rotport.type.rig != RIG_PORT_SERIAL) { + return -RIG_EINVAL; + } + + switch (rs->rotport.parm.serial.handshake) { + case RIG_HANDSHAKE_NONE: + s = "None"; + break; + + case RIG_HANDSHAKE_XONXOFF: + s = "XONXOFF"; + break; + + case RIG_HANDSHAKE_HARDWARE: + s = "Hardware"; + break; + + default: + return -RIG_EINVAL; + } + + strcpy(val, s); + break; + + case TOK_MIN_AZ: + sprintf(val, "%f", rs->min_az); + break; + + case TOK_MAX_AZ: + sprintf(val, "%f", rs->max_az); + break; + + case TOK_MIN_EL: + sprintf(val, "%f", rs->min_el); + break; + + case TOK_MAX_EL: + sprintf(val, "%f", rs->max_el); + break; + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } + /** * \brief Executes cfunc on all the elements stored in the conf table * \param rot non-null @@ -318,28 +433,39 @@ int frontrot_get_conf(ROT *rot, token_t token, char *val) * * start first with backend conf table, then finish with frontend table */ -int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data) +int HAMLIB_API rot_token_foreach(ROT *rot, + int (*cfunc)(const struct confparams *, rig_ptr_t), + rig_ptr_t data) { - const struct confparams *cfp; + const struct confparams *cfp; - if (!rot || !rot->caps || !cfunc) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - for (cfp = rotfrontend_cfg_params; cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; + if (!rot || !rot->caps || !cfunc) { + return -RIG_EINVAL; + } - if (rot->caps->port_type == RIG_PORT_SERIAL) { - for (cfp = rotfrontend_serial_cfg_params; cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; - } + for (cfp = rotfrontend_cfg_params; cfp->name; cfp++) { + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } + } - for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++) - if ((*cfunc)(cfp, data) == 0) - return RIG_OK; + if (rot->caps->port_type == RIG_PORT_SERIAL) { + for (cfp = rotfrontend_serial_cfg_params; cfp->name; cfp++) { + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } + } + } - return RIG_OK; + for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++) { + if ((*cfunc)(cfp, data) == 0) { + return RIG_OK; + } + } + + return RIG_OK; } @@ -352,31 +478,45 @@ int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams * lookup backend config table first, then fall back to frontend. * TODO: should use Lex to speed it up, strcmp hurts! */ -const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *name) +const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, + const char *name) { - const struct confparams *cfp; - token_t token; + const struct confparams *cfp; + token_t token; - if (!rot || !rot->caps) - return NULL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* 0 returned for invalid format */ - token = strtol(name, NULL, 0); + if (!rot || !rot->caps) { + return NULL; + } - for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; - for (cfp = rotfrontend_cfg_params; cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; - if (rot->caps->port_type == RIG_PORT_SERIAL) { - for (cfp = rotfrontend_serial_cfg_params; cfp->name; cfp++) - if (!strcmp(cfp->name, name) || token == cfp->token) - return cfp; - } - return NULL; + /* 0 returned for invalid format */ + token = strtol(name, NULL, 0); + + for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++) { + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } + } + + for (cfp = rotfrontend_cfg_params; cfp->name; cfp++) { + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } + } + + if (rot->caps->port_type == RIG_PORT_SERIAL) { + for (cfp = rotfrontend_serial_cfg_params; cfp->name; cfp++) { + if (!strcmp(cfp->name, name) || token == cfp->token) { + return cfp; + } + } + } + + return NULL; } + /** * \brief Simple lookup returning token id associated with name * \param rot @@ -385,20 +525,25 @@ const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char * */ token_t HAMLIB_API rot_token_lookup(ROT *rot, const char *name) { - const struct confparams *cfp; + const struct confparams *cfp; - cfp = rot_confparam_lookup(rot, name); - if (!cfp) - return RIG_CONF_END; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return cfp->token; + cfp = rot_confparam_lookup(rot, name); + + if (!cfp) { + return RIG_CONF_END; + } + + return cfp->token; } + /** * \brief set a rotator configuration parameter - * \param rot The rot handle - * \param token The parameter - * \param val The value to set the parameter to + * \param rot The rot handle + * \param token The parameter + * \param val The value to set the parameter to * * Sets a configuration parameter. * @@ -410,33 +555,42 @@ token_t HAMLIB_API rot_token_lookup(ROT *rot, const char *name) */ int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val) { - if (!rot || !rot->caps) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig_need_debug(RIG_DEBUG_VERBOSE)) { - const struct confparams *cfp; - char tokenstr[12]; - sprintf(tokenstr, "%ld", token); - cfp = rot_confparam_lookup(rot, tokenstr); - if (!cfp) - return -RIG_EINVAL; - rig_debug(RIG_DEBUG_VERBOSE, "%s: %s='%s'\n", __func__, cfp->name, val); - } + if (!rot || !rot->caps) { + return -RIG_EINVAL; + } - if (IS_TOKEN_FRONTEND(token)) - return frontrot_set_conf(rot, token, val); + if (rig_need_debug(RIG_DEBUG_VERBOSE)) { + const struct confparams *cfp; + char tokenstr[12]; + sprintf(tokenstr, "%ld", token); + cfp = rot_confparam_lookup(rot, tokenstr); - if (rot->caps->set_conf == NULL) - return -RIG_ENAVAIL; + if (!cfp) { + return -RIG_EINVAL; + } - return rot->caps->set_conf(rot, token, val); + rot_debug(RIG_DEBUG_VERBOSE, "%s: %s='%s'\n", __func__, cfp->name, val); + } + + if (IS_TOKEN_FRONTEND(token)) { + return frontrot_set_conf(rot, token, val); + } + + if (rot->caps->set_conf == NULL) { + return -RIG_ENAVAIL; + } + + return rot->caps->set_conf(rot, token, val); } + /** * \brief get the value of a configuration parameter - * \param rot The rot handle - * \param token The parameter - * \param val The location where to store the value of config \a token + * \param rot The rot handle + * \param token The parameter + * \param val The location where to store the value of config \a token * * Retrieves the value of a configuration paramter associated with \a token. * @@ -448,16 +602,21 @@ int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val) */ int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val) { - if (!rot || !rot->caps || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (IS_TOKEN_FRONTEND(token)) - return frontrot_get_conf(rot, token, val); + if (!rot || !rot->caps || !val) { + return -RIG_EINVAL; + } - if (rot->caps->get_conf == NULL) - return -RIG_ENAVAIL; + if (IS_TOKEN_FRONTEND(token)) { + return frontrot_get_conf(rot, token, val); + } - return rot->caps->get_conf(rot, token, val); + if (rot->caps->get_conf == NULL) { + return -RIG_ENAVAIL; + } + + return rot->caps->get_conf(rot, token, val); } /** @} */ diff --git a/src/rot_reg.c b/src/rot_reg.c index d8bc25c1f..f019400d0 100644 --- a/src/rot_reg.c +++ b/src/rot_reg.c @@ -48,10 +48,15 @@ #define ROT_BACKEND_MAX 32 -#define DEFINE_INITROT_BACKEND(backend) \ - int MAKE_VERSIONED_FN(PREFIX_INITROTS, ABI_VERSION, backend(void *be_handle)); \ - rig_model_t MAKE_VERSIONED_FN(PREFIX_PROBEROTS, ABI_VERSION, backend(hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)) - +#define DEFINE_INITROT_BACKEND(backend) \ + int MAKE_VERSIONED_FN(PREFIX_INITROTS, \ + ABI_VERSION, \ + backend(void *be_handle)); \ + rig_model_t MAKE_VERSIONED_FN(PREFIX_PROBEROTS, \ + ABI_VERSION, \ + backend(hamlib_port_t *port, \ + rig_probe_func_t cfunc, \ + rig_ptr_t data)) #define ROT_FUNCNAMA(backend) MAKE_VERSIONED_FN(PREFIX_INITROTS, ABI_VERSION, backend) #define ROT_FUNCNAMB(backend) MAKE_VERSIONED_FN(PREFIX_PROBEROTS, ABI_VERSION, backend) @@ -77,6 +82,7 @@ DEFINE_INITROT_BACKEND(ether6); DEFINE_INITROT_BACKEND(cnctrk); DEFINE_INITROT_BACKEND(prosistel); + /*! \def ROT_BACKEND_LIST * \brief Static list of rotator models. * @@ -87,40 +93,37 @@ DEFINE_INITROT_BACKEND(prosistel); * in this array. */ static struct { - int be_num; - const char *be_name; - int (*be_init)(void *); - rot_model_t (*be_probe)(hamlib_port_t *); -} rot_backend_list[ROT_BACKEND_MAX] = -{ - { ROT_DUMMY, ROT_BACKEND_DUMMY, ROT_FUNCNAMA(dummy) }, - { ROT_EASYCOMM, ROT_BACKEND_EASYCOMM, ROT_FUNCNAMA(easycomm) }, - { ROT_FODTRACK, ROT_BACKEND_FODTRACK, ROT_FUNCNAMA(fodtrack) }, - { ROT_ROTOREZ, ROT_BACKEND_ROTOREZ, ROT_FUNCNAMA(rotorez) }, - { ROT_SARTEK, ROT_BACKEND_SARTEK, ROT_FUNCNAMA(sartek) }, - { ROT_GS232A, ROT_BACKEND_GS232A, ROT_FUNCNAMA(gs232a) }, - { ROT_KIT, ROT_BACKEND_KIT, ROT_FUNCNAMA(kit) }, - { ROT_HEATHKIT, ROT_BACKEND_HEATHKIT, ROT_FUNCNAMA(heathkit) }, - { ROT_SPID, ROT_BACKEND_SPID, ROT_FUNCNAMA(spid) }, - { ROT_M2, ROT_BACKEND_M2, ROT_FUNCNAMA(m2) }, - { ROT_ARS, ROT_BACKEND_ARS, ROT_FUNCNAMA(ars) }, - { ROT_AMSAT, ROT_BACKEND_AMSAT, ROT_FUNCNAMA(amsat) }, - { ROT_TS7400, ROT_BACKEND_TS7400, ROT_FUNCNAMA(ts7400) }, - { ROT_CELESTRON, ROT_BACKEND_CELESTRON, ROT_FUNCNAMA(celestron) }, - { ROT_ETHER6, ROT_BACKEND_ETHER6, ROT_FUNCNAMA(ether6) }, - { ROT_CNCTRK, ROT_BACKEND_CNCTRK, ROT_FUNCNAMA(cnctrk) }, - { ROT_PROSISTEL, ROT_BACKEND_PROSISTEL, ROT_FUNCNAMA(prosistel) }, - { 0, NULL }, /* end */ + int be_num; + const char *be_name; + int (*be_init)(void *); + rot_model_t (*be_probe)(hamlib_port_t *); +} rot_backend_list[ROT_BACKEND_MAX] = { + { ROT_DUMMY, ROT_BACKEND_DUMMY, ROT_FUNCNAMA(dummy) }, + { ROT_EASYCOMM, ROT_BACKEND_EASYCOMM, ROT_FUNCNAMA(easycomm) }, + { ROT_FODTRACK, ROT_BACKEND_FODTRACK, ROT_FUNCNAMA(fodtrack) }, + { ROT_ROTOREZ, ROT_BACKEND_ROTOREZ, ROT_FUNCNAMA(rotorez) }, + { ROT_SARTEK, ROT_BACKEND_SARTEK, ROT_FUNCNAMA(sartek) }, + { ROT_GS232A, ROT_BACKEND_GS232A, ROT_FUNCNAMA(gs232a) }, + { ROT_KIT, ROT_BACKEND_KIT, ROT_FUNCNAMA(kit) }, + { ROT_HEATHKIT, ROT_BACKEND_HEATHKIT, ROT_FUNCNAMA(heathkit) }, + { ROT_SPID, ROT_BACKEND_SPID, ROT_FUNCNAMA(spid) }, + { ROT_M2, ROT_BACKEND_M2, ROT_FUNCNAMA(m2) }, + { ROT_ARS, ROT_BACKEND_ARS, ROT_FUNCNAMA(ars) }, + { ROT_AMSAT, ROT_BACKEND_AMSAT, ROT_FUNCNAMA(amsat) }, + { ROT_TS7400, ROT_BACKEND_TS7400, ROT_FUNCNAMA(ts7400) }, + { ROT_CELESTRON, ROT_BACKEND_CELESTRON, ROT_FUNCNAMA(celestron) }, + { ROT_ETHER6, ROT_BACKEND_ETHER6, ROT_FUNCNAMA(ether6) }, + { ROT_CNCTRK, ROT_BACKEND_CNCTRK, ROT_FUNCNAMA(cnctrk) }, + { ROT_PROSISTEL, ROT_BACKEND_PROSISTEL, ROT_FUNCNAMA(prosistel) }, + { 0, NULL }, /* end */ }; + // Apparently, no rotator can be probed. /* - * ROT_BACKEND_LIST is here, please keep it up to data, - * ie. each time you give birth to a new backend - * Also, it should be possible to register "external" backend, - * that is backend that were not known by Hamlib at compile time. - * Maybe, rotlist.h should reserve some numbers for them? --SF + * ROT_BACKEND_LIST is here, please keep it up to date, + * i.e. each time you implement a new backend. */ @@ -129,69 +132,81 @@ static struct { * It is chained, and used in a hash table, see below. */ struct rot_list { - const struct rot_caps *caps; - struct rot_list *next; + const struct rot_caps *caps; + struct rot_list *next; }; + #define ROTLSTHASHSZ 16 #define HASH_FUNC(a) ((a)%ROTLSTHASHSZ) + /* * The rot_hash_table is a hash table pointing to a list of next==NULL - * terminated caps. + * terminated caps. */ static struct rot_list *rot_hash_table[ROTLSTHASHSZ] = { NULL, }; static int rot_lookup_backend(rot_model_t rot_model); + /* * Basically, this is a hash insert function that doesn't check for dup! */ int HAMLIB_API rot_register(const struct rot_caps *caps) { - int hval; - struct rot_list *p; + int hval; + struct rot_list *p; - if (!caps) - return -RIG_EINVAL; + if (!caps) { + return -RIG_EINVAL; + } - rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n",caps->rot_model); + rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n", caps->rot_model); #ifndef DONT_WANT_DUP_CHECK - if (rot_get_caps(caps->rot_model)!=NULL) - return -RIG_EINVAL; + + if (rot_get_caps(caps->rot_model) != NULL) { + return -RIG_EINVAL; + } + #endif - p = (struct rot_list*)malloc(sizeof(struct rot_list)); - if (!p) - return -RIG_ENOMEM; + p = (struct rot_list *)malloc(sizeof(struct rot_list)); - hval = HASH_FUNC(caps->rot_model); - p->caps = caps; - // p->handle = NULL; - p->next = rot_hash_table[hval]; - rot_hash_table[hval] = p; + if (!p) { + return -RIG_ENOMEM; + } - return RIG_OK; + hval = HASH_FUNC(caps->rot_model); + p->caps = caps; + // p->handle = NULL; + p->next = rot_hash_table[hval]; + rot_hash_table[hval] = p; + + return RIG_OK; } + /* * Get rot capabilities. - * ie. rot_hash_table lookup + * i.e. rot_hash_table lookup */ - const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model) { - struct rot_list *p; + struct rot_list *p; - for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p=p->next) { - if (p->caps->rot_model == rot_model) - return p->caps; - } - return NULL; /* sorry, caps not registered! */ + for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p = p->next) { + if (p->caps->rot_model == rot_model) { + return p->caps; + } + } + + return NULL; /* sorry, caps not registered! */ } + /* * lookup for backend index in rot_backend_list table, * according to BACKEND_NUM @@ -199,16 +214,19 @@ const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model) */ static int rot_lookup_backend(rot_model_t rot_model) { - int i; + int i; - for (i=0; inext) { - if (p->caps->rot_model == rot_model) { - if (q == NULL) - rot_hash_table[hval] = p->next; - else - q->next = p->next; - free(p); - return RIG_OK; - } - q = p; - } - return -RIG_EINVAL; /* sorry, caps not registered! */ + hval = HASH_FUNC(rot_model); + q = NULL; + + for (p = rot_hash_table[hval]; p; p = p->next) { + if (p->caps->rot_model == rot_model) { + if (q == NULL) { + rot_hash_table[hval] = p->next; + } else { + q->next = p->next; + } + + free(p); + return RIG_OK; + } + + q = p; + } + + return -RIG_EINVAL; /* sorry, caps not registered! */ } + /* * rot_list_foreach * executes cfunc on all the elements stored in the rot hash list */ -int HAMLIB_API rot_list_foreach(int (*cfunc)(const struct rot_caps*, rig_ptr_t),rig_ptr_t data) +int HAMLIB_API rot_list_foreach(int (*cfunc)(const struct rot_caps *, rig_ptr_t), + rig_ptr_t data) { - struct rot_list *p; - int i; + struct rot_list *p; + int i; - if (!cfunc) - return -RIG_EINVAL; + if (!cfunc) { + return -RIG_EINVAL; + } - for (i=0; inext) - if ((*cfunc)(p->caps,data) == 0) - return RIG_OK; - } - return RIG_OK; + for (i = 0; i < ROTLSTHASHSZ; i++) { + for (p = rot_hash_table[i]; p; p = p->next) + if ((*cfunc)(p->caps, data) == 0) { + return RIG_OK; + } + } + + return RIG_OK; } + /* * rot_probe_all * called straight by rot_probe */ rot_model_t HAMLIB_API rot_probe_all(hamlib_port_t *p) { - int i; - rot_model_t rot_model; + int i; + rot_model_t rot_model; - for (i=0; i -#include "hamlib/rotator.h" +#include #include "serial.h" #include "parallel.h" #include "usb_port.h" @@ -85,56 +85,66 @@ #define CHECK_ROT_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) + /* * Data structure to track the opened rot (by rot_open) */ struct opened_rot_l { - ROT *rot; - struct opened_rot_l *next; + ROT *rot; + struct opened_rot_l *next; }; static struct opened_rot_l *opened_rot_list = { NULL }; + /* * track which rot is opened (with rot_open) * needed at least for transceive mode */ static int add_opened_rot(ROT *rot) { - struct opened_rot_l *p; - p = (struct opened_rot_l *)malloc(sizeof(struct opened_rot_l)); - if (!p) - return -RIG_ENOMEM; - p->rot = rot; - p->next = opened_rot_list; - opened_rot_list = p; - return RIG_OK; + struct opened_rot_l *p; + p = (struct opened_rot_l *)malloc(sizeof(struct opened_rot_l)); + + if (!p) { + return -RIG_ENOMEM; + } + + p->rot = rot; + p->next = opened_rot_list; + opened_rot_list = p; + return RIG_OK; } + static int remove_opened_rot(ROT *rot) { - struct opened_rot_l *p,*q; - q = NULL; + struct opened_rot_l *p, *q; + q = NULL; - for (p=opened_rot_list; p; p=p->next) { - if (p->rot == rot) { - if (q == NULL) { - opened_rot_list = opened_rot_list->next; - } else { - q->next = p->next; - } - free(p); - return RIG_OK; - } - q = p; - } - return -RIG_EINVAL; /* Not found in list ! */ + for (p = opened_rot_list; p; p = p->next) { + if (p->rot == rot) { + if (q == NULL) { + opened_rot_list = opened_rot_list->next; + } else { + q->next = p->next; + } + + free(p); + return RIG_OK; + } + + q = p; + } + + return -RIG_EINVAL; /* Not found in list ! */ } #endif /* !DOC_HIDDEN */ + /** * \brief execs cfunc() on each opened rot - * \param cfunc The function to be executed on each rot - * \param data Data pointer to be passed to cfunc() + * \param cfunc The function to be executed on each rot + * \param data Data pointer to be passed to cfunc() * * Calls cfunc() function for each opened rot. * The contents of the opened rot table @@ -149,21 +159,25 @@ static int remove_opened_rot(ROT *rot) * * \return always RIG_OK. */ - int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data) { - struct opened_rot_l *p; + struct opened_rot_l *p; - for (p=opened_rot_list; p; p=p->next) { - if ((*cfunc)(p->rot,data) == 0) - return RIG_OK; - } - return RIG_OK; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + for (p = opened_rot_list; p; p = p->next) { + if ((*cfunc)(p->rot, data) == 0) { + return RIG_OK; + } + } + + return RIG_OK; } + /** * \brief allocate a new #ROT handle - * \param rot_model The rot model for this new handle + * \param rot_model The rot model for this new handle * * Allocates a new #ROT handle and initializes the associated data * for \a rot_model. @@ -173,105 +187,110 @@ int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data) * * \sa rot_cleanup(), rot_open() */ - -ROT * HAMLIB_API rot_init(rot_model_t rot_model) +ROT *HAMLIB_API rot_init(rot_model_t rot_model) { - ROT *rot; - const struct rot_caps *caps; - struct rot_state *rs; - int retcode; + ROT *rot; + const struct rot_caps *caps; + struct rot_state *rs; + int retcode; - rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_init called \n"); + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - rot_check_backend(rot_model); + rot_check_backend(rot_model); - caps = rot_get_caps(rot_model); - if (!caps) - return NULL; + caps = rot_get_caps(rot_model); - /* - * okay, we've found it. Allocate some memory and set it to zeros, - * and especially the initialize the callbacks - */ - rot = calloc(1, sizeof(ROT)); - if (rot == NULL) { - /* - * FIXME: how can the caller know it's a memory shortage, - * and not "rot not found" ? - */ - return NULL; - } + if (!caps) { + return NULL; + } - /* caps is const, so we need to tell compiler - that we now what we are doing */ - rot->caps = (struct rot_caps *) caps; + /* + * okay, we've found it. Allocate some memory and set it to zeros, + * and especially the initialize the callbacks + */ + rot = calloc(1, sizeof(ROT)); - /* - * populate the rot->state - * TODO: read the Preferences here! - */ + if (rot == NULL) { + /* + * FIXME: how can the caller know it's a memory shortage, + * and not "rot not found" ? + */ + return NULL; + } - rs = &rot->state; + /* caps is const, so we need to tell compiler + that we know what we are doing */ + rot->caps = (struct rot_caps *) caps; - rs->comm_state = 0; - rs->rotport.type.rig = caps->port_type; /* default from caps */ + /* + * populate the rot->state + * TODO: read the Preferences here! + */ + rs = &rot->state; - rs->rotport.write_delay = caps->write_delay; - rs->rotport.post_write_delay = caps->post_write_delay; - rs->rotport.timeout = caps->timeout; - rs->rotport.retry = caps->retry; + rs->comm_state = 0; + rs->rotport.type.rig = caps->port_type; /* default from caps */ - switch (caps->port_type) { - case RIG_PORT_SERIAL: - strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN - 1); - rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */ - rs->rotport.parm.serial.data_bits = caps->serial_data_bits; - rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits; - rs->rotport.parm.serial.parity = caps->serial_parity; - rs->rotport.parm.serial.handshake = caps->serial_handshake; - break; + rs->rotport.write_delay = caps->write_delay; + rs->rotport.post_write_delay = caps->post_write_delay; + rs->rotport.timeout = caps->timeout; + rs->rotport.retry = caps->retry; - case RIG_PORT_PARALLEL: - strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN - 1); - break; + switch (caps->port_type) { + case RIG_PORT_SERIAL: + strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN - 1); + rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */ + rs->rotport.parm.serial.data_bits = caps->serial_data_bits; + rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits; + rs->rotport.parm.serial.parity = caps->serial_parity; + rs->rotport.parm.serial.handshake = caps->serial_handshake; + break; - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: - strncpy(rs->rotport.pathname, "127.0.0.1:4533", FILPATHLEN - 1); - break; + case RIG_PORT_PARALLEL: + strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN - 1); + break; - default: - strncpy(rs->rotport.pathname, "", FILPATHLEN - 1); - } + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: + strncpy(rs->rotport.pathname, "127.0.0.1:4533", FILPATHLEN - 1); + break; - rs->min_el = caps->min_el; - rs->max_el = caps->max_el; - rs->min_az = caps->min_az; - rs->max_az = caps->max_az; + default: + strncpy(rs->rotport.pathname, "", FILPATHLEN - 1); + } - rs->rotport.fd = -1; + rs->min_el = caps->min_el; + rs->max_el = caps->max_el; + rs->min_az = caps->min_az; + rs->max_az = caps->max_az; - /* - * let the backend a chance to setup his private data - * This must be done only once defaults are setup, - * so the backend init can override rot_state. - */ - if (caps->rot_init != NULL) { - retcode = caps->rot_init(rot); - if (retcode != RIG_OK) { - rot_debug(RIG_DEBUG_VERBOSE,"rot:backend_init failed!\n"); - /* cleanup and exit */ - free(rot); - return NULL; - } - } + rs->rotport.fd = -1; - return rot; + /* + * let the backend a chance to setup his private data + * This must be done only once defaults are setup, + * so the backend init can override rot_state. + */ + if (caps->rot_init != NULL) { + retcode = caps->rot_init(rot); + + if (retcode != RIG_OK) { + rot_debug(RIG_DEBUG_VERBOSE, + "%s: backend_init failed!\n", + __func__); + /* cleanup and exit */ + free(rot); + return NULL; + } + } + + return rot; } + /** * \brief open the communication to the rot - * \param rot The #ROT handle of the rotator to be opened + * \param rot The #ROT handle of the rotator to be opened * * Opens communication to a rotator which \a ROT handle has been passed * by argument. @@ -280,95 +299,113 @@ ROT * HAMLIB_API rot_init(rot_model_t rot_model) * a negative value if an error occured (in which case, cause is * set appropriately). * - * \retval RIG_EINVAL \a rot is NULL or unconsistent. - * \retval RIG_ENIMPL port type communication is not implemented yet. + * \retval RIG_EINVAL \a rot is NULL or unconsistent. + * \retval RIG_ENIMPL port type communication is not implemented yet. * * \sa rot_init(), rot_close() */ - int HAMLIB_API rot_open(ROT *rot) { - const struct rot_caps *caps; - struct rot_state *rs; - int status; + const struct rot_caps *caps; + struct rot_state *rs; + int status; - rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_open called \n"); + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rot || !rot->caps) - return -RIG_EINVAL; + if (!rot || !rot->caps) { + return -RIG_EINVAL; + } - caps = rot->caps; - rs = &rot->state; + caps = rot->caps; + rs = &rot->state; - if (rs->comm_state) - return -RIG_EINVAL; + if (rs->comm_state) { + return -RIG_EINVAL; + } - rs->rotport.fd = -1; + rs->rotport.fd = -1; - switch(rs->rotport.type.rig) { - case RIG_PORT_SERIAL: - status = serial_open(&rs->rotport); - if (status != 0) - return status; - break; + switch (rs->rotport.type.rig) { + case RIG_PORT_SERIAL: + status = serial_open(&rs->rotport); - case RIG_PORT_PARALLEL: - status = par_open(&rs->rotport); - if (status < 0) - return status; - break; + if (status != 0) { + return status; + } - case RIG_PORT_DEVICE: - status = open(rs->rotport.pathname, O_RDWR, 0); - if (status < 0) - return -RIG_EIO; - rs->rotport.fd = status; - break; + break; - case RIG_PORT_USB: - status = usb_port_open(&rs->rotport); - if (status < 0) - return status; - break; + case RIG_PORT_PARALLEL: + status = par_open(&rs->rotport); - case RIG_PORT_NONE: - case RIG_PORT_RPC: - break; /* ez :) */ + if (status < 0) { + return status; + } - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: + break; + + case RIG_PORT_DEVICE: + status = open(rs->rotport.pathname, O_RDWR, 0); + + if (status < 0) { + return -RIG_EIO; + } + + rs->rotport.fd = status; + break; + + case RIG_PORT_USB: + status = usb_port_open(&rs->rotport); + + if (status < 0) { + return status; + } + + break; + + case RIG_PORT_NONE: + case RIG_PORT_RPC: + break; /* ez :) */ + + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: /* FIXME: default port */ - status = network_open(&rs->rotport, 4533); - if (status < 0) - return status; - break; + status = network_open(&rs->rotport, 4533); - default: - return -RIG_EINVAL; - } + if (status < 0) { + return status; + } + + break; + + default: + return -RIG_EINVAL; + } - add_opened_rot(rot); + add_opened_rot(rot); - rs->comm_state = 1; + rs->comm_state = 1; - /* - * Maybe the backend has something to initialize - * In case of failure, just close down and report error code. - */ - if (caps->rot_open != NULL) { - status = caps->rot_open(rot); - if (status != RIG_OK) { - return status; - } - } + /* + * Maybe the backend has something to initialize + * In case of failure, just close down and report error code. + */ + if (caps->rot_open != NULL) { + status = caps->rot_open(rot); - return RIG_OK; + if (status != RIG_OK) { + return status; + } + } + + return RIG_OK; } + /** * \brief close the communication to the rot - * \param rot The #ROT handle of the rotator to be closed + * \param rot The #ROT handle of the rotator to be closed * * Closes communication to a rotator which \a ROT handle has been passed * by argument that was previously open with rot_open(). @@ -379,62 +416,70 @@ int HAMLIB_API rot_open(ROT *rot) * * \sa rot_cleanup(), rot_open() */ - int HAMLIB_API rot_close(ROT *rot) { - const struct rot_caps *caps; - struct rot_state *rs; + const struct rot_caps *caps; + struct rot_state *rs; - rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_close called \n"); + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rot || !rot->caps) - return -RIG_EINVAL; + if (!rot || !rot->caps) { + return -RIG_EINVAL; + } - caps = rot->caps; - rs = &rot->state; + caps = rot->caps; + rs = &rot->state; - if (!rs->comm_state) - return -RIG_EINVAL; + if (!rs->comm_state) { + return -RIG_EINVAL; + } - /* - * Let the backend say 73s to the rot. - * and ignore the return code. - */ - if (caps->rot_close) - caps->rot_close(rot); + /* + * Let the backend say 73s to the rot. + * and ignore the return code. + */ + if (caps->rot_close) { + caps->rot_close(rot); + } - if (rs->rotport.fd != -1) { - switch(rs->rotport.type.rig) { - case RIG_PORT_SERIAL: - ser_close(&rs->rotport); - break; - case RIG_PORT_PARALLEL: - par_close(&rs->rotport); - break; - case RIG_PORT_USB: - usb_port_close(&rs->rotport); - break; - case RIG_PORT_NETWORK: - case RIG_PORT_UDP_NETWORK: - network_close(&rs->rotport); - break; - default: - close(rs->rotport.fd); - } - rs->rotport.fd = -1; - } + if (rs->rotport.fd != -1) { + switch (rs->rotport.type.rig) { + case RIG_PORT_SERIAL: + ser_close(&rs->rotport); + break; - remove_opened_rot(rot); + case RIG_PORT_PARALLEL: + par_close(&rs->rotport); + break; - rs->comm_state = 0; + case RIG_PORT_USB: + usb_port_close(&rs->rotport); + break; - return RIG_OK; + case RIG_PORT_NETWORK: + case RIG_PORT_UDP_NETWORK: + network_close(&rs->rotport); + break; + + default: + close(rs->rotport.fd); + } + + rs->rotport.fd = -1; + } + + remove_opened_rot(rot); + + rs->comm_state = 0; + + return RIG_OK; } + /** * \brief release a rot handle and free associated memory - * \param rot The #ROT handle of the radio to be closed + * \param rot The #ROT handle of the radio to be closed * * Releases a rot struct which port has eventualy been closed already * with rot_close(). @@ -445,36 +490,39 @@ int HAMLIB_API rot_close(ROT *rot) * * \sa rot_init(), rot_close() */ - int HAMLIB_API rot_cleanup(ROT *rot) { - rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_cleanup called \n"); + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rot || !rot->caps) - return -RIG_EINVAL; + if (!rot || !rot->caps) { + return -RIG_EINVAL; + } - /* - * check if they forgot to close the rot - */ - if (rot->state.comm_state) - rot_close(rot); + /* + * check if they forgot to close the rot + */ + if (rot->state.comm_state) { + rot_close(rot); + } - /* - * basically free up the priv struct - */ - if (rot->caps->rot_cleanup) - rot->caps->rot_cleanup(rot); + /* + * basically free up the priv struct + */ + if (rot->caps->rot_cleanup) { + rot->caps->rot_cleanup(rot); + } - free(rot); + free(rot); - return RIG_OK; + return RIG_OK; } + /** * \brief set the azimuth and elevation of the rotator - * \param rot The rot handle - * \param azimuth The azimuth to set to - * \param elevation The elevation to set to + * \param rot The rot handle + * \param azimuth The azimuth to set to + * \param elevation The elevation to set to * * Sets the azimuth and elevation of the rotator. * @@ -484,33 +532,41 @@ int HAMLIB_API rot_cleanup(ROT *rot) * * \sa rot_get_position() */ - -int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevation) +int HAMLIB_API rot_set_position(ROT *rot, azimuth_t azimuth, + elevation_t elevation) { - const struct rot_caps *caps; - const struct rot_state *rs; + const struct rot_caps *caps; + const struct rot_state *rs; - if (CHECK_ROT_ARG(rot)) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; - rs = &rot->state; + if (CHECK_ROT_ARG(rot)) { + return -RIG_EINVAL; + } - if (azimuth < rs->min_az || azimuth > rs->max_az || - elevation < rs->min_el || elevation > rs->max_el) - return -RIG_EINVAL; + caps = rot->caps; + rs = &rot->state; - if (caps->set_position == NULL) - return -RIG_ENAVAIL; + if (azimuth < rs->min_az + || azimuth > rs->max_az + || elevation < rs->min_el + || elevation > rs->max_el) { + return -RIG_EINVAL; + } - return caps->set_position(rot, azimuth, elevation); + if (caps->set_position == NULL) { + return -RIG_ENAVAIL; + } + + return caps->set_position(rot, azimuth, elevation); } + /** * \brief get the azimuth and elevation of the rotator - * \param rot The rot handle - * \param azimuth The location where to store the current azimuth - * \param elevation The location where to store the current elevation + * \param rot The rot handle + * \param azimuth The location where to store the current azimuth + * \param elevation The location where to store the current elevation * * Retrieves the current azimuth and elevation of the rotator. * @@ -520,25 +576,30 @@ int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevat * * \sa rot_set_position() */ - -int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elevation) +int HAMLIB_API rot_get_position(ROT *rot, azimuth_t *azimuth, + elevation_t *elevation) { - const struct rot_caps *caps; + const struct rot_caps *caps; - if (CHECK_ROT_ARG(rot) || !azimuth || !elevation) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; + if (CHECK_ROT_ARG(rot) || !azimuth || !elevation) { + return -RIG_EINVAL; + } - if (caps->get_position == NULL) - return -RIG_ENAVAIL; + caps = rot->caps; - return caps->get_position(rot, azimuth, elevation); + if (caps->get_position == NULL) { + return -RIG_ENAVAIL; + } + + return caps->get_position(rot, azimuth, elevation); } + /** * \brief park the antenna - * \param rot The rot handle + * \param rot The rot handle * * Park the antenna. * @@ -547,25 +608,29 @@ int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elev * set appropriately). * */ - -int HAMLIB_API rot_park (ROT *rot) +int HAMLIB_API rot_park(ROT *rot) { - const struct rot_caps *caps; + const struct rot_caps *caps; - if (CHECK_ROT_ARG(rot)) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; + if (CHECK_ROT_ARG(rot)) { + return -RIG_EINVAL; + } - if (caps->park == NULL) - return -RIG_ENAVAIL; + caps = rot->caps; - return caps->park(rot); + if (caps->park == NULL) { + return -RIG_ENAVAIL; + } + + return caps->park(rot); } + /** * \brief stop the rotator - * \param rot The rot handle + * \param rot The rot handle * * Stop the rotator. * @@ -574,25 +639,29 @@ int HAMLIB_API rot_park (ROT *rot) * set appropriately). * */ - -int HAMLIB_API rot_stop (ROT *rot) +int HAMLIB_API rot_stop(ROT *rot) { - const struct rot_caps *caps; + const struct rot_caps *caps; - if (CHECK_ROT_ARG(rot)) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; + if (CHECK_ROT_ARG(rot)) { + return -RIG_EINVAL; + } - if (caps->stop == NULL) - return -RIG_ENAVAIL; + caps = rot->caps; - return caps->stop(rot); + if (caps->stop == NULL) { + return -RIG_ENAVAIL; + } + + return caps->stop(rot); } + /** * \brief reset the rotator - * \param rot The rot handle + * \param rot The rot handle * \param reset The reset operation to perform * * Resets the rotator. @@ -602,22 +671,26 @@ int HAMLIB_API rot_stop (ROT *rot) * set appropriately). * */ - -int HAMLIB_API rot_reset (ROT *rot, rot_reset_t reset) +int HAMLIB_API rot_reset(ROT *rot, rot_reset_t reset) { - const struct rot_caps *caps; + const struct rot_caps *caps; - if (CHECK_ROT_ARG(rot)) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; + if (CHECK_ROT_ARG(rot)) { + return -RIG_EINVAL; + } - if (caps->reset == NULL) - return -RIG_ENAVAIL; + caps = rot->caps; - return caps->reset(rot, reset); + if (caps->reset == NULL) { + return -RIG_ENAVAIL; + } + + return caps->reset(rot, reset); } + /** * \brief move the rotator in the specified direction * \param rot The rot handle @@ -627,24 +700,29 @@ int HAMLIB_API rot_reset (ROT *rot, rot_reset_t reset) * Move the rotator in the specified direction. The speed is a value * between 1 and 100. */ -int HAMLIB_API rot_move (ROT *rot, int direction, int speed) +int HAMLIB_API rot_move(ROT *rot, int direction, int speed) { - const struct rot_caps *caps; + const struct rot_caps *caps; - if (CHECK_ROT_ARG(rot)) - return -RIG_EINVAL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rot->caps; + if (CHECK_ROT_ARG(rot)) { + return -RIG_EINVAL; + } - if (caps->move == NULL) - return -RIG_ENAVAIL; + caps = rot->caps; - return caps->move(rot, direction, speed); + if (caps->move == NULL) { + return -RIG_ENAVAIL; + } + + return caps->move(rot, direction, speed); } + /** * \brief get general information from the rotator - * \param rot The rot handle + * \param rot The rot handle * * Retrieves some general information from the rotator. * This can include firmware revision, exact model name, or just nothing. @@ -653,15 +731,19 @@ int HAMLIB_API rot_move (ROT *rot, int direction, int speed) * if the operation has been sucessful, otherwise NULL if an error occured * or get_info not part of capabilities. */ -const char* HAMLIB_API rot_get_info(ROT *rot) +const char *HAMLIB_API rot_get_info(ROT *rot) { - if (CHECK_ROT_ARG(rot)) - return NULL; + rot_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rot->caps->get_info == NULL) - return NULL; + if (CHECK_ROT_ARG(rot)) { + return NULL; + } - return rot->caps->get_info(rot); + if (rot->caps->get_info == NULL) { + return NULL; + } + + return rot->caps->get_info(rot); } /*! @} */ diff --git a/src/serial.c b/src/serial.c index 9cfc0cabf..4fdcb2568 100644 --- a/src/serial.c +++ b/src/serial.c @@ -58,7 +58,7 @@ #else #ifdef HAVE_TERMIO_H #include -#else /* sgtty */ +#else /* sgtty */ #ifdef HAVE_SGTTY_H #include #endif @@ -67,7 +67,7 @@ #if defined(WIN32) && !defined(HAVE_TERMIOS_H) #include "win32termios.h" -#define HAVE_TERMIOS_H 1 /* we have replacement */ +#define HAVE_TERMIOS_H 1 /* we have replacement */ #else #define OPEN open #define CLOSE close @@ -82,44 +82,52 @@ #include #endif + /** * \brief Open serial port using rig.state data * \param rp port data structure (must spec port id eg /dev/ttyS1) * \return RIG_OK or < 0 if error */ -int HAMLIB_API serial_open(hamlib_port_t *rp) { +int HAMLIB_API serial_open(hamlib_port_t *rp) +{ - int fd; /* File descriptor for the port */ - int err; + int fd; /* File descriptor for the port */ + int err; - if (!rp) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - /* - * Open in Non-blocking mode. Watch for EAGAIN errors! - */ - fd = OPEN(rp->pathname, O_RDWR | O_NOCTTY | O_NDELAY); + if (!rp) { + return -RIG_EINVAL; + } - if (fd == -1) { + /* + * Open in Non-blocking mode. Watch for EAGAIN errors! + */ + fd = OPEN(rp->pathname, O_RDWR | O_NOCTTY | O_NDELAY); - /* Could not open the port. */ + if (fd == -1) { + /* Could not open the port. */ + rig_debug(RIG_DEBUG_ERR, + "%s: Unable to open %s - %s\n", + __func__, + rp->pathname, + strerror(errno)); + return -RIG_EIO; + } - rig_debug(RIG_DEBUG_ERR, "%s: Unable to open %s - %s\n", - __func__, rp->pathname, strerror(errno)); - return -RIG_EIO; - } + rp->fd = fd; - rp->fd = fd; + err = serial_setup(rp); - err = serial_setup(rp); - if (err != RIG_OK) { - CLOSE(fd); - return err; - } + if (err != RIG_OK) { + CLOSE(fd); + return err; + } - return RIG_OK; + return RIG_OK; } + /** * \brief Set up Serial port according to requests in port * \param rp @@ -127,265 +135,308 @@ int HAMLIB_API serial_open(hamlib_port_t *rp) { */ int HAMLIB_API serial_setup(hamlib_port_t *rp) { - int fd; - /* There's a lib replacement for termios under Mingw */ + int fd; + /* There's a lib replacement for termios under Mingw */ #if defined(HAVE_TERMIOS_H) - speed_t speed; /* serial comm speed */ - struct termios options; + speed_t speed; /* serial comm speed */ + struct termios options; #elif defined(HAVE_TERMIO_H) - struct termio options; + struct termio options; #elif defined(HAVE_SGTTY_H) - struct sgttyb sg; + struct sgttyb sg; #else #error "No term control supported!" #endif - if (!rp) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - fd = rp->fd; + if (!rp) { + return -RIG_EINVAL; + } - /* - * Get the current options for the port... - */ + fd = rp->fd; + /* + * Get the current options for the port... + */ #if defined(HAVE_TERMIOS_H) - tcgetattr(fd, &options); + tcgetattr(fd, &options); #elif defined(HAVE_TERMIO_H) - IOCTL (fd, TCGETA, &options); -#else /* sgtty */ - IOCTL (fd, TIOCGETP, &sg); + IOCTL(fd, TCGETA, &options); +#else /* sgtty */ + IOCTL(fd, TIOCGETP, &sg); #endif #ifdef HAVE_CFMAKERAW - cfmakeraw(&options); /* Set serial port to RAW mode by default. */ + /* Set serial port to RAW mode by default. */ + cfmakeraw(&options); #endif - /* - * Set the baud rates to requested values - */ + /* + * Set the baud rates to requested values + */ + switch (rp->parm.serial.rate) { + case 150: + speed = B150; /* yikes... */ + break; - switch(rp->parm.serial.rate) { - case 150: - speed = B150; /* yikes... */ - break; - case 300: - speed = B300; /* yikes... */ - break; - case 600: + case 300: + speed = B300; /* yikes... */ + break; + + case 600: speed = B600; - break; - case 1200: - speed = B1200; - break; - case 2400: - speed = B2400; - break; - case 4800: - speed = B4800; - break; - case 9600: - speed = B9600; - break; - case 19200: - speed = B19200; - break; - case 38400: - speed = B38400; - break; - case 57600: - speed = B57600; /* cool.. */ - break; - case 115200: - speed = B115200; /* awsome! */ - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported rate specified: %d\n", - __func__, rp->parm.serial.rate); - CLOSE(fd); - return -RIG_ECONF; - } - /* TODO */ - cfsetispeed(&options, speed); - cfsetospeed(&options, speed); + break; - /* - * Enable the receiver and set local mode... - */ + case 1200: + speed = B1200; + break; - options.c_cflag |= (CLOCAL | CREAD); + case 2400: + speed = B2400; + break; - /* - * close doesn't change modem signals - */ - options.c_cflag &= ~HUPCL; + case 4800: + speed = B4800; + break; -/* - * Set data to requested values. - * - */ + case 9600: + speed = B9600; + break; - switch(rp->parm.serial.data_bits) { - case 7: - options.c_cflag &= ~CSIZE; - options.c_cflag |= CS7; - break; - case 8: - options.c_cflag &= ~CSIZE; - options.c_cflag |= CS8; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported serial_data_bits " - "specified: %d\n", __func__, rp->parm.serial.data_bits); - CLOSE(fd); - return -RIG_ECONF; - break; - } + case 19200: + speed = B19200; + break; -/* - * Set stop bits to requested values. - * - */ + case 38400: + speed = B38400; + break; - switch(rp->parm.serial.stop_bits) { - case 1: - options.c_cflag &= ~CSTOPB; - break; - case 2: - options.c_cflag |= CSTOPB; - break; + case 57600: + speed = B57600; /* cool.. */ + break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported serial_stop_bits " - "specified: %d\n", __func__, - rp->parm.serial.stop_bits); - CLOSE(fd); - return -RIG_ECONF; - break; - } + case 115200: + speed = B115200; /* awesome! */ + break; -/* - * Set parity to requested values. - * - */ + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported rate specified: %d\n", + __func__, + rp->parm.serial.rate); + CLOSE(fd); - switch(rp->parm.serial.parity) { - case RIG_PARITY_NONE: - options.c_cflag &= ~PARENB; - break; - case RIG_PARITY_EVEN: - options.c_cflag |= PARENB; - options.c_cflag &= ~PARODD; - break; - case RIG_PARITY_ODD: - options.c_cflag |= PARENB; - options.c_cflag |= PARODD; - break; - /* CMSPAR is not POSIX */ + return -RIG_ECONF; + } + + /* TODO */ + cfsetispeed(&options, speed); + cfsetospeed(&options, speed); + + /* + * Enable the receiver and set local mode... + */ + options.c_cflag |= (CLOCAL | CREAD); + + /* + * close doesn't change modem signals + */ + options.c_cflag &= ~HUPCL; + + /* + * Set data to requested values. + * + */ + switch (rp->parm.serial.data_bits) { + case 7: + options.c_cflag &= ~CSIZE; + options.c_cflag |= CS7; + break; + + case 8: + options.c_cflag &= ~CSIZE; + options.c_cflag |= CS8; + break; + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported serial_data_bits specified: %d\n", + __func__, + rp->parm.serial.data_bits); + CLOSE(fd); + + return -RIG_ECONF; + break; + } + + /* + * Set stop bits to requested values. + * + */ + switch (rp->parm.serial.stop_bits) { + case 1: + options.c_cflag &= ~CSTOPB; + break; + + case 2: + options.c_cflag |= CSTOPB; + break; + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported serial_stop_bits specified: %d\n", + __func__, + rp->parm.serial.stop_bits); + CLOSE(fd); + + return -RIG_ECONF; + break; + } + + /* + * Set parity to requested values. + * + */ + switch (rp->parm.serial.parity) { + case RIG_PARITY_NONE: + options.c_cflag &= ~PARENB; + break; + + case RIG_PARITY_EVEN: + options.c_cflag |= PARENB; + options.c_cflag &= ~PARODD; + break; + + case RIG_PARITY_ODD: + options.c_cflag |= PARENB; + options.c_cflag |= PARODD; + break; + /* CMSPAR is not POSIX */ #ifdef CMSPAR - case RIG_PARITY_MARK: - options.c_cflag |= PARENB | CMSPAR; - options.c_cflag |= PARODD; - break; - case RIG_PARITY_SPACE: - options.c_cflag |= PARENB | CMSPAR; - options.c_cflag &= ~PARODD; - break; + + case RIG_PARITY_MARK: + options.c_cflag |= PARENB | CMSPAR; + options.c_cflag |= PARODD; + break; + + case RIG_PARITY_SPACE: + options.c_cflag |= PARENB | CMSPAR; + options.c_cflag &= ~PARODD; + break; #endif - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported serial_parity " - "specified: %d\n", __func__, - rp->parm.serial.parity); - CLOSE(fd); - return -RIG_ECONF; - break; - } + + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported serial_parity specified: %d\n", + __func__, + rp->parm.serial.parity); + CLOSE(fd); + + return -RIG_ECONF; + break; + } -/* - * Set flow control to requested mode - * - */ + /* + * Set flow control to requested mode + * + */ + switch (rp->parm.serial.handshake) { + case RIG_HANDSHAKE_NONE: + options.c_cflag &= ~CRTSCTS; + options.c_iflag &= ~IXON; + break; - switch(rp->parm.serial.handshake) { - case RIG_HANDSHAKE_NONE: - options.c_cflag &= ~CRTSCTS; - options.c_iflag &= ~IXON; - break; - case RIG_HANDSHAKE_XONXOFF: - options.c_cflag &= ~CRTSCTS; - options.c_iflag |= IXON; /* Enable Xon/Xoff software handshaking */ - break; - case RIG_HANDSHAKE_HARDWARE: - options.c_cflag |= CRTSCTS; /* Enable Hardware handshaking */ - options.c_iflag &= ~IXON; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported flow_control " - "specified: %d\n", __func__, - rp->parm.serial.handshake); - CLOSE(fd); - return -RIG_ECONF; - break; - } + case RIG_HANDSHAKE_XONXOFF: + options.c_cflag &= ~CRTSCTS; + options.c_iflag |= IXON; /* Enable Xon/Xoff software handshaking */ + break; - /* - * Choose raw input, no preprocessing please .. - */ + case RIG_HANDSHAKE_HARDWARE: + options.c_cflag |= CRTSCTS; /* Enable Hardware handshaking */ + options.c_iflag &= ~IXON; + break; + default: + rig_debug(RIG_DEBUG_ERR, + "%s: unsupported flow_control specified: %d\n", + __func__, + rp->parm.serial.handshake); + CLOSE(fd); + + return -RIG_ECONF; + break; + } + + /* + * Choose raw input, no preprocessing please .. + */ #if defined(HAVE_TERMIOS_H) || defined(HAVE_TERMIO_H) - options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); - /* - * Choose raw output, no preprocessing please .. - */ + /* + * Choose raw output, no preprocessing please .. + */ + options.c_oflag &= ~OPOST; - options.c_oflag &= ~OPOST; - -#else /* sgtty */ - sg.sg_flags = RAW; +#else /* sgtty */ + sg.sg_flags = RAW; #endif - /* - * VTIME in deciseconds, rp->timeout in miliseconds - */ - options.c_cc[VTIME] = (rp->timeout + 99) / 100; - options.c_cc[VMIN] = 1; + /* + * VTIME in deciseconds, rp->timeout in miliseconds + */ + options.c_cc[VTIME] = (rp->timeout + 99) / 100; + options.c_cc[VMIN] = 1; - /* - * Flush serial port - */ - - tcflush(fd, TCIFLUSH); - - /* - * Finally, set the new options for the port... - */ + /* + * Flush serial port + */ + tcflush(fd, TCIFLUSH); + /* + * Finally, set the new options for the port... + */ #if defined(HAVE_TERMIOS_H) - if (tcsetattr(fd, TCSANOW, &options) == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: tcsetattr failed: %s\n", - __func__, strerror(errno)); - CLOSE(fd); - return -RIG_ECONF; /* arg, so close! */ - } + + if (tcsetattr(fd, TCSANOW, &options) == -1) { + rig_debug(RIG_DEBUG_ERR, + "%s: tcsetattr failed: %s\n", + __func__, + strerror(errno)); + CLOSE(fd); + + return -RIG_ECONF; /* arg, so close! */ + } + #elif defined(HAVE_TERMIO_H) - if (IOCTL(fd, TCSETA, &options) == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: ioctl(TCSETA) failed: %s\n", - __func__, strerror(errno)); - CLOSE(fd); - return -RIG_ECONF; /* arg, so close! */ - } -#else /* sgtty */ - if (IOCTL(fd, TIOCSETP, &sg) == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: ioctl(TIOCSETP) failed: %s\n", - __func__, strerror(errno)); - CLOSE(fd); - return -RIG_ECONF; /* arg, so close! */ - } + + if (IOCTL(fd, TCSETA, &options) == -1) { + rig_debug(RIG_DEBUG_ERR, + "%s: ioctl(TCSETA) failed: %s\n", + __func__, + strerror(errno)); + CLOSE(fd); + + return -RIG_ECONF; /* arg, so close! */ + } + +#else + /* sgtty */ + if (IOCTL(fd, TIOCSETP, &sg) == -1) { + rig_debug(RIG_DEBUG_ERR, + "%s: ioctl(TIOCSETP) failed: %s\n", + __func__, + strerror(errno)); + CLOSE(fd); + + return -RIG_ECONF; /* arg, so close! */ + } + #endif - return RIG_OK; + return RIG_OK; } @@ -394,13 +445,16 @@ int HAMLIB_API serial_setup(hamlib_port_t *rp) * \param p * \return RIG_OK */ -int HAMLIB_API serial_flush(hamlib_port_t *p ) +int HAMLIB_API serial_flush(hamlib_port_t *p) { - tcflush(p->fd, TCIFLUSH); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return RIG_OK; + tcflush(p->fd, TCIFLUSH); + + return RIG_OK; } + /** * \brief Open serial port * \param p @@ -408,9 +462,12 @@ int HAMLIB_API serial_flush(hamlib_port_t *p ) */ int ser_open(hamlib_port_t *p) { - return (p->fd = OPEN(p->pathname, O_RDWR | O_NOCTTY | O_NDELAY)); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + return (p->fd = OPEN(p->pathname, O_RDWR | O_NOCTTY | O_NDELAY)); } + /** * \brief Close serial port * \param p fd @@ -418,11 +475,14 @@ int ser_open(hamlib_port_t *p) */ int ser_close(hamlib_port_t *p) { - int rc = CLOSE(p->fd); - p->fd = -1; - return rc; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + int rc = CLOSE(p->fd); + p->fd = -1; + return rc; } + /** * \brief Set Request to Send (RTS) bit * \param p @@ -431,32 +491,42 @@ int ser_close(hamlib_port_t *p) */ int HAMLIB_API ser_set_rts(hamlib_port_t *p, int state) { - unsigned int y = TIOCM_RTS; - int rc; + unsigned int y = TIOCM_RTS; + int rc; - rig_debug(RIG_DEBUG_VERBOSE, "%s: RTS=%d\n", __func__, state); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + rig_debug(RIG_DEBUG_VERBOSE, "%s: RTS=%d\n", __func__, state); #if defined(TIOCMBIS) && defined(TIOCMBIC) - rc = IOCTL(p->fd, state ? TIOCMBIS : TIOCMBIC, &y); + rc = IOCTL(p->fd, state ? TIOCMBIS : TIOCMBIC, &y); #else - rc = IOCTL(p->fd, TIOCMGET, &y); - if (rc >= 0) - { - if (state) - y |= TIOCM_RTS; - else - y &= ~TIOCM_RTS; - rc = IOCTL(p->fd, TIOCMSET, &y); + rc = IOCTL(p->fd, TIOCMGET, &y); + + if (rc >= 0) { + if (state) { + y |= TIOCM_RTS; + } else { + y &= ~TIOCM_RTS; + } + + rc = IOCTL(p->fd, TIOCMSET, &y); } + #endif - if (rc < 0) - { - rig_debug(RIG_DEBUG_ERR, "%s: Cannot change RTS - %s\n", __func__, strerror(errno)); - return -RIG_EIO; + + if (rc < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: Cannot change RTS - %s\n", + __func__, + strerror(errno)); + return -RIG_EIO; } - return RIG_OK; + + return RIG_OK; } + /** * \brief Get RTS bit * \param p supposed to be &rig->state.rigport @@ -464,15 +534,18 @@ int HAMLIB_API ser_set_rts(hamlib_port_t *p, int state) */ int HAMLIB_API ser_get_rts(hamlib_port_t *p, int *state) { - int retcode; - unsigned int y; + int retcode; + unsigned int y; - retcode = IOCTL(p->fd, TIOCMGET, &y); - *state = (y & TIOCM_RTS) == TIOCM_RTS; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return retcode < 0 ? -RIG_EIO : RIG_OK; + retcode = IOCTL(p->fd, TIOCMGET, &y); + *state = (y & TIOCM_RTS) == TIOCM_RTS; + + return retcode < 0 ? -RIG_EIO : RIG_OK; } + /** * \brief Set Data Terminal Ready (DTR) bit * \param p @@ -481,32 +554,42 @@ int HAMLIB_API ser_get_rts(hamlib_port_t *p, int *state) */ int HAMLIB_API ser_set_dtr(hamlib_port_t *p, int state) { - unsigned int y = TIOCM_DTR; - int rc; + unsigned int y = TIOCM_DTR; + int rc; - rig_debug(RIG_DEBUG_VERBOSE, "%s: DTR=%d\n", __func__, state); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + rig_debug(RIG_DEBUG_VERBOSE, "%s: DTR=%d\n", __func__, state); #if defined(TIOCMBIS) && defined(TIOCMBIC) - rc = IOCTL(p->fd, state ? TIOCMBIS : TIOCMBIC, &y); + rc = IOCTL(p->fd, state ? TIOCMBIS : TIOCMBIC, &y); #else - rc = IOCTL(p->fd, TIOCMGET, &y); - if (rc >= 0) - { - if (state) - y |= TIOCM_DTR; - else - y &= ~TIOCM_DTR; - rc = IOCTL(p->fd, TIOCMSET, &y); + rc = IOCTL(p->fd, TIOCMGET, &y); + + if (rc >= 0) { + if (state) { + y |= TIOCM_DTR; + } else { + y &= ~TIOCM_DTR; + } + + rc = IOCTL(p->fd, TIOCMSET, &y); } + #endif - if (rc < 0) - { - rig_debug(RIG_DEBUG_ERR, "%s: Cannot change DTR - %s\n", __func__, strerror(errno)); - return -RIG_EIO; + + if (rc < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: Cannot change DTR - %s\n", + __func__, + strerror(errno)); + return -RIG_EIO; } - return RIG_OK; + + return RIG_OK; } + /** * \brief Get DTR bit * \param p supposed to be &rig->state.rigport @@ -514,15 +597,18 @@ int HAMLIB_API ser_set_dtr(hamlib_port_t *p, int state) */ int HAMLIB_API ser_get_dtr(hamlib_port_t *p, int *state) { - int retcode; - unsigned int y; + int retcode; + unsigned int y; - retcode = IOCTL(p->fd, TIOCMGET, &y); - *state = (y & TIOCM_DTR) == TIOCM_DTR; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return retcode < 0 ? -RIG_EIO : RIG_OK; + retcode = IOCTL(p->fd, TIOCMGET, &y); + *state = (y & TIOCM_DTR) == TIOCM_DTR; + + return retcode < 0 ? -RIG_EIO : RIG_OK; } + /** * \brief Set Break * \param p @@ -531,14 +617,17 @@ int HAMLIB_API ser_get_dtr(hamlib_port_t *p, int *state) */ int HAMLIB_API ser_set_brk(hamlib_port_t *p, int state) { + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + #if defined(TIOCSBRK) && defined(TIOCCBRK) - return IOCTL(p->fd, state ? TIOCSBRK : TIOCCBRK, 0 ) < 0 ? - -RIG_EIO : RIG_OK; + return IOCTL(p->fd, state ? TIOCSBRK : TIOCCBRK, 0) < 0 ? + -RIG_EIO : RIG_OK; #else - return -RIG_ENIMPL; + return -RIG_ENIMPL; #endif } + /** * \brief Get Carrier (CI?) bit * \param p supposed to be &rig->state.rigport @@ -546,15 +635,18 @@ int HAMLIB_API ser_set_brk(hamlib_port_t *p, int state) */ int HAMLIB_API ser_get_car(hamlib_port_t *p, int *state) { - int retcode; - unsigned int y; + int retcode; + unsigned int y; - retcode = IOCTL(p->fd, TIOCMGET, &y); - *state = (y & TIOCM_CAR) == TIOCM_CAR; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return retcode < 0 ? -RIG_EIO : RIG_OK; + retcode = IOCTL(p->fd, TIOCMGET, &y); + *state = (y & TIOCM_CAR) == TIOCM_CAR; + + return retcode < 0 ? -RIG_EIO : RIG_OK; } + /** * \brief Get Clear to Send (CTS) bit * \param p supposed to be &rig->state.rigport @@ -562,15 +654,18 @@ int HAMLIB_API ser_get_car(hamlib_port_t *p, int *state) */ int HAMLIB_API ser_get_cts(hamlib_port_t *p, int *state) { - int retcode; - unsigned int y; + int retcode; + unsigned int y; - retcode = IOCTL(p->fd, TIOCMGET, &y); - *state = (y & TIOCM_CTS) == TIOCM_CTS; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return retcode < 0 ? -RIG_EIO : RIG_OK; + retcode = IOCTL(p->fd, TIOCMGET, &y); + *state = (y & TIOCM_CTS) == TIOCM_CTS; + + return retcode < 0 ? -RIG_EIO : RIG_OK; } + /** * \brief Get Data Set Ready (DSR) bit * \param p supposed to be &rig->state.rigport @@ -578,13 +673,15 @@ int HAMLIB_API ser_get_cts(hamlib_port_t *p, int *state) */ int HAMLIB_API ser_get_dsr(hamlib_port_t *p, int *state) { - int retcode; - unsigned int y; + int retcode; + unsigned int y; - retcode = IOCTL(p->fd, TIOCMGET, &y); - *state = (y & TIOCM_DSR) == TIOCM_DSR; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return retcode < 0 ? -RIG_EIO : RIG_OK; + retcode = IOCTL(p->fd, TIOCMGET, &y); + *state = (y & TIOCM_DSR) == TIOCM_DSR; + + return retcode < 0 ? -RIG_EIO : RIG_OK; } /** @} */ diff --git a/src/settings.c b/src/settings.c index 9426b12f1..16461a13f 100644 --- a/src/settings.c +++ b/src/settings.c @@ -45,7 +45,7 @@ #include #include -#include "hamlib/rig.h" +#include #include "cal.h" @@ -58,10 +58,10 @@ /** * \brief set a radio level setting - * \param rig The rig handle - * \param vfo The target VFO - * \param level The level setting - * \param val The value to set the level setting to + * \param rig The rig handle + * \param vfo The target VFO + * \param level The level setting + * \param val The value to set the level setting to * * Sets the level of a setting. * The level value \a val can be a float or an integer. See #value_t @@ -75,51 +75,62 @@ */ int HAMLIB_API rig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_level == NULL || !rig_has_set_level(rig,level)) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_level(rig, vfo, level, val); + if (caps->set_level == NULL || !rig_has_set_level(rig, level)) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { + return caps->set_level(rig, vfo, level, val); + } - retcode = caps->set_level(rig, vfo, level, val); - caps->set_vfo(rig, curr_vfo); - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_level(rig, vfo, level, val); + caps->set_vfo(rig, curr_vfo); + return retcode; } + /** * \brief get the value of a level - * \param rig The rig handle - * \param vfo The target VFO - * \param level The level setting - * \param val The location where to store the value of \a level + * \param rig The rig handle + * \param vfo The target VFO + * \param level The level setting + * \param val The location where to store the value of \a level * * Retrieves the value of a \a level. * The level value \a val can be a float or an integer. See #value_t * for more information. * - * RIG_LEVEL_STRENGTH: \a val is an integer, representing the S Meter - * level in dB relative to S9, according to the ideal S Meter scale. - * The ideal S Meter scale is as follow: S0=-54, S1=-48, S2=-42, S3=-36, - * S4=-30, S5=-24, S6=-18, S7=-12, S8=-6, S9=0, +10=10, +20=20, - * +30=30, +40=40, +50=50 and +60=60. This is the responsability - * of the backend to return values calibrated for this scale. + * RIG_LEVEL_STRENGTH: \a val is an integer, representing the S Meter + * level in dB relative to S9, according to the ideal S Meter scale. + * The ideal S Meter scale is as follow: S0=-54, S1=-48, S2=-42, S3=-36, + * S4=-30, S5=-24, S6=-18, S7=-12, S8=-6, S9=0, +10=10, +20=20, + * +30=30, +40=40, +50=50 and +60=60. This is the responsability + * of the backend to return values calibrated for this scale. * * \return RIG_OK if the operation has been sucessful, otherwise * a negative value if an error occured (in which case, cause is @@ -129,57 +140,72 @@ int HAMLIB_API rig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) */ int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !val) { + return -RIG_EINVAL; + } - if (caps->get_level == NULL || !rig_has_get_level(rig,level)) - return -RIG_ENAVAIL; + caps = rig->caps; - /* - * Special case(frontend emulation): calibrated S-meter reading - */ - if (level == RIG_LEVEL_STRENGTH && - (caps->has_get_level & RIG_LEVEL_STRENGTH) == 0 && - rig_has_get_level(rig,RIG_LEVEL_RAWSTR) && - rig->state.str_cal.size) { + if (caps->get_level == NULL || !rig_has_get_level(rig, level)) { + return -RIG_ENAVAIL; + } - value_t rawstr; + /* + * Special case(frontend emulation): calibrated S-meter reading + */ + if (level == RIG_LEVEL_STRENGTH + && (caps->has_get_level & RIG_LEVEL_STRENGTH) == 0 + && rig_has_get_level(rig, RIG_LEVEL_RAWSTR) + && rig->state.str_cal.size) { - retcode = rig_get_level(rig, vfo, RIG_LEVEL_RAWSTR, &rawstr); - if (retcode != RIG_OK) - return retcode; - val->i = (int)rig_raw2val(rawstr.i, &rig->state.str_cal); - return RIG_OK; - } + value_t rawstr; + + retcode = rig_get_level(rig, vfo, RIG_LEVEL_RAWSTR, &rawstr); + + if (retcode != RIG_OK) { + return retcode; + } + + val->i = (int)rig_raw2val(rawstr.i, &rig->state.str_cal); + return RIG_OK; + } - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_level(rig, vfo, level, val); + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + return caps->get_level(rig, vfo, level, val); + } - retcode = caps->get_level(rig, vfo, level, val); - caps->set_vfo(rig, curr_vfo); - return retcode; + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_level(rig, vfo, level, val); + caps->set_vfo(rig, curr_vfo); + return retcode; } + /** * \brief set a radio parameter - * \param rig The rig handle - * \param parm The parameter - * \param val The value to set the parameter + * \param rig The rig handle + * \param parm The parameter + * \param val The value to set the parameter * * Sets a parameter. * The parameter value \a val can be a float or an integer. See #value_t @@ -193,20 +219,25 @@ int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) */ int HAMLIB_API rig_set_parm(RIG *rig, setting_t parm, value_t val) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->set_parm == NULL || !rig_has_set_parm(rig,parm)) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return rig->caps->set_parm(rig, parm, val); + if (rig->caps->set_parm == NULL || !rig_has_set_parm(rig, parm)) { + return -RIG_ENAVAIL; + } + + return rig->caps->set_parm(rig, parm, val); } + /** * \brief get the value of a parameter - * \param rig The rig handle - * \param parm The parameter - * \param val The location where to store the value of \a parm + * \param rig The rig handle + * \param parm The parameter + * \param val The location where to store the value of \a parm * * Retrieves the value of a \a parm. * The parameter value \a val can be a float or an integer. See #value_t @@ -220,25 +251,30 @@ int HAMLIB_API rig_set_parm(RIG *rig, setting_t parm, value_t val) */ int HAMLIB_API rig_get_parm(RIG *rig, setting_t parm, value_t *val) { - if (CHECK_RIG_ARG(rig) || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->get_parm == NULL || !rig_has_get_parm(rig,parm)) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig) || !val) { + return -RIG_EINVAL; + } - return rig->caps->get_parm(rig, parm, val); + if (rig->caps->get_parm == NULL || !rig_has_get_parm(rig, parm)) { + return -RIG_ENAVAIL; + } + + return rig->caps->get_parm(rig, parm, val); } + /** * \brief check retrieval ability of level settings - * \param rig The rig handle - * \param level The level settings + * \param rig The rig handle + * \param level The level settings * * Checks if a rig is capable of *getting* a level setting. * Since the \a level is an OR'ed bitwise argument, more than * one level can be checked at the same time. * - * EXAMPLE: if (rig_has_get_level(my_rig, RIG_LVL_STRENGTH)) disp_Smeter(); + * EXAMPLE: if (rig_has_get_level(my_rig, RIG_LVL_STRENGTH)) disp_Smeter(); * * \return a bit map of supported level settings that can be retrieved, * otherwise 0 if none supported. @@ -247,23 +283,26 @@ int HAMLIB_API rig_get_parm(RIG *rig, setting_t parm, value_t *val) */ setting_t HAMLIB_API rig_has_get_level(RIG *rig, setting_t level) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_get_level & level); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_get_level & level); } /** * \brief check settable ability of level settings - * \param rig The rig handle - * \param level The level settings + * \param rig The rig handle + * \param level The level settings * * Checks if a rig can *set* a level setting. * Since the \a level is an OR'ed bitwise argument, more than * one level can be check at the same time. * - * EXAMPLE: if (rig_has_set_level(my_rig, RIG_LVL_RFPOWER)) crank_tx(); + * EXAMPLE: if (rig_has_set_level(my_rig, RIG_LVL_RFPOWER)) crank_tx(); * * \return a bit map of supported level settings that can be set, * otherwise 0 if none supported. @@ -272,22 +311,26 @@ setting_t HAMLIB_API rig_has_get_level(RIG *rig, setting_t level) */ setting_t HAMLIB_API rig_has_set_level(RIG *rig, setting_t level) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_set_level & level); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_set_level & level); } + /** * \brief check retrieval ability of parameter settings - * \param rig The rig handle - * \param parm The parameter settings + * \param rig The rig handle + * \param parm The parameter settings * * Checks if a rig is capable of *getting* a parm setting. * Since the \a parm is an OR'ed bitwise argument, more than * one parameter can be checked at the same time. * - * EXAMPLE: if (rig_has_get_parm(my_rig, RIG_PARM_ANN)) good4you(); + * EXAMPLE: if (rig_has_get_parm(my_rig, RIG_PARM_ANN)) good4you(); * * \return a bit map of supported parameter settings that can be retrieved, * otherwise 0 if none supported. @@ -296,23 +339,26 @@ setting_t HAMLIB_API rig_has_set_level(RIG *rig, setting_t level) */ setting_t HAMLIB_API rig_has_get_parm(RIG *rig, setting_t parm) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_get_parm & parm); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_get_parm & parm); } /** * \brief check settable ability of parameter settings - * \param rig The rig handle - * \param parm The parameter settings + * \param rig The rig handle + * \param parm The parameter settings * * Checks if a rig can *set* a parameter setting. * Since the \a parm is an OR'ed bitwise argument, more than * one parameter can be check at the same time. * - * EXAMPLE: if (rig_has_set_parm(my_rig, RIG_PARM_ANN)) announce_all(); + * EXAMPLE: if (rig_has_set_parm(my_rig, RIG_PARM_ANN)) announce_all(); * * \return a bit map of supported parameter settings that can be set, * otherwise 0 if none supported. @@ -321,22 +367,26 @@ setting_t HAMLIB_API rig_has_get_parm(RIG *rig, setting_t parm) */ setting_t HAMLIB_API rig_has_set_parm(RIG *rig, setting_t parm) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_set_parm & parm); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_set_parm & parm); } + /** * \brief check ability of radio functions - * \param rig The rig handle - * \param func The functions + * \param rig The rig handle + * \param func The functions * * Checks if a rig supports a set of functions. * Since the \a func is an OR'ed bitwise argument, more than * one function can be checked at the same time. * - * EXAMPLE: if (rig_has_get_func(my_rig,RIG_FUNC_FAGC)) disp_fagc_button(); + * EXAMPLE: if (rig_has_get_func(my_rig,RIG_FUNC_FAGC)) disp_fagc_button(); * * \return a bit map of supported functions, * otherwise 0 if none supported. @@ -345,22 +395,26 @@ setting_t HAMLIB_API rig_has_set_parm(RIG *rig, setting_t parm) */ setting_t HAMLIB_API rig_has_get_func(RIG *rig, setting_t func) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_get_func & func); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_get_func & func); } + /** * \brief check ability of radio functions - * \param rig The rig handle - * \param func The functions + * \param rig The rig handle + * \param func The functions * * Checks if a rig supports a set of functions. * Since the \a func is an OR'ed bitwise argument, more than * one function can be checked at the same time. * - * EXAMPLE: if (rig_has_set_func(my_rig,RIG_FUNC_FAGC)) disp_fagc_button(); + * EXAMPLE: if (rig_has_set_func(my_rig,RIG_FUNC_FAGC)) disp_fagc_button(); * * \return a bit map of supported functions, * otherwise 0 if none supported. @@ -369,18 +423,22 @@ setting_t HAMLIB_API rig_has_get_func(RIG *rig, setting_t func) */ setting_t HAMLIB_API rig_has_set_func(RIG *rig, setting_t func) { - if (!rig || !rig->caps) - return 0; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return (rig->state.has_set_func & func); + if (!rig || !rig->caps) { + return 0; + } + + return (rig->state.has_set_func & func); } + /** * \brief activate/de-activate functions of radio - * \param rig The rig handle - * \param vfo The target VFO - * \param func The functions to activate - * \param status The status (on or off) to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param func The functions to activate + * \param status The status (on or off) to set to * * Activate/de-activate a function of the radio. * @@ -393,43 +451,54 @@ setting_t HAMLIB_API rig_has_set_func(RIG *rig, setting_t func) * * \sa rig_get_func() */ - int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_func == NULL || !rig_has_set_func(rig,func)) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_FUNC) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_func(rig, vfo, func, status); + if (caps->set_func == NULL || !rig_has_set_func(rig, func)) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_func(rig, vfo, func, status); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_func(rig, vfo, func, status); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_func(rig, vfo, func, status); + caps->set_vfo(rig, curr_vfo); + return retcode; } + /** * \brief get the status of functions of the radio - * \param rig The rig handle - * \param vfo The target VFO - * \param func The functions to get the status - * \param status The location where to store the function status + * \param rig The rig handle + * \param vfo The target VFO + * \param func The functions to get the status + * \param status The location where to store the function status * * Retrieves the status (on/off) of a function of the radio. * Upon return, \a status will hold the status of the function, @@ -445,40 +514,53 @@ int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) */ int HAMLIB_API rig_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !func) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !func) { + return -RIG_EINVAL; + } - if (caps->get_func == NULL || !rig_has_get_func(rig,func)) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_FUNC) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_func(rig, vfo, func, status); + if (caps->get_func == NULL || !rig_has_get_func(rig, func)) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_func(rig, vfo, func, status); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_func(rig, vfo, func, status); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_func(rig, vfo, func, status); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief set a radio level extra parameter - * \param rig The rig handle - * \param vfo The target VFO - * \param token The parameter - * \param val The value to set the parameter to + * \param rig The rig handle + * \param vfo The target VFO + * \param token The parameter + * \param val The value to set the parameter to * * Sets an level extra parameter. * @@ -488,42 +570,56 @@ int HAMLIB_API rig_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) * * \sa rig_get_ext_level() */ -int HAMLIB_API rig_set_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t val) +int HAMLIB_API rig_set_ext_level(RIG *rig, vfo_t vfo, token_t token, + value_t val) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_ext_level == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ext_level(rig, vfo, token, val); + if (caps->set_ext_level == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_ext_level(rig, vfo, token, val); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_ext_level(rig, vfo, token, val); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_ext_level(rig, vfo, token, val); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the value of a level extra parameter - * \param rig The rig handle - * \param vfo The target VFO - * \param token The parameter - * \param val The location where to store the value of \a token + * \param rig The rig handle + * \param vfo The target VFO + * \param token The parameter + * \param val The location where to store the value of \a token * * Retrieves the value of a level extra parameter associated with \a token. * @@ -533,41 +629,55 @@ int HAMLIB_API rig_set_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t val * * \sa rig_set_ext_level() */ -int HAMLIB_API rig_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *val) +int HAMLIB_API rig_get_ext_level(RIG *rig, vfo_t vfo, token_t token, + value_t *val) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !val) { + return -RIG_EINVAL; + } - if (caps->get_ext_level == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_PURE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ext_level(rig, vfo, token, val); + if (caps->get_ext_level == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_PURE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_ext_level(rig, vfo, token, val); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_ext_level(rig, vfo, token, val); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_ext_level(rig, vfo, token, val); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief set a radio parm extra parameter - * \param rig The rig handle - * \param token The parameter - * \param val The value to set the parameter to + * \param rig The rig handle + * \param token The parameter + * \param val The value to set the parameter to * * Sets an parm extra parameter. * @@ -579,20 +689,25 @@ int HAMLIB_API rig_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va */ int HAMLIB_API rig_set_ext_parm(RIG *rig, token_t token, value_t val) { - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->set_ext_parm == NULL) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - return rig->caps->set_ext_parm(rig, token, val); + if (rig->caps->set_ext_parm == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->set_ext_parm(rig, token, val); } + /** * \brief get the value of a parm extra parameter - * \param rig The rig handle - * \param token The parameter - * \param val The location where to store the value of \a token + * \param rig The rig handle + * \param token The parameter + * \param val The location where to store the value of \a token * * Retrieves the value of a parm extra parameter associated with \a token. * @@ -604,19 +719,23 @@ int HAMLIB_API rig_set_ext_parm(RIG *rig, token_t token, value_t val) */ int HAMLIB_API rig_get_ext_parm(RIG *rig, token_t token, value_t *val) { - if (CHECK_RIG_ARG(rig) || !val) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (rig->caps->get_ext_parm == NULL) - return -RIG_ENAVAIL; + if (CHECK_RIG_ARG(rig) || !val) { + return -RIG_EINVAL; + } - return rig->caps->get_ext_parm(rig, token, val); + if (rig->caps->get_ext_parm == NULL) { + return -RIG_ENAVAIL; + } + + return rig->caps->get_ext_parm(rig, token, val); } /** * \brief basically convert setting_t expressed 2^n to n - * \param s The setting to convert to + * \param s The setting to convert to * * Converts a setting_t value expressed by 2^n to the value of n. * @@ -625,14 +744,17 @@ int HAMLIB_API rig_get_ext_parm(RIG *rig, token_t token, value_t *val) */ int HAMLIB_API rig_setting2idx(setting_t s) { - int i; + int i; - for (i = 0; i -#include "hamlib/rig.h" +#include #include "tones.h" #if !defined(_WIN32) && !defined(__CYGWIN__) @@ -77,9 +77,9 @@ const tone_t full_dcs_list[] = { FULL_DCS_LIST }; /** * \brief set CTCSS sub-tone frequency - * \param rig The rig handle - * \param vfo The target VFO - * \param tone The tone to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param tone The tone to set to * * Sets the current Continuous Tone Controlled Squelch System (CTCSS) * sub-audible tone frequency. @@ -97,42 +97,54 @@ const tone_t full_dcs_list[] = { FULL_DCS_LIST }; * * \sa rig_get_ctcss_tone(), rig_set_ctcss_sql() */ - int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_ctcss_tone == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ctcss_tone(rig, vfo, tone); + if (caps->set_ctcss_tone == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_ctcss_tone(rig, vfo, tone); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_ctcss_tone(rig, vfo, tone); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_ctcss_tone(rig, vfo, tone); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the current CTCSS sub-tone frequency - * \param rig The rig handle - * \param vfo The target VFO - * \param tone The location where to store the current tone + * \param rig The rig handle + * \param vfo The target VFO + * \param tone The location where to store the current tone * * Retrieves the current Continuous Tone Controlled Squelch System (CTCSS) * sub-audible tone frequency. @@ -149,39 +161,52 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) */ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !tone) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !tone) { + return -RIG_EINVAL; + } - if (caps->get_ctcss_tone == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ctcss_tone(rig, vfo, tone); + if (caps->get_ctcss_tone == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_ctcss_tone(rig, vfo, tone); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_ctcss_tone(rig, vfo, tone); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_ctcss_tone(rig, vfo, tone); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief set the current encoding DCS code - * \param rig The rig handle - * \param vfo The target VFO - * \param code The tone to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param code The tone to set to * * Sets the current encoding Digitally-Coded Squelch code. * @@ -194,39 +219,52 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_dcs_code == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_dcs_code(rig, vfo, code); + if (caps->set_dcs_code == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_dcs_code(rig, vfo, code); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_dcs_code(rig, vfo, code); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_dcs_code(rig, vfo, code); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the current encoding DCS code - * \param rig The rig handle - * \param vfo The target VFO - * \param code The location where to store the current tone + * \param rig The rig handle + * \param vfo The target VFO + * \param code The location where to store the current tone * * Retrieves the current encoding Digitally-Coded Squelch code. * @@ -238,39 +276,52 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) */ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !code) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !code) { + return -RIG_EINVAL; + } - if (caps->get_dcs_code == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_dcs_code(rig, vfo, code); + if (caps->get_dcs_code == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_dcs_code(rig, vfo, code); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_dcs_code(rig, vfo, code); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_dcs_code(rig, vfo, code); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief set CTCSS squelch - * \param rig The rig handle - * \param vfo The target VFO - * \param tone The PL tone to set the squelch to + * \param rig The rig handle + * \param vfo The target VFO + * \param tone The PL tone to set the squelch to * * Sets the current Continuous Tone Controlled Squelch System (CTCSS) * sub-audible *squelch* tone. @@ -288,42 +339,54 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) * * \sa rig_get_ctcss_sql(), rig_set_ctcss_tone() */ - int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_ctcss_sql == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_ctcss_sql(rig, vfo, tone); + if (caps->set_ctcss_sql == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_ctcss_sql(rig, vfo, tone); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_ctcss_sql(rig, vfo, tone); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_ctcss_sql(rig, vfo, tone); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the current CTCSS squelch - * \param rig The rig handle - * \param vfo The target VFO - * \param tone The location where to store the current tone + * \param rig The rig handle + * \param vfo The target VFO + * \param tone The location where to store the current tone * * Retrieves the current Continuous Tone Controlled Squelch System (CTCSS) * sub-audible *squelch* tone. @@ -340,39 +403,52 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) */ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !tone) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !tone) { + return -RIG_EINVAL; + } - if (caps->get_ctcss_sql == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_ctcss_sql(rig, vfo, tone); + if (caps->get_ctcss_sql == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_ctcss_sql(rig, vfo, tone); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_ctcss_sql(rig, vfo, tone); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_ctcss_sql(rig, vfo, tone); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief set the current DCS code - * \param rig The rig handle - * \param vfo The target VFO - * \param code The tone to set to + * \param rig The rig handle + * \param vfo The target VFO + * \param code The tone to set to * * Sets the current Digitally-Coded *Squelch* code. * @@ -382,42 +458,54 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) * * \sa rig_get_dcs_sql(), rig_set_dcs_code() */ - int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig)) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig)) { + return -RIG_EINVAL; + } - if (caps->set_dcs_sql == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->set_dcs_sql(rig, vfo, code); + if (caps->set_dcs_sql == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->set_dcs_sql(rig, vfo, code); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->set_dcs_sql(rig, vfo, code); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->set_dcs_sql(rig, vfo, code); + caps->set_vfo(rig, curr_vfo); + + return retcode; } + /** * \brief get the current DCS code - * \param rig The rig handle - * \param vfo The target VFO - * \param code The location where to store the current tone + * \param rig The rig handle + * \param vfo The target VFO + * \param code The location where to store the current tone * * Retrieves the current Digitally-Coded *Squelch* code. * @@ -429,32 +517,44 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) */ int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code) { - const struct rig_caps *caps; - int retcode; - vfo_t curr_vfo; + const struct rig_caps *caps; + int retcode; + vfo_t curr_vfo; - if (CHECK_RIG_ARG(rig) || !code) - return -RIG_EINVAL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - caps = rig->caps; + if (CHECK_RIG_ARG(rig) || !code) { + return -RIG_EINVAL; + } - if (caps->get_dcs_sql == NULL) - return -RIG_ENAVAIL; + caps = rig->caps; - if ((caps->targetable_vfo&RIG_TARGETABLE_TONE) || - vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) - return caps->get_dcs_sql(rig, vfo, code); + if (caps->get_dcs_sql == NULL) { + return -RIG_ENAVAIL; + } - if (!caps->set_vfo) - return -RIG_ENTARGET; - curr_vfo = rig->state.current_vfo; - retcode = caps->set_vfo(rig, vfo); - if (retcode != RIG_OK) - return retcode; + if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) + || vfo == RIG_VFO_CURR + || vfo == rig->state.current_vfo) { - retcode = caps->get_dcs_sql(rig, vfo, code); - caps->set_vfo(rig, curr_vfo); - return retcode; + return caps->get_dcs_sql(rig, vfo, code); + } + + if (!caps->set_vfo) { + return -RIG_ENTARGET; + } + + curr_vfo = rig->state.current_vfo; + retcode = caps->set_vfo(rig, vfo); + + if (retcode != RIG_OK) { + return retcode; + } + + retcode = caps->get_dcs_sql(rig, vfo, code); + caps->set_vfo(rig, curr_vfo); + + return retcode; } /*! @} */ diff --git a/src/tones.h b/src/tones.h index 08064a430..8e1de8a4a 100644 --- a/src/tones.h +++ b/src/tones.h @@ -23,24 +23,25 @@ #define _TONES_H 1 -#include "hamlib/rig.h" /* and implicitly rig_dll.h */ +#include /* and implicitly rig_dll.h */ /* * 52 CTCSS sub-audible tones */ #define FULL_CTCSS_LIST \ - 600, 670, 693, 719, 744, 770, 797, 825, 854, 885, 915, \ - 948, 974, 1000, 1035, 1072, 1109, 1148, 1188, 1200, 1230, 1273, \ - 1318, 1365, 1413, 1462, 1514, 1567, 1598, 1622, 1655, 1679, \ - 1713, 1738, 1773, 1799, 1835, 1862, 1899, 1928, 1966, 1995, \ - 2035, 2065, 2107, 2181, 2257, 2291, 2336, 2418, 2503, 2541, \ - 0, + 600, 670, 693, 719, 744, 770, 797, 825, 854, 885, 915, \ + 948, 974, 1000, 1035, 1072, 1109, 1148, 1188, 1200, 1230, 1273, \ + 1318, 1365, 1413, 1462, 1514, 1567, 1598, 1622, 1655, 1679, \ + 1713, 1738, 1773, 1799, 1835, 1862, 1899, 1928, 1966, 1995, \ + 2035, 2065, 2107, 2181, 2257, 2291, 2336, 2418, 2503, 2541, \ + 0, static const tone_t static_full_ctcss_list[] = { - FULL_CTCSS_LIST + FULL_CTCSS_LIST }; + /* * 50 CTCSS sub-audible tones, from 67.0Hz to 254.1Hz * @@ -49,55 +50,58 @@ static const tone_t static_full_ctcss_list[] = { * own caps. --SF */ #define COMMON_CTCSS_LIST \ - 670, 693, 719, 744, 770, 797, 825, 854, 885, 915, \ - 948, 974, 1000, 1035, 1072, 1109, 1148, 1188, 1230, 1273, \ - 1318, 1365, 1413, 1462, 1514, 1567, 1598, 1622, 1655, 1679, \ - 1713, 1738, 1773, 1799, 1835, 1862, 1899, 1928, 1966, 1995, \ - 2035, 2065, 2107, 2181, 2257, 2291, 2336, 2418, 2503, 2541, \ - 0, + 670, 693, 719, 744, 770, 797, 825, 854, 885, 915, \ + 948, 974, 1000, 1035, 1072, 1109, 1148, 1188, 1230, 1273, \ + 1318, 1365, 1413, 1462, 1514, 1567, 1598, 1622, 1655, 1679, \ + 1713, 1738, 1773, 1799, 1835, 1862, 1899, 1928, 1966, 1995, \ + 2035, 2065, 2107, 2181, 2257, 2291, 2336, 2418, 2503, 2541, \ + 0, static const tone_t static_common_ctcss_list[] = { - COMMON_CTCSS_LIST + COMMON_CTCSS_LIST }; + /* * 104 DCS codes */ #define COMMON_DCS_LIST \ - 23, 25, 26, 31, 32, 36, 43, 47, 51, 53, \ - 54, 65, 71, 72, 73, 74, 114, 115, 116, 122, 125, 131, \ - 132, 134, 143, 145, 152, 155, 156, 162, 165, 172, 174, 205, \ - 212, 223, 225, 226, 243, 244, 245, 246, 251, 252, 255, 261, \ - 263, 265, 266, 271, 274, 306, 311, 315, 325, 331, 332, 343, \ - 346, 351, 356, 364, 365, 371, 411, 412, 413, 423, 431, 432, \ - 445, 446, 452, 454, 455, 462, 464, 465, 466, 503, 506, 516, \ - 523, 526, 532, 546, 565, 606, 612, 624, 627, 631, 632, 654, \ - 662, 664, 703, 712, 723, 731, 732, 734, 743, 754, \ - 0, + 23, 25, 26, 31, 32, 36, 43, 47, 51, 53, \ + 54, 65, 71, 72, 73, 74, 114, 115, 116, 122, 125, 131, \ + 132, 134, 143, 145, 152, 155, 156, 162, 165, 172, 174, 205, \ + 212, 223, 225, 226, 243, 244, 245, 246, 251, 252, 255, 261, \ + 263, 265, 266, 271, 274, 306, 311, 315, 325, 331, 332, 343, \ + 346, 351, 356, 364, 365, 371, 411, 412, 413, 423, 431, 432, \ + 445, 446, 452, 454, 455, 462, 464, 465, 466, 503, 506, 516, \ + 523, 526, 532, 546, 565, 606, 612, 624, 627, 631, 632, 654, \ + 662, 664, 703, 712, 723, 731, 732, 734, 743, 754, \ + 0, static const tone_t static_common_dcs_list[] = { - COMMON_DCS_LIST + COMMON_DCS_LIST }; + /* * 106 DCS codes */ #define FULL_DCS_LIST \ - 17, 23, 25, 26, 31, 32, 36, 43, 47, 50, 51, 53, \ - 54, 65, 71, 72, 73, 74, 114, 115, 116, 122, 125, 131, \ - 132, 134, 143, 145, 152, 155, 156, 162, 165, 172, 174, 205, \ - 212, 223, 225, 226, 243, 244, 245, 246, 251, 252, 255, 261, \ - 263, 265, 266, 271, 274, 306, 311, 315, 325, 331, 332, 343, \ - 346, 351, 356, 364, 365, 371, 411, 412, 413, 423, 431, 432, \ - 445, 446, 452, 454, 455, 462, 464, 465, 466, 503, 506, 516, \ - 523, 526, 532, 546, 565, 606, 612, 624, 627, 631, 632, 654, \ - 662, 664, 703, 712, 723, 731, 732, 734, 743, 754, \ - 0, + 17, 23, 25, 26, 31, 32, 36, 43, 47, 50, 51, 53, \ + 54, 65, 71, 72, 73, 74, 114, 115, 116, 122, 125, 131, \ + 132, 134, 143, 145, 152, 155, 156, 162, 165, 172, 174, 205, \ + 212, 223, 225, 226, 243, 244, 245, 246, 251, 252, 255, 261, \ + 263, 265, 266, 271, 274, 306, 311, 315, 325, 331, 332, 343, \ + 346, 351, 356, 364, 365, 371, 411, 412, 413, 423, 431, 432, \ + 445, 446, 452, 454, 455, 462, 464, 465, 466, 503, 506, 516, \ + 523, 526, 532, 546, 565, 606, 612, 624, 627, 631, 632, 654, \ + 662, 664, 703, 712, 723, 731, 732, 734, 743, 754, \ + 0, static const tone_t static_full_dcs_list[] = { - FULL_DCS_LIST + FULL_DCS_LIST }; + /* * These arrays cannot be shared on Win32 systems, * because DLL's vars don't have constant address. diff --git a/src/usb_port.c b/src/usb_port.c index 0bf19985c..739ddd189 100644 --- a/src/usb_port.c +++ b/src/usb_port.c @@ -35,7 +35,7 @@ #include "config.h" #endif -#include "hamlib/rig.h" +#include /* * Compile only if libusb is available @@ -60,110 +60,146 @@ #include "usb_port.h" - /** * \brief Find and open USB device * \param port * \return usb_handle */ -static libusb_device_handle *find_and_open_device(const hamlib_port_t *port) +static libusb_device_handle * find_and_open_device(const hamlib_port_t *port) { - libusb_device_handle *udh = NULL; - libusb_device *dev, **devs; - struct libusb_device_descriptor desc; - char string[256]; - int i, r; + libusb_device_handle *udh = NULL; + libusb_device *dev, **devs; + struct libusb_device_descriptor desc; + char string[256]; + int i, r; - rig_debug(RIG_DEBUG_VERBOSE, "%s: looking for device %04x:%04x...", - __func__, port->parm.usb.vid, port->parm.usb.pid); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - r = libusb_get_device_list(NULL, &devs); + rig_debug(RIG_DEBUG_VERBOSE, + "%s: looking for device %04x:%04x...", + __func__, + port->parm.usb.vid, + port->parm.usb.pid); - if (r < 0) { - rig_debug(RIG_DEBUG_ERR, "%s: failed getting usb device list: %s", - __func__, libusb_error_name(r)); - return NULL; - } + r = libusb_get_device_list(NULL, &devs); - for (i = 0; (dev = devs[i]) != NULL; i++) { + if (r < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: failed getting usb device list: %s", + __func__, + libusb_error_name(r)); - libusb_get_device_descriptor(dev, &desc); + return NULL; + } - rig_debug(RIG_DEBUG_VERBOSE, " %04x:%04x,", - desc.idVendor, desc.idProduct); + for (i = 0; (dev = devs[i]) != NULL; i++) { - if (desc.idVendor == port->parm.usb.vid && - desc.idProduct == port->parm.usb.pid) { + libusb_get_device_descriptor(dev, &desc); - /* we need to open the device in order to query strings */ - r = libusb_open(dev, &udh); + rig_debug(RIG_DEBUG_VERBOSE, + " %04x:%04x,", + desc.idVendor, + desc.idProduct); - if (r < 0) { - rig_debug(RIG_DEBUG_WARN, "%s: Warning: Cannot open USB device: %s\n", - __func__, libusb_error_name(r)); - continue; - } + if (desc.idVendor == port->parm.usb.vid + && desc.idProduct == port->parm.usb.pid) { - /* now check whether the names match: */ - if (port->parm.usb.vendor_name) { + /* we need to open the device in order to query strings */ + r = libusb_open(dev, &udh); - 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, + "%s: Warning: Cannot open USB device: %s\n", + __func__, + libusb_error_name(r)); - if (r < 0) { - rig_debug(RIG_DEBUG_WARN, "Warning: cannot query manufacturer for USB device: %s\n", libusb_error_name(r)); - libusb_close(udh); - continue; - } + continue; + } - rig_debug(RIG_DEBUG_VERBOSE, " vendor >%s<", string); + /* now check whether the names match: */ + if (port->parm.usb.vendor_name) { - if (strcmp(string, port->parm.usb.vendor_name) != 0) { - rig_debug(RIG_DEBUG_WARN, "%s: Warning: Vendor name string mismatch!\n", __func__); - libusb_close(udh); - continue; - } - } + string[0] = '\0'; + r = libusb_get_string_descriptor_ascii(udh, + desc.iManufacturer, + (unsigned char *)string, + sizeof(string)); - if (port->parm.usb.product) { + if (r < 0) { + rig_debug(RIG_DEBUG_WARN, + "Warning: cannot query manufacturer for USB device: %s\n", + libusb_error_name(r)); - string[0] = '\0'; - r = libusb_get_string_descriptor_ascii(udh, desc.iProduct, (unsigned char *)string, sizeof(string)); + libusb_close(udh); + continue; + } - if (r < 0) { - rig_debug(RIG_DEBUG_WARN, "Warning: cannot query product for USB device: %s\n", libusb_error_name(r)); - libusb_close(udh); - continue; - } + rig_debug(RIG_DEBUG_VERBOSE, " vendor >%s<", string); - rig_debug(RIG_DEBUG_VERBOSE, " product >%s<", string); + if (strcmp(string, port->parm.usb.vendor_name) != 0) { + rig_debug(RIG_DEBUG_WARN, + "%s: Warning: Vendor name string mismatch!\n", + __func__); - if (strcmp(string, port->parm.usb.product) != 0) { - /* Now testing with strncasecmp() for case insensitive - * match. Updating firmware on FUNcube Dongle to v18f resulted - * in product string changing from "FunCube Dongle" to - * "FUNcube Dongle". As new dongles are shipped with - * older firmware, both product strings are valid. Sigh... - */ - if (strncasecmp(string, port->parm.usb.product, sizeof(port->parm.usb.product - 1)) != 0) { - rig_debug(RIG_DEBUG_WARN, "%s: Warning: Product string mismatch!\n", __func__); - libusb_close(udh); - continue; - } - } - } + libusb_close(udh); + continue; + } + } - libusb_free_device_list(devs, 1); + if (port->parm.usb.product) { - rig_debug(RIG_DEBUG_VERBOSE, " -> found\n"); - return udh; - } - } + string[0] = '\0'; + r = libusb_get_string_descriptor_ascii(udh, + desc.iProduct, + (unsigned char *)string, + sizeof(string)); - libusb_free_device_list(devs, 1); + if (r < 0) { + rig_debug(RIG_DEBUG_WARN, + "Warning: cannot query product for USB device: %s\n", + libusb_error_name(r)); - rig_debug(RIG_DEBUG_VERBOSE, " -> not found\n"); - return NULL; /* not found */ + libusb_close(udh); + continue; + } + + rig_debug(RIG_DEBUG_VERBOSE, " product >%s<", string); + + if (strcmp(string, port->parm.usb.product) != 0) { + + /* Now testing with strncasecmp() for case insensitive + * match. Updating firmware on FUNcube Dongle to v18f resulted + * in product string changing from "FunCube Dongle" to + * "FUNcube Dongle". As new dongles are shipped with + * older firmware, both product strings are valid. Sigh... + */ + if (strncasecmp(string, + port->parm.usb.product, + sizeof(port->parm.usb.product - 1)) != 0) { + + rig_debug(RIG_DEBUG_WARN, + "%s: Warning: Product string mismatch!\n", + __func__); + + libusb_close(udh); + continue; + } + } + } + + libusb_free_device_list(devs, 1); + + rig_debug(RIG_DEBUG_VERBOSE, " -> found\n"); + + return udh; + } + } + + libusb_free_device_list(devs, 1); + + rig_debug(RIG_DEBUG_VERBOSE, " -> not found\n"); + + return NULL; /* not found */ } @@ -174,119 +210,144 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port) */ int usb_port_open(hamlib_port_t *port) { - static char pathname[FILPATHLEN]; - libusb_device_handle *udh; - char *p, *q; - int r; + static char pathname[FILPATHLEN]; + libusb_device_handle *udh; + char *p, *q; + int r; - /* init defaut libusb-1.0 library contexte, if needed */ - r = libusb_init(NULL); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (r < 0) { - rig_debug(RIG_DEBUG_ERR, "%s: libusb_init failed: %s\n", - __func__, libusb_error_name(r)); - return -RIG_EIO; - } + /* init defaut libusb-1.0 library contexte, if needed */ + r = libusb_init(NULL); - //libusb_set_debug(NULL, 1); + if (r < 0) { + rig_debug(RIG_DEBUG_ERR, + "%s: libusb_init failed: %s\n", + __func__, + libusb_error_name(r)); - /* 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'; + return -RIG_EIO; + } - p = pathname; - q = strchr(p, ':'); + //libusb_set_debug(NULL, 1); - if (q) { - ++q; - port->parm.usb.vid = strtol(q, NULL, 16); - p = q; - q = strchr(p, ':'); + /* 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'; - if (q) { - ++q; - port->parm.usb.pid = strtol(q, NULL, 16); - p = q; - q = strchr(p, ':'); + p = pathname; + q = strchr(p, ':'); - if (q) { - ++q; - port->parm.usb.vendor_name = q; - p = q; - q = strchr(p, ':'); + if (q) { + ++q; + port->parm.usb.vid = strtol(q, NULL, 16); + p = q; + q = strchr(p, ':'); - if (q) { - *q++ = '\0'; - port->parm.usb.product = q; - } - } - } - } + if (q) { + ++q; + port->parm.usb.pid = strtol(q, NULL, 16); + p = q; + q = strchr(p, ':'); - udh = find_and_open_device(port); + if (q) { + ++q; + port->parm.usb.vendor_name = q; + p = q; + q = strchr(p, ':'); - if (udh == 0) { - libusb_exit(NULL); - return -RIG_EIO; - } + if (q) { + *q++ = '\0'; + port->parm.usb.product = q; + } + } + } + } - /* Try to detach ftdi_sio kernel module. - * This should be performed only for devices using - * USB-serial converters (like FTDI chips), for other - * devices this may cause problems, so do not do it. - */ - (void)libusb_set_auto_detach_kernel_driver(udh, port->parm.usb.iface); + udh = find_and_open_device(port); - if (port->parm.usb.iface >= 0) { + if (udh == 0) { + libusb_exit(NULL); + return -RIG_EIO; + } + + /* Try to detach ftdi_sio kernel module. + * This should be performed only for devices using + * USB-serial converters (like FTDI chips), for other + * devices this may cause problems, so do not do it. + */ + (void)libusb_set_auto_detach_kernel_driver(udh, port->parm.usb.iface); + + 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) { - 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); - return -RIG_EIO; - } + /* Is it still needed with libusb-1.0 ? */ + if (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); + + return -RIG_EIO; + } #endif - rig_debug(RIG_DEBUG_VERBOSE, "%s: claiming %d\n", __func__, port->parm.usb.iface); + 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); - return -RIG_EIO; - } + 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); + + return -RIG_EIO; + } #if 0 - r = libusb_set_interface_alt_setting(udh, port->parm.usb.iface, port->parm.usb.alt); + 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__, - libusb_error_name(r)); - libusb_release_interface(udh, port->parm.usb.iface); - libusb_close(udh); - libusb_exit(NULL); - return -RIG_EIO; - } + if (r < 0) { + 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); + + return -RIG_EIO; + } #endif - } + } - port->handle = (void *) udh; + port->handle = (void *) udh; - return RIG_OK; + return RIG_OK; } + /** * \brief Close hamlib_port of USB device * \param port @@ -294,29 +355,36 @@ int usb_port_open(hamlib_port_t *port) */ int usb_port_close(hamlib_port_t *port) { - libusb_device_handle *udh = port->handle; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - libusb_release_interface(udh, port->parm.usb.iface); + libusb_device_handle *udh = port->handle; - libusb_close(udh); + libusb_release_interface(udh, port->parm.usb.iface); - libusb_exit(NULL); + libusb_close(udh); - return RIG_OK; + libusb_exit(NULL); + + return RIG_OK; } #else int usb_port_open(hamlib_port_t *port) { - return -RIG_ENAVAIL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + return -RIG_ENAVAIL; } + int usb_port_close(hamlib_port_t *port) { - return -RIG_ENAVAIL; + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + + return -RIG_ENAVAIL; } -#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */ +#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */ /** @} */