mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Migrating from libusb-0.1 to libusb-1.0

libusb-1-0
Stephane Fillod 2016-02-14 18:02:26 +01:00
rodzic 0e2ee1c4d5
commit 8d7697c3bd
11 zmienionych plików z 426 dodań i 413 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

18
INSTALL
Wyświetl plik

@ -250,13 +250,13 @@ MS Windows
./configure --host=i686-w64-mingw32
- Specifying the directory of libusb for a Windows build using MinGW as
libusb must be installed separately, use the following environment
- Specifying the directory of libusb-1.0 for a Windows build using MinGW as
libusb-1.0 must be installed separately, use the following environment
variables after all other options.
./configure [other options] \
CPPFLAGS="-I/path_to_libusb/include" \
LDFLAGS="-L/path_to_libusb/lib/gcc"
CPPFLAGS="-I/path_to_libusb-1.0/include" \
LDFLAGS="-L/path_to_libusb-1.0/lib/gcc"
- Mingw compiler under Cygwin
@ -333,12 +333,12 @@ Note, the following is still experimental.
application may be thought to ease its distribution. As a static library is
built by default the following notes may assist application authors.
The 'kit' backend depends on libusb. To link libusb statically set the
The 'kit' backend depends on libusb-1.0. To link libusb-1.0 statically set the
following environment variable on the 'configure' command line:
LIBUSB_LIBS="/usr/lib/i386-linux-gnu/libusb.a"
LIBUSB_LIBS="/usr/lib/i386-linux-gnu/libusb-1.0.a"
do note that the absolute path to 'libusb.a' may well be quite different on
do note that the absolute path to 'libusb-1.0.a' may well be quite different on
other systems.
By default the GNU linker (ld) will include most all symbols in a static
@ -358,7 +358,7 @@ nor does 'rotctl' contain any rig symbols.
./configure --disable-shared --prefix="$HOME/local" --without-cxx-binding \
--disable-winradio CFLAGS="-fdata-sections -ffunction-sections" \
LDFLAGS="-Wl,--gc-sections" LIBUSB_LIBS="/usr/lib/i386-linux-gnu/libusb.a"
LDFLAGS="-Wl,--gc-sections" LIBUSB_LIBS="/usr/lib/i386-linux-gnu/libusb-1.0.a"
to make a static only Hamlib library, statically link libusb, and include only
to make a static only Hamlib library, statically link libusb-1.0, and include only
the needed symbols in the Hamlib utilities linking to libhamlib.a.

6
README.betatester
Wyświetl plik

@ -86,12 +86,12 @@ Optional, but highly recommended for a complete build:
* zlib devel # Needed by configure's test for Python
* libxml2 devel # xml2-config --version
* libgd2 devel # gdlib-config --version
* libusb devel # libusb-config --version (not 1.0.0!)
* libusb-1.0 devel # ver 1.0 or newer (not 0.1!)
* libreadline devel # ver 5.2 or newer
N.B The libusb package is required for building most of the 'kit' backend.
The older version is needed, not 1.0.0 or higher. Debian and derivatives
package libusb 0.1.12 which is what is needed.
The newer version is needed, not 0.1. Debian and derivatives
package libusb-1.0 which is what is needed.
Documentation:
* Doxygen

4
android/config.h
Wyświetl plik

@ -222,8 +222,8 @@
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Define to 1 if you have the <usb.h> header file. */
#define HAVE_USB_H 1
/* Define to 1 if you have the <libusb.h> header file. */
#define HAVE_LIBUSB_H 1
/* Define to 1 if you have the `usleep' function. */
#define HAVE_USLEEP 1

12
configure.ac
Wyświetl plik

@ -309,23 +309,23 @@ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
dnl Check for libusb, treat LIBUSB_LIBS and LIBUSB_CFLAGS as precious variables
AC_ARG_VAR([LIBUSB_CFLAGS], [C compiler flags for libusb, overriding configure defaults])
AC_ARG_VAR([LIBUSB_LIBS], [linker flags for libusb, overriding configure check (useful for specifying static libusb.a (see INSTALL))])
AC_ARG_VAR([LIBUSB_LIBS], [linker flags for libusb, overriding configure check (useful for specifying static libusb-1.0.a (see INSTALL))])
cf_with_libusb="no"
AS_IF([test -z $LIBUSB_LIBS],
[AC_CHECK_LIB([usb], [usb_init], [LIBUSB_LIBS="-lusb" cf_with_libusb="yes"],
[AC_MSG_WARN([usb_init was not found in libusb--USB backends will be disabled])])
[AC_CHECK_LIB([usb-1.0], [libusb_init], [LIBUSB_LIBS="-lusb-1.0" cf_with_libusb="yes"],
[AC_MSG_WARN([libusb_init was not found in libusb-1.0--USB backends will be disabled])])
], [cf_with_libusb="yes"])
LIBUSB=""
AS_IF([test x"${cf_with_libusb}" = "xyes"],
[AC_CHECK_HEADERS([usb.h])
[AC_CHECK_HEADERS([libusb.h])
AC_DEFINE([HAVE_LIBUSB],
[1],
[Define if libusb is available])
LIBUSB="libusb"])
[Define if libusb-1.0 is available])
LIBUSB="libusb-1.0"])
# Only used in hamlib.pc.in
AC_SUBST([LIBUSB])

33
kit/dwt.c
Wyświetl plik

@ -235,7 +235,7 @@ int dwtdll_init(RIG *rig)
if (!priv->dll) {
rig_debug(RIG_DEBUG_ERR, "%s: Unable to LoadLibrary %s\n",
__FUNCTION__, DWTDLL);
__func__, DWTDLL);
free(priv);
return -RIG_EIO; /* huh! */
}
@ -456,11 +456,11 @@ static const char* dwtdll_get_info(RIG *rig)
}
#elif defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#elif defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#include <errno.h>
#include <usb.h>
#include <libusb.h>
#include "token.h"
@ -495,7 +495,7 @@ const struct rig_caps dwt_caps = {
.rig_model = RIG_MODEL_DWT,
.model_name = "Digital World Traveller",
.mfg_name = "Coding Technologies",
.version = "0.1",
.version = "0.2",
.copyright = "LGPL",
.status = RIG_STATUS_UNTESTED,
.rig_type = RIG_TYPE_TUNER,
@ -583,7 +583,7 @@ int dwt_init(RIG *rig)
#define MSG_LEN 16
int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int request, value, index;
unsigned char buf[MSG_LEN] = { 0x4a, 0x00, 0x03, 0x00, 0xff, 0xff, 0x32 };
int requesttype, r;
@ -597,27 +597,30 @@ int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
buf[8] = ifreq & 0xff;
buf[7] = (ifreq>>8) & 0xff;
r = usb_control_msg (udh, requesttype, request, value, index,
(char *) buf, 9, 1000);
r = libusb_control_transfer (udh, requesttype, request, value, index,
buf, 9, 1000);
if (r < 0) {
/* we get EPIPE if the firmware stalls the endpoint. */
if (errno != EPIPE)
rig_debug (RIG_DEBUG_ERR,
"usb_control_msg failed: %s\n",
usb_strerror ());
rig_debug (RIG_DEBUG_ERR,
"libusb_control_transfer failed: %s\n",
libusb_error_name (r));
return -RIG_EIO;
}
return RIG_OK;
}
/* Rem: not reentrant */
const char * dwt_get_info(RIG *rig)
{
static char buf[64];
struct usb_dev_handle *udh = rig->state.rigport.handle;
struct usb_device *q = usb_device(udh);
libusb_device_handle *udh = rig->state.rigport.handle;
struct libusb_device_descriptor desc;
sprintf(buf, "Dev %04d", q->descriptor.bcdDevice);
/* always succeeds since libusb-1.0.16 */
libusb_get_device_descriptor(libusb_get_device(udh), &desc);
sprintf(buf, "Dev %04d", desc.bcdDevice);
return buf;
}

