From a540559b83885b19e210b205b7142a84b56192ae Mon Sep 17 00:00:00 2001 From: Daniel Kulp Date: Mon, 2 Sep 2019 18:26:09 -0400 Subject: [PATCH] Update vast to be a c++ plugin --- .gitignore | 34 + .gitmodules | 3 - Makefile | 22 + callbacks.sh | 20 +- pluginInfo.json | 21 +- plugin_setup.php | 201 +++--- src/FPPVastFM.cpp | 214 +++++++ src/Si4713.cpp | 695 +++++++++++++++++++++ src/Si4713.h | 63 ++ src/bitstream.c | 123 ++++ src/bitstream.h | 42 ++ src/hid.c | 1514 +++++++++++++++++++++++++++++++++++++++++++++ src/hidapi.h | 391 ++++++++++++ vastfmt | 1 - 14 files changed, 3193 insertions(+), 151 deletions(-) create mode 100755 Makefile mode change 100644 => 100755 pluginInfo.json create mode 100755 src/FPPVastFM.cpp create mode 100755 src/Si4713.cpp create mode 100755 src/Si4713.h create mode 100755 src/bitstream.c create mode 100755 src/bitstream.h create mode 100755 src/hid.c create mode 100755 src/hidapi.h delete mode 160000 vastfmt diff --git a/.gitignore b/.gitignore index e69de29..6530728 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,34 @@ +._* + +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app diff --git a/.gitmodules b/.gitmodules index b693952..e69de29 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "vastfmt"] - path = vastfmt - url = https://github.com/fatpelt/vastfmt.git diff --git a/Makefile b/Makefile new file mode 100755 index 0000000..f450106 --- /dev/null +++ b/Makefile @@ -0,0 +1,22 @@ +include /opt/fpp/src/makefiles/common/setup.mk + +all: libfpp-vastfmt.so +debug: all + +CFLAGS+=-I. -I./vastfmt -I/usr/include/libusb-1.0 +OBJECTS_fpp_vastfmt_so += src/FPPVastFM.o src/hid.o src/Si4713.o src/bitstream.o +LIBS_fpp_vastfmt_so += -L/opt/fpp/src -lfpp -lusb-1.0 +CXXFLAGS_src/FPPVastFM.o += -I/opt/fpp/src + + +%.o: %.cpp Makefile + $(CCACHE) $(CC) $(CFLAGS) $(CXXFLAGS) $(CXXFLAGS_$@) -c $< -o $@ + +%.o: %.c Makefile + $(CCACHE) gcc $(CFLAGS) $(CFLAGS_$@) -c $< -o $@ + +libfpp-vastfmt.so: $(OBJECTS_fpp_vastfmt_so) /opt/fpp/src/libfpp.so + $(CCACHE) $(CC) -shared $(CFLAGS_$@) $(OBJECTS_fpp_vastfmt_so) $(LIBS_fpp_vastfmt_so) $(LDFLAGS) -o $@ + +clean: + rm -f libfpp-vastfmt.so $(OBJECTS_fpp_vastfmt_so) diff --git a/callbacks.sh b/callbacks.sh index 21b34bb..76cd50c 100755 --- a/callbacks.sh +++ b/callbacks.sh @@ -27,19 +27,8 @@ eval set -- "$OPTS" while true; do case $1 in -l|--list) - echo "media,playlist"; exit 0; - ;; - -t|--type) - shift - case $1 in - media|playlist) - operation=$1 - ;; - *) - die "Error: Unsupported type $1!" - ;; - esac - shift; continue + echo "c++"; + exit 0; ;; -h|--help) usage @@ -49,11 +38,6 @@ while true; do printf "%s, version %s\n" "$PROGRAM_NAME" "$PROGRAM_VERSION" exit 0 ;; - -d|--data) - shift - DATA=$(echo $1 | tr -dc '[:alnum:][:space:][:punct:]') - shift; continue - ;; --) # no more arguments to parse break diff --git a/pluginInfo.json b/pluginInfo.json old mode 100644 new mode 100755 index fdadfb5..04aba56 --- a/pluginInfo.json +++ b/pluginInfo.json @@ -21,13 +21,20 @@ "allowUpdates": 0, "sha": "749dc6bce52276a44e1223647809083947aa037d" }, - { - "minFPPVersion": "3.0", - "maxFPPVersion": "0", - "branch": "master", - "allowUpdates": 1, - "sha": "" - } + { + "minFPPVersion": "3.0", + "maxFPPVersion": "3.2.99", + "branch": "master", + "sha": "ada07e1d19f5eb7cafb6be65f0e4791afd770201", + "allowUpdates": 0, + }, + { + "minFPPVersion": "3.3", + "maxFPPVersion": "0", + "branch": "master", + "sha": "", + "allowUpdates": 0, + } ] } diff --git a/plugin_setup.php b/plugin_setup.php index 7dfd05f..5eaa69e 100755 --- a/plugin_setup.php +++ b/plugin_setup.php @@ -1,146 +1,103 @@ - + -
-
-Transmitter Information -

Vast Electronics V-FMT212R: Detected" : "Not Detected" ); ?>

- - -

To configure FPP to use the FM transmitter for audio output, go to the settings page and select "Transmitter" from the drop-down for "Audio Output Device".

- -

To use the VastFMT for audio output, please plug in device and reboot.

- +
+
+VAST-FMT Plugin Settings +

Start VAST-FMT at: "FPPDStart", "Playlist Start"=>"PlaylistStart", "Never"=>"Never"), "fpp-vastfmt", ""); ?>
+At Start, the VAST-FMT is reset, FM settings initialized, will broadcast any audio played, and send static RDS messages (if enabled).

+

Stop VAST-FMT at: "PlaylistStop", "Never (default)"=>"Never"), "fpp-vastfmt", ""); ?>
+At Stop, the VAST-FMT is reset. Listeners will hear static.


- - -
+
-Transmitter Settings - - - -

Toggle transmitter with playlist:

-

Power: dBμV

-

Set frequency on playlist start/stop:

-

Frequency: MHz

-

RDS Type: "disabled", "RT+"=>"rtp", "RT"=>"rt", "PS"=>"ps"), "fpp-vastfmt", "toggleStation"); ?>

-

RDS Static Text:

-

Station ID:

- +VAST-FMT FM Settings +

Frequency (76.00-108.00): MHz

+

Power (88-115, 116-120*): dBμV +
*Can be set as high as 120dBμV, but voltage accuracy above 115dBμV is not guaranteed.

+

Preemphasis: "50us", "75μs (USA, default)"=>"75us"), "fpp-vastfmt", ""); ?>

+

Antenna Tuning Capacitor (0=Auto, 1-191): * 0.25pF


-
-
-Plugin Information -

Instructions -

    -
  • Setup transmitter and save to EEPROM, or click the "Toggle transmitter -with playlist" option above.
    • -
  • Change audio on "FPP Settings" page. Go to the FPP Settings screen and -select the Vast as your sound output instead of the Pi's built-in audio.
    • -
  • Tag your MP3s/OGG files appropriate. The tags are used to set the Artist -and Title fields for RDS's RT+ text. The rest will happen auto-magically!
    • -
-

- - - -
+
-RDS Support Instructions - -

You're running an old version of FPP that doesn't yet contain the required -helper functions needed by this plugin. Advanced features are disabled.

- -

You must first set up your Vast V-FMT212R using the Vast Electronics -software and save it to the EEPROM. Once you have your VAST setup to transmit -on your frequency when booted, you can plug it into the Raspberry Pi and -reboot. You will then go to the FPP Settings screen and select the Vast as -your sound output instead of the Pi's built-in audio.

+VAST-FMT RDS Settings +

Enable RDS:

+

RDS Station - Sent 8 characters at a time

+

Station Text: - - -

Known Issues: -

    -
  • VastFMT will "crash" and be unable to receive RDS data if not used with -a powered USB hub. If this happens, the transmitter must be unplugged and re- -plugged into the Pi - Bug 2
    • -
+
-Planned Features: -
    -
  • Saving settings to EEPROM.
    • -
+

RDS Text: +

+Place {Artist} or {Title} where the media artist/title should be placed. Area's wrapped in brackets ( [] ) will not be output unless media is present. + + +

Program Type (PTY North America / Europe): 0, +"1 - News / News"=>1, +"2 - Information / Current Affairs"=>2, +"3 - Sport / Information"=>3, +"4 - Talk / Sport"=>4, +"5 - Rock / Education"=>5, +"6 - Classic Rock / Drama"=>6, +"7 - Adult Hits / Culture"=>7, +"8 - Soft Rock / Science"=>8, +"9 - Top 40 / Varied"=>9, +"10 - Country / Pop"=>10, +"11 - Oldies / Rock"=>11, +"12 - Soft Music / Easy Listening"=>12, +"13 - Nostalgia / Light Classical"=>13, +"14 - Jazz / Serious Classical"=>14, +"15 - Classical / Other Music"=>15, +"16 - R&B / Weather"=>16, +"17 - Soft R&B / Finance"=>17, +"18 - Language / Childrens"=>18, +"19 - Religious Music / Social Affairs"=>19, +"20 - Religious Talk / Religion"=>20, +"21 - Personality / Phone-In"=>21, +"22 - Public / Travel"=>22, +"23 - College / Leisure"=>23, +"24 - --- / Jazz"=>24, +"25 - --- / Country"=>25, +"26 - --- / National Music"=>26, +"27 - --- / Oldies"=>27, +"28 - --- / Folk"=>28, +"29 - Weather / Documentary"=>29), +"fpp-vastfmt", ""); ?> - Additional PTY information

+
+
-

To report a bug, please file it against the fpp-vastfmt plugin project here: -fpp-vastfmt GitHub Issues

