summaryrefslogtreecommitdiff
path: root/gr-fcd/lib
diff options
context:
space:
mode:
Diffstat (limited to 'gr-fcd/lib')
-rw-r--r--gr-fcd/lib/CMakeLists.txt67
-rw-r--r--gr-fcd/lib/fcd/CMakeLists.txt32
-rw-r--r--gr-fcd/lib/fcd/COPYRIGHT23
-rw-r--r--gr-fcd/lib/fcd/fcd.c904
-rw-r--r--gr-fcd/lib/fcd/fcd.h79
-rw-r--r--gr-fcd/lib/fcd/fcdhidcmd.h305
-rw-r--r--gr-fcd/lib/fcd_source_c.cc236
-rw-r--r--gr-fcd/lib/hid/CMakeLists.txt39
-rw-r--r--gr-fcd/lib/hid/COPYRIGHT25
-rw-r--r--gr-fcd/lib/hid/hid-libusb.c1386
-rw-r--r--gr-fcd/lib/hid/hidapi.h383
-rw-r--r--gr-fcd/lib/hid/hidmac.c1122
-rw-r--r--gr-fcd/lib/hid/hidwin.c873
13 files changed, 5474 insertions, 0 deletions
diff --git a/gr-fcd/lib/CMakeLists.txt b/gr-fcd/lib/CMakeLists.txt
new file mode 100644
index 000000000..0e1f2aa01
--- /dev/null
+++ b/gr-fcd/lib/CMakeLists.txt
@@ -0,0 +1,67 @@
+# Copyright 2012 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio 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, or (at your option)
+# any later version.
+#
+# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+
+GR_INCLUDE_SUBDIRECTORY(hid)
+GR_INCLUDE_SUBDIRECTORY(fcd)
+
+########################################################################
+# Setup the include and linker paths
+########################################################################
+include_directories(
+ ${GNURADIO_CORE_INCLUDE_DIRS}
+ ${GR_FCD_INCLUDE_DIRS}
+ ${GR_AUDIO_INCLUDE_DIRS}
+ ${CMAKE_CURRENT_SOURCE_DIR}/hid
+ ${CMAKE_CURRENT_SOURCE_DIR}/fcd
+ ${LIBUSB_INCLUDE_DIR}
+)
+
+include_directories(${Boost_INCLUDE_DIRS})
+link_directories(${Boost_LIBRARY_DIRS})
+
+########################################################################
+# Setup library
+########################################################################
+list(APPEND gr_fcd_sources
+ fcd_source_c.cc
+)
+
+list(APPEND fcd_libs
+ gnuradio-core
+ gnuradio-audio
+ ${Boost_LIBRARIES}
+)
+
+if (WIN32)
+ list(APPEND fcd_libs setupapi)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ FIND_LIBRARY(IOKIT_LIBRARY IOKit)
+ list(APPEND fcd_libs ${IOKIT_LIBRARY})
+elseif (NOT WIN32)
+ list(APPEND fcd_libs
+ ${LIBUSB_LIBRARIES}
+ )
+endif()
+
+
+add_library(gnuradio-fcd SHARED ${gr_fcd_sources})
+target_link_libraries(gnuradio-fcd ${fcd_libs})
+GR_LIBRARY_FOO(gnuradio-fcd RUNTIME_COMPONENT "fcd_runtime" DEVEL_COMPONENT "fcd_devel")
diff --git a/gr-fcd/lib/fcd/CMakeLists.txt b/gr-fcd/lib/fcd/CMakeLists.txt
new file mode 100644
index 000000000..416a7507e
--- /dev/null
+++ b/gr-fcd/lib/fcd/CMakeLists.txt
@@ -0,0 +1,32 @@
+# Copyright 2012 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio 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, or (at your option)
+# any later version.
+#
+# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+
+########################################################################
+# This file included, use CMake directory variables
+########################################################################
+
+include_directories(APPEND ${USB_INCLUDES})
+
+set(fcd_sources ${CMAKE_CURRENT_SOURCE_DIR}/fcd.c)
+
+
+########################################################################
+# Append gnuradio-fcd library sources
+########################################################################
+list(APPEND gr_fcd_sources ${fcd_sources})
diff --git a/gr-fcd/lib/fcd/COPYRIGHT b/gr-fcd/lib/fcd/COPYRIGHT
new file mode 100644
index 000000000..f176590e9
--- /dev/null
+++ b/gr-fcd/lib/fcd/COPYRIGHT
@@ -0,0 +1,23 @@
+For convenience, GNU Radio includes the contents of this directory
+in its distribution, but they are not considered part of GNU Radio.
+
+These files are licensed and redistributed using the terms of the
+GPLv3.
+-------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
diff --git a/gr-fcd/lib/fcd/fcd.c b/gr-fcd/lib/fcd/fcd.c
new file mode 100644
index 000000000..ca9050231
--- /dev/null
+++ b/gr-fcd/lib/fcd/fcd.c
@@ -0,0 +1,904 @@
+/***************************************************************************
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ ***************************************************************************/
+
+#define FCD
+#include <string.h>
+#ifdef WIN32
+ #include <malloc.h>
+#else
+ #include <stdlib.h>
+#endif
+#include "hidapi.h"
+#include "fcd.h"
+#include "fcdhidcmd.h"
+#include <stdio.h>
+
+
+#define FALSE 0
+#define TRUE 1
+typedef int BOOL;
+
+
+const unsigned short _usVID=0x04D8; /*!< USB vendor ID. */
+const unsigned short _usPID=0xFB56; /*!< USB product ID. */
+
+
+
+/** \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.
+ */
+static hid_device *fcdOpen(void)
+{
+ struct hid_device_info *phdi=NULL;
+ hid_device *phd=NULL;
+ char *pszPath=NULL;
+
+ phdi=hid_enumerate(_usVID,_usPID);
+ 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. */
+static void fcdClose(hid_device *phd)
+{
+ hid_close(phd);
+}
+
+
+/** \brief Get FCD mode.
+ * \return The current FCD mode.
+ * \sa FCD_MODE_ENUM
+ */
+EXTERN FCD_MODE_ENUM fcdGetMode(void)
+{
+ 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) {
+ 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
+ */
+EXTERN FCD_MODE_ENUM fcdGetFwVerStr(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
+ */
+EXTERN FCD_MODE_ENUM fcdGetCaps(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
+ */
+EXTERN FCD_MODE_ENUM fcdGetCapsStr(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.
+ */
+EXTERN FCD_MODE_ENUM fcdAppReset(void)
+{
+ 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
+ */
+EXTERN FCD_MODE_ENUM fcdAppSetFreqkHz(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
+ */
+EXTERN FCD_MODE_ENUM fcdAppSetFreq(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.
+ */
+EXTERN FCD_MODE_ENUM fcdBlReset(void)
+{
+ 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
+ */
+EXTERN FCD_MODE_ENUM fcdBlErase(void)
+{
+ 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
+ */
+EXTERN FCD_MODE_ENUM fcdBlWriteFirmware(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<u32AddrEnd && u32Addr+47<n64Size && !bFinished; u32Addr+=48)
+ {
+ memcpy(&aucBufOut[3], &pc[u32Addr], 48);
+
+ 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_WRITE_FLASH_BLOCK || aucBufIn[1]!=1)
+ {
+ bFinished = TRUE;
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_APP;
+ }
+ }
+
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_BL;
+}
+
+
+/** \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.
+ */
+EXTERN FCD_MODE_ENUM fcdBlVerifyFirmware(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;
+ }
+
+ // Read blocks
+ aucBufOut[0] = 0; // Report ID, ignored
+ aucBufOut[1] = FCD_CMD_BL_READ_FLASH_BLOCK;
+ for (u32Addr=u32AddrStart; u32Addr+47<u32AddrEnd && u32Addr+47<n64Size && !bFinished; u32Addr+=48)
+ {
+ 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_READ_FLASH_BLOCK || aucBufIn[1]!=1)
+ {
+ bFinished = TRUE;
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_APP;
+ }
+
+ if (memcmp(&aucBufIn[2],&pc[u32Addr],48)!=0)
+ {
+ bFinished = TRUE;
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_APP;
+ }
+ }
+
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_BL;
+}
+
+
+
+/** \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
+ */
+EXTERN FCD_MODE_ENUM fcdAppSetParam(uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len)
+{
+ hid_device *phd=NULL;
+ unsigned char aucBufOut[65];
+ unsigned char aucBufIn[65];
+
+
+ phd = fcdOpen();
+
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }
+
+ aucBufOut[0]=0; // Report ID, ignored
+ aucBufOut[1]=u8Cmd;
+ memcpy(aucBufOut+2, pu8Data,u8len);
+ hid_write(phd,aucBufOut,65);
+
+ /* we must read after each write in order to empty FCD/HID buffer */
+ memset(aucBufIn,0xCC,65); // Clear out the response buffer
+ hid_read(phd,aucBufIn,65);
+
+ /* Check the response, if OK return FCD_MODE_APP */
+ if (aucBufIn[0]==u8Cmd && aucBufIn[1]==1) {
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_APP;
+ }
+
+ /* Response did not contain the expected bytes */
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_BL;
+
+}
+
+
+/** \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
+ */
+EXTERN FCD_MODE_ENUM fcdAppGetParam(uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len)
+{
+ hid_device *phd=NULL;
+ unsigned char aucBufOut[65];
+ unsigned char aucBufIn[65];
+
+ phd = fcdOpen();
+ if (phd == NULL)
+ {
+ return FCD_MODE_NONE;
+ }
+
+ aucBufOut[0]=0; // Report ID, ignored
+ aucBufOut[1]=u8Cmd;
+ hid_write(phd,aucBufOut,65);
+
+ memset(aucBufIn,0xCC,65); // Clear out the response buffer
+ hid_read(phd,aucBufIn,65);
+ /* Copy return data to output buffer (even if cmd exec failed) */
+ memcpy(pu8Data,aucBufIn+2,u8len);
+
+ /* Check status bytes in returned data */
+ if (aucBufIn[0]==u8Cmd && aucBufIn[1]==1) {
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_APP;
+ }
+
+ /* Response did not contain the expected bytes */
+ fcdClose(phd);
+ phd = NULL;
+
+ return FCD_MODE_BL;
+}
+
diff --git a/gr-fcd/lib/fcd/fcd.h b/gr-fcd/lib/fcd/fcd.h
new file mode 100644
index 000000000..7cfe9b7ed
--- /dev/null
+++ b/gr-fcd/lib/fcd/fcd.h
@@ -0,0 +1,79 @@
+/***************************************************************************
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ ***************************************************************************/
+
+#ifndef FCD_H
+#define FCD_H 1
+
+#include <fcd_api.h>
+
+#ifdef FCD
+#define EXTERN
+#define ASSIGN (x) =x
+#else
+#define EXTERN extern
+#define ASSIGN(x)
+#endif
+
+#include <inttypes.h>
+
+/** \brief FCD mode enumeration. */
+typedef enum {
+ FCD_MODE_NONE, /*!< No FCD detected. */
+ 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;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Application functions */
+EXTERN FCD_API FCD_MODE_ENUM fcdGetMode(void);
+EXTERN FCD_API FCD_MODE_ENUM fcdGetFwVerStr(char *str);
+EXTERN FCD_API FCD_MODE_ENUM fcdGetCaps(FCD_CAPS_STRUCT *fcd_caps);
+EXTERN FCD_API FCD_MODE_ENUM fcdGetCapsStr(char *caps_str);
+EXTERN FCD_API FCD_MODE_ENUM fcdAppReset(void);
+EXTERN FCD_API FCD_MODE_ENUM fcdAppSetFreqkHz(int nFreq);
+EXTERN FCD_API FCD_MODE_ENUM fcdAppSetFreq(int nFreq);
+
+EXTERN FCD_API FCD_MODE_ENUM fcdAppSetParam(uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len);
+EXTERN FCD_API FCD_MODE_ENUM fcdAppGetParam(uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len);
+
+
+/* Bootloader functions */
+EXTERN FCD_API FCD_MODE_ENUM fcdBlReset(void);
+EXTERN FCD_API FCD_MODE_ENUM fcdBlErase(void);
+EXTERN FCD_API FCD_MODE_ENUM fcdBlWriteFirmware(char *pc, int64_t n64Size);
+EXTERN FCD_API FCD_MODE_ENUM fcdBlVerifyFirmware(char *pc, int64_t n64Size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // FCD_H
diff --git a/gr-fcd/lib/fcd/fcdhidcmd.h b/gr-fcd/lib/fcd/fcdhidcmd.h
new file mode 100644
index 000000000..fad55f15f
--- /dev/null
+++ b/gr-fcd/lib/fcd/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 <http://www.gnu.org/licenses/>.
+ *
+ ***************************************************************************/
+#ifndef FCDHIDCMD_H
+#define FCD_HID_CMD_H 1
+
+
+/* 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/gr-fcd/lib/fcd_source_c.cc b/gr-fcd/lib/fcd_source_c.cc
new file mode 100644
index 000000000..75bdd3162
--- /dev/null
+++ b/gr-fcd/lib/fcd_source_c.cc
@@ -0,0 +1,236 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011 Free Software Foundation, Inc.
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include <fcd_source_c.h>
+#include <fcd.h>
+#include <fcdhidcmd.h> // needed for extended API
+#include <gr_io_signature.h>
+#include <gr_audio_source.h>
+#include <gr_float_to_complex.h>
+#include <gruel/attributes.h>
+
+//#include <iostream>
+//using namespace std;
+
+/*
+ * Create a new instance of fcd_source_c and return
+ * a boost shared_ptr. This is effectively the public constructor.
+ */
+fcd_source_c_sptr fcd_make_source_c(const std::string device_name)
+{
+ return gnuradio::get_initial_sptr(new fcd_source_c(device_name));
+}
+
+
+static const int MIN_IN = 0; /*!< Mininum number of input streams. */
+static const int MAX_IN = 0; /*!< Maximum number of input streams. */
+static const int MIN_OUT = 1; /*!< Minimum number of output streams. */
+static const int MAX_OUT = 1; /*!< Maximum number of output streams. */
+
+
+fcd_source_c::fcd_source_c(const std::string device_name)
+ : gr_hier_block2 ("fcd_source_c",
+ gr_make_io_signature (MIN_IN, MAX_IN, sizeof (gr_complex)),
+ gr_make_io_signature (MIN_OUT, MAX_OUT, sizeof (gr_complex))),
+ d_freq_corr(-120),
+ d_freq_req(0)
+{
+ gr_float_to_complex_sptr f2c;
+
+ /* Audio source; sample rate fixed at 96kHz */
+ fcd = audio_make_source(96000, device_name, true);
+
+ /* block to convert stereo audio to a complex stream */
+ f2c = gr_make_float_to_complex(1);
+
+ connect(fcd, 0, f2c, 0);
+ connect(fcd, 1, f2c, 1);
+ connect(f2c, 0, self(), 0);
+
+}
+
+
+fcd_source_c::~fcd_source_c ()
+{
+
+}
+
+// Set frequency with Hz resolution
+void fcd_source_c::set_freq(int freq)
+{
+ FCD_MODE_ENUM __GR_ATTR_UNUSED fme;
+ double f = (double)freq;
+
+ /* valid range 50 MHz - 2.0 GHz */
+ if ((freq < 50000000) || (freq > 2000000000)) {
+ return;
+ }
+
+ d_freq_req = freq;
+ f *= 1.0 + d_freq_corr/1000000.0;
+
+ fme = fcdAppSetFreq((int)f);
+ /* TODO: check fme */
+}
+
+// Set frequency with Hz resolution (type float)
+void fcd_source_c::set_freq(float freq)
+{
+ FCD_MODE_ENUM __GR_ATTR_UNUSED fme;
+ double f = (double)freq;
+
+ /* valid range 50 MHz - 2.0 GHz */
+ if ((freq < 50.0e6) || (freq > 2.0e9)) {
+ return;
+ }
+
+ d_freq_req = (int)freq;
+ f *= 1.0 + d_freq_corr/1000000.0;
+
+ fme = fcdAppSetFreq((int)f);
+ /* TODO: check fme */
+}
+
+
+// Set frequency with kHz resolution.
+void fcd_source_c::set_freq_khz(int freq)
+{
+ FCD_MODE_ENUM __GR_ATTR_UNUSED fme;
+ double f = freq*1000.0;
+
+ /* valid range 50 MHz - 2.0 GHz */
+ if ((freq < 50000) || (freq > 2000000)) {
+ return;
+ }
+
+ d_freq_req = freq*1000;
+ f *= 1.0 + d_freq_corr/1000000.0;
+
+ fme = fcdAppSetFreqkHz((int)(f/1000.0));
+ /* TODO: check fme */
+}
+
+
+// Set LNA gain
+void fcd_source_c::set_lna_gain(float gain)
+{
+ FCD_MODE_ENUM __GR_ATTR_UNUSED fme;
+ unsigned char g;
+
+ /* convert to nearest discrete value */
+ if (gain > 27.5) {
+ g = 14; // 30.0 dB
+ }
+ else if (gain > 22.5) {
+ g = 13; // 25.0 dB
+ }
+ else if (gain > 18.75) {
+ g = 12; // 20.0 dB
+ }
+ else if (gain > 16.25) {
+ g = 11; // 17.5 dB
+ }
+ else if (gain > 13.75) {
+ g = 10; // 15.0 dB
+ }
+ else if (gain > 11.25) {
+ g = 9; // 12.5 dB
+ }
+ else if (gain > 8.75) {
+ g = 8; // 10.0 dB
+ }
+ else if (gain > 6.25) {
+ g = 7; // 7.5 dB
+ }
+ else if (gain > 3.75) {
+ g = 6; // 5.0 dB
+ }
+ else if (gain > 1.25) {
+ g = 5; // 2.5 dB
+ }
+ else if (gain > -1.25) {
+ g = 4; // 0.0 dB
+ }
+ else if (gain > -3.75) {
+ g = 1; // -2.5 dB
+ }
+ else {
+ g = 0; // -5.0 dB
+ }
+
+ fme = fcdAppSetParam(FCD_CMD_APP_SET_LNA_GAIN, &g, 1);
+ /* TODO: check fme */
+}
+
+// Set new frequency correction
+void fcd_source_c::set_freq_corr(int ppm)
+{
+ d_freq_corr = ppm;
+ // re-tune with new correction value
+ set_freq(d_freq_req);
+}
+
+
+// Set DC offset correction.
+void fcd_source_c::set_dc_corr(double _dci, double _dcq)
+{
+ union {
+ unsigned char auc[4];
+ struct {
+ signed short dci; // equivalent of qint16 which should be 16 bit everywhere
+ signed short dcq;
+ };
+ } dcinfo;
+
+ if ((_dci < -1.0) || (_dci > 1.0) || (_dcq < -1.0) || (_dcq > 1.0))
+ return;
+
+ dcinfo.dci = static_cast<signed short>(_dci*32768.0);
+ dcinfo.dcq = static_cast<signed short>(_dcq*32768.0);
+
+ fcdAppSetParam(FCD_CMD_APP_SET_DC_CORR, dcinfo.auc, 4);
+
+}
+
+
+// Set IQ phase and gain balance.
+void fcd_source_c::set_iq_corr(double _gain, double _phase)
+{
+ union {
+ unsigned char auc[4];
+ struct {
+ signed short phase;
+ signed short gain;
+ };
+ } iqinfo;
+
+ if ((_gain < -1.0) || (_gain > 1.0) || (_phase < -1.0) || (_phase > 1.0))
+ return;
+
+ iqinfo.phase = static_cast<signed short>(_phase*32768.0);
+ iqinfo.gain = static_cast<signed short>(_gain*32768.0);
+
+ fcdAppSetParam(FCD_CMD_APP_SET_IQ_CORR, iqinfo.auc, 4);
+
+}
diff --git a/gr-fcd/lib/hid/CMakeLists.txt b/gr-fcd/lib/hid/CMakeLists.txt
new file mode 100644
index 000000000..db335cc93
--- /dev/null
+++ b/gr-fcd/lib/hid/CMakeLists.txt
@@ -0,0 +1,39 @@
+# Copyright 2012 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio 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, or (at your option)
+# any later version.
+#
+# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+
+########################################################################
+# This file included, use CMake directory variables
+########################################################################
+
+include_directories(APPEND ${USB_INCLUDES})
+
+set(hid_sources)
+
+if(WIN32)
+ list(APPEND hid_sources ${CMAKE_CURRENT_SOURCE_DIR}/hidwin.c)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ list(APPEND hid_sources ${CMAKE_CURRENT_SOURCE_DIR}/hidmac.c)
+else()
+ list(APPEND hid_sources ${CMAKE_CURRENT_SOURCE_DIR}/hid-libusb.c)
+endif()
+
+########################################################################
+# Append gnuradio-fcd library sources
+########################################################################
+list(APPEND gr_fcd_sources ${hid_sources})
diff --git a/gr-fcd/lib/hid/COPYRIGHT b/gr-fcd/lib/hid/COPYRIGHT
new file mode 100644
index 000000000..e50305d7c
--- /dev/null
+++ b/gr-fcd/lib/hid/COPYRIGHT
@@ -0,0 +1,25 @@
+For convenience, GNU Radio includes the contents of this directory
+in its distribution, but they are not considered part of GNU Radio.
+
+These files are licensed and redistributed using the terms of the
+GPLv3.
+-------------------------------------------------------------------
+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 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 .
diff --git a/gr-fcd/lib/hid/hid-libusb.c b/gr-fcd/lib/hid/hid-libusb.c
new file mode 100644
index 000000000..7069f50d0
--- /dev/null
+++ b/gr-fcd/lib/hid/hid-libusb.c
@@ -0,0 +1,1386 @@
+/*******************************************************
+ 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
+
+ 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 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <locale.h>
+#include <errno.h>
+
+/* Unix */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <wchar.h>
+
+/* GNU / LibUSB */
+#include "libusb.h"
+#include "iconv.h"
+
+#include "hidapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DEBUG_PRINTF
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...) do {} while (0)
+#endif
+
+
+/* Uncomment to enable the retrieval of Usage and Usage Page in
+hid_enumerate(). Warning, this is very invasive as it requires the detach
+and re-attach of the kernel driver. See comments inside hid_enumerate().
+Linux/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;
+ struct libusb_transfer *transfer;
+
+ /* List of received input reports. */
+ struct input_report *input_reports;
+};
+
+static int initialized = 0;
+
+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->device_handle = NULL;
+ dev->input_endpoint = 0;
+ dev->output_endpoint = 0;
+ dev->input_ep_max_packet_size = 0;
+ dev->interface = 0;
+ dev->manufacturer_index = 0;
+ dev->product_index = 0;
+ dev->serial_index = 0;
+ dev->blocking = 1;
+ dev->shutdown_thread = 0;
+ dev->transfer = NULL;
+ dev->input_reports = NULL;
+
+ 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 Linux.
+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)
+{
+ 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
+
+
+/* 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];
+ unsigned int len;
+ wchar_t *str = NULL;
+ wchar_t wbuf[256];
+
+ /* iconv variables */
+ iconv_t ic;
+ size_t inbytes;
+ size_t outbytes;
+ size_t res;
+ char *inptr;
+ 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[sizeof(buf)-1] = '\0';
+
+ if (len+1 < sizeof(buf))
+ buf[len+1] = '\0';
+
+ /* Initialize iconv. */
+ ic = iconv_open("UTF-32", "UTF-16");
+ if (ic == (iconv_t)-1)
+ return NULL;
+
+ /* Convert to UTF-32 (wchar_t on glibc 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)
+ 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+1);
+
+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 (!initialized) {
+ if (libusb_init(NULL))
+ return -1;
+ initialized = 1;
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+ if (initialized) {
+ libusb_exit(NULL);
+ initialized = 0;
+ }
+
+ 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;
+
+ setlocale(LC_ALL,"");
+
+ if (!initialized)
+ hid_init();
+
+ num_devs = libusb_get_device_list(NULL, &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;
+
+ /* HID's are defined at the interface level. */
+ if (desc.bDeviceClass != LIBUSB_CLASS_PER_INTERFACE)
+ continue;
+
+ 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 && product_id == 0x0) ||
+ (vendor_id == dev_vid && 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. */
+ int detached = 0;
+ unsigned char data[256];
+
+ /* 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;
+ }
+ 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);
+
+ /* 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 /*******************/
+
+ 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, 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;
+
+ 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;
+ return;
+ }
+ else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
+ dev->shutdown_thread = 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. */
+ libusb_submit_transfer(transfer);
+}
+
+
+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(NULL);
+ if (res < 0) {
+ /* There was an error. Break out of this loop. */
+ break;
+ }
+ }
+
+ /* Cancel any transfer that may be pending. This call will fail
+ if no transfers are pending, but that's OK. */
+ if (libusb_cancel_transfer(dev->transfer) == 0) {
+ /* The transfer was cancelled, so wait for its completion. */
+ libusb_handle_events(NULL);
+ }
+
+ /* 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;
+
+ dev = new_hid_device();
+
+ libusb_device **devs;
+ libusb_device *usb_dev;
+ ssize_t num_devs;
+ int res;
+ int d = 0;
+ int good_open = 0;
+
+ setlocale(LC_ALL,"");
+
+ if (!initialized)
+ hid_init();
+
+ num_devs = libusb_get_device_list(NULL, &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;
+
+ /* 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;
+ }
+ }
+
+ 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;
+
+ /* 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. */
+ struct lang_map_entry *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/gr-fcd/lib/hid/hidapi.h b/gr-fcd/lib/hid/hidapi.h
new file mode 100644
index 000000000..31b1cf206
--- /dev/null
+++ b/gr-fcd/lib/hid/hidapi.h
@@ -0,0 +1,383 @@
+/*******************************************************
+ 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 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 <wchar.h>
+
+#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 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, 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 dev 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.
+ */
+ 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.
+ */
+ 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/gr-fcd/lib/hid/hidmac.c b/gr-fcd/lib/hid/hidmac.c
new file mode 100644
index 000000000..276541be1
--- /dev/null
+++ b/gr-fcd/lib/hid/hidmac.c
@@ -0,0 +1,1122 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 2010-07-03
+
+ Copyright 2010, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU 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 .
+********************************************************/
+
+/* See Apple Technical Note TN2187 for details on IOHidManager. */
+
+#include <IOKit/hid/IOHIDManager.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <wchar.h>
+#include <locale.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "hidapi.h"
+
+/* Barrier implementation because Mac OSX doesn't have pthread_barrier.
+ It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
+ This implementation came from Brent Priddy and was posted on
+ StackOverflow. It is used with his permission. */
+typedef int pthread_barrierattr_t;
+typedef struct pthread_barrier {
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+ int count;
+ int trip_count;
+} pthread_barrier_t;
+
+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+{
+ if(count == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
+ return -1;
+ }
+ if(pthread_cond_init(&barrier->cond, 0) < 0) {
+ pthread_mutex_destroy(&barrier->mutex);
+ return -1;
+ }
+ barrier->trip_count = count;
+ barrier->count = 0;
+
+ return 0;
+}
+
+static int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+ pthread_cond_destroy(&barrier->cond);
+ pthread_mutex_destroy(&barrier->mutex);
+ return 0;
+}
+
+static int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+ pthread_mutex_lock(&barrier->mutex);
+ ++(barrier->count);
+ if(barrier->count >= barrier->trip_count)
+ {
+ barrier->count = 0;
+ pthread_cond_broadcast(&barrier->cond);
+ pthread_mutex_unlock(&barrier->mutex);
+ return 1;
+ }
+ else
+ {
+ pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+ pthread_mutex_unlock(&barrier->mutex);
+ return 0;
+ }
+}
+
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+/* 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_ {
+ IOHIDDeviceRef device_handle;
+ int blocking;
+ int uses_numbered_reports;
+ int disconnected;
+ CFStringRef run_loop_mode;
+ CFRunLoopRef run_loop;
+ CFRunLoopSourceRef source;
+ uint8_t *input_report_buf;
+ CFIndex max_input_report_len;
+ struct input_report *input_reports;
+
+ pthread_t thread;
+ pthread_mutex_t mutex; /* Protects input_reports */
+ pthread_cond_t condition;
+ pthread_barrier_t barrier; /* Ensures correct startup sequence */
+ pthread_barrier_t shutdown_barrier; /* Ensures correct shutdown sequence */
+ int shutdown_thread;
+
+ hid_device *next;
+};
+
+/* Static list of all the devices open. This way when a device gets
+ disconnected, its hid_device structure can be marked as disconnected
+ from hid_device_removal_callback(). */
+static hid_device *device_list = NULL;
+static pthread_mutex_t device_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static hid_device *new_hid_device(void)
+{
+ hid_device *dev = calloc(1, sizeof(hid_device));
+ dev->device_handle = NULL;
+ dev->blocking = 1;
+ dev->uses_numbered_reports = 0;
+ dev->disconnected = 0;
+ dev->run_loop_mode = NULL;
+ dev->run_loop = NULL;
+ dev->source = NULL;
+ dev->input_report_buf = NULL;
+ dev->input_reports = NULL;
+ dev->shutdown_thread = 0;
+ dev->next = NULL;
+
+ /* Thread objects */
+ pthread_mutex_init(&dev->mutex, NULL);
+ pthread_cond_init(&dev->condition, NULL);
+ pthread_barrier_init(&dev->barrier, NULL, 2);
+ pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
+
+ /* Add the new record to the device_list. */
+ pthread_mutex_lock(&device_list_mutex);
+ if (!device_list)
+ device_list = dev;
+ else {
+ hid_device *d = device_list;
+ while (d) {
+ if (!d->next) {
+ d->next = dev;
+ break;
+ }
+ d = d->next;
+ }
+ }
+ pthread_mutex_unlock(&device_list_mutex);
+
+ return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+ if (!dev)
+ return;
+
+ /* Delete any input reports still left over. */
+ struct input_report *rpt = dev->input_reports;
+ while (rpt) {
+ struct input_report *next = rpt->next;
+ free(rpt->data);
+ free(rpt);
+ rpt = next;
+ }
+
+ /* Free the string and the report buffer. The check for NULL
+ is necessary here as CFRelease() doesn't handle NULL like
+ free() and others do. */
+ if (dev->run_loop_mode)
+ CFRelease(dev->run_loop_mode);
+ if (dev->source)
+ CFRelease(dev->source);
+ free(dev->input_report_buf);
+
+ /* Clean up the thread objects */
+ pthread_barrier_destroy(&dev->shutdown_barrier);
+ pthread_barrier_destroy(&dev->barrier);
+ pthread_cond_destroy(&dev->condition);
+ pthread_mutex_destroy(&dev->mutex);
+
+ /* Remove it from the device list. */
+ pthread_mutex_lock(&device_list_mutex);
+ hid_device *d = device_list;
+ if (d == dev) {
+ device_list = d->next;
+ }
+ else {
+ while (d) {
+ if (d->next == dev) {
+ d->next = d->next->next;
+ break;
+ }
+
+ d = d->next;
+ }
+ }
+ pthread_mutex_unlock(&device_list_mutex);
+
+ /* Free the structure itself. */
+ free(dev);
+}
+
+static IOHIDManagerRef hid_mgr = 0x0;
+
+
+#if 0
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+
+static int32_t get_int_property(IOHIDDeviceRef device, CFStringRef key)
+{
+ CFTypeRef ref;
+ int32_t value;
+
+ ref = IOHIDDeviceGetProperty(device, key);
+ if (ref) {
+ if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
+ CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
+ return value;
+ }
+ }
+ return 0;
+}
+
+static unsigned short get_vendor_id(IOHIDDeviceRef device)
+{
+ return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
+}
+
+static unsigned short get_product_id(IOHIDDeviceRef device)
+{
+ return get_int_property(device, CFSTR(kIOHIDProductIDKey));
+}
+
+
+static int32_t get_max_report_length(IOHIDDeviceRef device)
+{
+ return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
+}
+
+static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
+{
+ CFStringRef str = IOHIDDeviceGetProperty(device, prop);
+
+ buf[0] = 0x0000;
+
+ if (str) {
+ CFRange range;
+ range.location = 0;
+ range.length = len;
+ CFIndex used_buf_len;
+ CFStringGetBytes(str,
+ range,
+ kCFStringEncodingUTF32LE,
+ (char)'?',
+ FALSE,
+ (UInt8*)buf,
+ len,
+ &used_buf_len);
+ buf[len-1] = 0x00000000;
+ return used_buf_len;
+ }
+ else
+ return 0;
+
+}
+
+static int get_string_property_utf8(IOHIDDeviceRef device, CFStringRef prop, char *buf, size_t len)
+{
+ CFStringRef str = IOHIDDeviceGetProperty(device, prop);
+
+ buf[0] = 0x0000;
+
+ if (str) {
+ CFRange range;
+ range.location = 0;
+ range.length = len;
+ CFIndex used_buf_len;
+ CFStringGetBytes(str,
+ range,
+ kCFStringEncodingUTF8,
+ (char)'?',
+ FALSE,
+ (UInt8*)buf,
+ len,
+ &used_buf_len);
+ buf[len-1] = 0x00000000;
+ return used_buf_len;
+ }
+ else
+ return 0;
+
+}
+
+
+static int get_serial_number(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+ return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
+}
+
+static int get_manufacturer_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+ return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
+}
+
+static int get_product_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+ return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
+}
+
+
+/* Implementation of wcsdup() for Mac. */
+static wchar_t *dup_wcs(const wchar_t *s)
+{
+ size_t len = wcslen(s);
+ wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
+ wcscpy(ret, s);
+
+ return ret;
+}
+
+
+static int make_path(IOHIDDeviceRef device, char *buf, size_t len)
+{
+ int res;
+ unsigned short vid, pid;
+ char transport[32];
+
+ buf[0] = '\0';
+
+ res = get_string_property_utf8(
+ device, CFSTR(kIOHIDTransportKey),
+ transport, sizeof(transport));
+
+ if (!res)
+ return -1;
+
+ vid = get_vendor_id(device);
+ pid = get_product_id(device);
+
+ res = snprintf(buf, len, "%s_%04hx_%04hx_%p",
+ transport, vid, pid, device);
+
+
+ buf[len-1] = '\0';
+ return res+1;
+}
+
+static int init_hid_manager(void)
+{
+ IOReturn res;
+
+ /* Initialize all the HID Manager Objects */
+ hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+ IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
+ IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+ res = IOHIDManagerOpen(hid_mgr, kIOHIDOptionsTypeNone);
+ return (res == kIOReturnSuccess)? 0: -1;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+ if (!hid_mgr) {
+ if (init_hid_manager() < 0) {
+ hid_exit();
+ return -1;
+ }
+ }
+ return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+ if (hid_mgr) {
+ /* Close the HID manager. */
+ IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
+ CFRelease(hid_mgr);
+ hid_mgr = NULL;
+ }
+
+ return 0;
+}
+
+struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+ struct hid_device_info *root = NULL; // return object
+ struct hid_device_info *cur_dev = NULL;
+ CFIndex num_devices;
+ int i;
+
+ setlocale(LC_ALL,"");
+
+ /* Set up the HID Manager if it hasn't been done */
+ hid_init();
+
+ /* Get a list of the Devices */
+ CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
+
+ /* Convert the list into a C array so we can iterate easily. */
+ num_devices = CFSetGetCount(device_set);
+ IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+ CFSetGetValues(device_set, (const void **) device_array);
+
+ /* Iterate over each device, making an entry for it. */
+ for (i = 0; i < num_devices; i++) {
+ unsigned short dev_vid;
+ unsigned short dev_pid;
+ #define BUF_LEN 256
+ wchar_t buf[BUF_LEN];
+ char cbuf[BUF_LEN];
+
+ IOHIDDeviceRef dev = device_array[i];
+
+ if (!dev) {
+ continue;
+ }
+ dev_vid = get_vendor_id(dev);
+ dev_pid = get_product_id(dev);
+
+ /* Check the VID/PID against the arguments */
+ if ((vendor_id == 0x0 && product_id == 0x0) ||
+ (vendor_id == dev_vid && product_id == dev_pid)) {
+ struct hid_device_info *tmp;
+ size_t len;
+
+ /* VID/PID match. Create the record. */
+ tmp = malloc(sizeof(struct hid_device_info));
+ if (cur_dev) {
+ cur_dev->next = tmp;
+ }
+ else {
+ root = tmp;
+ }
+ cur_dev = tmp;
+
+ // Get the Usage Page and Usage for this device.
+ cur_dev->usage_page = get_int_property(dev, CFSTR(kIOHIDPrimaryUsagePageKey));
+ cur_dev->usage = get_int_property(dev, CFSTR(kIOHIDPrimaryUsageKey));
+
+ /* Fill out the record */
+ cur_dev->next = NULL;
+ len = make_path(dev, cbuf, sizeof(cbuf));
+ cur_dev->path = strdup(cbuf);
+
+ /* Serial Number */
+ get_serial_number(dev, buf, BUF_LEN);
+ cur_dev->serial_number = dup_wcs(buf);
+
+ /* Manufacturer and Product strings */
+ get_manufacturer_string(dev, buf, BUF_LEN);
+ cur_dev->manufacturer_string = dup_wcs(buf);
+ get_product_string(dev, buf, BUF_LEN);
+ cur_dev->product_string = dup_wcs(buf);
+
+ /* VID/PID */
+ cur_dev->vendor_id = dev_vid;
+ cur_dev->product_id = dev_pid;
+
+ /* Release Number */
+ cur_dev->release_number = get_int_property(dev, CFSTR(kIOHIDVersionNumberKey));
+
+ /* Interface Number (Unsupported on Mac)*/
+ cur_dev->interface_number = -1;
+ }
+ }
+
+ free(device_array);
+ CFRelease(device_set);
+
+ return root;
+}
+
+void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+ /* This function is identical to the Linux version. Platform independent. */
+ 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_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+{
+ /* This function is identical to the Linux version. Platform independent. */
+ 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 hid_device_removal_callback(void *context, IOReturn result,
+ void *sender, IOHIDDeviceRef dev_ref)
+{
+ /* Stop the Run Loop for this device. */
+ pthread_mutex_lock(&device_list_mutex);
+ hid_device *d = device_list;
+ while (d) {
+ if (d->device_handle == dev_ref) {
+ d->disconnected = 1;
+ CFRunLoopStop(d->run_loop);
+ }
+
+ d = d->next;
+ }
+ pthread_mutex_unlock(&device_list_mutex);
+}
+
+/* The Run Loop calls this function for each input report received.
+ This function puts the data into a linked list to be picked up by
+ hid_read(). */
+static void hid_report_callback(void *context, IOReturn result, void *sender,
+ IOHIDReportType report_type, uint32_t report_id,
+ uint8_t *report, CFIndex report_length)
+{
+ struct input_report *rpt;
+ hid_device *dev = context;
+
+ /* Make a new Input Report object */
+ rpt = calloc(1, sizeof(struct input_report));
+ rpt->data = calloc(1, report_length);
+ memcpy(rpt->data, report, report_length);
+ rpt->len = report_length;
+ rpt->next = NULL;
+
+ /* Lock this section */
+ 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;
+ }
+ 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);
+ }
+ }
+
+ /* Signal a waiting thread that there is data. */
+ pthread_cond_signal(&dev->condition);
+
+ /* Unlock */
+ pthread_mutex_unlock(&dev->mutex);
+
+}
+
+/* This gets called when the read_thred's run loop gets signaled by
+ hid_close(), and serves to stop the read_thread's run loop. */
+static void perform_signal_callback(void *context)
+{
+ hid_device *dev = context;
+ CFRunLoopStop(dev->run_loop); //TODO: CFRunLoopGetCurrent()
+}
+
+static void *read_thread(void *param)
+{
+ hid_device *dev = param;
+
+ /* Move the device's run loop to this thread. */
+ IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
+
+ /* Create the RunLoopSource which is used to signal the
+ event loop to stop when hid_close() is called. */
+ CFRunLoopSourceContext ctx;
+ memset(&ctx, 0, sizeof(ctx));
+ ctx.version = 0;
+ ctx.info = dev;
+ ctx.perform = &perform_signal_callback;
+ dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
+ CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
+
+ /* Store off the Run Loop so it can be stopped from hid_close()
+ and on device disconnection. */
+ dev->run_loop = CFRunLoopGetCurrent();
+
+ /* Notify the main thread that the read thread is up and running. */
+ pthread_barrier_wait(&dev->barrier);
+
+ /* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
+ reports into the hid_report_callback(). */
+ SInt32 code;
+ while (!dev->shutdown_thread && !dev->disconnected) {
+ code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
+ /* Return if the device has been disconnected */
+ if (code == kCFRunLoopRunFinished) {
+ dev->disconnected = 1;
+ break;
+ }
+
+
+ /* Break if The Run Loop returns Finished or Stopped. */
+ if (code != kCFRunLoopRunTimedOut &&
+ code != kCFRunLoopRunHandledSource) {
+ /* There was some kind of error. Setting
+ shutdown seems to make sense, but
+ there may be something else more appropriate */
+ dev->shutdown_thread = 1;
+ break;
+ }
+ }
+
+ /* 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);
+
+ /* Close the OS handle to the device, but only if it's not
+ been unplugged. If it's been unplugged, then calling
+ IOHIDDeviceClose() will crash. */
+ if (!dev->disconnected) {
+ IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeNone);
+ }
+
+ /* Wait here until hid_close() is called and makes it past
+ the call to CFRunLoopWakeUp(). This thread still needs to
+ be valid when that function is called on the other thread. */
+ pthread_barrier_wait(&dev->shutdown_barrier);
+
+ return NULL;
+}
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+ int i;
+ hid_device *dev = NULL;
+ CFIndex num_devices;
+
+ dev = new_hid_device();
+
+ /* Set up the HID Manager if it hasn't been done */
+ hid_init();
+
+ CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
+
+ num_devices = CFSetGetCount(device_set);
+ IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+ CFSetGetValues(device_set, (const void **) device_array);
+ for (i = 0; i < num_devices; i++) {
+ char cbuf[BUF_LEN];
+ size_t len;
+ IOHIDDeviceRef os_dev = device_array[i];
+
+ len = make_path(os_dev, cbuf, sizeof(cbuf));
+ if (!strcmp(cbuf, path)) {
+ // Matched Paths. Open this Device.
+ IOReturn ret = IOHIDDeviceOpen(os_dev, kIOHIDOptionsTypeNone);
+ if (ret == kIOReturnSuccess) {
+ char str[32];
+
+ free(device_array);
+ CFRelease(device_set);
+ dev->device_handle = os_dev;
+
+ /* Create the buffers for receiving data */
+ dev->max_input_report_len = (CFIndex) get_max_report_length(os_dev);
+ dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));
+
+ /* Create the Run Loop Mode for this device.
+ printing the reference seems to work. */
+ sprintf(str, "HIDAPI_%p", os_dev);
+ dev->run_loop_mode =
+ CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);
+
+ /* Attach the device to a Run Loop */
+ IOHIDDeviceRegisterInputReportCallback(
+ os_dev, dev->input_report_buf, dev->max_input_report_len,
+ &hid_report_callback, dev);
+ IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, hid_device_removal_callback, NULL);
+
+ /* Start the read thread */
+ pthread_create(&dev->thread, NULL, read_thread, dev);
+
+ /* Wait here for the read thread to be initialized. */
+ pthread_barrier_wait(&dev->barrier);
+
+ return dev;
+ }
+ else {
+ goto return_error;
+ }
+ }
+ }
+
+return_error:
+ free(device_array);
+ CFRelease(device_set);
+ free_hid_device(dev);
+ return NULL;
+}
+
+static int set_report(hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
+{
+ const unsigned char *data_to_send;
+ size_t length_to_send;
+ IOReturn res;
+
+ /* Return if the device has been disconnected. */
+ if (dev->disconnected)
+ return -1;
+
+ if (data[0] == 0x0) {
+ /* Not using numbered Reports.
+ Don't send the report number. */
+ data_to_send = data+1;
+ length_to_send = length-1;
+ }
+ else {
+ /* Using numbered Reports.
+ Send the Report Number */
+ data_to_send = data;
+ length_to_send = length;
+ }
+
+ if (!dev->disconnected) {
+ res = IOHIDDeviceSetReport(dev->device_handle,
+ type,
+ data[0], /* Report ID*/
+ data_to_send, length_to_send);
+
+ if (res == kIOReturnSuccess) {
+ return length;
+ }
+ else
+ return -1;
+ }
+
+ return -1;
+}
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+ return set_report(dev, kIOHIDReportTypeOutput, data, length);
+}
+
+/* Helper function, so that this isn't duplicated in hid_read(). */
+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;
+ memcpy(data, rpt->data, len);
+ dev->input_reports = rpt->next;
+ free(rpt->data);
+ free(rpt);
+ return len;
+}
+
+static int cond_wait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+ while (!dev->input_reports) {
+ int res = pthread_cond_wait(cond, mutex);
+ if (res != 0)
+ return res;
+
+ /* A res of 0 means we may have been signaled or it may
+ be a spurious wakeup. Check to see that there's acutally
+ data in the queue before returning, and if not, go back
+ to sleep. See the pthread_cond_timedwait() man page for
+ details. */
+
+ if (dev->shutdown_thread || dev->disconnected)
+ return -1;
+ }
+
+ return 0;
+}
+
+static int cond_timedwait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
+{
+ while (!dev->input_reports) {
+ int res = pthread_cond_timedwait(cond, mutex, abstime);
+ if (res != 0)
+ return res;
+
+ /* A res of 0 means we may have been signaled or it may
+ be a spurious wakeup. Check to see that there's acutally
+ data in the queue before returning, and if not, go back
+ to sleep. See the pthread_cond_timedwait() man page for
+ details. */
+
+ if (dev->shutdown_thread || dev->disconnected)
+ return -1;
+ }
+
+ return 0;
+
+}
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+ int bytes_read = -1;
+
+ /* Lock the access to the report list. */
+ pthread_mutex_lock(&dev->mutex);
+
+ /* 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;
+ }
+
+ /* Return if the device has been disconnected. */
+ if (dev->disconnected) {
+ bytes_read = -1;
+ goto ret;
+ }
+
+ if (dev->shutdown_thread) {
+ /* This means the device has been closed (or there
+ has been an error. An error code of -1 should
+ be returned. */
+ bytes_read = -1;
+ goto ret;
+ }
+
+ /* There is no data. Go to sleep and wait for data. */
+
+ if (milliseconds == -1) {
+ /* Blocking */
+ int res;
+ res = cond_wait(dev, &dev->condition, &dev->mutex);
+ if (res == 0)
+ bytes_read = return_data(dev, data, length);
+ else {
+ /* There was an error, or a device disconnection. */
+ bytes_read = -1;
+ }
+ }
+ else if (milliseconds > 0) {
+ /* Non-blocking, but called with timeout. */
+ int res;
+ struct timespec ts;
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ TIMEVAL_TO_TIMESPEC(&tv, &ts);
+ ts.tv_sec += milliseconds / 1000;
+ ts.tv_nsec += (milliseconds % 1000) * 1000000;
+ if (ts.tv_nsec >= 1000000000L) {
+ ts.tv_sec++;
+ ts.tv_nsec -= 1000000000L;
+ }
+
+ res = cond_timedwait(dev, &dev->condition, &dev->mutex, &ts);
+ if (res == 0)
+ bytes_read = return_data(dev, data, length);
+ else if (res == ETIMEDOUT)
+ bytes_read = 0;
+ else
+ bytes_read = -1;
+ }
+ else {
+ /* Purely non-blocking */
+ bytes_read = 0;
+ }
+
+ret:
+ /* Unlock */
+ pthread_mutex_unlock(&dev->mutex);
+ 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)
+{
+ /* All Nonblocking operation is handled by the library. */
+ dev->blocking = !nonblock;
+
+ return 0;
+}
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+ return set_report(dev, kIOHIDReportTypeFeature, data, length);
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+ CFIndex len = length;
+ IOReturn res;
+
+ /* Return if the device has been unplugged. */
+ if (dev->disconnected)
+ return -1;
+
+ res = IOHIDDeviceGetReport(dev->device_handle,
+ kIOHIDReportTypeFeature,
+ data[0], /* Report ID */
+ data, &len);
+ if (res == kIOReturnSuccess)
+ return len;
+ else
+ return -1;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+ if (!dev)
+ return;
+
+ /* Disconnect the report callback before close. */
+ if (!dev->disconnected) {
+ IOHIDDeviceRegisterInputReportCallback(
+ dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
+ NULL, dev);
+ IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, NULL, dev);
+ IOHIDDeviceUnscheduleFromRunLoop(dev->device_handle, dev->run_loop, dev->run_loop_mode);
+ IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetMain(), kCFRunLoopDefaultMode);
+ }
+
+ /* Cause read_thread() to stop. */
+ dev->shutdown_thread = 1;
+
+ /* Wake up the run thread's event loop so that the thread can exit. */
+ CFRunLoopSourceSignal(dev->source);
+ CFRunLoopWakeUp(dev->run_loop);
+
+ /* Notify the read thread that it can shut down now. */
+ pthread_barrier_wait(&dev->shutdown_barrier);
+
+ /* Wait for read_thread() to end. */
+ pthread_join(dev->thread, NULL);
+
+ /* Close the OS handle to the device, but only if it's not
+ been unplugged. If it's been unplugged, then calling
+ IOHIDDeviceClose() will crash. */
+ if (!dev->disconnected) {
+ IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeNone);
+ }
+
+ /* 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 get_manufacturer_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return get_product_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ return get_serial_number(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+ // TODO:
+
+ return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
+{
+ // TODO:
+
+ return NULL;
+}
+
+
+
+
+
+
+#if 0
+static int32_t get_location_id(IOHIDDeviceRef device)
+{
+ return get_int_property(device, CFSTR(kIOHIDLocationIDKey));
+}
+
+static int32_t get_usage(IOHIDDeviceRef device)
+{
+ int32_t res;
+ res = get_int_property(device, CFSTR(kIOHIDDeviceUsageKey));
+ if (!res)
+ res = get_int_property(device, CFSTR(kIOHIDPrimaryUsageKey));
+ return res;
+}
+
+static int32_t get_usage_page(IOHIDDeviceRef device)
+{
+ int32_t res;
+ res = get_int_property(device, CFSTR(kIOHIDDeviceUsagePageKey));
+ if (!res)
+ res = get_int_property(device, CFSTR(kIOHIDPrimaryUsagePageKey));
+ return res;
+}
+
+static int get_transport(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+ return get_string_property(device, CFSTR(kIOHIDTransportKey), buf, len);
+}
+
+
+int main(void)
+{
+ IOHIDManagerRef mgr;
+ int i;
+
+ mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+ IOHIDManagerSetDeviceMatching(mgr, NULL);
+ IOHIDManagerOpen(mgr, kIOHIDOptionsTypeNone);
+
+ CFSetRef device_set = IOHIDManagerCopyDevices(mgr);
+
+ CFIndex num_devices = CFSetGetCount(device_set);
+ IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+ CFSetGetValues(device_set, (const void **) device_array);
+
+ setlocale(LC_ALL, "");
+
+ for (i = 0; i < num_devices; i++) {
+ IOHIDDeviceRef dev = device_array[i];
+ printf("Device: %p\n", dev);
+ printf(" %04hx %04hx\n", get_vendor_id(dev), get_product_id(dev));
+
+ wchar_t serial[256], buf[256];
+ char cbuf[256];
+ get_serial_number(dev, serial, 256);
+
+
+ printf(" Serial: %ls\n", serial);
+ printf(" Loc: %ld\n", get_location_id(dev));
+ get_transport(dev, buf, 256);
+ printf(" Trans: %ls\n", buf);
+ make_path(dev, cbuf, 256);
+ printf(" Path: %s\n", cbuf);
+
+ }
+
+ return 0;
+}
+#endif
diff --git a/gr-fcd/lib/hid/hidwin.c b/gr-fcd/lib/hid/hidwin.c
new file mode 100644
index 000000000..26d870fd8
--- /dev/null
+++ b/gr-fcd/lib/hid/hidwin.c
@@ -0,0 +1,873 @@
+/*******************************************************
+ 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 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 .
+********************************************************/
+
+#include <windows.h>
+
+#ifndef _NTDEF_
+typedef LONG NTSTATUS;
+#endif
+
+#ifdef __MINGW32__
+#include <ntdef.h>
+#include <winbase.h>
+#endif
+
+#ifdef __CYGWIN__
+#include <ntdef.h>
+#define _wcsdup wcsdup
+#endif
+
+//#define HIDAPI_USE_DDK
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ #include <setupapi.h>
+ #include <winioctl.h>
+ #ifdef HIDAPI_USE_DDK
+ #include <hidsdi.h>
+ #endif
+
+ // Copied from inc/ddk/hidclass.h, part of the Windows DDK.
+ #define HID_OUT_CTL_CODE(id) \
+ CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+ #define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include "hidapi.h"
+
+#ifdef _MSC_VER
+ // Thanks Microsoft, but I know how to use strncpy().
+ #pragma warning(disable:4996)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef HIDAPI_USE_DDK
+ // Since we're not building with the DDK, and the HID header
+ // files aren't part of the SDK, we have to define all this
+ // stuff here. In lookup_functions(), the function pointers
+ // defined below are set.
+ typedef struct _HIDD_ATTRIBUTES{
+ ULONG Size;
+ USHORT VendorID;
+ USHORT ProductID;
+ USHORT VersionNumber;
+ } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+ typedef USHORT USAGE;
+ typedef struct _HIDP_CAPS {
+ USAGE Usage;
+ USAGE UsagePage;
+ USHORT InputReportByteLength;
+ USHORT OutputReportByteLength;
+ USHORT FeatureReportByteLength;
+ USHORT Reserved[17];
+ USHORT fields_not_used_by_hidapi[10];
+ } HIDP_CAPS, *PHIDP_CAPS;
+ typedef char* HIDP_PREPARSED_DATA;
+ #define HIDP_STATUS_SUCCESS 0x0
+
+ typedef BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib);
+ typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len);
+ typedef BOOLEAN (__stdcall *HidD_GetManufacturerString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+ typedef BOOLEAN (__stdcall *HidD_GetProductString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+ typedef BOOLEAN (__stdcall *HidD_SetFeature_)(HANDLE handle, PVOID data, ULONG length);
+ typedef BOOLEAN (__stdcall *HidD_GetFeature_)(HANDLE handle, PVOID data, ULONG length);
+ typedef BOOLEAN (__stdcall *HidD_GetIndexedString_)(HANDLE handle, ULONG string_index, PVOID buffer, ULONG buffer_len);
+ typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, HIDP_PREPARSED_DATA **preparsed_data);
+ typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(HIDP_PREPARSED_DATA *preparsed_data);
+ typedef BOOLEAN (__stdcall *HidP_GetCaps_)(HIDP_PREPARSED_DATA *preparsed_data, HIDP_CAPS *caps);
+
+ static HidD_GetAttributes_ HidD_GetAttributes;
+ static HidD_GetSerialNumberString_ HidD_GetSerialNumberString;
+ static HidD_GetManufacturerString_ HidD_GetManufacturerString;
+ static HidD_GetProductString_ HidD_GetProductString;
+ static HidD_SetFeature_ HidD_SetFeature;
+ static HidD_GetFeature_ HidD_GetFeature;
+ static HidD_GetIndexedString_ HidD_GetIndexedString;
+ static HidD_GetPreparsedData_ HidD_GetPreparsedData;
+ static HidD_FreePreparsedData_ HidD_FreePreparsedData;
+ static HidP_GetCaps_ HidP_GetCaps;
+
+ static HMODULE lib_handle = NULL;
+ static BOOLEAN initialized = FALSE;
+#endif // HIDAPI_USE_DDK
+
+struct hid_device_ {
+ HANDLE device_handle;
+ BOOL blocking;
+ size_t input_report_length;
+ void *last_error_str;
+ DWORD last_error_num;
+ BOOL read_pending;
+ char *read_buf;
+ OVERLAPPED ol;
+};
+
+static hid_device *new_hid_device()
+{
+ hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
+ dev->device_handle = INVALID_HANDLE_VALUE;
+ dev->blocking = TRUE;
+ dev->input_report_length = 0;
+ dev->last_error_str = NULL;
+ dev->last_error_num = 0;
+ dev->read_pending = FALSE;
+ dev->read_buf = NULL;
+ memset(&dev->ol, 0, sizeof(dev->ol));
+ dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*inital state f=nonsignaled*/, NULL);
+
+ return dev;
+}
+
+
+static void register_error(hid_device *device, const char *op)
+{
+ WCHAR *ptr, *msg;
+
+ FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ GetLastError(),
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPWSTR)&msg, 0/*sz*/,
+ NULL);
+
+ // Get rid of the CR and LF that FormatMessage() sticks at the
+ // end of the message. Thanks Microsoft!
+ ptr = msg;
+ while (*ptr) {
+ if (*ptr == '\r') {
+ *ptr = 0x0000;
+ break;
+ }
+ ptr++;
+ }
+
+ // Store the message off in the Device entry so that
+ // the hid_error() function can pick it up.
+ LocalFree(device->last_error_str);
+ device->last_error_str = msg;
+}
+
+#ifndef HIDAPI_USE_DDK
+static int lookup_functions()
+{
+ lib_handle = LoadLibraryA("hid.dll");
+ if (lib_handle) {
+#define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1;
+ RESOLVE(HidD_GetAttributes);
+ RESOLVE(HidD_GetSerialNumberString);
+ RESOLVE(HidD_GetManufacturerString);
+ RESOLVE(HidD_GetProductString);
+ RESOLVE(HidD_SetFeature);
+ RESOLVE(HidD_GetFeature);
+ RESOLVE(HidD_GetIndexedString);
+ RESOLVE(HidD_GetPreparsedData);
+ RESOLVE(HidD_FreePreparsedData);
+ RESOLVE(HidP_GetCaps);
+#undef RESOLVE
+ }
+ else
+ return -1;
+
+ return 0;
+}
+#endif
+
+static HANDLE open_device(const char *path)
+{
+ HANDLE handle;
+
+ /* First, try to open with sharing mode turned off. This will make it so
+ that a HID device can only be opened once. This is to be consistent
+ with the behavior on the other platforms. */
+ handle = CreateFileA(path,
+ GENERIC_WRITE |GENERIC_READ,
+ 0, /*share mode*/
+ NULL,
+ OPEN_EXISTING,
+ FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_NORMAL,
+ 0);
+
+ if (handle == INVALID_HANDLE_VALUE) {
+ /* Couldn't open the device. Some devices must be opened
+ with sharing enabled (even though they are only opened once),
+ so try it here. */
+ handle = CreateFileA(path,
+ GENERIC_WRITE |GENERIC_READ,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, /*share mode*/
+ NULL,
+ OPEN_EXISTING,
+ FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_NORMAL,
+ 0);
+ }
+
+ return handle;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+#ifndef HIDAPI_USE_DDK
+ if (!initialized) {
+ if (lookup_functions() < 0) {
+ hid_exit();
+ return -1;
+ }
+ initialized = TRUE;
+ }
+#endif
+ return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+#ifndef HIDAPI_USE_DDK
+ if (lib_handle)
+ FreeLibrary(lib_handle);
+ lib_handle = NULL;
+ initialized = FALSE;
+#endif
+ return 0;
+}
+
+struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+ BOOL res;
+ struct hid_device_info *root = NULL; // return object
+ struct hid_device_info *cur_dev = NULL;
+
+ // Windows objects for interacting with the driver.
+ GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, {0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30} };
+ SP_DEVINFO_DATA devinfo_data;
+ SP_DEVICE_INTERFACE_DATA device_interface_data;
+ SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL;
+ HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
+ int device_index = 0;
+
+ if (hid_init() < 0)
+ return NULL;
+
+ // Initialize the Windows objects.
+ devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
+ device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+
+ // Get information for all the devices belonging to the HID class.
+ device_info_set = SetupDiGetClassDevsA(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+
+ // Iterate over each device in the HID class, looking for the right one.
+
+ for (;;) {
+ HANDLE write_handle = INVALID_HANDLE_VALUE;
+ DWORD required_size = 0;
+ HIDD_ATTRIBUTES attrib;
+
+ res = SetupDiEnumDeviceInterfaces(device_info_set,
+ NULL,
+ &InterfaceClassGuid,
+ device_index,
+ &device_interface_data);
+
+ if (!res) {
+ // A return of FALSE from this function means that
+ // there are no more devices.
+ break;
+ }
+
+ // Call with 0-sized detail size, and let the function
+ // tell us how long the detail struct needs to be. The
+ // size is put in &required_size.
+ res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+ &device_interface_data,
+ NULL,
+ 0,
+ &required_size,
+ NULL);
+
+ // Allocate a long enough structure for device_interface_detail_data.
+ device_interface_detail_data = (SP_DEVICE_INTERFACE_DETAIL_DATA_A*) malloc(required_size);
+ device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+
+ // Get the detailed data for this device. The detail data gives us
+ // the device path for this device, which is then passed into
+ // CreateFile() to get a handle to the device.
+ res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+ &device_interface_data,
+ device_interface_detail_data,
+ required_size,
+ NULL,
+ NULL);
+
+ if (!res) {
+ //register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");
+ // Continue to the next device.
+ goto cont;
+ }
+
+ //wprintf(L"HandleName: %s\n", device_interface_detail_data->DevicePath);
+
+ // Open a handle to the device
+ write_handle = open_device(device_interface_detail_data->DevicePath);
+
+ // Check validity of write_handle.
+ if (write_handle == INVALID_HANDLE_VALUE) {
+ // Unable to open the device.
+ //register_error(dev, "CreateFile");
+ goto cont_close;
+ }
+
+
+ // Get the Vendor ID and Product ID for this device.
+ attrib.Size = sizeof(HIDD_ATTRIBUTES);
+ HidD_GetAttributes(write_handle, &attrib);
+ //wprintf(L"Product/Vendor: %x %x\n", attrib.ProductID, attrib.VendorID);
+
+ // Check the VID/PID to see if we should add this
+ // device to the enumeration list.
+ if ((vendor_id == 0x0 && product_id == 0x0) ||
+ (attrib.VendorID == vendor_id && attrib.ProductID == product_id)) {
+
+ #define WSTR_LEN 512
+ const char *str;
+ struct hid_device_info *tmp;
+ HIDP_PREPARSED_DATA *pp_data = NULL;
+ HIDP_CAPS caps;
+ BOOLEAN res;
+ NTSTATUS nt_res;
+ wchar_t wstr[WSTR_LEN]; // TODO: Determine Size
+ size_t len;
+
+ /* VID/PID match. Create the record. */
+ tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
+ if (cur_dev) {
+ cur_dev->next = tmp;
+ }
+ else {
+ root = tmp;
+ }
+ cur_dev = tmp;
+
+ // Get the Usage Page and Usage for this device.
+ res = HidD_GetPreparsedData(write_handle, &pp_data);
+ if (res) {
+ nt_res = HidP_GetCaps(pp_data, &caps);
+ if (nt_res == HIDP_STATUS_SUCCESS) {
+ cur_dev->usage_page = caps.UsagePage;
+ cur_dev->usage = caps.Usage;
+ }
+
+ HidD_FreePreparsedData(pp_data);
+ }
+
+ /* Fill out the record */
+ cur_dev->next = NULL;
+ str = device_interface_detail_data->DevicePath;
+ if (str) {
+ len = strlen(str);
+ cur_dev->path = (char*) calloc(len+1, sizeof(char));
+ strncpy(cur_dev->path, str, len+1);
+ cur_dev->path[len] = '\0';
+ }
+ else
+ cur_dev->path = NULL;
+
+ /* Serial Number */
+ res = HidD_GetSerialNumberString(write_handle, wstr, sizeof(wstr));
+ wstr[WSTR_LEN-1] = 0x0000;
+ if (res) {
+ cur_dev->serial_number = _wcsdup(wstr);
+ }
+
+ /* Manufacturer String */
+ res = HidD_GetManufacturerString(write_handle, wstr, sizeof(wstr));
+ wstr[WSTR_LEN-1] = 0x0000;
+ if (res) {
+ cur_dev->manufacturer_string = _wcsdup(wstr);
+ }
+
+ /* Product String */
+ res = HidD_GetProductString(write_handle, wstr, sizeof(wstr));
+ wstr[WSTR_LEN-1] = 0x0000;
+ if (res) {
+ cur_dev->product_string = _wcsdup(wstr);
+ }
+
+ /* VID/PID */
+ cur_dev->vendor_id = attrib.VendorID;
+ cur_dev->product_id = attrib.ProductID;
+
+ /* Release Number */
+ cur_dev->release_number = attrib.VersionNumber;
+
+ /* Interface Number. It can sometimes be parsed out of the path
+ on Windows if a device has multiple interfaces. See
+ http://msdn.microsoft.com/en-us/windows/hardware/gg487473 or
+ search for "Hardware IDs for HID Devices" at MSDN. If it's not
+ in the path, it's set to -1. */
+ cur_dev->interface_number = -1;
+ if (cur_dev->path) {
+ char *interface_component = strstr(cur_dev->path, "&mi_");
+ if (interface_component) {
+ char *hex_str = interface_component + 4;
+ char *endptr = NULL;
+ cur_dev->interface_number = strtol(hex_str, &endptr, 16);
+ if (endptr == hex_str) {
+ /* The parsing failed. Set interface_number to -1. */
+ cur_dev->interface_number = -1;
+ }
+ }
+ }
+ }
+
+cont_close:
+ CloseHandle(write_handle);
+cont:
+ // We no longer need the detail data. It can be freed
+ free(device_interface_detail_data);
+
+ device_index++;
+
+ }
+
+ // Close the device information handle.
+ SetupDiDestroyDeviceInfoList(device_info_set);
+
+ return root;
+
+}
+
+void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
+{
+ // TODO: Merge this with the Linux version. This function is platform-independent.
+ 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_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+{
+ // TODO: Merge this functions with the Linux version. This function should be platform independent.
+ 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;
+}
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path)
+{
+ hid_device *dev;
+ HIDP_CAPS caps;
+ HIDP_PREPARSED_DATA *pp_data = NULL;
+ BOOLEAN res;
+ NTSTATUS nt_res;
+
+ if (hid_init() < 0) {
+ return NULL;
+ }
+
+ dev = new_hid_device();
+
+ // Open a handle to the device
+ dev->device_handle = open_device(path);
+
+ // Check validity of write_handle.
+ if (dev->device_handle == INVALID_HANDLE_VALUE) {
+ // Unable to open the device.
+ register_error(dev, "CreateFile");
+ goto err;
+ }
+
+ // Get the Input Report length for the device.
+ res = HidD_GetPreparsedData(dev->device_handle, &pp_data);
+ if (!res) {
+ register_error(dev, "HidD_GetPreparsedData");
+ goto err;
+ }
+ nt_res = HidP_GetCaps(pp_data, &caps);
+ if (nt_res != HIDP_STATUS_SUCCESS) {
+ register_error(dev, "HidP_GetCaps");
+ goto err_pp_data;
+ }
+ dev->input_report_length = caps.InputReportByteLength;
+ HidD_FreePreparsedData(pp_data);
+
+ dev->read_buf = (char*) malloc(dev->input_report_length);
+
+ return dev;
+
+err_pp_data:
+ HidD_FreePreparsedData(pp_data);
+err:
+ CloseHandle(dev->device_handle);
+ free(dev);
+ return NULL;
+}
+
+int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+ DWORD bytes_written;
+ BOOL res;
+
+ OVERLAPPED ol;
+ memset(&ol, 0, sizeof(ol));
+
+ res = WriteFile(dev->device_handle, data, length, NULL, &ol);
+
+ if (!res) {
+ if (GetLastError() != ERROR_IO_PENDING) {
+ // WriteFile() failed. Return error.
+ register_error(dev, "WriteFile");
+ return -1;
+ }
+ }
+
+ // Wait here until the write is done. This makes
+ // hid_write() synchronous.
+ res = GetOverlappedResult(dev->device_handle, &ol, &bytes_written, TRUE/*wait*/);
+ if (!res) {
+ // The Write operation failed.
+ register_error(dev, "WriteFile");
+ return -1;
+ }
+
+ return bytes_written;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+ DWORD bytes_read = 0;
+ BOOL res;
+
+ // Copy the handle for convenience.
+ HANDLE ev = dev->ol.hEvent;
+
+ if (!dev->read_pending) {
+ // Start an Overlapped I/O read.
+ dev->read_pending = TRUE;
+ ResetEvent(ev);
+ res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol);
+
+ if (!res) {
+ if (GetLastError() != ERROR_IO_PENDING) {
+ // ReadFile() has failed.
+ // Clean up and return error.
+ CancelIo(dev->device_handle);
+ dev->read_pending = FALSE;
+ goto end_of_function;
+ }
+ }
+ }
+
+ if (milliseconds >= 0) {
+ // See if there is any data yet.
+ res = WaitForSingleObject(ev, milliseconds);
+ if (res != WAIT_OBJECT_0) {
+ // There was no data this time. Return zero bytes available,
+ // but leave the Overlapped I/O running.
+ return 0;
+ }
+ }
+
+ // Either WaitForSingleObject() told us that ReadFile has completed, or
+ // we are in non-blocking mode. Get the number of bytes read. The actual
+ // data has been copied to the data[] array which was passed to ReadFile().
+ res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
+
+ // Set pending back to false, even if GetOverlappedResult() returned error.
+ dev->read_pending = FALSE;
+
+ if (res && bytes_read > 0) {
+ if (dev->read_buf[0] == 0x0) {
+ /* If report numbers aren't being used, but Windows sticks a report
+ number (0x0) on the beginning of the report anyway. To make this
+ work like the other platforms, and to make it work more like the
+ HID spec, we'll skip over this byte. */
+ bytes_read--;
+ memcpy(data, dev->read_buf+1, length);
+ }
+ else {
+ /* Copy the whole buffer, report number and all. */
+ memcpy(data, dev->read_buf, length);
+ }
+ }
+
+end_of_function:
+ if (!res) {
+ register_error(dev, "GetOverlappedResult");
+ return -1;
+ }
+
+ return bytes_read;
+}
+
+int HID_API_EXPORT HID_API_CALL 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_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+ dev->blocking = !nonblock;
+ return 0; /* Success */
+}
+
+int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+ BOOL res = HidD_SetFeature(dev->device_handle, (PVOID)data, length);
+ if (!res) {
+ register_error(dev, "HidD_SetFeature");
+ return -1;
+ }
+
+ return length;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+ BOOL res;
+#if 0
+ res = HidD_GetFeature(dev->device_handle, data, length);
+ if (!res) {
+ register_error(dev, "HidD_GetFeature");
+ return -1;
+ }
+ return 0; /* HidD_GetFeature() doesn't give us an actual length, unfortunately */
+#else
+ DWORD bytes_returned;
+
+ OVERLAPPED ol;
+ memset(&ol, 0, sizeof(ol));
+
+ res = DeviceIoControl(dev->device_handle,
+ IOCTL_HID_GET_FEATURE,
+ data, length,
+ data, length,
+ &bytes_returned, &ol);
+
+ if (!res) {
+ if (GetLastError() != ERROR_IO_PENDING) {
+ // DeviceIoControl() failed. Return error.
+ register_error(dev, "Send Feature Report DeviceIoControl");
+ return -1;
+ }
+ }
+
+ // Wait here until the write is done. This makes
+ // hid_get_feature_report() synchronous.
+ res = GetOverlappedResult(dev->device_handle, &ol, &bytes_returned, TRUE/*wait*/);
+ if (!res) {
+ // The operation failed.
+ register_error(dev, "Send Feature Report GetOverLappedResult");
+ return -1;
+ }
+ return bytes_returned;
+#endif
+}
+
+void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
+{
+ if (!dev)
+ return;
+ CancelIo(dev->device_handle);
+ CloseHandle(dev->ol.hEvent);
+ CloseHandle(dev->device_handle);
+ LocalFree(dev->last_error_str);
+ free(dev->read_buf);
+ free(dev);
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ BOOL res;
+
+ res = HidD_GetManufacturerString(dev->device_handle, string, 2 * maxlen);
+ if (!res) {
+ register_error(dev, "HidD_GetManufacturerString");
+ return -1;
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ BOOL res;
+
+ res = HidD_GetProductString(dev->device_handle, string, 2 * maxlen);
+ if (!res) {
+ register_error(dev, "HidD_GetProductString");
+ return -1;
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+ BOOL res;
+
+ res = HidD_GetSerialNumberString(dev->device_handle, string, 2 * maxlen);
+ if (!res) {
+ register_error(dev, "HidD_GetSerialNumberString");
+ return -1;
+ }
+
+ return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+ BOOL res;
+
+ res = HidD_GetIndexedString(dev->device_handle, string_index, string, 2 * maxlen);
+ if (!res) {
+ register_error(dev, "HidD_GetIndexedString");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
+{
+ return (wchar_t*)dev->last_error_str;
+}
+
+
+//#define PICPGM
+//#define S11
+#define P32
+#ifdef S11
+ unsigned short VendorID = 0xa0a0;
+ unsigned short ProductID = 0x0001;
+#endif
+
+#ifdef P32
+ unsigned short VendorID = 0x04d8;
+ unsigned short ProductID = 0x3f;
+#endif
+
+
+#ifdef PICPGM
+ unsigned short VendorID = 0x04d8;
+ unsigned short ProductID = 0x0033;
+#endif
+
+
+#if 0
+int __cdecl main(int argc, char* argv[])
+{
+ int res;
+ unsigned char buf[65];
+
+ UNREFERENCED_PARAMETER(argc);
+ UNREFERENCED_PARAMETER(argv);
+
+ // Set up the command buffer.
+ memset(buf,0x00,sizeof(buf));
+ buf[0] = 0;
+ buf[1] = 0x81;
+
+
+ // Open the device.
+ int handle = open(VendorID, ProductID, L"12345");
+ if (handle < 0)
+ printf("unable to open device\n");
+
+
+ // Toggle LED (cmd 0x80)
+ buf[1] = 0x80;
+ res = write(handle, buf, 65);
+ if (res < 0)
+ printf("Unable to write()\n");
+
+ // Request state (cmd 0x81)
+ buf[1] = 0x81;
+ write(handle, buf, 65);
+ if (res < 0)
+ printf("Unable to write() (2)\n");
+
+ // Read requested state
+ read(handle, buf, 65);
+ if (res < 0)
+ printf("Unable to read()\n");
+
+ // Print out the returned buffer.
+ for (int i = 0; i < 4; i++)
+ printf("buf[%d]: %d\n", i, buf[i]);
+
+ return 0;
+}
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
generated by cgit (git 2.34.1) at 2024-12-21 07:00:27 +0000