78
kit/elektor507.c
Wyświetl plik

@ -33,7 +33,7 @@
#ifdef _WIN32
#define USE_FTDI_DLL
#elif defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#elif defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#define USE_LIBUSB
#endif
@ -145,7 +145,7 @@ struct elektor507_extra_priv_data {
#include <errno.h>
#include <usb.h>
#include <libusb.h>
#define USB_VID_FTDI 0x0403 /* Future Technology Devices International */
@ -236,7 +236,7 @@ int elektor507_init(RIG *rig)
if (!extra_priv->dll) {
rig_debug(RIG_DEBUG_ERR, "%s: Unable to LoadLibrary %s\n",
__FUNCTION__, ELEKTOR507_DLL);
__func__, ELEKTOR507_DLL);
free(priv);
return -RIG_EIO; /* huh! */
}
@ -273,7 +273,7 @@ int elektor507_ftdi_write_data(RIG *rig, void *FTOutBuf, unsigned long BufferSiz
FT_Result ret;
int Result;
rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __FUNCTION__, BufferSize);
rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __func__, BufferSize);
/* Open FTDI */
ret = extra_priv->FT_Open(0, &extra_priv->ftHandle);
@ -376,32 +376,36 @@ int elektor507_cleanup(RIG *rig)
return RIG_OK;
}
/* Rem: not reentrant */
const char * elektor507_get_info(RIG *rig)
{
static char buf[64];
struct usb_dev_handle *udh = rig->state.rigport.handle;
struct usb_device *q = usb_device(udh);
libusb_device_handle *udh = rig->state.rigport.handle;
struct libusb_device_descriptor desc;
sprintf(buf, "USB dev %04d", q->descriptor.bcdDevice);
/* always succeeds since libusb-1.0.16 */
libusb_get_device_descriptor(libusb_get_device(udh), &desc);
sprintf(buf, "USB dev %04d", desc.bcdDevice);
return buf;
}
int elektor507_libusb_setup(RIG *rig)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
unsigned short index=0, usb_val;
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__);
/* Reset the ftdi device */
#if 1
ret = usb_control_msg(udh, 0x40, 0, 0, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
ret = libusb_control_transfer(udh, 0x40, 0, 0, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
if (ret != 0) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg reset failed: %s\n",
__FUNCTION__,
usb_strerror ());
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer reset failed: %s\n",
__func__,
libusb_error_name (ret));
return -RIG_EIO;
}
#endif
@ -412,11 +416,11 @@ int elektor507_libusb_setup(RIG *rig)
usb_val = 0xff; /* low byte: bitmask */
usb_val |= (0x01 << 8); /* Basic bitbang_mode: 0x01 */
ret = usb_control_msg(udh, 0x40, 0x0B, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
ret = libusb_control_transfer(udh, 0x40, 0x0B, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
if (ret != 0) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg bitbangmode failed: %s\n",
__FUNCTION__,
usb_strerror ());
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer bitbangmode failed: %s\n",
__func__,
libusb_error_name (ret));
return -RIG_EIO;
}
@ -426,11 +430,11 @@ int elektor507_libusb_setup(RIG *rig)
*/
usb_val = 49230; /* magic value for 38400 bauds */
index = 0;
ret = usb_control_msg(udh, 0x40, 3, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
ret = libusb_control_transfer(udh, 0x40, 3, usb_val, index, NULL, 0, FTDI_USB_WRITE_TIMEOUT);
if (ret != 0) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg baudrate failed: %s\n",
__FUNCTION__,
usb_strerror ());
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer baudrate failed: %s\n",
__func__,
libusb_error_name (ret));
return -RIG_EIO;
}
@ -439,18 +443,16 @@ int elektor507_libusb_setup(RIG *rig)
int elektor507_ftdi_write_data(RIG *rig, void *FTOutBuf, unsigned long BufferSize)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
int ret;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret, actual_length;
rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __FUNCTION__, BufferSize);
rig_debug(RIG_DEBUG_TRACE,"%s called, %d bytes\n", __func__, BufferSize);
ret = usb_bulk_write(udh, FTDI_IN_EP, FTOutBuf, BufferSize, FTDI_USB_WRITE_TIMEOUT);
ret = libusb_bulk_transfer(udh, FTDI_IN_EP, FTOutBuf, BufferSize, &actual_length, FTDI_USB_WRITE_TIMEOUT);
if (ret < 0) {
/* we get EPIPE if the firmware stalls the endpoint. */
if (errno != EPIPE)
rig_debug (RIG_DEBUG_ERR,
"usb_bulk_write failed: %s\n",
usb_strerror ());
rig_debug (RIG_DEBUG_ERR,
"usb_bulk_write failed: %s\n",
libusb_error_name (ret));
return -RIG_EIO;
}
@ -495,7 +497,7 @@ const struct rig_caps elektor507_caps = {
.rig_model = RIG_MODEL_ELEKTOR507,
.model_name = "Elektor SDR-USB",
.mfg_name = "Elektor",
.version = "0.3.1",
.version = "0.3.2",
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_TUNER,
@ -625,7 +627,7 @@ int elektor507_open(RIG *rig)
struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv;
int ret;
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__);
/*
* Setup the FT232R.
@ -758,7 +760,7 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq)
VCO = ((double)priv->osc_freq/priv->Q)*priv->P;
if (VCO < 100e3 || VCO > 400e3)
rig_debug(RIG_DEBUG_VERBOSE, "%s: Unstable parameters for VCO=%.1f\n",
__FUNCTION__, VCO);
__func__, VCO);
}
#endif /* ORIG_ALGORITHM */
@ -826,7 +828,7 @@ static void find_P_Q_DIV1N(struct elektor507_priv_data *priv, freq_t freq)
VCO = ((double)priv->osc_freq/priv->Q)*priv->P;
if (VCO < vco_min || VCO > 400e3)
rig_debug(RIG_DEBUG_VERBOSE, "%s: Unstable parameters for VCO=%.1f\n",
__FUNCTION__, VCO);
__func__, VCO);
}
#endif /* default alternative to ORIG_ALGORITHM */
@ -902,12 +904,12 @@ int elektor507_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
elektor507_get_freq(rig, vfo, &final_freq);
rig_debug(RIG_DEBUG_VERBOSE, "%s: Freq=%.0f kHz, delta=%d Hz, Div1N=%d, P=%d, Q=%d, FREQ_ALGORITHM=%d\n",
__FUNCTION__, freq/kHz(1), (int)(final_freq-freq), priv->Div1N, priv->P, priv->Q, FREQ_ALGORITHM);
__func__, freq/kHz(1), (int)(final_freq-freq), priv->Div1N, priv->P, priv->Q, FREQ_ALGORITHM);
if ((double)priv->osc_freq/priv->Q < 250)
rig_debug(RIG_DEBUG_WARN,
"%s: Unstable parameters for REF/Qtotal=%.1f\n",
__FUNCTION__, (double)priv->osc_freq/priv->Q);
__func__, (double)priv->osc_freq/priv->Q);
ret = cy_update_pll(rig, CY_I2C_RAM_ADR);
@ -990,7 +992,7 @@ int elektor507_set_ant(RIG * rig, vfo_t vfo, ant_t ant)
struct elektor507_priv_data *priv = (struct elektor507_priv_data *)rig->state.priv;
int ret, Mux;
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__);
/*
* FTDI: RTS, CTS, DTR
@ -1240,7 +1242,7 @@ int load_ftdi_code(RIG *rig, unsigned char IICadr, const unsigned char code[])
int ret;
int i, j;
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__);
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__);
for (i = 0; i<16; i++)
{

64
kit/fifisdr.c
Wyświetl plik

@ -41,10 +41,10 @@
/*
* Compile this model only if libusb is available
*/
#if defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#if defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#include <errno.h>
#include <usb.h>
#include <libusb.h>
@ -120,7 +120,7 @@ const struct rig_caps fifisdr_caps = {
.rig_model = RIG_MODEL_FIFISDR,
.model_name = "FiFi-SDR",
.mfg_name = "FiFi",
.version = "0.5",
.version = "0.6",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
@ -261,20 +261,20 @@ static uint32_t fifisdr_fromle32 (uint32_t x)
/** USB OUT transfer via vendor device command. */
static int fifisdr_usb_write (RIG *rig,
int request, int value, int index,
char *bytes, int size)
unsigned char *bytes, int size)
{
int ret;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
request, value, index,
bytes, size, rig->state.rigport.timeout);
if (ret != size) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg (%d/%d) failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -286,20 +286,20 @@ static int fifisdr_usb_write (RIG *rig,
/** USB IN transfer via vendor device command. */
static int fifisdr_usb_read (RIG *rig,
int request, int value, int index,
char *bytes, int size)
unsigned char *bytes, int size)
{
int ret;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
request, value, index,
bytes, size, rig->state.rigport.timeout);
if (ret != size) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg (%d/%d) failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -365,7 +365,7 @@ int fifisdr_open (RIG *rig)
/* The VCO is a multiple of the RX frequency. Typically 4 */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
11, /* Read virtual VCO factor */
(char *)&multiply, sizeof(multiply));
(unsigned char *)&multiply, sizeof(multiply));
if (ret == RIG_OK) {
priv->multiplier = fifisdr_fromle32(multiply);
}
@ -381,7 +381,7 @@ const char * fifisdr_get_info (RIG *rig)
int ret;
uint32_t svn_version;
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, 0, (char *)&svn_version, sizeof(svn_version));
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, 0, (unsigned char *)&svn_version, sizeof(svn_version));
if (ret != RIG_OK) {
return NULL;
}
@ -406,7 +406,7 @@ int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
freq1121 = fifisdr_tole32(round(mhz * 2097152.0));
ret = fifisdr_usb_write(rig, REQUEST_SET_FREQ_BY_VALUE, 0, 0,
(char *)&freq1121, sizeof(freq1121));
(unsigned char *)&freq1121, sizeof(freq1121));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -423,7 +423,7 @@ int fifisdr_get_freq (RIG *rig, vfo_t vfo, freq_t *freq)
uint32_t freq1121;
ret = fifisdr_usb_read(rig, REQUEST_READ_FREQUENCY, 0, 0, (char *)&freq1121, sizeof(freq1121));
ret = fifisdr_usb_read(rig, REQUEST_READ_FREQUENCY, 0, 0, (unsigned char *)&freq1121, sizeof(freq1121));
if (ret == RIG_OK) {
freq1121 = fifisdr_fromle32(freq1121);
@ -461,7 +461,7 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
15, /* Demodulator mode */
(char *)&fifi_mode, sizeof(fifi_mode));
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -470,7 +470,7 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
fifi_width = fifisdr_tole32(width);
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
16, /* Filter width */
(char *)&fifi_width, sizeof(fifi_width));
(unsigned char *)&fifi_width, sizeof(fifi_width));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -490,7 +490,7 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt
/* Read current mode */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
15, /* Demodulator mode */
(char *)&fifi_mode, sizeof(fifi_mode));
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
if (ret != RIG_OK) {
return -RIG_EIO;
@ -516,7 +516,7 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt
/* Read current filter width */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
16, /* Filter width */
(char *)&fifi_width, sizeof(fifi_width));
(unsigned char *)&fifi_width, sizeof(fifi_width));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -547,7 +547,7 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
19, /* Preamp */
(char *)&fifi_preamp, sizeof(fifi_preamp));
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
break;
/* RX volume control */
@ -562,7 +562,7 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
14, /* Demodulator volume */
(char *)&fifi_volume, sizeof(fifi_volume));
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
break;
/* Squelch level */
@ -577,7 +577,7 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
20, /* Squelch control */
(char *)&fifi_squelch, sizeof(fifi_squelch));
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
break;
/* AGC */
@ -595,7 +595,7 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
21, /* AGC template */
(char *)&fifi_agc, sizeof(fifi_agc));
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
break;
/* Unsupported option */
@ -623,7 +623,7 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_PREAMP:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
19, /* Preamp */
(char *)&fifi_preamp, sizeof(fifi_preamp));
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
if (ret == RIG_OK) {
/* Value can be 0 (0 dB) or 1 (+6 dB) */
val->i = 0;
@ -637,7 +637,7 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_AF:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
14, /* Demodulator volume */
(char *)&fifi_volume, sizeof(fifi_volume));
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
@ -651,7 +651,7 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_SQL:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
20, /* Squelch control */
(char *)&fifi_squelch, sizeof(fifi_squelch));
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
@ -665,7 +665,7 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_AGC:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
21, /* AGC template */
(char *)&fifi_agc, sizeof(fifi_agc));
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
if (ret == RIG_OK) {
val->i = 0;
switch (fifi_agc) {
@ -684,7 +684,7 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_STRENGTH:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
17, /* S-Meter */
(char *)&fifi_meter, sizeof(fifi_meter));
(unsigned char *)&fifi_meter, sizeof(fifi_meter));
if (ret == RIG_OK) {
val->i = fifisdr_fromle32(fifi_meter);
}
@ -711,7 +711,7 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va
case TOK_LVL_FMCENTER:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
18, /* FM center frequency */
(char *)&u32, sizeof(u32));
(unsigned char *)&u32, sizeof(u32));
if (ret == RIG_OK) {
val->f = Hz((int32_t)fifisdr_fromle32(u32));
}
@ -725,4 +725,4 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va
return ret;
}
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_USB_H) */
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */

