diff --git a/CMakeLists.txt b/CMakeLists.txt
index 897610b61..23d4d8d25 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -329,3 +329,4 @@ qt5_use_modules(sdrangel Widgets Multimedia)
##############################################################################
add_subdirectory(plugins)
+add_subdirectory(fcdhid)
diff --git a/Readme.md b/Readme.md
index 199ad6a3b..0ac9a6c21 100644
--- a/Readme.md
+++ b/Readme.md
@@ -18,11 +18,16 @@ These plugins come from the parent code base and are still present in the source
- Channels:
- tetra
- Sample sources:
+ - fcd
- gnuradio
- osmosdr
- v4l-msi
- v4l-rtl
+Funcube Dongle (fcd)
+
+This is the old driver.
+
Gnuradio
The Gnuradio plugin source needs extra packages, including `liblog4cpp-dev libboost-system-dev gnuradio-dev libosmosdr-dev`
@@ -51,11 +56,11 @@ If you use your own location for libbladeRF install directory you need to specif
`-DLIBBLADERF_LIBRARIES=/opt/install/libbladeRF/lib/libbladeRF.so -DLIBBLADERF_INCLUDE_DIR=/opt/install/libbladeRF/include`
-Funcube Dongle
+FunCube Dongle
-Only the original Funcube Dongle Pro is supported. Funcube Dongle Pro+ will come later.
+At the moment only the Pro+ is supported with the plugin in fcdpro. This is a work in progress. Support of features is still limited (no IF gain, no filter settings).
-The interface is built in the software and do not require additional libraries other than USB support with libusb.
+The control interface is based on qthid and has been built in the software in the fcdhid library. You don't need anything else than libusb support.
RTL-SDR
diff --git a/fcdhid/CMakeLists.txt b/fcdhid/CMakeLists.txt
new file mode 100644
index 000000000..45fb37102
--- /dev/null
+++ b/fcdhid/CMakeLists.txt
@@ -0,0 +1,30 @@
+project(fcdhid)
+
+set(fcdhid_SOURCES
+ hid-libusb.c
+ fcdhid.c
+)
+
+set(fcdhid_HEADERS
+ fcdhid.h
+ hid-libusb.h
+ hidapi.h
+)
+
+include_directories(
+ .
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/include-gpl
+)
+
+#add_definitions(-DQT_PLUGIN)
+add_definitions(-DQT_SHARED)
+
+add_library(fcdhid SHARED
+ ${fcdhid_SOURCES}
+)
+
+target_link_libraries(fcdhid
+ ${LIBUSB_LIBRARIES}
+)
diff --git a/fcdhid/fcdhid.c b/fcdhid/fcdhid.c
new file mode 100644
index 000000000..e8f73b92e
--- /dev/null
+++ b/fcdhid/fcdhid.c
@@ -0,0 +1,927 @@
+/***************************************************************************
+ * This file is part of Qthid.
+ *
+ * Copyright (C) 2010 Howard Long, G6LVB
+ * CopyRight (C) 2011 Alexandru Csete, OZ9AEC
+ * Mario Lorenz, DL5MLO
+ *
+ * Qthid is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Qthid is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Qthid. If not, see .
+ *
+ ***************************************************************************/
+
+#include "fcdhid.h"
+
+/** \brief Open FCD device.
+ * \return Pointer to the FCD HID device or NULL if none found
+ *
+ * This function looks for FCD devices connected to the computer and
+ * opens the first one found.
+ */
+hid_device *fcdOpen(uint16_t usVID, uint16_t usPID, int whichdongle)
+{
+ struct hid_device_info *phdi=NULL;
+ hid_device *phd=NULL;
+ char *pszPath=NULL;
+
+ phdi = hid_enumerate(usVID, usPID);
+
+ int which = whichdongle;
+
+ while (phdi && which)
+ {
+ phdi=phdi->next;
+ which--;
+ }
+
+ if (phdi==NULL)
+ {
+ return NULL; // No FCD device found
+ }
+
+ pszPath=strdup(phdi->path);
+
+ if (pszPath==NULL)
+ {
+ return NULL;
+ }
+
+ hid_free_enumeration(phdi);
+ phdi=NULL;
+
+ if ((phd=hid_open_path(pszPath)) == NULL)
+ {
+ free(pszPath);
+ pszPath=NULL;
+
+ return NULL;
+ }
+
+ free(pszPath);
+ pszPath=NULL;
+
+ return phd;
+}
+
+
+/** \brief Close FCD HID device. */
+void fcdClose(hid_device *phd)
+{
+ hid_close(phd);
+}
+
+
+/** \brief Get FCD mode.
+ * \return The current FCD mode.
+ * \sa FCD_MODE_ENUM
+ */
+FCD_MODE_ENUM fcdGetMode(hid_device *phd)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+ FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_DEAD;
+ }*/
+
+ /* Send a BL Query Command */
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_QUERY;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ /* first check status bytes then check which mode */
+ if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
+
+ /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
+ if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
+ fcd_mode = FCD_MODE_BL;
+ }
+ /* In application mode we have "FCDAPP_18.06" where the number is the FW version */
+ else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
+ fcd_mode = FCD_MODE_APP;
+ }
+ /* either no FCD or firmware less than 18f */
+ else {
+ fcd_mode = FCD_MODE_NONE;
+ }
+ }
+
+ return fcd_mode;
+}
+
+
+/** \brief Get FCD firmware version as string.
+ * \param str The returned vesion number as a 0 terminated string (must be pre-allocated)
+ * \return The current FCD mode.
+ * \sa FCD_MODE_ENUM
+ */
+FCD_MODE_ENUM fcdGetFwVerStr(hid_device *phd, char *str)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+ FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ /* Send a BL Query Command */
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_QUERY;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ /* first check status bytes then check which mode */
+ if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
+
+ /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
+ if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
+ fcd_mode = FCD_MODE_BL;
+ }
+ /* In application mode we have "FCDAPP_18.06" where the number is the FW version */
+ else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
+ strncpy(str, (char *)(aucBufIn+9), 5);
+ str[5] = 0;
+ fcd_mode = FCD_MODE_APP;
+ }
+ /* either no FCD or firmware less than 18f */
+ else {
+ fcd_mode = FCD_MODE_NONE;
+ }
+ }
+
+ return fcd_mode;
+}
+
+
+/** \brief Get hardware and firmware dependent FCD capabilities.
+ * \param fcd_caps Pointer to an FCD_CAPS_STRUCT
+ * \return The current FCD mode.
+ *
+ * This function queries the FCD and extracts the hardware and firmware dependent
+ * capabilities. Currently these capabilities are:
+ * - Bias T (available since S/N TBD)
+ * - Cellular block (the certified version of the FCD)
+ * When the FCD is in application mode, the string returned by the query command is
+ * (starting at index 2):
+ * FCDAPP 18.08 Brd 1.0 No blk
+ * 1.0 means no bias tee, 1.1 means there is a bias tee
+ * 'No blk' means it is not cellular blocked.
+ *
+ * Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303
+ */
+FCD_MODE_ENUM fcdGetCaps(hid_device *phd, FCD_CAPS_STRUCT *fcd_caps)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+ FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
+
+ /* clear output buffer */
+ fcd_caps->hasBiasT = 0;
+ fcd_caps->hasCellBlock = 0;
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ /* Send a BL Query Command */
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_QUERY;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ /* first check status bytes then check which mode */
+ if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
+
+ /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
+ if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
+ fcd_mode = FCD_MODE_BL;
+ }
+ /* In application mode we have "FCDAPP 18.08 Brd 1.0 No blk" (see API doc) */
+ else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
+
+ /* Bias T */
+ fcd_caps->hasBiasT = (aucBufIn[21] == '1') ? 1 : 0;
+
+ /* cellular block */
+ if (strncmp((char *)(aucBufIn+23), "No blk", 6) == 0) {
+ fcd_caps->hasCellBlock = 0;
+ } else {
+ fcd_caps->hasCellBlock = 1;
+ }
+
+ fcd_mode = FCD_MODE_APP;
+ }
+ /* either no FCD or firmware less than 18f */
+ else {
+ fcd_mode = FCD_MODE_NONE;
+ }
+ }
+
+ return fcd_mode;
+}
+
+
+/** \brief Get hardware and firmware dependent FCD capabilities as string.
+ * \param caps_str Pointer to a pre-allocated string buffer where the info will be copied.
+ * \return The current FCD mode.
+ *
+ * This function queries the FCD and copies the returned string into the caps_str parameter.
+ * THe return buffer must be at least 28 characters.
+ * When the FCD is in application mode, the string returned by the query command is
+ * (starting at index 2):
+ * FCDAPP 18.08 Brd 1.0 No blk
+ * 1.0 means no bias tee, 1.1 means there is a bias tee
+ * 'No blk' means it is not cellular blocked.
+ *
+ * Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303
+ */
+FCD_MODE_ENUM fcdGetCapsStr(hid_device *phd, char *caps_str)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+ FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ /* Send a BL Query Command */
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_QUERY;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ /* first check status bytes then check which mode */
+ if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {
+
+ /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
+ if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
+ fcd_mode = FCD_MODE_BL;
+ }
+ /* In application mode we have "FCDAPP 18.08 Brd 1.0 No blk" (see API doc) */
+ else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
+
+ strncpy(caps_str, (char *)(aucBufIn+2), 27);
+ caps_str[27] = 0;
+
+ fcd_mode = FCD_MODE_APP;
+ }
+ /* either no FCD or firmware less than 18f */
+ else {
+ fcd_mode = FCD_MODE_NONE;
+ }
+ }
+
+ return fcd_mode;
+}
+
+
+
+/** \brief Reset FCD to bootloader mode.
+ * \return FCD_MODE_NONE
+ *
+ * This function is used to switch the FCD into bootloader mode in which
+ * various firmware operations can be performed.
+ */
+FCD_MODE_ENUM fcdAppReset(hid_device *phd)
+{
+ //hid_device *phd=NULL;
+ //unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Send an App reset command
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_APP_RESET;
+ hid_write(phd, aucBufOut, 65);
+
+ /** FIXME: hid_read() will occasionally hang due to a pthread_cond_wait() never returning.
+ It seems that the read_callback() in hid-libusb.c will never receive any
+ data during the reconfiguration. Since the same logic works in the native
+ windows application, it could be a libusb thing. Anyhow, since the value
+ returned by this function is not used, we may as well just skip the hid_read()
+ and return FME_NONE.
+ Correct switch from APP to BL mode can be observed in /var/log/messages (linux)
+ (when in bootloader mode the device version includes 'BL')
+ */
+ /*
+ memset(aucBufIn,0xCC,65); // Clear out the response buffer
+ hid_read(phd,aucBufIn,65);
+
+ if (aucBufIn[0]==FCDCMDAPPRESET && aucBufIn[1]==1)
+ {
+ FCDClose(phd);
+ phd=NULL;
+ return FME_APP;
+ }
+ FCDClose(phd);
+ phd=NULL;
+ return FME_BL;
+ */
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_NONE;
+
+}
+
+
+/** \brief Set FCD frequency with kHz resolution.
+ * \param nFreq The new frequency in kHz.
+ * \return The FCD mode.
+ *
+ * This function sets the frequency of the FCD with 1 kHz resolution. The parameter
+ * nFreq must already contain any necessary frequency correction.
+ *
+ * \sa fcdAppSetFreq
+ */
+FCD_MODE_ENUM fcdAppSetFreqkHz(hid_device *phd, int nFreq)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Send an App reset command
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_APP_SET_FREQ_KHZ;
+ aucBufOut[2] = (unsigned char)nFreq;
+ aucBufOut[3] = (unsigned char)(nFreq>>8);
+ aucBufOut[4] = (unsigned char)(nFreq>>16);
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_KHZ && aucBufIn[1]==1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+ }
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_BL;
+}
+
+
+/** \brief Set FCD frequency with Hz resolution.
+ * \param nFreq The new frequency in Hz.
+ * \return The FCD mode.
+ *
+ * This function sets the frequency of the FCD with 1 Hz resolution. The parameter
+ * nFreq must already contain any necessary frequency correction.
+ *
+ * \sa fcdAppSetFreq
+ */
+FCD_MODE_ENUM fcdAppSetFreq(hid_device *phd, int nFreq)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Send an App reset command
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_APP_SET_FREQ_HZ;
+ aucBufOut[2] = (unsigned char)nFreq;
+ aucBufOut[3] = (unsigned char)(nFreq>>8);
+ aucBufOut[4] = (unsigned char)(nFreq>>16);
+ aucBufOut[5] = (unsigned char)(nFreq>>24);
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_HZ && aucBufIn[1]==1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+ }
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_BL;
+}
+
+
+
+/** \brief Reset FCD to application mode.
+ * \return FCD_MODE_NONE
+ *
+ * This function is used to switch the FCD from bootloader mode
+ * into application mode.
+ */
+FCD_MODE_ENUM fcdBlReset(hid_device *phd)
+{
+ //hid_device *phd=NULL;
+ // unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Send an BL reset command
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_RESET;
+ hid_write(phd, aucBufOut, 65);
+
+ /** FIXME: hid_read() will hang due to a pthread_cond_wait() never returning.
+ It seems that the read_callback() in hid-libusb.c will never receive any
+ data during the reconfiguration. Since the same logic works in the native
+ windows application, it could be a libusb thing. Anyhow, since the value
+ returned by this function is not used, we may as well jsut skip the hid_read()
+ and return FME_NONE.
+ Correct switch from BL to APP mode can be observed in /var/log/messages (linux)
+ (when in bootloader mode the device version includes 'BL')
+ */
+ /*
+ memset(aucBufIn,0xCC,65); // Clear out the response buffer
+ hid_read(phd,aucBufIn,65);
+
+ if (aucBufIn[0]==FCDCMDBLRESET && aucBufIn[1]==1)
+ {
+ FCDClose(phd);
+ phd=NULL;
+ return FME_BL;
+ }
+ FCDClose(phd);
+ phd=NULL;
+ return FME_APP;
+ */
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_NONE;
+
+}
+
+
+/** \brief Erase firmware from FCD.
+ * \return The FCD mode
+ *
+ * This function deletes the firmware from the FCD. This is required
+ * before writing new firmware into the FCD.
+ *
+ * \sa fcdBlWriteFirmware
+ */
+FCD_MODE_ENUM fcdBlErase(hid_device *phd)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+
+ /*
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Send an App reset command
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_ERASE;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]==FCD_CMD_BL_ERASE && aucBufIn[1]==1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_BL;
+ }
+
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+}
+
+
+/** \brief Write new firmware into the FCD.
+ * \param pc Pointer to the new firmware data
+ * \param n64size The number of bytes in the data
+ * \return The FCD mode
+ *
+ * This function is used to upload new firmware into the FCD flash.
+ *
+ * \sa fcdBlErase
+ */
+FCD_MODE_ENUM fcdBlWriteFirmware(hid_device *phd, char *pc, int64_t n64Size)
+{
+ //hid_device *phd=NULL;
+ unsigned char aucBufIn[65];
+ unsigned char aucBufOut[65];
+ uint32_t u32AddrStart;
+ uint32_t u32AddrEnd;
+ uint32_t u32Addr;
+ BOOL bFinished=FALSE;
+
+ /*
+ phd = fcdOpen();
+
+ if (phd==NULL)
+ {
+ return FCD_MODE_NONE;
+ }*/
+
+ // Get the valid flash address range
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_GET_BYTE_ADDR_RANGE;
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]!=FCD_CMD_BL_GET_BYTE_ADDR_RANGE || aucBufIn[1]!=1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+ }
+
+ u32AddrStart=
+ aucBufIn[2]+
+ (((uint32_t)aucBufIn[3])<<8)+
+ (((uint32_t)aucBufIn[4])<<16)+
+ (((uint32_t)aucBufIn[5])<<24);
+ u32AddrEnd=
+ aucBufIn[6]+
+ (((uint32_t)aucBufIn[7])<<8)+
+ (((uint32_t)aucBufIn[8])<<16)+
+ (((uint32_t)aucBufIn[9])<<24);
+
+ // Set start address for flash
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_SET_BYTE_ADDR;
+ aucBufOut[2] = ((unsigned char)u32AddrStart);
+ aucBufOut[3] = ((unsigned char)(u32AddrStart>>8));
+ aucBufOut[4] = ((unsigned char)(u32AddrStart>>16));
+ aucBufOut[5] = ((unsigned char)(u32AddrStart>>24));
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]!=FCD_CMD_BL_SET_BYTE_ADDR || aucBufIn[1]!=1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+ }
+
+ // Write blocks
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_WRITE_FLASH_BLOCK;
+ for (u32Addr=u32AddrStart; u32Addr+47>8));
+ aucBufOut[4] = ((unsigned char)(u32AddrStart>>16));
+ aucBufOut[5] = ((unsigned char)(u32AddrStart>>24));
+ hid_write(phd, aucBufOut, 65);
+ memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
+ hid_read(phd, aucBufIn, 65);
+
+ if (aucBufIn[0]!=FCD_CMD_BL_SET_BYTE_ADDR || aucBufIn[1]!=1)
+ {
+ /*
+ fcdClose(phd);
+ phd = NULL;*/
+
+ return FCD_MODE_APP;
+ }
+
+ // Read blocks
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_READ_FLASH_BLOCK;
+ for (u32Addr=u32AddrStart; u32Addr+47.
+ *
+ ***************************************************************************/
+
+#ifndef _QTHID_H_
+#define _QTHID_H_
+
+#include
+#include
+#include
+#include
+#include "fcdhidcmd.h"
+#include "hidapi.h"
+
+#include
+
+#define FALSE 0
+#define TRUE 1
+typedef int BOOL;
+
+/** \brief FCD mode enumeration. */
+typedef enum {
+ FCD_MODE_NONE, /*!< No FCD detected. */
+ FCD_MODE_DEAD,
+ FCD_MODE_BL, /*!< FCD present in bootloader mode. */
+ FCD_MODE_APP /*!< FCD present in aplpication mode. */
+} FCD_MODE_ENUM; // The current mode of the FCD: none inserted, in bootloader mode or in normal application mode
+
+/** \brief FCD capabilities that depend on both hardware and firmware. */
+typedef struct {
+ unsigned char hasBiasT; /*!< Whether FCD has hardware bias tee (1=yes, 0=no) */
+ unsigned char hasCellBlock; /*!< Whether FCD has cellular blocking. */
+} FCD_CAPS_STRUCT;
+
+
+//#define FCDPP // FIXME: the Pro / Pro+ switch should be handled better than this!
+//const unsigned short _usVID=0x04D8; /*!< USB vendor ID. */
+//#ifdef FCDPP
+//const unsigned short _usPID=0xFB31; /*!< USB product ID. */
+//#else
+//const unsigned short _usPID=0xFB56; /*!< USB product ID. */
+//#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \brief Open FCD device.
+ * \return Pointer to the FCD HID device or NULL if none found
+ *
+ * This function looks for FCD devices connected to the computer and
+ * opens the first one found.
+ */
+hid_device *fcdOpen(uint16_t usVID, uint16_t usPID, int whichdongle);
+
+/** \brief Close FCD HID device. */
+void fcdClose(hid_device *phd);
+
+/** \brief Get FCD mode.
+ * \return The current FCD mode.
+ * \sa FCD_MODE_ENUM
+ */
+FCD_MODE_ENUM fcdGetMode(hid_device *phd);
+
+/** \brief Get FCD firmware version as string.
+ * \param str The returned vesion number as a 0 terminated string (must be pre-allocated)
+ * \return The current FCD mode.
+ * \sa FCD_MODE_ENUM
+ */
+FCD_MODE_ENUM fcdGetFwVerStr(hid_device *phd, char *str);
+
+/** \brief Get hardware and firmware dependent FCD capabilities.
+ * \param fcd_caps Pointer to an FCD_CAPS_STRUCT
+ * \return The current FCD mode.
+ *
+ * This function queries the FCD and extracts the hardware and firmware dependent
+ * capabilities. Currently these capabilities are:
+ * - Bias T (available since S/N TBD)
+ * - Cellular block (the certified version of the FCD)
+ * When the FCD is in application mode, the string returned by the query command is
+ * (starting at index 2):
+ * FCDAPP 18.08 Brd 1.0 No blk
+ * 1.0 means no bias tee, 1.1 means there is a bias tee
+ * 'No blk' means it is not cellular blocked.
+ *
+ * Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303
+ */
+FCD_MODE_ENUM fcdGetCaps(hid_device *phd, FCD_CAPS_STRUCT *fcd_caps);
+
+/** \brief Get hardware and firmware dependent FCD capabilities as string.
+ * \param caps_str Pointer to a pre-allocated string buffer where the info will be copied.
+ * \return The current FCD mode.
+ *
+ * This function queries the FCD and copies the returned string into the caps_str parameter.
+ * THe return buffer must be at least 28 characters.
+ * When the FCD is in application mode, the string returned by the query command is
+ * (starting at index 2):
+ * FCDAPP 18.08 Brd 1.0 No blk
+ * 1.0 means no bias tee, 1.1 means there is a bias tee
+ * 'No blk' means it is not cellular blocked.
+ *
+ * Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303
+ */
+FCD_MODE_ENUM fcdGetCapsStr(hid_device *phd, char *caps_str);
+
+/** \brief Reset FCD to bootloader mode.
+ * \return FCD_MODE_NONE
+ *
+ * This function is used to switch the FCD into bootloader mode in which
+ * various firmware operations can be performed.
+ */
+FCD_MODE_ENUM fcdAppReset(hid_device *phd);
+
+/** \brief Set FCD frequency with kHz resolution.
+ * \param nFreq The new frequency in kHz.
+ * \return The FCD mode.
+ *
+ * This function sets the frequency of the FCD with 1 kHz resolution. The parameter
+ * nFreq must already contain any necessary frequency correction.
+ *
+ * \sa fcdAppSetFreq
+ */
+FCD_MODE_ENUM fcdAppSetFreqkHz(hid_device *phd, int nFreq);
+
+/** \brief Set FCD frequency with Hz resolution.
+ * \param nFreq The new frequency in Hz.
+ * \return The FCD mode.
+ *
+ * This function sets the frequency of the FCD with 1 Hz resolution. The parameter
+ * nFreq must already contain any necessary frequency correction.
+ *
+ * \sa fcdAppSetFreq
+ */
+FCD_MODE_ENUM fcdAppSetFreq(hid_device *phd, int nFreq);
+
+/** \brief Reset FCD to application mode.
+ * \return FCD_MODE_NONE
+ *
+ * This function is used to switch the FCD from bootloader mode
+ * into application mode.
+ */
+FCD_MODE_ENUM fcdBlReset(hid_device *phd);
+
+/** \brief Erase firmware from FCD.
+ * \return The FCD mode
+ *
+ * This function deletes the firmware from the FCD. This is required
+ * before writing new firmware into the FCD.
+ *
+ * \sa fcdBlWriteFirmware
+ */
+FCD_MODE_ENUM fcdBlErase(hid_device *phd);
+
+/** \brief Write new firmware into the FCD.
+ * \param pc Pointer to the new firmware data
+ * \param n64size The number of bytes in the data
+ * \return The FCD mode
+ *
+ * This function is used to upload new firmware into the FCD flash.
+ *
+ * \sa fcdBlErase
+ */
+FCD_MODE_ENUM fcdBlWriteFirmware(hid_device *phd, char *pc, int64_t n64Size);
+
+/** \brief Verify firmware in FCd flash.
+ * \param pc Pointer to firmware data to verify against.
+ * \param n64Size Size of the data in pc.
+ * \return The FCD_MODE_BL if verification was succesful.
+ *
+ * This function verifies the firmware currently in the FCd flash against the firmware
+ * image pointed to by pc. The function return FCD_MODE_BL if the verification is OK and
+ * FCD_MODE_APP otherwise.
+ */
+FCD_MODE_ENUM fcdBlVerifyFirmware(hid_device *phd, char *pc, int64_t n64Size);
+
+/** \brief Write FCD parameter (e.g. gain or filter)
+ * \param u8Cmd The command byte / parameter ID, see FCD_CMD_APP_SET_*
+ * \param pu8Data The parameter value to be written
+ * \param u8len Length of pu8Data in bytes
+ * \return One of FCD_MODE_NONE, FCD_MODE_APP or FCD_MODE_BL (see description)
+ *
+ * This function can be used to set the value of a parameter in the FCD for which there is no
+ * high level API call. It gives access to the low level API of the FCD and the caller is expected
+ * to be aware of the various FCD commands, since they are required to be supplied as parameter
+ * to this function.
+ *
+ * The return value can be used to determine the success or failure of the command execution:
+ * - FCD_MODE_APP : Reply from FCD was as expected (nominal case).
+ * - FCD_MODE_BL : Reply from FCD was not as expected.
+ * - FCD_MODE_NONE : No FCD was found
+ */
+FCD_MODE_ENUM fcdAppSetParam(hid_device *phd, uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len);
+
+/** \brief Read FCD parameter (e.g. gain or filter)
+ * \param u8Cmd The command byte / parameter ID, see FCD_CMD_APP_GET_*
+ * \param pu8Data TPointer to buffer where the parameter value(s) will be written
+ * \param u8len Length of pu8Data in bytes
+ * \return One of FCD_MODE_NONE, FCD_MODE_APP or FCD_MODE_BL (see description)
+ *
+ * This function can be used to read the value of a parameter in the FCD for which there is no
+ * high level API call. It gives access to the low level API of the FCD and the caller is expected
+ * to be aware of the various FCD commands, since they are required to be supplied as parameter
+ * to this function.
+ *
+ * The return value can be used to determine the success or failure of the command execution:
+ * - FCD_MODE_APP : Reply from FCD was as expected (nominal case).
+ * - FCD_MODE_BL : Reply from FCD was not as expected.
+ * - FCD_MODE_NONE : No FCD was found
+ */
+FCD_MODE_ENUM fcdAppGetParam(hid_device *phd, uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _QTHID_H_
diff --git a/fcdhid/fcdhidcmd.h b/fcdhid/fcdhidcmd.h
new file mode 100644
index 000000000..b1aed1aab
--- /dev/null
+++ b/fcdhid/fcdhidcmd.h
@@ -0,0 +1,305 @@
+/***************************************************************************
+ * This file is part of Qthid.
+ *
+ * Copyright (C) 2010 Howard Long, G6LVB
+ * CopyRight (C) 2011 Alexandru Csete, OZ9AEC
+ * Mario Lorenz, DL5MLO
+ *
+ * Qthid is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Qthid is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Qthid. If not, see .
+ *
+ ***************************************************************************/
+#ifndef FCDHIDCMD_H
+#define FCDHIDCMD_H
+
+
+/* Commands applicable in bootloader mode */
+#define FCD_CMD_BL_QUERY 1 /*!< Returns string with "FCDAPP version". */
+#define FCD_CMD_BL_RESET 8 /*!< Reset to application mode. */
+#define FCD_CMD_BL_ERASE 24 /*!< Erase firmware from FCD flash. */
+#define FCD_CMD_BL_SET_BYTE_ADDR 25 /*!< TBD */
+#define FCD_CMD_BL_GET_BYTE_ADDR_RANGE 26 /*!< Get address range. */
+#define FCD_CMD_BL_WRITE_FLASH_BLOCK 27 /*!< Write flash block. */
+#define FCD_CMD_BL_READ_FLASH_BLOCK 28 /*!< Read flash block. */
+
+/* Commands applicable in application mode */
+#define FCD_CMD_APP_SET_FREQ_KHZ 100 /*!< Send with 3 byte unsigned little endian frequency in kHz. */
+#define FCD_CMD_APP_SET_FREQ_HZ 101 /*!< Send with 4 byte unsigned little endian frequency in Hz, returns with actual frequency set in Hz */
+#define FCD_CMD_APP_GET_FREQ_HZ 102 /*!< Returns 4 byte unsigned little endian frequency in Hz. */
+
+#define FCD_CMD_APP_GET_IF_RSSI 104 /*!< Supposed to return 1 byte unsigned IF RSSI (-35dBm=0, -10dBm=70) but it is not functional. */
+#define FCD_CMD_APP_GET_PLL_LOCK 105 /*!< Returns 1 bit, true if locked. */
+
+#define FCD_CMD_APP_SET_DC_CORR 106 /*!< Send with 2 byte unsigned I DC correction followed by 2 byte unsigned Q DC correction. 32768 is the default centre value. */
+#define FCD_CMD_APP_GET_DC_CORR 107 /*!< Returns 2 byte unsigned I DC correction followed by 2 byte unsigned Q DC correction. 32768 is the default centre value. */
+#define FCD_CMD_APP_SET_IQ_CORR 108 /*!< Send with 2 byte signed phase correction followed by 2 byte unsigned gain correction. 0 is the default centre value for phase correction, 32768 is the default centre value for gain. */
+#define FCD_CMD_APP_GET_IQ_CORR 109 /*!< Returns 2 byte signed phase correction followed by 2 byte unsigned gain correction. 0 is the default centre value for phase correction, 32768 is the default centre value for gain. */
+
+#define FCD_CMD_APP_SET_LNA_GAIN 110 /*!< Send a 1 byte value, see enums for reference. */
+#define FCD_CMD_APP_SET_LNA_ENHANCE 111
+#define FCD_CMD_APP_SET_BAND 112
+#define FCD_CMD_APP_SET_RF_FILTER 113
+#define FCD_CMD_APP_SET_MIXER_GAIN 114
+#define FCD_CMD_APP_SET_BIAS_CURRENT 115
+#define FCD_CMD_APP_SET_MIXER_FILTER 116
+#define FCD_CMD_APP_SET_IF_GAIN1 117
+#define FCD_CMD_APP_SET_IF_GAIN_MODE 118
+#define FCD_CMD_APP_SET_IF_RC_FILTER 119
+#define FCD_CMD_APP_SET_IF_GAIN2 120
+#define FCD_CMD_APP_SET_IF_GAIN3 121
+#define FCD_CMD_APP_SET_IF_FILTER 122
+#define FCD_CMD_APP_SET_IF_GAIN4 123
+#define FCD_CMD_APP_SET_IF_GAIN5 124
+#define FCD_CMD_APP_SET_IF_GAIN6 125
+#define FCD_CMD_APP_SET_BIAS_TEE 126 /*!< Bias T for ext LNA. Send with one byte: 1=ON, 0=OFF. */
+
+#define FCD_CMD_APP_GET_LNA_GAIN 150 // Retrieve a 1 byte value, see enums for reference
+#define FCD_CMD_APP_GET_LNA_ENHANCE 151
+#define FCD_CMD_APP_GET_BAND 152
+#define FCD_CMD_APP_GET_RF_FILTER 153
+#define FCD_CMD_APP_GET_MIXER_GAIN 154
+#define FCD_CMD_APP_GET_BIAS_CURRENT 155
+#define FCD_CMD_APP_GET_MIXER_FILTER 156
+#define FCD_CMD_APP_GET_IF_GAIN1 157
+#define FCD_CMD_APP_GET_IF_GAIN_MODE 158
+#define FCD_CMD_APP_GET_IF_RC_FILTER 159
+#define FCD_CMD_APP_GET_IF_GAIN2 160
+#define FCD_CMD_APP_GET_IF_GAIN3 161
+#define FCD_CMD_APP_GET_IF_FILTER 162
+#define FCD_CMD_APP_GET_IF_GAIN4 163
+#define FCD_CMD_APP_GET_IF_GAIN5 164
+#define FCD_CMD_APP_GET_IF_GAIN6 165
+#define FCD_CMD_APP_GET_BIAS_TEE 166 /*!< Bias T. 1=ON, 0=OFF. */
+
+#define FCD_CMD_APP_SEND_I2C_BYTE 200
+#define FCD_CMD_APP_RECV_I2C_BYTE 201
+
+#define FCD_CMD_APP_RESET 255 // Reset to bootloader
+
+
+typedef enum
+{
+ TLGE_N5_0DB=0,
+ TLGE_N2_5DB=1,
+ TLGE_P0_0DB=4,
+ TLGE_P2_5DB=5,
+ TLGE_P5_0DB=6,
+ TLGE_P7_5DB=7,
+ TLGE_P10_0DB=8,
+ TLGE_P12_5DB=9,
+ TLGE_P15_0DB=10,
+ TLGE_P17_5DB=11,
+ TLGE_P20_0DB=12,
+ TLGE_P25_0DB=13,
+ TLGE_P30_0DB=14
+} TUNER_LNA_GAIN_ENUM;
+
+typedef enum
+{
+ TLEE_OFF=0,
+ TLEE_0=1,
+ TLEE_1=3,
+ TLEE_2=5,
+ TLEE_3=7
+} TUNER_LNA_ENHANCE_ENUM;
+
+typedef enum
+{
+ TBE_VHF2,
+ TBE_VHF3,
+ TBE_UHF,
+ TBE_LBAND
+} TUNER_BAND_ENUM;
+
+typedef enum
+{
+ // Band 0, VHF II
+ TRFE_LPF268MHZ=0,
+ TRFE_LPF299MHZ=8,
+ // Band 1, VHF III
+ TRFE_LPF509MHZ=0,
+ TRFE_LPF656MHZ=8,
+ // Band 2, UHF
+ TRFE_BPF360MHZ=0,
+ TRFE_BPF380MHZ=1,
+ TRFE_BPF405MHZ=2,
+ TRFE_BPF425MHZ=3,
+ TRFE_BPF450MHZ=4,
+ TRFE_BPF475MHZ=5,
+ TRFE_BPF505MHZ=6,
+ TRFE_BPF540MHZ=7,
+ TRFE_BPF575MHZ=8,
+ TRFE_BPF615MHZ=9,
+ TRFE_BPF670MHZ=10,
+ TRFE_BPF720MHZ=11,
+ TRFE_BPF760MHZ=12,
+ TRFE_BPF840MHZ=13,
+ TRFE_BPF890MHZ=14,
+ TRFE_BPF970MHZ=15,
+ // Band 2, L band
+ TRFE_BPF1300MHZ=0,
+ TRFE_BPF1320MHZ=1,
+ TRFE_BPF1360MHZ=2,
+ TRFE_BPF1410MHZ=3,
+ TRFE_BPF1445MHZ=4,
+ TRFE_BPF1460MHZ=5,
+ TRFE_BPF1490MHZ=6,
+ TRFE_BPF1530MHZ=7,
+ TRFE_BPF1560MHZ=8,
+ TRFE_BPF1590MHZ=9,
+ TRFE_BPF1640MHZ=10,
+ TRFE_BPF1660MHZ=11,
+ TRFE_BPF1680MHZ=12,
+ TRFE_BPF1700MHZ=13,
+ TRFE_BPF1720MHZ=14,
+ TRFE_BPF1750MHZ=15
+} TUNER_RF_FILTER_ENUM;
+
+typedef enum
+{
+ TMGE_P4_0DB=0,
+ TMGE_P12_0DB=1
+} TUNER_MIXER_GAIN_ENUM;
+
+typedef enum
+{
+ TBCE_LBAND=0,
+ TBCE_1=1,
+ TBCE_2=2,
+ TBCE_VUBAND=3
+} TUNER_BIAS_CURRENT_ENUM;
+
+typedef enum
+{
+ TMFE_27_0MHZ=0,
+ TMFE_4_6MHZ=8,
+ TMFE_4_2MHZ=9,
+ TMFE_3_8MHZ=10,
+ TMFE_3_4MHZ=11,
+ TMFE_3_0MHZ=12,
+ TMFE_2_7MHZ=13,
+ TMFE_2_3MHZ=14,
+ TMFE_1_9MHZ=15
+} TUNER_MIXER_FILTER_ENUM;
+
+typedef enum
+{
+ TIG1E_N3_0DB=0,
+ TIG1E_P6_0DB=1
+} TUNER_IF_GAIN1_ENUM;
+
+typedef enum
+{
+ TIGME_LINEARITY=0,
+ TIGME_SENSITIVITY=1
+} TUNER_IF_GAIN_MODE_ENUM;
+
+typedef enum
+{
+ TIRFE_21_4MHZ=0,
+ TIRFE_21_0MHZ=1,
+ TIRFE_17_6MHZ=2,
+ TIRFE_14_7MHZ=3,
+ TIRFE_12_4MHZ=4,
+ TIRFE_10_6MHZ=5,
+ TIRFE_9_0MHZ=6,
+ TIRFE_7_7MHZ=7,
+ TIRFE_6_4MHZ=8,
+ TIRFE_5_3MHZ=9,
+ TIRFE_4_4MHZ=10,
+ TIRFE_3_4MHZ=11,
+ TIRFE_2_6MHZ=12,
+ TIRFE_1_8MHZ=13,
+ TIRFE_1_2MHZ=14,
+ TIRFE_1_0MHZ=15
+} TUNER_IF_RC_FILTER_ENUM;
+
+typedef enum
+{
+ TIG2E_P0_0DB=0,
+ TIG2E_P3_0DB=1,
+ TIG2E_P6_0DB=2,
+ TIG2E_P9_0DB=3
+} TUNER_IF_GAIN2_ENUM;
+
+typedef enum
+{
+ TIG3E_P0_0DB=0,
+ TIG3E_P3_0DB=1,
+ TIG3E_P6_0DB=2,
+ TIG3E_P9_0DB=3
+} TUNER_IF_GAIN3_ENUM;
+
+typedef enum
+{
+ TIG4E_P0_0DB=0,
+ TIG4E_P1_0DB=1,
+ TIG4E_P2_0DB=2
+} TUNER_IF_GAIN4_ENUM;
+
+typedef enum
+{
+ TIFE_5_50MHZ=0,
+ TIFE_5_30MHZ=1,
+ TIFE_5_00MHZ=2,
+ TIFE_4_80MHZ=3,
+ TIFE_4_60MHZ=4,
+ TIFE_4_40MHZ=5,
+ TIFE_4_30MHZ=6,
+ TIFE_4_10MHZ=7,
+ TIFE_3_90MHZ=8,
+ TIFE_3_80MHZ=9,
+ TIFE_3_70MHZ=10,
+ TIFE_3_60MHZ=11,
+ TIFE_3_40MHZ=12,
+ TIFE_3_30MHZ=13,
+ TIFE_3_20MHZ=14,
+ TIFE_3_10MHZ=15,
+ TIFE_3_00MHZ=16,
+ TIFE_2_95MHZ=17,
+ TIFE_2_90MHZ=18,
+ TIFE_2_80MHZ=19,
+ TIFE_2_75MHZ=20,
+ TIFE_2_70MHZ=21,
+ TIFE_2_60MHZ=22,
+ TIFE_2_55MHZ=23,
+ TIFE_2_50MHZ=24,
+ TIFE_2_45MHZ=25,
+ TIFE_2_40MHZ=26,
+ TIFE_2_30MHZ=27,
+ TIFE_2_28MHZ=28,
+ TIFE_2_24MHZ=29,
+ TIFE_2_20MHZ=30,
+ TIFE_2_15MHZ=31
+} TUNER_IF_FILTER_ENUM;
+
+typedef enum
+{
+ TIG5E_P3_0DB=0,
+ TIG5E_P6_0DB=1,
+ TIG5E_P9_0DB=2,
+ TIG5E_P12_0DB=3,
+ TIG5E_P15_0DB=4
+} TUNER_IF_GAIN5_ENUM;
+
+typedef enum
+{
+ TIG6E_P3_0DB=0,
+ TIG6E_P6_0DB=1,
+ TIG6E_P9_0DB=2,
+ TIG6E_P12_0DB=3,
+ TIG6E_P15_0DB=4
+} TUNER_IF_GAIN6_ENUM;
+
+
+#endif // FCDHIDCMD_H
diff --git a/fcdhid/hid-libusb.c b/fcdhid/hid-libusb.c
new file mode 100644
index 000000000..c90f71dc4
--- /dev/null
+++ b/fcdhid/hid-libusb.c
@@ -0,0 +1,1427 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2010
+ Libusb Version - 8/13/2010
+ FreeBSD Version - 11/1/2011
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+ http://github.com/signal11/hidapi .
+********************************************************/
+
+#define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */
+
+/* C */
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* Unix */
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* GNU / LibUSB */
+#include
+#include "iconv.h"
+
+#include "../fcdhid/hidapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DEBUG_PRINTF
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...) do {} while (0)
+#endif
+
+#ifndef __FreeBSD__
+#define DETACH_KERNEL_DRIVER
+#endif
+
+/* Uncomment to enable the retrieval of Usage and Usage Page in
+hid_enumerate(). Warning, on platforms different from FreeBSD
+this is very invasive as it requires the detach
+and re-attach of the kernel driver. See comments inside hid_enumerate().
+libusb HIDAPI programs are encouraged to use the interface number
+instead to differentiate between interfaces on a composite HID device. */
+/*#define INVASIVE_GET_USAGE*/
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+ uint8_t *data;
+ size_t len;
+ struct input_report *next;
+};
+
+
+struct hid_device_ {
+ /* Handle to the actual device. */
+ libusb_device_handle *device_handle;
+
+ /* Endpoint information */
+ int input_endpoint;
+ int output_endpoint;
+ int input_ep_max_packet_size;
+
+ /* The interface number of the HID */
+ int interface;
+
+ /* Indexes of Strings */
+ int manufacturer_index;
+ int product_index;
+ int serial_index;
+
+ /* Whether blocking reads are used */
+ int blocking; /* boolean */
+
+ /* Read thread objects */
+ pthread_t thread;
+ pthread_mutex_t mutex; /* Protects input_reports */
+ pthread_cond_t condition;
+ pthread_barrier_t barrier; /* Ensures correct startup sequence */
+ int shutdown_thread;
+ int cancelled;
+ struct libusb_transfer *transfer;
+
+ /* List of received input reports. */
+ struct input_report *input_reports;
+};
+
+static libusb_context *usb_context = NULL;
+
+uint16_t get_usb_code_for_current_locale(void);
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+static hid_device *new_hid_device(void)
+{
+ hid_device *dev = calloc(1, sizeof(hid_device));
+ dev->blocking = 1;
+
+ pthread_mutex_init(&dev->mutex, NULL);
+ pthread_cond_init(&dev->condition, NULL);
+ pthread_barrier_init(&dev->barrier, NULL, 2);
+
+ return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+ /* Clean up the thread objects */
+ pthread_barrier_destroy(&dev->barrier);
+ pthread_cond_destroy(&dev->condition);
+ pthread_mutex_destroy(&dev->mutex);
+
+ /* Free the device itself */
+ free(dev);
+}
+
+#if 0
+/*TODO: Implement this funciton on hidapi/libusb.. */
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+#ifdef INVASIVE_GET_USAGE
+/* Get bytes from a HID Report Descriptor.
+ Only call with a num_bytes of 0, 1, 2, or 4. */
+static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
+{
+ /* Return if there aren't enough bytes. */
+ if (cur + num_bytes >= len)
+ return 0;
+
+ if (num_bytes == 0)
+ return 0;
+ else if (num_bytes == 1) {
+ return rpt[cur+1];
+ }
+ else if (num_bytes == 2) {
+ return (rpt[cur+2] * 256 + rpt[cur+1]);
+ }
+ else if (num_bytes == 4) {
+ return (rpt[cur+4] * 0x01000000 +
+ rpt[cur+3] * 0x00010000 +
+ rpt[cur+2] * 0x00000100 +
+ rpt[cur+1] * 0x00000001);
+ }
+ else
+ return 0;
+}
+
+/* Retrieves the device's Usage Page and Usage from the report
+ descriptor. The algorithm is simple, as it just returns the first
+ Usage and Usage Page that it finds in the descriptor.
+ The return value is 0 on success and -1 on failure. */
+static int get_usage(uint8_t *report_descriptor, size_t size,
+ unsigned short *usage_page, unsigned short *usage)
+{
+ unsigned int i = 0;
+ int size_code;
+ int data_len, key_size;
+ int usage_found = 0, usage_page_found = 0;
+
+ while (i < size) {
+ int key = report_descriptor[i];
+ int key_cmd = key & 0xfc;
+
+ //printf("key: %02hhx\n", key);
+
+ if ((key & 0xf0) == 0xf0) {
+ /* This is a Long Item. The next byte contains the
+ length of the data section (value) for this key.
+ See the HID specification, version 1.11, section
+ 6.2.2.3, titled "Long Items." */
+ if (i+1 < size)
+ data_len = report_descriptor[i+1];
+ else
+ data_len = 0; /* malformed report */
+ key_size = 3;
+ }
+ else {
+ /* This is a Short Item. The bottom two bits of the
+ key contain the size code for the data section
+ (value) for this key. Refer to the HID
+ specification, version 1.11, section 6.2.2.2,
+ titled "Short Items." */
+ size_code = key & 0x3;
+ switch (size_code) {
+ case 0:
+ case 1:
+ case 2:
+ data_len = size_code;
+ break;
+ case 3:
+ data_len = 4;
+ break;
+ default:
+ /* Can't ever happen since size_code is & 0x3 */
+ data_len = 0;
+ break;
+ };
+ key_size = 1;
+ }
+
+ if (key_cmd == 0x4) {
+ *usage_page = get_bytes(report_descriptor, size, data_len, i);
+ usage_page_found = 1;
+ //printf("Usage Page: %x\n", (uint32_t)*usage_page);
+ }
+ if (key_cmd == 0x8) {
+ *usage = get_bytes(report_descriptor, size, data_len, i);
+ usage_found = 1;
+ //printf("Usage: %x\n", (uint32_t)*usage);
+ }
+
+ if (usage_page_found && usage_found)
+ return 0; /* success */
+
+ /* Skip over this key and it's associated data */
+ i += data_len + key_size;
+ }
+
+ return -1; /* failure */
+}
+#endif /* INVASIVE_GET_USAGE */
+
+#ifdef __FreeBSD__
+/* The FreeBSD version of libusb doesn't have this funciton. In mainline
+ libusb, it's inlined in libusb.h. This function will bear a striking
+ resemblence to that one, because there's about one way to code it.
+
+ Note that the data parameter is Unicode in UTF-16LE encoding.
+ Return value is the number of bytes in data, or LIBUSB_ERROR_*.
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
+ uint8_t descriptor_index, uint16_t lang_id,
+ unsigned char *data, int length)
+{
+ return libusb_control_transfer(dev,
+ LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
+ LIBUSB_REQUEST_GET_DESCRIPTOR,
+ (LIBUSB_DT_STRING << 8) | descriptor_index,
+ lang_id, data, (uint16_t) length, 1000);
+}
+
+#endif
+
+
+/* Get the first language the device says it reports. This comes from
+ USB string #0. */
+static uint16_t get_first_language(libusb_device_handle *dev)
+{
+ uint16_t buf[32];
+ int len;
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ 0x0, /* String ID */
+ 0x0, /* Language */
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 4)
+ return 0x0;
+
+ return buf[1]; /* First two bytes are len and descriptor type. */
+}
+
+static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
+{
+ uint16_t buf[32];
+ int len;
+ int i;
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ 0x0, /* String ID */
+ 0x0, /* Language */
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 4)
+ return 0x0;
+
+
+ len /= 2; /* language IDs are two-bytes each. */
+ /* Start at index 1 because there are two bytes of protocol data. */
+ for (i = 1; i < len; i++) {
+ if (buf[i] == lang)
+ return 1;
+ }
+
+ return 0;
+}
+
+
+/* This function returns a newly allocated wide string containing the USB
+ device string numbered by the index. The returned string must be freed
+ by using free(). */
+static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
+{
+ char buf[512];
+ int len;
+ wchar_t *str = NULL;
+ wchar_t wbuf[256];
+
+ /* iconv variables */
+ iconv_t ic;
+ size_t inbytes;
+ size_t outbytes;
+ size_t res;
+#ifdef __FreeBSD__
+ const char *inptr;
+#else
+ char *inptr;
+#endif
+ char *outptr;
+
+ /* Determine which language to use. */
+ uint16_t lang;
+ lang = get_usb_code_for_current_locale();
+ if (!is_language_supported(dev, lang))
+ lang = get_first_language(dev);
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ idx,
+ lang,
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 0)
+ return NULL;
+
+ /* buf does not need to be explicitly NULL-terminated because
+ it is only passed into iconv() which does not need it. */
+
+ /* Initialize iconv. */
+ ic = iconv_open("WCHAR_T", "UTF-16LE");
+ if (ic == (iconv_t)-1) {
+ LOG("iconv_open() failed\n");
+ return NULL;
+ }
+
+ /* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
+ Skip the first character (2-bytes). */
+ inptr = buf+2;
+ inbytes = len-2;
+ outptr = (char*) wbuf;
+ outbytes = sizeof(wbuf);
+ res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);
+ if (res == (size_t)-1) {
+ LOG("iconv() failed\n");
+ goto err;
+ }
+
+ /* Write the terminating NULL. */
+ wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
+ if (outbytes >= sizeof(wbuf[0]))
+ *((wchar_t*)outptr) = 0x00000000;
+
+ /* Allocate and copy the string. */
+ str = wcsdup(wbuf);
+
+err:
+ iconv_close(ic);
+
+ return str;
+}
+
+static char *make_path(libusb_device *dev, int interface_number)
+{
+ char str[64];
+ snprintf(str, sizeof(str), "%04x:%04x:%02x",
+ libusb_get_bus_number(dev),
+ libusb_get_device_address(dev),
+ interface_number);
+ str[sizeof(str)-1] = '\0';
+
+ return strdup(str);
+}
+
+
+int HID_API_EXPORT hid_init(void)
+{
+ if (!usb_context) {
+ const char *locale;
+
+ /* Init Libusb */
+ if (libusb_init(&usb_context))
+ return -1;
+
+ /* Set the locale if it's not set. */
+ locale = setlocale(LC_CTYPE, NULL);
+ if (!locale)
+ setlocale(LC_CTYPE, "");
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+ if (usb_context) {
+ libusb_exit(usb_context);
+ usb_context = NULL;
+ }
+
+ return 0;
+}
+
+struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+ libusb_device **devs;
+ libusb_device *dev;
+ libusb_device_handle *handle;
+ ssize_t num_devs;
+ int i = 0;
+
+ struct hid_device_info *root = NULL; /* return object */
+ struct hid_device_info *cur_dev = NULL;
+
+ if(hid_init() < 0)
+ return NULL;
+
+ num_devs = libusb_get_device_list(usb_context, &devs);
+ if (num_devs < 0)
+ return NULL;
+ while ((dev = devs[i++]) != NULL) {
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *conf_desc = NULL;
+ int j, k;
+ int interface_num = 0;
+
+ int res = libusb_get_device_descriptor(dev, &desc);
+ unsigned short dev_vid = desc.idVendor;
+ unsigned short dev_pid = desc.idProduct;
+
+ res = libusb_get_active_config_descriptor(dev, &conf_desc);
+ if (res < 0)
+ libusb_get_config_descriptor(dev, 0, &conf_desc);
+ if (conf_desc) {
+ for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+ const struct libusb_interface *intf = &conf_desc->interface[j];
+ for (k = 0; k < intf->num_altsetting; k++) {
+ const struct libusb_interface_descriptor *intf_desc;
+ intf_desc = &intf->altsetting[k];
+ if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+ interface_num = intf_desc->bInterfaceNumber;
+
+ /* Check the VID/PID against the arguments */
+ if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+ (product_id == 0x0 || product_id == dev_pid)) {
+ struct hid_device_info *tmp;
+
+ /* VID/PID match. Create the record. */
+ tmp = calloc(1, sizeof(struct hid_device_info));
+ if (cur_dev) {
+ cur_dev->next = tmp;
+ }
+ else {
+ root = tmp;
+ }
+ cur_dev = tmp;
+
+ /* Fill out the record */
+ cur_dev->next = NULL;
+ cur_dev->path = make_path(dev, interface_num);
+
+ res = libusb_open(dev, &handle);
+
+ if (res >= 0) {
+ /* Serial Number */
+ if (desc.iSerialNumber > 0)
+ cur_dev->serial_number =
+ get_usb_string(handle, desc.iSerialNumber);
+
+ /* Manufacturer and Product strings */
+ if (desc.iManufacturer > 0)
+ cur_dev->manufacturer_string =
+ get_usb_string(handle, desc.iManufacturer);
+ if (desc.iProduct > 0)
+ cur_dev->product_string =
+ get_usb_string(handle, desc.iProduct);
+
+#ifdef INVASIVE_GET_USAGE
+{
+ /*
+ This section is removed because it is too
+ invasive on the system. Getting a Usage Page
+ and Usage requires parsing the HID Report
+ descriptor. Getting a HID Report descriptor
+ involves claiming the interface. Claiming the
+ interface involves detaching the kernel driver.
+ Detaching the kernel driver is hard on the system
+ because it will unclaim interfaces (if another
+ app has them claimed) and the re-attachment of
+ the driver will sometimes change /dev entry names.
+ It is for these reasons that this section is
+ #if 0. For composite devices, use the interface
+ field in the hid_device_info struct to distinguish
+ between interfaces. */
+ unsigned char data[256];
+#ifdef DETACH_KERNEL_DRIVER
+ int detached = 0;
+ /* Usage Page and Usage */
+ res = libusb_kernel_driver_active(handle, interface_num);
+ if (res == 1) {
+ res = libusb_detach_kernel_driver(handle, interface_num);
+ if (res < 0)
+ LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");
+ else
+ detached = 1;
+ }
+#endif
+ res = libusb_claim_interface(handle, interface_num);
+ if (res >= 0) {
+ /* Get the HID Report Descriptor. */
+ res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
+ if (res >= 0) {
+ unsigned short page=0, usage=0;
+ /* Parse the usage and usage page
+ out of the report descriptor. */
+ get_usage(data, res, &page, &usage);
+ cur_dev->usage_page = page;
+ cur_dev->usage = usage;
+ }
+ else
+ LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
+
+ /* Release the interface */
+ res = libusb_release_interface(handle, interface_num);
+ if (res < 0)
+ LOG("Can't release the interface.\n");
+ }
+ else
+ LOG("Can't claim interface %d\n", res);
+#ifdef DETACH_KERNEL_DRIVER
+ /* Re-attach kernel driver if necessary. */
+ if (detached) {
+ res = libusb_attach_kernel_driver(handle, interface_num);
+ if (res < 0)
+ LOG("Couldn't re-attach kernel driver.\n");
+ }
+#endif
+}
+#endif /* INVASIVE_GET_USAGE */
+
+ libusb_close(handle);
+ }
+ /* VID/PID */
+ cur_dev->vendor_id = dev_vid;
+ cur_dev->product_id = dev_pid;
+
+ /* Release Number */
+ cur_dev->release_number = desc.bcdDevice;
+
+ /* Interface Number */
+ cur_dev->interface_number = interface_num;
+ }
+ }
+ } /* altsettings */
+ } /* interfaces */
+ libusb_free_config_descriptor(conf_desc);
+ }
+ }
+
+ libusb_free_device_list(devs, 1);
+
+ return root;
+}
+
+void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+ struct hid_device_info *d = devs;
+ while (d) {
+ struct hid_device_info *next = d->next;
+ free(d->path);
+ free(d->serial_number);
+ free(d->manufacturer_string);
+ free(d->product_string);
+ free(d);
+ d = next;
+ }
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+ struct hid_device_info *devs, *cur_dev;
+ const char *path_to_open = NULL;
+ hid_device *handle = NULL;
+
+ devs = hid_enumerate(vendor_id, product_id);
+ cur_dev = devs;
+ while (cur_dev) {
+ if (cur_dev->vendor_id == vendor_id &&
+ cur_dev->product_id == product_id) {
+ if (serial_number) {
+ if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+ path_to_open = cur_dev->path;
+ break;
+ }
+ }
+ else {
+ path_to_open = cur_dev->path;
+ break;
+ }
+ }
+ cur_dev = cur_dev->next;
+ }
+
+ if (path_to_open) {
+ /* Open the device */
+ handle = hid_open_path(path_to_open);
+ }
+
+ hid_free_enumeration(devs);
+
+ return handle;
+}
+
+static void read_callback(struct libusb_transfer *transfer)
+{
+ hid_device *dev = transfer->user_data;
+ int res;
+
+ if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+
+ struct input_report *rpt = malloc(sizeof(*rpt));
+ rpt->data = malloc(transfer->actual_length);
+ memcpy(rpt->data, transfer->buffer, transfer->actual_length);
+ rpt->len = transfer->actual_length;
+ rpt->next = NULL;
+
+ pthread_mutex_lock(&dev->mutex);
+
+ /* Attach the new report object to the end of the list. */
+ if (dev->input_reports == NULL) {
+ /* The list is empty. Put it at the root. */
+ dev->input_reports = rpt;
+ pthread_cond_signal(&dev->condition);
+ }
+ else {
+ /* Find the end of the list and attach. */
+ struct input_report *cur = dev->input_reports;
+ int num_queued = 0;
+ while (cur->next != NULL) {
+ cur = cur->next;
+ num_queued++;
+ }
+ cur->next = rpt;
+
+ /* Pop one off if we've reached 30 in the queue. This
+ way we don't grow forever if the user never reads
+ anything from the device. */
+ if (num_queued > 30) {
+ return_data(dev, NULL, 0);
+ }
+ }
+ pthread_mutex_unlock(&dev->mutex);
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ return;
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ return;
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
+ //LOG("Timeout (normal)\n");
+ }
+ else {
+ LOG("Unknown transfer code: %d\n", transfer->status);
+ }
+
+ /* Re-submit the transfer object. */
+ res = libusb_submit_transfer(transfer);
+ if (res != 0) {
+ LOG("Unable to submit URB. libusb error code: %d\n", res);
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ }
+}
+
+
+static void *read_thread(void *param)
+{
+ hid_device *dev = param;
+ unsigned char *buf;
+ const size_t length = dev->input_ep_max_packet_size;
+
+ /* Set up the transfer object. */
+ buf = malloc(length);
+ dev->transfer = libusb_alloc_transfer(0);
+ libusb_fill_interrupt_transfer(dev->transfer,
+ dev->device_handle,
+ dev->input_endpoint,
+ buf,
+ length,
+ read_callback,
+ dev,
+ 5000/*timeout*/);
+
+ /* Make the first submission. Further submissions are made
+ from inside read_callback() */
+ libusb_submit_transfer(dev->transfer);
+
+ /* Notify the main thread that the read thread is up and running. */
+ pthread_barrier_wait(&dev->barrier);
+
+ /* Handle all the events. */
+ while (!dev->shutdown_thread) {
+ int res;
+ res = libusb_handle_events(usb_context);
+ if (res < 0) {
+ /* There was an error. */
+ LOG("read_thread(): libusb reports error # %d\n", res);
+
+ /* Break out of this loop only on fatal error.*/
+ if (res != LIBUSB_ERROR_BUSY &&
+ res != LIBUSB_ERROR_TIMEOUT &&
+ res != LIBUSB_ERROR_OVERFLOW &&
+ res != LIBUSB_ERROR_INTERRUPTED) {
+ break;
+ }
+ }
+ }
+
+ /* Cancel any transfer that may be pending. This call will fail
+ if no transfers are pending, but that's OK. */
+ libusb_cancel_transfer(dev->transfer);
+
+ while (!dev->cancelled)
+ libusb_handle_events_completed(usb_context, &dev->cancelled);
+
+ /* Now that the read thread is stopping, Wake any threads which are
+ waiting on data (in hid_read_timeout()). Do this under a mutex to
+ make sure that a thread which is about to go to sleep waiting on
+ the condition acutally will go to sleep before the condition is
+ signaled. */
+ pthread_mutex_lock(&dev->mutex);
+ pthread_cond_broadcast(&dev->condition);
+ pthread_mutex_unlock(&dev->mutex);
+
+ /* The dev->transfer->buffer and dev->transfer objects are cleaned up
+ in hid_close(). They are not cleaned up here because this thread
+ could end either due to a disconnect or due to a user
+ call to hid_close(). In both cases the objects can be safely
+ cleaned up after the call to pthread_join() (in hid_close()), but
+ since hid_close() calls libusb_cancel_transfer(), on these objects,
+ they can not be cleaned up here. */
+
+ return NULL;
+}
+
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+ hid_device *dev = NULL;
+
+ libusb_device **devs;
+ libusb_device *usb_dev;
+ int res;
+ int d = 0;
+ int good_open = 0;
+
+ if(hid_init() < 0)
+ return NULL;
+
+ dev = new_hid_device();
+
+ libusb_get_device_list(usb_context, &devs);
+ while ((usb_dev = devs[d++]) != NULL) {
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *conf_desc = NULL;
+ int i,j,k;
+ libusb_get_device_descriptor(usb_dev, &desc);
+
+ if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)
+ continue;
+ for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+ const struct libusb_interface *intf = &conf_desc->interface[j];
+ for (k = 0; k < intf->num_altsetting; k++) {
+ const struct libusb_interface_descriptor *intf_desc;
+ intf_desc = &intf->altsetting[k];
+ if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+ char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);
+ if (!strcmp(dev_path, path)) {
+ /* Matched Paths. Open this device */
+
+ /* OPEN HERE */
+ res = libusb_open(usb_dev, &dev->device_handle);
+ if (res < 0) {
+ LOG("can't open device\n");
+ free(dev_path);
+ break;
+ }
+ good_open = 1;
+#ifdef DETACH_KERNEL_DRIVER
+ /* Detach the kernel driver, but only if the
+ device is managed by the kernel */
+ if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {
+ res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);
+ if (res < 0) {
+ libusb_close(dev->device_handle);
+ LOG("Unable to detach Kernel Driver\n");
+ free(dev_path);
+ good_open = 0;
+ break;
+ }
+ }
+#endif
+ res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);
+ if (res < 0) {
+ LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
+ free(dev_path);
+ libusb_close(dev->device_handle);
+ good_open = 0;
+ break;
+ }
+
+ /* Store off the string descriptor indexes */
+ dev->manufacturer_index = desc.iManufacturer;
+ dev->product_index = desc.iProduct;
+ dev->serial_index = desc.iSerialNumber;
+
+ /* Store off the interface number */
+ dev->interface = intf_desc->bInterfaceNumber;
+
+ /* Find the INPUT and OUTPUT endpoints. An
+ OUTPUT endpoint is not required. */
+ for (i = 0; i < intf_desc->bNumEndpoints; i++) {
+ const struct libusb_endpoint_descriptor *ep
+ = &intf_desc->endpoint[i];
+
+ /* Determine the type and direction of this
+ endpoint. */
+ int is_interrupt =
+ (ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+ == LIBUSB_TRANSFER_TYPE_INTERRUPT;
+ int is_output =
+ (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+ == LIBUSB_ENDPOINT_OUT;
+ int is_input =
+ (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+ == LIBUSB_ENDPOINT_IN;
+
+ /* Decide whether to use it for intput or output. */
+ if (dev->input_endpoint == 0 &&
+ is_interrupt && is_input) {
+ /* Use this endpoint for INPUT */
+ dev->input_endpoint = ep->bEndpointAddress;
+ dev->input_ep_max_packet_size = ep->wMaxPacketSize;
+ }
+ if (dev->output_endpoint == 0 &&
+ is_interrupt && is_output) {
+ /* Use this endpoint for OUTPUT */
+ dev->output_endpoint = ep->bEndpointAddress;
+ }
+ }
+
+ pthread_create(&dev->thread, NULL, read_thread, dev);
+
+ /* Wait here for the read thread to be initialized. */
+ pthread_barrier_wait(&dev->barrier);
+
+ }
+ free(dev_path);
+ }
+ }
+ }
+ libusb_free_config_descriptor(conf_desc);
+
+ }
+
+ libusb_free_device_list(devs, 1);
+
+ /* If we have a good handle, return it. */
+ if (good_open) {
+ return dev;
+ }
+ else {
+ /* Unable to open any devices. */
+ free_hid_device(dev);
+ return NULL;
+ }
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+ int res;
+ int report_number = data[0];
+ int skipped_report_id = 0;
+
+ if (report_number == 0x0) {
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+
+
+ if (dev->output_endpoint <= 0) {
+ /* No interrput out endpoint. Use the Control Endpoint */
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+ 0x09/*HID Set_Report*/,
+ (2/*HID output*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ length++;
+
+ return length;
+ }
+ else {
+ /* Use the interrupt out endpoint */
+ int actual_length;
+ res = libusb_interrupt_transfer(dev->device_handle,
+ dev->output_endpoint,
+ (unsigned char*)data,
+ length,
+ &actual_length, 1000);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ actual_length++;
+
+ return actual_length;
+ }
+}
+
+/* Helper function, to simplify hid_read().
+ This should be called with dev->mutex locked. */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+ /* Copy the data out of the linked list item (rpt) into the
+ return buffer (data), and delete the liked list item. */
+ struct input_report *rpt = dev->input_reports;
+ size_t len = (length < rpt->len)? length: rpt->len;
+ if (len > 0)
+ memcpy(data, rpt->data, len);
+ dev->input_reports = rpt->next;
+ free(rpt->data);
+ free(rpt);
+ return len;
+}
+
+static void cleanup_mutex(void *param)
+{
+ hid_device *dev = param;
+ pthread_mutex_unlock(&dev->mutex);
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+ int bytes_read = -1;
+
+#if 0
+ int transferred;
+ int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
+ LOG("transferred: %d\n", transferred);
+ return transferred;
+#endif
+
+ pthread_mutex_lock(&dev->mutex);
+ pthread_cleanup_push(&cleanup_mutex, dev);
+
+ /* There's an input report queued up. Return it. */
+ if (dev->input_reports) {
+ /* Return the first one */
+ bytes_read = return_data(dev, data, length);
+ goto ret;
+ }
+
+ if (dev->shutdown_thread) {
+ /* This means the device has been disconnected.
+ An error code of -1 should be returned. */
+ bytes_read = -1;
+ goto ret;
+ }
+
+ if (milliseconds == -1) {
+ /* Blocking */
+ while (!dev->input_reports && !dev->shutdown_thread) {
+ pthread_cond_wait(&dev->condition, &dev->mutex);
+ }
+ if (dev->input_reports) {
+ bytes_read = return_data(dev, data, length);
+ }
+ }
+ else if (milliseconds > 0) {
+ /* Non-blocking, but called with timeout. */
+ int res;
+ struct timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += milliseconds / 1000;
+ ts.tv_nsec += (milliseconds % 1000) * 1000000;
+ if (ts.tv_nsec >= 1000000000L) {
+ ts.tv_sec++;
+ ts.tv_nsec -= 1000000000L;
+ }
+
+ while (!dev->input_reports && !dev->shutdown_thread) {
+ res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
+ if (res == 0) {
+ if (dev->input_reports) {
+ bytes_read = return_data(dev, data, length);
+ break;
+ }
+
+ /* If we're here, there was a spurious wake up
+ or the read thread was shutdown. Run the
+ loop again (ie: don't break). */
+ }
+ else if (res == ETIMEDOUT) {
+ /* Timed out. */
+ bytes_read = 0;
+ break;
+ }
+ else {
+ /* Error. */
+ bytes_read = -1;
+ break;
+ }
+ }
+ }
+ else {
+ /* Purely non-blocking */
+ bytes_read = 0;
+ }
+
+ret:
+ pthread_mutex_unlock(&dev->mutex);
+ pthread_cleanup_pop(0);
+
+ return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+ return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+ dev->blocking = !nonblock;
+
+ return 0;
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+ int res = -1;
+ int skipped_report_id = 0;
+ int report_number = data[0];
+
+ if (report_number == 0x0) {
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+ 0x09/*HID set_report*/,
+ (3/*HID feature*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ /* Account for the report ID */
+ if (skipped_report_id)
+ length++;
+
+ return length;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+ int res = -1;
+ int skipped_report_id = 0;
+ int report_number = data[0];
+
+ if (report_number == 0x0) {
+ /* Offset the return buffer by 1, so that the report ID
+ will remain in byte 0. */
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,
+ 0x01/*HID get_report*/,
+ (3/*HID feature*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ res++;
+
+ return res;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+ if (!dev)
+ return;
+
+ /* Cause read_thread() to stop. */
+ dev->shutdown_thread = 1;
+ libusb_cancel_transfer(dev->transfer);
+
+ /* Wait for read_thread() to end. */
+ pthread_join(dev->thread, NULL);
+
+ /* Clean up the Transfer objects allocated in read_thread(). */
+ free(dev->transfer->buffer);
+ libusb_free_transfer(dev->transfer);
+
+ /* release the interface */
+ libusb_release_interface(dev->device_handle, dev->interface);
+
+ /* Close the handle */
+ libusb_close(dev->device_handle);
+
+ /* Clear out the queue of received reports. */
+ pthread_mutex_lock(&dev->mutex);
+ while (dev->input_reports) {
+ return_data(dev, NULL, 0);
+ }
+ pthread_mutex_unlock(&dev->mutex);
+
+ free_hid_device(dev);
+}
+
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->product_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+ wchar_t *str;
+
+ str = get_usb_string(dev->device_handle, string_index);
+ if (str) {
+ wcsncpy(string, str, maxlen);
+ string[maxlen-1] = L'\0';
+ free(str);
+ return 0;
+ }
+ else
+ return -1;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
+{
+ return NULL;
+}
+
+
+struct lang_map_entry {
+ const char *name;
+ const char *string_code;
+ uint16_t usb_code;
+};
+
+#define LANG(name,code,usb_code) { name, code, usb_code }
+static struct lang_map_entry lang_map[] = {
+ LANG("Afrikaans", "af", 0x0436),
+ LANG("Albanian", "sq", 0x041C),
+ LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),
+ LANG("Arabic - Bahrain", "ar_bh", 0x3C01),
+ LANG("Arabic - Algeria", "ar_dz", 0x1401),
+ LANG("Arabic - Egypt", "ar_eg", 0x0C01),
+ LANG("Arabic - Iraq", "ar_iq", 0x0801),
+ LANG("Arabic - Jordan", "ar_jo", 0x2C01),
+ LANG("Arabic - Kuwait", "ar_kw", 0x3401),
+ LANG("Arabic - Lebanon", "ar_lb", 0x3001),
+ LANG("Arabic - Libya", "ar_ly", 0x1001),
+ LANG("Arabic - Morocco", "ar_ma", 0x1801),
+ LANG("Arabic - Oman", "ar_om", 0x2001),
+ LANG("Arabic - Qatar", "ar_qa", 0x4001),
+ LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),
+ LANG("Arabic - Syria", "ar_sy", 0x2801),
+ LANG("Arabic - Tunisia", "ar_tn", 0x1C01),
+ LANG("Arabic - Yemen", "ar_ye", 0x2401),
+ LANG("Armenian", "hy", 0x042B),
+ LANG("Azeri - Latin", "az_az", 0x042C),
+ LANG("Azeri - Cyrillic", "az_az", 0x082C),
+ LANG("Basque", "eu", 0x042D),
+ LANG("Belarusian", "be", 0x0423),
+ LANG("Bulgarian", "bg", 0x0402),
+ LANG("Catalan", "ca", 0x0403),
+ LANG("Chinese - China", "zh_cn", 0x0804),
+ LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),
+ LANG("Chinese - Macau SAR", "zh_mo", 0x1404),
+ LANG("Chinese - Singapore", "zh_sg", 0x1004),
+ LANG("Chinese - Taiwan", "zh_tw", 0x0404),
+ LANG("Croatian", "hr", 0x041A),
+ LANG("Czech", "cs", 0x0405),
+ LANG("Danish", "da", 0x0406),
+ LANG("Dutch - Netherlands", "nl_nl", 0x0413),
+ LANG("Dutch - Belgium", "nl_be", 0x0813),
+ LANG("English - Australia", "en_au", 0x0C09),
+ LANG("English - Belize", "en_bz", 0x2809),
+ LANG("English - Canada", "en_ca", 0x1009),
+ LANG("English - Caribbean", "en_cb", 0x2409),
+ LANG("English - Ireland", "en_ie", 0x1809),
+ LANG("English - Jamaica", "en_jm", 0x2009),
+ LANG("English - New Zealand", "en_nz", 0x1409),
+ LANG("English - Phillippines", "en_ph", 0x3409),
+ LANG("English - Southern Africa", "en_za", 0x1C09),
+ LANG("English - Trinidad", "en_tt", 0x2C09),
+ LANG("English - Great Britain", "en_gb", 0x0809),
+ LANG("English - United States", "en_us", 0x0409),
+ LANG("Estonian", "et", 0x0425),
+ LANG("Farsi", "fa", 0x0429),
+ LANG("Finnish", "fi", 0x040B),
+ LANG("Faroese", "fo", 0x0438),
+ LANG("French - France", "fr_fr", 0x040C),
+ LANG("French - Belgium", "fr_be", 0x080C),
+ LANG("French - Canada", "fr_ca", 0x0C0C),
+ LANG("French - Luxembourg", "fr_lu", 0x140C),
+ LANG("French - Switzerland", "fr_ch", 0x100C),
+ LANG("Gaelic - Ireland", "gd_ie", 0x083C),
+ LANG("Gaelic - Scotland", "gd", 0x043C),
+ LANG("German - Germany", "de_de", 0x0407),
+ LANG("German - Austria", "de_at", 0x0C07),
+ LANG("German - Liechtenstein", "de_li", 0x1407),
+ LANG("German - Luxembourg", "de_lu", 0x1007),
+ LANG("German - Switzerland", "de_ch", 0x0807),
+ LANG("Greek", "el", 0x0408),
+ LANG("Hebrew", "he", 0x040D),
+ LANG("Hindi", "hi", 0x0439),
+ LANG("Hungarian", "hu", 0x040E),
+ LANG("Icelandic", "is", 0x040F),
+ LANG("Indonesian", "id", 0x0421),
+ LANG("Italian - Italy", "it_it", 0x0410),
+ LANG("Italian - Switzerland", "it_ch", 0x0810),
+ LANG("Japanese", "ja", 0x0411),
+ LANG("Korean", "ko", 0x0412),
+ LANG("Latvian", "lv", 0x0426),
+ LANG("Lithuanian", "lt", 0x0427),
+ LANG("F.Y.R.O. Macedonia", "mk", 0x042F),
+ LANG("Malay - Malaysia", "ms_my", 0x043E),
+ LANG("Malay – Brunei", "ms_bn", 0x083E),
+ LANG("Maltese", "mt", 0x043A),
+ LANG("Marathi", "mr", 0x044E),
+ LANG("Norwegian - Bokml", "no_no", 0x0414),
+ LANG("Norwegian - Nynorsk", "no_no", 0x0814),
+ LANG("Polish", "pl", 0x0415),
+ LANG("Portuguese - Portugal", "pt_pt", 0x0816),
+ LANG("Portuguese - Brazil", "pt_br", 0x0416),
+ LANG("Raeto-Romance", "rm", 0x0417),
+ LANG("Romanian - Romania", "ro", 0x0418),
+ LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),
+ LANG("Russian", "ru", 0x0419),
+ LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),
+ LANG("Sanskrit", "sa", 0x044F),
+ LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),
+ LANG("Serbian - Latin", "sr_sp", 0x081A),
+ LANG("Setsuana", "tn", 0x0432),
+ LANG("Slovenian", "sl", 0x0424),
+ LANG("Slovak", "sk", 0x041B),
+ LANG("Sorbian", "sb", 0x042E),
+ LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),
+ LANG("Spanish - Argentina", "es_ar", 0x2C0A),
+ LANG("Spanish - Bolivia", "es_bo", 0x400A),
+ LANG("Spanish - Chile", "es_cl", 0x340A),
+ LANG("Spanish - Colombia", "es_co", 0x240A),
+ LANG("Spanish - Costa Rica", "es_cr", 0x140A),
+ LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),
+ LANG("Spanish - Ecuador", "es_ec", 0x300A),
+ LANG("Spanish - Guatemala", "es_gt", 0x100A),
+ LANG("Spanish - Honduras", "es_hn", 0x480A),
+ LANG("Spanish - Mexico", "es_mx", 0x080A),
+ LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),
+ LANG("Spanish - Panama", "es_pa", 0x180A),
+ LANG("Spanish - Peru", "es_pe", 0x280A),
+ LANG("Spanish - Puerto Rico", "es_pr", 0x500A),
+ LANG("Spanish - Paraguay", "es_py", 0x3C0A),
+ LANG("Spanish - El Salvador", "es_sv", 0x440A),
+ LANG("Spanish - Uruguay", "es_uy", 0x380A),
+ LANG("Spanish - Venezuela", "es_ve", 0x200A),
+ LANG("Southern Sotho", "st", 0x0430),
+ LANG("Swahili", "sw", 0x0441),
+ LANG("Swedish - Sweden", "sv_se", 0x041D),
+ LANG("Swedish - Finland", "sv_fi", 0x081D),
+ LANG("Tamil", "ta", 0x0449),
+ LANG("Tatar", "tt", 0X0444),
+ LANG("Thai", "th", 0x041E),
+ LANG("Turkish", "tr", 0x041F),
+ LANG("Tsonga", "ts", 0x0431),
+ LANG("Ukrainian", "uk", 0x0422),
+ LANG("Urdu", "ur", 0x0420),
+ LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),
+ LANG("Uzbek – Latin", "uz_uz", 0x0443),
+ LANG("Vietnamese", "vi", 0x042A),
+ LANG("Xhosa", "xh", 0x0434),
+ LANG("Yiddish", "yi", 0x043D),
+ LANG("Zulu", "zu", 0x0435),
+ LANG(NULL, NULL, 0x0),
+};
+
+uint16_t get_usb_code_for_current_locale(void)
+{
+ char *locale;
+ char search_string[64];
+ char *ptr;
+ struct lang_map_entry *lang;
+
+ /* Get the current locale. */
+ locale = setlocale(0, NULL);
+ if (!locale)
+ return 0x0;
+
+ /* Make a copy of the current locale string. */
+ strncpy(search_string, locale, sizeof(search_string));
+ search_string[sizeof(search_string)-1] = '\0';
+
+ /* Chop off the encoding part, and make it lower case. */
+ ptr = search_string;
+ while (*ptr) {
+ *ptr = tolower(*ptr);
+ if (*ptr == '.') {
+ *ptr = '\0';
+ break;
+ }
+ ptr++;
+ }
+
+ /* Find the entry which matches the string code of our locale. */
+ lang = lang_map;
+ while (lang->string_code) {
+ if (!strcmp(lang->string_code, search_string)) {
+ return lang->usb_code;
+ }
+ lang++;
+ }
+
+ /* There was no match. Find with just the language only. */
+ /* Chop off the variant. Chop it off at the '_'. */
+ ptr = search_string;
+ while (*ptr) {
+ *ptr = tolower(*ptr);
+ if (*ptr == '_') {
+ *ptr = '\0';
+ break;
+ }
+ ptr++;
+ }
+
+#if 0 /* TODO: Do we need this? */
+ /* Find the entry which matches the string code of our language. */
+ lang = lang_map;
+ while (lang->string_code) {
+ if (!strcmp(lang->string_code, search_string)) {
+ return lang->usb_code;
+ }
+ lang++;
+ }
+#endif
+
+ /* Found nothing. */
+ return 0x0;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/fcdhid/hid-libusb.h b/fcdhid/hid-libusb.h
new file mode 100644
index 000000000..2296dc3a7
--- /dev/null
+++ b/fcdhid/hid-libusb.h
@@ -0,0 +1,1432 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2010
+ Libusb Version - 8/13/2010
+ FreeBSD Version - 11/1/2011
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+ http://github.com/signal11/hidapi .
+********************************************************/
+
+#ifndef _HIDAPI_H_
+#define _HIDAPI_H_
+
+//#define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */
+
+/* C */
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* Unix */
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* GNU / LibUSB */
+#include
+#include "iconv.h"
+
+#include "../fcdhid/hidapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DEBUG_PRINTF
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...) do {} while (0)
+#endif
+
+#ifndef __FreeBSD__
+#define DETACH_KERNEL_DRIVER
+#endif
+
+/* Uncomment to enable the retrieval of Usage and Usage Page in
+hid_enumerate(). Warning, on platforms different from FreeBSD
+this is very invasive as it requires the detach
+and re-attach of the kernel driver. See comments inside hid_enumerate().
+libusb HIDAPI programs are encouraged to use the interface number
+instead to differentiate between interfaces on a composite HID device. */
+/*#define INVASIVE_GET_USAGE*/
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+ uint8_t *data;
+ size_t len;
+ struct input_report *next;
+};
+
+
+struct hid_device_ {
+ /* Handle to the actual device. */
+ libusb_device_handle *device_handle;
+
+ /* Endpoint information */
+ int input_endpoint;
+ int output_endpoint;
+ int input_ep_max_packet_size;
+
+ /* The interface number of the HID */
+ int interface;
+
+ /* Indexes of Strings */
+ int manufacturer_index;
+ int product_index;
+ int serial_index;
+
+ /* Whether blocking reads are used */
+ int blocking; /* boolean */
+
+ /* Read thread objects */
+ pthread_t thread;
+ pthread_mutex_t mutex; /* Protects input_reports */
+ pthread_cond_t condition;
+ pthread_barrier_t barrier; /* Ensures correct startup sequence */
+ int shutdown_thread;
+ int cancelled;
+ struct libusb_transfer *transfer;
+
+ /* List of received input reports. */
+ struct input_report *input_reports;
+};
+
+static libusb_context *usb_context = NULL;
+
+uint16_t get_usb_code_for_current_locale(void);
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+static hid_device *new_hid_device(void)
+{
+ hid_device *dev = (hid_device *)calloc(1, sizeof(hid_device));
+ dev->blocking = 1;
+
+ pthread_mutex_init(&dev->mutex, NULL);
+ pthread_cond_init(&dev->condition, NULL);
+ pthread_barrier_init(&dev->barrier, NULL, 2);
+
+ return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+ /* Clean up the thread objects */
+ pthread_barrier_destroy(&dev->barrier);
+ pthread_cond_destroy(&dev->condition);
+ pthread_mutex_destroy(&dev->mutex);
+
+ /* Free the device itself */
+ free(dev);
+}
+
+#if 0
+/*TODO: Implement this funciton on hidapi/libusb.. */
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+#ifdef INVASIVE_GET_USAGE
+/* Get bytes from a HID Report Descriptor.
+ Only call with a num_bytes of 0, 1, 2, or 4. */
+static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
+{
+ /* Return if there aren't enough bytes. */
+ if (cur + num_bytes >= len)
+ return 0;
+
+ if (num_bytes == 0)
+ return 0;
+ else if (num_bytes == 1) {
+ return rpt[cur+1];
+ }
+ else if (num_bytes == 2) {
+ return (rpt[cur+2] * 256 + rpt[cur+1]);
+ }
+ else if (num_bytes == 4) {
+ return (rpt[cur+4] * 0x01000000 +
+ rpt[cur+3] * 0x00010000 +
+ rpt[cur+2] * 0x00000100 +
+ rpt[cur+1] * 0x00000001);
+ }
+ else
+ return 0;
+}
+
+/* Retrieves the device's Usage Page and Usage from the report
+ descriptor. The algorithm is simple, as it just returns the first
+ Usage and Usage Page that it finds in the descriptor.
+ The return value is 0 on success and -1 on failure. */
+static int get_usage(uint8_t *report_descriptor, size_t size,
+ unsigned short *usage_page, unsigned short *usage)
+{
+ unsigned int i = 0;
+ int size_code;
+ int data_len, key_size;
+ int usage_found = 0, usage_page_found = 0;
+
+ while (i < size) {
+ int key = report_descriptor[i];
+ int key_cmd = key & 0xfc;
+
+ //printf("key: %02hhx\n", key);
+
+ if ((key & 0xf0) == 0xf0) {
+ /* This is a Long Item. The next byte contains the
+ length of the data section (value) for this key.
+ See the HID specification, version 1.11, section
+ 6.2.2.3, titled "Long Items." */
+ if (i+1 < size)
+ data_len = report_descriptor[i+1];
+ else
+ data_len = 0; /* malformed report */
+ key_size = 3;
+ }
+ else {
+ /* This is a Short Item. The bottom two bits of the
+ key contain the size code for the data section
+ (value) for this key. Refer to the HID
+ specification, version 1.11, section 6.2.2.2,
+ titled "Short Items." */
+ size_code = key & 0x3;
+ switch (size_code) {
+ case 0:
+ case 1:
+ case 2:
+ data_len = size_code;
+ break;
+ case 3:
+ data_len = 4;
+ break;
+ default:
+ /* Can't ever happen since size_code is & 0x3 */
+ data_len = 0;
+ break;
+ };
+ key_size = 1;
+ }
+
+ if (key_cmd == 0x4) {
+ *usage_page = get_bytes(report_descriptor, size, data_len, i);
+ usage_page_found = 1;
+ //printf("Usage Page: %x\n", (uint32_t)*usage_page);
+ }
+ if (key_cmd == 0x8) {
+ *usage = get_bytes(report_descriptor, size, data_len, i);
+ usage_found = 1;
+ //printf("Usage: %x\n", (uint32_t)*usage);
+ }
+
+ if (usage_page_found && usage_found)
+ return 0; /* success */
+
+ /* Skip over this key and it's associated data */
+ i += data_len + key_size;
+ }
+
+ return -1; /* failure */
+}
+#endif /* INVASIVE_GET_USAGE */
+
+#ifdef __FreeBSD__
+/* The FreeBSD version of libusb doesn't have this funciton. In mainline
+ libusb, it's inlined in libusb.h. This function will bear a striking
+ resemblence to that one, because there's about one way to code it.
+
+ Note that the data parameter is Unicode in UTF-16LE encoding.
+ Return value is the number of bytes in data, or LIBUSB_ERROR_*.
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
+ uint8_t descriptor_index, uint16_t lang_id,
+ unsigned char *data, int length)
+{
+ return libusb_control_transfer(dev,
+ LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
+ LIBUSB_REQUEST_GET_DESCRIPTOR,
+ (LIBUSB_DT_STRING << 8) | descriptor_index,
+ lang_id, data, (uint16_t) length, 1000);
+}
+
+#endif
+
+
+/* Get the first language the device says it reports. This comes from
+ USB string #0. */
+static uint16_t get_first_language(libusb_device_handle *dev)
+{
+ uint16_t buf[32];
+ int len;
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ 0x0, /* String ID */
+ 0x0, /* Language */
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 4)
+ return 0x0;
+
+ return buf[1]; /* First two bytes are len and descriptor type. */
+}
+
+static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
+{
+ uint16_t buf[32];
+ int len;
+ int i;
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ 0x0, /* String ID */
+ 0x0, /* Language */
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 4)
+ return 0x0;
+
+
+ len /= 2; /* language IDs are two-bytes each. */
+ /* Start at index 1 because there are two bytes of protocol data. */
+ for (i = 1; i < len; i++) {
+ if (buf[i] == lang)
+ return 1;
+ }
+
+ return 0;
+}
+
+
+/* This function returns a newly allocated wide string containing the USB
+ device string numbered by the index. The returned string must be freed
+ by using free(). */
+static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
+{
+ char buf[512];
+ int len;
+ wchar_t *str = NULL;
+ wchar_t wbuf[256];
+
+ /* iconv variables */
+ iconv_t ic;
+ size_t inbytes;
+ size_t outbytes;
+ size_t res;
+#ifdef __FreeBSD__
+ const char *inptr;
+#else
+ char *inptr;
+#endif
+ char *outptr;
+
+ /* Determine which language to use. */
+ uint16_t lang;
+ lang = get_usb_code_for_current_locale();
+ if (!is_language_supported(dev, lang))
+ lang = get_first_language(dev);
+
+ /* Get the string from libusb. */
+ len = libusb_get_string_descriptor(dev,
+ idx,
+ lang,
+ (unsigned char*)buf,
+ sizeof(buf));
+ if (len < 0)
+ return NULL;
+
+ /* buf does not need to be explicitly NULL-terminated because
+ it is only passed into iconv() which does not need it. */
+
+ /* Initialize iconv. */
+ ic = iconv_open("WCHAR_T", "UTF-16LE");
+ if (ic == (iconv_t)-1) {
+ LOG("iconv_open() failed\n");
+ return NULL;
+ }
+
+ /* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
+ Skip the first character (2-bytes). */
+ inptr = buf+2;
+ inbytes = len-2;
+ outptr = (char*) wbuf;
+ outbytes = sizeof(wbuf);
+ res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);
+ if (res == (size_t)-1) {
+ LOG("iconv() failed\n");
+ goto err;
+ }
+
+ /* Write the terminating NULL. */
+ wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
+ if (outbytes >= sizeof(wbuf[0]))
+ *((wchar_t*)outptr) = 0x00000000;
+
+ /* Allocate and copy the string. */
+ str = wcsdup(wbuf);
+
+err:
+ iconv_close(ic);
+
+ return str;
+}
+
+static char *make_path(libusb_device *dev, int interface_number)
+{
+ char str[64];
+ snprintf(str, sizeof(str), "%04x:%04x:%02x",
+ libusb_get_bus_number(dev),
+ libusb_get_device_address(dev),
+ interface_number);
+ str[sizeof(str)-1] = '\0';
+
+ return strdup(str);
+}
+
+
+int HID_API_EXPORT hid_init(void)
+{
+ if (!usb_context) {
+ const char *locale;
+
+ /* Init Libusb */
+ if (libusb_init(&usb_context))
+ return -1;
+
+ /* Set the locale if it's not set. */
+ locale = setlocale(LC_CTYPE, NULL);
+ if (!locale)
+ setlocale(LC_CTYPE, "");
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+ if (usb_context) {
+ libusb_exit(usb_context);
+ usb_context = NULL;
+ }
+
+ return 0;
+}
+
+struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+ libusb_device **devs;
+ libusb_device *dev;
+ libusb_device_handle *handle;
+ ssize_t num_devs;
+ int i = 0;
+
+ struct hid_device_info *root = NULL; /* return object */
+ struct hid_device_info *cur_dev = NULL;
+
+ if(hid_init() < 0)
+ return NULL;
+
+ num_devs = libusb_get_device_list(usb_context, &devs);
+ if (num_devs < 0)
+ return NULL;
+ while ((dev = devs[i++]) != NULL) {
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *conf_desc = NULL;
+ int j, k;
+ int interface_num = 0;
+
+ int res = libusb_get_device_descriptor(dev, &desc);
+ unsigned short dev_vid = desc.idVendor;
+ unsigned short dev_pid = desc.idProduct;
+
+ res = libusb_get_active_config_descriptor(dev, &conf_desc);
+ if (res < 0)
+ libusb_get_config_descriptor(dev, 0, &conf_desc);
+ if (conf_desc) {
+ for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+ const struct libusb_interface *intf = &conf_desc->interface[j];
+ for (k = 0; k < intf->num_altsetting; k++) {
+ const struct libusb_interface_descriptor *intf_desc;
+ intf_desc = &intf->altsetting[k];
+ if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+ interface_num = intf_desc->bInterfaceNumber;
+
+ /* Check the VID/PID against the arguments */
+ if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+ (product_id == 0x0 || product_id == dev_pid)) {
+ struct hid_device_info *tmp;
+
+ /* VID/PID match. Create the record. */
+ tmp = (hid_device_info *)calloc(1, sizeof(struct hid_device_info));
+ if (cur_dev) {
+ cur_dev->next = tmp;
+ }
+ else {
+ root = tmp;
+ }
+ cur_dev = tmp;
+
+ /* Fill out the record */
+ cur_dev->next = NULL;
+ cur_dev->path = make_path(dev, interface_num);
+
+ res = libusb_open(dev, &handle);
+
+ if (res >= 0) {
+ /* Serial Number */
+ if (desc.iSerialNumber > 0)
+ cur_dev->serial_number =
+ get_usb_string(handle, desc.iSerialNumber);
+
+ /* Manufacturer and Product strings */
+ if (desc.iManufacturer > 0)
+ cur_dev->manufacturer_string =
+ get_usb_string(handle, desc.iManufacturer);
+ if (desc.iProduct > 0)
+ cur_dev->product_string =
+ get_usb_string(handle, desc.iProduct);
+
+#ifdef INVASIVE_GET_USAGE
+{
+ /*
+ This section is removed because it is too
+ invasive on the system. Getting a Usage Page
+ and Usage requires parsing the HID Report
+ descriptor. Getting a HID Report descriptor
+ involves claiming the interface. Claiming the
+ interface involves detaching the kernel driver.
+ Detaching the kernel driver is hard on the system
+ because it will unclaim interfaces (if another
+ app has them claimed) and the re-attachment of
+ the driver will sometimes change /dev entry names.
+ It is for these reasons that this section is
+ #if 0. For composite devices, use the interface
+ field in the hid_device_info struct to distinguish
+ between interfaces. */
+ unsigned char data[256];
+#ifdef DETACH_KERNEL_DRIVER
+ int detached = 0;
+ /* Usage Page and Usage */
+ res = libusb_kernel_driver_active(handle, interface_num);
+ if (res == 1) {
+ res = libusb_detach_kernel_driver(handle, interface_num);
+ if (res < 0)
+ LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");
+ else
+ detached = 1;
+ }
+#endif
+ res = libusb_claim_interface(handle, interface_num);
+ if (res >= 0) {
+ /* Get the HID Report Descriptor. */
+ res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
+ if (res >= 0) {
+ unsigned short page=0, usage=0;
+ /* Parse the usage and usage page
+ out of the report descriptor. */
+ get_usage(data, res, &page, &usage);
+ cur_dev->usage_page = page;
+ cur_dev->usage = usage;
+ }
+ else
+ LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
+
+ /* Release the interface */
+ res = libusb_release_interface(handle, interface_num);
+ if (res < 0)
+ LOG("Can't release the interface.\n");
+ }
+ else
+ LOG("Can't claim interface %d\n", res);
+#ifdef DETACH_KERNEL_DRIVER
+ /* Re-attach kernel driver if necessary. */
+ if (detached) {
+ res = libusb_attach_kernel_driver(handle, interface_num);
+ if (res < 0)
+ LOG("Couldn't re-attach kernel driver.\n");
+ }
+#endif
+}
+#endif /* INVASIVE_GET_USAGE */
+
+ libusb_close(handle);
+ }
+ /* VID/PID */
+ cur_dev->vendor_id = dev_vid;
+ cur_dev->product_id = dev_pid;
+
+ /* Release Number */
+ cur_dev->release_number = desc.bcdDevice;
+
+ /* Interface Number */
+ cur_dev->interface_number = interface_num;
+ }
+ }
+ } /* altsettings */
+ } /* interfaces */
+ libusb_free_config_descriptor(conf_desc);
+ }
+ }
+
+ libusb_free_device_list(devs, 1);
+
+ return root;
+}
+
+void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+ struct hid_device_info *d = devs;
+ while (d) {
+ struct hid_device_info *next = d->next;
+ free(d->path);
+ free(d->serial_number);
+ free(d->manufacturer_string);
+ free(d->product_string);
+ free(d);
+ d = next;
+ }
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+ struct hid_device_info *devs, *cur_dev;
+ const char *path_to_open = NULL;
+ hid_device *handle = NULL;
+
+ devs = hid_enumerate(vendor_id, product_id);
+ cur_dev = devs;
+ while (cur_dev) {
+ if (cur_dev->vendor_id == vendor_id &&
+ cur_dev->product_id == product_id) {
+ if (serial_number) {
+ if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+ path_to_open = cur_dev->path;
+ break;
+ }
+ }
+ else {
+ path_to_open = cur_dev->path;
+ break;
+ }
+ }
+ cur_dev = cur_dev->next;
+ }
+
+ if (path_to_open) {
+ /* Open the device */
+ handle = hid_open_path(path_to_open);
+ }
+
+ hid_free_enumeration(devs);
+
+ return handle;
+}
+
+static void read_callback(struct libusb_transfer *transfer)
+{
+ hid_device *dev = (hid_device *)transfer->user_data;
+ int res;
+
+ if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+
+ struct input_report *rpt = (input_report *)malloc(sizeof(*rpt));
+ rpt->data = (unsigned char *)malloc(transfer->actual_length);
+ memcpy(rpt->data, transfer->buffer, transfer->actual_length);
+ rpt->len = transfer->actual_length;
+ rpt->next = NULL;
+
+ pthread_mutex_lock(&dev->mutex);
+
+ /* Attach the new report object to the end of the list. */
+ if (dev->input_reports == NULL) {
+ /* The list is empty. Put it at the root. */
+ dev->input_reports = rpt;
+ pthread_cond_signal(&dev->condition);
+ }
+ else {
+ /* Find the end of the list and attach. */
+ struct input_report *cur = dev->input_reports;
+ int num_queued = 0;
+ while (cur->next != NULL) {
+ cur = cur->next;
+ num_queued++;
+ }
+ cur->next = rpt;
+
+ /* Pop one off if we've reached 30 in the queue. This
+ way we don't grow forever if the user never reads
+ anything from the device. */
+ if (num_queued > 30) {
+ return_data(dev, NULL, 0);
+ }
+ }
+ pthread_mutex_unlock(&dev->mutex);
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ return;
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ return;
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
+ //LOG("Timeout (normal)\n");
+ }
+ else {
+ LOG("Unknown transfer code: %d\n", transfer->status);
+ }
+
+ /* Re-submit the transfer object. */
+ res = libusb_submit_transfer(transfer);
+ if (res != 0) {
+ LOG("Unable to submit URB. libusb error code: %d\n", res);
+ dev->shutdown_thread = 1;
+ dev->cancelled = 1;
+ }
+}
+
+
+static void *read_thread(void *param)
+{
+ hid_device *dev = (hid_device *)param;
+ unsigned char *buf;
+ const size_t length = dev->input_ep_max_packet_size;
+
+ /* Set up the transfer object. */
+ buf = (unsigned char *)malloc(length);
+ dev->transfer = libusb_alloc_transfer(0);
+ libusb_fill_interrupt_transfer(dev->transfer,
+ dev->device_handle,
+ dev->input_endpoint,
+ buf,
+ length,
+ read_callback,
+ dev,
+ 5000/*timeout*/);
+
+ /* Make the first submission. Further submissions are made
+ from inside read_callback() */
+ libusb_submit_transfer(dev->transfer);
+
+ /* Notify the main thread that the read thread is up and running. */
+ pthread_barrier_wait(&dev->barrier);
+
+ /* Handle all the events. */
+ while (!dev->shutdown_thread) {
+ int res;
+ res = libusb_handle_events(usb_context);
+ if (res < 0) {
+ /* There was an error. */
+ LOG("read_thread(): libusb reports error # %d\n", res);
+
+ /* Break out of this loop only on fatal error.*/
+ if (res != LIBUSB_ERROR_BUSY &&
+ res != LIBUSB_ERROR_TIMEOUT &&
+ res != LIBUSB_ERROR_OVERFLOW &&
+ res != LIBUSB_ERROR_INTERRUPTED) {
+ break;
+ }
+ }
+ }
+
+ /* Cancel any transfer that may be pending. This call will fail
+ if no transfers are pending, but that's OK. */
+ libusb_cancel_transfer(dev->transfer);
+
+ while (!dev->cancelled)
+ libusb_handle_events_completed(usb_context, &dev->cancelled);
+
+ /* Now that the read thread is stopping, Wake any threads which are
+ waiting on data (in hid_read_timeout()). Do this under a mutex to
+ make sure that a thread which is about to go to sleep waiting on
+ the condition acutally will go to sleep before the condition is
+ signaled. */
+ pthread_mutex_lock(&dev->mutex);
+ pthread_cond_broadcast(&dev->condition);
+ pthread_mutex_unlock(&dev->mutex);
+
+ /* The dev->transfer->buffer and dev->transfer objects are cleaned up
+ in hid_close(). They are not cleaned up here because this thread
+ could end either due to a disconnect or due to a user
+ call to hid_close(). In both cases the objects can be safely
+ cleaned up after the call to pthread_join() (in hid_close()), but
+ since hid_close() calls libusb_cancel_transfer(), on these objects,
+ they can not be cleaned up here. */
+
+ return NULL;
+}
+
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+ hid_device *dev = NULL;
+
+ libusb_device **devs;
+ libusb_device *usb_dev;
+ int res;
+ int d = 0;
+ int good_open = 0;
+
+ if(hid_init() < 0)
+ return NULL;
+
+ dev = new_hid_device();
+
+ libusb_get_device_list(usb_context, &devs);
+ while ((usb_dev = devs[d++]) != NULL) {
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *conf_desc = NULL;
+ int i,j,k;
+ libusb_get_device_descriptor(usb_dev, &desc);
+
+ if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)
+ continue;
+ for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+ const struct libusb_interface *intf = &conf_desc->interface[j];
+ for (k = 0; k < intf->num_altsetting; k++) {
+ const struct libusb_interface_descriptor *intf_desc;
+ intf_desc = &intf->altsetting[k];
+ if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+ char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);
+ if (!strcmp(dev_path, path)) {
+ /* Matched Paths. Open this device */
+
+ /* OPEN HERE */
+ res = libusb_open(usb_dev, &dev->device_handle);
+ if (res < 0) {
+ LOG("can't open device\n");
+ free(dev_path);
+ break;
+ }
+ good_open = 1;
+#ifdef DETACH_KERNEL_DRIVER
+ /* Detach the kernel driver, but only if the
+ device is managed by the kernel */
+ if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {
+ res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);
+ if (res < 0) {
+ libusb_close(dev->device_handle);
+ LOG("Unable to detach Kernel Driver\n");
+ free(dev_path);
+ good_open = 0;
+ break;
+ }
+ }
+#endif
+ res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);
+ if (res < 0) {
+ LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
+ free(dev_path);
+ libusb_close(dev->device_handle);
+ good_open = 0;
+ break;
+ }
+
+ /* Store off the string descriptor indexes */
+ dev->manufacturer_index = desc.iManufacturer;
+ dev->product_index = desc.iProduct;
+ dev->serial_index = desc.iSerialNumber;
+
+ /* Store off the interface number */
+ dev->interface = intf_desc->bInterfaceNumber;
+
+ /* Find the INPUT and OUTPUT endpoints. An
+ OUTPUT endpoint is not required. */
+ for (i = 0; i < intf_desc->bNumEndpoints; i++) {
+ const struct libusb_endpoint_descriptor *ep
+ = &intf_desc->endpoint[i];
+
+ /* Determine the type and direction of this
+ endpoint. */
+ int is_interrupt =
+ (ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+ == LIBUSB_TRANSFER_TYPE_INTERRUPT;
+ int is_output =
+ (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+ == LIBUSB_ENDPOINT_OUT;
+ int is_input =
+ (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+ == LIBUSB_ENDPOINT_IN;
+
+ /* Decide whether to use it for intput or output. */
+ if (dev->input_endpoint == 0 &&
+ is_interrupt && is_input) {
+ /* Use this endpoint for INPUT */
+ dev->input_endpoint = ep->bEndpointAddress;
+ dev->input_ep_max_packet_size = ep->wMaxPacketSize;
+ }
+ if (dev->output_endpoint == 0 &&
+ is_interrupt && is_output) {
+ /* Use this endpoint for OUTPUT */
+ dev->output_endpoint = ep->bEndpointAddress;
+ }
+ }
+
+ pthread_create(&dev->thread, NULL, read_thread, dev);
+
+ /* Wait here for the read thread to be initialized. */
+ pthread_barrier_wait(&dev->barrier);
+
+ }
+ free(dev_path);
+ }
+ }
+ }
+ libusb_free_config_descriptor(conf_desc);
+
+ }
+
+ libusb_free_device_list(devs, 1);
+
+ /* If we have a good handle, return it. */
+ if (good_open) {
+ return dev;
+ }
+ else {
+ /* Unable to open any devices. */
+ free_hid_device(dev);
+ return NULL;
+ }
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+ int res;
+ int report_number = data[0];
+ int skipped_report_id = 0;
+
+ if (report_number == 0x0) {
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+
+
+ if (dev->output_endpoint <= 0) {
+ /* No interrput out endpoint. Use the Control Endpoint */
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+ 0x09/*HID Set_Report*/,
+ (2/*HID output*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ length++;
+
+ return length;
+ }
+ else {
+ /* Use the interrupt out endpoint */
+ int actual_length;
+ res = libusb_interrupt_transfer(dev->device_handle,
+ dev->output_endpoint,
+ (unsigned char*)data,
+ length,
+ &actual_length, 1000);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ actual_length++;
+
+ return actual_length;
+ }
+}
+
+/* Helper function, to simplify hid_read().
+ This should be called with dev->mutex locked. */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+ /* Copy the data out of the linked list item (rpt) into the
+ return buffer (data), and delete the liked list item. */
+ struct input_report *rpt = dev->input_reports;
+ size_t len = (length < rpt->len)? length: rpt->len;
+ if (len > 0)
+ memcpy(data, rpt->data, len);
+ dev->input_reports = rpt->next;
+ free(rpt->data);
+ free(rpt);
+ return len;
+}
+
+static void cleanup_mutex(void *param)
+{
+ hid_device *dev = (hid_device *)param;
+ pthread_mutex_unlock(&dev->mutex);
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+ int bytes_read = -1;
+
+#if 0
+ int transferred;
+ int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
+ LOG("transferred: %d\n", transferred);
+ return transferred;
+#endif
+
+ pthread_mutex_lock(&dev->mutex);
+ pthread_cleanup_push(&cleanup_mutex, dev);
+
+ /* There's an input report queued up. Return it. */
+ if (dev->input_reports) {
+ /* Return the first one */
+ bytes_read = return_data(dev, data, length);
+ goto ret;
+ }
+
+ if (dev->shutdown_thread) {
+ /* This means the device has been disconnected.
+ An error code of -1 should be returned. */
+ bytes_read = -1;
+ goto ret;
+ }
+
+ if (milliseconds == -1) {
+ /* Blocking */
+ while (!dev->input_reports && !dev->shutdown_thread) {
+ pthread_cond_wait(&dev->condition, &dev->mutex);
+ }
+ if (dev->input_reports) {
+ bytes_read = return_data(dev, data, length);
+ }
+ }
+ else if (milliseconds > 0) {
+ /* Non-blocking, but called with timeout. */
+ int res;
+ struct timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += milliseconds / 1000;
+ ts.tv_nsec += (milliseconds % 1000) * 1000000;
+ if (ts.tv_nsec >= 1000000000L) {
+ ts.tv_sec++;
+ ts.tv_nsec -= 1000000000L;
+ }
+
+ while (!dev->input_reports && !dev->shutdown_thread) {
+ res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
+ if (res == 0) {
+ if (dev->input_reports) {
+ bytes_read = return_data(dev, data, length);
+ break;
+ }
+
+ /* If we're here, there was a spurious wake up
+ or the read thread was shutdown. Run the
+ loop again (ie: don't break). */
+ }
+ else if (res == ETIMEDOUT) {
+ /* Timed out. */
+ bytes_read = 0;
+ break;
+ }
+ else {
+ /* Error. */
+ bytes_read = -1;
+ break;
+ }
+ }
+ }
+ else {
+ /* Purely non-blocking */
+ bytes_read = 0;
+ }
+
+ret:
+ pthread_mutex_unlock(&dev->mutex);
+ pthread_cleanup_pop(0);
+
+ return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+ return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+ dev->blocking = !nonblock;
+
+ return 0;
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+ int res = -1;
+ int skipped_report_id = 0;
+ int report_number = data[0];
+
+ if (report_number == 0x0) {
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+ 0x09/*HID set_report*/,
+ (3/*HID feature*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ /* Account for the report ID */
+ if (skipped_report_id)
+ length++;
+
+ return length;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+ int res = -1;
+ int skipped_report_id = 0;
+ int report_number = data[0];
+
+ if (report_number == 0x0) {
+ /* Offset the return buffer by 1, so that the report ID
+ will remain in byte 0. */
+ data++;
+ length--;
+ skipped_report_id = 1;
+ }
+ res = libusb_control_transfer(dev->device_handle,
+ LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,
+ 0x01/*HID get_report*/,
+ (3/*HID feature*/ << 8) | report_number,
+ dev->interface,
+ (unsigned char *)data, length,
+ 1000/*timeout millis*/);
+
+ if (res < 0)
+ return -1;
+
+ if (skipped_report_id)
+ res++;
+
+ return res;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+ if (!dev)
+ return;
+
+ /* Cause read_thread() to stop. */
+ dev->shutdown_thread = 1;
+ libusb_cancel_transfer(dev->transfer);
+
+ /* Wait for read_thread() to end. */
+ pthread_join(dev->thread, NULL);
+
+ /* Clean up the Transfer objects allocated in read_thread(). */
+ free(dev->transfer->buffer);
+ libusb_free_transfer(dev->transfer);
+
+ /* release the interface */
+ libusb_release_interface(dev->device_handle, dev->interface);
+
+ /* Close the handle */
+ libusb_close(dev->device_handle);
+
+ /* Clear out the queue of received reports. */
+ pthread_mutex_lock(&dev->mutex);
+ while (dev->input_reports) {
+ return_data(dev, NULL, 0);
+ }
+ pthread_mutex_unlock(&dev->mutex);
+
+ free_hid_device(dev);
+}
+
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->product_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+ wchar_t *str;
+
+ str = get_usb_string(dev->device_handle, string_index);
+ if (str) {
+ wcsncpy(string, str, maxlen);
+ string[maxlen-1] = L'\0';
+ free(str);
+ return 0;
+ }
+ else
+ return -1;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
+{
+ return NULL;
+}
+
+
+struct lang_map_entry {
+ const char *name;
+ const char *string_code;
+ uint16_t usb_code;
+};
+
+#define LANG(name,code,usb_code) { name, code, usb_code }
+static struct lang_map_entry lang_map[] = {
+ LANG("Afrikaans", "af", 0x0436),
+ LANG("Albanian", "sq", 0x041C),
+ LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),
+ LANG("Arabic - Bahrain", "ar_bh", 0x3C01),
+ LANG("Arabic - Algeria", "ar_dz", 0x1401),
+ LANG("Arabic - Egypt", "ar_eg", 0x0C01),
+ LANG("Arabic - Iraq", "ar_iq", 0x0801),
+ LANG("Arabic - Jordan", "ar_jo", 0x2C01),
+ LANG("Arabic - Kuwait", "ar_kw", 0x3401),
+ LANG("Arabic - Lebanon", "ar_lb", 0x3001),
+ LANG("Arabic - Libya", "ar_ly", 0x1001),
+ LANG("Arabic - Morocco", "ar_ma", 0x1801),
+ LANG("Arabic - Oman", "ar_om", 0x2001),
+ LANG("Arabic - Qatar", "ar_qa", 0x4001),
+ LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),
+ LANG("Arabic - Syria", "ar_sy", 0x2801),
+ LANG("Arabic - Tunisia", "ar_tn", 0x1C01),
+ LANG("Arabic - Yemen", "ar_ye", 0x2401),
+ LANG("Armenian", "hy", 0x042B),
+ LANG("Azeri - Latin", "az_az", 0x042C),
+ LANG("Azeri - Cyrillic", "az_az", 0x082C),
+ LANG("Basque", "eu", 0x042D),
+ LANG("Belarusian", "be", 0x0423),
+ LANG("Bulgarian", "bg", 0x0402),
+ LANG("Catalan", "ca", 0x0403),
+ LANG("Chinese - China", "zh_cn", 0x0804),
+ LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),
+ LANG("Chinese - Macau SAR", "zh_mo", 0x1404),
+ LANG("Chinese - Singapore", "zh_sg", 0x1004),
+ LANG("Chinese - Taiwan", "zh_tw", 0x0404),
+ LANG("Croatian", "hr", 0x041A),
+ LANG("Czech", "cs", 0x0405),
+ LANG("Danish", "da", 0x0406),
+ LANG("Dutch - Netherlands", "nl_nl", 0x0413),
+ LANG("Dutch - Belgium", "nl_be", 0x0813),
+ LANG("English - Australia", "en_au", 0x0C09),
+ LANG("English - Belize", "en_bz", 0x2809),
+ LANG("English - Canada", "en_ca", 0x1009),
+ LANG("English - Caribbean", "en_cb", 0x2409),
+ LANG("English - Ireland", "en_ie", 0x1809),
+ LANG("English - Jamaica", "en_jm", 0x2009),
+ LANG("English - New Zealand", "en_nz", 0x1409),
+ LANG("English - Phillippines", "en_ph", 0x3409),
+ LANG("English - Southern Africa", "en_za", 0x1C09),
+ LANG("English - Trinidad", "en_tt", 0x2C09),
+ LANG("English - Great Britain", "en_gb", 0x0809),
+ LANG("English - United States", "en_us", 0x0409),
+ LANG("Estonian", "et", 0x0425),
+ LANG("Farsi", "fa", 0x0429),
+ LANG("Finnish", "fi", 0x040B),
+ LANG("Faroese", "fo", 0x0438),
+ LANG("French - France", "fr_fr", 0x040C),
+ LANG("French - Belgium", "fr_be", 0x080C),
+ LANG("French - Canada", "fr_ca", 0x0C0C),
+ LANG("French - Luxembourg", "fr_lu", 0x140C),
+ LANG("French - Switzerland", "fr_ch", 0x100C),
+ LANG("Gaelic - Ireland", "gd_ie", 0x083C),
+ LANG("Gaelic - Scotland", "gd", 0x043C),
+ LANG("German - Germany", "de_de", 0x0407),
+ LANG("German - Austria", "de_at", 0x0C07),
+ LANG("German - Liechtenstein", "de_li", 0x1407),
+ LANG("German - Luxembourg", "de_lu", 0x1007),
+ LANG("German - Switzerland", "de_ch", 0x0807),
+ LANG("Greek", "el", 0x0408),
+ LANG("Hebrew", "he", 0x040D),
+ LANG("Hindi", "hi", 0x0439),
+ LANG("Hungarian", "hu", 0x040E),
+ LANG("Icelandic", "is", 0x040F),
+ LANG("Indonesian", "id", 0x0421),
+ LANG("Italian - Italy", "it_it", 0x0410),
+ LANG("Italian - Switzerland", "it_ch", 0x0810),
+ LANG("Japanese", "ja", 0x0411),
+ LANG("Korean", "ko", 0x0412),
+ LANG("Latvian", "lv", 0x0426),
+ LANG("Lithuanian", "lt", 0x0427),
+ LANG("F.Y.R.O. Macedonia", "mk", 0x042F),
+ LANG("Malay - Malaysia", "ms_my", 0x043E),
+ LANG("Malay – Brunei", "ms_bn", 0x083E),
+ LANG("Maltese", "mt", 0x043A),
+ LANG("Marathi", "mr", 0x044E),
+ LANG("Norwegian - Bokml", "no_no", 0x0414),
+ LANG("Norwegian - Nynorsk", "no_no", 0x0814),
+ LANG("Polish", "pl", 0x0415),
+ LANG("Portuguese - Portugal", "pt_pt", 0x0816),
+ LANG("Portuguese - Brazil", "pt_br", 0x0416),
+ LANG("Raeto-Romance", "rm", 0x0417),
+ LANG("Romanian - Romania", "ro", 0x0418),
+ LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),
+ LANG("Russian", "ru", 0x0419),
+ LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),
+ LANG("Sanskrit", "sa", 0x044F),
+ LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),
+ LANG("Serbian - Latin", "sr_sp", 0x081A),
+ LANG("Setsuana", "tn", 0x0432),
+ LANG("Slovenian", "sl", 0x0424),
+ LANG("Slovak", "sk", 0x041B),
+ LANG("Sorbian", "sb", 0x042E),
+ LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),
+ LANG("Spanish - Argentina", "es_ar", 0x2C0A),
+ LANG("Spanish - Bolivia", "es_bo", 0x400A),
+ LANG("Spanish - Chile", "es_cl", 0x340A),
+ LANG("Spanish - Colombia", "es_co", 0x240A),
+ LANG("Spanish - Costa Rica", "es_cr", 0x140A),
+ LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),
+ LANG("Spanish - Ecuador", "es_ec", 0x300A),
+ LANG("Spanish - Guatemala", "es_gt", 0x100A),
+ LANG("Spanish - Honduras", "es_hn", 0x480A),
+ LANG("Spanish - Mexico", "es_mx", 0x080A),
+ LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),
+ LANG("Spanish - Panama", "es_pa", 0x180A),
+ LANG("Spanish - Peru", "es_pe", 0x280A),
+ LANG("Spanish - Puerto Rico", "es_pr", 0x500A),
+ LANG("Spanish - Paraguay", "es_py", 0x3C0A),
+ LANG("Spanish - El Salvador", "es_sv", 0x440A),
+ LANG("Spanish - Uruguay", "es_uy", 0x380A),
+ LANG("Spanish - Venezuela", "es_ve", 0x200A),
+ LANG("Southern Sotho", "st", 0x0430),
+ LANG("Swahili", "sw", 0x0441),
+ LANG("Swedish - Sweden", "sv_se", 0x041D),
+ LANG("Swedish - Finland", "sv_fi", 0x081D),
+ LANG("Tamil", "ta", 0x0449),
+ LANG("Tatar", "tt", 0X0444),
+ LANG("Thai", "th", 0x041E),
+ LANG("Turkish", "tr", 0x041F),
+ LANG("Tsonga", "ts", 0x0431),
+ LANG("Ukrainian", "uk", 0x0422),
+ LANG("Urdu", "ur", 0x0420),
+ LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),
+ LANG("Uzbek – Latin", "uz_uz", 0x0443),
+ LANG("Vietnamese", "vi", 0x042A),
+ LANG("Xhosa", "xh", 0x0434),
+ LANG("Yiddish", "yi", 0x043D),
+ LANG("Zulu", "zu", 0x0435),
+ LANG(NULL, NULL, 0x0),
+};
+
+uint16_t get_usb_code_for_current_locale(void)
+{
+ char *locale;
+ char search_string[64];
+ char *ptr;
+ struct lang_map_entry *lang;
+
+ /* Get the current locale. */
+ locale = setlocale(0, NULL);
+ if (!locale)
+ return 0x0;
+
+ /* Make a copy of the current locale string. */
+ strncpy(search_string, locale, sizeof(search_string));
+ search_string[sizeof(search_string)-1] = '\0';
+
+ /* Chop off the encoding part, and make it lower case. */
+ ptr = search_string;
+ while (*ptr) {
+ *ptr = tolower(*ptr);
+ if (*ptr == '.') {
+ *ptr = '\0';
+ break;
+ }
+ ptr++;
+ }
+
+ /* Find the entry which matches the string code of our locale. */
+ lang = lang_map;
+ while (lang->string_code) {
+ if (!strcmp(lang->string_code, search_string)) {
+ return lang->usb_code;
+ }
+ lang++;
+ }
+
+ /* There was no match. Find with just the language only. */
+ /* Chop off the variant. Chop it off at the '_'. */
+ ptr = search_string;
+ while (*ptr) {
+ *ptr = tolower(*ptr);
+ if (*ptr == '_') {
+ *ptr = '\0';
+ break;
+ }
+ ptr++;
+ }
+
+#if 0 /* TODO: Do we need this? */
+ /* Find the entry which matches the string code of our language. */
+ lang = lang_map;
+ while (lang->string_code) {
+ if (!strcmp(lang->string_code, search_string)) {
+ return lang->usb_code;
+ }
+ lang++;
+ }
+#endif
+
+ /* Found nothing. */
+ return 0x0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _HIDAPI_H_
diff --git a/fcdhid/hidapi.h b/fcdhid/hidapi.h
new file mode 100644
index 000000000..5730f8676
--- /dev/null
+++ b/fcdhid/hidapi.h
@@ -0,0 +1,387 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+ http://github.com/signal11/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include
+
+#ifdef _WIN32
+ #define HID_API_EXPORT __declspec(dllexport)
+ #define HID_API_CALL
+#else
+ #define HID_API_EXPORT /**< API export macro */
+ #define HID_API_CALL /**< API call macro */
+#endif
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ struct hid_device_;
+ typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+ /** hidapi info structure */
+ struct hid_device_info {
+ /** Platform-specific device path */
+ char *path;
+ /** Device Vendor ID */
+ unsigned short vendor_id;
+ /** Device Product ID */
+ unsigned short product_id;
+ /** Serial Number */
+ wchar_t *serial_number;
+ /** Device Release Number in binary-coded decimal,
+ also known as Device Version Number */
+ unsigned short release_number;
+ /** Manufacturer String */
+ wchar_t *manufacturer_string;
+ /** Product string */
+ wchar_t *product_string;
+ /** Usage Page for this Device/Interface
+ (Windows/Mac only). */
+ unsigned short usage_page;
+ /** Usage for this Device/Interface
+ (Windows/Mac only).*/
+ unsigned short usage;
+ /** The USB interface which this logical device
+ represents. Valid on both Linux implementations
+ in all cases, and valid on the Windows implementation
+ only if the device contains more than one interface. */
+ int interface_number;
+
+ /** Pointer to the next device */
+ struct hid_device_info *next;
+ };
+
+
+ /** @brief Initialize the HIDAPI library.
+
+ This function initializes the HIDAPI library. Calling it is not
+ strictly necessary, as it will be called automatically by
+ hid_enumerate() and any of the hid_open_*() functions if it is
+ needed. This function should be called at the beginning of
+ execution however, if there is a chance of HIDAPI handles
+ being opened by different threads simultaneously.
+
+ @ingroup API
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+ /** @brief Finalize the HIDAPI library.
+
+ This function frees all of the static data associated with
+ HIDAPI. It should be called at the end of execution to avoid
+ memory leaks.
+
+ @ingroup API
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+ /** @brief Enumerate the HID Devices.
+
+ This function returns a linked list of all the HID devices
+ attached to the system which match vendor_id and product_id.
+ If @p vendor_id is set to 0 then any vendor matches.
+ If @p product_id is set to 0 then any product matches.
+ If @p vendor_id and @p product_id are both set to 0, then
+ all HID devices will be returned.
+
+ @ingroup API
+ @param vendor_id The Vendor ID (VID) of the types of device
+ to open.
+ @param product_id The Product ID (PID) of the types of
+ device to open.
+
+ @returns
+ This function returns a pointer to a linked list of type
+ struct #hid_device, containing information about the HID devices
+ attached to the system, or NULL in the case of failure. Free
+ this linked list by calling hid_free_enumeration().
+ */
+ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+ /** @brief Free an enumeration Linked List
+
+ This function frees a linked list created by hid_enumerate().
+
+ @ingroup API
+ @param devs Pointer to a list of struct_device returned from
+ hid_enumerate().
+ */
+ void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
+
+ /** @brief Open a HID device using a Vendor ID (VID), Product ID
+ (PID) and optionally a serial number.
+
+ If @p serial_number is NULL, the first device with the
+ specified VID and PID is opened.
+
+ @ingroup API
+ @param vendor_id The Vendor ID (VID) of the device to open.
+ @param product_id The Product ID (PID) of the device to open.
+ @param serial_number The Serial Number of the device to open
+ (Optionally NULL).
+
+ @returns
+ This function returns a pointer to a #hid_device object on
+ success or NULL on failure.
+ */
+ HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
+
+ /** @brief Open a HID device by its path name.
+
+ The path name be determined by calling hid_enumerate(), or a
+ platform-specific path name can be used (eg: /dev/hidraw0 on
+ Linux).
+
+ @ingroup API
+ @param path The path name of the device to open
+
+ @returns
+ This function returns a pointer to a #hid_device object on
+ success or NULL on failure.
+ */
+ HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);
+
+ /** @brief Write an Output report to a HID device.
+
+ The first byte of @p data[] must contain the Report ID. For
+ devices which only support a single report, this must be set
+ to 0x0. The remaining bytes contain the report data. Since
+ the Report ID is mandatory, calls to hid_write() will always
+ contain one more byte than the report contains. For example,
+ if a hid report is 16 bytes long, 17 bytes must be passed to
+ hid_write(), the Report ID (or 0x0, for devices with a
+ single report), followed by the report data (16 bytes). In
+ this example, the length passed in would be 17.
+
+ hid_write() will send the data on the first OUT endpoint, if
+ one exists. If it does not, it will send the data through
+ the Control Endpoint (Endpoint 0).
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param data The data to send, including the report number as
+ the first byte.
+ @param length The length in bytes of the data to send.
+
+ @returns
+ This function returns the actual number of bytes written and
+ -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
+
+ /** @brief Read an Input report from a HID device with timeout.
+
+ Input reports are returned
+ to the host through the INTERRUPT IN endpoint. The first byte will
+ contain the Report number if the device uses numbered reports.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param data A buffer to put the read data into.
+ @param length The number of bytes to read. For devices with
+ multiple reports, make sure to read an extra byte for
+ the report number.
+ @param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+ @returns
+ This function returns the actual number of bytes read and
+ -1 on error. If no packet was available to be read within
+ the timeout period, this function returns 0.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
+
+ /** @brief Read an Input report from a HID device.
+
+ Input reports are returned
+ to the host through the INTERRUPT IN endpoint. The first byte will
+ contain the Report number if the device uses numbered reports.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param data A buffer to put the read data into.
+ @param length The number of bytes to read. For devices with
+ multiple reports, make sure to read an extra byte for
+ the report number.
+
+ @returns
+ This function returns the actual number of bytes read and
+ -1 on error. If no packet was available to be read and
+ the handle is in non-blocking mode, this function returns 0.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
+
+ /** @brief Set the device handle to be non-blocking.
+
+ In non-blocking mode calls to hid_read() will return
+ immediately with a value of 0 if there is no data to be
+ read. In blocking mode, hid_read() will wait (block) until
+ there is data to read before returning.
+
+ Nonblocking can be turned on and off at any time.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param nonblock enable or not the nonblocking reads
+ - 1 to enable nonblocking
+ - 0 to disable nonblocking.
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
+
+ /** @brief Send a Feature report to the device.
+
+ Feature reports are sent over the Control endpoint as a
+ Set_Report transfer. The first byte of @p data[] must
+ contain the Report ID. For devices which only support a
+ single report, this must be set to 0x0. The remaining bytes
+ contain the report data. Since the Report ID is mandatory,
+ calls to hid_send_feature_report() will always contain one
+ more byte than the report contains. For example, if a hid
+ report is 16 bytes long, 17 bytes must be passed to
+ hid_send_feature_report(): the Report ID (or 0x0, for
+ devices which do not use numbered reports), followed by the
+ report data (16 bytes). In this example, the length passed
+ in would be 17.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param data The data to send, including the report number as
+ the first byte.
+ @param length The length in bytes of the data to send, including
+ the report number.
+
+ @returns
+ This function returns the actual number of bytes written and
+ -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
+
+ /** @brief Get a feature report from a HID device.
+
+ Make sure to set the first byte of @p data[] to the Report
+ ID of the report to be read. Make sure to allow space for
+ this extra byte in @p data[].
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param data A buffer to put the read data into, including
+ the Report ID. Set the first byte of @p data[] to the
+ Report ID of the report to be read.
+ @param length The number of bytes to read, including an
+ extra byte for the report ID. The buffer can be longer
+ than the actual report.
+
+ @returns
+ This function returns the number of bytes read and
+ -1 on error.
+ */
+ int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
+
+ /** @brief Close a HID device.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ */
+ void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
+
+ /** @brief Get The Manufacturer String from a HID device.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param string A wide string buffer to put the data into.
+ @param maxlen The length of the buffer in multiples of wchar_t.
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+ /** @brief Get The Product String from a HID device.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param string A wide string buffer to put the data into.
+ @param maxlen The length of the buffer in multiples of wchar_t.
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+ /** @brief Get The Serial Number String from a HID device.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param string A wide string buffer to put the data into.
+ @param maxlen The length of the buffer in multiples of wchar_t.
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+ /** @brief Get a string from a HID device, based on its string index.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+ @param string_index The index of the string to get.
+ @param string A wide string buffer to put the data into.
+ @param maxlen The length of the buffer in multiples of wchar_t.
+
+ @returns
+ This function returns 0 on success and -1 on error.
+ */
+ int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
+
+ /** @brief Get a string describing the last error which occurred.
+
+ @ingroup API
+ @param device A device handle returned from hid_open().
+
+ @returns
+ This function returns a string containing the last error
+ which occurred or NULL if none has occurred.
+ */
+ HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/plugins/samplesource/CMakeLists.txt b/plugins/samplesource/CMakeLists.txt
index 93d9d7c57..166353be6 100644
--- a/plugins/samplesource/CMakeLists.txt
+++ b/plugins/samplesource/CMakeLists.txt
@@ -18,7 +18,7 @@ if(LIBUSB_FOUND AND UNIX)
FIND_LIBRARY (LIBASOUND asound)
endif()
if(LIBASOUND AND ASOUNDH)
- add_subdirectory(fcd)
+ add_subdirectory(fcdpro)
endif()
find_package(LibRTLSDR)
diff --git a/plugins/samplesource/bladerf/CMakeLists.txt b/plugins/samplesource/bladerf/CMakeLists.txt
index 235490f22..dc59d6810 100644
--- a/plugins/samplesource/bladerf/CMakeLists.txt
+++ b/plugins/samplesource/bladerf/CMakeLists.txt
@@ -25,7 +25,7 @@ include_directories(
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_SOURCE_DIR}/include
${CMAKE_SOURCE_DIR}/include-gpl
- ${LIBRTLSDR_INCLUDE_DIR}
+ ${LIBBLADERF_INCLUDE_DIR}
)
#include(${QT_USE_FILE})
diff --git a/plugins/samplesource/fcd/fcdinput.cpp b/plugins/samplesource/fcd/fcdinput.cpp
index 4e23df0b5..04616aa18 100644
--- a/plugins/samplesource/fcd/fcdinput.cpp
+++ b/plugins/samplesource/fcd/fcdinput.cpp
@@ -171,7 +171,7 @@ const QString& FCDInput::getDeviceDescription() const
int FCDInput::getSampleRate() const
{
- return 96000;
+ return 192000;
}
quint64 FCDInput::getCenterFrequency() const
@@ -220,7 +220,7 @@ void FCDInput::applySettings(const Settings& settings, bool force)
if (signalChange)
{
- DSPSignalNotification *notif = new DSPSignalNotification(96000, m_settings.centerFrequency);
+ DSPSignalNotification *notif = new DSPSignalNotification(192000, m_settings.centerFrequency);
getOutputMessageQueue()->push(notif);
}
}
diff --git a/plugins/samplesource/fcd/fcdthread.cpp b/plugins/samplesource/fcd/fcdthread.cpp
index 95f87ab0e..1d6b88fa3 100644
--- a/plugins/samplesource/fcd/fcdthread.cpp
+++ b/plugins/samplesource/fcd/fcdthread.cpp
@@ -42,7 +42,7 @@ void FCDThread::stopWork()
void FCDThread::run()
{
- if ( !OpenSource("hw:CARD=V10") ) // FIXME: original is V10 pro is V20. Make it an option
+ if ( !OpenSource("hw:CARD=V20") ) // FIXME: pro is V10 pro+ is V20. Make it an option
return;
// TODO: fallback to original fcd
@@ -70,6 +70,7 @@ bool FCDThread::OpenSource(const char* cardname)
if (snd_pcm_open(&fcd_handle, cardname, fcd_stream, 0) < 0)
{
+ qCritical("FCDThread::OpenSource: cannot open %s", cardname);
return false;
}
@@ -77,10 +78,12 @@ bool FCDThread::OpenSource(const char* cardname)
if (snd_pcm_hw_params_any(fcd_handle, params) < 0)
{
+ qCritical("FCDThread::OpenSource: snd_pcm_hw_params_any failed");
fail = true;
}
else if (snd_pcm_hw_params(fcd_handle, params) < 0)
{
+ qCritical("FCDThread::OpenSource: snd_pcm_hw_params failed");
fail = true;
// TODO: check actual samplerate, may be crippled firmware
}
@@ -88,6 +91,7 @@ bool FCDThread::OpenSource(const char* cardname)
{
if (snd_pcm_start(fcd_handle) < 0)
{
+ qCritical("FCDThread::OpenSource: snd_pcm_start failed");
fail = true;
}
}
diff --git a/plugins/samplesource/fcd/qthid.h b/plugins/samplesource/fcd/qthid.h
index 0da5074a0..7a2433578 100644
--- a/plugins/samplesource/fcd/qthid.h
+++ b/plugins/samplesource/fcd/qthid.h
@@ -34,7 +34,7 @@
typedef bool BOOL;
-//#define FCDPP // FIXME: the Pro / Pro+ switch should be handled better than this!
+#define FCDPP // FIXME: the Pro / Pro+ switch should be handled better than this!
const unsigned short _usVID=0x04D8; /*!< USB vendor ID. */
#ifdef FCDPP
const unsigned short _usPID=0xFB31; /*!< USB product ID. */
diff --git a/plugins/samplesource/fcdpro/CMakeLists.txt b/plugins/samplesource/fcdpro/CMakeLists.txt
new file mode 100644
index 000000000..371105607
--- /dev/null
+++ b/plugins/samplesource/fcdpro/CMakeLists.txt
@@ -0,0 +1,53 @@
+project(fcdpro)
+
+set(fcdpro_SOURCES
+ fcdgui.cpp
+ fcdinput.cpp
+ fcdplugin.cpp
+ fcdserializer.cpp
+ fcdthread.cpp
+)
+
+set(fcdpro_HEADERS
+ fcdgui.h
+ fcdinput.h
+ fcdplugin.h
+ fcdserializer.h
+ fcdthread.h
+)
+
+set(fcdpro_FORMS
+ fcdgui.ui
+)
+
+include_directories(
+ .
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/include-gpl
+ ${CMAKE_SOURCE_DIR}/fcdhid
+)
+
+#include(${QT_USE_FILE})
+add_definitions(${QT_DEFINITIONS})
+add_definitions(-DQT_PLUGIN)
+add_definitions(-DQT_SHARED)
+
+#qt4_wrap_cpp(fcdpro_HEADERS_MOC ${fcdpro_HEADERS})
+qt5_wrap_ui(fcdpro_FORMS_HEADERS ${fcdpro_FORMS})
+
+add_library(inputfcdpro SHARED
+ ${fcdpro_SOURCES}
+ ${fcdpro_HEADERS_MOC}
+ ${fcdpro_FORMS_HEADERS}
+)
+
+target_link_libraries(inputfcdpro
+ ${QT_LIBRARIES}
+ ${LIBUSB_LIBRARIES}
+ asound
+ fcdhid
+ sdrbase
+)
+
+qt5_use_modules(inputfcdpro Core Widgets OpenGL Multimedia)
diff --git a/plugins/samplesource/fcdpro/fcdgui.cpp b/plugins/samplesource/fcdpro/fcdgui.cpp
new file mode 100644
index 000000000..8e7c86dd2
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdgui.cpp
@@ -0,0 +1,149 @@
+#include "fcdgui.h"
+#include "ui_fcdgui.h"
+#include "plugin/pluginapi.h"
+#include "gui/colormapper.h"
+#include "dsp/dspengine.h"
+
+FCDGui::FCDGui(PluginAPI* pluginAPI, QWidget* parent) :
+ QWidget(parent),
+ ui(new Ui::FCDGui),
+ m_pluginAPI(pluginAPI),
+ m_settings(),
+ m_sampleSource(NULL)
+{
+ ui->setupUi(this);
+ ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::ReverseGold));
+ ui->centerFrequency->setValueRange(7, 64000U, 1700000U);
+ connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
+ displaySettings();
+
+ m_sampleSource = new FCDInput();
+ DSPEngine::instance()->setSource(m_sampleSource);
+}
+
+FCDGui::~FCDGui()
+{
+ delete ui;
+}
+
+void FCDGui::destroy()
+{
+ delete this;
+}
+
+void FCDGui::setName(const QString& name)
+{
+ setObjectName(name);
+}
+
+QString FCDGui::getName() const
+{
+ return objectName();
+}
+
+void FCDGui::resetToDefaults()
+{
+ m_settings.resetToDefaults();
+ displaySettings();
+ sendSettings();
+}
+
+QByteArray FCDGui::serialize() const
+{
+ return m_settings.serialize();
+}
+
+bool FCDGui::deserialize(const QByteArray& data)
+{
+ if(m_settings.deserialize(data))
+ {
+ displaySettings();
+ sendSettings();
+ return true;
+ }
+ else
+ {
+ resetToDefaults();
+ return false;
+ }
+}
+
+bool FCDGui::handleMessage(const Message& message)
+{
+ return false;
+}
+
+void FCDGui::displaySettings()
+{
+ ui->centerFrequency->setValue(m_settings.centerFrequency / 1000);
+ ui->checkBoxR->setChecked(m_settings.range);
+ ui->checkBoxG->setChecked(m_settings.gain);
+ ui->checkBoxB->setChecked(m_settings.bias);
+}
+
+void FCDGui::sendSettings()
+{
+ if(!m_updateTimer.isActive())
+ m_updateTimer.start(100);
+}
+
+void FCDGui::on_centerFrequency_changed(quint64 value)
+{
+ m_settings.centerFrequency = value * 1000;
+ sendSettings();
+}
+
+void FCDGui::updateHardware()
+{
+ FCDInput::MsgConfigureFCD* message = FCDInput::MsgConfigureFCD::create(m_settings);
+ m_sampleSource->getInputMessageQueue()->push(message);
+ m_updateTimer.stop();
+}
+
+void FCDGui::on_checkBoxR_stateChanged(int state)
+{
+ if (state == Qt::Checked) // FIXME: this is for the Pro+ version only!
+ {
+ ui->centerFrequency->setValueRange(7, 150U, 240000U);
+ ui->centerFrequency->setValue(7000);
+ m_settings.centerFrequency = 7000 * 1000;
+ m_settings.range = 1;
+ }
+ else
+ {
+ ui->centerFrequency->setValueRange(7, 64000U, 1900000U);
+ ui->centerFrequency->setValue(435000);
+ m_settings.centerFrequency = 435000 * 1000;
+ m_settings.range = 0;
+ }
+
+ sendSettings();
+}
+
+void FCDGui::on_checkBoxG_stateChanged(int state)
+{
+ if (state == Qt::Checked)
+ {
+ m_settings.gain = 1;
+ }
+ else
+ {
+ m_settings.gain = 0;
+ }
+
+ sendSettings();
+}
+
+void FCDGui::on_checkBoxB_stateChanged(int state)
+{
+ if (state == Qt::Checked)
+ {
+ m_settings.bias = 1;
+ }
+ else
+ {
+ m_settings.bias = 0;
+ }
+
+ sendSettings();
+}
diff --git a/plugins/samplesource/fcdpro/fcdgui.h b/plugins/samplesource/fcdpro/fcdgui.h
new file mode 100644
index 000000000..1b4b8d6fe
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdgui.h
@@ -0,0 +1,51 @@
+#ifndef INCLUDE_FCDGUI_H
+#define INCLUDE_FCDGUI_H
+
+#include
+#include "plugin/plugingui.h"
+#include "fcdinput.h"
+
+class PluginAPI;
+
+namespace Ui {
+ class FCDGui;
+}
+
+class FCDGui : public QWidget, public PluginGUI {
+ Q_OBJECT
+
+public:
+ explicit FCDGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
+ virtual ~FCDGui();
+ void destroy();
+
+ void setName(const QString& name);
+ QString getName() const;
+
+ void resetToDefaults();
+ QByteArray serialize() const;
+ bool deserialize(const QByteArray& data);
+
+ virtual bool handleMessage(const Message& message);
+
+private:
+ Ui::FCDGui* ui;
+
+ PluginAPI* m_pluginAPI;
+ FCDInput::Settings m_settings;
+ QTimer m_updateTimer;
+ std::vector m_gains;
+ SampleSource* m_sampleSource;
+
+ void displaySettings();
+ void sendSettings();
+
+private slots:
+ void on_centerFrequency_changed(quint64 value);
+ void on_checkBoxR_stateChanged(int state);
+ void on_checkBoxG_stateChanged(int state);
+ void on_checkBoxB_stateChanged(int state);
+ void updateHardware();
+};
+
+#endif // INCLUDE_FCDGUI_H
diff --git a/plugins/samplesource/fcdpro/fcdgui.ui b/plugins/samplesource/fcdpro/fcdgui.ui
new file mode 100644
index 000000000..d20ad55f1
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdgui.ui
@@ -0,0 +1,144 @@
+
+
+ FCDGui
+
+
+
+ 0
+ 0
+ 132
+ 119
+
+
+
+
+ 0
+ 0
+
+
+
+ FunCubeDongle
+
+
+
+ 3
+
+
+ 2
+
+
+ 2
+
+
+ 2
+
+
+ 2
+
+ -
+
+
-
+
+
+ Qt::Horizontal
+
+
+
+ 0
+ 0
+
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 32
+ 16
+
+
+
+
+ Monospace
+ 20
+
+
+
+ Qt::StrongFocus
+
+
+ Tuner center frequency in kHz
+
+
+
+ -
+
+
+ Qt::Horizontal
+
+
+
+ 0
+ 0
+
+
+
+
+
+
+ -
+
+
+ Qt::Horizontal
+
+
+
+ -
+
+
-
+
+
+ Low Range
+
+
+
+
+
+ -
+
+
-
+
+
+ LNA Gain
+
+
+
+ -
+
+
+ Bias T
+
+
+
+
+
+
+
+
+
+ ValueDial
+ QWidget
+
+ 1
+
+
+
+
+
diff --git a/plugins/samplesource/fcdpro/fcdinput.cpp b/plugins/samplesource/fcdpro/fcdinput.cpp
new file mode 100644
index 000000000..b170959f5
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdinput.cpp
@@ -0,0 +1,286 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany //
+// written by Christian Daniel //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+// FIXME: FCD is handled very badly!
+
+#include
+#include
+#include
+#include "fcdinput.h"
+#include "fcdthread.h"
+#include "fcdgui.h"
+#include "dsp/dspcommands.h"
+#include "fcdserializer.h"
+
+MESSAGE_CLASS_DEFINITION(FCDInput::MsgConfigureFCD, Message)
+//MESSAGE_CLASS_DEFINITION(FCDInput::MsgReportFCD, Message)
+
+const uint16_t FCDInput::m_vendorId = 0x04D8;
+
+const uint16_t FCDInput::m_productId = 0xFB31;
+const int FCDInput::m_sampleRate = 192000;
+const std::string FCDInput::m_deviceName("hw:CARD=V20");
+
+//const uint16_t FCDInput::m_productId = 0xFB56;
+//const int FCDInput::m_sampleRate = 96000;
+//const std::string FCDInput::m_deviceName("hw:CARD=V10");
+
+FCDInput::Settings::Settings() :
+ centerFrequency(435000000),
+ range(0),
+ gain(0),
+ bias(0)
+{
+}
+
+void FCDInput::Settings::resetToDefaults()
+{
+ centerFrequency = 435000000;
+ range = 0;
+ gain = 0;
+ bias = 0;
+}
+
+QByteArray FCDInput::Settings::serialize() const
+{
+ FCDSerializer::FCDData data;
+
+ data.m_data.m_lnaGain = gain;
+ data.m_data.m_frequency = centerFrequency;
+ data.m_range = range;
+ data.m_bias = bias;
+
+ QByteArray byteArray;
+
+ FCDSerializer::writeSerializedData(data, byteArray);
+
+ return byteArray;
+
+ /*
+ SimpleSerializer s(1);
+ s.writeU64(1, centerFrequency);
+ s.writeS32(2, range);
+ s.writeS32(3, gain);
+ s.writeS32(4, bias);
+ return s.final();*/
+}
+
+bool FCDInput::Settings::deserialize(const QByteArray& serializedData)
+{
+ FCDSerializer::FCDData data;
+
+ bool valid = FCDSerializer::readSerializedData(serializedData, data);
+
+ gain = data.m_data.m_lnaGain;
+ centerFrequency = data.m_data.m_frequency;
+ range = data.m_range;
+ bias = data.m_bias;
+
+ return valid;
+
+ /*
+ SimpleDeserializer d(data);
+
+ if (d.isValid() && d.getVersion() == 1)
+ {
+ d.readU64(1, ¢erFrequency, 435000000);
+ d.readS32(2, &range, 0);
+ d.readS32(3, &gain, 0);
+ d.readS32(4, &bias, 0);
+ return true;
+ }
+
+ resetToDefaults();
+ return true;*/
+}
+
+FCDInput::FCDInput() :
+ m_dev(0),
+ m_settings(),
+ m_FCDThread(0),
+ m_deviceDescription()
+{
+}
+
+FCDInput::~FCDInput()
+{
+ stop();
+}
+
+bool FCDInput::init(const Message& cmd)
+{
+ return false;
+}
+
+bool FCDInput::start(int device)
+{
+ qDebug() << "FCDInput::start with device #" << device;
+
+ QMutexLocker mutexLocker(&m_mutex);
+
+ if (m_FCDThread)
+ {
+ return false;
+ }
+
+ m_dev = fcdOpen(m_vendorId, m_productId, device);
+
+ if (m_dev == 0)
+ {
+ qCritical("FCDInput::start: could not open FCD");
+ return false;
+ }
+
+ /* Apply settings before streaming to avoid bus contention;
+ * there is very little spare bandwidth on a full speed USB device.
+ * Failure is harmless if no device is found */
+
+ applySettings(m_settings, true);
+
+ if(!m_sampleFifo.setSize(96000*4))
+ {
+ qCritical("Could not allocate SampleFifo");
+ return false;
+ }
+
+ if ((m_FCDThread = new FCDThread(&m_sampleFifo)) == NULL)
+ {
+ qFatal("out of memory");
+ return false;
+ }
+
+ m_deviceDescription = QString("Funcube Dongle");
+
+ qDebug("FCDInput::started");
+ return true;
+}
+
+void FCDInput::stop()
+{
+ QMutexLocker mutexLocker(&m_mutex);
+
+ if (m_FCDThread)
+ {
+ m_FCDThread->stopWork();
+ // wait for thread to quit ?
+ delete m_FCDThread;
+ m_FCDThread = 0;
+ }
+
+ fcdClose(m_dev);
+ m_dev = 0;
+
+ m_deviceDescription.clear();
+}
+
+const QString& FCDInput::getDeviceDescription() const
+{
+ return m_deviceDescription;
+}
+
+int FCDInput::getSampleRate() const
+{
+ return m_sampleRate;
+}
+
+quint64 FCDInput::getCenterFrequency() const
+{
+ return m_settings.centerFrequency;
+}
+
+bool FCDInput::handleMessage(const Message& message)
+{
+ if(MsgConfigureFCD::match(message))
+ {
+ qDebug() << "FCDInput::handleMessage: MsgConfigureFCD";
+ MsgConfigureFCD& conf = (MsgConfigureFCD&) message;
+ applySettings(conf.getSettings(), false);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+void FCDInput::applySettings(const Settings& settings, bool force)
+{
+ bool signalChange = false;
+
+ if ((m_settings.centerFrequency != settings.centerFrequency))
+ {
+ qDebug() << "FCDInput::applySettings: fc: " << settings.centerFrequency;
+ m_settings.centerFrequency = settings.centerFrequency;
+
+ if (m_dev != 0)
+ {
+ set_center_freq((double) m_settings.centerFrequency);
+ }
+
+ signalChange = true;
+ }
+
+ if ((m_settings.gain != settings.gain) || force)
+ {
+ m_settings.gain = settings.gain;
+
+ if (m_dev != 0)
+ {
+ set_lna_gain(settings.gain > 0);
+ }
+ }
+
+ if ((m_settings.bias != settings.bias) || force)
+ {
+ m_settings.bias = settings.bias;
+
+ if (m_dev != 0)
+ {
+ set_bias_t(settings.bias > 0);
+ }
+ }
+
+ if (signalChange)
+ {
+ DSPSignalNotification *notif = new DSPSignalNotification(m_sampleRate, m_settings.centerFrequency);
+ getOutputMessageQueue()->push(notif);
+ }
+}
+
+void FCDInput::set_center_freq(double freq)
+{
+ if (fcdAppSetFreq(m_dev, freq) == FCD_MODE_NONE)
+ {
+ qDebug("No FCD HID found for frquency change");
+ }
+}
+
+void FCDInput::set_bias_t(bool on)
+{
+ quint8 cmd = on ? 1 : 0;
+
+ fcdAppSetParam(m_dev, FCD_CMD_APP_SET_BIAS_TEE, &cmd, 1);
+}
+
+void FCDInput::set_lna_gain(bool on)
+{
+ quint8 cmd = on ? 1 : 0;
+
+ fcdAppSetParam(m_dev, FCD_CMD_APP_SET_LNA_GAIN, &cmd, 1);
+}
+
+
diff --git a/plugins/samplesource/fcdpro/fcdinput.h b/plugins/samplesource/fcdpro/fcdinput.h
new file mode 100644
index 000000000..d6e3548f0
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdinput.h
@@ -0,0 +1,98 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany //
+// written by Christian Daniel //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FCDINPUT_H
+#define INCLUDE_FCDINPUT_H
+
+#include "dsp/samplesource.h"
+#include "fcdhid.h"
+#include
+#include
+
+struct fcd_buffer {
+ void *start;
+ std::size_t length;
+};
+
+class FCDThread;
+
+class FCDInput : public SampleSource {
+public:
+ struct Settings {
+ Settings();
+ quint64 centerFrequency;
+ qint32 range;
+ qint32 gain;
+ qint32 bias;
+ void resetToDefaults();
+ QByteArray serialize() const;
+ bool deserialize(const QByteArray& data);
+ };
+
+ class MsgConfigureFCD : public Message {
+ MESSAGE_CLASS_DECLARATION
+
+ public:
+ const Settings& getSettings() const { return m_settings; }
+
+ static MsgConfigureFCD* create(const Settings& settings)
+ {
+ return new MsgConfigureFCD(settings);
+ }
+
+ private:
+ Settings m_settings;
+
+ MsgConfigureFCD(const Settings& settings) :
+ Message(),
+ m_settings(settings)
+ { }
+ };
+
+ FCDInput();
+ virtual ~FCDInput();
+
+ virtual bool init(const Message& cmd);
+ virtual bool start(int device);
+ virtual void stop();
+
+ virtual const QString& getDeviceDescription() const;
+ virtual int getSampleRate() const;
+ virtual quint64 getCenterFrequency() const;
+
+ virtual bool handleMessage(const Message& message);
+
+ void set_center_freq(double freq);
+ void set_bias_t(bool on);
+ void set_lna_gain(bool on);
+
+ static const uint16_t m_vendorId; //!< USB vendor ID.
+ static const uint16_t m_productId; //!< USB product ID.
+ static const int m_sampleRate;
+ static const std::string m_deviceName;
+
+private:
+ void applySettings(const Settings& settings, bool force);
+
+ hid_device *m_dev;
+ QMutex m_mutex;
+ Settings m_settings;
+ FCDThread* m_FCDThread;
+ QString m_deviceDescription;
+};
+
+#endif // INCLUDE_FCD_H
diff --git a/plugins/samplesource/fcdpro/fcdplugin.cpp b/plugins/samplesource/fcdpro/fcdplugin.cpp
new file mode 100644
index 000000000..e068172bb
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdplugin.cpp
@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015 Edouard Griffiths, F4EXB //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include
+#include
+#include "plugin/pluginapi.h"
+#include "util/simpleserializer.h"
+#include "fcdplugin.h"
+#include "fcdgui.h"
+
+const PluginDescriptor FCDPlugin::m_pluginDescriptor = {
+ QString("FunCube Pro Input"),
+ QString("---"),
+ QString("(c) Edouard Griffiths, F4EXB"),
+ QString("https://github.com/f4exb/sdrangel"),
+ true,
+ QString("https://github.com/f4exb/sdrangel")
+};
+
+FCDPlugin::FCDPlugin(QObject* parent) :
+ QObject(parent)
+{
+}
+
+const PluginDescriptor& FCDPlugin::getPluginDescriptor() const
+{
+ return m_pluginDescriptor;
+}
+
+void FCDPlugin::initPlugin(PluginAPI* pluginAPI)
+{
+ m_pluginAPI = pluginAPI;
+
+ m_pluginAPI->registerSampleSource("org.osmocom.sdr.samplesource.fcdpro", this);
+}
+
+PluginInterface::SampleSourceDevices FCDPlugin::enumSampleSources()
+{
+ SampleSourceDevices result;
+
+ QString displayedName(QString("Funcube Dongle Pro #1"));
+ SimpleSerializer s(1);
+ s.writeS32(1, 0);
+ result.append(SampleSourceDevice(displayedName, "org.osmocom.sdr.samplesource.fcdpro", s.final()));
+
+ return result;
+}
+
+PluginGUI* FCDPlugin::createSampleSourcePluginGUI(const QString& sourceName, const QByteArray& address)
+{
+ if(sourceName == "org.osmocom.sdr.samplesource.fcdpro") {
+ FCDGui* gui = new FCDGui(m_pluginAPI);
+ m_pluginAPI->setInputGUI(gui);
+ return gui;
+ } else {
+ return NULL;
+ }
+}
diff --git a/plugins/samplesource/fcdpro/fcdplugin.h b/plugins/samplesource/fcdpro/fcdplugin.h
new file mode 100644
index 000000000..f85a1fff5
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdplugin.h
@@ -0,0 +1,27 @@
+#ifndef INCLUDE_FCDPLUGIN_H
+#define INCLUDE_FCDPLUGIN_H
+
+#include
+#include "plugin/plugininterface.h"
+
+class FCDPlugin : public QObject, public PluginInterface {
+ Q_OBJECT
+ Q_INTERFACES(PluginInterface)
+ Q_PLUGIN_METADATA(IID "org.osmocom.sdr.samplesource.fcdpro")
+
+public:
+ explicit FCDPlugin(QObject* parent = NULL);
+
+ const PluginDescriptor& getPluginDescriptor() const;
+ void initPlugin(PluginAPI* pluginAPI);
+
+ SampleSourceDevices enumSampleSources();
+ PluginGUI* createSampleSourcePluginGUI(const QString& sourceName, const QByteArray& address);
+
+private:
+ static const PluginDescriptor m_pluginDescriptor;
+
+ PluginAPI* m_pluginAPI;
+};
+
+#endif // INCLUDE_FCDPLUGIN_H
diff --git a/plugins/samplesource/fcdpro/fcdserializer.cpp b/plugins/samplesource/fcdpro/fcdserializer.cpp
new file mode 100644
index 000000000..68dd6d424
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdserializer.cpp
@@ -0,0 +1,68 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015 Edouard Griffiths, F4EXB //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "fcdserializer.h"
+
+void FCDSerializer::writeSerializedData(const FCDData& data, QByteArray& serializedData)
+{
+ QByteArray sampleSourceSerialized;
+ SampleSourceSerializer::writeSerializedData(data.m_data, sampleSourceSerialized);
+
+ SimpleSerializer s(1);
+
+ s.writeBlob(1, sampleSourceSerialized);
+ s.writeS32(2, data.m_bias);
+ s.writeS32(3, data.m_range);
+
+ serializedData = s.final();
+}
+
+bool FCDSerializer::readSerializedData(const QByteArray& serializedData, FCDData& data)
+{
+ bool valid = SampleSourceSerializer::readSerializedData(serializedData, data.m_data);
+
+ QByteArray sampleSourceSerialized;
+
+ SimpleDeserializer d(serializedData);
+
+ if (!d.isValid())
+ {
+ setDefaults(data);
+ return false;
+ }
+
+ if (d.getVersion() == SampleSourceSerializer::getSerializerVersion())
+ {
+ int intval;
+
+ d.readBlob(1, &sampleSourceSerialized);
+ d.readS32(2, &data.m_bias);
+ d.readS32(3, &data.m_range);
+
+ return SampleSourceSerializer::readSerializedData(sampleSourceSerialized, data.m_data);
+ }
+ else
+ {
+ setDefaults(data);
+ return false;
+ }
+}
+
+void FCDSerializer::setDefaults(FCDData& data)
+{
+ data.m_range = 0;
+ data.m_bias = 0;
+}
diff --git a/plugins/samplesource/fcdpro/fcdserializer.h b/plugins/samplesource/fcdpro/fcdserializer.h
new file mode 100644
index 000000000..735dd6a56
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdserializer.h
@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015 Edouard Griffiths, F4EXB //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef PLUGINS_SAMPLESOURCE_FCD_FCDSERIALIZER_H_
+#define PLUGINS_SAMPLESOURCE_FCD_FCDSERIALIZER_H_
+
+#include "util/samplesourceserializer.h"
+
+class FCDSerializer
+{
+public:
+ struct FCDData
+ {
+ SampleSourceSerializer::Data m_data;
+ qint32 m_bias;
+ qint32 m_range;
+ };
+
+ static void writeSerializedData(const FCDData& data, QByteArray& serializedData);
+ static bool readSerializedData(const QByteArray& serializedData, FCDData& data);
+ static void setDefaults(FCDData& data);
+};
+
+
+
+#endif /* PLUGINS_SAMPLESOURCE_FCD_FCDSERIALIZER_H_ */
diff --git a/plugins/samplesource/fcdpro/fcdthread.cpp b/plugins/samplesource/fcdpro/fcdthread.cpp
new file mode 100644
index 000000000..34e1c98de
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdthread.cpp
@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany //
+// written by Christian Daniel //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include
+#include
+#include
+#include "fcdthread.h"
+#include "fcdinput.h"
+#include "dsp/samplefifo.h"
+
+FCDThread::FCDThread(SampleFifo* sampleFifo, QObject* parent) :
+ QThread(parent),
+ fcd_handle(NULL),
+ m_running(false),
+ m_convertBuffer(FCD_BLOCKSIZE),
+ m_sampleFifo(sampleFifo)
+{
+ start();
+}
+
+FCDThread::~FCDThread()
+{
+}
+
+void FCDThread::stopWork()
+{
+ m_running = false;
+ wait();
+}
+
+void FCDThread::run()
+{
+ if ( !OpenSource(FCDInput::m_deviceName.c_str()) )
+ {
+ qCritical() << "FCDThread::run: cannot open FCD sound card";
+ return;
+ }
+ // TODO: fallback to original fcd
+
+ m_running = true;
+
+ while(m_running)
+ {
+ if (work(FCD_BLOCKSIZE) < 0)
+ {
+ break;
+ }
+ }
+
+ CloseSource();
+}
+
+bool FCDThread::OpenSource(const char* cardname)
+{
+ bool fail = false;
+ snd_pcm_hw_params_t* params;
+ //fcd_rate = FCDPP_RATE;
+ //fcd_channels =2;
+ //fcd_format = SND_PCM_SFMT_U16_LE;
+ snd_pcm_stream_t fcd_stream = SND_PCM_STREAM_CAPTURE;
+
+ if (fcd_handle)
+ {
+ return false;
+ }
+
+ if (snd_pcm_open(&fcd_handle, cardname, fcd_stream, 0) < 0)
+ {
+ qCritical("FCDThread::OpenSource: cannot open %s", cardname);
+ return false;
+ }
+
+ snd_pcm_hw_params_alloca(¶ms);
+
+ if (snd_pcm_hw_params_any(fcd_handle, params) < 0)
+ {
+ qCritical("FCDThread::OpenSource: snd_pcm_hw_params_any failed");
+ fail = true;
+ }
+ else if (snd_pcm_hw_params(fcd_handle, params) < 0)
+ {
+ qCritical("FCDThread::OpenSource: snd_pcm_hw_params failed");
+ fail = true;
+ // TODO: check actual samplerate, may be crippled firmware
+ }
+ else
+ {
+ if (snd_pcm_start(fcd_handle) < 0)
+ {
+ qCritical("FCDThread::OpenSource: snd_pcm_start failed");
+ fail = true;
+ }
+ }
+
+ if (fail)
+ {
+ snd_pcm_close( fcd_handle );
+ return false;
+ }
+ else
+ {
+ qDebug("FCDThread::OpenSource: Funcube stream started");
+ }
+
+ return true;
+}
+
+void FCDThread::CloseSource()
+{
+ if (fcd_handle)
+ {
+ snd_pcm_close( fcd_handle );
+ }
+
+ fcd_handle = NULL;
+}
+
+int FCDThread::work(int n_items)
+{
+ int l;
+ SampleVector::iterator it;
+ void *out;
+
+ it = m_convertBuffer.begin();
+ out = (void *)&it[0];
+ l = snd_pcm_mmap_readi(fcd_handle, out, (snd_pcm_uframes_t)n_items);
+ if (l > 0)
+ m_sampleFifo->write(it, it + l);
+ if (l == -EPIPE) {
+ qDebug("FCD: Overrun detected");
+ return 0;
+ }
+ return l;
+}
+
+
diff --git a/plugins/samplesource/fcdpro/fcdthread.h b/plugins/samplesource/fcdpro/fcdthread.h
new file mode 100644
index 000000000..dc7e4530d
--- /dev/null
+++ b/plugins/samplesource/fcdpro/fcdthread.h
@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany //
+// written by Christian Daniel //
+// //
+// This program is free software; you can redistribute it and/or modify //
+// it under the terms of the GNU General Public License as published by //
+// the Free Software Foundation as version 3 of the License, or //
+// //
+// This program is distributed in the hope that it will be useful, //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
+// GNU General Public License V3 for more details. //
+// //
+// You should have received a copy of the GNU General Public License //
+// along with this program. If not, see . //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FCDTHREAD_H
+#define INCLUDE_FCDTHREAD_H
+
+#include
+#include
+#include
+#include "dsp/samplefifo.h"
+#include "dsp/inthalfbandfilter.h"
+#include
+
+#define FCDPP_RATE 192000 // FIXME: The Pro / Pro+ switch should be handled better than this!
+#define FCD_BLOCKSIZE (1<<11)
+
+class FCDThread : public QThread {
+ Q_OBJECT
+
+public:
+ FCDThread(SampleFifo* sampleFifo, QObject* parent = NULL);
+ ~FCDThread();
+
+ void stopWork();
+ bool OpenSource(const char *filename);
+ void CloseSource();
+ int work(int n_items);
+private:
+ snd_pcm_format_t fcd_format;
+ snd_pcm_t* fcd_handle;
+
+ QMutex m_startWaitMutex;
+ QWaitCondition m_startWaiter;
+ bool m_running;
+
+ SampleVector m_convertBuffer;
+ SampleFifo* m_sampleFifo;
+
+ void run();
+
+};
+#endif // INCLUDE_FCDTHREAD_H