+
-
+ +
diff --git a/src/FPPVastFM.cpp b/src/FPPVastFM.cpp new file mode 100755 index 0000000..5403de1 --- /dev/null +++ b/src/FPPVastFM.cpp @@ -0,0 +1,214 @@ +#include +#include + +#include +#include + +#include +#include "mediadetails.h" +#include "common.h" +#include "settings.h" +#include "Plugin.h" +#include "log.h" + +#include "Si4713.h" + + +// VASTFM vendor/product +//HID\VID_0451&PID_2100&REV_0101&MI_02 +const uint16_t _usVID=0x0451; /*!< USB vendor ID. */ +const uint16_t _usPID=0x2100; /*!< USB product ID. */ + +static std::string padToNearest(std::string s, int l) { + if (!s.empty()) { + int n = 0; + while (n < s.size()) { + n += l; + } + if (n != s.size()) { + size_t a = n - s.size(); + s.append(a, ' '); + } + } + return s; +} +static void padTo(std::string &s, int l) { + size_t n = l - s.size(); + if (n) { + s.append(n, ' '); + } +} + +class FPPVastFMPlugin : public FPPPlugin { +public: + bool enabled = true; + FPPVastFMPlugin() : FPPPlugin("fpp-vastfmt") { + setDefaultSettings(); + if (settings["Start"] == "FPPDStart") { + startVast(); + } + } + virtual ~FPPVastFMPlugin() { + if (si4713 != nullptr) { + //si4713->powerDown(); + delete si4713; + si4713 = nullptr; + } + } + + void startVast() { + if (si4713 == nullptr) { + si4713 = new Si4713(_usVID, _usPID); + if (si4713->isOk()) { + si4713->powerUp(); + + std::string rev = si4713->getRev(); + LogInfo(VB_PLUGIN, "VAST-FMT: %s\n", rev.c_str()); + + if (settings["Preemphasis"] == "50us") { + si4713->setEUPreemphasis(); + } + + float f = std::stoi(settings["AntCap"]); + si4713->setTXPower(std::stoi(settings["Power"]), f); + + std::string freq = settings["Frequency"]; + f = std::stof(freq); + f *= 100; + + si4713->setFrequency(f); + si4713->setPTY(std::stoi(settings["Pty"])); + + std::string asq = si4713->getASQ(); + LogInfo(VB_PLUGIN, "VAST-FMT: %s\n", asq.c_str()); + + std::string ts = si4713->getTuneStatus(); + LogInfo(VB_PLUGIN, "VAST-FMT: %s\n", ts.c_str()); + + if (settings["EnableRDS"] == "True") { + si4713->beginRDS(); + formatAndSendText(settings["StationText"], "", "", true); + formatAndSendText(settings["RDSTextText"], "", "", false); + } + } + if (!si4713->isOk()) { + delete si4713; + si4713 = nullptr; + } + } + } + void stopVast() { + if (si4713 != nullptr) { + //si4713->powerDown(); + delete si4713; + si4713 = nullptr; + } + } + + void formatAndSendText(const std::string &text, const std::string &artist, const std::string &title, bool station) { + std::string output; + for (int x = 0; x < text.length(); x++) { + if (text[x] == '[') { + if (artist == "" && title == "") { + while (text[x] != ']' && x < text.length()) { + x++; + } + } + } else if (text[x] == ']') { + //nothing + } else if (text[x] == '{') { + const static std::string ARTIST = "{Artist}"; + const static std::string TITLE = "{Title}"; + std::string subs = text.substr(x); + if (subs.rfind(ARTIST) == 0) { + x += ARTIST.length() - 1; + output += artist; + } else if (subs.rfind(TITLE) == 0) { + x += TITLE.length() - 1; + output += title; + } else { + output += text[x]; + } + } else { + output += text[x]; + } + } + if (station) { + LogDebug(VB_PLUGIN, "Setting RDS Station text to %s\n", output.c_str()); + std::vector fragments; + while (output.size()) { + if (output.size() <= 8) { + padTo(output, 8); + fragments.push_back(output); + output.clear(); + } else { + std::string lft = output.substr(0, 8); + padTo(lft, 8); + output = output.substr(8); + fragments.push_back(lft); + } + } + if (fragments.empty()) { + std::string m = " "; + fragments.push_back(m); + } + si4713->setRDSStation(fragments); + } else { + LogDebug(VB_PLUGIN, "Setting RDS text to %s\n", output.c_str()); + si4713->setRDSBuffer(output); + } + } + + virtual void playlistCallback(const Json::Value &playlist, const std::string &action, const std::string §ion, int item) { + if (settings["Start"] == "PlaylistStart" && action == "start") { + startVast(); + } else if (settings["Stop"] == "PlaylistStop" && action == "stop") { + stopVast(); + } + } + virtual void mediaCallback(const Json::Value &playlist, const MediaDetails &mediaDetails) { + std::string title = mediaDetails.title; + std::string artist = mediaDetails.artist; + std::string album = mediaDetails.album; + int track = mediaDetails.track; + int length = mediaDetails.length; + + std::string type = playlist["currentEntry"]["type"].asString(); + if (type != "both" && type != "media") { + title = ""; + artist = ""; + } + + formatAndSendText(settings["StationText"], artist, title, true); + formatAndSendText(settings["RDSTextText"], artist, title, false); + } + + + void setDefaultSettings() { + setIfNotFound("Start", "FPPDStart"); + setIfNotFound("Frequency", "100.10"); + setIfNotFound("Power", "110"); + setIfNotFound("Preemphasis", "75us"); + setIfNotFound("AntCap", "0"); + setIfNotFound("EnableRDS", "False"); + setIfNotFound("StationText", "Merry Christ- mas", true); + setIfNotFound("RDSTextText", "[{Artist} - {Title}]", true); + setIfNotFound("Pty", "2"); + } + void setIfNotFound(const std::string &s, const std::string &v, bool emptyAllowed = false) { + if (settings.find(s) == settings.end()) { + settings[s] = v; + } else if (!emptyAllowed && settings[s] == "") { + settings[s] = v; + } + } + + Si4713 *si4713 = nullptr; +}; + + +extern "C" { + FPPPlugin *createPlugin() { + return new FPPVastFMPlugin(); + } +} diff --git a/src/Si4713.cpp b/src/Si4713.cpp new file mode 100755 index 0000000..6c9b8e4 --- /dev/null +++ b/src/Si4713.cpp @@ -0,0 +1,695 @@ +#include +#include + +#include "Si4713.h" +#include "util/I2CUtils.h" + +#include "hidapi.h" +#include "log.h" +#include "bitstream.h" + + +#define PCRequestError 0x80 +#define PCTransfer 0x02 +#define RequestDone 0x80 + +//status bits +#define STATUS_BIT_STCINT 0x01 +#define STATUS_BIT_ASQINT 0x02 +#define STATUS_BIT_RDSINT 0x04 +#define STATUS_BIT_RSQINT 0x08 +#define STATUS_BIT_ERR 0x40 +#define STATUS_BIT_CTS 0x80 + +// properties +#define SI4713_PROP_GPO_IEN 0x0001 +#define SI4713_PROP_DIGITAL_INPUT_FORMAT 0x0101 +#define SI4713_PROP_DIGITAL_INPUT_SAMPLE_RATE 0x0103 +#define SI4713_PROP_REFCLK_FREQ 0x0201 +#define SI4713_PROP_REFCLK_PRESCALE 0x0202 +#define SI4713_PROP_TX_COMPONENT_ENABLE 0x2100 +#define SI4713_PROP_TX_AUDIO_DEVIATION 0x2101 +#define SI4713_PROP_TX_PILOT_DEVIATION 0x2102 +#define SI4713_PROP_TX_RDS_DEVIATION 0x2103 +#define SI4713_PROP_TX_LINE_LEVEL_INPUT_LEVEL 0x2104 +#define SI4713_PROP_TX_LINE_INPUT_MUTE 0x2105 +#define SI4713_PROP_TX_PREEMPHASIS 0x2106 +#define SI4713_PROP_TX_PILOT_FREQUENCY 0x2107 +#define SI4713_PROP_TX_ACOMP_ENABLE 0x2200 +#define SI4713_PROP_TX_ACOMP_THRESHOLD 0x2201 +#define SI4713_PROP_TX_ATTACK_TIME 0x2202 +#define SI4713_PROP_TX_RELEASE_TIME 0x2203 +#define SI4713_PROP_TX_ACOMP_GAIN 0x2204 +#define SI4713_PROP_TX_LIMITER_RELEASE_TIME 0x2205 +#define SI4713_PROP_TX_ASQ_INTERRUPT_SOURCE 0x2300 +#define SI4713_PROP_TX_ASQ_LEVEL_LOW 0x2301 +#define SI4713_PROP_TX_ASQ_DURATION_LOW 0x2302 +#define SI4713_PROP_TX_ASQ_LEVEL_HIGH 0x2303 +#define SI4713_PROP_TX_ASQ_DURATION_HIGH 0x2304 +#define SI4713_PROP_TX_RDS_INTERRUPT_SOURCE 0x2C00 +#define SI4713_PROP_TX_RDS_PI 0x2C01 +#define SI4713_PROP_TX_RDS_PS_MIX 0x2C02 +#define SI4713_PROP_TX_RDS_PS_MISC 0x2C03 +#define SI4713_PROP_TX_RDS_PS_REPEAT_COUNT 0x2C04 +#define SI4713_PROP_TX_RDS_MESSAGE_COUNT 0x2C05 +#define SI4713_PROP_TX_RDS_PS_AF 0x2C06 +#define SI4713_PROP_TX_RDS_FIFO_SIZE 0x2C07 + + + +//================================================================== +// FM Transmit Commands +//================================================================== +// TX_TUNE_FREQ +#define TX_TUNE_FREQ 0x30 + +// TX_TUNE_POWER +#define TX_TUNE_POWER 0x31 + +// TX_TUNE_MEASURE +#define TX_TUNE_MEASURE 0x32 + +// TX_TUNE_STATUS +#define TX_TUNE_STATUS 0x33 +#define TX_TUNE_STATUS_IN_INTACK 0x01 + +// TX_ASQ_STATUS +#define TX_ASQ_STATUS 0x34 +#define TX_ASQ_STATUS_IN_INTACK 0x01 +#define TX_ASQ_STATUS_OUT_IALL 0x01 +#define TX_ASQ_STATUS_OUT_IALH 0x02 +#define TX_ASQ_STATUS_OUT_OVERMOD 0x04 + +// TX_RDS_BUFF +#define TX_RDS_BUFF 0x35 +#define TX_RDS_BUFF_IN_INTACK 0x01 +#define TX_RDS_BUFF_IN_MTBUFF 0x02 +#define TX_RDS_BUFF_IN_LDBUFF 0x04 +#define TX_RDS_BUFF_IN_FIFO 0x80 +#define TX_RDS_BUFF_OUT_RDSPSXMIT 0x10 +#define TX_RDS_BUFF_OUT_CBUFXMIT 0x08 +#define TX_RDS_BUFF_OUT_FIFOXMIT 0x04 +#define TX_RDS_BUFF_OUT_CBUFWRAP 0x02 +#define TX_RDS_BUFF_OUT_FIFOMT 0x01 + +// TX_RDS_PS +#define TX_RDS_PS 0x36 + + +enum { + RequestNone = 0, + RequestCpuId, + RequestSi4711Reset, //reset + RequestSi4711Access, //low level access + RequestSi4711GetProp, //medium level get prop + RequestSi4711SetProp, //medium level set prop + RequestSi4711PowerStatus, + RequestSi4711PowerUp, //high level power up + RequestSi4711PowerDown, //high level power down + RequestSi4711AudioEnable, //this MUST BE!!! called after setting config to enable audio. + RequestSi4711AudioDisable, + RequestEepromSectionRead, + RequestEepromSectionWrite, + RequestSi4711AsqStatus, + RequestSi4711TuneStatus, + RequestUnknown +}; +static const char *si471x_requests[] = { + "NONE", + "CPU ID", + "Frontend Reset", + "Frontend Access", + "Get Property", + "Set Property", + "Frontend Power Status", + "Frontend Power Up", + "Frontend Power Down", + "Frontend Enable Audio", + "Frontend Disable Audio", + "EEPROM Read", + "EEPROM Write", + "unknown" +}; +#define Si471xRequestStr(x) (x < RequestUnknown ? si471x_requests[x] : si471x_requests[RequestUnknown]) + +enum { + SI4711_OK = 0, + SI4711_TIMEOUT, + SI4711_COMM_ERR, + SI4711_BAD_ARG, + SI4711_NOCTS, + SI4711_ERROR_UNKNOWN +}; +static const char *si471x_statuses[] = { + "OK", + "I2C Timeout", + "I2C Communication Error", + "Bad Argument", + "No CTS!", + "unknown" +}; +#define Si471xStatusStr(x) (x < SI4711_ERROR_UNKNOWN ? si471x_statuses[x] : si471x_statuses[SI4711_ERROR_UNKNOWN]) + + + +class Si4713Connector { +public: + Si4713Connector() {} + virtual ~Si4713Connector() {} + + virtual bool isOk() = 0; + + virtual bool sendDeviceCommand(uint8_t cmd, std::vector &dataOut, bool ignoreFailures) = 0; + virtual bool sendSi4711Command(uint8_t cmd, const std::vector &dataIn, std::vector &dataOut, bool ignoreFailures) = 0; + + virtual bool setProperty(uint16_t prop, uint16_t val) = 0; + virtual bool getProperty(uint16_t prop, uint16_t &val) = 0; + +}; + +class USBSi4713Connector : public Si4713Connector { +public: + USBSi4713Connector(uint16_t _usVID, uint16_t _usPID) { + struct hid_device_info *phdi = nullptr; + phdi = hid_enumerate(_usVID,_usPID); + if (phdi == nullptr) { + return; + } + phd = hid_open_path(phdi->path); + hid_free_enumeration(phdi); + phdi=nullptr; + } + virtual ~USBSi4713Connector() { + if (phd) { + hid_close(phd); + } + } + virtual bool isOk() override { return phd != nullptr; } + virtual bool sendDeviceCommand(uint8_t cmd, std::vector &dataOut, bool ignoreFailures) { + unsigned char aucBufIn[43]; + unsigned char aucBufOut[43]; + memset(aucBufOut, 0x00, 43); // Clear out the response buffer + memset(aucBufIn, 0xCC, 43); // Clear out the response buffer + + /* Send a BL Query Command */ + aucBufOut[0] = 0; // Report ID, ignored + aucBufOut[1] = PCTransfer; + aucBufOut[2] = cmd; + + hid_write(phd, aucBufOut, 43); + int r = hid_read(phd, aucBufIn, 43); + + if (r < 2) { + LogWarn(VB_PLUGIN, "Si4713/USB: not enough data\n"); + return false; + } + if (!ignoreFailures && aucBufIn[0] & PCRequestError) { + LogWarn(VB_PLUGIN, "Si4713/USB: request error\n"); + return false; + } + if (!ignoreFailures && !(aucBufIn[0] & PCTransfer)) { + LogWarn(VB_PLUGIN, "Si4713/USB: Transfer error.\n"); + return false; + } + if (ignoreFailures || aucBufIn[1] == (cmd|RequestDone)) { + dataOut.resize(r - 2); + memcpy(&dataOut[0], &aucBufIn[2], r - 2); + return true; + } else { + LogWarn(VB_PLUGIN, "Si4713/USB: Request not done.\n"); + } + return false; + } + virtual bool sendSi4711Command(uint8_t cmd, const std::vector &dataIn, std::vector &dataOut, bool ignoreFailures) override { + unsigned char aucBufIn[43]; + unsigned char aucBufOut[43]; + memset(aucBufOut, 0x00, 43); // Clear out the response buffer + memset(aucBufIn, 0xCC, 43); // Clear out the response buffer + + /* Send a BL Query Command */ + aucBufOut[0] = 0; // Report ID, ignored + aucBufOut[1] = PCTransfer; + aucBufOut[2] = RequestSi4711Access; + aucBufOut[3] = dataIn.size() + 1; + aucBufOut[4] = cmd; + memcpy(&aucBufOut[5], &dataIn[0], dataIn.size()); + + hid_write(phd, aucBufOut, 43); + int r = hid_read(phd, aucBufIn, 42); + /* + for (int x = 0; x < 25; x++) { + printf("%x ", aucBufIn[x]); + } + printf("\n"); + */ + if (!ignoreFailures && aucBufIn[2] != 1) { + LogWarn(VB_PLUGIN, "Si4711/USB: command failed (%d): %s, returned (FALSE)\n", aucBufIn[2], Si471xStatusStr(aucBufIn[2])); + //sometimes it timeoutes, but the CTS=0, so we must re-read this byte again. + //return false; + } + + if (!ignoreFailures && aucBufIn[3]!=SI4711_OK) { + LogWarn(VB_PLUGIN, "Si4711/USB: I2C_READ failed (%d): %s\n", aucBufIn[3], Si471xStatusStr(aucBufIn[3])); + return false; + } + + if(!ignoreFailures && aucBufIn[4] > 16) { + LogWarn(VB_PLUGIN, "Si4711/USB: I2C_READ failed, too much bytes received: %d\n", aucBufIn[4]); + return false; + } + + //LogDebug(VB_PLUGIN, "Si4711/USB: Volume: %d.%d (deviation: %d)\n", (int) aucBufIn[21], (int ) aucBufIn[22], (int ) (aucBufIn[23] << 8 | aucBufIn[24])); + //printf("Si4711/USB: Volume: %d.%d (deviation: %d)\n", (int ) aucBufIn[21], (int ) aucBufIn[22], (int ) (aucBufIn[23] << 8 | aucBufIn[24])); + //printf("datasize: %d\n", aucBufIn[4]); + int sz = 16; // aucBufIn[4] + dataOut.resize(sz); + memcpy(&dataOut[0], &aucBufIn[5], sz); + return true; + } + virtual bool setProperty(uint16_t prop, uint16_t val) override { + unsigned char aucBufIn[43]; + unsigned char aucBufOut[43]; + memset(aucBufOut, 0x00, 43); // Clear out the response buffer + memset(aucBufIn, 0xCC, 43); // Clear out the response buffer + aucBufOut[0] = 0x00; //report number, would be unused! + aucBufOut[1] = PCTransfer; // + aucBufOut[2] = RequestSi4711SetProp; + aucBufOut[3] = prop >> 8; + aucBufOut[4] = prop; + aucBufOut[5] = val >> 8; + aucBufOut[6] = val; + hid_write(phd, aucBufOut, 43); + hid_read(phd, aucBufIn, 42); + + if (aucBufIn[0] & PCRequestError) { + LogWarn(VB_PLUGIN, "Si4713/USB: request error for property %X.\n", prop); + return false; + } + + if (!(aucBufIn[1] & RequestDone)) { + LogWarn(VB_PLUGIN, "Si4713/USB: request is not done!\n"); + return false; + } + + if (aucBufIn[8]!=SI4711_OK) { + LogWarn(VB_PLUGIN, "Si4713/USB: Device request \"%s\" failed (%d): %s\n", Si471xRequestStr(RequestSi4711SetProp), aucBufIn[2], Si471xStatusStr(aucBufIn[2])); + return false; + } + + if (aucBufIn[7] & STATUS_BIT_ERR) { + LogWarn(VB_PLUGIN, "Si4713/USB: Answers: Error setting property 0x%04x to \"0x%04x\".\n", prop, val); + return false; + } + + if (!(aucBufIn[7] & STATUS_BIT_CTS)) { + LogWarn(VB_PLUGIN, "Si4713/USB: Answers: NO CTS! When setting property 0x%04x.\n", prop); + return false; + } + + if (aucBufIn[6] != 1) { + LogWarn(VB_PLUGIN, "Si4713/USB: Device request \"%s\" failed (%02x): %s (false!)\n", Si471xRequestStr(RequestSi4711SetProp), aucBufIn[6]); + return false; + } + return true; + } + virtual bool getProperty(uint16_t prop, uint16_t &val) override { + unsigned char aucBufIn[43]; + unsigned char aucBufOut[43]; + memset(aucBufOut, 0x00, 43); // Clear out the response buffer + memset(aucBufIn, 0xCC, 43); // Clear out the response buffer + aucBufOut[0] = 0x00; //report number, would be unused! + aucBufOut[1] = PCTransfer; // + aucBufOut[2] = RequestSi4711GetProp; + aucBufOut[3] = prop >> 8; + aucBufOut[4] = prop; + hid_write(phd, aucBufOut, 43); + hid_read(phd, aucBufIn, 42); + + if (aucBufIn[0] & PCRequestError) { + LogWarn(VB_PLUGIN, "Si4713/USB: request error for property %X.\n", prop); + return false; + } + + if (!(aucBufIn[1] & RequestDone)) { + LogWarn(VB_PLUGIN, "Si4713/USB: request is not done!\n"); + return false; + } + + if (aucBufIn[8]!=SI4711_OK) { + LogWarn(VB_PLUGIN, "Si4713/USB: Device request \"%s\" failed (%d): %s\n", Si471xRequestStr(RequestSi4711SetProp), aucBufIn[2], Si471xStatusStr(aucBufIn[2])); + return false; + } + + if (aucBufIn[7] & STATUS_BIT_ERR) { + LogWarn(VB_PLUGIN, "Si4713/USB: Answers: Error setting property 0x%04x to \"0x%04x\".\n", prop, val); + return false; + } + + if (!(aucBufIn[7] & STATUS_BIT_CTS)) { + LogWarn(VB_PLUGIN, "Si4713/USB: Answers: NO CTS! When setting property 0x%04x.\n", prop); + return false; + } + + if (aucBufIn[6] != 1) { + LogWarn(VB_PLUGIN, "Si4713/USB: Device request \"%s\" failed (%02x): %s (false!)\n", Si471xRequestStr(RequestSi4711SetProp), aucBufIn[6]); + return false; + } + val = (int16_t ) ((aucBufIn[4] & 0x00FF) << 8) | aucBufIn[5]; + return true; + } + + + hid_device *phd = nullptr; +}; + + +Si4713::Si4713(uint16_t _usVID, uint16_t _usPID) { + connector = new USBSi4713Connector(_usVID, _usPID); + if (isOk()) { + Init(); + } +} + + +Si4713::~Si4713() { + if (connector) { + delete connector; + } +} + +bool Si4713::isOk() { + return connector && connector->isOk(); +} + + +void Si4713::Init() { + std::string rev = getRev(); + //setProperty(SI4713_PROP_REFCLK_FREQ, 32768); // crystal is 32.768 + setProperty(SI4713_PROP_TX_PREEMPHASIS, isEUPremphasis ? 1 : 0); // 75uS pre-emph (default for US) + setProperty(SI4713_PROP_TX_ACOMP_ENABLE, 0x03); // turn on limiter and AGC + + setProperty(SI4713_PROP_TX_ACOMP_THRESHOLD, 0x10000-15); // -15 dBFS + setProperty(SI4713_PROP_TX_ATTACK_TIME, 0); // 0.5 ms + setProperty(SI4713_PROP_TX_RELEASE_TIME, 4); // 1000 ms + setProperty(SI4713_PROP_TX_ACOMP_GAIN, 5); // dB + + powerUp(); +} +bool Si4713::sendDeviceCommand(uint8_t cmd, bool ignoreFailures) { + std::vector out; + return connector->sendDeviceCommand(cmd, out, ignoreFailures); +} +bool Si4713::sendDeviceCommand(uint8_t cmd, std::vector &out, bool ignoreFailures) { + return connector->sendDeviceCommand(cmd, out, ignoreFailures); +} +bool Si4713::setProperty(uint16_t prop, uint16_t val) { + return connector->setProperty(prop, val); +} +bool Si4713::getProperty(uint16_t prop, uint16_t &val) { + return connector->getProperty(prop, val); +} + +bool Si4713::sendSi4711Command(uint8_t cmd, const std::vector &data, bool ignoreFailures) { + std::vector out; + return connector->sendSi4711Command(cmd, data, out, ignoreFailures); +} +bool Si4713::sendSi4711Command(uint8_t cmd, const std::vector &data, std::vector &out, bool ignoreFailures) { + return connector->sendSi4711Command(cmd, data, out, ignoreFailures); +} + +void Si4713::powerUp() { + sendDeviceCommand(RequestSi4711PowerUp, true); +} +void Si4713::powerDown() { + sendDeviceCommand(RequestSi4711PowerDown, true); +} +void Si4713::reset() { + sendDeviceCommand(RequestSi4711Reset, true); +} + +std::string Si4713::getRev() { + std::vector out; + sendSi4711Command(0x10, {0}, out); + + if (sendDeviceCommand(RequestCpuId, out)) { + std::string rev = (char*)(&out[3]); + std::string board = (char*)(&out[5 + rev.size()]); + return board + " - " + rev; + } + return ""; +} + +void Si4713::setFrequency(int frequency) { + uint8_t ft = frequency>>8; + uint8_t fl = 0x00FF & frequency; + sendSi4711Command(TX_TUNE_FREQ, {0x00, ft, fl}); +} +void Si4713::setTXPower(int power, double antCap) { + uint8_t rfcap0 = antCap/0.25; + uint8_t p = power & 0xff; + sendSi4711Command(TX_TUNE_POWER, {0x00, 0x00, p, rfcap0}); +} + + +std::string Si4713::getASQ() { + std::vector out; + if (sendDeviceCommand(RequestSi4711AsqStatus, out)) { + std::string r = "ASQ Flags: "; + r += std::to_string(out[1]) + " " + std::to_string(out[2]) + " " + std::to_string(out[3]); + r += " - InLevel:"; + int lev = out[4]; + if (lev > 127) { + lev -= 256; + } + r += std::to_string(lev); + r += " dBfs"; + return r; + } + return ""; +} +std::string Si4713::getTuneStatus() { + std::vector out; + if (sendDeviceCommand(RequestSi4711TuneStatus, out)) { + int currFreq = out[1] << 8 | out[2]; + int currdBuV = out[3]; + int currAntCap = out[4]; + + float f = currFreq / 100.0f; + float cap = ((float)currAntCap) * 0.25f; + + std::string r = "Freq:" + std::to_string(f) + + " MHz - Power:" + std::to_string(currdBuV) + + "dBuV - ANTcap:" + std::to_string(cap); + return r; + } + return ""; +} + +void Si4713::enableAudio() { + sendDeviceCommand(RequestSi4711AudioEnable); +} +void Si4713::disableAudio() { + sendDeviceCommand(RequestSi4711AudioDisable); +} + + +void Si4713::beginRDS() { + //66.25KHz (default is 68.25) + setProperty(SI4713_PROP_TX_AUDIO_DEVIATION, 6625); + // 2KHz (default) + setProperty(SI4713_PROP_TX_RDS_DEVIATION, 200); + + //RDS IRQ + setProperty(SI4713_PROP_TX_RDS_INTERRUPT_SOURCE, 0x0001); + // program identifier + setProperty(SI4713_PROP_TX_RDS_PI, 0x40A7); + // 50% mix (default) + setProperty(SI4713_PROP_TX_RDS_PS_MIX, 0x03); + // RDSD0 & RDSMS (default) + setProperty(SI4713_PROP_TX_RDS_PS_MISC, 0x1008 | (pty << 5)); + // 3 repeats (default) + setProperty(SI4713_PROP_TX_RDS_PS_REPEAT_COUNT, 3); + + setProperty(SI4713_PROP_TX_RDS_MESSAGE_COUNT, 1); + setProperty(SI4713_PROP_TX_RDS_PS_AF, 0xE0E0); // no AF + setProperty(SI4713_PROP_TX_RDS_FIFO_SIZE, 7); + + setProperty(SI4713_PROP_TX_COMPONENT_ENABLE, 0x0007); +} +void Si4713::setRDSStation(const std::vector &station) { + uint8_t buf[8]; + + if (lastStation == station) { + return; + } + lastStation = station; + + setProperty(SI4713_PROP_TX_RDS_MESSAGE_COUNT, station.size()); + uint8_t idx = 0; + for (auto &a : station) { + int sl = a.size(); + memset(buf, ' ', 8); + if (sl > 8) { + sl = 8; + } + for (int x = 0; x < sl; x++) { + buf[x] = a[x]; + } + for (uint8_t i = 0; i < 2; i++) { + sendSi4711Command(TX_RDS_PS, {idx, buf[i*4], buf[(i*4)+1], buf[(i*4)+2], buf[(i*4)+3]}); + idx++; + } + } +} +void Si4713::setRDSBuffer(const std::string &station) { + if (lastRDS == station) { + return; + } + lastRDS = station; + uint8_t buf[64]; + memset(buf, ' ', 64); + + + int sl = station.size(); + if (sl > 64) { + sl = 64; + } + for (int x = 0; x < sl; x++) { + buf[x] = station[x]; + } + for (int x = (sl-1); x > 0; --x) { + if (buf[x] == ' ') { + sl--; + } else { + break; + } + } + + std::vector out; + sendSi4711Command(TX_RDS_BUFF, {TX_RDS_BUFF_IN_MTBUFF, 0, 0, 0, 0, 0, 0}, out); + if (station.size() != 0) { + int count = (sl + 3) / 4; + //printf("%d, %s\n", count, station.c_str()); + for (uint8_t i = 0; i < count; i++) { + uint8_t sb = TX_RDS_BUFF_IN_LDBUFF; + if (i == 0) { + sb |= TX_RDS_BUFF_IN_MTBUFF; + } + sendSi4711Command(TX_RDS_BUFF, {sb, 0x20, i, buf[i*4], buf[(i*4)+1], buf[(i*4)+2], buf[(i*4)+3]}, out); + + if (out.size() < 8) { + out.resize(8); + } + //printf("bu out %d: %2X %2X %2X %2X %2X %2X %2X %2X\n", i, out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); + } + //sendRtPlusInfo(1, 0, 10, 4, 11, sl - 11); + } + sendTimestamp(); + + setProperty(SI4713_PROP_TX_COMPONENT_ENABLE, 0x0007); + sendSi4711Command(0x14, {}, out); + //printf("0x14 out: %2X %2X %2X %2X %2X %2X %2X %2X\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); + sendSi4711Command(TX_RDS_BUFF, {TX_RDS_BUFF_IN_INTACK, 0, 0, 0, 0, 0, 0}, out); + //printf("int ack out: %2X %2X %2X %2X %2X %2X %2X %2X\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); +} + + +static int rtplus_toggle_bit = 1; //XXX:used to save RT+ toggle bit value +#define RTPLUS_GROUP_ID 0b1011 +void Si4713::sendRtPlusInfo(int content1, int content1_pos, int content1_len, + int content2, int content2_pos, int content2_len) { + uint8_t buff[16]; + char msg[6]; + + if (content1_len || content2_len) { + + + memset (msg, 0x00, 6); + bitstream_t *bs = nullptr; + bs_create(&bs); + bs_attach(bs, (uint8_t *) msg, 6); + + bs_put(bs, 0x00, 3); //seek to start pos + rtplus_toggle_bit = !rtplus_toggle_bit; //if we using RT+, update information! + bs_put(bs, rtplus_toggle_bit, 1); //Item toggle bit + bs_put(bs, 1, 1); //Item running bit + + if (content1_len) { + bs_put(bs, content1, 6); //RT content type 1 + bs_put(bs, content1_pos, 6); //start marker 1 + bs_put(bs, content1_len, 6); //length marker 1 + } + + if (content2_len) { + bs_put(bs, content2, 6); //RT content type 2 + bs_put(bs, content2_pos, 6); //start marker 2 + bs_put(bs, content2_len, 5); //length marker 2 (5 bits!) + } + + std::vector out; + sendSi4711Command(TX_RDS_BUFF, {TX_RDS_BUFF_IN_LDBUFF, + RTPLUS_GROUP_ID << 4, + msg[0], msg[1], msg[2], msg[3], msg[4]}, out); + printf("RTPLUS Settings: %2X %2X %2X %2X %2X %2X %2X %2X\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); + + //send RT+ announces + // FmRadioController::HandleRDSData + // FmRadioRDSParser::ParseRDSData RDSGroup:6 + // !!TEST FmRadioRDSParser::RT+ GROUP_TYPE_3A : RT+ Message + // !!TEST FmRadioRDSParser::RT+ Message RT+ flag : 0 0, RT+ AID : 4bd7 19415 (flag : 0 0) + // !!TEST FmRadioRDSParser::RT+ Message application group type code : 16 22 + sendSi4711Command(TX_RDS_BUFF, {TX_RDS_BUFF_IN_LDBUFF, + 0x30, //RDS GROUP: 3A + RTPLUS_GROUP_ID << 1, //we are describing RT+ group 11A + //RTPLUS_GROUP_ID, //we are describing RT+ group 11A + 0, //xxx.y.zzzz + //xxx - rfu + //y - cb flag (for template number) + //zzzz - for rds server needs. + 0, //template id=0 + 0x4B, 0xD7 //it's RT+ + }, out); + printf("RTPLUS Group: %2X %2X %2X %2X %2X %2X %2X %2X\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); + } +} + + +void Si4713::sendTimestamp() { + uint32_t MJD; + int y, m, d, k; + struct tm *ltm; + int8_t offset; + struct timezone tz; + struct timeval tv; + gettimeofday( &tv, &tz); + ltm=localtime(&tv.tv_sec); + offset = tz.tz_minuteswest / 30; + + y = ltm->tm_year; + m = ltm->tm_mon + 1; + d = ltm->tm_mday; + k = 0; + if((m == 1) || (m == 2)) { + k = 1; + } + + MJD = 14956 + d + ((int) ((y - k) * 365.25)) + ((int) ((m + 1 + k * 12) * 30.6001)); + + if (offset > 0) { + offset = (abs(offset) & 0x1F) | 0x20; + } else { + offset = abs(offset) & 0x1F; + } + + uint8_t sb = TX_RDS_BUFF_IN_LDBUFF | TX_RDS_BUFF_IN_FIFO; + std::vector out; + + uint8_t arg1 = (MJD >> 15); + uint8_t arg2 = (MJD >> 7); + uint8_t arg3 = (MJD << 1) | ((ltm->tm_hour & 0x1F)>> 4); + uint8_t arg4 = ((ltm->tm_hour & 0x1F)<< 4)|((ltm->tm_min & 0x3F)>> 2); + uint8_t arg5 = ((ltm->tm_min & 0x3F)<< 6)|offset; + sendSi4711Command(TX_RDS_BUFF,{sb, 0x40, arg1, arg2, arg3, arg4, arg5}, out); + //printf("ts out: %2X %2X %2X %2X %2X %2X %2X %2X\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]); +} + diff --git a/src/Si4713.h b/src/Si4713.h new file mode 100755 index 0000000..1d5c30a --- /dev/null +++ b/src/Si4713.h @@ -0,0 +1,63 @@ +#ifndef __SI4713__ +#define __SI4713__ + +#include +#include +#include + +class Si4713Connector; + +class Si4713 { +public: + Si4713(uint16_t _usVID, uint16_t _usPID); //usb + + virtual ~Si4713(); + + bool isOk(); + bool init(); + + std::string getRev(); + void powerUp(); + void powerDown(); + void reset(); + + void setEUPreemphasis() {isEUPremphasis = true;} + void setFrequency(int frequency); // freq * 100, so 8790 for 87.9 + void setTXPower(int power, double antCap); + + std::string getASQ(); + std::string getTuneStatus(); + + //RDS stuff + void setPTY(int i) { pty = i;} + void beginRDS(); + void setRDSStation(const std::vector &station); + void setRDSBuffer(const std::string &rds); + void sendTimestamp(); + + //USB audio + void enableAudio(); + void disableAudio(); +private: + void Init(); + + void sendRtPlusInfo(int content1, int content1_pos, int content1_len, + int content2, int content2_pos, int content2_len); + + bool sendDeviceCommand(uint8_t cmd, bool ignoreFailures = false); + bool sendDeviceCommand(uint8_t cmd, std::vector &out, bool ignoreFailures = false); + bool sendSi4711Command(uint8_t cmd, const std::vector &data, bool ignoreFailures = false); + bool sendSi4711Command(uint8_t cmd, const std::vector &data, std::vector &out, bool ignoreFailures = false); + bool setProperty(uint16_t prop, uint16_t val); + bool getProperty(uint16_t prop, uint16_t &val); + + + Si4713Connector * connector = nullptr; + + bool isEUPremphasis = false; + int pty = 2; + std::vector lastStation; + std::string lastRDS; +}; + +#endif diff --git a/src/bitstream.c b/src/bitstream.c new file mode 100755 index 0000000..cc93289 --- /dev/null +++ b/src/bitstream.c @@ -0,0 +1,123 @@ +/* + * FILE: bitstream.c + * PROGRAM: RAT + * AUTHOR: Orion Hodson + * + * Copyright (c) 1998-2001 University College London + * All rights reserved. + */ + +#ifdef WIN32 + #include +#else + #include +#endif + +#include +#include +#include +#include + +#include "bitstream.h" + +#define FALSE 0 +#define TRUE 1 +typedef int BOOL; + +typedef struct s_bitstream { + uint8_t *buf; /* head of bitstream */ + uint8_t *pos; /* current byte in bitstream */ + unsigned int remain; /* bits remaining */ + unsigned int len; /* length of bitstream in bytes */ +} bs; + +int bs_create(bitstream_t **ppb) +{ + bs *pb; + pb = (bs*)calloc(1, sizeof(bs)); + if (pb) { + *ppb = pb; + return TRUE; + } + return FALSE; +} + +int bs_destroy(bitstream_t **ppb) +{ + free(*ppb); + return TRUE; +} + +int bs_attach(bitstream_t *b, + uint8_t *buf, + int blen) +{ + b->buf = b->pos = buf; + b->remain = 8; + b->len = blen; + return TRUE; +} + +int bs_put(bitstream_t *b, + uint8_t bits, + uint8_t nbits) +{ + assert(nbits != 0 && nbits <= 8); + + if (b->remain == 0) { + b->pos++; + b->remain = 8; + } + + if (nbits > b->remain) { + unsigned int over = nbits - b->remain; + (*b->pos) |= (bits >> over); + b->pos++; + b->remain = 8 - over; + (*b->pos) = (bits << b->remain); + } else { + (*b->pos) |= bits << (b->remain - nbits); + b->remain -= nbits; + } + + assert((unsigned int)(b->pos - b->buf) <= b->len); + return TRUE; +} + +uint8_t bs_get(bitstream_t *b, + uint8_t nbits) +{ + uint8_t out; + + if (b->remain == 0) { + b->pos++; + b->remain = 8; + } + + if (nbits > b->remain) { + /* Get high bits */ + out = *b->pos; + out <<= (8 - b->remain); + out >>= (8 - nbits); + b->pos++; + b->remain += 8 - nbits; + out |= (*b->pos) >> b->remain; + } else { + out = *b->pos; + out <<= (8 - b->remain); + out >>= (8 - nbits); + b->remain -= nbits; + } + + assert((unsigned int)(b->pos - b->buf) <= b->len); + return out; +} + +int bs_bytes_used(bitstream_t *b) +{ + unsigned int used = (unsigned int)(b->pos - b->buf); + if (b->remain != 8) { + used++; + } + return used; +} diff --git a/src/bitstream.h b/src/bitstream.h new file mode 100755 index 0000000..6f93640 --- /dev/null +++ b/src/bitstream.h @@ -0,0 +1,42 @@ +/* + * FILE: bitstream.h + * PROGRAM: RAT + * AUTHOR: Orion Hodson + * + * Copyright (c) 1998-2001 University College London + * All rights reserved. + * + * $Id$ + */ + +#ifndef BITSTREAM_H +#define BITSTREAM_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct s_bitstream bitstream_t; + +int bs_create (bitstream_t **b); + +int bs_destroy (bitstream_t **b); + +int bs_attach (bitstream_t *b, + uint8_t *buf, + int blen); + +int bs_put (bitstream_t *b, + uint8_t bits, + uint8_t nbits); + +uint8_t bs_get (bitstream_t *b, + uint8_t nbits); + +int bs_bytes_used (bitstream_t *b); + +#ifdef __cplusplus +} +#endif + +#endif /* BITSTREAM_H */ diff --git a/src/hid.c b/src/hid.c new file mode 100755 index 0000000..3c6d877 --- /dev/null +++ b/src/hid.c @@ -0,0 +1,1514 @@ +/******************************************************* + HIDAPI - Multi-Platform library for + communication with HID devices. + + Alan Ott + Signal 11 Software + + 8/22/2009 + Linux Version - 6/2/2010 + Libusb Version - 8/13/2010 + FreeBSD Version - 11/1/2011 + + Copyright 2009, All Rights Reserved. + + At the discretion of the user of this library, + this software may be licensed under the terms of the + GNU General Public License v3, a BSD-Style license, or the + original HIDAPI license as outlined in the LICENSE.txt, + LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt + files located at the root of the source distribution. + These files may also be found in the public source + code repository located at: + http://github.com/signal11/hidapi . +********************************************************/ + +#define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */ + +/* C */ +#include +#include +#include +#include +#include +#include + +/* Unix */ +#include +#include +#include +#include +#include +#include +#include +#include + +/* GNU / LibUSB */ +#include +#ifndef __ANDROID__ +#include +#endif + +#include "hidapi.h" + +#ifdef __ANDROID__ + +/* Barrier implementation because Android/Bionic don't have pthread_barrier. + 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; + } +} + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef DEBUG_PRINTF +#define LOG(...) fprintf(stderr, __VA_ARGS__) +#else +#define LOG(...) do {} while (0) +#endif + +#ifndef __FreeBSD__ +#define DETACH_KERNEL_DRIVER +#endif + +/* Uncomment to enable the retrieval of Usage and Usage Page in +hid_enumerate(). Warning, on platforms different from FreeBSD +this is very invasive as it requires the detach +and re-attach of the kernel driver. See comments inside hid_enumerate(). +libusb HIDAPI programs are encouraged to use the interface number +instead to differentiate between interfaces on a composite HID device. */ +/*#define INVASIVE_GET_USAGE*/ + +/* Linked List of input reports received from the device. */ +struct input_report { + uint8_t *data; + size_t len; + struct input_report *next; +}; + + +struct hid_device_ { + /* Handle to the actual device. */ + libusb_device_handle *device_handle; + + /* Endpoint information */ + int input_endpoint; + int output_endpoint; + int input_ep_max_packet_size; + + /* The interface number of the HID */ + int interface; + + /* Indexes of Strings */ + int manufacturer_index; + int product_index; + int serial_index; + + /* Whether blocking reads are used */ + int blocking; /* boolean */ + + /* Read thread objects */ + pthread_t thread; + pthread_mutex_t mutex; /* Protects input_reports */ + pthread_cond_t condition; + pthread_barrier_t barrier; /* Ensures correct startup sequence */ + int shutdown_thread; + int cancelled; + struct libusb_transfer *transfer; + + /* List of received input reports. */ + struct input_report *input_reports; +}; + +static libusb_context *usb_context = NULL; + +uint16_t get_usb_code_for_current_locale(void); +static int return_data(hid_device *dev, unsigned char *data, size_t length); + +static hid_device *new_hid_device(void) +{ + hid_device *dev = calloc(1, sizeof(hid_device)); + dev->blocking = 1; + + pthread_mutex_init(&dev->mutex, NULL); + pthread_cond_init(&dev->condition, NULL); + pthread_barrier_init(&dev->barrier, NULL, 2); + + return dev; +} + +static void free_hid_device(hid_device *dev) +{ + /* Clean up the thread objects */ + pthread_barrier_destroy(&dev->barrier); + pthread_cond_destroy(&dev->condition); + pthread_mutex_destroy(&dev->mutex); + + /* Free the device itself */ + free(dev); +} + +#if 0 +/*TODO: Implement this funciton on hidapi/libusb.. */ +static void register_error(hid_device *device, const char *op) +{ + +} +#endif + +#ifdef INVASIVE_GET_USAGE +/* Get bytes from a HID Report Descriptor. + Only call with a num_bytes of 0, 1, 2, or 4. */ +static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur) +{ + /* Return if there aren't enough bytes. */ + if (cur + num_bytes >= len) + return 0; + + if (num_bytes == 0) + return 0; + else if (num_bytes == 1) { + return rpt[cur+1]; + } + else if (num_bytes == 2) { + return (rpt[cur+2] * 256 + rpt[cur+1]); + } + else if (num_bytes == 4) { + return (rpt[cur+4] * 0x01000000 + + rpt[cur+3] * 0x00010000 + + rpt[cur+2] * 0x00000100 + + rpt[cur+1] * 0x00000001); + } + else + return 0; +} + +/* Retrieves the device's Usage Page and Usage from the report + descriptor. The algorithm is simple, as it just returns the first + Usage and Usage Page that it finds in the descriptor. + The return value is 0 on success and -1 on failure. */ +static int get_usage(uint8_t *report_descriptor, size_t size, + unsigned short *usage_page, unsigned short *usage) +{ + unsigned int i = 0; + int size_code; + int data_len, key_size; + int usage_found = 0, usage_page_found = 0; + + while (i < size) { + int key = report_descriptor[i]; + int key_cmd = key & 0xfc; + + //printf("key: %02hhx\n", key); + + if ((key & 0xf0) == 0xf0) { + /* This is a Long Item. The next byte contains the + length of the data section (value) for this key. + See the HID specification, version 1.11, section + 6.2.2.3, titled "Long Items." */ + if (i+1 < size) + data_len = report_descriptor[i+1]; + else + data_len = 0; /* malformed report */ + key_size = 3; + } + else { + /* This is a Short Item. The bottom two bits of the + key contain the size code for the data section + (value) for this key. Refer to the HID + specification, version 1.11, section 6.2.2.2, + titled "Short Items." */ + size_code = key & 0x3; + switch (size_code) { + case 0: + case 1: + case 2: + data_len = size_code; + break; + case 3: + data_len = 4; + break; + default: + /* Can't ever happen since size_code is & 0x3 */ + data_len = 0; + break; + }; + key_size = 1; + } + + if (key_cmd == 0x4) { + *usage_page = get_bytes(report_descriptor, size, data_len, i); + usage_page_found = 1; + //printf("Usage Page: %x\n", (uint32_t)*usage_page); + } + if (key_cmd == 0x8) { + *usage = get_bytes(report_descriptor, size, data_len, i); + usage_found = 1; + //printf("Usage: %x\n", (uint32_t)*usage); + } + + if (usage_page_found && usage_found) + return 0; /* success */ + + /* Skip over this key and it's associated data */ + i += data_len + key_size; + } + + return -1; /* failure */ +} +#endif /* INVASIVE_GET_USAGE */ + +#if defined(__FreeBSD__) && __FreeBSD__ < 10 +/* The libusb version included in FreeBSD < 10 doesn't have this function. In + mainline libusb, it's inlined in libusb.h. This function will bear a striking + resemblance to that one, because there's about one way to code it. + + Note that the data parameter is Unicode in UTF-16LE encoding. + Return value is the number of bytes in data, or LIBUSB_ERROR_*. + */ +static inline int libusb_get_string_descriptor(libusb_device_handle *dev, + uint8_t descriptor_index, uint16_t lang_id, + unsigned char *data, int length) +{ + return libusb_control_transfer(dev, + LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */ + LIBUSB_REQUEST_GET_DESCRIPTOR, + (LIBUSB_DT_STRING << 8) | descriptor_index, + lang_id, data, (uint16_t) length, 1000); +} + +#endif + + +/* Get the first language the device says it reports. This comes from + USB string #0. */ +static uint16_t get_first_language(libusb_device_handle *dev) +{ + uint16_t buf[32]; + int len; + + /* Get the string from libusb. */ + len = libusb_get_string_descriptor(dev, + 0x0, /* String ID */ + 0x0, /* Language */ + (unsigned char*)buf, + sizeof(buf)); + if (len < 4) + return 0x0; + + return buf[1]; /* First two bytes are len and descriptor type. */ +} + +static int is_language_supported(libusb_device_handle *dev, uint16_t lang) +{ + uint16_t buf[32]; + int len; + int i; + + /* Get the string from libusb. */ + len = libusb_get_string_descriptor(dev, + 0x0, /* String ID */ + 0x0, /* Language */ + (unsigned char*)buf, + sizeof(buf)); + if (len < 4) + return 0x0; + + + len /= 2; /* language IDs are two-bytes each. */ + /* Start at index 1 because there are two bytes of protocol data. */ + for (i = 1; i < len; i++) { + if (buf[i] == lang) + return 1; + } + + return 0; +} + + +/* This function returns a newly allocated wide string containing the USB + device string numbered by the index. The returned string must be freed + by using free(). */ +static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx) +{ + char buf[512]; + int len; + wchar_t *str = NULL; + +#ifndef __ANDROID__ /* we don't use iconv on Android */ + wchar_t wbuf[256]; + /* iconv variables */ + iconv_t ic; + size_t inbytes; + size_t outbytes; + size_t res; +#ifdef __FreeBSD__ + const char *inptr; +#else + char *inptr; +#endif + char *outptr; +#endif + + /* 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; + +#ifdef __ANDROID__ + + /* Bionic does not have iconv support nor wcsdup() function, so it + has to be done manually. The following code will only work for + code points that can be represented as a single UTF-16 character, + and will incorrectly convert any code points which require more + than one UTF-16 character. + + Skip over the first character (2-bytes). */ + len -= 2; + str = malloc((len / 2 + 1) * sizeof(wchar_t)); + int i; + for (i = 0; i < len / 2; i++) { + str[i] = buf[i * 2 + 2] | (buf[i * 2 + 3] << 8); + } + str[len / 2] = 0x00000000; + +#else + + /* buf does not need to be explicitly NULL-terminated because + it is only passed into iconv() which does not need it. */ + + /* Initialize iconv. */ + ic = iconv_open("WCHAR_T", "UTF-16LE"); + if (ic == (iconv_t)-1) { + LOG("iconv_open() failed\n"); + return NULL; + } + + /* Convert to native wchar_t (UTF-32 on glibc/BSD systems). + Skip the first character (2-bytes). */ + inptr = buf+2; + inbytes = len-2; + outptr = (char*) wbuf; + outbytes = sizeof(wbuf); + res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes); + if (res == (size_t)-1) { + LOG("iconv() failed\n"); + goto err; + } + + /* Write the terminating NULL. */ + wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000; + if (outbytes >= sizeof(wbuf[0])) + *((wchar_t*)outptr) = 0x00000000; + + /* Allocate and copy the string. */ + str = wcsdup(wbuf); + +err: + iconv_close(ic); + +#endif + + return str; +} + +static char *make_path(libusb_device *dev, int interface_number) +{ + char str[64]; + snprintf(str, sizeof(str), "%04x:%04x:%02x", + libusb_get_bus_number(dev), + libusb_get_device_address(dev), + interface_number); + str[sizeof(str)-1] = '\0'; + + return strdup(str); +} + + +int HID_API_EXPORT hid_init(void) +{ + if (!usb_context) { + const char *locale; + + /* Init Libusb */ + if (libusb_init(&usb_context)) + return -1; + + /* Set the locale if it's not set. */ + locale = setlocale(LC_CTYPE, NULL); + if (!locale) + setlocale(LC_CTYPE, ""); + } + + return 0; +} + +int HID_API_EXPORT hid_exit(void) +{ + if (usb_context) { + libusb_exit(usb_context); + usb_context = NULL; + } + + return 0; +} + +struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) +{ + libusb_device **devs; + libusb_device *dev; + libusb_device_handle *handle; + ssize_t num_devs; + int i = 0; + + struct hid_device_info *root = NULL; /* return object */ + struct hid_device_info *cur_dev = NULL; + + if(hid_init() < 0) + return NULL; + + num_devs = libusb_get_device_list(usb_context, &devs); + if (num_devs < 0) + return NULL; + while ((dev = devs[i++]) != NULL) { + struct libusb_device_descriptor desc; + struct libusb_config_descriptor *conf_desc = NULL; + int j, k; + int interface_num = 0; + + int res = libusb_get_device_descriptor(dev, &desc); + unsigned short dev_vid = desc.idVendor; + unsigned short dev_pid = desc.idProduct; + + res = libusb_get_active_config_descriptor(dev, &conf_desc); + if (res < 0) + libusb_get_config_descriptor(dev, 0, &conf_desc); + if (conf_desc) { + for (j = 0; j < conf_desc->bNumInterfaces; j++) { + const struct libusb_interface *intf = &conf_desc->interface[j]; + for (k = 0; k < intf->num_altsetting; k++) { + const struct libusb_interface_descriptor *intf_desc; + intf_desc = &intf->altsetting[k]; + if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) { + interface_num = intf_desc->bInterfaceNumber; + + /* Check the VID/PID against the arguments */ + if ((vendor_id == 0x0 || vendor_id == dev_vid) && + (product_id == 0x0 || product_id == dev_pid)) { + struct hid_device_info *tmp; + + /* VID/PID match. Create the record. */ + tmp = calloc(1, sizeof(struct hid_device_info)); + if (cur_dev) { + cur_dev->next = tmp; + } + else { + root = tmp; + } + cur_dev = tmp; + + /* Fill out the record */ + cur_dev->next = NULL; + cur_dev->path = make_path(dev, interface_num); + + res = libusb_open(dev, &handle); + + if (res >= 0) { + /* Serial Number */ + if (desc.iSerialNumber > 0) + cur_dev->serial_number = + get_usb_string(handle, desc.iSerialNumber); + + /* Manufacturer and Product strings */ + if (desc.iManufacturer > 0) + cur_dev->manufacturer_string = + get_usb_string(handle, desc.iManufacturer); + if (desc.iProduct > 0) + cur_dev->product_string = + get_usb_string(handle, desc.iProduct); + +#ifdef INVASIVE_GET_USAGE +{ + /* + This section is removed because it is too + invasive on the system. Getting a Usage Page + and Usage requires parsing the HID Report + descriptor. Getting a HID Report descriptor + involves claiming the interface. Claiming the + interface involves detaching the kernel driver. + Detaching the kernel driver is hard on the system + because it will unclaim interfaces (if another + app has them claimed) and the re-attachment of + the driver will sometimes change /dev entry names. + It is for these reasons that this section is + #if 0. For composite devices, use the interface + field in the hid_device_info struct to distinguish + between interfaces. */ + unsigned char data[256]; +#ifdef DETACH_KERNEL_DRIVER + int detached = 0; + /* Usage Page and Usage */ + res = libusb_kernel_driver_active(handle, interface_num); + if (res == 1) { + res = libusb_detach_kernel_driver(handle, interface_num); + if (res < 0) + LOG("Couldn't detach kernel driver, even though a kernel driver was attached."); + else + detached = 1; + } +#endif + res = libusb_claim_interface(handle, interface_num); + if (res >= 0) { + /* Get the HID Report Descriptor. */ + res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000); + if (res >= 0) { + unsigned short page=0, usage=0; + /* Parse the usage and usage page + out of the report descriptor. */ + get_usage(data, res, &page, &usage); + cur_dev->usage_page = page; + cur_dev->usage = usage; + } + else + LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res); + + /* Release the interface */ + res = libusb_release_interface(handle, interface_num); + if (res < 0) + LOG("Can't release the interface.\n"); + } + else + LOG("Can't claim interface %d\n", res); +#ifdef DETACH_KERNEL_DRIVER + /* Re-attach kernel driver if necessary. */ + if (detached) { + res = libusb_attach_kernel_driver(handle, interface_num); + if (res < 0) + LOG("Couldn't re-attach kernel driver.\n"); + } +#endif +} +#endif /* INVASIVE_GET_USAGE */ + + libusb_close(handle); + } + /* VID/PID */ + cur_dev->vendor_id = dev_vid; + cur_dev->product_id = dev_pid; + + /* Release Number */ + cur_dev->release_number = desc.bcdDevice; + + /* Interface Number */ + cur_dev->interface_number = interface_num; + } + } + } /* altsettings */ + } /* interfaces */ + libusb_free_config_descriptor(conf_desc); + } + } + + libusb_free_device_list(devs, 1); + + return root; +} + +void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs) +{ + struct hid_device_info *d = devs; + while (d) { + struct hid_device_info *next = d->next; + free(d->path); + free(d->serial_number); + free(d->manufacturer_string); + free(d->product_string); + free(d); + d = next; + } +} + +hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) +{ + struct hid_device_info *devs, *cur_dev; + const char *path_to_open = NULL; + hid_device *handle = NULL; + + devs = hid_enumerate(vendor_id, product_id); + cur_dev = devs; + while (cur_dev) { + if (cur_dev->vendor_id == vendor_id && + cur_dev->product_id == product_id) { + if (serial_number) { + if (cur_dev->serial_number && + wcscmp(serial_number, cur_dev->serial_number) == 0) { + path_to_open = cur_dev->path; + break; + } + } + else { + path_to_open = cur_dev->path; + break; + } + } + cur_dev = cur_dev->next; + } + + if (path_to_open) { + /* Open the device */ + handle = hid_open_path(path_to_open); + } + + hid_free_enumeration(devs); + + return handle; +} + +static void read_callback(struct libusb_transfer *transfer) +{ + hid_device *dev = transfer->user_data; + int res; + + if (transfer->status == LIBUSB_TRANSFER_COMPLETED) { + + struct input_report *rpt = malloc(sizeof(*rpt)); + rpt->data = malloc(transfer->actual_length); + memcpy(rpt->data, transfer->buffer, transfer->actual_length); + rpt->len = transfer->actual_length; + rpt->next = NULL; + + pthread_mutex_lock(&dev->mutex); + + /* Attach the new report object to the end of the list. */ + if (dev->input_reports == NULL) { + /* The list is empty. Put it at the root. */ + dev->input_reports = rpt; + pthread_cond_signal(&dev->condition); + } + else { + /* Find the end of the list and attach. */ + struct input_report *cur = dev->input_reports; + int num_queued = 0; + while (cur->next != NULL) { + cur = cur->next; + num_queued++; + } + cur->next = rpt; + + /* Pop one off if we've reached 30 in the queue. This + way we don't grow forever if the user never reads + anything from the device. */ + if (num_queued > 30) { + return_data(dev, NULL, 0); + } + } + pthread_mutex_unlock(&dev->mutex); + } + else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) { + dev->shutdown_thread = 1; + dev->cancelled = 1; + return; + } + else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) { + dev->shutdown_thread = 1; + dev->cancelled = 1; + return; + } + else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) { + //LOG("Timeout (normal)\n"); + } + else { + LOG("Unknown transfer code: %d\n", transfer->status); + } + + /* Re-submit the transfer object. */ + res = libusb_submit_transfer(transfer); + if (res != 0) { + LOG("Unable to submit URB. libusb error code: %d\n", res); + dev->shutdown_thread = 1; + dev->cancelled = 1; + } +} + + +static void *read_thread(void *param) +{ + hid_device *dev = param; + unsigned char *buf; + const size_t length = dev->input_ep_max_packet_size; + + /* Set up the transfer object. */ + buf = malloc(length); + dev->transfer = libusb_alloc_transfer(0); + libusb_fill_interrupt_transfer(dev->transfer, + dev->device_handle, + dev->input_endpoint, + buf, + length, + read_callback, + dev, + 5000/*timeout*/); + + /* Make the first submission. Further submissions are made + from inside read_callback() */ + libusb_submit_transfer(dev->transfer); + + /* Notify the main thread that the read thread is up and running. */ + pthread_barrier_wait(&dev->barrier); + + /* Handle all the events. */ + while (!dev->shutdown_thread) { + int res; + res = libusb_handle_events(usb_context); + if (res < 0) { + /* There was an error. */ + LOG("read_thread(): libusb reports error # %d\n", res); + + /* Break out of this loop only on fatal error.*/ + if (res != LIBUSB_ERROR_BUSY && + res != LIBUSB_ERROR_TIMEOUT && + res != LIBUSB_ERROR_OVERFLOW && + res != LIBUSB_ERROR_INTERRUPTED) { + break; + } + } + } + + /* Cancel any transfer that may be pending. This call will fail + if no transfers are pending, but that's OK. */ + libusb_cancel_transfer(dev->transfer); + + while (!dev->cancelled) + libusb_handle_events_completed(usb_context, &dev->cancelled); + + /* Now that the read thread is stopping, Wake any threads which are + waiting on data (in hid_read_timeout()). Do this under a mutex to + make sure that a thread which is about to go to sleep waiting on + the condition actually will go to sleep before the condition is + signaled. */ + pthread_mutex_lock(&dev->mutex); + pthread_cond_broadcast(&dev->condition); + pthread_mutex_unlock(&dev->mutex); + + /* The dev->transfer->buffer and dev->transfer objects are cleaned up + in hid_close(). They are not cleaned up here because this thread + could end either due to a disconnect or due to a user + call to hid_close(). In both cases the objects can be safely + cleaned up after the call to pthread_join() (in hid_close()), but + since hid_close() calls libusb_cancel_transfer(), on these objects, + they can not be cleaned up here. */ + + return NULL; +} + + +hid_device * HID_API_EXPORT hid_open_path(const char *path) +{ + hid_device *dev = NULL; + + libusb_device **devs; + libusb_device *usb_dev; + int res; + int d = 0; + int good_open = 0; + + if(hid_init() < 0) + return NULL; + + dev = new_hid_device(); + + libusb_get_device_list(usb_context, &devs); + while ((usb_dev = devs[d++]) != NULL) { + struct libusb_device_descriptor desc; + struct libusb_config_descriptor *conf_desc = NULL; + int i,j,k; + libusb_get_device_descriptor(usb_dev, &desc); + + if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0) + continue; + for (j = 0; j < conf_desc->bNumInterfaces; j++) { + const struct libusb_interface *intf = &conf_desc->interface[j]; + for (k = 0; k < intf->num_altsetting; k++) { + const struct libusb_interface_descriptor *intf_desc; + intf_desc = &intf->altsetting[k]; + if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) { + char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber); + if (!strcmp(dev_path, path)) { + /* Matched Paths. Open this device */ + + /* OPEN HERE */ + res = libusb_open(usb_dev, &dev->device_handle); + if (res < 0) { + LOG("can't open device\n"); + free(dev_path); + break; + } + good_open = 1; +#ifdef DETACH_KERNEL_DRIVER + /* Detach the kernel driver, but only if the + device is managed by the kernel */ + if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) { + res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber); + if (res < 0) { + libusb_close(dev->device_handle); + LOG("Unable to detach Kernel Driver\n"); + free(dev_path); + good_open = 0; + break; + } + } +#endif + res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber); + if (res < 0) { + LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res); + free(dev_path); + libusb_close(dev->device_handle); + good_open = 0; + break; + } + + /* Store off the string descriptor indexes */ + dev->manufacturer_index = desc.iManufacturer; + dev->product_index = desc.iProduct; + dev->serial_index = desc.iSerialNumber; + + /* Store off the interface number */ + dev->interface = intf_desc->bInterfaceNumber; + + /* Find the INPUT and OUTPUT endpoints. An + OUTPUT endpoint is not required. */ + for (i = 0; i < intf_desc->bNumEndpoints; i++) { + const struct libusb_endpoint_descriptor *ep + = &intf_desc->endpoint[i]; + + /* Determine the type and direction of this + endpoint. */ + int is_interrupt = + (ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) + == LIBUSB_TRANSFER_TYPE_INTERRUPT; + int is_output = + (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) + == LIBUSB_ENDPOINT_OUT; + int is_input = + (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) + == LIBUSB_ENDPOINT_IN; + + /* Decide whether to use it for input 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 interrupt out endpoint. Use the Control Endpoint */ + res = libusb_control_transfer(dev->device_handle, + LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT, + 0x09/*HID Set_Report*/, + (2/*HID output*/ << 8) | report_number, + dev->interface, + (unsigned char *)data, length, + 1000/*timeout millis*/); + + if (res < 0) + return -1; + + if (skipped_report_id) + length++; + + return length; + } + else { + /* Use the interrupt out endpoint */ + int actual_length; + res = libusb_interrupt_transfer(dev->device_handle, + dev->output_endpoint, + (unsigned char*)data, + length, + &actual_length, 1000); + + if (res < 0) + return -1; + + if (skipped_report_id) + actual_length++; + + return actual_length; + } +} + +/* Helper function, to simplify hid_read(). + This should be called with dev->mutex locked. */ +static int return_data(hid_device *dev, unsigned char *data, size_t length) +{ + /* Copy the data out of the linked list item (rpt) into the + return buffer (data), and delete the liked list item. */ + struct input_report *rpt = dev->input_reports; + size_t len = (length < rpt->len)? length: rpt->len; + if (len > 0) + memcpy(data, rpt->data, len); + dev->input_reports = rpt->next; + free(rpt->data); + free(rpt); + return len; +} + +static void cleanup_mutex(void *param) +{ + hid_device *dev = param; + pthread_mutex_unlock(&dev->mutex); +} + + +int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds) +{ + int bytes_read = -1; + +#if 0 + int transferred; + int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000); + LOG("transferred: %d\n", transferred); + return transferred; +#endif + + pthread_mutex_lock(&dev->mutex); + pthread_cleanup_push(&cleanup_mutex, dev); + + /* There's an input report queued up. Return it. */ + if (dev->input_reports) { + /* Return the first one */ + bytes_read = return_data(dev, data, length); + goto ret; + } + + if (dev->shutdown_thread) { + /* This means the device has been disconnected. + An error code of -1 should be returned. */ + bytes_read = -1; + goto ret; + } + + if (milliseconds == -1) { + /* Blocking */ + while (!dev->input_reports && !dev->shutdown_thread) { + pthread_cond_wait(&dev->condition, &dev->mutex); + } + if (dev->input_reports) { + bytes_read = return_data(dev, data, length); + } + } + else if (milliseconds > 0) { + /* Non-blocking, but called with timeout. */ + int res; + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_sec += milliseconds / 1000; + ts.tv_nsec += (milliseconds % 1000) * 1000000; + if (ts.tv_nsec >= 1000000000L) { + ts.tv_sec++; + ts.tv_nsec -= 1000000000L; + } + + while (!dev->input_reports && !dev->shutdown_thread) { + res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts); + if (res == 0) { + if (dev->input_reports) { + bytes_read = return_data(dev, data, length); + break; + } + + /* If we're here, there was a spurious wake up + or the read thread was shutdown. Run the + loop again (ie: don't break). */ + } + else if (res == ETIMEDOUT) { + /* Timed out. */ + bytes_read = 0; + break; + } + else { + /* Error. */ + bytes_read = -1; + break; + } + } + } + else { + /* Purely non-blocking */ + bytes_read = 0; + } + +ret: + pthread_mutex_unlock(&dev->mutex); + pthread_cleanup_pop(0); + + return bytes_read; +} + +int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length) +{ + return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0); +} + +int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock) +{ + dev->blocking = !nonblock; + + return 0; +} + + +int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length) +{ + int res = -1; + int skipped_report_id = 0; + int report_number = data[0]; + + if (report_number == 0x0) { + data++; + length--; + skipped_report_id = 1; + } + + res = libusb_control_transfer(dev->device_handle, + LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT, + 0x09/*HID set_report*/, + (3/*HID feature*/ << 8) | report_number, + dev->interface, + (unsigned char *)data, length, + 1000/*timeout millis*/); + + if (res < 0) + return -1; + + /* Account for the report ID */ + if (skipped_report_id) + length++; + + return length; +} + +int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length) +{ + int res = -1; + int skipped_report_id = 0; + int report_number = data[0]; + + if (report_number == 0x0) { + /* Offset the return buffer by 1, so that the report ID + will remain in byte 0. */ + data++; + length--; + skipped_report_id = 1; + } + res = libusb_control_transfer(dev->device_handle, + LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN, + 0x01/*HID get_report*/, + (3/*HID feature*/ << 8) | report_number, + dev->interface, + (unsigned char *)data, length, + 1000/*timeout millis*/); + + if (res < 0) + return -1; + + if (skipped_report_id) + res++; + + return res; +} + + +void HID_API_EXPORT hid_close(hid_device *dev) +{ + if (!dev) + return; + + /* Cause read_thread() to stop. */ + dev->shutdown_thread = 1; + libusb_cancel_transfer(dev->transfer); + + /* Wait for read_thread() to end. */ + pthread_join(dev->thread, NULL); + + /* Clean up the Transfer objects allocated in read_thread(). */ + free(dev->transfer->buffer); + libusb_free_transfer(dev->transfer); + + /* release the interface */ + libusb_release_interface(dev->device_handle, dev->interface); + + /* Close the handle */ + libusb_close(dev->device_handle); + + /* Clear out the queue of received reports. */ + pthread_mutex_lock(&dev->mutex); + while (dev->input_reports) { + return_data(dev, NULL, 0); + } + pthread_mutex_unlock(&dev->mutex); + + free_hid_device(dev); +} + + +int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen) +{ + return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen); +} + +int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen) +{ + return hid_get_indexed_string(dev, dev->product_index, string, maxlen); +} + +int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen) +{ + return hid_get_indexed_string(dev, dev->serial_index, string, maxlen); +} + +int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) +{ + wchar_t *str; + + str = get_usb_string(dev->device_handle, string_index); + if (str) { + wcsncpy(string, str, maxlen); + string[maxlen-1] = L'\0'; + free(str); + return 0; + } + else + return -1; +} + + +HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev) +{ + return NULL; +} + + +struct lang_map_entry { + const char *name; + const char *string_code; + uint16_t usb_code; +}; + +#define LANG(name,code,usb_code) { name, code, usb_code } +static struct lang_map_entry lang_map[] = { + LANG("Afrikaans", "af", 0x0436), + LANG("Albanian", "sq", 0x041C), + LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801), + LANG("Arabic - Bahrain", "ar_bh", 0x3C01), + LANG("Arabic - Algeria", "ar_dz", 0x1401), + LANG("Arabic - Egypt", "ar_eg", 0x0C01), + LANG("Arabic - Iraq", "ar_iq", 0x0801), + LANG("Arabic - Jordan", "ar_jo", 0x2C01), + LANG("Arabic - Kuwait", "ar_kw", 0x3401), + LANG("Arabic - Lebanon", "ar_lb", 0x3001), + LANG("Arabic - Libya", "ar_ly", 0x1001), + LANG("Arabic - Morocco", "ar_ma", 0x1801), + LANG("Arabic - Oman", "ar_om", 0x2001), + LANG("Arabic - Qatar", "ar_qa", 0x4001), + LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401), + LANG("Arabic - Syria", "ar_sy", 0x2801), + LANG("Arabic - Tunisia", "ar_tn", 0x1C01), + LANG("Arabic - Yemen", "ar_ye", 0x2401), + LANG("Armenian", "hy", 0x042B), + LANG("Azeri - Latin", "az_az", 0x042C), + LANG("Azeri - Cyrillic", "az_az", 0x082C), + LANG("Basque", "eu", 0x042D), + LANG("Belarusian", "be", 0x0423), + LANG("Bulgarian", "bg", 0x0402), + LANG("Catalan", "ca", 0x0403), + LANG("Chinese - China", "zh_cn", 0x0804), + LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04), + LANG("Chinese - Macau SAR", "zh_mo", 0x1404), + LANG("Chinese - Singapore", "zh_sg", 0x1004), + LANG("Chinese - Taiwan", "zh_tw", 0x0404), + LANG("Croatian", "hr", 0x041A), + LANG("Czech", "cs", 0x0405), + LANG("Danish", "da", 0x0406), + LANG("Dutch - Netherlands", "nl_nl", 0x0413), + LANG("Dutch - Belgium", "nl_be", 0x0813), + LANG("English - Australia", "en_au", 0x0C09), + LANG("English - Belize", "en_bz", 0x2809), + LANG("English - Canada", "en_ca", 0x1009), + LANG("English - Caribbean", "en_cb", 0x2409), + LANG("English - Ireland", "en_ie", 0x1809), + LANG("English - Jamaica", "en_jm", 0x2009), + LANG("English - New Zealand", "en_nz", 0x1409), + LANG("English - Phillippines", "en_ph", 0x3409), + LANG("English - Southern Africa", "en_za", 0x1C09), + LANG("English - Trinidad", "en_tt", 0x2C09), + LANG("English - Great Britain", "en_gb", 0x0809), + LANG("English - United States", "en_us", 0x0409), + LANG("Estonian", "et", 0x0425), + LANG("Farsi", "fa", 0x0429), + LANG("Finnish", "fi", 0x040B), + LANG("Faroese", "fo", 0x0438), + LANG("French - France", "fr_fr", 0x040C), + LANG("French - Belgium", "fr_be", 0x080C), + LANG("French - Canada", "fr_ca", 0x0C0C), + LANG("French - Luxembourg", "fr_lu", 0x140C), + LANG("French - Switzerland", "fr_ch", 0x100C), + LANG("Gaelic - Ireland", "gd_ie", 0x083C), + LANG("Gaelic - Scotland", "gd", 0x043C), + LANG("German - Germany", "de_de", 0x0407), + LANG("German - Austria", "de_at", 0x0C07), + LANG("German - Liechtenstein", "de_li", 0x1407), + LANG("German - Luxembourg", "de_lu", 0x1007), + LANG("German - Switzerland", "de_ch", 0x0807), + LANG("Greek", "el", 0x0408), + LANG("Hebrew", "he", 0x040D), + LANG("Hindi", "hi", 0x0439), + LANG("Hungarian", "hu", 0x040E), + LANG("Icelandic", "is", 0x040F), + LANG("Indonesian", "id", 0x0421), + LANG("Italian - Italy", "it_it", 0x0410), + LANG("Italian - Switzerland", "it_ch", 0x0810), + LANG("Japanese", "ja", 0x0411), + LANG("Korean", "ko", 0x0412), + LANG("Latvian", "lv", 0x0426), + LANG("Lithuanian", "lt", 0x0427), + LANG("F.Y.R.O. Macedonia", "mk", 0x042F), + LANG("Malay - Malaysia", "ms_my", 0x043E), + LANG("Malay – Brunei", "ms_bn", 0x083E), + LANG("Maltese", "mt", 0x043A), + LANG("Marathi", "mr", 0x044E), + LANG("Norwegian - Bokml", "no_no", 0x0414), + LANG("Norwegian - Nynorsk", "no_no", 0x0814), + LANG("Polish", "pl", 0x0415), + LANG("Portuguese - Portugal", "pt_pt", 0x0816), + LANG("Portuguese - Brazil", "pt_br", 0x0416), + LANG("Raeto-Romance", "rm", 0x0417), + LANG("Romanian - Romania", "ro", 0x0418), + LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818), + LANG("Russian", "ru", 0x0419), + LANG("Russian - Republic of Moldova", "ru_mo", 0x0819), + LANG("Sanskrit", "sa", 0x044F), + LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A), + LANG("Serbian - Latin", "sr_sp", 0x081A), + LANG("Setsuana", "tn", 0x0432), + LANG("Slovenian", "sl", 0x0424), + LANG("Slovak", "sk", 0x041B), + LANG("Sorbian", "sb", 0x042E), + LANG("Spanish - Spain (Traditional)", "es_es", 0x040A), + LANG("Spanish - Argentina", "es_ar", 0x2C0A), + LANG("Spanish - Bolivia", "es_bo", 0x400A), + LANG("Spanish - Chile", "es_cl", 0x340A), + LANG("Spanish - Colombia", "es_co", 0x240A), + LANG("Spanish - Costa Rica", "es_cr", 0x140A), + LANG("Spanish - Dominican Republic", "es_do", 0x1C0A), + LANG("Spanish - Ecuador", "es_ec", 0x300A), + LANG("Spanish - Guatemala", "es_gt", 0x100A), + LANG("Spanish - Honduras", "es_hn", 0x480A), + LANG("Spanish - Mexico", "es_mx", 0x080A), + LANG("Spanish - Nicaragua", "es_ni", 0x4C0A), + LANG("Spanish - Panama", "es_pa", 0x180A), + LANG("Spanish - Peru", "es_pe", 0x280A), + LANG("Spanish - Puerto Rico", "es_pr", 0x500A), + LANG("Spanish - Paraguay", "es_py", 0x3C0A), + LANG("Spanish - El Salvador", "es_sv", 0x440A), + LANG("Spanish - Uruguay", "es_uy", 0x380A), + LANG("Spanish - Venezuela", "es_ve", 0x200A), + LANG("Southern Sotho", "st", 0x0430), + LANG("Swahili", "sw", 0x0441), + LANG("Swedish - Sweden", "sv_se", 0x041D), + LANG("Swedish - Finland", "sv_fi", 0x081D), + LANG("Tamil", "ta", 0x0449), + LANG("Tatar", "tt", 0X0444), + LANG("Thai", "th", 0x041E), + LANG("Turkish", "tr", 0x041F), + LANG("Tsonga", "ts", 0x0431), + LANG("Ukrainian", "uk", 0x0422), + LANG("Urdu", "ur", 0x0420), + LANG("Uzbek - Cyrillic", "uz_uz", 0x0843), + LANG("Uzbek – Latin", "uz_uz", 0x0443), + LANG("Vietnamese", "vi", 0x042A), + LANG("Xhosa", "xh", 0x0434), + LANG("Yiddish", "yi", 0x043D), + LANG("Zulu", "zu", 0x0435), + LANG(NULL, NULL, 0x0), +}; + +uint16_t get_usb_code_for_current_locale(void) +{ + char *locale; + char search_string[64]; + char *ptr; + struct lang_map_entry *lang; + + /* Get the current locale. */ + locale = setlocale(0, NULL); + if (!locale) + return 0x0; + + /* Make a copy of the current locale string. */ + strncpy(search_string, locale, sizeof(search_string)); + search_string[sizeof(search_string)-1] = '\0'; + + /* Chop off the encoding part, and make it lower case. */ + ptr = search_string; + while (*ptr) { + *ptr = tolower(*ptr); + if (*ptr == '.') { + *ptr = '\0'; + break; + } + ptr++; + } + + /* Find the entry which matches the string code of our locale. */ + lang = lang_map; + while (lang->string_code) { + if (!strcmp(lang->string_code, search_string)) { + return lang->usb_code; + } + lang++; + } + + /* There was no match. Find with just the language only. */ + /* Chop off the variant. Chop it off at the '_'. */ + ptr = search_string; + while (*ptr) { + *ptr = tolower(*ptr); + if (*ptr == '_') { + *ptr = '\0'; + break; + } + ptr++; + } + +#if 0 /* TODO: Do we need this? */ + /* Find the entry which matches the string code of our language. */ + lang = lang_map; + while (lang->string_code) { + if (!strcmp(lang->string_code, search_string)) { + return lang->usb_code; + } + lang++; + } +#endif + + /* Found nothing. */ + return 0x0; +} + +#ifdef __cplusplus +} +#endif diff --git a/src/hidapi.h b/src/hidapi.h new file mode 100755 index 0000000..e5bc2dc --- /dev/null +++ b/src/hidapi.h @@ -0,0 +1,391 @@ +/******************************************************* + HIDAPI - Multi-Platform library for + communication with HID devices. + + Alan Ott + Signal 11 Software + + 8/22/2009 + + Copyright 2009, All Rights Reserved. + + At the discretion of the user of this library, + this software may be licensed under the terms of the + GNU General Public License v3, a BSD-Style license, or the + original HIDAPI license as outlined in the LICENSE.txt, + LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt + files located at the root of the source distribution. + These files may also be found in the public source + code repository located at: + http://github.com/signal11/hidapi . +********************************************************/ + +/** @file + * @defgroup API hidapi API + */ + +#ifndef HIDAPI_H__ +#define HIDAPI_H__ + +#include + +#ifdef _WIN32 + #define HID_API_EXPORT __declspec(dllexport) + #define HID_API_CALL +#else + #define HID_API_EXPORT /**< API export macro */ + #define HID_API_CALL /**< API call macro */ +#endif + +#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/ + +#ifdef __cplusplus +extern "C" { +#endif + struct hid_device_; + typedef struct hid_device_ hid_device; /**< opaque hidapi structure */ + + /** hidapi info structure */ + struct hid_device_info { + /** Platform-specific device path */ + char *path; + /** Device Vendor ID */ + unsigned short vendor_id; + /** Device Product ID */ + unsigned short product_id; + /** Serial Number */ + wchar_t *serial_number; + /** Device Release Number in binary-coded decimal, + also known as Device Version Number */ + unsigned short release_number; + /** Manufacturer String */ + wchar_t *manufacturer_string; + /** Product string */ + wchar_t *product_string; + /** Usage Page for this Device/Interface + (Windows/Mac only). */ + unsigned short usage_page; + /** Usage for this Device/Interface + (Windows/Mac only).*/ + unsigned short usage; + /** The USB interface which this logical device + represents. Valid on both Linux implementations + in all cases, and valid on the Windows implementation + only if the device contains more than one interface. */ + int interface_number; + + /** Pointer to the next device */ + struct hid_device_info *next; + }; + + + /** @brief Initialize the HIDAPI library. + + This function initializes the HIDAPI library. Calling it is not + strictly necessary, as it will be called automatically by + hid_enumerate() and any of the hid_open_*() functions if it is + needed. This function should be called at the beginning of + execution however, if there is a chance of HIDAPI handles + being opened by different threads simultaneously. + + @ingroup API + + @returns + This function returns 0 on success and -1 on error. + */ + int HID_API_EXPORT HID_API_CALL hid_init(void); + + /** @brief Finalize the HIDAPI library. + + This function frees all of the static data associated with + HIDAPI. It should be called at the end of execution to avoid + memory leaks. + + @ingroup API + + @returns + This function returns 0 on success and -1 on error. + */ + int HID_API_EXPORT HID_API_CALL hid_exit(void); + + /** @brief Enumerate the HID Devices. + + This function returns a linked list of all the HID devices + attached to the system which match vendor_id and product_id. + If @p vendor_id is set to 0 then any vendor matches. + If @p product_id is set to 0 then any product matches. + If @p vendor_id and @p product_id are both set to 0, then + all HID devices will be returned. + + @ingroup API + @param vendor_id The Vendor ID (VID) of the types of device + to open. + @param product_id The Product ID (PID) of the types of + device to open. + + @returns + This function returns a pointer to a linked list of type + struct #hid_device, containing information about the HID devices + attached to the system, or NULL in the case of failure. Free + this linked list by calling hid_free_enumeration(). + */ + struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id); + + /** @brief Free an enumeration Linked List + + This function frees a linked list created by hid_enumerate(). + + @ingroup API + @param devs Pointer to a list of struct_device returned from + hid_enumerate(). + */ + void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs); + + /** @brief Open a HID device using a Vendor ID (VID), Product ID + (PID) and optionally a serial number. + + If @p serial_number is NULL, the first device with the + specified VID and PID is opened. + + @ingroup API + @param vendor_id The Vendor ID (VID) of the device to open. + @param product_id The Product ID (PID) of the device to open. + @param serial_number The Serial Number of the device to open + (Optionally NULL). + + @returns + This function returns a pointer to a #hid_device object on + success or NULL on failure. + */ + HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number); + + /** @brief Open a HID device by its path name. + + The path name be determined by calling hid_enumerate(), or a + platform-specific path name can be used (eg: /dev/hidraw0 on + Linux). + + @ingroup API + @param path The path name of the device to open + + @returns + This function returns a pointer to a #hid_device object on + success or NULL on failure. + */ + HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path); + + /** @brief Write an Output report to a HID device. + + The first byte of @p data[] must contain the Report ID. For + devices which only support a single report, this must be set + to 0x0. The remaining bytes contain the report data. Since + the Report ID is mandatory, calls to hid_write() will always + contain one more byte than the report contains. For example, + if a hid report is 16 bytes long, 17 bytes must be passed to + hid_write(), the Report ID (or 0x0, for devices with a + single report), followed by the report data (16 bytes). In + this example, the length passed in would be 17. + + hid_write() will send the data on the first OUT endpoint, if + one exists. If it does not, it will send the data through + the Control Endpoint (Endpoint 0). + + @ingroup API + @param device A device handle returned from hid_open(). + @param data The data to send, including the report number as + the first byte. + @param length The length in bytes of the data to send. + + @returns + This function returns the actual number of bytes written and + -1 on error. + */ + int HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length); + + /** @brief Read an Input report from a HID device with timeout. + + Input reports are returned + to the host through the INTERRUPT IN endpoint. The first byte will + contain the Report number if the device uses numbered reports. + + @ingroup API + @param device A device handle returned from hid_open(). + @param data A buffer to put the read data into. + @param length The number of bytes to read. For devices with + multiple reports, make sure to read an extra byte for + the report number. + @param milliseconds timeout in milliseconds or -1 for blocking wait. + + @returns + This function returns the actual number of bytes read and + -1 on error. If no packet was available to be read within + the timeout period, this function returns 0. + */ + int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds); + + /** @brief Read an Input report from a HID device. + + Input reports are returned + to the host through the INTERRUPT IN endpoint. The first byte will + contain the Report number if the device uses numbered reports. + + @ingroup API + @param device A device handle returned from hid_open(). + @param data A buffer to put the read data into. + @param length The number of bytes to read. For devices with + multiple reports, make sure to read an extra byte for + the report number. + + @returns + This function returns the actual number of bytes read and + -1 on error. If no packet was available to be read and + the handle is in non-blocking mode, this function returns 0. + */ + int HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length); + + /** @brief Set the device handle to be non-blocking. + + In non-blocking mode calls to hid_read() will return + immediately with a value of 0 if there is no data to be + read. In blocking mode, hid_read() will wait (block) until + there is data to read before returning. + + Nonblocking can be turned on and off at any time. + + @ingroup API + @param device A device handle returned from hid_open(). + @param nonblock enable or not the nonblocking reads + - 1 to enable nonblocking + - 0 to disable nonblocking. + + @returns + This function returns 0 on success and -1 on error. + */ + int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock); + + /** @brief Send a Feature report to the device. + + Feature reports are sent over the Control endpoint as a + Set_Report transfer. The first byte of @p data[] must + contain the Report ID. For devices which only support a + single report, this must be set to 0x0. The remaining bytes + contain the report data. Since the Report ID is mandatory, + calls to hid_send_feature_report() will always contain one + more byte than the report contains. For example, if a hid + report is 16 bytes long, 17 bytes must be passed to + hid_send_feature_report(): the Report ID (or 0x0, for + devices which do not use numbered reports), followed by the + report data (16 bytes). In this example, the length passed + in would be 17. + + @ingroup API + @param device A device handle returned from hid_open(). + @param data The data to send, including the report number as + the first byte. + @param length The length in bytes of the data to send, including + the report number. + + @returns + This function returns the actual number of bytes written and + -1 on error. + */ + int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length); + + /** @brief Get a feature report from a HID device. + + 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[]. Upon return, the first byte will + still contain the Report ID, and the report data will + start in data[1]. + + @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, or set it to zero + if your device does not use numbered reports. + @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 plus + one for the report ID (which is still in the first + byte), or -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/vastfmt b/vastfmt deleted file mode 160000 index b6cebd0..0000000 --- a/vastfmt +++ /dev/null @@ -1 +0,0 @@ -Subproject commit b6cebd08644d73f5a63522a83a95beb2a1d360e4