185
kit/funcube.c
Wyświetl plik

@ -42,10 +42,10 @@
/*
* Compile this model only if libusb is available
*/
#if defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#if defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#include <errno.h>
#include <usb.h>
#include <libusb.h>
#include "funcube.h"
@ -63,8 +63,8 @@ static const struct confparams funcube_cfg_params[] = {
};
// functions used set / read frequency, working on FUNcube version 0 and 1
int set_freq_v0(usb_dev_handle *udh, unsigned int f, int timeout);
int set_freq_v1(usb_dev_handle *udh, unsigned int f, int timeout);
int set_freq_v0(libusb_device_handle *udh, unsigned int f, int timeout);
int set_freq_v1(libusb_device_handle *udh, unsigned int f, int timeout);
/*
* Common data struct
@ -86,7 +86,7 @@ const struct rig_caps funcube_caps = {
.rig_model = RIG_MODEL_FUNCUBEDONGLE,
.model_name = "FUNcube Dongle",
.mfg_name = "AMSAT-UK",
.version = "0.2",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
@ -148,7 +148,7 @@ const struct rig_caps funcubeplus_caps = {
.rig_model = RIG_MODEL_FUNCUBEDONGLEPLUS,
.model_name = "FUNcube Dongle Pro+",
.mfg_name = "AMSAT-UK",
.version = "0.2",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
@ -271,55 +271,60 @@ int funcube_cleanup(RIG *rig)
return RIG_OK;
}
/* Rem: not reentrant */
const char * funcube_get_info(RIG *rig)
{
static char buf[64];
struct usb_dev_handle *udh = rig->state.rigport.handle;
struct usb_device *q = usb_device(udh);
libusb_device_handle *udh = rig->state.rigport.handle;
struct libusb_device_descriptor desc;
sprintf(buf, "USB dev %04d", q->descriptor.bcdDevice);
/* always succeeds since libusb-1.0.16 */
libusb_get_device_descriptor(libusb_get_device(udh), &desc);
sprintf(buf, "Dev %04d", desc.bcdDevice);
return buf;
}
int set_freq_v0(usb_dev_handle *udh, unsigned int f, int timeout)
int set_freq_v0(libusb_device_handle *udh, unsigned int f, int timeout)
{
int ret;
int actual_length;
char au8BufOut[64]; // endpoint size
char au8BufIn[64]; // endpoint size
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
// frequency is in Hz, while the dongle expects it in kHz
f = f / 1e3;
f = f / 1000;
au8BufOut[0]=REQUEST_SET_FREQ; // Command to Set Frequency on dongle
au8BufOut[1]=(char)f;
au8BufOut[2]=(char)(f>>8);
au8BufOut[3]=(char)(f>>16);
au8BufOut[1]=(unsigned char)f;
au8BufOut[2]=(unsigned char)(f>>8);
au8BufOut[3]=(unsigned char)(f>>16);
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, (unsigned)au8BufOut[0] & 0xFF, (unsigned)au8BufOut[1] & 0xFF, (unsigned)au8BufOut[2] & 0xFF, (unsigned)au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = usb_interrupt_write(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_write failed (%d): %s\n",
__func__,ret, usb_strerror ());
return -RIG_EIO;
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret, libusb_error_name (ret));
return -RIG_EIO;
}
ret = usb_interrupt_read(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
if( ret != sizeof(au8BufIn) )
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_read failed (%d): %s\n",
__func__, ret, usb_strerror ());
return -RIG_EIO;
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret, libusb_error_name (ret));
return -RIG_EIO;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n",
__func__, (unsigned)au8BufIn[0] & 0xFF, (unsigned)au8BufIn[1] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ not supported\n",
@ -330,46 +335,47 @@ int set_freq_v0(usb_dev_handle *udh, unsigned int f, int timeout)
return RIG_OK;
}
int set_freq_v1(usb_dev_handle *udh, unsigned int f, int timeout)
int set_freq_v1(libusb_device_handle *udh, unsigned int f, int timeout)
{
int ret;
int actual_length;
char au8BufOut[64]; // endpoint size
char au8BufIn[64]; // endpoint size
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
au8BufOut[0]=REQUEST_SET_FREQ_HZ; // Command to Set Frequency in Hz on dongle
au8BufOut[1]=(char)f;
au8BufOut[2]=(char)(f>>8);
au8BufOut[3]=(char)(f>>16);
au8BufOut[4]=(char)(f>>24);
au8BufOut[1]=(unsigned char)f;
au8BufOut[2]=(unsigned char)(f>>8);
au8BufOut[3]=(unsigned char)(f>>16);
au8BufOut[4]=(unsigned char)(f>>24);
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x%02x\n",
__func__, (unsigned)au8BufOut[0] & 0xFF, (unsigned)au8BufOut[1] & 0xFF, (unsigned)au8BufOut[2] & 0xFF, (unsigned)au8BufOut[3] & 0xFF,
(unsigned)au8BufOut[4] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF,
au8BufOut[4] & 0xFF);
ret = usb_interrupt_write(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_write failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
usb_strerror ());
return -RIG_EIO;
libusb_error_name (ret));
return -RIG_EIO;
}
ret = usb_interrupt_read(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
if( ret != sizeof(au8BufIn) )
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_read failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
usb_strerror ());
return -RIG_EIO;
libusb_error_name (ret));
return -RIG_EIO;
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n",
__func__, (unsigned)au8BufIn[0] & 0xFF, (unsigned)au8BufIn[1] & 0xFF, (unsigned)au8BufIn[2] & 0xFF, (unsigned)au8BufIn[3] & 0xFF,
(unsigned)au8BufIn[4] & 0xFF, (unsigned)au8BufIn[5] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ_HZ not supported\n",
@ -383,7 +389,7 @@ int set_freq_v1(usb_dev_handle *udh, unsigned int f, int timeout)
int funcube_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
struct funcube_priv_data *priv = (struct funcube_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
if ((ret = set_freq_v1(udh, freq, rig->state.rigport.timeout)) != RIG_OK) {
@ -410,39 +416,40 @@ int get_freq_v0(RIG *rig, vfo_t vfo, freq_t *freq)
int get_freq_v1(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
unsigned int f;
int actual_length;
char au8BufOut[64]; // endpoint size
char au8BufIn[64]; // endpoint size
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
au8BufOut[0]=REQUEST_GET_FREQ_HZ; // Command to Set Frequency on dongle
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, (unsigned)au8BufOut[0] & 0xFF, (unsigned)au8BufOut[1] & 0xFF, (unsigned)au8BufOut[2] & 0xFF, (unsigned)au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = usb_interrupt_write(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_write failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
usb_strerror ());
libusb_error_name (ret));
}
ret = usb_interrupt_read(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret != sizeof(au8BufIn) )
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_read failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
usb_strerror ());
libusb_error_name (ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n",
__func__, (unsigned)au8BufIn[0] & 0xFF, (unsigned)au8BufIn[1] & 0xFF, (unsigned)au8BufIn[2] & 0xFF, (unsigned)au8BufIn[3] & 0xFF,
(unsigned)au8BufIn[4] & 0xFF, (unsigned)au8BufIn[5] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
@ -450,8 +457,8 @@ int get_freq_v1(RIG *rig, vfo_t vfo, freq_t *freq)
return -RIG_EIO;
}
f = ((unsigned int)au8BufIn[2] & 0xFF) | (((unsigned int)au8BufIn[3] & 0xFF) << 8) |
(((unsigned int)au8BufIn[4] & 0xFF) << 16) | (((unsigned int)au8BufIn[5] & 0xFF) << 24),
f = (au8BufIn[2] & 0xFF) | ((au8BufIn[3] & 0xFF) << 8) |
((au8BufIn[4] & 0xFF) << 16) | ((au8BufIn[5] & 0xFF) << 24),
*freq = f;
@ -471,10 +478,11 @@ int funcube_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
int funcube_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
char au8BufOut[64]; // endpoint size
char au8BufIn[64]; // endpoint size
int actual_length;
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
switch (level) {
case RIG_LEVEL_PREAMP:
@ -525,28 +533,28 @@ int funcube_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, (unsigned)au8BufOut[0] & 0xFF, (unsigned)au8BufOut[1] & 0xFF, (unsigned)au8BufOut[2] & 0xFF, (unsigned)au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = usb_interrupt_write(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_write failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
usb_strerror ());
libusb_error_name (ret));
}
ret = usb_interrupt_read(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret != sizeof(au8BufIn) )
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_read failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
usb_strerror ());
libusb_error_name (ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n",
__func__, (unsigned)au8BufIn[0] & 0xFF, (unsigned)au8BufIn[1] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
@ -558,10 +566,11 @@ int funcube_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
int funcube_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
char au8BufOut[64]; // endpoint size
char au8BufIn[64]; // endpoint size
int actual_length;
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
switch (level) {
case RIG_LEVEL_ATT:
@ -579,28 +588,28 @@ int funcube_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, (unsigned)au8BufOut[0] & 0xFF, (unsigned)au8BufOut[1] & 0xFF, (unsigned)au8BufOut[2] & 0xFF, (unsigned)au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = usb_interrupt_write(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_write failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
usb_strerror ());
libusb_error_name (ret));
}
ret = usb_interrupt_read(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret != sizeof(au8BufIn) )
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: usb_interrupt_read failed (%d): %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
usb_strerror ());
libusb_error_name (ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x\n",
__func__, (unsigned)au8BufIn[0] & 0xFF, (unsigned)au8BufIn[1] & 0xFF, (unsigned)au8BufIn[2] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
@ -658,4 +667,4 @@ int funcube_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return RIG_OK;
}
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_USB_H) */
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */

4
kit/kit.c
Wyświetl plik

@ -46,7 +46,7 @@ DECLARE_INITRIG_BACKEND(kit)
rig_register(&miniVNA_caps);
rig_register(&hiqsdr_caps);
#if (defined(HAVE_LIBUSB) && defined(HAVE_USB_H))
#if (defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H))
rig_register(&si570avrusb_caps);
rig_register(&si570picusb_caps);
rig_register(&si570peaberry1_caps);
@ -56,7 +56,7 @@ DECLARE_INITRIG_BACKEND(kit)
rig_register(&fasdr_caps);
rig_register(&funcubeplus_caps);
#endif
#if (defined(HAVE_LIBUSB) && defined(HAVE_USB_H)) || defined(_WIN32)
#if (defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)) || defined(_WIN32)
/* rigs with alternate DLL support on Win32 */
rig_register(&dwt_caps);
rig_register(&elektor507_caps);

148
kit/si570avrusb.c
Wyświetl plik

@ -41,10 +41,10 @@
/*
* Compile this model only if libusb is available
*/
#if defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#if defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#include <errno.h>
#include <usb.h>
#include <libusb.h>
#include "si570avrusb.h"
@ -146,7 +146,7 @@ const struct rig_caps si570avrusb_caps = {
.rig_model = RIG_MODEL_SI570AVRUSB,
.model_name = "Si570 AVR-USB",
.mfg_name = "SoftRock",
.version = "0.2",
.version = "0.3",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
@ -222,7 +222,7 @@ const struct rig_caps si570peaberry1_caps = {
.rig_model = RIG_MODEL_SI570PEABERRY1,
.model_name = "Si570 Peaberry V1",
.mfg_name = "AE9RB",
.version = "0.2",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
@ -379,7 +379,7 @@ const struct rig_caps si570picusb_caps = {
.rig_model = RIG_MODEL_SI570PICUSB,
.model_name = "Si570 PIC-USB",
.mfg_name = "KTH-SDR kit",
.version = "0.2",
.version = "0.3",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
@ -459,7 +459,7 @@ const struct rig_caps fasdr_caps = {
.rig_model = RIG_MODEL_FASDR,
.model_name = "FA-SDR",
.mfg_name = "Funkamatuer",
.version = "0.1",
.version = "0.2",
.copyright = "LGPL",
.status = RIG_STATUS_ALPHA,
.rig_type = RIG_FLAG_TUNER|RIG_FLAG_TRANSMITTER,
@ -527,6 +527,9 @@ const struct rig_caps fasdr_caps = {
};
// libusb control transfer request types
#define REQUEST_TYPE_IN (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN)
#define REQUEST_TYPE_OUT (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT)
/*
* AVR-USB model
@ -722,7 +725,7 @@ int fasdr_init(RIG *rig)
int fasdr_open(RIG *rig)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret,i;
double f;
unsigned char buffer[4];
@ -731,22 +734,24 @@ int fasdr_open(RIG *rig)
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __func__);
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_READ_VERSION, 0x0E00, 0,
(char *) &version, sizeof(version), rig->state.rigport.timeout);
(unsigned char *) &version, sizeof(version), rig->state.rigport.timeout);
if (ret != 2) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
// Does version needs endianess ordering ?
priv->version = version; // Unsure how to get firmware version
ret=usb_control_msg(udh,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
REQUEST_READ_EEPROM,F_CAL_STATUS,0,(char *) buffer,1,
ret=libusb_control_transfer(udh,
REQUEST_TYPE_IN,
REQUEST_READ_EEPROM,F_CAL_STATUS,0, buffer,1,
rig->state.rigport.timeout);
if( ret !=1)
return -RIG_EIO;
@ -754,9 +759,9 @@ int fasdr_open(RIG *rig)
rig_debug(RIG_DEBUG_VERBOSE,"%s: calibration byte %x", __func__,buffer[0]);
// ret = usb_control_msg(udh,
// USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
// REQUEST_READ_XTALL, 0, 0, (char *) &iFreq, sizeof(iFreq),
// ret = libusb_control_transfer(udh,
// REQUEST_TYPE_IN,
// REQUEST_READ_XTALL, 0, 0, (unsigned char *) &iFreq, sizeof(iFreq),
// rig->state.rigport.timeout);
if(buffer[0] == 0xFF )
{
@ -765,9 +770,9 @@ int fasdr_open(RIG *rig)
}
for(i=0; i<4; i++)
{
ret = usb_control_msg(udh,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
REQUEST_READ_EEPROM,F_CRYST + i, 0,(char *) &buffer[i], 1,
ret = libusb_control_transfer(udh,
REQUEST_TYPE_IN,
REQUEST_READ_EEPROM,F_CRYST + i, 0, &buffer[i], 1,
rig->state.rigport.timeout);
if (ret != 1)
return -RIG_EIO;
@ -866,15 +871,17 @@ int si570xxxusb_get_conf(RIG *rig, token_t token, char *val)
static int setBPF(RIG *rig, int enable)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
/* allocate enough space for up to 16 filters */
unsigned short FilterCrossOver[16];
int nBytes, i;
// Does FilterCrossOver needs endianess ordering ?
// first find out how may cross over points there are for the 1st bank, use 255 for index
nBytes = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
nBytes = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_FILTERS, 0, 255,
(char *) FilterCrossOver, sizeof(FilterCrossOver),
(unsigned char *) FilterCrossOver, sizeof(FilterCrossOver),
rig->state.rigport.timeout);
if (nBytes < 0)
@ -882,9 +889,9 @@ static int setBPF(RIG *rig, int enable)
if (nBytes > 2) {
nBytes = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
nBytes = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_FILTERS, enable, (nBytes / 2) - 1,
(char *) FilterCrossOver, sizeof(FilterCrossOver),
(unsigned char *) FilterCrossOver, sizeof(FilterCrossOver),
rig->state.rigport.timeout);
if (nBytes < 0)
return -RIG_EIO;
@ -903,7 +910,7 @@ static int setBPF(RIG *rig, int enable)
int si570xxxusb_open(RIG *rig)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
unsigned short version;
@ -913,14 +920,14 @@ int si570xxxusb_open(RIG *rig)
* Determine firmware
*/
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_READ_VERSION, 0x0E00, 0,
(char *) &version, sizeof(version), rig->state.rigport.timeout);
(unsigned char *) &version, sizeof(version), rig->state.rigport.timeout);
if (ret != 2) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -931,9 +938,9 @@ int si570xxxusb_open(RIG *rig)
rig_debug(RIG_DEBUG_VERBOSE,"%s: detected PE0FKO-like firmware\n", __func__);
ret = usb_control_msg(udh,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
REQUEST_READ_XTALL, 0, 0, (char *) &iFreq, sizeof(iFreq),
ret = libusb_control_transfer(udh,
REQUEST_TYPE_IN,
REQUEST_READ_XTALL, 0, 0, (unsigned char *) &iFreq, sizeof(iFreq),
rig->state.rigport.timeout);
if (ret != 4)
@ -955,32 +962,35 @@ int si570xxxusb_open(RIG *rig)
}
/* Rem: not reentrant */
const char * si570xxxusb_get_info(RIG *rig)
{
static char buf[64];
struct usb_dev_handle *udh = rig->state.rigport.handle;
struct usb_device *q = usb_device(udh);
libusb_device_handle *udh = rig->state.rigport.handle;
struct libusb_device_descriptor desc;
int ret;
unsigned short version;
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_READ_VERSION, 0x0E00, 0,
(char *) &version, sizeof(version), rig->state.rigport.timeout);
(unsigned char *) &version, sizeof(version), rig->state.rigport.timeout);
if (ret != 2) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return NULL;
}
sprintf(buf, "USB dev %04d, version: %d.%d", q->descriptor.bcdDevice,
/* always succeeds since libusb-1.0.16 */
libusb_get_device_descriptor(libusb_get_device(udh), &desc);
sprintf(buf, "USB dev %04d, version: %d.%d", desc.bcdDevice,
(version & 0xFF00) >> 8, version & 0xFF);
return buf;
}
static const int HS_DIV_MAP[] = {4,5,6,7,-1,9,-1,11};
static int calcDividers(RIG *rig, double f, struct solution* solution)
@ -1057,7 +1067,7 @@ static void setLongWord(uint32_t value, unsigned char * bytes)
int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
unsigned char buffer[6];
int request = REQUEST_SET_FREQ;
@ -1093,8 +1103,8 @@ int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
buffer[0] = theSolution.N1 / 4;
buffer[0] = buffer[0] + (theSolution.HS_DIV << 5);
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
request, value, index, (char*)buffer, sizeof(buffer), rig->state.rigport.timeout);
ret = libusb_control_transfer(udh, REQUEST_TYPE_OUT,
request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout);
rig_debug(RIG_DEBUG_TRACE, "%s: Freq=%.6f MHz, Real=%.6f MHz, buf=%02x%02x%02x%02x%02x%02x\n",
__func__, freq/1e6, f,
@ -1102,9 +1112,9 @@ int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
if (!ret) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -1117,7 +1127,7 @@ int si570xxxusb_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
int si570xxxusb_set_freq_by_value(RIG *rig, vfo_t vfo, freq_t freq)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
unsigned char buffer[4];
@ -1134,13 +1144,13 @@ int si570xxxusb_set_freq_by_value(RIG *rig, vfo_t vfo, freq_t freq)
__func__, freq/1e6, f,
buffer[0], buffer[1], buffer[2], buffer[3]);
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
request, value, index, (char*)buffer, sizeof(buffer), rig->state.rigport.timeout);
ret = libusb_control_transfer(udh, REQUEST_TYPE_OUT,
request, value, index, buffer, sizeof(buffer), rig->state.rigport.timeout);
if (!ret) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -1182,7 +1192,7 @@ static double calculateFrequency(RIG *rig, const unsigned char * buffer)
int si570xxxusb_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
unsigned char buffer[6];
int ret;
@ -1190,14 +1200,14 @@ int si570xxxusb_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
rig->caps->rig_model == RIG_MODEL_SI570PEABERRY1 || rig->caps->rig_model == RIG_MODEL_SI570PEABERRY2)
return si570xxxusb_get_freq_by_value(rig, vfo, freq);
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_READ_REGISTERS, priv->i2c_addr, 0,
(char *)buffer, sizeof(buffer), rig->state.rigport.timeout);
buffer, sizeof(buffer), rig->state.rigport.timeout);
if (ret <= 0) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -1209,18 +1219,20 @@ int si570xxxusb_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
int si570xxxusb_get_freq_by_value(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct si570xxxusb_priv_data *priv = (struct si570xxxusb_priv_data *)rig->state.priv;
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
uint32_t iFreq;
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
// Does iFreq needs endianess ordering ?
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_READ_FREQUENCY, 0, 0,
(char *)&iFreq, sizeof(iFreq), rig->state.rigport.timeout);
(unsigned char *)&iFreq, sizeof(iFreq), rig->state.rigport.timeout);
if (ret != 4) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
@ -1232,9 +1244,9 @@ int si570xxxusb_get_freq_by_value(RIG *rig, vfo_t vfo, freq_t *freq)
int si570xxxusb_set_ptt(RIG * rig, vfo_t vfo, ptt_t ptt)
{
struct usb_dev_handle *udh = rig->state.rigport.handle;
libusb_device_handle *udh = rig->state.rigport.handle;
int ret;
char buffer[3];
unsigned char buffer[3];
rig_debug(RIG_DEBUG_TRACE,"%s called: %d\n", __func__, ptt);
@ -1242,17 +1254,17 @@ int si570xxxusb_set_ptt(RIG * rig, vfo_t vfo, ptt_t ptt)
buffer[1] = 0;
buffer[2] = 0;
ret = usb_control_msg(udh, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
ret = libusb_control_transfer(udh, REQUEST_TYPE_IN,
REQUEST_SET_PTT, (ptt == RIG_PTT_ON) ? 1 : 0, 0,
(char *)buffer, sizeof(buffer), rig->state.rigport.timeout);
buffer, sizeof(buffer), rig->state.rigport.timeout);
if (ret < 0) {
rig_debug (RIG_DEBUG_ERR, "%s: usb_control_msg failed: %s\n",
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer failed: %s\n",
__func__,
usb_strerror ());
libusb_error_name (ret));
return -RIG_EIO;
}
return RIG_OK;
}
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_USB_H) */
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */

287
src/usb_port.c
Wyświetl plik

@ -40,7 +40,7 @@
/*
* Compile only if libusb is available
*/
#if defined(HAVE_LIBUSB) && defined(HAVE_USB_H)
#if defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H)
#include <stdlib.h>
@ -51,131 +51,108 @@
#include <sys/types.h>
#include <unistd.h>
#include <usb.h>
#include <libusb.h>
#include "usb_port.h"
/**
* \brief Get ASCII string from USB descriptor
* \param udh
* \param index
* \param langid
* \param buf
* \param buflen
* \return status/len
*/
static int usbGetStringAscii(usb_dev_handle *udh, int index, int langid, char *buf, int buflen)
{
char buffer[256];
int rval, i;
rval = usb_control_msg(udh, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
(USB_DT_STRING << 8) + index, langid, buffer, sizeof(buffer), 1000);
if(rval < 0)
return rval;
if(buffer[1] != USB_DT_STRING)
return 0;
if((unsigned char)buffer[0] < rval)
rval = (unsigned char)buffer[0];
rval /= 2;
/* lossy conversion to ISO Latin1 */
for(i=1;i<rval;i++) {
if(i > buflen) /* destination buffer overflow */
break;
buf[i - 1] = buffer[2 * i];
if(buffer[2 * i + 1] != 0) /* outside of ISO Latin1 range */
buf[i - 1] = '?';
}
buf[i - 1] = 0;
return i - 1;
}
/**
* \brief Find and open USB device
* \param port
* \return usb_handle
*/
static struct usb_dev_handle *find_and_open_device(const hamlib_port_t *port)
static libusb_device_handle *find_and_open_device(const hamlib_port_t *port)
{
struct usb_bus *bus;
struct usb_device *dev;
struct usb_dev_handle *udh;
libusb_device_handle *udh = NULL;
libusb_device *dev, **devs;
struct libusb_device_descriptor desc;
char string[256];
int len;
int i, r;
rig_debug(RIG_DEBUG_VERBOSE, "%s: looking for device %04x:%04x...",
__func__, port->parm.usb.vid, port->parm.usb.pid);
for (bus = usb_get_busses(); bus != NULL; bus = bus->next) {
for (dev = bus->devices; dev != NULL; dev = dev->next) {
r = libusb_get_device_list(NULL, &devs);
if (r < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: failed getting usb device list: %s",
__func__, libusb_error_name(r));
return NULL;
}
rig_debug(RIG_DEBUG_VERBOSE, " %04x:%04x,",
dev->descriptor.idVendor, dev->descriptor.idProduct);
if (dev->descriptor.idVendor == port->parm.usb.vid &&
dev->descriptor.idProduct == port->parm.usb.pid) {
for (i=0; (dev=devs[i]) != NULL; i++) {
/* we need to open the device in order to query strings */
udh = usb_open(dev);
if (!udh) {
rig_debug(RIG_DEBUG_WARN, "%s: Warning: Cannot open USB device: %s\n", __func__, usb_strerror());
libusb_get_device_descriptor(dev, &desc);
rig_debug(RIG_DEBUG_VERBOSE, " %04x:%04x,",
desc.idVendor, desc.idProduct);
if (desc.idVendor == port->parm.usb.vid &&
desc.idProduct == port->parm.usb.pid) {
/* we need to open the device in order to query strings */
r = libusb_open(dev, &udh);
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "%s: Warning: Cannot open USB device: %s\n",
__func__, libusb_error_name(r));
continue;
}
/* now check whether the names match: */
if (port->parm.usb.vendor_name) {
string[0] = '\0';
r = libusb_get_string_descriptor_ascii(udh, desc.iManufacturer, (unsigned char *)string, sizeof(string));
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query manufacturer for USB device: %s\n", libusb_error_name(r));
libusb_close(udh);
continue;
}
/* now check whether the names match: */
if (port->parm.usb.vendor_name) {
len = usbGetStringAscii(udh, dev->descriptor.iManufacturer, 0x0409, string, sizeof(string));
if (len < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query manufacturer for USB device: %s\n", usb_strerror());
usb_close(udh);
continue;
}
rig_debug(RIG_DEBUG_VERBOSE, " vendor >%s<", string);
rig_debug(RIG_DEBUG_VERBOSE, " vendor >%s<", string);
if (strcmp(string, port->parm.usb.vendor_name) != 0) {
rig_debug(RIG_DEBUG_WARN, "%s: Warning: Vendor name string mismatch!\n", __func__);
usb_close(udh);
continue;
}
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;
}
if (port->parm.usb.product) {
len = usbGetStringAscii(udh, dev->descriptor.iProduct, 0x0409, string, sizeof(string));
if (len < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query product for USB device: %s\n", usb_strerror());
usb_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__);
usb_close(udh);
continue;
}
}
}
rig_debug(RIG_DEBUG_VERBOSE, " -> found\n");
return udh;
}
if (port->parm.usb.product) {
string[0] = '\0';
r = libusb_get_string_descriptor_ascii(udh, desc.iProduct, (unsigned char *)string, sizeof(string));
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query product for USB device: %s\n", libusb_error_name(r));
libusb_close(udh);
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 */
}
@ -188,90 +165,97 @@ static struct usb_dev_handle *find_and_open_device(const hamlib_port_t *port)
*/
int usb_port_open(hamlib_port_t *port)
{
struct usb_dev_handle *udh;
static char pathname[FILPATHLEN];
libusb_device_handle *udh;
char *p, *q;
int r;
usb_init (); /* usb library init */
if (usb_find_busses () < 0)
rig_debug(RIG_DEBUG_ERR, "%s: usb_find_busses failed %s\n",
__func__, usb_strerror());
if (usb_find_devices() < 0)
rig_debug(RIG_DEBUG_ERR, "%s: usb_find_devices failed %s\n",
__func__, usb_strerror());
/* init defaut libusb-1.0 library contexte, if needed */
r = libusb_init (NULL);
if (r < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_init failed: %s\n",
__func__, libusb_error_name(r));
return -RIG_EIO;
}
p = port->pathname;
//libusb_set_debug(NULL, 1);
/* 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';
p = pathname;
q = strchr(p, ':');
if (q) {
if (q != p+1)
port->parm.usb.vid = strtol(q, NULL, 16);
p = q+1;
++q;
port->parm.usb.vid = strtol(q, NULL, 16);
p = q;
q = strchr(p, ':');
if (q) {
if (q != p+1)
port->parm.usb.pid = strtol(q, NULL, 16);
p = q+1;
++q;
port->parm.usb.pid = strtol(q, NULL, 16);
p = q;
q = strchr(p, ':');
if (q) {
if (q != p+1)
port->parm.usb.vendor_name = q;
p = q+1;
++q;
port->parm.usb.vendor_name = q;
p = q;
q = strchr(p, ':');
if (q) {
if (q != p+1)
port->parm.usb.product = q;
*q++ = '\0';
port->parm.usb.product = q;
}
}
}
}
udh = find_and_open_device(port);
if (udh == 0)
if (udh == 0) {
libusb_exit (NULL);
return -RIG_EIO;
}
#ifdef LIBUSB_HAS_GET_DRIVER_NP
/* Try to detach ftdi_sio kernel module
/* 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.
*/
char dname[32] = {0};
int retval = usb_get_driver_np(udh, port->parm.usb.iface, dname, 31);
if (!retval) {
/* Try to detach ftdi_sio kernel module
* Returns ENODATA if driver is not loaded.
* Don't check return value, let it fail later.
*/
usb_detach_kernel_driver_np(udh, port->parm.usb.iface);
}
#endif
(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 &&
usb_set_configuration (udh, port->parm.usb.conf) < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: usb_set_configuration: failed conf %d: %s\n",
__func__, port->parm.usb.conf, usb_strerror());
usb_close (udh);
(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);
if (usb_claim_interface (udh, port->parm.usb.iface) < 0) {
rig_debug(RIG_DEBUG_ERR, "%s:usb_claim_interface: failed interface %d: %s\n",
__func__,port->parm.usb.iface, usb_strerror());
usb_close (udh);
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 0
if (usb_set_altinterface (udh, port->parm.usb.alt) < 0) {
r = libusb_set_interface_alt_setting(udh, port->parm.usb.iface, port->parm.usb.alt);
if (r < 0) {
fprintf (stderr, "%s:usb_set_alt_interface: failed: %s\n", __func__,
usb_strerror());
usb_release_interface (udh, port->parm.usb.iface);
usb_close (udh);
libusb_error_name(r));
libusb_release_interface (udh, port->parm.usb.iface);
libusb_close (udh);
libusb_exit (NULL);
return -RIG_EIO;
}
#endif
@ -290,12 +274,15 @@ int usb_port_open(hamlib_port_t *port)
*/
int usb_port_close(hamlib_port_t *port)
{
struct usb_dev_handle *udh = port->handle;
libusb_device_handle *udh = port->handle;
usb_release_interface (udh, port->parm.usb.iface);
libusb_release_interface(udh, port->parm.usb.iface);
/* we're assuming that closing an interface automatically releases it. */
return usb_close (udh) == 0 ? RIG_OK : -RIG_EIO;
libusb_close(udh);
libusb_exit (NULL);
return RIG_OK;
}
#else
@ -310,6 +297,6 @@ int usb_port_close(hamlib_port_t *port)
return -RIG_ENAVAIL;
}
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_USB_H) */
#endif /* defined(HAVE_LIBUSB) && defined(HAVE_LIBUSB_H) */
/** @} */