moxiu/K1NG-Driver
1
0
Fork 0
Code Issues Pull Requests Actions Releases 3 Activity

add broken ass source for now

Browse Source
This commit is contained in:
moxiu
2026-07-28 22:28:01 +02:00
commit 3176370951
174 changed files with 53679 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
includes/libusb-1.0.30/libusb/os/darwin_usb.c
+3057
View File
File diff suppressed because it is too large Load Diff
includes/libusb-1.0.30/libusb/os/darwin_usb.h
+158
View File
@@ -0,0 +1,158 @@
/*
* darwin backend for libusb 1.0
* Copyright © 2008-2023 Nathan Hjelm <hjelmn@users.sourceforge.net>
* Copyright © 2019-2023 Google LLC. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#if !defined(LIBUSB_DARWIN_H)
#define LIBUSB_DARWIN_H
#include <stdbool.h>
#include "libusbi.h"
#include <IOKit/IOTypes.h>
#include <IOKit/IOCFBundle.h>
#include <IOKit/usb/IOUSBLib.h>
#include <IOKit/IOCFPlugIn.h>
#if defined(HAVE_IOKIT_USB_IOUSBHOSTFAMILYDEFINITIONS_H)
#include <IOKit/usb/IOUSBHostFamilyDefinitions.h>
#endif
/* IOUSBInterfaceInferface */
#if defined(kIOUSBInterfaceInterfaceID800)
#define MAX_INTERFACE_VERSION 800
#elif defined(kIOUSBInterfaceInterfaceID700)
#define MAX_INTERFACE_VERSION 700
#elif defined(kIOUSBInterfaceInterfaceID650)
#define MAX_INTERFACE_VERSION 650
#elif defined(kIOUSBInterfaceInterfaceID550)
#define MAX_INTERFACE_VERSION 550
#elif defined(kIOUSBInterfaceInterfaceID245)
#define MAX_INTERFACE_VERSION 245
#else
#define MAX_INTERFACE_VERSION 220
#endif
/* set to the minimum version and casted up as needed. */
typedef IOUSBInterfaceInterface220 **usb_interface_t;
#define IOINTERFACE0(darwin_interface, version) ((IOUSBInterfaceInterface ## version **) (darwin_interface)->interface)
#define IOINTERFACE_V(darwin_interface, version) IOINTERFACE0(darwin_interface, version)
#define IOINTERFACE(darwin_interface) ((darwin_interface)->interface)
/* IOUSBDeviceInterface */
#if defined(kIOUSBDeviceInterfaceID650)
#define MAX_DEVICE_VERSION 650
#elif defined(kIOUSBDeviceInterfaceID500)
#define MAX_DEVICE_VERSION 500
#elif defined(kIOUSBDeviceInterfaceID320)
#define MAX_DEVICE_VERSION 320
#elif defined(kIOUSBDeviceInterfaceID300)
#define MAX_DEVICE_VERSION 300
#elif defined(kIOUSBDeviceInterfaceID245)
#define MAX_DEVICE_VERSION 245
#else
#define MAX_DEVICE_VERSION 197
#endif
/* set to the minimum version and casted up as needed */
typedef IOUSBDeviceInterface197 **usb_device_t;
#define IODEVICE0(darwin_device, version) ((IOUSBDeviceInterface ## version **)(darwin_device))
#define IODEVICE_V(darwin_device, version) IODEVICE0(darwin_device, version)
#if !defined(kIOUSBHostInterfaceClassName)
#define kIOUSBHostInterfaceClassName "IOUSBHostInterface"
#endif
#if !defined(kUSBHostMatchingPropertyInterfaceNumber)
#define kUSBHostMatchingPropertyInterfaceNumber "bInterfaceNumber"
#endif
#if !defined(IO_OBJECT_NULL)
#define IO_OBJECT_NULL ((io_object_t) 0)
#endif
/* returns the current macOS version in a format similar to the
* MAC_OS_X_VERSION_MIN_REQUIRED macro.
* Examples:
* 10.1.5 -> 100105
* 13.3.0 -> 130300
*/
uint32_t get_running_version(void);
typedef IOCFPlugInInterface *io_cf_plugin_ref_t;
typedef IONotificationPortRef io_notification_port_t;
/* private structures */
struct darwin_cached_device {
struct list_head list;
IOUSBDeviceDescriptor dev_descriptor;
UInt32 location;
UInt64 parent_session;
UInt64 session;
USBDeviceAddress address;
char sys_path[21];
usb_device_t device;
io_service_t service;
int open_count;
UInt8 first_config, active_config, port;
int can_enumerate;
int refcount;
atomic_bool in_reenumerate;
int capture_count;
};
struct darwin_device_priv {
struct darwin_cached_device *dev;
};
struct darwin_interface {
usb_interface_t interface;
uint8_t num_endpoints;
CFRunLoopSourceRef cfSource;
uint64_t frames[256];
uint8_t endpoint_addrs[USB_MAXENDPOINTS];
};
struct darwin_device_handle_priv {
bool is_open;
CFRunLoopSourceRef cfSource;
struct darwin_interface interfaces[USB_MAXINTERFACES];
};
struct darwin_transfer_priv {
/* Isoc */
IOUSBIsocFrame *isoc_framelist;
int num_iso_packets;
/* Control */
IOUSBDevRequestTO req;
/* Bulk */
/* Completion status */
IOReturn result;
UInt32 size;
};
#endif
includes/libusb-1.0.30/libusb/os/emscripten_webusb.cpp
+896
View File
@@ -0,0 +1,896 @@
/*
* Copyright © 2021 Google LLC
* Copyright © 2023 Ingvar Stepanyan <me@rreverser.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Authors:
* Ingvar Stepanyan <me@rreverser.com>
*/
#include <emscripten/version.h>
static_assert((__EMSCRIPTEN_major__ * 100 * 100 + __EMSCRIPTEN_minor__ * 100 +
__EMSCRIPTEN_tiny__) >= 30148,
"Emscripten 3.1.48 or newer is required.");
#include <assert.h>
#include <emscripten.h>
#include <emscripten/val.h>
#include <type_traits>
#include <utility>
#include "libusbi.h"
using namespace emscripten;
#ifdef _REENTRANT
#include <emscripten/proxying.h>
#include <emscripten/threading.h>
#include <pthread.h>
static ProxyingQueue queue;
#endif
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wshadow"
namespace {
// clang-format off
EM_JS(EM_VAL, usbi_em_promise_catch, (EM_VAL handle), {
let promise = Emval.toValue(handle);
promise = promise.then(
value => ({error : 0, value}),
error => {
console.error(error);
let errorCode = -99; // LIBUSB_ERROR_OTHER
if (error instanceof DOMException) {
const ERROR_CODES = {
// LIBUSB_ERROR_IO
NetworkError : -1,
// LIBUSB_ERROR_INVALID_PARAM
DataError : -2,
TypeMismatchError : -2,
IndexSizeError : -2,
// LIBUSB_ERROR_ACCESS
SecurityError : -3,
// LIBUSB_ERROR_NOT_FOUND
NotFoundError : -5,
// LIBUSB_ERROR_BUSY
InvalidStateError : -6,
// LIBUSB_ERROR_TIMEOUT
TimeoutError : -7,
// LIBUSB_ERROR_INTERRUPTED
AbortError : -10,
// LIBUSB_ERROR_NOT_SUPPORTED
NotSupportedError : -12,
};
errorCode = ERROR_CODES[error.name] ?? errorCode;
} else if (error instanceof RangeError || error instanceof TypeError) {
errorCode = -2; // LIBUSB_ERROR_INVALID_PARAM
}
return {error: errorCode, value: undefined};
}
);
return Emval.toHandle(promise);
});
EM_JS(void, usbi_em_copy_from_dataview, (void* dst, EM_VAL src), {
src = Emval.toValue(src);
src = new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
HEAPU8.set(src, dst);
});
// Our implementation proxies operations from multiple threads to the same
// underlying USBDevice on the main thread. This can lead to issues when
// multiple threads try to open/close the same device at the same time.
//
// First, since open/close operations are asynchronous in WebUSB, we can end up
// with multiple open/close operations in flight at the same time, which can
// lead to unpredictable outcome (e.g. device got closed but opening succeeded
// right before that).
//
// Second, since multiple threads are allowed to have their own handles to the
// same device, we need to keep track of number of open handles and close the
// device only when the last handle is closed.
//
// We fix both of these issues by using a shared promise chain that executes
// open and close operations sequentially and keeps track of the reference count
// in each promise's result. This way, we can ensure that only one open/close
// operation is in flight at any given time. Note that we don't need to worry
// about all other operations because they're preconditioned on the device being
// open and having at least 1 reference anyway.
EM_JS(EM_VAL, usbi_em_device_safe_open_close, (EM_VAL device, bool open), {
device = Emval.toValue(device);
const symbol = Symbol.for('libusb.open_close_chain');
let promiseChain = device[symbol] ?? Promise.resolve(0);
device[symbol] = promiseChain = promiseChain.then(async refCount => {
if (open) {
if (!refCount++) {
await device.open();
}
} else {
if (!--refCount) {
await device.close();
}
}
return refCount;
});
return Emval.toHandle(promiseChain);
});
// clang-format on
libusb_transfer_status getTransferStatus(const val& transfer_result) {
auto status = transfer_result["status"].as<std::string>();
if (status == "ok") {
return LIBUSB_TRANSFER_COMPLETED;
} else if (status == "stall") {
return LIBUSB_TRANSFER_STALL;
} else if (status == "babble") {
return LIBUSB_TRANSFER_OVERFLOW;
} else {
return LIBUSB_TRANSFER_ERROR;
}
}
// Note: this assumes that `dst` is valid for at least `src.byteLength` bytes.
// This is true for all results returned from WebUSB as we pass max length to
// the transfer APIs.
void copyFromDataView(void* dst, const val& src) {
usbi_em_copy_from_dataview(dst, src.as_handle());
}
auto getUnsharedMemoryView(void* src, size_t len) {
auto view = typed_memory_view(len, (uint8_t*)src);
#ifdef _REENTRANT
// Unfortunately, TypedArrays backed by SharedArrayBuffers are not accepted
// by most Web APIs, trading off guaranteed thread-safety for performance
// loss. The usual workaround is to copy them into a new TypedArray, which
// is what we do here via the `.slice()` method.
return val(view).call<val>("slice");
#else
// Non-threaded builds can avoid the copy penalty.
return view;
#endif
}
// A helper that proxies a function call to the main thread if not already
// there. This is a wrapper around Emscripten's raw proxying API with couple of
// high-level improvements, namely support for destroying lambda on the target
// thread as well as custom return types.
template <typename Func>
auto runOnMain(Func&& func) {
#ifdef _REENTRANT
if (!emscripten_is_main_runtime_thread()) {
if constexpr (std::is_same_v<std::invoke_result_t<Func>, void>) {
bool proxied =
queue.proxySync(emscripten_main_runtime_thread_id(), [&func] {
// Capture func by reference and move into a local variable
// to render the captured func inert on the first (and only)
// call. This way it can be safely destructed on the main
// thread instead of the current one when this call
// finishes. TODO: remove this when
// https://github.com/emscripten-core/emscripten/issues/20610
// is fixed.
auto func_ = std::move(func);
func_();
});
assert(proxied);
return;
} else {
// A storage for the result of the function call.
// TODO: remove when
// https://github.com/emscripten-core/emscripten/issues/20611 is
// implemented.
std::optional<std::invoke_result_t<Func>> result;
runOnMain(
[&result, func = std::move(func)] { result.emplace(func()); });
return std::move(result.value());
}
}
#endif
return func();
}
// C++ struct representation for `{value, error}` object used by `CaughtPromise`
// below.
struct PromiseResult {
int error;
val value;
PromiseResult() = delete;
PromiseResult(PromiseResult&&) = default;
PromiseResult(val&& result)
: error(result["error"].as<int>()), value(result["value"]) {}
~PromiseResult() {
// make sure value is freed on the thread it exists on
runOnMain([value = std::move(value)] {});
}
};
struct CaughtPromise : val {
CaughtPromise(val&& promise)
: val(wrapPromiseWithCatch(std::move(promise))) {}
using AwaitResult = PromiseResult;
private:
// Wrap promise with conversion from some value T to `{value: T, error:
// number}`.
static val wrapPromiseWithCatch(val&& promise) {
auto handle = promise.as_handle();
handle = usbi_em_promise_catch(handle);
return val::take_ownership(handle);
}
};
#define co_await_try(promise) \
({ \
PromiseResult result = co_await CaughtPromise(promise); \
if (result.error) { \
co_return result.error; \
} \
std::move(result.value); \
})
// A helper that runs an asynchronous callback when the promise is resolved.
template <typename Promise, typename OnResult>
val promiseThen(Promise&& promise, OnResult&& onResult) {
// Save captures from the callback while we can, or they'll be destructed.
// https://devblogs.microsoft.com/oldnewthing/20211103-00/?p=105870
auto onResult_ = std::move(onResult);
onResult_(co_await promise);
co_return val::undefined();
}
// A helper that runs an asynchronous function on the main thread and blocks the
// current thread until the promise is resolved (via Asyncify "blocking" if
// already on the main thread or regular blocking otherwise).
template <typename Func>
static std::invoke_result_t<Func>::AwaitResult awaitOnMain(Func&& func) {
#ifdef _REENTRANT
if (!emscripten_is_main_runtime_thread()) {
// If we're on a different thread, we can't use main thread's Asyncify
// as multiple threads might be fighting for its state; instead, use
// proxying to synchronously block the current thread until the promise
// is complete.
std::optional<typename std::invoke_result_t<Func>::AwaitResult> result;
queue.proxySyncWithCtx(
emscripten_main_runtime_thread_id(),
[&result, &func](ProxyingQueue::ProxyingCtx ctx) {
// Same as `func` in `runOnMain`, move to destruct on the first
// call.
auto func_ = std::move(func);
promiseThen(
func_(),
[&result, ctx = std::move(ctx)](auto&& result_) mutable {
result.emplace(std::move(result_));
ctx.finish();
});
});
return std::move(result.value());
}
#endif
// If we're already on the main thread, use Asyncify to block until the
// promise is resolved.
return func().await();
}
// A helper that makes a control transfer given a setup pointer (assumed to be
// followed by data payload for out-transfers).
val makeControlTransferPromise(const val& dev, libusb_control_setup* setup) {
auto params = val::object();
const char* request_type = "unknown";
// See LIBUSB_REQ_TYPE in windows_winusb.h (or docs for `bmRequestType`).
switch (setup->bmRequestType & (0x03 << 5)) {
case LIBUSB_REQUEST_TYPE_STANDARD:
request_type = "standard";
break;
case LIBUSB_REQUEST_TYPE_CLASS:
request_type = "class";
break;
case LIBUSB_REQUEST_TYPE_VENDOR:
request_type = "vendor";
break;
}
params.set("requestType", request_type);
const char* recipient = "other";
switch (setup->bmRequestType & 0x0f) {
case LIBUSB_RECIPIENT_DEVICE:
recipient = "device";
break;
case LIBUSB_RECIPIENT_INTERFACE:
recipient = "interface";
break;
case LIBUSB_RECIPIENT_ENDPOINT:
recipient = "endpoint";
break;
}
params.set("recipient", recipient);
params.set("request", setup->bRequest);
params.set("value", setup->wValue);
params.set("index", setup->wIndex);
if (setup->bmRequestType & LIBUSB_ENDPOINT_IN) {
return dev.call<val>("controlTransferIn", params, setup->wLength);
} else {
return dev.call<val>("controlTransferOut", params,
getUnsharedMemoryView(setup + 1, setup->wLength));
}
}
// Smart pointer for managing pointers to places allocated by libusb inside its
// backend structures.
template <typename T>
struct ValPtr {
template <typename... Args>
void emplace(Args&&... args) {
new (ptr) T(std::forward<Args>(args)...);
}
const T& operator*() const { return *ptr; }
T& operator*() { return *ptr; }
const T* operator->() const { return ptr; }
T* operator->() { return ptr; }
void free() { ptr->~T(); }
T take() {
auto value = std::move(*ptr);
free();
return value;
}
protected:
ValPtr(void* ptr) : ptr(static_cast<T*>(ptr)) {}
private:
// Note: this is not a heap-allocated pointer, but a pointer to a part
// of the backend structure allocated by libusb itself.
T* ptr;
};
struct CachedDevice;
struct WebUsbDevicePtr : ValPtr<CachedDevice> {
public:
WebUsbDevicePtr(libusb_device* dev) : ValPtr(usbi_get_device_priv(dev)) {}
WebUsbDevicePtr(libusb_device_handle* handle)
: WebUsbDevicePtr(handle->dev) {}
};
struct WebUsbTransferPtr : ValPtr<PromiseResult> {
public:
WebUsbTransferPtr(usbi_transfer* itransfer)
: ValPtr(usbi_get_transfer_priv(itransfer)) {}
};
enum class OpenClose : bool {
Open = true,
Close = false,
};
struct CachedDevice {
CachedDevice() = delete;
CachedDevice(CachedDevice&&) = delete;
// Fill in the device descriptor and configurations by reading them from the
// WebUSB device.
static val initFromDevice(val&& web_usb_dev, libusb_device* libusb_dev) {
auto cachedDevicePtr = WebUsbDevicePtr(libusb_dev);
cachedDevicePtr.emplace(std::move(web_usb_dev));
bool must_close = false;
val result = co_await cachedDevicePtr->initFromDeviceWithoutClosing(
libusb_dev, must_close);
if (must_close) {
co_await_try(cachedDevicePtr->safeOpenCloseAssumingMainThread(
OpenClose::Close));
}
co_return std::move(result);
}
const val& getDeviceAssumingMainThread() const { return device; }
uint8_t getActiveConfigValue() const {
return runOnMain([&] {
auto web_usb_config = device["configuration"];
return web_usb_config.isNull()
? 0
: web_usb_config["configurationValue"].as<uint8_t>();
});
}
usbi_configuration_descriptor* getConfigDescriptor(uint8_t config_id) {
return config_id < configurations.size()
? configurations[config_id].get()
: nullptr;
}
usbi_configuration_descriptor* findConfigDescriptorByValue(
uint8_t config_id) const {
for (auto& config : configurations) {
if (config->bConfigurationValue == config_id) {
return config.get();
}
}
return nullptr;
}
int copyConfigDescriptor(const usbi_configuration_descriptor* config,
void* buf,
size_t buf_len) {
auto len = std::min(buf_len, (size_t)config->wTotalLength);
memcpy(buf, config, len);
return len;
}
template <typename... Args>
int awaitOnMain(const char* methodName, Args&&... args) const {
return ::awaitOnMain([&] {
return CaughtPromise(device.call<val>(
methodName, std::forward<Args>(args)...));
})
.error;
}
~CachedDevice() {
runOnMain([device = std::move(device)] {});
}
CaughtPromise safeOpenCloseAssumingMainThread(OpenClose open) {
return val::take_ownership(usbi_em_device_safe_open_close(
device.as_handle(), static_cast<bool>(open)));
}
int safeOpenCloseOnMain(OpenClose open) {
return ::awaitOnMain([this, open] {
return safeOpenCloseAssumingMainThread(open);
})
.error;
}
private:
val device;
std::vector<std::unique_ptr<usbi_configuration_descriptor>> configurations;
CaughtPromise requestDescriptor(libusb_descriptor_type desc_type,
uint8_t desc_index,
uint16_t max_length) const {
libusb_control_setup setup = {
.bmRequestType = LIBUSB_ENDPOINT_IN,
.bRequest = LIBUSB_REQUEST_GET_DESCRIPTOR,
.wValue = (uint16_t)((desc_type << 8) | desc_index),
.wIndex = 0,
.wLength = max_length,
};
return makeControlTransferPromise(device, &setup);
}
// Implementation of the `CachedDevice::initFromDevice` above. This is a
// separate function just because we need to close the device on exit if
// we opened it successfully, and we can't use an async operation (`close`)
// in RAII destructor.
val initFromDeviceWithoutClosing(libusb_device* dev, bool& must_close) {
co_await_try(safeOpenCloseAssumingMainThread(OpenClose::Open));
// Can't use RAII to close on exit as co_await is not permitted in
// destructors (yet:
// https://github.com/cplusplus/papers/issues/445), so use a good
// old boolean + a wrapper instead.
must_close = true;
{
auto result = co_await_try(
requestDescriptor(LIBUSB_DT_DEVICE, 0, LIBUSB_DT_DEVICE_SIZE));
if (auto error = getTransferStatus(result)) {
co_return error;
}
copyFromDataView(&dev->device_descriptor, result["data"]);
}
// Infer the device speed (which is not yet provided by WebUSB) from
// the descriptor.
if (dev->device_descriptor.bMaxPacketSize0 ==
/* actually means 2^9, only valid for superspeeds */ 9) {
dev->speed = dev->device_descriptor.bcdUSB >= 0x0310
? LIBUSB_SPEED_SUPER_PLUS
: LIBUSB_SPEED_SUPER;
} else if (dev->device_descriptor.bcdUSB >= 0x0200) {
dev->speed = LIBUSB_SPEED_HIGH;
} else if (dev->device_descriptor.bMaxPacketSize0 > 8) {
dev->speed = LIBUSB_SPEED_FULL;
} else {
dev->speed = LIBUSB_SPEED_LOW;
}
if (auto error = usbi_sanitize_device(dev)) {
co_return error;
}
auto configurations_len = dev->device_descriptor.bNumConfigurations;
configurations.reserve(configurations_len);
for (uint8_t j = 0; j < configurations_len; j++) {
// Read descriptor header first to discover target length.
auto config_header_result = co_await_try(
requestDescriptor(LIBUSB_DT_CONFIG, j, LIBUSB_DT_CONFIG_SIZE));
if (auto error = getTransferStatus(config_header_result)) {
co_return error;
}
union usbi_config_desc_buf config_header = {};
copyFromDataView(config_header.buf, config_header_result["data"]);
if (config_header.desc.bDescriptorType != LIBUSB_DT_CONFIG ||
config_header.desc.bLength < LIBUSB_DT_CONFIG_SIZE) {
co_return LIBUSB_ERROR_IO;
}
auto config_total_length =
libusb_le16_to_cpu(config_header.desc.wTotalLength);
if (config_total_length < LIBUSB_DT_CONFIG_SIZE) {
co_return LIBUSB_ERROR_IO;
}
auto config_result = co_await_try(
requestDescriptor(LIBUSB_DT_CONFIG, j, config_total_length));
if (auto error = getTransferStatus(config_result)) {
co_return error;
}
auto configVal = config_result["data"];
if (configVal["byteLength"].as<size_t>() < config_total_length) {
co_return LIBUSB_ERROR_IO;
}
auto configLen = configVal["byteLength"].as<size_t>();
auto& config = configurations.emplace_back(
(usbi_configuration_descriptor*)::operator new(configLen));
copyFromDataView(config.get(), configVal);
}
co_return (int) LIBUSB_SUCCESS;
}
CachedDevice(val device) : device(std::move(device)) {}
friend struct ValPtr<CachedDevice>;
};
unsigned long getDeviceSessionId(val& web_usb_device) {
thread_local const val SessionIdSymbol =
val::global("Symbol")(val("libusb.session_id"));
val session_id_val = web_usb_device[SessionIdSymbol];
if (!session_id_val.isUndefined()) {
return session_id_val.as<unsigned long>();
}
// If the device doesn't have a session ID, it means we haven't seen
// it before. Generate a new session ID for it. We can associate an
// incrementing ID with the `USBDevice` object itself. It's
// guaranteed to be alive and, thus, stable as long as the device is
// connected, even between different libusb invocations. See
// https://github.com/WICG/webusb/issues/241.
static unsigned long next_session_id = 0;
web_usb_device.set(SessionIdSymbol, next_session_id);
return next_session_id++;
}
val getDeviceList(libusb_context* ctx, discovered_devs** devs) {
// Check if browser supports USB
val navigator_usb = val::global("navigator")["usb"];
if (navigator_usb == val::undefined()) {
co_return (int) LIBUSB_ERROR_NOT_SUPPORTED;
}
// C++ equivalent of `await navigator.usb.getDevices()`. Note: at this point
// we must already have some devices exposed - caller must have called
// `await navigator.usb.requestDevice(...)` in response to user interaction
// before going to LibUSB. Otherwise this list will be empty.
auto web_usb_devices =
co_await_try(navigator_usb.call<val>("getDevices"));
for (auto&& web_usb_device : web_usb_devices) {
auto session_id = getDeviceSessionId(web_usb_device);
auto dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev == NULL) {
dev = usbi_alloc_device(ctx, session_id);
if (dev == NULL) {
usbi_err(ctx, "failed to allocate a new device structure");
continue;
}
auto statusVal = co_await CachedDevice::initFromDevice(
std::move(web_usb_device), dev);
if (auto error = statusVal.as<int>()) {
usbi_err(ctx, "failed to read device information: %s",
libusb_error_name(error));
libusb_unref_device(dev);
continue;
}
// We don't have real buses in WebUSB, just pretend everything
// is on bus 1.
dev->bus_number = 1;
// This can wrap around but it's the best approximation of a stable
// device address and port number we can provide.
dev->device_address = dev->port_number = (uint8_t)session_id;
usbi_connect_device(dev);
}
*devs = discovered_devs_append(*devs, dev);
libusb_unref_device(dev);
}
co_return (int) LIBUSB_SUCCESS;
}
int em_get_device_list(libusb_context* ctx, discovered_devs** devs) {
// No need to wrap into CaughtPromise as we catch all individual ops in the
// inner implementation and return just the error code. We do need a custom
// promise type to ensure conversion to int happens on the main thread
// though.
struct IntPromise : val {
IntPromise(val&& promise) : val(std::move(promise)) {}
struct AwaitResult {
int error;
AwaitResult(val&& result) : error(result.as<int>()) {}
};
};
return awaitOnMain(
[ctx, devs] { return IntPromise(getDeviceList(ctx, devs)); })
.error;
}
int em_open(libusb_device_handle* handle) {
return WebUsbDevicePtr(handle)->safeOpenCloseOnMain(OpenClose::Open);
}
void em_close(libusb_device_handle* handle) {
// LibUSB API doesn't allow us to handle an error here, but we still need to
// wait for the promise to make sure that subsequent attempt to reopen the
// same device doesn't fail with a "device busy" error.
if (auto error =
WebUsbDevicePtr(handle)->safeOpenCloseOnMain(OpenClose::Close)) {
usbi_err(handle->dev->ctx, "failed to close device: %s",
libusb_error_name(error));
}
}
int em_get_active_config_descriptor(libusb_device* dev, void* buf, size_t len) {
auto& cached_device = *WebUsbDevicePtr(dev);
auto config_value = cached_device.getActiveConfigValue();
if (auto config = cached_device.findConfigDescriptorByValue(config_value)) {
return cached_device.copyConfigDescriptor(config, buf, len);
} else {
return LIBUSB_ERROR_NOT_FOUND;
}
}
int em_get_config_descriptor(libusb_device* dev,
uint8_t config_id,
void* buf,
size_t len) {
auto& cached_device = *WebUsbDevicePtr(dev);
if (auto config = cached_device.getConfigDescriptor(config_id)) {
return cached_device.copyConfigDescriptor(config, buf, len);
} else {
return LIBUSB_ERROR_NOT_FOUND;
}
}
int em_get_configuration(libusb_device_handle* dev_handle,
uint8_t* config_value) {
*config_value = WebUsbDevicePtr(dev_handle)->getActiveConfigValue();
return LIBUSB_SUCCESS;
}
int em_get_config_descriptor_by_value(libusb_device* dev,
uint8_t config_value,
void** buf) {
auto& cached_device = *WebUsbDevicePtr(dev);
if (auto config = cached_device.findConfigDescriptorByValue(config_value)) {
*buf = config;
return config->wTotalLength;
} else {
return LIBUSB_ERROR_NOT_FOUND;
}
}
int em_set_configuration(libusb_device_handle* dev_handle, int config) {
return WebUsbDevicePtr(dev_handle)->awaitOnMain("selectConfiguration", config);
}
int em_claim_interface(libusb_device_handle* handle, uint8_t iface) {
return WebUsbDevicePtr(handle)->awaitOnMain("claimInterface", iface);
}
int em_release_interface(libusb_device_handle* handle, uint8_t iface) {
return WebUsbDevicePtr(handle)->awaitOnMain("releaseInterface", iface);
}
int em_set_interface_altsetting(libusb_device_handle* handle,
uint8_t iface,
uint8_t altsetting) {
return WebUsbDevicePtr(handle)->awaitOnMain("selectAlternateInterface",
iface, altsetting);
}
int em_clear_halt(libusb_device_handle* handle, unsigned char endpoint) {
std::string direction = endpoint & LIBUSB_ENDPOINT_IN ? "in" : "out";
endpoint &= LIBUSB_ENDPOINT_ADDRESS_MASK;
return WebUsbDevicePtr(handle)->awaitOnMain("clearHalt", direction,
endpoint);
}
int em_reset_device(libusb_device_handle* handle) {
return WebUsbDevicePtr(handle)->awaitOnMain("reset");
}
void em_destroy_device(libusb_device* dev) {
WebUsbDevicePtr(dev).free();
}
int em_submit_transfer(usbi_transfer* itransfer) {
return runOnMain([itransfer] {
auto transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
auto& web_usb_device = WebUsbDevicePtr(transfer->dev_handle)
->getDeviceAssumingMainThread();
val transfer_promise;
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL: {
transfer_promise = makeControlTransferPromise(
web_usb_device,
libusb_control_transfer_get_setup(transfer));
break;
}
case LIBUSB_TRANSFER_TYPE_BULK:
case LIBUSB_TRANSFER_TYPE_INTERRUPT: {
auto endpoint =
transfer->endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK;
if (IS_XFERIN(transfer)) {
transfer_promise = web_usb_device.call<val>(
"transferIn", endpoint, transfer->length);
} else {
auto data = getUnsharedMemoryView(transfer->buffer,
transfer->length);
transfer_promise =
web_usb_device.call<val>("transferOut", endpoint, data);
}
break;
}
// TODO: add implementation for isochronous transfers too.
default:
return LIBUSB_ERROR_NOT_SUPPORTED;
}
// Not a coroutine because we don't want to block on this promise, just
// schedule an asynchronous callback.
promiseThen(CaughtPromise(std::move(transfer_promise)),
[itransfer](auto&& result) {
WebUsbTransferPtr(itransfer).emplace(std::move(result));
usbi_signal_transfer_completion(itransfer);
});
return LIBUSB_SUCCESS;
});
}
void em_clear_transfer_priv(usbi_transfer* itransfer) {
WebUsbTransferPtr(itransfer).free();
}
int em_cancel_transfer(usbi_transfer* itransfer) {
return LIBUSB_SUCCESS;
}
int em_handle_transfer_completion(usbi_transfer* itransfer) {
libusb_transfer_status status = runOnMain([itransfer] {
auto transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
// Take ownership of the transfer result, as `em_clear_transfer_priv` is
// not called automatically for completed transfers and we must free it
// to avoid leaks.
auto result = WebUsbTransferPtr(itransfer).take();
if (itransfer->state_flags & USBI_TRANSFER_CANCELLING) {
return LIBUSB_TRANSFER_CANCELLED;
}
if (result.error) {
return LIBUSB_TRANSFER_ERROR;
}
auto& value = result.value;
void* dataDest;
unsigned char endpointDir;
if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) {
dataDest = libusb_control_transfer_get_data(transfer);
endpointDir =
libusb_control_transfer_get_setup(transfer)->bmRequestType;
} else {
dataDest = transfer->buffer;
endpointDir = transfer->endpoint;
}
if (endpointDir & LIBUSB_ENDPOINT_IN) {
auto data = value["data"];
if (!data.isNull()) {
itransfer->transferred = data["byteLength"].as<int>();
copyFromDataView(dataDest, data);
}
} else {
itransfer->transferred = value["bytesWritten"].as<int>();
}
return getTransferStatus(value);
});
// Invoke user's handlers outside of the main thread to reduce pressure.
return status == LIBUSB_TRANSFER_CANCELLED
? usbi_handle_transfer_cancellation(itransfer)
: usbi_handle_transfer_completion(itransfer, status);
}
} // namespace
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
extern "C" const usbi_os_backend usbi_backend = {
.name = "Emscripten + WebUSB backend",
.caps = 0,
.get_device_list = em_get_device_list,
.open = em_open,
.close = em_close,
.get_active_config_descriptor = em_get_active_config_descriptor,
.get_config_descriptor = em_get_config_descriptor,
.get_config_descriptor_by_value = em_get_config_descriptor_by_value,
.get_configuration = em_get_configuration,
.set_configuration = em_set_configuration,
.claim_interface = em_claim_interface,
.release_interface = em_release_interface,
.set_interface_altsetting = em_set_interface_altsetting,
.clear_halt = em_clear_halt,
.reset_device = em_reset_device,
.destroy_device = em_destroy_device,
.submit_transfer = em_submit_transfer,
.cancel_transfer = em_cancel_transfer,
.clear_transfer_priv = em_clear_transfer_priv,
.handle_transfer_completion = em_handle_transfer_completion,
.device_priv_size = sizeof(CachedDevice),
.transfer_priv_size = sizeof(PromiseResult),
};
#pragma clang diagnostic pop
includes/libusb-1.0.30/libusb/os/events_posix.c
+340
View File
@@ -0,0 +1,340 @@
/*
* libusb event abstraction on POSIX platforms
*
* Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
#include <errno.h>
#include <fcntl.h>
#ifdef HAVE_EVENTFD
#include <sys/eventfd.h>
#endif
#ifdef HAVE_TIMERFD
#include <sys/timerfd.h>
#endif
#ifdef __EMSCRIPTEN__
/* On Emscripten `pipe` does not conform to the spec and does not block
* until events are available, which makes it unusable for event system
* and often results in deadlocks when `pipe` is in a loop like it is
* in libusb.
*
* Therefore use a custom event system based on browser event emitters. */
#include <emscripten.h>
#include <emscripten/atomic.h>
#include <emscripten/threading.h>
EM_ASYNC_JS(void, em_libusb_wait_async, (const _Atomic int* ptr, int expected_value, int timeout), {
await Atomics.waitAsync(HEAP32, ptr >> 2, expected_value, timeout).value;
});
static void em_libusb_wait(const _Atomic int *ptr, int expected_value, int timeout)
{
if (emscripten_is_main_runtime_thread()) {
em_libusb_wait_async(ptr, expected_value, timeout);
} else {
emscripten_atomic_wait_u32((int*)ptr, expected_value, 1000000LL * timeout);
}
}
#endif
#include <unistd.h>
#ifdef HAVE_EVENTFD
#define EVENT_READ_FD(e) ((e)->eventfd)
#define EVENT_WRITE_FD(e) ((e)->eventfd)
#else
#define EVENT_READ_FD(e) ((e)->pipefd[0])
#define EVENT_WRITE_FD(e) ((e)->pipefd[1])
#endif
#ifdef HAVE_NFDS_T
typedef nfds_t usbi_nfds_t;
#else
typedef unsigned int usbi_nfds_t;
#endif
int usbi_create_event(usbi_event_t *event)
{
#ifdef HAVE_EVENTFD
event->eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
if (event->eventfd == -1) {
usbi_err(NULL, "failed to create eventfd, errno=%d", errno);
return LIBUSB_ERROR_OTHER;
}
return 0;
#else
#if defined(HAVE_PIPE2)
int ret = pipe2(event->pipefd, O_CLOEXEC);
#else
int ret = pipe(event->pipefd);
#endif
if (ret != 0) {
usbi_err(NULL, "failed to create pipe, errno=%d", errno);
return LIBUSB_ERROR_OTHER;
}
#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
ret = fcntl(event->pipefd[0], F_GETFD);
if (ret == -1) {
usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
goto err_close_pipe;
}
ret = fcntl(event->pipefd[0], F_SETFD, ret | FD_CLOEXEC);
if (ret == -1) {
usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
goto err_close_pipe;
}
ret = fcntl(event->pipefd[1], F_GETFD);
if (ret == -1) {
usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
goto err_close_pipe;
}
ret = fcntl(event->pipefd[1], F_SETFD, ret | FD_CLOEXEC);
if (ret == -1) {
usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
goto err_close_pipe;
}
#endif
ret = fcntl(event->pipefd[1], F_GETFL);
if (ret == -1) {
usbi_err(NULL, "failed to get pipe fd status flags, errno=%d", errno);
goto err_close_pipe;
}
ret = fcntl(event->pipefd[1], F_SETFL, ret | O_NONBLOCK);
if (ret == -1) {
usbi_err(NULL, "failed to set pipe fd status flags, errno=%d", errno);
goto err_close_pipe;
}
return 0;
err_close_pipe:
close(event->pipefd[1]);
close(event->pipefd[0]);
return LIBUSB_ERROR_OTHER;
#endif
}
void usbi_destroy_event(usbi_event_t *event)
{
#ifdef HAVE_EVENTFD
if (close(event->eventfd) == -1)
usbi_warn(NULL, "failed to close eventfd, errno=%d", errno);
#else
if (close(event->pipefd[1]) == -1)
usbi_warn(NULL, "failed to close pipe write end, errno=%d", errno);
if (close(event->pipefd[0]) == -1)
usbi_warn(NULL, "failed to close pipe read end, errno=%d", errno);
#endif
}
void usbi_signal_event(usbi_event_t *event)
{
uint64_t dummy = 1;
ssize_t r;
r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
if (r != sizeof(dummy))
usbi_warn(NULL, "event write failed");
#ifdef __EMSCRIPTEN__
event->has_event = 1;
emscripten_atomic_notify(&event->has_event, EMSCRIPTEN_NOTIFY_ALL_WAITERS);
#endif
}
void usbi_clear_event(usbi_event_t *event)
{
uint64_t dummy;
ssize_t r;
r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
if (r != sizeof(dummy))
usbi_warn(NULL, "event read failed");
#ifdef __EMSCRIPTEN__
event->has_event = 0;
#endif
}
#ifdef HAVE_TIMERFD
int usbi_create_timer(usbi_timer_t *timer)
{
timer->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
if (timer->timerfd == -1) {
usbi_warn(NULL, "failed to create timerfd, errno=%d", errno);
return LIBUSB_ERROR_OTHER;
}
return 0;
}
void usbi_destroy_timer(usbi_timer_t *timer)
{
if (close(timer->timerfd) == -1)
usbi_warn(NULL, "failed to close timerfd, errno=%d", errno);
}
int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
{
const struct itimerspec it = { { 0, 0 }, { timeout->tv_sec, timeout->tv_nsec } };
if (timerfd_settime(timer->timerfd, TFD_TIMER_ABSTIME, &it, NULL) == -1) {
usbi_warn(NULL, "failed to arm timerfd, errno=%d", errno);
return LIBUSB_ERROR_OTHER;
}
return 0;
}
int usbi_disarm_timer(usbi_timer_t *timer)
{
const struct itimerspec it = { { 0, 0 }, { 0, 0 } };
if (timerfd_settime(timer->timerfd, 0, &it, NULL) == -1) {
usbi_warn(NULL, "failed to disarm timerfd, errno=%d", errno);
return LIBUSB_ERROR_OTHER;
}
return 0;
}
#endif
int usbi_alloc_event_data(struct libusb_context *ctx)
{
struct usbi_event_source *ievent_source;
struct pollfd *fds;
size_t i = 0;
if (ctx->event_data) {
free(ctx->event_data);
ctx->event_data = NULL;
}
ctx->event_data_cnt = 0;
for_each_event_source(ctx, ievent_source)
ctx->event_data_cnt++;
fds = calloc(ctx->event_data_cnt, sizeof(*fds));
if (!fds)
return LIBUSB_ERROR_NO_MEM;
for_each_event_source(ctx, ievent_source) {
fds[i].fd = ievent_source->data.os_handle;
fds[i].events = ievent_source->data.poll_events;
i++;
}
ctx->event_data = fds;
return 0;
}
int usbi_wait_for_events(struct libusb_context *ctx,
struct usbi_reported_events *reported_events, int timeout_ms)
{
struct pollfd *fds = ctx->event_data;
usbi_nfds_t nfds = (usbi_nfds_t)ctx->event_data_cnt;
int internal_fds, num_ready;
usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
#ifdef __EMSCRIPTEN__
/* Emscripten's poll doesn't actually block, so we need to use an
* out-of-band waiting signal. */
em_libusb_wait(&ctx->event.has_event, 0, timeout_ms);
/* Emscripten ignores timeout_ms, but set it to 0 for future-proofing
* in case they ever implement real poll. */
timeout_ms = 0;
#endif
num_ready = poll(fds, nfds, timeout_ms);
usbi_dbg(ctx, "poll() returned %d", num_ready);
if (num_ready == 0) {
if (usbi_using_timer(ctx))
goto done;
return LIBUSB_ERROR_TIMEOUT;
} else if (num_ready == -1) {
if (errno == EINTR)
return LIBUSB_ERROR_INTERRUPTED;
usbi_err(ctx, "poll() failed, errno=%d", errno);
return LIBUSB_ERROR_IO;
}
/* fds[0] is always the internal signalling event */
if (fds[0].revents) {
reported_events->event_triggered = 1;
num_ready--;
} else {
reported_events->event_triggered = 0;
}
#ifdef HAVE_OS_TIMER
/* on timer configurations, fds[1] is the timer */
if (usbi_using_timer(ctx) && fds[1].revents) {
reported_events->timer_triggered = 1;
num_ready--;
} else {
reported_events->timer_triggered = 0;
}
#endif
if (!num_ready)
goto done;
/* the backend will never need to attempt to handle events on the
* library's internal file descriptors, so we determine how many are
* in use internally for this context and skip these when passing any
* remaining pollfds to the backend. */
internal_fds = usbi_using_timer(ctx) ? 2 : 1;
fds += internal_fds;
nfds -= internal_fds;
usbi_mutex_lock(&ctx->event_data_lock);
if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
struct usbi_event_source *ievent_source;
for_each_removed_event_source(ctx, ievent_source) {
usbi_nfds_t n;
for (n = 0; n < nfds; n++) {
if (ievent_source->data.os_handle != fds[n].fd)
continue;
if (!fds[n].revents)
continue;
/* pollfd was removed between the creation of the fds array and
* here. remove triggered revent as it is no longer relevant. */
usbi_dbg(ctx, "fd %d was removed, ignoring raised events", fds[n].fd);
fds[n].revents = 0;
num_ready--;
break;
}
}
}
usbi_mutex_unlock(&ctx->event_data_lock);
if (num_ready) {
assert(num_ready > 0);
reported_events->event_data = fds;
reported_events->event_data_count = (unsigned int)nfds;
}
done:
reported_events->num_ready = num_ready;
return LIBUSB_SUCCESS;
}
includes/libusb-1.0.30/libusb/os/events_posix.h
+62
View File
@@ -0,0 +1,62 @@
/*
* libusb event abstraction on POSIX platforms
*
* Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_EVENTS_POSIX_H
#define LIBUSB_EVENTS_POSIX_H
#include <poll.h>
typedef int usbi_os_handle_t;
#define USBI_OS_HANDLE_FORMAT_STRING "fd %d"
#ifdef HAVE_EVENTFD
typedef struct usbi_event {
int eventfd;
} usbi_event_t;
#define USBI_EVENT_OS_HANDLE(e) ((e)->eventfd)
#define USBI_EVENT_POLL_EVENTS POLLIN
#define USBI_INVALID_EVENT { -1 }
#else
typedef struct usbi_event {
int pipefd[2];
#ifdef __EMSCRIPTEN__
_Atomic int has_event;
#endif
} usbi_event_t;
#define USBI_EVENT_OS_HANDLE(e) ((e)->pipefd[0])
#define USBI_EVENT_POLL_EVENTS POLLIN
#define USBI_INVALID_EVENT { { -1, -1 } }
#endif
#ifdef HAVE_TIMERFD
#define HAVE_OS_TIMER 1
typedef struct usbi_timer {
int timerfd;
} usbi_timer_t;
#define USBI_TIMER_OS_HANDLE(t) ((t)->timerfd)
#define USBI_TIMER_POLL_EVENTS POLLIN
static inline int usbi_timer_valid(usbi_timer_t *timer)
{
return timer->timerfd >= 0;
}
#endif
#endif
includes/libusb-1.0.30/libusb/os/events_windows.c
+214
View File
@@ -0,0 +1,214 @@
/*
* libusb event abstraction on Microsoft Windows
*
* Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <config.h>
#include "libusbi.h"
#include "windows_common.h"
int usbi_create_event(usbi_event_t *event)
{
event->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (event->hEvent == NULL) {
usbi_err(NULL, "CreateEvent failed: %s", windows_error_str(0));
return LIBUSB_ERROR_OTHER;
}
return 0;
}
void usbi_destroy_event(usbi_event_t *event)
{
if (!CloseHandle(event->hEvent))
usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
}
void usbi_signal_event(usbi_event_t *event)
{
if (!SetEvent(event->hEvent))
usbi_warn(NULL, "SetEvent failed: %s", windows_error_str(0));
}
void usbi_clear_event(usbi_event_t *event)
{
if (!ResetEvent(event->hEvent))
usbi_warn(NULL, "ResetEvent failed: %s", windows_error_str(0));
}
#ifdef HAVE_OS_TIMER
int usbi_create_timer(usbi_timer_t *timer)
{
timer->hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
if (timer->hTimer == NULL) {
usbi_warn(NULL, "CreateWaitableTimer failed: %s", windows_error_str(0));
return LIBUSB_ERROR_OTHER;
}
return 0;
}
void usbi_destroy_timer(usbi_timer_t *timer)
{
if (!CloseHandle(timer->hTimer))
usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
}
int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
{
struct timespec systime, remaining;
FILETIME filetime;
LARGE_INTEGER dueTime;
/* Transfer timeouts are based on the monotonic clock and the waitable
* timers on the system clock. This requires a conversion between the
* two, so we calculate the remaining time relative to the monotonic
* clock and calculate an absolute system time for the timer expiration.
* Note that if the timeout has already passed, the remaining time will
* be negative and thus an absolute system time in the past will be set.
* This works just as intended because the timer becomes signalled
* immediately. */
usbi_get_monotonic_time(&systime);
TIMESPEC_SUB(timeout, &systime, &remaining);
GetSystemTimeAsFileTime(&filetime);
dueTime.LowPart = filetime.dwLowDateTime;
dueTime.HighPart = filetime.dwHighDateTime;
dueTime.QuadPart += (remaining.tv_sec * 10000000LL) + (remaining.tv_nsec / 100LL);
if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
return LIBUSB_ERROR_OTHER;
}
return 0;
}
int usbi_disarm_timer(usbi_timer_t *timer)
{
LARGE_INTEGER dueTime;
/* A manual-reset waitable timer will stay in the signalled state until
* another call to SetWaitableTimer() is made. It is possible that the
* timer has already expired by the time we come in to disarm it, so to
* be entirely sure the timer is disarmed and not in the signalled state,
* we will set it with an impossibly large expiration and immediately
* cancel. */
dueTime.QuadPart = LLONG_MAX;
if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
return LIBUSB_ERROR_OTHER;
}
if (!CancelWaitableTimer(timer->hTimer)) {
usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
return LIBUSB_ERROR_OTHER;
}
return 0;
}
#endif
int usbi_alloc_event_data(struct libusb_context *ctx)
{
struct usbi_event_source *ievent_source;
HANDLE *handles;
size_t i = 0;
/* Event sources are only added during usbi_io_init(). We should not
* be running this function again if the event data has already been
* allocated. */
if (ctx->event_data) {
usbi_warn(ctx, "program assertion failed - event data already allocated");
return LIBUSB_ERROR_OTHER;
}
ctx->event_data_cnt = 0;
for_each_event_source(ctx, ievent_source)
ctx->event_data_cnt++;
/* We only expect up to two HANDLEs to wait on, one for the internal
* signalling event and the other for the timer. */
if (ctx->event_data_cnt != 1 && ctx->event_data_cnt != 2) {
usbi_err(ctx, "program assertion failed - expected exactly 1 or 2 HANDLEs");
return LIBUSB_ERROR_OTHER;
}
handles = calloc(ctx->event_data_cnt, sizeof(HANDLE));
if (!handles)
return LIBUSB_ERROR_NO_MEM;
for_each_event_source(ctx, ievent_source) {
handles[i] = ievent_source->data.os_handle;
i++;
}
ctx->event_data = handles;
return 0;
}
int usbi_wait_for_events(struct libusb_context *ctx,
struct usbi_reported_events *reported_events, int timeout_ms)
{
HANDLE *handles = ctx->event_data;
DWORD num_handles = (DWORD)ctx->event_data_cnt;
DWORD result;
usbi_dbg(ctx, "WaitForMultipleObjects() for %lu HANDLEs with timeout in %dms", ULONG_CAST(num_handles), timeout_ms);
result = WaitForMultipleObjects(num_handles, handles, FALSE, (DWORD)timeout_ms);
usbi_dbg(ctx, "WaitForMultipleObjects() returned %lu", ULONG_CAST(result));
if (result == WAIT_TIMEOUT) {
if (usbi_using_timer(ctx))
goto done;
return LIBUSB_ERROR_TIMEOUT;
} else if (result == WAIT_FAILED) {
usbi_err(ctx, "WaitForMultipleObjects() failed: %s", windows_error_str(0));
return LIBUSB_ERROR_IO;
}
result -= WAIT_OBJECT_0;
/* handles[0] is always the internal signalling event */
if (result == 0)
reported_events->event_triggered = 1;
else
reported_events->event_triggered = 0;
#ifdef HAVE_OS_TIMER
/* on timer configurations, handles[1] is the timer */
if (usbi_using_timer(ctx)) {
/* The WaitForMultipleObjects() function reports the index of
* the first object that became signalled. If the internal
* signalling event was reported, we need to also check and
* report whether the timer is in the signalled state. */
if (result == 1 || WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0)
reported_events->timer_triggered = 1;
else
reported_events->timer_triggered = 0;
} else {
reported_events->timer_triggered = 0;
}
#endif
done:
/* no events are ever reported to the backend */
reported_events->num_ready = 0;
return LIBUSB_SUCCESS;
}
includes/libusb-1.0.30/libusb/os/events_windows.h
+46
View File
@@ -0,0 +1,46 @@
/*
* libusb event abstraction on Microsoft Windows
*
* Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_EVENTS_WINDOWS_H
#define LIBUSB_EVENTS_WINDOWS_H
typedef HANDLE usbi_os_handle_t;
#define USBI_OS_HANDLE_FORMAT_STRING "HANDLE %p"
typedef struct usbi_event {
HANDLE hEvent;
} usbi_event_t;
#define USBI_EVENT_OS_HANDLE(e) ((e)->hEvent)
#define USBI_EVENT_POLL_EVENTS 0
#define USBI_INVALID_EVENT { INVALID_HANDLE_VALUE }
#define HAVE_OS_TIMER 1
typedef struct usbi_timer {
HANDLE hTimer;
} usbi_timer_t;
#define USBI_TIMER_OS_HANDLE(t) ((t)->hTimer)
#define USBI_TIMER_POLL_EVENTS 0
static inline int usbi_timer_valid(usbi_timer_t *timer)
{
return timer->hTimer != NULL;
}
#endif
includes/libusb-1.0.30/libusb/os/haiku_pollfs.cpp
+372
View File
@@ -0,0 +1,372 @@
/*
* Copyright 2007-2008, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#include "haiku_usb.h"
#include <cstdio>
#include <Directory.h>
#include <Entry.h>
#include <Looper.h>
#include <Messenger.h>
#include <Node.h>
#include <NodeMonitor.h>
#include <Path.h>
#include <cstring>
class WatchedEntry {
public:
WatchedEntry(BMessenger *, entry_ref *);
~WatchedEntry();
bool EntryCreated(entry_ref *ref);
bool EntryRemoved(ino_t node);
bool InitCheck();
private:
BMessenger* fMessenger;
node_ref fNode;
bool fIsDirectory;
USBDevice* fDevice;
WatchedEntry* fEntries;
WatchedEntry* fLink;
bool fInitCheck;
};
class RosterLooper : public BLooper {
public:
RosterLooper(USBRoster *);
void Stop();
virtual void MessageReceived(BMessage *);
bool InitCheck();
private:
USBRoster* fRoster;
WatchedEntry* fRoot;
BMessenger* fMessenger;
bool fInitCheck;
};
WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
: fMessenger(messenger),
fIsDirectory(false),
fDevice(NULL),
fEntries(NULL),
fLink(NULL),
fInitCheck(false)
{
BEntry entry(ref);
entry.GetNodeRef(&fNode);
BDirectory directory;
if (entry.IsDirectory() && directory.SetTo(ref) >= B_OK) {
fIsDirectory = true;
while (directory.GetNextEntry(&entry) >= B_OK) {
if (entry.GetRef(ref) < B_OK)
continue;
WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
if (child == NULL)
continue;
if (child->InitCheck() == false) {
delete child;
continue;
}
child->fLink = fEntries;
fEntries = child;
}
watch_node(&fNode, B_WATCH_DIRECTORY, *fMessenger);
}
else {
if (strncmp(ref->name, "raw", 3) == 0)
return;
BPath path, parent_path;
entry.GetPath(&path);
fDevice = new(std::nothrow) USBDevice(path.Path());
if (fDevice != NULL && fDevice->InitCheck() == true) {
// Add this new device to each active context's device list
struct libusb_context *ctx;
unsigned long session_id = (unsigned long)&fDevice;
usbi_mutex_lock(&active_contexts_lock);
for_each_context(ctx) {
struct libusb_device *dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev) {
usbi_dbg(NULL, "using previously allocated device with location %lu", session_id);
libusb_unref_device(dev);
continue;
}
usbi_dbg(NULL, "allocating new device with location %lu", session_id);
dev = usbi_alloc_device(ctx, session_id);
if (!dev) {
usbi_dbg(NULL, "device allocation failed");
continue;
}
*((USBDevice **)usbi_get_device_priv(dev)) = fDevice;
// Calculate pseudo-device-address
int addr, tmp;
if (strcmp(path.Leaf(), "hub") == 0)
tmp = 100; //Random Number
else
sscanf(path.Leaf(), "%d", &tmp);
addr = tmp + 1;
path.GetParent(&parent_path);
while (strcmp(parent_path.Leaf(), "usb") != 0) {
sscanf(parent_path.Leaf(), "%d", &tmp);
addr += tmp + 1;
parent_path.GetParent(&parent_path);
}
sscanf(path.Path(), "/dev/bus/usb/%hhu", &dev->bus_number);
dev->device_address = addr - (dev->bus_number + 1);
static_assert(sizeof(dev->device_descriptor) == sizeof(usb_device_descriptor),
"mismatch between libusb and OS device descriptor sizes");
memcpy(&dev->device_descriptor, fDevice->Descriptor(), LIBUSB_DT_DEVICE_SIZE);
usbi_localize_device_descriptor(&dev->device_descriptor);
if (usbi_sanitize_device(dev) < 0) {
usbi_dbg(NULL, "device sanitization failed");
libusb_unref_device(dev);
continue;
}
usbi_connect_device(dev);
}
usbi_mutex_unlock(&active_contexts_lock);
}
else if (fDevice) {
delete fDevice;
fDevice = NULL;
return;
}
}
fInitCheck = true;
}
WatchedEntry::~WatchedEntry()
{
if (fIsDirectory) {
watch_node(&fNode, B_STOP_WATCHING, *fMessenger);
WatchedEntry *child = fEntries;
while (child) {
WatchedEntry *next = child->fLink;
delete child;
child = next;
}
}
if (fDevice) {
// Remove this device from each active context's device list
struct libusb_context *ctx;
struct libusb_device *dev;
unsigned long session_id = (unsigned long)&fDevice;
usbi_mutex_lock(&active_contexts_lock);
for_each_context(ctx) {
dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev != NULL) {
usbi_disconnect_device(dev);
libusb_unref_device(dev);
} else {
usbi_dbg(ctx, "device with location %lu not found", session_id);
}
}
usbi_mutex_static_unlock(&active_contexts_lock);
delete fDevice;
}
}
bool
WatchedEntry::EntryCreated(entry_ref *ref)
{
if (!fIsDirectory)
return false;
if (ref->directory != fNode.node) {
WatchedEntry *child = fEntries;
while (child) {
if (child->EntryCreated(ref))
return true;
child = child->fLink;
}
return false;
}
WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
if (child == NULL)
return false;
child->fLink = fEntries;
fEntries = child;
return true;
}
bool
WatchedEntry::EntryRemoved(ino_t node)
{
if (!fIsDirectory)
return false;
WatchedEntry *child = fEntries;
WatchedEntry *lastChild = NULL;
while (child) {
if (child->fNode.node == node) {
if (lastChild)
lastChild->fLink = child->fLink;
else
fEntries = child->fLink;
delete child;
return true;
}
if (child->EntryRemoved(node))
return true;
lastChild = child;
child = child->fLink;
}
return false;
}
bool
WatchedEntry::InitCheck()
{
return fInitCheck;
}
RosterLooper::RosterLooper(USBRoster *roster)
: BLooper("LibusbRoster Looper"),
fRoster(roster),
fRoot(NULL),
fMessenger(NULL),
fInitCheck(false)
{
BEntry entry("/dev/bus/usb");
if (!entry.Exists()) {
usbi_err(NULL, "usb_raw not published");
return;
}
Run();
fMessenger = new(std::nothrow) BMessenger(this);
if (fMessenger == NULL) {
usbi_err(NULL, "error creating BMessenger object");
return;
}
if (Lock()) {
entry_ref ref;
entry.GetRef(&ref);
fRoot = new(std::nothrow) WatchedEntry(fMessenger, &ref);
Unlock();
if (fRoot == NULL)
return;
if (fRoot->InitCheck() == false) {
delete fRoot;
fRoot = NULL;
return;
}
}
fInitCheck = true;
}
void
RosterLooper::Stop()
{
Lock();
delete fRoot;
delete fMessenger;
Quit();
}
void
RosterLooper::MessageReceived(BMessage *message)
{
int32 opcode;
if (message->FindInt32("opcode", &opcode) < B_OK)
return;
switch (opcode) {
case B_ENTRY_CREATED:
{
dev_t device;
ino_t directory;
const char *name;
if (message->FindInt32("device", &device) < B_OK ||
message->FindInt64("directory", &directory) < B_OK ||
message->FindString("name", &name) < B_OK)
break;
entry_ref ref(device, directory, name);
fRoot->EntryCreated(&ref);
break;
}
case B_ENTRY_REMOVED:
{
ino_t node;
if (message->FindInt64("node", &node) < B_OK)
break;
fRoot->EntryRemoved(node);
break;
}
}
}
bool
RosterLooper::InitCheck()
{
return fInitCheck;
}
USBRoster::USBRoster()
: fLooper(NULL)
{
}
USBRoster::~USBRoster()
{
Stop();
}
int
USBRoster::Start()
{
if (fLooper == NULL) {
fLooper = new(std::nothrow) RosterLooper(this);
if (fLooper == NULL || ((RosterLooper *)fLooper)->InitCheck() == false) {
if (fLooper)
fLooper = NULL;
return LIBUSB_ERROR_OTHER;
}
}
return LIBUSB_SUCCESS;
}
void
USBRoster::Stop()
{
if (fLooper) {
((RosterLooper *)fLooper)->Stop();
fLooper = NULL;
}
}
includes/libusb-1.0.30/libusb/os/haiku_usb.h
+113
View File
@@ -0,0 +1,113 @@
/*
* Haiku Backend for libusb
* Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <List.h>
#include <Locker.h>
#include <Autolock.h>
#include <USBKit.h>
#include <map>
#include "libusbi.h"
#include "haiku_usb_raw.h"
using namespace std;
class USBDevice;
class USBDeviceHandle;
class USBTransfer;
class USBDevice {
public:
USBDevice(const char *);
virtual ~USBDevice();
const char* Location() const;
uint8 CountConfigurations() const;
const usb_device_descriptor* Descriptor() const;
const usb_configuration_descriptor* ConfigurationDescriptor(uint8) const;
const usb_configuration_descriptor* ActiveConfiguration() const;
uint8 EndpointToIndex(uint8) const;
uint8 EndpointToInterface(uint8) const;
int ClaimInterface(uint8);
int ReleaseInterface(uint8);
int CheckInterfacesFree(uint8);
void SetActiveConfiguration(uint8);
uint8 ActiveConfigurationIndex() const;
bool InitCheck();
private:
int Initialise();
unsigned int fClaimedInterfaces; // Max Interfaces can be 32. Using a bitmask
usb_device_descriptor fDeviceDescriptor;
unsigned char** fConfigurationDescriptors;
uint8 fActiveConfiguration;
char* fPath;
map<uint8,uint8> fConfigToIndex;
map<uint8,uint8>* fEndpointToIndex;
map<uint8,uint8>* fEndpointToInterface;
bool fInitCheck;
};
class USBDeviceHandle {
public:
USBDeviceHandle(USBDevice *dev);
virtual ~USBDeviceHandle();
int ClaimInterface(uint8);
int ReleaseInterface(uint8);
int SetConfiguration(uint8);
int SetAltSetting(uint8, uint8);
int ClearHalt(uint8);
status_t SubmitTransfer(struct usbi_transfer *);
status_t CancelTransfer(USBTransfer *);
bool InitCheck();
private:
int fRawFD;
static status_t TransfersThread(void *);
void TransfersWorker();
USBDevice* fUSBDevice;
unsigned int fClaimedInterfaces;
BList fTransfers;
BLocker fTransfersLock;
sem_id fTransfersSem;
thread_id fTransfersThread;
bool fInitCheck;
};
class USBTransfer {
public:
USBTransfer(struct usbi_transfer *, USBDevice *);
virtual ~USBTransfer();
void Do(int);
struct usbi_transfer* UsbiTransfer();
void SetCancelled();
bool IsCancelled();
private:
struct usbi_transfer* fUsbiTransfer;
struct libusb_transfer* fLibusbTransfer;
USBDevice* fUSBDevice;
BLocker fStatusLock;
bool fCancelled;
};
class USBRoster {
public:
USBRoster();
virtual ~USBRoster();
int Start();
void Stop();
private:
void* fLooper;
};
includes/libusb-1.0.30/libusb/os/haiku_usb_backend.cpp
+532
View File
@@ -0,0 +1,532 @@
/*
* Haiku Backend for libusb
* Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <new>
#include <vector>
#include "haiku_usb.h"
static int _errno_to_libusb(int status)
{
return status;
}
USBTransfer::USBTransfer(struct usbi_transfer *itransfer, USBDevice *device)
{
fUsbiTransfer = itransfer;
fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
fUSBDevice = device;
fCancelled = false;
}
USBTransfer::~USBTransfer()
{
}
struct usbi_transfer *
USBTransfer::UsbiTransfer()
{
return fUsbiTransfer;
}
void
USBTransfer::SetCancelled()
{
fCancelled = true;
}
bool
USBTransfer::IsCancelled()
{
return fCancelled;
}
void
USBTransfer::Do(int fRawFD)
{
switch (fLibusbTransfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
{
struct libusb_control_setup *setup = (struct libusb_control_setup *)fLibusbTransfer->buffer;
usb_raw_command command;
command.control.request_type = setup->bmRequestType;
command.control.request = setup->bRequest;
command.control.value = setup->wValue;
command.control.index = setup->wIndex;
command.control.length = setup->wLength;
command.control.data = fLibusbTransfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
if (fCancelled)
break;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
command.control.status != B_USB_RAW_STATUS_SUCCESS) {
fUsbiTransfer->transferred = -1;
usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed control transfer");
break;
}
fUsbiTransfer->transferred = command.control.length;
}
break;
case LIBUSB_TRANSFER_TYPE_BULK:
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
{
usb_raw_command command;
command.transfer.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
command.transfer.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
command.transfer.data = fLibusbTransfer->buffer;
command.transfer.length = fLibusbTransfer->length;
if (fCancelled)
break;
if (fLibusbTransfer->type == LIBUSB_TRANSFER_TYPE_BULK) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_BULK_TRANSFER, &command, sizeof(command)) ||
command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
fUsbiTransfer->transferred = -1;
usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed bulk transfer");
break;
}
}
else {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_INTERRUPT_TRANSFER, &command, sizeof(command)) ||
command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
fUsbiTransfer->transferred = -1;
usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed interrupt transfer");
break;
}
}
fUsbiTransfer->transferred = command.transfer.length;
}
break;
// IsochronousTransfers not tested
case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
{
usb_raw_command command;
command.isochronous.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
command.isochronous.endpoint = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
command.isochronous.data = fLibusbTransfer->buffer;
command.isochronous.length = fLibusbTransfer->length;
command.isochronous.packet_count = fLibusbTransfer->num_iso_packets;
int i;
usb_iso_packet_descriptor *packetDescriptors = new usb_iso_packet_descriptor[fLibusbTransfer->num_iso_packets];
for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
if ((fLibusbTransfer->iso_packet_desc[i]).length > (unsigned int)INT16_MAX) {
fUsbiTransfer->transferred = -1;
usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
break;
}
packetDescriptors[i].request_length = (int16)(fLibusbTransfer->iso_packet_desc[i]).length;
}
if (i < fLibusbTransfer->num_iso_packets)
break; // TODO Handle this error
command.isochronous.packet_descriptors = packetDescriptors;
if (fCancelled)
break;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command, sizeof(command)) ||
command.isochronous.status != B_USB_RAW_STATUS_SUCCESS) {
fUsbiTransfer->transferred = -1;
usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
break;
}
for (i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
(fLibusbTransfer->iso_packet_desc[i]).actual_length = packetDescriptors[i].actual_length;
switch (packetDescriptors[i].status) {
case B_OK:
(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_COMPLETED;
break;
default:
(fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_ERROR;
break;
}
}
delete[] packetDescriptors;
// Do we put the length of transfer here, for isochronous transfers?
fUsbiTransfer->transferred = command.transfer.length;
}
break;
default:
usbi_err(TRANSFER_CTX(fLibusbTransfer), "Unknown type of transfer");
}
}
bool
USBDeviceHandle::InitCheck()
{
return fInitCheck;
}
status_t
USBDeviceHandle::TransfersThread(void *self)
{
USBDeviceHandle *handle = (USBDeviceHandle *)self;
handle->TransfersWorker();
return B_OK;
}
void
USBDeviceHandle::TransfersWorker()
{
while (true) {
status_t status = acquire_sem(fTransfersSem);
if (status == B_BAD_SEM_ID)
break;
if (status == B_INTERRUPTED)
continue;
fTransfersLock.Lock();
USBTransfer *fPendingTransfer = (USBTransfer *) fTransfers.RemoveItem((int32)0);
fTransfersLock.Unlock();
fPendingTransfer->Do(fRawFD);
usbi_signal_transfer_completion(fPendingTransfer->UsbiTransfer());
}
}
status_t
USBDeviceHandle::SubmitTransfer(struct usbi_transfer *itransfer)
{
USBTransfer *transfer = new USBTransfer(itransfer, fUSBDevice);
*((USBTransfer **)usbi_get_transfer_priv(itransfer)) = transfer;
BAutolock locker(fTransfersLock);
fTransfers.AddItem(transfer);
release_sem(fTransfersSem);
return LIBUSB_SUCCESS;
}
status_t
USBDeviceHandle::CancelTransfer(USBTransfer *transfer)
{
transfer->SetCancelled();
fTransfersLock.Lock();
bool removed = fTransfers.RemoveItem(transfer);
fTransfersLock.Unlock();
if (removed)
usbi_signal_transfer_completion(transfer->UsbiTransfer());
return LIBUSB_SUCCESS;
}
USBDeviceHandle::USBDeviceHandle(USBDevice *dev)
:
fUSBDevice(dev),
fClaimedInterfaces(0),
fTransfersThread(-1),
fInitCheck(false)
{
fRawFD = open(dev->Location(), O_RDWR | O_CLOEXEC);
if (fRawFD < 0) {
usbi_err(NULL,"failed to open device");
return;
}
fTransfersSem = create_sem(0, "Transfers Queue Sem");
fTransfersThread = spawn_thread(TransfersThread, "Transfer Worker", B_NORMAL_PRIORITY, this);
resume_thread(fTransfersThread);
fInitCheck = true;
}
USBDeviceHandle::~USBDeviceHandle()
{
if (fRawFD > 0)
close(fRawFD);
for (int i = 0; i < 32; i++) {
if (fClaimedInterfaces & (1U << i))
ReleaseInterface(i);
}
delete_sem(fTransfersSem);
if (fTransfersThread > 0)
wait_for_thread(fTransfersThread, NULL);
}
int
USBDeviceHandle::ClaimInterface(uint8 inumber)
{
int status = fUSBDevice->ClaimInterface(inumber);
if (status == LIBUSB_SUCCESS)
fClaimedInterfaces |= (1U << inumber);
return status;
}
int
USBDeviceHandle::ReleaseInterface(uint8 inumber)
{
fUSBDevice->ReleaseInterface(inumber);
fClaimedInterfaces &= ~(1U << inumber);
return LIBUSB_SUCCESS;
}
int
USBDeviceHandle::SetConfiguration(uint8 config)
{
int config_index = fUSBDevice->CheckInterfacesFree(config);
if (config_index == LIBUSB_ERROR_BUSY || config_index == LIBUSB_ERROR_NOT_FOUND)
return config_index;
usb_raw_command command;
command.config.config_index = config_index;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_CONFIGURATION, &command, sizeof(command)) ||
command.config.status != B_USB_RAW_STATUS_SUCCESS) {
return _errno_to_libusb(command.config.status);
}
fUSBDevice->SetActiveConfiguration((uint8)config_index);
return LIBUSB_SUCCESS;
}
int
USBDeviceHandle::SetAltSetting(uint8 inumber, uint8 alt)
{
usb_raw_command command;
command.alternate.config_index = fUSBDevice->ActiveConfigurationIndex();
command.alternate.interface_index = inumber;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX, &command, sizeof(command)) ||
command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "Error retrieving active alternate interface");
return _errno_to_libusb(command.alternate.status);
}
if (command.alternate.alternate_info == (uint32)alt) {
usbi_dbg(NULL, "Setting alternate interface successful");
return LIBUSB_SUCCESS;
}
command.alternate.alternate_info = alt;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command, sizeof(command)) ||
command.alternate.status != B_USB_RAW_STATUS_SUCCESS) { //IF IOCTL FAILS DEVICE DISCONNECTED PROBABLY
usbi_err(NULL, "Error setting alternate interface");
return _errno_to_libusb(command.alternate.status);
}
usbi_dbg(NULL, "Setting alternate interface successful");
return LIBUSB_SUCCESS;
}
int
USBDeviceHandle::ClearHalt(uint8 endpoint)
{
usb_raw_command command;
command.control.request_type = USB_REQTYPE_ENDPOINT_OUT;
command.control.request = USB_REQUEST_CLEAR_FEATURE;
command.control.value = USB_FEATURE_ENDPOINT_HALT;
command.control.index = endpoint;
command.control.length = 0;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) ||
command.control.status != B_USB_RAW_STATUS_SUCCESS) {
return _errno_to_libusb(command.control.status);
}
return LIBUSB_SUCCESS;
}
USBDevice::USBDevice(const char *path)
:
fClaimedInterfaces(0),
fConfigurationDescriptors(NULL),
fActiveConfiguration(0), //0?
fPath(NULL),
fEndpointToIndex(NULL),
fEndpointToInterface(NULL),
fInitCheck(false)
{
fPath=strdup(path);
Initialise();
}
USBDevice::~USBDevice()
{
free(fPath);
if (fConfigurationDescriptors) {
for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
if (fConfigurationDescriptors[i])
delete fConfigurationDescriptors[i];
}
delete[] fConfigurationDescriptors;
}
if (fEndpointToIndex)
delete[] fEndpointToIndex;
if (fEndpointToInterface)
delete[] fEndpointToInterface;
}
bool
USBDevice::InitCheck()
{
return fInitCheck;
}
const char *
USBDevice::Location() const
{
return fPath;
}
uint8
USBDevice::CountConfigurations() const
{
return fDeviceDescriptor.num_configurations;
}
const usb_device_descriptor *
USBDevice::Descriptor() const
{
return &fDeviceDescriptor;
}
const usb_configuration_descriptor *
USBDevice::ConfigurationDescriptor(uint8 index) const
{
if (index > CountConfigurations())
return NULL;
return (usb_configuration_descriptor *) fConfigurationDescriptors[index];
}
const usb_configuration_descriptor *
USBDevice::ActiveConfiguration() const
{
return (usb_configuration_descriptor *) fConfigurationDescriptors[fActiveConfiguration];
}
uint8
USBDevice::ActiveConfigurationIndex() const
{
return fActiveConfiguration;
}
int USBDevice::ClaimInterface(uint8 interface)
{
if (interface > ActiveConfiguration()->number_interfaces)
return LIBUSB_ERROR_NOT_FOUND;
if (fClaimedInterfaces & (1U << interface))
return LIBUSB_ERROR_BUSY;
fClaimedInterfaces |= (1U << interface);
return LIBUSB_SUCCESS;
}
int USBDevice::ReleaseInterface(uint8 interface)
{
fClaimedInterfaces &= ~(1U << interface);
return LIBUSB_SUCCESS;
}
int
USBDevice::CheckInterfacesFree(uint8 config)
{
if (fConfigToIndex.count(config) == 0)
return LIBUSB_ERROR_NOT_FOUND;
if (fClaimedInterfaces == 0)
return fConfigToIndex[config];
return LIBUSB_ERROR_BUSY;
}
void
USBDevice::SetActiveConfiguration(uint8 config_index)
{
fActiveConfiguration = config_index;
}
uint8
USBDevice::EndpointToIndex(uint8 address) const
{
return fEndpointToIndex[fActiveConfiguration][address];
}
uint8
USBDevice::EndpointToInterface(uint8 address) const
{
return fEndpointToInterface[fActiveConfiguration][address];
}
int
USBDevice::Initialise() //Do we need more error checking, etc? How to report?
{
int fRawFD = open(fPath, O_RDWR | O_CLOEXEC);
if (fRawFD < 0)
return B_ERROR;
usb_raw_command command;
command.device.descriptor = &fDeviceDescriptor;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command, sizeof(command)) ||
command.device.status != B_USB_RAW_STATUS_SUCCESS) {
close(fRawFD);
return B_ERROR;
}
fConfigurationDescriptors = new(std::nothrow) unsigned char *[fDeviceDescriptor.num_configurations];
fEndpointToIndex = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
fEndpointToInterface = new(std::nothrow) map<uint8,uint8> [fDeviceDescriptor.num_configurations];
for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
usb_configuration_descriptor tmp_config;
command.config.descriptor = &tmp_config;
command.config.config_index = i;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command, sizeof(command)) ||
command.config.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "failed retrieving configuration descriptor");
close(fRawFD);
return B_ERROR;
}
fConfigToIndex[tmp_config.configuration_value] = i;
fConfigurationDescriptors[i] = new(std::nothrow) unsigned char[tmp_config.total_length];
command.config_etc.descriptor = (usb_configuration_descriptor*)fConfigurationDescriptors[i];
command.config_etc.length = tmp_config.total_length;
command.config_etc.config_index = i;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC, &command, sizeof(command)) ||
command.config_etc.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "failed retrieving full configuration descriptor");
close(fRawFD);
return B_ERROR;
}
for (uint8 j = 0; j < tmp_config.number_interfaces; j++) {
command.alternate.config_index = i;
command.alternate.interface_index = j;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command, sizeof(command)) ||
command.config.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "failed retrieving number of alternate interfaces");
close(fRawFD);
return B_ERROR;
}
uint8 num_alternate = (uint8)command.alternate.alternate_info;
for (uint8 k = 0; k < num_alternate; k++) {
usb_interface_descriptor tmp_interface;
command.interface_etc.config_index = i;
command.interface_etc.interface_index = j;
command.interface_etc.alternate_index = k;
command.interface_etc.descriptor = &tmp_interface;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC, &command, sizeof(command)) ||
command.config.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "failed retrieving interface descriptor");
close(fRawFD);
return B_ERROR;
}
for (uint8 l = 0; l < tmp_interface.num_endpoints; l++) {
usb_endpoint_descriptor tmp_endpoint;
command.endpoint_etc.config_index = i;
command.endpoint_etc.interface_index = j;
command.endpoint_etc.alternate_index = k;
command.endpoint_etc.endpoint_index = l;
command.endpoint_etc.descriptor = &tmp_endpoint;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC, &command, sizeof(command)) ||
command.config.status != B_USB_RAW_STATUS_SUCCESS) {
usbi_err(NULL, "failed retrieving endpoint descriptor");
close(fRawFD);
return B_ERROR;
}
fEndpointToIndex[i][tmp_endpoint.endpoint_address] = l;
fEndpointToInterface[i][tmp_endpoint.endpoint_address] = j;
}
}
}
}
close(fRawFD);
fInitCheck = true;
return B_OK;
}
includes/libusb-1.0.30/libusb/os/haiku_usb_raw.cpp
+235
View File
@@ -0,0 +1,235 @@
/*
* Haiku Backend for libusb
* Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <new>
#include <vector>
#include "haiku_usb.h"
USBRoster gUsbRoster;
int32 gInitCount = 0;
static int haiku_get_config_descriptor(struct libusb_device *, uint8_t,
void *, size_t);
static int
haiku_init(struct libusb_context *ctx)
{
UNUSED(ctx);
if (atomic_add(&gInitCount, 1) == 0)
return gUsbRoster.Start();
return LIBUSB_SUCCESS;
}
static void
haiku_exit(struct libusb_context *ctx)
{
UNUSED(ctx);
if (atomic_add(&gInitCount, -1) == 1)
gUsbRoster.Stop();
}
static int
haiku_open(struct libusb_device_handle *dev_handle)
{
USBDevice *dev = *((USBDevice **)usbi_get_device_priv(dev_handle->dev));
USBDeviceHandle *handle = new(std::nothrow) USBDeviceHandle(dev);
if (handle == NULL)
return LIBUSB_ERROR_NO_MEM;
if (handle->InitCheck() == false) {
delete handle;
return LIBUSB_ERROR_NO_DEVICE;
}
*((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle)) = handle;
return LIBUSB_SUCCESS;
}
static void
haiku_close(struct libusb_device_handle *dev_handle)
{
USBDeviceHandle **pHandle = (USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle);
USBDeviceHandle *handle = *pHandle;
if (handle == NULL)
return;
delete handle;
*pHandle = NULL;
}
static int
haiku_get_active_config_descriptor(struct libusb_device *device, void *buffer, size_t len)
{
USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
return haiku_get_config_descriptor(device, dev->ActiveConfigurationIndex(), buffer, len);
}
static int
haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len)
{
USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
const usb_configuration_descriptor *config = dev->ConfigurationDescriptor(config_index);
if (config == NULL) {
usbi_err(DEVICE_CTX(device), "failed getting configuration descriptor");
return LIBUSB_ERROR_IO;
}
if (len > config->total_length) {
len = config->total_length;
}
memcpy(buffer, config, len);
return len;
}
static int
haiku_set_configuration(struct libusb_device_handle *dev_handle, int config)
{
USBDeviceHandle *handle= *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
if (config <= 0)
return LIBUSB_ERROR_NOT_SUPPORTED; // cannot unconfigure
return handle->SetConfiguration((uint8)config);
}
static int
haiku_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
{
USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
return handle->ClaimInterface(interface_number);
}
static int
haiku_set_altsetting(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting)
{
USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
return handle->SetAltSetting(interface_number, altsetting);
}
static int
haiku_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
{
USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
return handle->ClearHalt(endpoint);
}
static int
haiku_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
{
USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
haiku_set_altsetting(dev_handle, interface_number, 0);
return handle->ReleaseInterface(interface_number);
}
static int
haiku_submit_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
return fDeviceHandle->SubmitTransfer(itransfer);
}
static int
haiku_cancel_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_get_transfer_priv(itransfer)));
}
static int
haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
{
USBTransfer **pTransfer = (USBTransfer **)usbi_get_transfer_priv(itransfer);
USBTransfer *transfer = *pTransfer;
usbi_mutex_lock(&itransfer->lock);
if (transfer->IsCancelled()) {
delete transfer;
*pTransfer = NULL;
usbi_mutex_unlock(&itransfer->lock);
if (itransfer->transferred < 0)
itransfer->transferred = 0;
return usbi_handle_transfer_cancellation(itransfer);
}
libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
if (itransfer->transferred < 0) {
usbi_err(ITRANSFER_CTX(itransfer), "error in transfer");
status = LIBUSB_TRANSFER_ERROR;
itransfer->transferred = 0;
}
delete transfer;
*pTransfer = NULL;
usbi_mutex_unlock(&itransfer->lock);
return usbi_handle_transfer_completion(itransfer, status);
}
const struct usbi_os_backend usbi_backend = {
/*.name =*/ "Haiku usbfs",
/*.caps =*/ 0,
/*.init =*/ haiku_init,
/*.exit =*/ haiku_exit,
/*.set_option =*/ NULL,
/*.get_device_list =*/ NULL,
/*.get_device_string =*/ NULL,
/*.hotplug_poll =*/ NULL,
/*.wrap_sys_device =*/ NULL,
/*.open =*/ haiku_open,
/*.close =*/ haiku_close,
/*.get_active_config_descriptor =*/ haiku_get_active_config_descriptor,
/*.get_config_descriptor =*/ haiku_get_config_descriptor,
/*.get_config_descriptor_by_value =*/ NULL,
/*.get_configuration =*/ NULL,
/*.set_configuration =*/ haiku_set_configuration,
/*.claim_interface =*/ haiku_claim_interface,
/*.release_interface =*/ haiku_release_interface,
/*.set_interface_altsetting =*/ haiku_set_altsetting,
/*.clear_halt =*/ haiku_clear_halt,
/*.reset_device =*/ NULL,
/*.alloc_streams =*/ NULL,
/*.free_streams =*/ NULL,
/*.dev_mem_alloc =*/ NULL,
/*.dev_mem_free =*/ NULL,
/*.kernel_driver_active =*/ NULL,
/*.detach_kernel_driver =*/ NULL,
/*.attach_kernel_driver =*/ NULL,
/*.endpoint_supports_raw_io =*/ NULL,
/*.endpoint_set_raw_io =*/ NULL,
/*.get_max_raw_io_transfer_size =*/ NULL,
/*.destroy_device =*/ NULL,
/*.submit_transfer =*/ haiku_submit_transfer,
/*.cancel_transfer =*/ haiku_cancel_transfer,
/*.clear_transfer_priv =*/ NULL,
/*.handle_events =*/ NULL,
/*.handle_transfer_completion =*/ haiku_handle_transfer_completion,
/*.context_priv_size =*/ 0,
/*.device_priv_size =*/ sizeof(USBDevice *),
/*.device_handle_priv_size =*/ sizeof(USBDeviceHandle *),
/*.transfer_priv_size =*/ sizeof(USBTransfer *),
};
includes/libusb-1.0.30/libusb/os/haiku_usb_raw.h
+188
View File
@@ -0,0 +1,188 @@
/*
* Copyright 2006-2008, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#ifndef _USB_RAW_H_
#define _USB_RAW_H_
#include <USB3.h>
#define B_USB_RAW_PROTOCOL_VERSION 0x0015
#define B_USB_RAW_ACTIVE_ALTERNATE 0xffffffff
typedef enum {
B_USB_RAW_COMMAND_GET_VERSION = 0x1000,
B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX,
B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC,
B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC,
B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR_ETC,
B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC,
B_USB_RAW_COMMAND_SET_CONFIGURATION = 0x3000,
B_USB_RAW_COMMAND_SET_FEATURE,
B_USB_RAW_COMMAND_CLEAR_FEATURE,
B_USB_RAW_COMMAND_GET_STATUS,
B_USB_RAW_COMMAND_GET_DESCRIPTOR,
B_USB_RAW_COMMAND_SET_ALT_INTERFACE,
B_USB_RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
B_USB_RAW_COMMAND_INTERRUPT_TRANSFER,
B_USB_RAW_COMMAND_BULK_TRANSFER,
B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER
} usb_raw_command_id;
typedef enum {
B_USB_RAW_STATUS_SUCCESS = 0,
B_USB_RAW_STATUS_FAILED,
B_USB_RAW_STATUS_ABORTED,
B_USB_RAW_STATUS_STALLED,
B_USB_RAW_STATUS_CRC_ERROR,
B_USB_RAW_STATUS_TIMEOUT,
B_USB_RAW_STATUS_INVALID_CONFIGURATION,
B_USB_RAW_STATUS_INVALID_INTERFACE,
B_USB_RAW_STATUS_INVALID_ENDPOINT,
B_USB_RAW_STATUS_INVALID_STRING,
B_USB_RAW_STATUS_NO_MEMORY
} usb_raw_command_status;
typedef union {
struct {
status_t status;
} version;
struct {
status_t status;
usb_device_descriptor *descriptor;
} device;
struct {
status_t status;
usb_configuration_descriptor *descriptor;
uint32 config_index;
} config;
struct {
status_t status;
usb_configuration_descriptor *descriptor;
uint32 config_index;
size_t length;
} config_etc;
struct {
status_t status;
uint32 alternate_info;
uint32 config_index;
uint32 interface_index;
} alternate;
struct {
status_t status;
usb_interface_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
} interface;
struct {
status_t status;
usb_interface_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
uint32 alternate_index;
} interface_etc;
struct {
status_t status;
usb_endpoint_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
uint32 endpoint_index;
} endpoint;
struct {
status_t status;
usb_endpoint_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
uint32 alternate_index;
uint32 endpoint_index;
} endpoint_etc;
struct {
status_t status;
usb_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
uint32 generic_index;
size_t length;
} generic;
struct {
status_t status;
usb_descriptor *descriptor;
uint32 config_index;
uint32 interface_index;
uint32 alternate_index;
uint32 generic_index;
size_t length;
} generic_etc;
struct {
status_t status;
usb_string_descriptor *descriptor;
uint32 string_index;
size_t length;
} string;
struct {
status_t status;
uint8 type;
uint8 index;
uint16 language_id;
void *data;
size_t length;
} descriptor;
struct {
status_t status;
uint8 request_type;
uint8 request;
uint16 value;
uint16 index;
uint16 length;
void *data;
} control;
struct {
status_t status;
uint32 interface;
uint32 endpoint;
void *data;
size_t length;
} transfer;
struct {
status_t status;
uint32 interface;
uint32 endpoint;
void *data;
size_t length;
usb_iso_packet_descriptor *packet_descriptors;
uint32 packet_count;
} isochronous;
} usb_raw_command;
#endif // _USB_RAW_H_
includes/libusb-1.0.30/libusb/os/linux_netlink.c
+401
View File
@@ -0,0 +1,401 @@
/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
/*
* Linux usbfs backend for libusb
* Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
* Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
* Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.com>
* Copyright (c) 2016 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
#include "linux_usbfs.h"
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#ifdef HAVE_ASM_TYPES_H
#include <asm/types.h>
#endif
#include <sys/socket.h>
#include <linux/netlink.h>
#define NL_GROUP_KERNEL 1
#ifndef SOCK_CLOEXEC
#define SOCK_CLOEXEC 0
#endif
#ifndef SOCK_NONBLOCK
#define SOCK_NONBLOCK 0
#endif
static int linux_netlink_socket = -1;
static usbi_event_t netlink_control_event = USBI_INVALID_EVENT;
static pthread_t libusb_linux_event_thread;
static void *linux_netlink_event_thread_main(void *arg);
static int set_fd_cloexec_nb(int fd, int socktype)
{
int flags;
#if defined(FD_CLOEXEC)
/* Make sure the netlink socket file descriptor is marked as CLOEXEC */
if (!(socktype & SOCK_CLOEXEC)) {
flags = fcntl(fd, F_GETFD);
if (flags == -1) {
usbi_err(NULL, "failed to get netlink fd flags, errno=%d", errno);
return -1;
}
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
usbi_err(NULL, "failed to set netlink fd flags, errno=%d", errno);
return -1;
}
}
#endif
/* Make sure the netlink socket is non-blocking */
if (!(socktype & SOCK_NONBLOCK)) {
flags = fcntl(fd, F_GETFL);
if (flags == -1) {
usbi_err(NULL, "failed to get netlink fd status flags, errno=%d", errno);
return -1;
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
usbi_err(NULL, "failed to set netlink fd status flags, errno=%d", errno);
return -1;
}
}
return 0;
}
int linux_netlink_start_event_monitor(void)
{
struct sockaddr_nl sa_nl = { .nl_family = AF_NETLINK, .nl_groups = NL_GROUP_KERNEL };
int socktype = SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC;
int opt = 1;
int ret;
linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
if (linux_netlink_socket == -1 && errno == EINVAL) {
usbi_dbg(NULL, "failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
socktype = SOCK_RAW;
linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
}
if (linux_netlink_socket == -1) {
usbi_err(NULL, "failed to create netlink socket, errno=%d", errno);
goto err;
}
ret = set_fd_cloexec_nb(linux_netlink_socket, socktype);
if (ret == -1)
goto err_close_socket;
ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
if (ret == -1) {
usbi_err(NULL, "failed to bind netlink socket, errno=%d", errno);
goto err_close_socket;
}
ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
if (ret == -1) {
usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option, errno=%d", errno);
goto err_close_socket;
}
ret = usbi_create_event(&netlink_control_event);
if (ret) {
usbi_err(NULL, "failed to create netlink control event");
goto err_close_socket;
}
ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
if (ret != 0) {
usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
goto err_destroy_event;
}
return LIBUSB_SUCCESS;
err_destroy_event:
usbi_destroy_event(&netlink_control_event);
netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
err_close_socket:
close(linux_netlink_socket);
linux_netlink_socket = -1;
err:
return LIBUSB_ERROR_OTHER;
}
int linux_netlink_stop_event_monitor(void)
{
int ret;
assert(linux_netlink_socket != -1);
/* Signal the control event and wait for the thread to exit */
usbi_signal_event(&netlink_control_event);
ret = pthread_join(libusb_linux_event_thread, NULL);
if (ret)
usbi_warn(NULL, "failed to join netlink event thread (%d)", ret);
usbi_destroy_event(&netlink_control_event);
netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
close(linux_netlink_socket);
linux_netlink_socket = -1;
return LIBUSB_SUCCESS;
}
static const char *netlink_message_parse(const char *buffer, size_t len, const char *key)
{
const char *end = buffer + len;
size_t keylen = strlen(key);
while (buffer < end && *buffer) {
if (strncmp(buffer, key, keylen) == 0 && buffer[keylen] == '=')
return buffer + keylen + 1;
buffer += strlen(buffer) + 1;
}
return NULL;
}
/* parse parts of netlink message common to both libudev and the kernel */
static int linux_netlink_parse(const char *buffer, size_t len, int *detached,
const char **sys_name, uint8_t *busnum, uint8_t *devaddr)
{
const char *tmp, *slash;
errno = 0;
*sys_name = NULL;
*detached = 0;
*busnum = 0;
*devaddr = 0;
tmp = netlink_message_parse(buffer, len, "ACTION");
if (!tmp) {
return -1;
} else if (strcmp(tmp, "remove") == 0) {
*detached = 1;
} else if (strcmp(tmp, "add") != 0) {
usbi_dbg(NULL, "unknown device action %s", tmp);
return -1;
}
/* check that this is a usb message */
tmp = netlink_message_parse(buffer, len, "SUBSYSTEM");
if (!tmp || strcmp(tmp, "usb") != 0) {
/* not usb. ignore */
return -1;
}
/* check that this is an actual usb device */
tmp = netlink_message_parse(buffer, len, "DEVTYPE");
if (!tmp || strcmp(tmp, "usb_device") != 0) {
/* not usb. ignore */
return -1;
}
tmp = netlink_message_parse(buffer, len, "BUSNUM");
if (tmp) {
*busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
if (errno) {
errno = 0;
return -1;
}
tmp = netlink_message_parse(buffer, len, "DEVNUM");
if (NULL == tmp)
return -1;
*devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
if (errno) {
errno = 0;
return -1;
}
} else {
/* no bus number. try "DEVICE" */
tmp = netlink_message_parse(buffer, len, "DEVICE");
if (!tmp) {
/* not usb. ignore */
return -1;
}
/* Parse a device path such as /dev/bus/usb/003/004 */
slash = strrchr(tmp, '/');
if (!slash)
return -1;
*busnum = (uint8_t)(strtoul(slash - 3, NULL, 10) & 0xff);
if (errno) {
errno = 0;
return -1;
}
*devaddr = (uint8_t)(strtoul(slash + 1, NULL, 10) & 0xff);
if (errno) {
errno = 0;
return -1;
}
return 0;
}
tmp = netlink_message_parse(buffer, len, "DEVPATH");
if (!tmp)
return -1;
slash = strrchr(tmp, '/');
if (slash)
*sys_name = slash + 1;
/* found a usb device */
return 0;
}
static int linux_netlink_read_message(void)
{
char cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
char msg_buffer[2048];
const char *sys_name = NULL;
uint8_t busnum, devaddr;
int detached, r;
ssize_t len;
struct cmsghdr *cmsg;
struct ucred *cred;
struct sockaddr_nl sa_nl;
struct iovec iov = { .iov_base = msg_buffer, .iov_len = sizeof(msg_buffer) };
struct msghdr msg = {
.msg_iov = &iov, .msg_iovlen = 1,
.msg_control = cred_buffer, .msg_controllen = sizeof(cred_buffer),
.msg_name = &sa_nl, .msg_namelen = sizeof(sa_nl)
};
/* read netlink message */
len = recvmsg(linux_netlink_socket, &msg, 0);
if (len == -1) {
if (errno != EAGAIN && errno != EINTR)
usbi_err(NULL, "error receiving message from netlink, errno=%d", errno);
return -1;
}
if (len < 32 || (msg.msg_flags & MSG_TRUNC)) {
usbi_err(NULL, "invalid netlink message length");
return -1;
}
if (sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
usbi_dbg(NULL, "ignoring netlink message from unknown group/PID (%u/%u)",
(unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
return -1;
}
cmsg = CMSG_FIRSTHDR(&msg);
if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
usbi_dbg(NULL, "ignoring netlink message with no sender credentials");
return -1;
}
cred = (struct ucred *)CMSG_DATA(cmsg);
if (cred->uid != 0) {
usbi_dbg(NULL, "ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
return -1;
}
r = linux_netlink_parse(msg_buffer, (size_t)len, &detached, &sys_name, &busnum, &devaddr);
if (r)
return r;
usbi_dbg(NULL, "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s",
busnum, devaddr, sys_name, detached ? "yes" : "no");
/* signal device is available (or not) to all contexts */
if (detached)
linux_device_disconnected(busnum, devaddr);
else
linux_hotplug_enumerate(busnum, devaddr, sys_name);
return 0;
}
static void *linux_netlink_event_thread_main(void *arg)
{
struct pollfd fds[] = {
{ .fd = USBI_EVENT_OS_HANDLE(&netlink_control_event),
.events = USBI_EVENT_POLL_EVENTS },
{ .fd = linux_netlink_socket,
.events = POLLIN },
};
int r;
UNUSED(arg);
#if defined(HAVE_PTHREAD_SETNAME_NP)
r = pthread_setname_np(pthread_self(), "libusb_event");
if (r)
usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
#endif
usbi_dbg(NULL, "netlink event thread entering");
while (1) {
r = poll(fds, 2, -1);
if (r == -1) {
/* check for temporary failure */
if (errno == EINTR)
continue;
usbi_err(NULL, "poll() failed, errno=%d", errno);
break;
}
if (fds[0].revents) {
/* activity on control event, exit */
break;
}
if (fds[1].revents) {
usbi_mutex_static_lock(&linux_hotplug_lock);
linux_netlink_read_message();
usbi_mutex_static_unlock(&linux_hotplug_lock);
}
}
usbi_dbg(NULL, "netlink event thread exiting");
return NULL;
}
void linux_netlink_hotplug_poll(void)
{
int r;
usbi_mutex_static_lock(&linux_hotplug_lock);
do {
r = linux_netlink_read_message();
} while (r == 0);
usbi_mutex_static_unlock(&linux_hotplug_lock);
}
includes/libusb-1.0.30/libusb/os/linux_udev.c
+321
View File
@@ -0,0 +1,321 @@
/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
/*
* Linux usbfs backend for libusb
* Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
* Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
* Copyright (c) 2012-2013 Nathan Hjelm <hjelmn@mac.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
#include "linux_usbfs.h"
#include <errno.h>
#include <fcntl.h>
#include <libudev.h>
#include <poll.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
/* udev context */
static struct udev *udev_ctx = NULL;
static int udev_monitor_fd = -1;
static usbi_event_t udev_control_event = USBI_INVALID_EVENT;
static struct udev_monitor *udev_monitor = NULL;
static pthread_t linux_event_thread;
static void udev_hotplug_event(struct udev_device *udev_dev);
static void *linux_udev_event_thread_main(void *arg);
int linux_udev_start_event_monitor(void)
{
int r;
assert(udev_ctx == NULL);
udev_ctx = udev_new();
if (!udev_ctx) {
usbi_err(NULL, "could not create udev context");
goto err;
}
udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
if (!udev_monitor) {
usbi_err(NULL, "could not initialize udev monitor");
goto err_free_ctx;
}
r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device");
if (r) {
usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
goto err_free_monitor;
}
if (udev_monitor_enable_receiving(udev_monitor)) {
usbi_err(NULL, "failed to enable the udev monitor");
goto err_free_monitor;
}
udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
#if defined(FD_CLOEXEC)
/* Make sure the udev file descriptor is marked as CLOEXEC */
r = fcntl(udev_monitor_fd, F_GETFD);
if (r == -1) {
usbi_err(NULL, "failed to get udev monitor fd flags, errno=%d", errno);
goto err_free_monitor;
}
if (!(r & FD_CLOEXEC)) {
if (fcntl(udev_monitor_fd, F_SETFD, r | FD_CLOEXEC) == -1) {
usbi_err(NULL, "failed to set udev monitor fd flags, errno=%d", errno);
goto err_free_monitor;
}
}
#endif
/* Some older versions of udev are not non-blocking by default,
* so make sure this is set */
r = fcntl(udev_monitor_fd, F_GETFL);
if (r == -1) {
usbi_err(NULL, "failed to get udev monitor fd status flags, errno=%d", errno);
goto err_free_monitor;
}
if (!(r & O_NONBLOCK)) {
if (fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK) == -1) {
usbi_err(NULL, "failed to set udev monitor fd status flags, errno=%d", errno);
goto err_free_monitor;
}
}
r = usbi_create_event(&udev_control_event);
if (r) {
usbi_err(NULL, "failed to create udev control event");
goto err_free_monitor;
}
r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL);
if (r) {
usbi_err(NULL, "failed to create hotplug event thread (%d)", r);
goto err_destroy_event;
}
return LIBUSB_SUCCESS;
err_destroy_event:
usbi_destroy_event(&udev_control_event);
udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
err_free_monitor:
udev_monitor_unref(udev_monitor);
udev_monitor = NULL;
udev_monitor_fd = -1;
err_free_ctx:
udev_unref(udev_ctx);
err:
udev_ctx = NULL;
return LIBUSB_ERROR_OTHER;
}
int linux_udev_stop_event_monitor(void)
{
int r;
assert(udev_ctx != NULL);
assert(udev_monitor != NULL);
assert(udev_monitor_fd != -1);
/* Signal the control event and wait for the thread to exit */
usbi_signal_event(&udev_control_event);
r = pthread_join(linux_event_thread, NULL);
if (r)
usbi_warn(NULL, "failed to join hotplug event thread (%d)", r);
usbi_destroy_event(&udev_control_event);
udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
/* Release the udev monitor */
udev_monitor_unref(udev_monitor);
udev_monitor = NULL;
udev_monitor_fd = -1;
/* Clean up the udev context */
udev_unref(udev_ctx);
udev_ctx = NULL;
return LIBUSB_SUCCESS;
}
static void *linux_udev_event_thread_main(void *arg)
{
struct pollfd fds[] = {
{ .fd = USBI_EVENT_OS_HANDLE(&udev_control_event),
.events = USBI_EVENT_POLL_EVENTS },
{ .fd = udev_monitor_fd,
.events = POLLIN },
};
struct udev_device *udev_dev;
int r;
UNUSED(arg);
#if defined(HAVE_PTHREAD_SETNAME_NP)
r = pthread_setname_np(pthread_self(), "libusb_event");
if (r)
usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
#endif
usbi_dbg(NULL, "udev event thread entering");
while (1) {
r = poll(fds, 2, -1);
if (r == -1) {
/* check for temporary failure */
if (errno == EINTR)
continue;
usbi_err(NULL, "poll() failed, errno=%d", errno);
break;
}
if (fds[0].revents) {
/* activity on control event, exit */
break;
}
if (fds[1].revents) {
usbi_mutex_static_lock(&linux_hotplug_lock);
udev_dev = udev_monitor_receive_device(udev_monitor);
if (udev_dev)
udev_hotplug_event(udev_dev);
usbi_mutex_static_unlock(&linux_hotplug_lock);
}
}
usbi_dbg(NULL, "udev event thread exiting");
return NULL;
}
static int udev_device_info(struct libusb_context *ctx, int detached,
struct udev_device *udev_dev, uint8_t *busnum,
uint8_t *devaddr, const char **sys_name) {
const char *dev_node;
dev_node = udev_device_get_devnode(udev_dev);
if (!dev_node) {
return LIBUSB_ERROR_OTHER;
}
*sys_name = udev_device_get_sysname(udev_dev);
if (!*sys_name) {
return LIBUSB_ERROR_OTHER;
}
return linux_get_device_address(ctx, detached, busnum, devaddr,
dev_node, *sys_name, -1);
}
static void udev_hotplug_event(struct udev_device *udev_dev)
{
const char *udev_action;
const char *sys_name = NULL;
uint8_t busnum = 0, devaddr = 0;
int detached;
int r;
do {
udev_action = udev_device_get_action(udev_dev);
if (!udev_action) {
break;
}
detached = !strncmp(udev_action, "remove", 6);
r = udev_device_info(NULL, detached, udev_dev, &busnum, &devaddr, &sys_name);
if (LIBUSB_SUCCESS != r) {
break;
}
usbi_dbg(NULL, "udev hotplug event. action: %s.", udev_action);
if (strncmp(udev_action, "add", 3) == 0) {
linux_hotplug_enumerate(busnum, devaddr, sys_name);
} else if (detached) {
linux_device_disconnected(busnum, devaddr);
} else if (strncmp(udev_action, "bind", 4) == 0) {
/* silently ignore "known unhandled" action */
} else {
usbi_err(NULL, "ignoring udev action %s", udev_action);
}
} while (0);
udev_device_unref(udev_dev);
}
int linux_udev_scan_devices(struct libusb_context *ctx)
{
struct udev_enumerate *enumerator;
struct udev_list_entry *devices, *entry;
struct udev_device *udev_dev;
const char *sys_name;
int r;
assert(udev_ctx != NULL);
enumerator = udev_enumerate_new(udev_ctx);
if (NULL == enumerator) {
usbi_err(ctx, "error creating udev enumerator");
return LIBUSB_ERROR_OTHER;
}
udev_enumerate_add_match_subsystem(enumerator, "usb");
udev_enumerate_add_match_property(enumerator, "DEVTYPE", "usb_device");
udev_enumerate_scan_devices(enumerator);
devices = udev_enumerate_get_list_entry(enumerator);
entry = NULL;
udev_list_entry_foreach(entry, devices) {
const char *path = udev_list_entry_get_name(entry);
uint8_t busnum = 0, devaddr = 0;
udev_dev = udev_device_new_from_syspath(udev_ctx, path);
r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
if (r) {
udev_device_unref(udev_dev);
continue;
}
linux_enumerate_device(ctx, busnum, devaddr, sys_name);
udev_device_unref(udev_dev);
}
udev_enumerate_unref(enumerator);
return LIBUSB_SUCCESS;
}
void linux_udev_hotplug_poll(void)
{
struct udev_device *udev_dev;
usbi_mutex_static_lock(&linux_hotplug_lock);
do {
udev_dev = udev_monitor_receive_device(udev_monitor);
if (udev_dev) {
usbi_dbg(NULL, "Handling hotplug event from hotplug_poll");
udev_hotplug_event(udev_dev);
}
} while (udev_dev);
usbi_mutex_static_unlock(&linux_hotplug_lock);
}
includes/libusb-1.0.30/libusb/os/linux_usbfs.c
+2877
View File
File diff suppressed because it is too large Load Diff
includes/libusb-1.0.30/libusb/os/linux_usbfs.h
+221
View File
@@ -0,0 +1,221 @@
/*
* usbfs header structures
* Copyright © 2007 Daniel Drake <dsd@gentoo.org>
* Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_USBFS_H
#define LIBUSB_USBFS_H
#include <linux/magic.h>
#include <linux/types.h>
#define SYSFS_MOUNT_PATH "/sys"
#define SYSFS_DEVICE_PATH SYSFS_MOUNT_PATH "/bus/usb/devices"
struct usbfs_ctrltransfer {
/* keep in sync with usbdevice_fs.h:usbdevfs_ctrltransfer */
__u8 bmRequestType;
__u8 bRequest;
__u16 wValue;
__u16 wIndex;
__u16 wLength;
__u32 timeout; /* in milliseconds */
/* pointer to data */
void *data;
};
struct usbfs_setinterface {
/* keep in sync with usbdevice_fs.h:usbdevfs_setinterface */
unsigned int interface;
unsigned int altsetting;
};
#define USBFS_MAXDRIVERNAME 255
struct usbfs_getdriver {
unsigned int interface;
char driver[USBFS_MAXDRIVERNAME + 1];
};
#define USBFS_URB_SHORT_NOT_OK 0x01
#define USBFS_URB_ISO_ASAP 0x02
#define USBFS_URB_BULK_CONTINUATION 0x04
#define USBFS_URB_QUEUE_BULK 0x10
#define USBFS_URB_ZERO_PACKET 0x40
#define USBFS_URB_TYPE_ISO 0
#define USBFS_URB_TYPE_INTERRUPT 1
#define USBFS_URB_TYPE_CONTROL 2
#define USBFS_URB_TYPE_BULK 3
struct usbfs_iso_packet_desc {
unsigned int length;
unsigned int actual_length;
unsigned int status;
};
#define MAX_BULK_BUFFER_LENGTH 16384
#define MAX_CTRL_BUFFER_LENGTH 4096
#define MAX_ISO_PACKETS_PER_URB 128
struct usbfs_urb {
unsigned char type;
unsigned char endpoint;
int status;
unsigned int flags;
void *buffer;
int buffer_length;
int actual_length;
int start_frame;
union {
int number_of_packets; /* Only used for isoc urbs */
unsigned int stream_id; /* Only used with bulk streams */
};
int error_count;
unsigned int signr;
void *usercontext;
struct usbfs_iso_packet_desc iso_frame_desc[0];
};
struct usbfs_connectinfo {
unsigned int devnum;
unsigned char slow;
};
struct usbfs_ioctl {
int ifno; /* interface 0..N ; negative numbers reserved */
int ioctl_code; /* MUST encode size + direction of data so the
* macros in <asm/ioctl.h> give correct values */
void *data; /* param buffer (in, or out) */
};
#define USBFS_CAP_ZERO_PACKET 0x01
#define USBFS_CAP_BULK_CONTINUATION 0x02
#define USBFS_CAP_NO_PACKET_SIZE_LIM 0x04
#define USBFS_CAP_BULK_SCATTER_GATHER 0x08
#define USBFS_CAP_REAP_AFTER_DISCONNECT 0x10
#define USBFS_DISCONNECT_CLAIM_IF_DRIVER 0x01
#define USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER 0x02
struct usbfs_disconnect_claim {
unsigned int interface;
unsigned int flags;
char driver[USBFS_MAXDRIVERNAME + 1];
};
struct usbfs_streams {
unsigned int num_streams; /* Not used by USBDEVFS_FREE_STREAMS */
unsigned int num_eps;
unsigned char eps[0];
};
#define USBFS_SPEED_UNKNOWN 0
#define USBFS_SPEED_LOW 1
#define USBFS_SPEED_FULL 2
#define USBFS_SPEED_HIGH 3
#define USBFS_SPEED_WIRELESS 4
#define USBFS_SPEED_SUPER 5
#define USBFS_SPEED_SUPER_PLUS 6
#define IOCTL_USBFS_CONTROL _IOWR('U', 0, struct usbfs_ctrltransfer)
#define IOCTL_USBFS_SETINTERFACE _IOR('U', 4, struct usbfs_setinterface)
#define IOCTL_USBFS_SETCONFIGURATION _IOR('U', 5, unsigned int)
#define IOCTL_USBFS_GETDRIVER _IOW('U', 8, struct usbfs_getdriver)
#define IOCTL_USBFS_SUBMITURB _IOR('U', 10, struct usbfs_urb)
#define IOCTL_USBFS_DISCARDURB _IO('U', 11)
#define IOCTL_USBFS_REAPURBNDELAY _IOW('U', 13, void *)
#define IOCTL_USBFS_CLAIMINTERFACE _IOR('U', 15, unsigned int)
#define IOCTL_USBFS_RELEASEINTERFACE _IOR('U', 16, unsigned int)
#define IOCTL_USBFS_CONNECTINFO _IOW('U', 17, struct usbfs_connectinfo)
#define IOCTL_USBFS_IOCTL _IOWR('U', 18, struct usbfs_ioctl)
#define IOCTL_USBFS_RESET _IO('U', 20)
#define IOCTL_USBFS_CLEAR_HALT _IOR('U', 21, unsigned int)
#define IOCTL_USBFS_DISCONNECT _IO('U', 22)
#define IOCTL_USBFS_CONNECT _IO('U', 23)
#define IOCTL_USBFS_GET_CAPABILITIES _IOR('U', 26, __u32)
#define IOCTL_USBFS_DISCONNECT_CLAIM _IOR('U', 27, struct usbfs_disconnect_claim)
#define IOCTL_USBFS_ALLOC_STREAMS _IOR('U', 28, struct usbfs_streams)
#define IOCTL_USBFS_FREE_STREAMS _IOR('U', 29, struct usbfs_streams)
#define IOCTL_USBFS_DROP_PRIVILEGES _IOW('U', 30, __u32)
#define IOCTL_USBFS_GET_SPEED _IO('U', 31)
extern usbi_mutex_static_t linux_hotplug_lock;
#ifdef HAVE_LIBUDEV
int linux_udev_start_event_monitor(void);
int linux_udev_stop_event_monitor(void);
int linux_udev_scan_devices(struct libusb_context *ctx);
void linux_udev_hotplug_poll(void);
#else
int linux_netlink_start_event_monitor(void);
int linux_netlink_stop_event_monitor(void);
void linux_netlink_hotplug_poll(void);
#endif
static inline int linux_start_event_monitor(void)
{
#if defined(HAVE_LIBUDEV)
return linux_udev_start_event_monitor();
/*
* __ANDROID__: preprocessor macro defined automatically by GCC for all Android
* targets (i.e. both Android native applications, and Android OS-level
* services)
*
* ANDROID_OS: compilation flag that should be set for using libusb from programs
* running on Android at OS level (e.g. Android platform services).
* The programs using libusb built with the ANDROID_OS flag must have
* permission to access netlink sockets.
*/
#elif !defined(__ANDROID__) || defined(ANDROID_OS)
return linux_netlink_start_event_monitor();
#else
return LIBUSB_SUCCESS;
#endif
}
static inline void linux_stop_event_monitor(void)
{
#if defined(HAVE_LIBUDEV)
linux_udev_stop_event_monitor();
#elif !defined(__ANDROID__) || defined(ANDROID_OS)
linux_netlink_stop_event_monitor();
#endif
}
static inline void linux_hotplug_poll(void)
{
#if defined(HAVE_LIBUDEV)
linux_udev_hotplug_poll();
#elif !defined(__ANDROID__) || defined(ANDROID_OS)
linux_netlink_hotplug_poll();
#endif
}
void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name);
void linux_device_disconnected(uint8_t busnum, uint8_t devaddr);
int linux_get_device_address(struct libusb_context *ctx, int detached,
uint8_t *busnum, uint8_t *devaddr, const char *dev_node,
const char *sys_name, int fd);
int linux_enumerate_device(struct libusb_context *ctx,
uint8_t busnum, uint8_t devaddr, const char *sysfs_dir);
#endif
includes/libusb-1.0.30/libusb/os/netbsd_usb.c
+619
View File
@@ -0,0 +1,619 @@
/*
* Copyright © 2011 Martin Pieuchot <mpi@openbsd.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <config.h>
#include <sys/time.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dev/usb/usb.h>
#include "libusbi.h"
struct device_priv {
char devnode[16];
int fd;
usb_config_descriptor_t *cdesc; /* active config descriptor */
};
struct handle_priv {
int endpoints[USB_MAX_ENDPOINTS];
};
/*
* Backend functions
*/
static int netbsd_get_device_list(struct libusb_context *,
struct discovered_devs **);
static int netbsd_open(struct libusb_device_handle *);
static void netbsd_close(struct libusb_device_handle *);
static int netbsd_get_active_config_descriptor(struct libusb_device *,
void *, size_t);
static int netbsd_get_config_descriptor(struct libusb_device *, uint8_t,
void *, size_t);
static int netbsd_get_configuration(struct libusb_device_handle *, uint8_t *);
static int netbsd_set_configuration(struct libusb_device_handle *, int);
static int netbsd_claim_interface(struct libusb_device_handle *, uint8_t);
static int netbsd_release_interface(struct libusb_device_handle *, uint8_t);
static int netbsd_set_interface_altsetting(struct libusb_device_handle *,
uint8_t, uint8_t);
static int netbsd_clear_halt(struct libusb_device_handle *, unsigned char);
static void netbsd_destroy_device(struct libusb_device *);
static int netbsd_submit_transfer(struct usbi_transfer *);
static int netbsd_cancel_transfer(struct usbi_transfer *);
static int netbsd_handle_transfer_completion(struct usbi_transfer *);
/*
* Private functions
*/
static int _errno_to_libusb(int);
static int _cache_active_config_descriptor(struct libusb_device *, int);
static int _sync_control_transfer(struct usbi_transfer *);
static int _sync_gen_transfer(struct usbi_transfer *);
static int _access_endpoint(struct libusb_transfer *);
const struct usbi_os_backend usbi_backend = {
.name = "Synchronous NetBSD backend",
.caps = 0,
.get_device_list = netbsd_get_device_list,
.open = netbsd_open,
.close = netbsd_close,
.get_active_config_descriptor = netbsd_get_active_config_descriptor,
.get_config_descriptor = netbsd_get_config_descriptor,
.get_configuration = netbsd_get_configuration,
.set_configuration = netbsd_set_configuration,
.claim_interface = netbsd_claim_interface,
.release_interface = netbsd_release_interface,
.set_interface_altsetting = netbsd_set_interface_altsetting,
.clear_halt = netbsd_clear_halt,
.destroy_device = netbsd_destroy_device,
.submit_transfer = netbsd_submit_transfer,
.cancel_transfer = netbsd_cancel_transfer,
.handle_transfer_completion = netbsd_handle_transfer_completion,
.device_priv_size = sizeof(struct device_priv),
.device_handle_priv_size = sizeof(struct handle_priv),
};
int
netbsd_get_device_list(struct libusb_context * ctx,
struct discovered_devs **discdevs)
{
struct libusb_device *dev;
struct device_priv *dpriv;
struct usb_device_info di;
usb_device_descriptor_t ddesc;
unsigned long session_id;
char devnode[16];
int fd, err, i;
usbi_dbg(ctx, " ");
/* Only ugen(4) is supported */
for (i = 0; i < USB_MAX_DEVICES; i++) {
/* Control endpoint is always .00 */
snprintf(devnode, sizeof(devnode), "/dev/ugen%d.00", i);
if ((fd = open(devnode, O_RDONLY)) < 0) {
if (errno != ENOENT && errno != ENXIO)
usbi_err(ctx, "could not open %s", devnode);
continue;
}
if (ioctl(fd, USB_GET_DEVICEINFO, &di) < 0)
continue;
session_id = (di.udi_bus << 8 | di.udi_addr);
dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev == NULL) {
dev = usbi_alloc_device(ctx, session_id);
if (dev == NULL)
return LIBUSB_ERROR_NO_MEM;
dev->bus_number = 1 + di.udi_bus;
dev->device_address = 1 + di.udi_addr;
dev->speed = di.udi_speed; /* NetBSD #define's happen to match libusb enum */
dpriv = usbi_get_device_priv(dev);
strlcpy(dpriv->devnode, devnode, sizeof(devnode));
dpriv->fd = -1;
if (ioctl(fd, USB_GET_DEVICE_DESC, &ddesc) < 0) {
err = errno;
goto error;
}
static_assert(sizeof(dev->device_descriptor) == sizeof(ddesc),
"mismatch between libusb and OS device descriptor sizes");
memcpy(&dev->device_descriptor, &ddesc, LIBUSB_DT_DEVICE_SIZE);
usbi_localize_device_descriptor(&dev->device_descriptor);
if (_cache_active_config_descriptor(dev, fd)) {
err = errno;
goto error;
}
if ((err = usbi_sanitize_device(dev)))
goto error;
usbi_connect_device(dev);
}
close(fd);
if (discovered_devs_append(*discdevs, dev) == NULL)
return LIBUSB_ERROR_NO_MEM;
libusb_unref_device(dev);
}
return LIBUSB_SUCCESS;
error:
close(fd);
libusb_unref_device(dev);
return _errno_to_libusb(err);
}
int
netbsd_open(struct libusb_device_handle *handle)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
int i;
dpriv->fd = open(dpriv->devnode, O_RDWR);
if (dpriv->fd < 0) {
dpriv->fd = open(dpriv->devnode, O_RDONLY);
if (dpriv->fd < 0)
return _errno_to_libusb(errno);
}
for (i = 0; i < USB_MAX_ENDPOINTS; i++)
hpriv->endpoints[i] = -1;
usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", dpriv->devnode, dpriv->fd);
return LIBUSB_SUCCESS;
}
void
netbsd_close(struct libusb_device_handle *handle)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
close(dpriv->fd);
dpriv->fd = -1;
}
int
netbsd_get_active_config_descriptor(struct libusb_device *dev,
void *buf, size_t len)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
memcpy(buf, dpriv->cdesc, len);
return (int)len;
}
int
netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
void *buf, size_t len)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
struct usb_full_desc ufd;
int fd, err;
usbi_dbg(DEVICE_CTX(dev), "index %u, len %zu", idx, len);
/* A config descriptor may be requested before opening the device */
if (dpriv->fd >= 0) {
fd = dpriv->fd;
} else {
fd = open(dpriv->devnode, O_RDONLY);
if (fd < 0)
return _errno_to_libusb(errno);
}
ufd.ufd_config_index = idx;
ufd.ufd_size = len;
ufd.ufd_data = buf;
if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
err = errno;
if (dpriv->fd < 0)
close(fd);
return _errno_to_libusb(err);
}
if (dpriv->fd < 0)
close(fd);
return (int)len;
}
int
netbsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
int tmp;
usbi_dbg(HANDLE_CTX(handle), " ");
if (ioctl(dpriv->fd, USB_GET_CONFIG, &tmp) < 0)
return _errno_to_libusb(errno);
usbi_dbg(HANDLE_CTX(handle), "configuration %d", tmp);
*config = (uint8_t)tmp;
return LIBUSB_SUCCESS;
}
int
netbsd_set_configuration(struct libusb_device_handle *handle, int config)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
usbi_dbg(HANDLE_CTX(handle), "configuration %d", config);
if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
return _errno_to_libusb(errno);
return _cache_active_config_descriptor(handle->dev, dpriv->fd);
}
int
netbsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
{
struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
int i;
UNUSED(iface);
for (i = 0; i < USB_MAX_ENDPOINTS; i++)
hpriv->endpoints[i] = -1;
return LIBUSB_SUCCESS;
}
int
netbsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
{
struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
int i;
UNUSED(iface);
for (i = 0; i < USB_MAX_ENDPOINTS; i++)
if (hpriv->endpoints[i] >= 0)
close(hpriv->endpoints[i]);
return LIBUSB_SUCCESS;
}
int
netbsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
uint8_t altsetting)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
struct usb_alt_interface intf;
usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
memset(&intf, 0, sizeof(intf));
intf.uai_interface_index = iface;
intf.uai_alt_no = altsetting;
if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
return _errno_to_libusb(errno);
return LIBUSB_SUCCESS;
}
int
netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
struct usb_ctl_request req;
usbi_dbg(HANDLE_CTX(handle), " ");
req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
req.ucr_request.bRequest = UR_CLEAR_FEATURE;
USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
USETW(req.ucr_request.wIndex, endpoint);
USETW(req.ucr_request.wLength, 0);
if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
return _errno_to_libusb(errno);
return LIBUSB_SUCCESS;
}
void
netbsd_destroy_device(struct libusb_device *dev)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
usbi_dbg(DEVICE_CTX(dev), " ");
free(dpriv->cdesc);
}
int
netbsd_submit_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
int err = 0;
usbi_dbg(ITRANSFER_CTX(itransfer), " ");
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
err = _sync_control_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
if (IS_XFEROUT(transfer)) {
/* Isochronous write is not supported */
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
err = _sync_gen_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_BULK:
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
if (IS_XFEROUT(transfer) &&
transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
err = _sync_gen_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
if (err)
return err;
usbi_signal_transfer_completion(itransfer);
return LIBUSB_SUCCESS;
}
int
netbsd_cancel_transfer(struct usbi_transfer *itransfer)
{
UNUSED(itransfer);
usbi_dbg(ITRANSFER_CTX(itransfer), " ");
return LIBUSB_ERROR_NOT_SUPPORTED;
}
int
netbsd_handle_transfer_completion(struct usbi_transfer *itransfer)
{
return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
}
int
_errno_to_libusb(int err)
{
usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
switch (err) {
case EIO:
return LIBUSB_ERROR_IO;
case EACCES:
return LIBUSB_ERROR_ACCESS;
case ENOENT:
return LIBUSB_ERROR_NO_DEVICE;
case ENOMEM:
return LIBUSB_ERROR_NO_MEM;
case EWOULDBLOCK:
case ETIMEDOUT:
return LIBUSB_ERROR_TIMEOUT;
default:
return LIBUSB_ERROR_OTHER;
}
}
int
_cache_active_config_descriptor(struct libusb_device *dev, int fd)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
struct usb_config_desc ucd;
struct usb_full_desc ufd;
void *buf;
int len;
usbi_dbg(DEVICE_CTX(dev), "fd %d", fd);
ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
if (ioctl(fd, USB_GET_CONFIG_DESC, &ucd) < 0)
return _errno_to_libusb(errno);
usbi_dbg(DEVICE_CTX(dev), "active bLength %d", ucd.ucd_desc.bLength);
len = UGETW(ucd.ucd_desc.wTotalLength);
buf = malloc((size_t)len);
if (buf == NULL)
return LIBUSB_ERROR_NO_MEM;
ufd.ufd_config_index = ucd.ucd_config_index;
ufd.ufd_size = len;
ufd.ufd_data = buf;
usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", ufd.ufd_config_index, len);
if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
free(buf);
return _errno_to_libusb(errno);
}
if (dpriv->cdesc)
free(dpriv->cdesc);
dpriv->cdesc = buf;
return 0;
}
int
_sync_control_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
struct libusb_control_setup *setup;
struct device_priv *dpriv;
struct usb_ctl_request req;
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
setup = (struct libusb_control_setup *)transfer->buffer;
usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
setup->bmRequestType, setup->bRequest,
libusb_le16_to_cpu(setup->wValue),
libusb_le16_to_cpu(setup->wIndex),
libusb_le16_to_cpu(setup->wLength), transfer->timeout);
req.ucr_request.bmRequestType = setup->bmRequestType;
req.ucr_request.bRequest = setup->bRequest;
/* Don't use USETW, libusb already deals with the endianness */
(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
req.ucr_flags = USBD_SHORT_XFER_OK;
if (ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
return _errno_to_libusb(errno);
if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
return _errno_to_libusb(errno);
itransfer->transferred = req.ucr_actlen;
usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
return 0;
}
int
_access_endpoint(struct libusb_transfer *transfer)
{
struct handle_priv *hpriv;
struct device_priv *dpriv;
char *s, devnode[16];
int fd, endpt;
mode_t mode;
hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
endpt = UE_GET_ADDR(transfer->endpoint);
mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
if (hpriv->endpoints[endpt] < 0) {
/* Pick the right node given the control one */
strlcpy(devnode, dpriv->devnode, sizeof(devnode));
s = strchr(devnode, '.');
snprintf(s, 4, ".%02d", endpt);
/* We may need to read/write to the same endpoint later. */
if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
if ((fd = open(devnode, mode)) < 0)
return -1;
hpriv->endpoints[endpt] = fd;
}
return hpriv->endpoints[endpt];
}
int
_sync_gen_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
int fd, nr = 1;
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
/*
* Bulk, Interrupt or Isochronous transfer depends on the
* endpoint and thus the node to open.
*/
if ((fd = _access_endpoint(transfer)) < 0)
return _errno_to_libusb(errno);
if (ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
return _errno_to_libusb(errno);
if (IS_XFERIN(transfer)) {
if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
if (ioctl(fd, USB_SET_SHORT_XFER, &nr) < 0)
return _errno_to_libusb(errno);
nr = read(fd, transfer->buffer, transfer->length);
} else {
nr = write(fd, transfer->buffer, transfer->length);
}
if (nr < 0)
return _errno_to_libusb(errno);
itransfer->transferred = nr;
return 0;
}
includes/libusb-1.0.30/libusb/os/null_usb.c
+111
View File
@@ -0,0 +1,111 @@
/*
* Copyright © 2019 Pino Toscano <toscano.pino@tiscali.it>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
static int
null_get_device_list(struct libusb_context * ctx,
struct discovered_devs **discdevs)
{
return LIBUSB_SUCCESS;
}
static int
null_open(struct libusb_device_handle *handle)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static void
null_close(struct libusb_device_handle *handle)
{
}
static int
null_get_active_config_descriptor(struct libusb_device *dev,
void *buf, size_t len)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
void *buf, size_t len)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_set_configuration(struct libusb_device_handle *handle, int config)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_release_interface(struct libusb_device_handle *handle, uint8_t iface)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
uint8_t altsetting)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_submit_transfer(struct usbi_transfer *itransfer)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int
null_cancel_transfer(struct usbi_transfer *itransfer)
{
return LIBUSB_ERROR_NOT_SUPPORTED;
}
const struct usbi_os_backend usbi_backend = {
.name = "Null backend",
.caps = 0,
.get_device_list = null_get_device_list,
.open = null_open,
.close = null_close,
.get_active_config_descriptor = null_get_active_config_descriptor,
.get_config_descriptor = null_get_config_descriptor,
.set_configuration = null_set_configuration,
.claim_interface = null_claim_interface,
.release_interface = null_release_interface,
.set_interface_altsetting = null_set_interface_altsetting,
.clear_halt = null_clear_halt,
.submit_transfer = null_submit_transfer,
.cancel_transfer = null_cancel_transfer,
};
includes/libusb-1.0.30/libusb/os/openbsd_usb.c
+702
View File
@@ -0,0 +1,702 @@
/*
* Copyright © 2011-2013 Martin Pieuchot <mpi@openbsd.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <config.h>
#include <sys/time.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dev/usb/usb.h>
#include "libusbi.h"
struct device_priv {
char *devname; /* name of the ugen(4) node */
int fd; /* device file descriptor */
usb_config_descriptor_t *cdesc; /* active config descriptor */
};
struct handle_priv {
int endpoints[USB_MAX_ENDPOINTS];
};
/*
* Backend functions
*/
static int obsd_get_device_list(struct libusb_context *,
struct discovered_devs **);
static int obsd_open(struct libusb_device_handle *);
static void obsd_close(struct libusb_device_handle *);
static int obsd_get_active_config_descriptor(struct libusb_device *,
void *, size_t);
static int obsd_get_config_descriptor(struct libusb_device *, uint8_t,
void *, size_t);
static int obsd_get_configuration(struct libusb_device_handle *, uint8_t *);
static int obsd_set_configuration(struct libusb_device_handle *, int);
static int obsd_claim_interface(struct libusb_device_handle *, uint8_t);
static int obsd_release_interface(struct libusb_device_handle *, uint8_t);
static int obsd_set_interface_altsetting(struct libusb_device_handle *, uint8_t,
uint8_t);
static int obsd_clear_halt(struct libusb_device_handle *, unsigned char);
static void obsd_destroy_device(struct libusb_device *);
static int obsd_submit_transfer(struct usbi_transfer *);
static int obsd_cancel_transfer(struct usbi_transfer *);
static int obsd_handle_transfer_completion(struct usbi_transfer *);
/*
* Private functions
*/
static int _errno_to_libusb(int);
static int _cache_active_config_descriptor(struct libusb_device *);
static int _sync_control_transfer(struct usbi_transfer *);
static int _sync_gen_transfer(struct usbi_transfer *);
static int _access_endpoint(struct libusb_transfer *);
static int _bus_open(int);
const struct usbi_os_backend usbi_backend = {
.name = "Synchronous OpenBSD backend",
.get_device_list = obsd_get_device_list,
.open = obsd_open,
.close = obsd_close,
.get_active_config_descriptor = obsd_get_active_config_descriptor,
.get_config_descriptor = obsd_get_config_descriptor,
.get_configuration = obsd_get_configuration,
.set_configuration = obsd_set_configuration,
.claim_interface = obsd_claim_interface,
.release_interface = obsd_release_interface,
.set_interface_altsetting = obsd_set_interface_altsetting,
.clear_halt = obsd_clear_halt,
.destroy_device = obsd_destroy_device,
.submit_transfer = obsd_submit_transfer,
.cancel_transfer = obsd_cancel_transfer,
.handle_transfer_completion = obsd_handle_transfer_completion,
.device_priv_size = sizeof(struct device_priv),
.device_handle_priv_size = sizeof(struct handle_priv),
};
#define DEVPATH "/dev/"
#define USBDEV DEVPATH "usb"
int
obsd_get_device_list(struct libusb_context * ctx,
struct discovered_devs **discdevs)
{
struct discovered_devs *ddd;
struct libusb_device *dev;
struct device_priv *dpriv;
struct usb_device_info di;
struct usb_device_ddesc dd;
unsigned long session_id;
char devices[USB_MAX_DEVICES];
char busnode[16];
char *udevname;
int fd, addr, i, j;
usbi_dbg(ctx, " ");
for (i = 0; i < 8; i++) {
snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
if ((fd = open(busnode, O_RDWR)) < 0) {
if (errno != ENOENT && errno != ENXIO)
usbi_err(ctx, "could not open %s", busnode);
continue;
}
bzero(devices, sizeof(devices));
for (addr = 1; addr < USB_MAX_DEVICES; addr++) {
if (devices[addr])
continue;
di.udi_addr = addr;
if (ioctl(fd, USB_DEVICEINFO, &di) < 0)
continue;
/*
* XXX If ugen(4) is attached to the USB device
* it will be used.
*/
udevname = NULL;
for (j = 0; j < USB_MAX_DEVNAMES; j++)
if (!strncmp("ugen", di.udi_devnames[j], 4)) {
udevname = strdup(di.udi_devnames[j]);
break;
}
session_id = (di.udi_bus << 8 | di.udi_addr);
dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev == NULL) {
dev = usbi_alloc_device(ctx, session_id);
if (dev == NULL) {
close(fd);
return LIBUSB_ERROR_NO_MEM;
}
dev->bus_number = di.udi_bus;
dev->device_address = di.udi_addr;
dev->speed = di.udi_speed;
dev->port_number = di.udi_port;
dpriv = usbi_get_device_priv(dev);
dpriv->fd = -1;
dpriv->devname = udevname;
dd.udd_bus = di.udi_bus;
dd.udd_addr = di.udi_addr;
if (ioctl(fd, USB_DEVICE_GET_DDESC, &dd) < 0) {
libusb_unref_device(dev);
continue;
}
static_assert(sizeof(dev->device_descriptor) == sizeof(dd.udd_desc),
"mismatch between libusb and OS device descriptor sizes");
memcpy(&dev->device_descriptor, &dd.udd_desc, LIBUSB_DT_DEVICE_SIZE);
usbi_localize_device_descriptor(&dev->device_descriptor);
if (_cache_active_config_descriptor(dev)) {
libusb_unref_device(dev);
continue;
}
if (usbi_sanitize_device(dev)) {
libusb_unref_device(dev);
continue;
}
usbi_connect_device(dev);
}
ddd = discovered_devs_append(*discdevs, dev);
if (ddd == NULL) {
close(fd);
return LIBUSB_ERROR_NO_MEM;
}
libusb_unref_device(dev);
*discdevs = ddd;
devices[addr] = 1;
}
close(fd);
}
return LIBUSB_SUCCESS;
}
int
obsd_open(struct libusb_device_handle *handle)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
char devnode[16];
if (dpriv->devname) {
int fd;
/*
* Only open ugen(4) attached devices read-write, all
* read-only operations are done through the bus node.
*/
snprintf(devnode, sizeof(devnode), DEVPATH "%s.00",
dpriv->devname);
fd = open(devnode, O_RDWR);
if (fd < 0)
return _errno_to_libusb(errno);
dpriv->fd = fd;
usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", devnode, dpriv->fd);
}
return LIBUSB_SUCCESS;
}
void
obsd_close(struct libusb_device_handle *handle)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
if (dpriv->devname) {
usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
close(dpriv->fd);
dpriv->fd = -1;
}
}
int
obsd_get_active_config_descriptor(struct libusb_device *dev,
void *buf, size_t len)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
memcpy(buf, dpriv->cdesc, len);
return (int)len;
}
int
obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
void *buf, size_t len)
{
struct usb_device_fdesc udf;
int fd, err;
if ((fd = _bus_open(dev->bus_number)) < 0)
return _errno_to_libusb(errno);
udf.udf_bus = dev->bus_number;
udf.udf_addr = dev->device_address;
udf.udf_config_index = idx;
udf.udf_size = len;
udf.udf_data = buf;
usbi_dbg(DEVICE_CTX(dev), "index %d, len %zu", udf.udf_config_index, len);
if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
err = errno;
close(fd);
return _errno_to_libusb(err);
}
close(fd);
return (int)len;
}
int
obsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
*config = dpriv->cdesc->bConfigurationValue;
usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %u", *config);
return LIBUSB_SUCCESS;
}
int
obsd_set_configuration(struct libusb_device_handle *handle, int config)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
if (dpriv->devname == NULL)
return LIBUSB_ERROR_NOT_SUPPORTED;
usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %d", config);
if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
return _errno_to_libusb(errno);
return _cache_active_config_descriptor(handle->dev);
}
int
obsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
{
struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
int i;
UNUSED(iface);
for (i = 0; i < USB_MAX_ENDPOINTS; i++)
hpriv->endpoints[i] = -1;
return LIBUSB_SUCCESS;
}
int
obsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
{
struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
int i;
UNUSED(iface);
for (i = 0; i < USB_MAX_ENDPOINTS; i++)
if (hpriv->endpoints[i] >= 0)
close(hpriv->endpoints[i]);
return LIBUSB_SUCCESS;
}
int
obsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
uint8_t altsetting)
{
struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
struct usb_alt_interface intf;
if (dpriv->devname == NULL)
return LIBUSB_ERROR_NOT_SUPPORTED;
usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
memset(&intf, 0, sizeof(intf));
intf.uai_interface_index = iface;
intf.uai_alt_no = altsetting;
if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
return _errno_to_libusb(errno);
return LIBUSB_SUCCESS;
}
int
obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
{
struct usb_ctl_request req;
int fd, err;
if ((fd = _bus_open(handle->dev->bus_number)) < 0)
return _errno_to_libusb(errno);
usbi_dbg(HANDLE_CTX(handle), " ");
req.ucr_addr = handle->dev->device_address;
req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
req.ucr_request.bRequest = UR_CLEAR_FEATURE;
USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
USETW(req.ucr_request.wIndex, endpoint);
USETW(req.ucr_request.wLength, 0);
if (ioctl(fd, USB_REQUEST, &req) < 0) {
err = errno;
close(fd);
return _errno_to_libusb(err);
}
close(fd);
return LIBUSB_SUCCESS;
}
void
obsd_destroy_device(struct libusb_device *dev)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
usbi_dbg(DEVICE_CTX(dev), " ");
free(dpriv->cdesc);
free(dpriv->devname);
}
int
obsd_submit_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
int err = 0;
usbi_dbg(ITRANSFER_CTX(itransfer), " ");
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
err = _sync_control_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
if (IS_XFEROUT(transfer)) {
/* Isochronous write is not supported */
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
err = _sync_gen_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_BULK:
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
if (IS_XFEROUT(transfer) &&
transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
err = _sync_gen_transfer(itransfer);
break;
case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
err = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
if (err)
return err;
usbi_signal_transfer_completion(itransfer);
return LIBUSB_SUCCESS;
}
int
obsd_cancel_transfer(struct usbi_transfer *itransfer)
{
UNUSED(itransfer);
usbi_dbg(ITRANSFER_CTX(itransfer), " ");
return LIBUSB_ERROR_NOT_SUPPORTED;
}
int
obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
{
return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
}
int
_errno_to_libusb(int err)
{
usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
switch (err) {
case EIO:
return LIBUSB_ERROR_IO;
case EACCES:
return LIBUSB_ERROR_ACCESS;
case ENOENT:
return LIBUSB_ERROR_NO_DEVICE;
case ENOMEM:
return LIBUSB_ERROR_NO_MEM;
case ETIMEDOUT:
return LIBUSB_ERROR_TIMEOUT;
default:
return LIBUSB_ERROR_OTHER;
}
}
int
_cache_active_config_descriptor(struct libusb_device *dev)
{
struct device_priv *dpriv = usbi_get_device_priv(dev);
struct usb_device_cdesc udc;
struct usb_device_fdesc udf;
void *buf;
int fd, len, err;
if ((fd = _bus_open(dev->bus_number)) < 0)
return _errno_to_libusb(errno);
usbi_dbg(DEVICE_CTX(dev), "fd %d, addr %d", fd, dev->device_address);
udc.udc_bus = dev->bus_number;
udc.udc_addr = dev->device_address;
udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
if (ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
err = errno;
close(fd);
return _errno_to_libusb(errno);
}
usbi_dbg(DEVICE_CTX(dev), "active bLength %d", udc.udc_desc.bLength);
len = UGETW(udc.udc_desc.wTotalLength);
buf = malloc((size_t)len);
if (buf == NULL)
return LIBUSB_ERROR_NO_MEM;
udf.udf_bus = dev->bus_number;
udf.udf_addr = dev->device_address;
udf.udf_config_index = udc.udc_config_index;
udf.udf_size = len;
udf.udf_data = buf;
usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", udf.udf_config_index, len);
if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
err = errno;
close(fd);
free(buf);
return _errno_to_libusb(err);
}
close(fd);
if (dpriv->cdesc)
free(dpriv->cdesc);
dpriv->cdesc = buf;
return LIBUSB_SUCCESS;
}
int
_sync_control_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
struct libusb_control_setup *setup;
struct device_priv *dpriv;
struct usb_ctl_request req;
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
setup = (struct libusb_control_setup *)transfer->buffer;
usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
setup->bmRequestType, setup->bRequest,
libusb_le16_to_cpu(setup->wValue),
libusb_le16_to_cpu(setup->wIndex),
libusb_le16_to_cpu(setup->wLength), transfer->timeout);
req.ucr_addr = transfer->dev_handle->dev->device_address;
req.ucr_request.bmRequestType = setup->bmRequestType;
req.ucr_request.bRequest = setup->bRequest;
/* Don't use USETW, libusb already deals with the endianness */
(*(uint16_t *)req.ucr_request.wValue) = setup->wValue;
(*(uint16_t *)req.ucr_request.wIndex) = setup->wIndex;
(*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
req.ucr_data = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
req.ucr_flags = USBD_SHORT_XFER_OK;
if (dpriv->devname == NULL) {
/*
* XXX If the device is not attached to ugen(4) it is
* XXX still possible to submit a control transfer but
* XXX with the default timeout only.
*/
int fd, err;
if ((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
return _errno_to_libusb(errno);
if (ioctl(fd, USB_REQUEST, &req) < 0) {
err = errno;
close(fd);
return _errno_to_libusb(err);
}
close(fd);
} else {
if (ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
return _errno_to_libusb(errno);
if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
return _errno_to_libusb(errno);
}
itransfer->transferred = req.ucr_actlen;
usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
return 0;
}
int
_access_endpoint(struct libusb_transfer *transfer)
{
struct handle_priv *hpriv;
struct device_priv *dpriv;
char devnode[16];
int fd, endpt;
mode_t mode;
hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
endpt = UE_GET_ADDR(transfer->endpoint);
mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
if (hpriv->endpoints[endpt] < 0) {
/* Pick the right endpoint node */
snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d",
dpriv->devname, endpt);
/* We may need to read/write to the same endpoint later. */
if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
if ((fd = open(devnode, mode)) < 0)
return -1;
hpriv->endpoints[endpt] = fd;
}
return hpriv->endpoints[endpt];
}
int
_sync_gen_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer;
struct device_priv *dpriv;
int fd, nr = 1;
transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
if (dpriv->devname == NULL)
return LIBUSB_ERROR_NOT_SUPPORTED;
/*
* Bulk, Interrupt or Isochronous transfer depends on the
* endpoint and thus the node to open.
*/
if ((fd = _access_endpoint(transfer)) < 0)
return _errno_to_libusb(errno);
if (ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
return _errno_to_libusb(errno);
if (IS_XFERIN(transfer)) {
if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
if (ioctl(fd, USB_SET_SHORT_XFER, &nr) < 0)
return _errno_to_libusb(errno);
nr = read(fd, transfer->buffer, transfer->length);
} else {
nr = write(fd, transfer->buffer, transfer->length);
}
if (nr < 0)
return _errno_to_libusb(errno);
itransfer->transferred = nr;
return 0;
}
int
_bus_open(int number)
{
char busnode[16];
snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
return open(busnode, O_RDWR);
}
includes/libusb-1.0.30/libusb/os/sunos_usb.c
+1621
View File
File diff suppressed because it is too large Load Diff
includes/libusb-1.0.30/libusb/os/sunos_usb.h
+79
View File
@@ -0,0 +1,79 @@
/*
*
* Copyright (c) 2016, Oracle and/or its affiliates.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_SUNOS_H
#define LIBUSB_SUNOS_H
#include <libdevinfo.h>
#include <pthread.h>
#include "libusbi.h"
#define READ 0
#define WRITE 1
typedef struct sunos_device_priv {
uint8_t cfgvalue; /* active config value */
uint8_t *raw_cfgdescr; /* active config descriptor */
char *ugenpath; /* name of the ugen(4) node */
char *phypath; /* physical path */
} sunos_dev_priv_t;
typedef struct endpoint {
int datafd; /* data file */
int statfd; /* state file */
} sunos_ep_priv_t;
typedef struct sunos_device_handle_priv {
uint8_t altsetting[USB_MAXINTERFACES]; /* a interface's alt */
uint8_t config_index;
sunos_ep_priv_t eps[USB_MAXENDPOINTS];
sunos_dev_priv_t *dpriv; /* device private */
} sunos_dev_handle_priv_t;
typedef struct sunos_transfer_priv {
struct aiocb aiocb;
struct libusb_transfer *transfer;
} sunos_xfer_priv_t;
struct node_args {
struct libusb_context *ctx;
struct discovered_devs **discdevs;
const char *last_ugenpath;
di_devlink_handle_t dlink_hdl;
};
struct devlink_cbarg {
struct node_args *nargs; /* di node walk arguments */
di_node_t myself; /* the di node */
di_minor_t minor;
};
typedef struct walk_link {
char *path;
int len;
char **linkpp;
} walk_link_t;
/* AIO callback args */
struct aio_callback_args{
struct libusb_transfer *transfer;
struct aiocb aiocb;
};
#endif /* LIBUSB_SUNOS_H */
includes/libusb-1.0.30/libusb/os/threads_posix.c
+126
View File
@@ -0,0 +1,126 @@
/*
* libusb synchronization using POSIX Threads
*
* Copyright © 2011 Vitali Lovich <vlovich@aliph.com>
* Copyright © 2011 Peter Stuge <peter@stuge.se>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
#include <errno.h>
#include <limits.h>
#if defined(__ANDROID__)
# include <unistd.h>
#elif defined(__HAIKU__)
# include <os/kernel/OS.h>
#elif defined(__linux__)
# include <sys/syscall.h>
# include <unistd.h>
#elif defined(__NetBSD__)
# include <lwp.h>
#elif defined(__OpenBSD__)
# include <unistd.h>
#elif defined(__sun__)
# include <sys/lwp.h>
#endif
void usbi_cond_init(usbi_cond_t *cond)
{
#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
pthread_condattr_t condattr;
PTHREAD_CHECK(pthread_condattr_init(&condattr));
PTHREAD_CHECK(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC));
PTHREAD_CHECK(pthread_cond_init(cond, &condattr));
PTHREAD_CHECK(pthread_condattr_destroy(&condattr));
#else
PTHREAD_CHECK(pthread_cond_init(cond, NULL));
#endif
}
int usbi_cond_timedwait(usbi_cond_t *cond,
usbi_mutex_t *mutex, const struct timeval *tv)
{
struct timespec timeout;
int r;
#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
usbi_get_monotonic_time(&timeout);
#else
usbi_get_real_time(&timeout);
#endif
timeout.tv_sec += tv->tv_sec;
timeout.tv_nsec += tv->tv_usec * 1000L;
if (timeout.tv_nsec >= NSEC_PER_SEC) {
timeout.tv_nsec -= NSEC_PER_SEC;
timeout.tv_sec++;
}
r = pthread_cond_timedwait(cond, mutex, &timeout);
if (r == 0)
return 0;
else if (r == ETIMEDOUT)
return LIBUSB_ERROR_TIMEOUT;
else
return LIBUSB_ERROR_OTHER;
}
unsigned long usbi_get_tid(void)
{
static _Thread_local unsigned long tl_tid;
unsigned long tid;
if (tl_tid)
return tl_tid;
#if defined(__ANDROID__)
tid = (unsigned long)gettid();
#elif defined(__APPLE__)
#ifdef HAVE_PTHREAD_THREADID_NP
uint64_t thread_id;
if (pthread_threadid_np(NULL, &thread_id) == 0)
tid = (unsigned long)thread_id;
else
tid = ULONG_MAX;
#else
tid = (unsigned long)pthread_mach_thread_np(pthread_self());
#endif
#elif defined(__HAIKU__)
tid = (unsigned long)get_pthread_thread_id(pthread_self());
#elif defined(__linux__)
tid = (unsigned long)syscall(SYS_gettid);
#elif defined(__NetBSD__)
tid = (unsigned long)_lwp_self();
#elif defined(__OpenBSD__)
tid = (unsigned long)getthrid();
#elif defined(__sun__)
tid = (unsigned long)_lwp_self();
#else
tid = ULONG_MAX;
#endif
if (tid == ULONG_MAX) {
/* If we don't have a thread ID, at least return a unique
* value that can be used to distinguish individual
* threads. */
tid = (unsigned long)(uintptr_t)pthread_self();
}
return tl_tid = tid;
}
includes/libusb-1.0.30/libusb/os/threads_posix.h
+104
View File
@@ -0,0 +1,104 @@
/*
* libusb synchronization using POSIX Threads
*
* Copyright © 2010 Peter Stuge <peter@stuge.se>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_THREADS_POSIX_H
#define LIBUSB_THREADS_POSIX_H
#include <pthread.h>
#define PTHREAD_CHECK(expression) ASSERT_EQ(expression, 0)
#define USBI_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
typedef pthread_mutex_t usbi_mutex_static_t;
static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_lock(mutex));
}
static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_unlock(mutex));
}
typedef pthread_mutex_t usbi_mutex_t;
static inline void usbi_mutex_init(usbi_mutex_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_init(mutex, NULL));
}
static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_lock(mutex));
}
static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_unlock(mutex));
}
static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
{
int mutexIsLocked = pthread_mutex_trylock(mutex) == 0;
return mutexIsLocked;
}
static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
{
PTHREAD_CHECK(pthread_mutex_destroy(mutex));
}
#define USBI_COND_INITIALIZER PTHREAD_COND_INITIALIZER
typedef pthread_cond_t usbi_cond_t;
void usbi_cond_init(usbi_cond_t *cond);
static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
{
PTHREAD_CHECK(pthread_cond_wait(cond, mutex));
}
int usbi_cond_timedwait(usbi_cond_t *cond,
usbi_mutex_t *mutex, const struct timeval *tv);
static inline void usbi_cond_signal(usbi_cond_t *cond)
{
PTHREAD_CHECK(pthread_cond_signal(cond));
}
static inline void usbi_cond_broadcast(usbi_cond_t *cond)
{
PTHREAD_CHECK(pthread_cond_broadcast(cond));
}
static inline void usbi_cond_destroy(usbi_cond_t *cond)
{
PTHREAD_CHECK(pthread_cond_destroy(cond));
}
typedef pthread_key_t usbi_tls_key_t;
static inline void usbi_tls_key_create(usbi_tls_key_t *key)
{
PTHREAD_CHECK(pthread_key_create(key, NULL));
}
static inline void *usbi_tls_key_get(usbi_tls_key_t key)
{
return pthread_getspecific(key);
}
static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
{
PTHREAD_CHECK(pthread_setspecific(key, ptr));
}
static inline void usbi_tls_key_delete(usbi_tls_key_t key)
{
PTHREAD_CHECK(pthread_key_delete(key));
}
unsigned long usbi_get_tid(void);
#endif /* LIBUSB_THREADS_POSIX_H */
includes/libusb-1.0.30/libusb/os/threads_windows.c
+40
View File
@@ -0,0 +1,40 @@
/*
* libusb synchronization on Microsoft Windows
*
* Copyright © 2010 Michael Plante <michael.plante@gmail.com>
* Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
int usbi_cond_timedwait(usbi_cond_t *cond,
usbi_mutex_t *mutex, const struct timeval *tv)
{
DWORD millis;
millis = (DWORD)(tv->tv_sec * 1000L) + (tv->tv_usec / 1000L);
/* round up to next millisecond */
if (tv->tv_usec % 1000L)
millis++;
if (SleepConditionVariableCS(cond, mutex, millis))
return 0;
else if (GetLastError() == ERROR_TIMEOUT)
return LIBUSB_ERROR_TIMEOUT;
else
return LIBUSB_ERROR_OTHER;
}
includes/libusb-1.0.30/libusb/os/threads_windows.h
+114
View File
@@ -0,0 +1,114 @@
/*
* libusb synchronization on Microsoft Windows
*
* Copyright © 2010 Michael Plante <michael.plante@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_THREADS_WINDOWS_H
#define LIBUSB_THREADS_WINDOWS_H
#define WINAPI_CHECK(expression) ASSERT_NE(expression, 0)
#define USBI_MUTEX_INITIALIZER 0L
typedef LONG usbi_mutex_static_t;
static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
{
while (InterlockedExchange(mutex, 1L) == 1L)
SleepEx(0, TRUE);
}
static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
{
InterlockedExchange(mutex, 0L);
}
typedef CRITICAL_SECTION usbi_mutex_t;
static inline void usbi_mutex_init(usbi_mutex_t *mutex)
{
InitializeCriticalSection(mutex);
}
static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
{
EnterCriticalSection(mutex);
}
static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
{
LeaveCriticalSection(mutex);
}
static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
{
int mutexIsLocked = TryEnterCriticalSection(mutex) != 0;
return mutexIsLocked;
}
static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
{
DeleteCriticalSection(mutex);
}
#if !defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED)
#define HAVE_STRUCT_TIMESPEC 1
#define _TIMESPEC_DEFINED 1
struct timespec {
long tv_sec;
long tv_nsec;
};
#endif /* HAVE_STRUCT_TIMESPEC || _TIMESPEC_DEFINED */
typedef CONDITION_VARIABLE usbi_cond_t;
static inline void usbi_cond_init(usbi_cond_t *cond)
{
InitializeConditionVariable(cond);
}
static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
{
WINAPI_CHECK(SleepConditionVariableCS(cond, mutex, INFINITE));
}
int usbi_cond_timedwait(usbi_cond_t *cond,
usbi_mutex_t *mutex, const struct timeval *tv);
static inline void usbi_cond_broadcast(usbi_cond_t *cond)
{
WakeAllConditionVariable(cond);
}
static inline void usbi_cond_destroy(usbi_cond_t *cond)
{
UNUSED(cond);
}
typedef DWORD usbi_tls_key_t;
static inline void usbi_tls_key_create(usbi_tls_key_t *key)
{
*key = TlsAlloc();
assert(*key != TLS_OUT_OF_INDEXES);
}
static inline void *usbi_tls_key_get(usbi_tls_key_t key)
{
return TlsGetValue(key);
}
static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
{
WINAPI_CHECK(TlsSetValue(key, ptr));
}
static inline void usbi_tls_key_delete(usbi_tls_key_t key)
{
WINAPI_CHECK(TlsFree(key));
}
static inline unsigned long usbi_get_tid(void)
{
return (unsigned long)GetCurrentThreadId();
}
#endif /* LIBUSB_THREADS_WINDOWS_H */
includes/libusb-1.0.30/libusb/os/windows_common.c
+1008
View File
File diff suppressed because it is too large Load Diff
includes/libusb-1.0.30/libusb/os/windows_common.h
+443
View File
@@ -0,0 +1,443 @@
/*
* Windows backend common header for libusb 1.0
*
* This file brings together header code common between
* the desktop Windows backends.
* Copyright © 2012-2013 RealVNC Ltd.
* Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
* Copyright © 2014-2020 Chris Dickens <christopher.a.dickens@gmail.com>
* With contributions from Michael Plante, Orin Eman et al.
* Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
* Major code testing contribution by Xiaofan Chen
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_WINDOWS_COMMON_H
#define LIBUSB_WINDOWS_COMMON_H
#include <stdbool.h>
/*
* Workaround for the mess that exists with the DWORD and ULONG types.
* Visual Studio unconditionally defines these types as 'unsigned long'
* and a long is always 32-bits, even on 64-bit builds. GCC on the other
* hand varies the width of a long, matching it to the build. To make
* matters worse, the platform headers for these GCC builds define a
* DWORD/ULONG to be 'unsigned long' on 32-bit builds and 'unsigned int'
* on 64-bit builds. This creates a great deal of warnings for compilers
* that support printf format checking since it will never actually be
* an unsigned long.
*/
#if defined(_MSC_VER)
#define ULONG_CAST(x) (x)
#else
#define ULONG_CAST(x) ((unsigned long)(x))
#endif
#if defined(__CYGWIN__)
#define _stricmp strcasecmp
#define _strdup strdup
// _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
#define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, (LPDWORD)f)
#else
#include <process.h>
#endif
#define safe_free(p) do {if (p != NULL) {free((void *)p); p = NULL;}} while (0)
/*
* API macros - leveraged from libusb-win32 1.x
*/
#define DLL_STRINGIFY(s) #s
/*
* Macros for handling DLL themselves
*/
#define DLL_HANDLE_NAME(name) __dll_##name##_handle
#define DLL_DECLARE_HANDLE(name) \
static HMODULE DLL_HANDLE_NAME(name)
#define DLL_GET_HANDLE(ctx, name) \
do { \
DLL_HANDLE_NAME(name) = load_system_library(ctx, \
DLL_STRINGIFY(name)); \
if (!DLL_HANDLE_NAME(name)) \
return false; \
} while (0)
#define DLL_FREE_HANDLE(name) \
do { \
if (DLL_HANDLE_NAME(name)) { \
FreeLibrary(DLL_HANDLE_NAME(name)); \
DLL_HANDLE_NAME(name) = NULL; \
} \
} while (0)
/*
* Macros for handling functions within a DLL
*/
#define DLL_FUNC_NAME(name) __dll_##name##_func_t
#define DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefixname, name, args) \
typedef ret (api * DLL_FUNC_NAME(name))args; \
static DLL_FUNC_NAME(name) prefixname
#define DLL_DECLARE_FUNC(api, ret, name, args) \
DLL_DECLARE_FUNC_PREFIXNAME(api, ret, name, name, args)
#define DLL_DECLARE_FUNC_PREFIXED(api, ret, prefix, name, args) \
DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefix##name, name, args)
#define DLL_LOAD_FUNC_PREFIXNAME(dll, prefixname, name, ret_on_failure) \
do { \
HMODULE h = DLL_HANDLE_NAME(dll); \
prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, \
DLL_STRINGIFY(name)); \
if (prefixname) \
break; \
prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, \
DLL_STRINGIFY(name) DLL_STRINGIFY(A)); \
if (prefixname) \
break; \
prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, \
DLL_STRINGIFY(name) DLL_STRINGIFY(W)); \
if (prefixname) \
break; \
if (ret_on_failure) \
return false; \
} while (0)
#define DLL_LOAD_FUNC(dll, name, ret_on_failure) \
DLL_LOAD_FUNC_PREFIXNAME(dll, name, name, ret_on_failure)
#define DLL_LOAD_FUNC_PREFIXED(dll, prefix, name, ret_on_failure) \
DLL_LOAD_FUNC_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
// https://msdn.microsoft.com/en-us/library/windows/hardware/ff539136(v=vs.85).aspx
#if !defined(USBD_SUCCESS)
typedef LONG USBD_STATUS;
#define USBD_SUCCESS(Status) ((USBD_STATUS)(Status) >= 0)
#define USBD_STATUS_STALL_PID ((USBD_STATUS)0xC0000004L)
#define USBD_STATUS_ENDPOINT_HALTED ((USBD_STATUS)0xC0000030L)
#define USBD_STATUS_TIMEOUT ((USBD_STATUS)0xC0006000L)
#define USBD_STATUS_DEVICE_GONE ((USBD_STATUS)0xC0007000L)
#define USBD_STATUS_CANCELED ((USBD_STATUS)0xC0010000L)
#endif
// error code added with Windows SDK 10.0.18362
#ifndef ERROR_NO_SUCH_DEVICE
#define ERROR_NO_SUCH_DEVICE 433L
#endif
/* Windows versions */
enum windows_version {
WINDOWS_UNDEFINED,
WINDOWS_2000,
WINDOWS_XP,
WINDOWS_2003, // Also XP x64
WINDOWS_VISTA,
WINDOWS_7,
WINDOWS_8,
WINDOWS_8_1,
WINDOWS_10,
WINDOWS_11,
WINDOWS_12_OR_LATER
};
extern enum windows_version windows_version;
#include <pshpack1.h>
typedef struct USB_DEVICE_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
USHORT bcdUSB;
UCHAR bDeviceClass;
UCHAR bDeviceSubClass;
UCHAR bDeviceProtocol;
UCHAR bMaxPacketSize0;
USHORT idVendor;
USHORT idProduct;
USHORT bcdDevice;
UCHAR iManufacturer;
UCHAR iProduct;
UCHAR iSerialNumber;
UCHAR bNumConfigurations;
} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
typedef struct USB_CONFIGURATION_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
USHORT wTotalLength;
UCHAR bNumInterfaces;
UCHAR bConfigurationValue;
UCHAR iConfiguration;
UCHAR bmAttributes;
UCHAR MaxPower;
} USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
#include <poppack.h>
#define MAX_DEVICE_ID_LEN 200
typedef struct USB_DK_DEVICE_ID {
WCHAR DeviceID[MAX_DEVICE_ID_LEN];
WCHAR InstanceID[MAX_DEVICE_ID_LEN];
} USB_DK_DEVICE_ID, *PUSB_DK_DEVICE_ID;
typedef struct USB_DK_DEVICE_INFO {
USB_DK_DEVICE_ID ID;
ULONG64 FilterID;
ULONG64 Port;
ULONG64 Speed;
USB_DEVICE_DESCRIPTOR DeviceDescriptor;
} USB_DK_DEVICE_INFO, *PUSB_DK_DEVICE_INFO;
typedef struct USB_DK_ISO_TRANSFER_RESULT {
ULONG64 ActualLength;
ULONG64 TransferResult;
} USB_DK_ISO_TRANSFER_RESULT, *PUSB_DK_ISO_TRANSFER_RESULT;
typedef struct USB_DK_GEN_TRANSFER_RESULT {
ULONG64 BytesTransferred;
ULONG64 UsbdStatus; // USBD_STATUS code
} USB_DK_GEN_TRANSFER_RESULT, *PUSB_DK_GEN_TRANSFER_RESULT;
typedef struct USB_DK_TRANSFER_RESULT {
USB_DK_GEN_TRANSFER_RESULT GenResult;
PVOID64 IsochronousResultsArray; // array of USB_DK_ISO_TRANSFER_RESULT
} USB_DK_TRANSFER_RESULT, *PUSB_DK_TRANSFER_RESULT;
typedef struct USB_DK_TRANSFER_REQUEST {
ULONG64 EndpointAddress;
PVOID64 Buffer;
ULONG64 BufferLength;
ULONG64 TransferType;
ULONG64 IsochronousPacketsArraySize;
PVOID64 IsochronousPacketsArray;
USB_DK_TRANSFER_RESULT Result;
} USB_DK_TRANSFER_REQUEST, *PUSB_DK_TRANSFER_REQUEST;
struct usbdk_device_priv {
USB_DK_DEVICE_ID ID;
PUSB_CONFIGURATION_DESCRIPTOR *config_descriptors;
HANDLE redirector_handle;
HANDLE system_handle;
uint8_t active_configuration;
};
struct winusb_device_priv {
bool initialized;
#if defined(LIBUSB_WINDOWS_HOTPLUG)
bool seen_during_scan; // set true for each device encountered during windows_get_device_list
bool seen_before_scan; // set true for each device encountered before windows_get_device_list
#endif
bool root_hub;
uint8_t active_config;
uint16_t langid; // cached USB language ID for string descriptor requests
uint8_t depth; // distance to HCD
const struct windows_usb_api_backend *apib;
char *dev_id;
char *path; // device interface path
int sub_api; // for WinUSB-like APIs
usbi_mutex_t interface_lock; // protects usb_interface[] against concurrent
// claim/release/altsetting from different handles,
// and concurrent enumeration setup
// (set_composite_interface, set_hid_interface,
// and HUB_PASS/DEV_PASS in winusb_get_device_list)
struct {
char *path; // each interface needs a device interface path,
const struct windows_usb_api_backend *apib; // an API backend (multiple drivers support),
int sub_api;
int8_t nb_endpoints; // and a set of endpoint addresses (USB_MAXENDPOINTS)
uint8_t *endpoint;
int current_altsetting;
bool restricted_functionality; // indicates if the interface functionality is restricted
// by Windows (eg. HID keyboards or mice cannot do R/W)
uint8_t num_associated_interfaces; // If non-zero, the interface is part of a grouped
// set of associated interfaces (defined by an IAD)
// and this is the number of interfaces within the
// associated group (bInterfaceCount in IAD).
uint8_t first_associated_interface; // For associated interfaces, this is the index of
// the first interface (bFirstInterface in IAD) for
// the grouped set of associated interfaces.
} usb_interface[USB_MAXINTERFACES];
struct hid_device_priv *hid;
PUSB_CONFIGURATION_DESCRIPTOR *config_descriptor; // list of pointers to the cached config descriptors
GUID class_guid; // checked for change during re-enumeration
};
struct usbdk_device_handle_priv {
// Not currently used
char dummy;
};
enum WINUSB_ZLP {
WINUSB_ZLP_UNSET = 0,
WINUSB_ZLP_OFF = 1,
WINUSB_ZLP_ON = 2
};
struct winusb_device_handle_priv {
int active_interface;
struct {
HANDLE dev_handle; // WinUSB needs an extra handle for the file
HANDLE api_handle; // used by the API to communicate with the device
uint8_t zlp[USB_MAXENDPOINTS]; // Current per-endpoint SHORT_PACKET_TERMINATE status (enum WINUSB_ZLP)
} interface_handle[USB_MAXINTERFACES];
int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
};
struct usbdk_transfer_priv {
USB_DK_TRANSFER_REQUEST request;
PULONG64 IsochronousPacketsArray;
PUSB_DK_ISO_TRANSFER_RESULT IsochronousResultsArray;
};
struct winusb_transfer_priv {
uint8_t interface_number;
uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID
uint8_t *hid_dest; // transfer buffer destination, required for HID
size_t hid_expected_size;
// For isochronous transfers with LibUSBk driver:
void *iso_context;
// For isochronous transfers with Microsoft WinUSB driver:
void *isoch_buffer_handle; // The isoch_buffer_handle to free at the end of the transfer
BOOL iso_break_stream; // Whether the isoch. stream was to be continued in the last call of libusb_submit_transfer.
// As we this structure is zeroed out upon initialization, we need to use inverse logic here.
libusb_transfer_cb_fn iso_user_callback; // Original transfer callback of the user. Might be used for isochronous transfers.
};
struct windows_backend {
int (*init)(struct libusb_context *ctx);
void (*exit)(struct libusb_context *ctx);
int (*get_device_list)(struct libusb_context *ctx,
struct discovered_devs **discdevs);
int (*get_device_string)(libusb_device *dev,
enum libusb_device_string_type string_type, char *data, int length);
int (*open)(struct libusb_device_handle *dev_handle);
void (*close)(struct libusb_device_handle *dev_handle);
int (*get_active_config_descriptor)(struct libusb_device *device,
void *buffer, size_t len);
int (*get_config_descriptor)(struct libusb_device *device,
uint8_t config_index, void *buffer, size_t len);
int (*get_config_descriptor_by_value)(struct libusb_device *device,
uint8_t bConfigurationValue, void **buffer);
int (*get_configuration)(struct libusb_device_handle *dev_handle, uint8_t *config);
int (*set_configuration)(struct libusb_device_handle *dev_handle, uint8_t config);
int (*claim_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
int (*release_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle,
uint8_t interface_number, uint8_t altsetting);
int (*clear_halt)(struct libusb_device_handle *dev_handle,
unsigned char endpoint);
int (*reset_device)(struct libusb_device_handle *dev_handle);
void (*destroy_device)(struct libusb_device *dev);
int (*submit_transfer)(struct usbi_transfer *itransfer);
int (*cancel_transfer)(struct usbi_transfer *itransfer);
void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
enum libusb_transfer_status (*copy_transfer_data)(struct usbi_transfer *itransfer, DWORD length);
int (*endpoint_supports_raw_io)(struct libusb_device_handle *dev_handle,
uint8_t endpoint);
int (*endpoint_set_raw_io)(struct libusb_device_handle *dev_handle,
uint8_t endpoint, int enable);
int (*get_max_raw_io_transfer_size)(
struct libusb_device_handle *dev_handle,
uint8_t endpoint);
};
struct windows_context_priv {
const struct windows_backend *backend;
HANDLE completion_port;
HANDLE completion_port_thread;
};
union windows_device_priv {
struct usbdk_device_priv usbdk_priv;
struct winusb_device_priv winusb_priv;
};
struct windows_device_handle_priv {
struct list_head active_transfers;
union {
struct usbdk_device_handle_priv usbdk_priv;
struct winusb_device_handle_priv winusb_priv;
};
};
struct windows_transfer_priv {
OVERLAPPED overlapped;
HANDLE handle;
struct list_head list;
union {
struct usbdk_transfer_priv usbdk_priv;
struct winusb_transfer_priv winusb_priv;
};
};
static inline struct usbdk_device_handle_priv *get_usbdk_device_handle_priv(struct libusb_device_handle *dev_handle)
{
struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
return &handle_priv->usbdk_priv;
}
static inline struct winusb_device_handle_priv *get_winusb_device_handle_priv(struct libusb_device_handle *dev_handle)
{
struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
return &handle_priv->winusb_priv;
}
static inline OVERLAPPED *get_transfer_priv_overlapped(struct usbi_transfer *itransfer)
{
struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
return &transfer_priv->overlapped;
}
static inline void set_transfer_priv_handle(struct usbi_transfer *itransfer, HANDLE handle)
{
struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
transfer_priv->handle = handle;
}
static inline struct usbdk_transfer_priv *get_usbdk_transfer_priv(struct usbi_transfer *itransfer)
{
struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
return &transfer_priv->usbdk_priv;
}
static inline struct winusb_transfer_priv *get_winusb_transfer_priv(struct usbi_transfer *itransfer)
{
struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
return &transfer_priv->winusb_priv;
}
extern const struct windows_backend usbdk_backend;
extern const struct windows_backend winusb_backend;
HMODULE load_system_library(struct libusb_context *ctx, const char *name);
unsigned long htab_hash(const char *str);
enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status);
void windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size);
#if defined(ENABLE_LOGGING)
const char *windows_error_str(DWORD error_code);
#endif
#endif
includes/libusb-1.0.30/libusb/os/windows_hotplug.c
+321
View File
@@ -0,0 +1,321 @@
/*
* windows hotplug backend for libusb 1.0
* Copyright © 2024 Sylvain Fasel <sylvain@sonatique.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusbi.h"
#include "threads_windows.h"
#include "windows_common.h"
#include "windows_hotplug.h"
#include <stdio.h>
#include <dbt.h>
/* The Windows Hotplug system is a two steps process.
* 1. We create a hidden window and listen for DBT_DEVNODES_CHANGED, which Windows
* broadcasts to all top-level windows whenever the device tree changes (no
* registration required). Multiple rapid events (e.g. a hub with many children)
* are coalesced via a short debounce timer so we only scan once the burst settles.
* A maximum delay ceiling guarantees a scan fires within a bounded time even
* during sustained bursts, preventing unbounded latency.
* 2. Upon timer expiry, we snapshot the current device list, run a full re-enumeration
* via the Windows backend, then diff the result: newly found devices that have been
* successfully initialized generate DEVICE_ARRIVED events; devices that were not
* encountered by the re-enumeration (physically removed) generate DEVICE_LEFT events.
*/
#define HOTPLUG_DEBOUNCE_TIMER_ID 1
#define HOTPLUG_DEBOUNCE_MS 10
#define HOTPLUG_DEBOUNCE_MAX_DELAY_MS 100
static ULONGLONG first_debounce_tick;
static HWND windows_event_hwnd;
static HANDLE windows_event_thread_handle;
static DWORD WINAPI windows_event_thread_main(LPVOID lpParam);
static LRESULT CALLBACK windows_proc_callback(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
#define log_error(operation) do { \
usbi_err(NULL, "%s failed with error: %s", operation, windows_error_str(0)); \
} while (0)
int windows_start_event_monitor(void)
{
windows_event_thread_handle = CreateThread(
NULL, // Default security descriptor
0, // Default stack size
windows_event_thread_main,
NULL, // No parameters to pass to the thread
0, // Start immediately
NULL // No need to keep track of thread ID
);
if (windows_event_thread_handle == NULL)
{
log_error("CreateThread");
return LIBUSB_ERROR_OTHER;
}
return LIBUSB_SUCCESS;
}
int windows_stop_event_monitor(void)
{
if (windows_event_hwnd == NULL)
{
return LIBUSB_SUCCESS;
}
if (!SUCCEEDED(SendMessage(windows_event_hwnd, WM_CLOSE, 0, 0)))
{
log_error("SendMessage");
return LIBUSB_ERROR_OTHER;
}
if (WaitForSingleObject(windows_event_thread_handle, INFINITE) != WAIT_OBJECT_0)
{
log_error("WaitForSingleObject");
return LIBUSB_ERROR_OTHER;
}
if (!CloseHandle(windows_event_thread_handle))
{
log_error("CloseHandle");
return LIBUSB_ERROR_OTHER;
}
return LIBUSB_SUCCESS;
}
static int windows_get_device_list(struct libusb_context *ctx)
{
// note: context device list is protected by active_contexts_lock
return ((struct windows_context_priv *)usbi_get_context_priv(ctx))->backend->get_device_list(ctx, NULL);
}
void windows_initial_scan_devices(struct libusb_context *ctx)
{
usbi_mutex_static_lock(&active_contexts_lock);
const int ret = windows_get_device_list(ctx);
if (ret != LIBUSB_SUCCESS)
{
usbi_err(ctx, "hotplug failed to retrieve initial list with error: %s", libusb_error_name(ret));
}
usbi_mutex_static_unlock(&active_contexts_lock);
}
static void windows_refresh_device_list(struct libusb_context *ctx)
{
struct libusb_device *dev, *next_dev;
// Step 1: clear seen_during_scan so the scan can mark which devices are still
// physically present, and set seen_before_scan so we can distinguish newly
// created devices (which start with seen_before_scan=false via calloc).
for_each_device_safe(ctx, dev, next_dev)
{
struct winusb_device_priv *priv = (struct winusb_device_priv *)usbi_get_device_priv(dev);
priv->seen_during_scan = false;
priv->seen_before_scan = true;
}
// Step 2: re-enumerate — winusb_get_device_list attaches newly-arrived devices
// and sets seen_during_scan=true for every device it physically encounters.
// seen_before_scan is untouched and will be left in default state (false) for newly created devices, allowing us to identify them in the next step.
const int ret = windows_get_device_list(ctx);
if (ret != LIBUSB_SUCCESS)
{
usbi_err(ctx, "hotplug failed to retrieve current list with error: %s", libusb_error_name(ret));
return;
}
// Step 3: diff old vs new.
for_each_device_safe(ctx, dev, next_dev)
{
struct winusb_device_priv *priv = (struct winusb_device_priv *)usbi_get_device_priv(dev);
if (!priv->seen_during_scan)
{
// Not encountered by the scan: device was physically removed.
if (priv->initialized)
{
usbi_disconnect_device(dev); // fires DEVICE_LEFT
}
else
{
usbi_detach_device(dev);
// No DEVICE_LEFT message is posted for uninitialized
// devices, so no message handler will drop the initial
// ref. We must drop it here to avoid a leak.
libusb_unref_device(dev);
}
}
else if (!priv->seen_before_scan)
{
if (priv->initialized)
{
usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
}
}
}
}
static void windows_refresh_device_list_for_all_ctx(void)
{
usbi_mutex_static_lock(&active_contexts_lock);
struct libusb_context *ctx;
for_each_context(ctx)
{
windows_refresh_device_list(ctx);
}
usbi_mutex_static_unlock(&active_contexts_lock);
}
#define WND_CLASS_NAME TEXT("libusb-1.0-windows-hotplug")
static bool init_wnd_class(void)
{
WNDCLASS wndClass = { 0 };
wndClass.lpfnWndProc = windows_proc_callback;
wndClass.hInstance = GetModuleHandle(NULL);
wndClass.lpszClassName = WND_CLASS_NAME;
if (!RegisterClass(&wndClass))
{
log_error("event thread: RegisterClass");
return false;
}
return true;
}
static DWORD WINAPI windows_event_thread_main(LPVOID lpParam)
{
UNUSED(lpParam);
usbi_dbg(NULL, "windows event thread entering");
if (!init_wnd_class())
{
return (DWORD)-1;
}
windows_event_hwnd = CreateWindow(
WND_CLASS_NAME,
TEXT(""),
0,
0, 0, 0, 0,
NULL, NULL,
GetModuleHandle(NULL),
NULL);
if (windows_event_hwnd == NULL)
{
log_error("event thread: CreateWindow");
return (DWORD)-1;
}
MSG msg;
BOOL ret_val;
while ((ret_val = GetMessage(&msg, windows_event_hwnd, 0, 0)) != 0)
{
if (ret_val == -1)
{
log_error("event thread: GetMessage");
break;
}
if (!SUCCEEDED(TranslateMessage(&msg)))
{
log_error("event thread: TranslateMessage");
}
if (!SUCCEEDED(DispatchMessage(&msg)))
{
log_error("event thread: DispatchMessage");
}
}
usbi_dbg(NULL, "windows event thread exiting");
return 0;
}
static LRESULT CALLBACK windows_proc_callback(
HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message)
{
case WM_DEVICECHANGE:
if (wParam == DBT_DEVNODES_CHANGED)
{
if (first_debounce_tick == 0)
{
// First event in a new burst — record the time and start the debounce timer.
first_debounce_tick = GetTickCount64();
SetTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID, HOTPLUG_DEBOUNCE_MS, NULL);
}
else if (GetTickCount64() - first_debounce_tick >= HOTPLUG_DEBOUNCE_MAX_DELAY_MS)
{
// Maximum delay reached — force an immediate scan so devices
// are not invisible for the entire duration of a sustained burst.
KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
first_debounce_tick = 0;
windows_refresh_device_list_for_all_ctx();
}
else
{
// Still within the max-delay window — reset the debounce timer.
SetTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID, HOTPLUG_DEBOUNCE_MS, NULL);
}
return TRUE;
}
return DefWindowProc(hwnd, message, wParam, lParam);
case WM_TIMER:
if (wParam == HOTPLUG_DEBOUNCE_TIMER_ID)
{
KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
first_debounce_tick = 0;
windows_refresh_device_list_for_all_ctx();
return 0;
}
return DefWindowProc(hwnd, message, wParam, lParam);
case WM_CLOSE:
KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
first_debounce_tick = 0;
if (!DestroyWindow(hwnd))
{
log_error("DestroyWindow");
}
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
}
includes/libusb-1.0.30/libusb/os/windows_hotplug.h
+28
View File
@@ -0,0 +1,28 @@
/*
* windows hotplug backend for libusb 1.0
* Copyright © 2024 Sylvain Fasel <sylvain@sonatique.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef WINDOWS_HOTPLUG_H
#define WINDOWS_HOTPLUG_H
int windows_start_event_monitor(void);
int windows_stop_event_monitor(void);
void windows_initial_scan_devices(struct libusb_context *ctx);
#endif
includes/libusb-1.0.30/libusb/os/windows_usbdk.c
+732
View File
@@ -0,0 +1,732 @@
/*
* windows UsbDk backend for libusb 1.0
* Copyright © 2014 Red Hat, Inc.
* Authors:
* Dmitry Fleytman <dmitry@daynix.com>
* Pavel Gurvich <pavel@daynix.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <config.h>
#include <windows.h>
#include <stdio.h>
#include "libusbi.h"
#include "windows_usbdk.h"
#if !defined(STATUS_SUCCESS)
typedef LONG NTSTATUS;
#define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
#endif
#if !defined(STATUS_CANCELLED)
#define STATUS_CANCELLED ((NTSTATUS)0xC0000120L)
#endif
#if !defined(STATUS_REQUEST_CANCELED)
#define STATUS_REQUEST_CANCELED ((NTSTATUS)0xC0000703L)
#endif
static struct {
HMODULE module;
USBDK_GET_DEVICES_LIST GetDevicesList;
USBDK_RELEASE_DEVICES_LIST ReleaseDevicesList;
USBDK_START_REDIRECT StartRedirect;
USBDK_STOP_REDIRECT StopRedirect;
USBDK_GET_CONFIGURATION_DESCRIPTOR GetConfigurationDescriptor;
USBDK_RELEASE_CONFIGURATION_DESCRIPTOR ReleaseConfigurationDescriptor;
USBDK_READ_PIPE ReadPipe;
USBDK_WRITE_PIPE WritePipe;
USBDK_ABORT_PIPE AbortPipe;
USBDK_RESET_PIPE ResetPipe;
USBDK_SET_ALTSETTING SetAltsetting;
USBDK_RESET_DEVICE ResetDevice;
USBDK_GET_REDIRECTOR_SYSTEM_HANDLE GetRedirectorSystemHandle;
} usbdk_helper;
static FARPROC get_usbdk_proc_addr(struct libusb_context *ctx, LPCSTR api_name)
{
FARPROC api_ptr = GetProcAddress(usbdk_helper.module, api_name);
if (api_ptr == NULL)
usbi_err(ctx, "UsbDkHelper API %s not found: %s", api_name, windows_error_str(0));
return api_ptr;
}
static void unload_usbdk_helper_dll(void)
{
if (usbdk_helper.module != NULL) {
FreeLibrary(usbdk_helper.module);
usbdk_helper.module = NULL;
}
}
static int load_usbdk_helper_dll(struct libusb_context *ctx)
{
usbdk_helper.module = load_system_library(ctx, "UsbDkHelper");
if (usbdk_helper.module == NULL) {
usbi_err(ctx, "Failed to load UsbDkHelper.dll: %s", windows_error_str(0));
return LIBUSB_ERROR_NOT_FOUND;
}
usbdk_helper.GetDevicesList = (USBDK_GET_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_GetDevicesList");
if (usbdk_helper.GetDevicesList == NULL)
goto error_unload;
usbdk_helper.ReleaseDevicesList = (USBDK_RELEASE_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseDevicesList");
if (usbdk_helper.ReleaseDevicesList == NULL)
goto error_unload;
usbdk_helper.StartRedirect = (USBDK_START_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StartRedirect");
if (usbdk_helper.StartRedirect == NULL)
goto error_unload;
usbdk_helper.StopRedirect = (USBDK_STOP_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StopRedirect");
if (usbdk_helper.StopRedirect == NULL)
goto error_unload;
usbdk_helper.GetConfigurationDescriptor = (USBDK_GET_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_GetConfigurationDescriptor");
if (usbdk_helper.GetConfigurationDescriptor == NULL)
goto error_unload;
usbdk_helper.ReleaseConfigurationDescriptor = (USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseConfigurationDescriptor");
if (usbdk_helper.ReleaseConfigurationDescriptor == NULL)
goto error_unload;
usbdk_helper.ReadPipe = (USBDK_READ_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ReadPipe");
if (usbdk_helper.ReadPipe == NULL)
goto error_unload;
usbdk_helper.WritePipe = (USBDK_WRITE_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_WritePipe");
if (usbdk_helper.WritePipe == NULL)
goto error_unload;
usbdk_helper.AbortPipe = (USBDK_ABORT_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_AbortPipe");
if (usbdk_helper.AbortPipe == NULL)
goto error_unload;
usbdk_helper.ResetPipe = (USBDK_RESET_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ResetPipe");
if (usbdk_helper.ResetPipe == NULL)
goto error_unload;
usbdk_helper.SetAltsetting = (USBDK_SET_ALTSETTING)get_usbdk_proc_addr(ctx, "UsbDk_SetAltsetting");
if (usbdk_helper.SetAltsetting == NULL)
goto error_unload;
usbdk_helper.ResetDevice = (USBDK_RESET_DEVICE)get_usbdk_proc_addr(ctx, "UsbDk_ResetDevice");
if (usbdk_helper.ResetDevice == NULL)
goto error_unload;
usbdk_helper.GetRedirectorSystemHandle = (USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)get_usbdk_proc_addr(ctx, "UsbDk_GetRedirectorSystemHandle");
if (usbdk_helper.GetRedirectorSystemHandle == NULL)
goto error_unload;
return LIBUSB_SUCCESS;
error_unload:
FreeLibrary(usbdk_helper.module);
usbdk_helper.module = NULL;
return LIBUSB_ERROR_NOT_FOUND;
}
typedef SC_HANDLE (WINAPI *POPENSCMANAGERA)(LPCSTR, LPCSTR, DWORD);
typedef SC_HANDLE (WINAPI *POPENSERVICEA)(SC_HANDLE, LPCSTR, DWORD);
typedef BOOL (WINAPI *PCLOSESERVICEHANDLE)(SC_HANDLE);
static int usbdk_init(struct libusb_context *ctx)
{
POPENSCMANAGERA pOpenSCManagerA;
POPENSERVICEA pOpenServiceA;
PCLOSESERVICEHANDLE pCloseServiceHandle;
SC_HANDLE managerHandle;
SC_HANDLE serviceHandle;
HMODULE h;
h = load_system_library(ctx, "Advapi32");
if (h == NULL) {
usbi_warn(ctx, "failed to open Advapi32\n");
return LIBUSB_ERROR_OTHER;
}
pOpenSCManagerA = (POPENSCMANAGERA)GetProcAddress(h, "OpenSCManagerA");
if (pOpenSCManagerA == NULL) {
usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenSCManagerA");
goto error_free_library;
}
pOpenServiceA = (POPENSERVICEA)GetProcAddress(h, "OpenServiceA");
if (pOpenServiceA == NULL) {
usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenServiceA");
goto error_free_library;
}
pCloseServiceHandle = (PCLOSESERVICEHANDLE)GetProcAddress(h, "CloseServiceHandle");
if (pCloseServiceHandle == NULL) {
usbi_warn(ctx, "failed to find %s in Advapi32\n", "CloseServiceHandle");
goto error_free_library;
}
managerHandle = pOpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
if (managerHandle == NULL) {
usbi_warn(ctx, "failed to open service control manager: %s", windows_error_str(0));
goto error_free_library;
}
serviceHandle = pOpenServiceA(managerHandle, "UsbDk", GENERIC_READ);
pCloseServiceHandle(managerHandle);
if (serviceHandle == NULL) {
if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
usbi_warn(ctx, "failed to open UsbDk service: %s", windows_error_str(0));
FreeLibrary(h);
return LIBUSB_ERROR_NOT_FOUND;
}
pCloseServiceHandle(serviceHandle);
FreeLibrary(h);
return load_usbdk_helper_dll(ctx);
error_free_library:
FreeLibrary(h);
return LIBUSB_ERROR_OTHER;
}
static void usbdk_exit(struct libusb_context *ctx)
{
UNUSED(ctx);
unload_usbdk_helper_dll();
}
static int usbdk_get_session_id_for_device(struct libusb_context *ctx,
PUSB_DK_DEVICE_ID id, unsigned long *session_id)
{
char dev_identity[ARRAYSIZE(id->DeviceID) + ARRAYSIZE(id->InstanceID) + 1];
if (snprintf(dev_identity, sizeof(dev_identity), "%S%S", id->DeviceID, id->InstanceID) == -1) {
usbi_warn(ctx, "cannot form device identity");
return LIBUSB_ERROR_NOT_SUPPORTED;
}
*session_id = htab_hash(dev_identity);
return LIBUSB_SUCCESS;
}
static void usbdk_release_config_descriptors(struct usbdk_device_priv *priv, uint8_t count)
{
uint8_t i;
for (i = 0; i < count; i++)
usbdk_helper.ReleaseConfigurationDescriptor(priv->config_descriptors[i]);
free(priv->config_descriptors);
priv->config_descriptors = NULL;
}
static int usbdk_cache_config_descriptors(struct libusb_context *ctx,
struct usbdk_device_priv *priv, PUSB_DK_DEVICE_INFO info)
{
uint8_t i;
USB_DK_CONFIG_DESCRIPTOR_REQUEST Request;
Request.ID = info->ID;
priv->config_descriptors = calloc(info->DeviceDescriptor.bNumConfigurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
if (priv->config_descriptors == NULL) {
usbi_err(ctx, "failed to allocate configuration descriptors holder");
return LIBUSB_ERROR_NO_MEM;
}
for (i = 0; i < info->DeviceDescriptor.bNumConfigurations; i++) {
ULONG Length;
Request.Index = i;
if (!usbdk_helper.GetConfigurationDescriptor(&Request, &priv->config_descriptors[i], &Length)) {
usbi_err(ctx, "failed to retrieve configuration descriptors");
usbdk_release_config_descriptors(priv, i);
return LIBUSB_ERROR_OTHER;
}
}
return LIBUSB_SUCCESS;
}
static inline int usbdk_device_priv_init(struct libusb_context *ctx, struct libusb_device *dev, PUSB_DK_DEVICE_INFO info)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
priv->ID = info->ID;
priv->active_configuration = 0;
return usbdk_cache_config_descriptors(ctx, priv, info);
}
static void usbdk_device_init(struct libusb_device *dev, PUSB_DK_DEVICE_INFO info)
{
dev->bus_number = (uint8_t)info->FilterID;
dev->port_number = (uint8_t)info->Port;
dev->parent_dev = NULL;
// Addresses in libusb are 1-based
dev->device_address = (uint8_t)(info->Port + 1);
static_assert(sizeof(dev->device_descriptor) == sizeof(info->DeviceDescriptor),
"mismatch between libusb and OS device descriptor sizes");
memcpy(&dev->device_descriptor, &info->DeviceDescriptor, LIBUSB_DT_DEVICE_SIZE);
usbi_localize_device_descriptor(&dev->device_descriptor);
switch (info->Speed) {
case LowSpeed:
dev->speed = LIBUSB_SPEED_LOW;
break;
case FullSpeed:
dev->speed = LIBUSB_SPEED_FULL;
break;
case HighSpeed:
dev->speed = LIBUSB_SPEED_HIGH;
break;
case SuperSpeed:
dev->speed = LIBUSB_SPEED_SUPER;
break;
case NoSpeed:
default:
dev->speed = LIBUSB_SPEED_UNKNOWN;
break;
}
}
static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
{
int r = LIBUSB_SUCCESS;
ULONG i;
struct discovered_devs *discdevs = NULL;
ULONG dev_number;
PUSB_DK_DEVICE_INFO devices;
if (!usbdk_helper.GetDevicesList(&devices, &dev_number))
return LIBUSB_ERROR_OTHER;
for (i = 0; i < dev_number; i++) {
unsigned long session_id;
struct libusb_device *dev = NULL;
if (usbdk_get_session_id_for_device(ctx, &devices[i].ID, &session_id))
continue;
dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev == NULL) {
dev = usbi_alloc_device(ctx, session_id);
if (dev == NULL) {
usbi_err(ctx, "failed to allocate a new device structure");
continue;
}
usbdk_device_init(dev, &devices[i]);
if (usbdk_device_priv_init(ctx, dev, &devices[i]) != LIBUSB_SUCCESS) {
libusb_unref_device(dev);
continue;
}
usbi_connect_device(dev);
}
if (_discdevs) {
discdevs = discovered_devs_append(*_discdevs, dev);
libusb_unref_device(dev);
if (!discdevs) {
usbi_err(ctx, "cannot append new device to list");
r = LIBUSB_ERROR_NO_MEM;
goto func_exit;
}
*_discdevs = discdevs;
}
}
func_exit:
usbdk_helper.ReleaseDevicesList(devices);
return r;
}
static int usbdk_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
PUSB_CONFIGURATION_DESCRIPTOR config_header;
size_t size;
config_header = (PUSB_CONFIGURATION_DESCRIPTOR)priv->config_descriptors[config_index];
size = min(config_header->wTotalLength, len);
memcpy(buffer, config_header, size);
return (int)size;
}
static int usbdk_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue,
void **buffer)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
PUSB_CONFIGURATION_DESCRIPTOR config_header;
uint8_t index;
for (index = 0; index < dev->device_descriptor.bNumConfigurations; index++) {
config_header = priv->config_descriptors[index];
if (config_header->bConfigurationValue == bConfigurationValue) {
*buffer = priv->config_descriptors[index];
return (int)config_header->wTotalLength;
}
}
return LIBUSB_ERROR_NOT_FOUND;
}
static int usbdk_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
return usbdk_get_config_descriptor(dev, priv->active_configuration, buffer, len);
}
static int usbdk_open(struct libusb_device_handle *dev_handle)
{
struct libusb_device *dev = dev_handle->dev;
struct libusb_context *ctx = DEVICE_CTX(dev);
struct windows_context_priv *priv = usbi_get_context_priv(ctx);
struct usbdk_device_priv *device_priv = usbi_get_device_priv(dev);
device_priv->redirector_handle = usbdk_helper.StartRedirect(&device_priv->ID);
if (device_priv->redirector_handle == INVALID_HANDLE_VALUE) {
usbi_err(ctx, "Redirector startup failed");
device_priv->redirector_handle = NULL;
return LIBUSB_ERROR_OTHER;
}
device_priv->system_handle = usbdk_helper.GetRedirectorSystemHandle(device_priv->redirector_handle);
if (CreateIoCompletionPort(device_priv->system_handle, priv->completion_port, (ULONG_PTR)dev_handle, 0) == NULL) {
usbi_err(ctx, "failed to associate handle to I/O completion port: %s", windows_error_str(0));
usbdk_helper.StopRedirect(device_priv->redirector_handle);
device_priv->system_handle = NULL;
device_priv->redirector_handle = NULL;
return LIBUSB_ERROR_OTHER;
}
return LIBUSB_SUCCESS;
}
static void usbdk_close(struct libusb_device_handle *dev_handle)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
if (!usbdk_helper.StopRedirect(priv->redirector_handle))
usbi_err(HANDLE_CTX(dev_handle), "Redirector shutdown failed");
priv->system_handle = NULL;
priv->redirector_handle = NULL;
}
static int usbdk_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
*config = priv->active_configuration;
return LIBUSB_SUCCESS;
}
static int usbdk_set_configuration(struct libusb_device_handle *dev_handle, uint8_t config)
{
UNUSED(dev_handle);
UNUSED(config);
return LIBUSB_SUCCESS;
}
static int usbdk_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface)
{
UNUSED(dev_handle);
UNUSED(iface);
return LIBUSB_SUCCESS;
}
static int usbdk_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
if (!usbdk_helper.SetAltsetting(priv->redirector_handle, iface, altsetting)) {
usbi_err(HANDLE_CTX(dev_handle), "SetAltsetting failed: %s", windows_error_str(0));
return LIBUSB_ERROR_NO_DEVICE;
}
return LIBUSB_SUCCESS;
}
static int usbdk_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface)
{
UNUSED(dev_handle);
UNUSED(iface);
return LIBUSB_SUCCESS;
}
static int usbdk_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
if (!usbdk_helper.ResetPipe(priv->redirector_handle, endpoint)) {
usbi_err(HANDLE_CTX(dev_handle), "ResetPipe failed: %s", windows_error_str(0));
return LIBUSB_ERROR_NO_DEVICE;
}
return LIBUSB_SUCCESS;
}
static int usbdk_reset_device(struct libusb_device_handle *dev_handle)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
if (!usbdk_helper.ResetDevice(priv->redirector_handle)) {
usbi_err(HANDLE_CTX(dev_handle), "ResetDevice failed: %s", windows_error_str(0));
return LIBUSB_ERROR_NO_DEVICE;
}
return LIBUSB_SUCCESS;
}
static void usbdk_destroy_device(struct libusb_device *dev)
{
struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
if (priv->config_descriptors != NULL)
usbdk_release_config_descriptors(priv, dev->device_descriptor.bNumConfigurations);
}
static void usbdk_clear_transfer_priv(struct usbi_transfer *itransfer)
{
struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
safe_free(transfer_priv->IsochronousPacketsArray);
safe_free(transfer_priv->IsochronousResultsArray);
}
}
static int usbdk_do_control_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
TransferResult transResult;
transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
transfer_priv->request.BufferLength = transfer->length;
transfer_priv->request.TransferType = ControlTransferType;
set_transfer_priv_handle(itransfer, priv->system_handle);
if (transfer->buffer[0] & LIBUSB_ENDPOINT_IN)
transResult = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
else
transResult = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
switch (transResult) {
case TransferSuccess:
windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
break;
case TransferSuccessAsync:
break;
case TransferFailure:
usbi_err(TRANSFER_CTX(transfer), "ControlTransfer failed: %s", windows_error_str(0));
return LIBUSB_ERROR_IO;
}
return LIBUSB_SUCCESS;
}
static int usbdk_do_bulk_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
TransferResult transferRes;
transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
transfer_priv->request.BufferLength = transfer->length;
transfer_priv->request.EndpointAddress = transfer->endpoint;
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_BULK:
transfer_priv->request.TransferType = BulkTransferType;
break;
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
transfer_priv->request.TransferType = InterruptTransferType;
break;
}
set_transfer_priv_handle(itransfer, priv->system_handle);
if (IS_XFERIN(transfer))
transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
else
transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
switch (transferRes) {
case TransferSuccess:
windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
break;
case TransferSuccessAsync:
break;
case TransferFailure:
usbi_err(TRANSFER_CTX(transfer), "ReadPipe/WritePipe failed: %s", windows_error_str(0));
return LIBUSB_ERROR_IO;
}
return LIBUSB_SUCCESS;
}
static int usbdk_do_iso_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct usbdk_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
OVERLAPPED *overlapped = get_transfer_priv_overlapped(itransfer);
TransferResult transferRes;
int i;
transfer_priv->request.Buffer = (PVOID64)transfer->buffer;
transfer_priv->request.BufferLength = transfer->length;
transfer_priv->request.EndpointAddress = transfer->endpoint;
transfer_priv->request.TransferType = IsochronousTransferType;
transfer_priv->request.IsochronousPacketsArraySize = transfer->num_iso_packets;
transfer_priv->IsochronousPacketsArray = malloc(transfer->num_iso_packets * sizeof(ULONG64));
transfer_priv->request.IsochronousPacketsArray = (PVOID64)transfer_priv->IsochronousPacketsArray;
if (!transfer_priv->IsochronousPacketsArray) {
usbi_err(TRANSFER_CTX(transfer), "Allocation of IsochronousPacketsArray failed");
return LIBUSB_ERROR_NO_MEM;
}
transfer_priv->IsochronousResultsArray = malloc(transfer->num_iso_packets * sizeof(USB_DK_ISO_TRANSFER_RESULT));
transfer_priv->request.Result.IsochronousResultsArray = (PVOID64)transfer_priv->IsochronousResultsArray;
if (!transfer_priv->IsochronousResultsArray) {
usbi_err(TRANSFER_CTX(transfer), "Allocation of isochronousResultsArray failed");
return LIBUSB_ERROR_NO_MEM;
}
for (i = 0; i < transfer->num_iso_packets; i++)
transfer_priv->IsochronousPacketsArray[i] = transfer->iso_packet_desc[i].length;
set_transfer_priv_handle(itransfer, priv->system_handle);
if (IS_XFERIN(transfer))
transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
else
transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
switch (transferRes) {
case TransferSuccess:
windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
break;
case TransferSuccessAsync:
break;
case TransferFailure:
return LIBUSB_ERROR_IO;
}
return LIBUSB_SUCCESS;
}
static int usbdk_submit_transfer(struct usbi_transfer *itransfer)
{
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
return usbdk_do_control_transfer(itransfer);
case LIBUSB_TRANSFER_TYPE_BULK:
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
if (IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
return LIBUSB_ERROR_NOT_SUPPORTED; //TODO: Check whether we can support this in UsbDk
return usbdk_do_bulk_transfer(itransfer);
case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
return usbdk_do_iso_transfer(itransfer);
default:
// Should not get here since windows_submit_transfer() validates
// the transfer->type field
usbi_err(TRANSFER_CTX(transfer), "unsupported endpoint type %d", transfer->type);
return LIBUSB_ERROR_NOT_SUPPORTED;
}
}
static enum libusb_transfer_status usbdk_copy_transfer_data(struct usbi_transfer *itransfer, DWORD length)
{
struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
UNUSED(length);
if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
ULONG64 i;
for (i = 0; i < transfer_priv->request.IsochronousPacketsArraySize; i++) {
struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
switch (transfer_priv->IsochronousResultsArray[i].TransferResult) {
case STATUS_SUCCESS:
case STATUS_CANCELLED:
case STATUS_REQUEST_CANCELED:
lib_desc->status = LIBUSB_TRANSFER_COMPLETED; // == ERROR_SUCCESS
break;
default:
lib_desc->status = LIBUSB_TRANSFER_ERROR; // ERROR_UNKNOWN_EXCEPTION;
break;
}
lib_desc->actual_length = (unsigned int)transfer_priv->IsochronousResultsArray[i].ActualLength;
}
}
itransfer->transferred += (int)transfer_priv->request.Result.GenResult.BytesTransferred;
return usbd_status_to_libusb_transfer_status((USBD_STATUS)transfer_priv->request.Result.GenResult.UsbdStatus);
}
const struct windows_backend usbdk_backend = {
usbdk_init,
usbdk_exit,
usbdk_get_device_list,
NULL, /* usbdk_get_device_string */
usbdk_open,
usbdk_close,
usbdk_get_active_config_descriptor,
usbdk_get_config_descriptor,
usbdk_get_config_descriptor_by_value,
usbdk_get_configuration,
usbdk_set_configuration,
usbdk_claim_interface,
usbdk_release_interface,
usbdk_set_interface_altsetting,
usbdk_clear_halt,
usbdk_reset_device,
usbdk_destroy_device,
usbdk_submit_transfer,
NULL, /* cancel_transfer */
usbdk_clear_transfer_priv,
usbdk_copy_transfer_data,
NULL, /* endpoint_supports_raw_io */
NULL, /* endpoint_set_raw_io */
NULL, /* get_max_raw_io_transfer_size */
};
includes/libusb-1.0.30/libusb/os/windows_usbdk.h
+106
View File
@@ -0,0 +1,106 @@
/*
* windows UsbDk backend for libusb 1.0
* Copyright © 2014 Red Hat, Inc.
* Authors:
* Dmitry Fleytman <dmitry@daynix.com>
* Pavel Gurvich <pavel@daynix.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_WINDOWS_USBDK_H
#define LIBUSB_WINDOWS_USBDK_H
#include "windows_common.h"
typedef struct USB_DK_CONFIG_DESCRIPTOR_REQUEST {
USB_DK_DEVICE_ID ID;
ULONG64 Index;
} USB_DK_CONFIG_DESCRIPTOR_REQUEST, *PUSB_DK_CONFIG_DESCRIPTOR_REQUEST;
typedef enum {
TransferFailure = 0,
TransferSuccess,
TransferSuccessAsync
} TransferResult;
typedef enum {
NoSpeed = 0,
LowSpeed,
FullSpeed,
HighSpeed,
SuperSpeed
} USB_DK_DEVICE_SPEED;
typedef enum {
ControlTransferType,
BulkTransferType,
InterruptTransferType,
IsochronousTransferType
} USB_DK_TRANSFER_TYPE;
typedef BOOL (__cdecl *USBDK_GET_DEVICES_LIST)(
PUSB_DK_DEVICE_INFO *DeviceInfo,
PULONG DeviceNumber
);
typedef void (__cdecl *USBDK_RELEASE_DEVICES_LIST)(
PUSB_DK_DEVICE_INFO DeviceInfo
);
typedef HANDLE (__cdecl *USBDK_START_REDIRECT)(
PUSB_DK_DEVICE_ID DeviceId
);
typedef BOOL (__cdecl *USBDK_STOP_REDIRECT)(
HANDLE DeviceHandle
);
typedef BOOL (__cdecl *USBDK_GET_CONFIGURATION_DESCRIPTOR)(
PUSB_DK_CONFIG_DESCRIPTOR_REQUEST Request,
PUSB_CONFIGURATION_DESCRIPTOR *Descriptor,
PULONG Length
);
typedef void (__cdecl *USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)(
PUSB_CONFIGURATION_DESCRIPTOR Descriptor
);
typedef TransferResult (__cdecl *USBDK_WRITE_PIPE)(
HANDLE DeviceHandle,
PUSB_DK_TRANSFER_REQUEST Request,
LPOVERLAPPED lpOverlapped
);
typedef TransferResult (__cdecl *USBDK_READ_PIPE)(
HANDLE DeviceHandle,
PUSB_DK_TRANSFER_REQUEST Request,
LPOVERLAPPED lpOverlapped
);
typedef BOOL (__cdecl *USBDK_ABORT_PIPE)(
HANDLE DeviceHandle,
ULONG64 PipeAddress
);
typedef BOOL (__cdecl *USBDK_RESET_PIPE)(
HANDLE DeviceHandle,
ULONG64 PipeAddress
);
typedef BOOL (__cdecl *USBDK_SET_ALTSETTING)(
HANDLE DeviceHandle,
ULONG64 InterfaceIdx,
ULONG64 AltSettingIdx
);
typedef BOOL (__cdecl *USBDK_RESET_DEVICE)(
HANDLE DeviceHandle
);
typedef HANDLE (__cdecl *USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)(
HANDLE DeviceHandle
);
#endif
includes/libusb-1.0.30/libusb/os/windows_winusb.c
+5478
View File
File diff suppressed because it is too large Load Diff
includes/libusb-1.0.30/libusb/os/windows_winusb.h
+792
View File
@@ -0,0 +1,792 @@
/*
* Windows backend for libusb 1.0
* Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
* With contributions from Michael Plante, Orin Eman et al.
* Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
* Major code testing contribution by Xiaofan Chen
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_WINDOWS_WINUSB_H
#define LIBUSB_WINDOWS_WINUSB_H
#include <devioctl.h>
#include <initguid.h>
#include <usbiodef.h>
#include "windows_common.h"
#define MAX_CTRL_BUFFER_LENGTH 4096
#define MAX_USB_STRING_LENGTH 128
#define MAX_HID_REPORT_SIZE 1024
#define MAX_HID_DESCRIPTOR_SIZE 256
#define MAX_GUID_STRING_LENGTH 39
#define MAX_PATH_LENGTH 256
#define MAX_KEY_LENGTH 256
#define LIST_SEPARATOR ';'
// Handle code for HID interface that have been claimed ("dibs")
#define INTERFACE_CLAIMED ((HANDLE)(intptr_t)0xD1B5)
// Additional return code for HID operations that completed synchronously
#define LIBUSB_COMPLETED (LIBUSB_SUCCESS + 1)
// libusb0 Filter Device Interface GUID
DEFINE_GUID(GUID_DEVINTERFACE_LIBUSB0_FILTER, 0xF9F3FF14, 0xAE21, 0x48A0, 0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9);
// The following define MUST be == sizeof(USB_DESCRIPTOR_REQUEST)
#define USB_DESCRIPTOR_REQUEST_SIZE 12U
/*
* Multiple USB API backend support
*/
#define USB_API_UNSUPPORTED 0
#define USB_API_HUB 1
#define USB_API_COMPOSITE 2
#define USB_API_WINUSBX 3
#define USB_API_HID 4
#define USB_API_MAX 5
// Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
// Must have the same values as the KUSB_DRVID enum from libusbk.h
#define SUB_API_NOTSET -1
#define SUB_API_LIBUSBK 0
#define SUB_API_LIBUSB0 1
#define SUB_API_WINUSB 2
#define SUB_API_MAX 3
struct windows_usb_api_backend {
const uint8_t id;
const char * const designation;
const char * const * const driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
const uint8_t nb_driver_names;
bool (*init)(struct libusb_context *ctx);
void (*exit)(void);
int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
int (*cancel_transfer)(int sub_api, struct usbi_transfer *itransfer);
enum libusb_transfer_status (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, DWORD length);
int (*endpoint_supports_raw_io)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t endpoint);
int (*endpoint_set_raw_io)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t endpoint, int enable);
int (*get_max_raw_io_transfer_size)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t endpoint);
};
extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
#define PRINT_UNSUPPORTED_API(fname) \
usbi_dbg(NULL, "unsupported API call for '%s' " \
"(unrecognized device driver)", #fname)
#define CHECK_SUPPORTED_API(apip, fname) \
do { \
if ((apip)->fname == NULL) { \
PRINT_UNSUPPORTED_API(fname); \
return LIBUSB_ERROR_NOT_SUPPORTED; \
} \
} while (0)
/*
* private structures definition
* with inline pseudo constructors/destructors
*/
// TODO (v2+): move hid desc to libusb.h?
struct libusb_hid_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bcdHID;
uint8_t bCountryCode;
uint8_t bNumDescriptors;
uint8_t bClassDescriptorType;
uint16_t wClassDescriptorLength;
};
#define LIBUSB_DT_HID_SIZE 9
#define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
+ LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
#define HID_MAX_REPORT_SIZE 1024
#define HID_IN_EP 0x81
#define HID_OUT_EP 0x02
#define LIBUSB_REQ_RECIPIENT(request_type) ((request_type) & 0x1F)
#define LIBUSB_REQ_TYPE(request_type) ((request_type) & (0x03 << 5))
#define LIBUSB_REQ_IN(request_type) ((request_type) & LIBUSB_ENDPOINT_IN)
#define LIBUSB_REQ_OUT(request_type) (!LIBUSB_REQ_IN(request_type))
// The following are used for HID reports IOCTLs
#define HID_IN_CTL_CODE(id) \
CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
#define HID_OUT_CTL_CODE(id) \
CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
#define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100)
#define IOCTL_HID_GET_INPUT_REPORT HID_OUT_CTL_CODE(104)
#define IOCTL_HID_SET_FEATURE HID_IN_CTL_CODE(100)
#define IOCTL_HID_SET_OUTPUT_REPORT HID_IN_CTL_CODE(101)
enum libusb_hid_request_type {
HID_REQ_GET_REPORT = 0x01,
HID_REQ_GET_IDLE = 0x02,
HID_REQ_GET_PROTOCOL = 0x03,
HID_REQ_SET_REPORT = 0x09,
HID_REQ_SET_IDLE = 0x0A,
HID_REQ_SET_PROTOCOL = 0x0B
};
enum libusb_hid_report_type {
HID_REPORT_TYPE_INPUT = 0x01,
HID_REPORT_TYPE_OUTPUT = 0x02,
HID_REPORT_TYPE_FEATURE = 0x03
};
struct hid_device_priv {
uint16_t vid;
uint16_t pid;
uint8_t config;
uint8_t nb_interfaces;
bool uses_report_ids[3]; // input, ouptput, feature
uint16_t input_report_size;
uint16_t output_report_size;
uint16_t feature_report_size;
uint16_t usage;
uint16_t usagePage;
WCHAR string[3][MAX_USB_STRING_LENGTH];
uint8_t string_index[3]; // man, prod, ser
};
static inline struct winusb_device_priv *winusb_device_priv_init(struct libusb_device *dev)
{
struct winusb_device_priv *priv = usbi_get_device_priv(dev);
int i;
usbi_mutex_init(&priv->interface_lock);
priv->apib = &usb_api_backend[USB_API_UNSUPPORTED];
priv->sub_api = SUB_API_NOTSET;
for (i = 0; i < USB_MAXINTERFACES; i++) {
priv->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
priv->usb_interface[i].sub_api = SUB_API_NOTSET;
}
return priv;
}
static inline void winusb_device_priv_release(struct libusb_device *dev)
{
struct winusb_device_priv *priv = usbi_get_device_priv(dev);
int i;
free(priv->dev_id);
free(priv->path);
if ((dev->device_descriptor.bNumConfigurations > 0) && (priv->config_descriptor != NULL)) {
for (i = 0; i < dev->device_descriptor.bNumConfigurations; i++) {
if (priv->config_descriptor[i] == NULL)
continue;
free((UCHAR *)priv->config_descriptor[i] - USB_DESCRIPTOR_REQUEST_SIZE);
}
}
free(priv->config_descriptor);
free(priv->hid);
for (i = 0; i < USB_MAXINTERFACES; i++) {
free(priv->usb_interface[i].path);
free(priv->usb_interface[i].endpoint);
}
usbi_mutex_destroy(&priv->interface_lock);
}
// used to match a device driver (including filter drivers) against a supported API
struct driver_lookup {
char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names
const DWORD reg_prop; // SPDRP registry key to use to retrieve list
const char *designation; // internal designation (for debug output)
};
/*
* Windows DDK API definitions. Most of it copied from MinGW's includes
*/
typedef DWORD DEVNODE, DEVINST;
typedef DEVNODE *PDEVNODE, *PDEVINST;
typedef DWORD RETURN_TYPE;
typedef RETURN_TYPE CONFIGRET;
#define CR_SUCCESS 0x00000000
/* Cfgmgr32 dependencies */
DLL_DECLARE_HANDLE(Cfgmgr32);
DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
/* AdvAPI32 dependencies */
DLL_DECLARE_HANDLE(AdvAPI32);
DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExA, (HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
/* SetupAPI dependencies */
DLL_DECLARE_HANDLE(SetupAPI);
DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (LPCGUID, PCSTR, HWND, DWORD));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
LPCGUID, DWORD, PSP_DEVICE_INTERFACE_DATA));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInstanceIdA, (HDEVINFO, PSP_DEVINFO_DATA,
PCSTR, DWORD, PDWORD));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
#define FILE_DEVICE_USB FILE_DEVICE_UNKNOWN
#define USB_GET_NODE_INFORMATION 258
#define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260
#define USB_GET_NODE_CONNECTION_INFORMATION_EX 274
#define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 279
#define USB_CTL_CODE(id) \
CTL_CODE(FILE_DEVICE_USB, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_USB_GET_NODE_INFORMATION \
USB_CTL_CODE(USB_GET_NODE_INFORMATION)
#define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
USB_CTL_CODE(USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION)
#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX)
#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 \
USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2)
typedef enum _USB_CONNECTION_STATUS {
NoDeviceConnected,
DeviceConnected,
DeviceFailedEnumeration,
DeviceGeneralFailure,
DeviceCausedOvercurrent,
DeviceNotEnoughPower,
DeviceNotEnoughBandwidth,
DeviceHubNestedTooDeeply,
DeviceInLegacyHub,
DeviceEnumerating,
DeviceReset
} USB_CONNECTION_STATUS;
typedef enum _USB_DEVICE_SPEED {
UsbLowSpeed = 0,
UsbFullSpeed,
UsbHighSpeed,
UsbSuperSpeed,
UsbSuperSpeedPlus // Not in Microsoft headers
} USB_DEVICE_SPEED;
typedef enum _USB_HUB_NODE {
UsbHub,
UsbMIParent
} USB_HUB_NODE;
#if defined(_MSC_VER)
// disable /W4 MSVC warnings that are benign
#pragma warning(push)
#pragma warning(disable:4214) // bit field types other than int
#endif
// Most of the structures below need to be packed
#pragma pack(push, 1)
typedef struct _USB_HUB_DESCRIPTOR {
UCHAR bDescriptorLength;
UCHAR bDescriptorType;
UCHAR bNumberOfPorts;
USHORT wHubCharacteristics;
UCHAR bPowerOnToPowerGood;
UCHAR bHubControlCurrent;
UCHAR bRemoveAndPowerMask[64];
} USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
typedef struct _USB_HUB_INFORMATION {
USB_HUB_DESCRIPTOR HubDescriptor;
BOOLEAN HubIsBusPowered;
} USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
typedef struct _USB_NODE_INFORMATION {
USB_HUB_NODE NodeType;
union {
USB_HUB_INFORMATION HubInformation;
// USB_MI_PARENT_INFORMATION MiParentInformation;
} u;
} USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
typedef struct _USB_DESCRIPTOR_REQUEST {
ULONG ConnectionIndex;
struct {
UCHAR bmRequest;
UCHAR bRequest;
USHORT wValue;
USHORT wIndex;
USHORT wLength;
} SetupPacket;
// UCHAR Data[0];
} USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
USB_DESCRIPTOR_REQUEST req;
USB_CONFIGURATION_DESCRIPTOR desc;
} USB_CONFIGURATION_DESCRIPTOR_SHORT;
typedef struct USB_INTERFACE_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
UCHAR bInterfaceNumber;
UCHAR bAlternateSetting;
UCHAR bNumEndpoints;
UCHAR bInterfaceClass;
UCHAR bInterfaceSubClass;
UCHAR bInterfaceProtocol;
UCHAR iInterface;
} USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {
ULONG ConnectionIndex;
USB_DEVICE_DESCRIPTOR DeviceDescriptor;
UCHAR CurrentConfigurationValue;
UCHAR Speed;
BOOLEAN DeviceIsHub;
USHORT DeviceAddress;
ULONG NumberOfOpenPipes;
USB_CONNECTION_STATUS ConnectionStatus;
// USB_PIPE_INFO PipeList[0];
} USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
typedef union _USB_PROTOCOLS {
ULONG ul;
struct {
ULONG Usb110:1;
ULONG Usb200:1;
ULONG Usb300:1;
ULONG ReservedMBZ:29;
};
} USB_PROTOCOLS, *PUSB_PROTOCOLS;
typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS {
ULONG ul;
struct {
ULONG DeviceIsOperatingAtSuperSpeedOrHigher:1;
ULONG DeviceIsSuperSpeedCapableOrHigher:1;
ULONG DeviceIsOperatingAtSuperSpeedPlusOrHigher:1;
ULONG DeviceIsSuperSpeedPlusCapableOrHigher:1;
ULONG ReservedMBZ:28;
};
} USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS;
typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 {
ULONG ConnectionIndex;
ULONG Length;
USB_PROTOCOLS SupportedUsbProtocols;
USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags;
} USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2;
#pragma pack(pop)
#if defined(_MSC_VER)
// Restore original warnings
#pragma warning(pop)
#endif
/* winusb.dll interface */
/* pipe policies */
#define SHORT_PACKET_TERMINATE 0x01
#define AUTO_CLEAR_STALL 0x02
#define PIPE_TRANSFER_TIMEOUT 0x03
#define IGNORE_SHORT_PACKETS 0x04
#define ALLOW_PARTIAL_READS 0x05
#define AUTO_FLUSH 0x06
#define RAW_IO 0x07
#define MAXIMUM_TRANSFER_SIZE 0x08
/* libusbK */
#define ISO_ALWAYS_START_ASAP 0x21
typedef struct _USBD_ISO_PACKET_DESCRIPTOR {
ULONG Offset;
ULONG Length;
USBD_STATUS Status;
} USBD_ISO_PACKET_DESCRIPTOR, *PUSBD_ISO_PACKET_DESCRIPTOR;
typedef enum _USBD_PIPE_TYPE {
UsbdPipeTypeControl,
UsbdPipeTypeIsochronous,
UsbdPipeTypeBulk,
UsbdPipeTypeInterrupt
} USBD_PIPE_TYPE;
typedef struct {
USBD_PIPE_TYPE PipeType;
UCHAR PipeId;
USHORT MaximumPacketSize;
UCHAR Interval;
ULONG MaximumBytesPerInterval;
} WINUSB_PIPE_INFORMATION_EX, *PWINUSB_PIPE_INFORMATION_EX;
#pragma pack(push, 1)
typedef struct _WINUSB_SETUP_PACKET {
UCHAR RequestType;
UCHAR Request;
USHORT Value;
USHORT Index;
USHORT Length;
} WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
#pragma pack(pop)
typedef PVOID WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
typedef PVOID WINUSB_ISOCH_BUFFER_HANDLE, *PWINUSB_ISOCH_BUFFER_HANDLE;
typedef BOOL (WINAPI *WinUsb_AbortPipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID
);
typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
WINUSB_SETUP_PACKET SetupPacket,
PUCHAR Buffer,
ULONG BufferLength,
PULONG LengthTransferred,
LPOVERLAPPED Overlapped
);
typedef BOOL (WINAPI *WinUsb_FlushPipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID
);
typedef BOOL (WINAPI *WinUsb_Free_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle
);
typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR AssociatedInterfaceIndex,
PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle
);
typedef BOOL (WINAPI *WinUsb_Initialize_t)(
HANDLE DeviceHandle,
PWINUSB_INTERFACE_HANDLE InterfaceHandle
);
typedef BOOL (WINAPI *WinUsb_QueryPipeEx_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR AlternateInterfaceHandle,
UCHAR PipeIndex,
PWINUSB_PIPE_INFORMATION_EX PipeInformationEx
);
typedef BOOL (WINAPI *WinUsb_ReadIsochPipeAsap_t)(
PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle,
ULONG Offset,
ULONG Length,
BOOL ContinueStream,
ULONG NumberOfPackets,
PUSBD_ISO_PACKET_DESCRIPTOR IsoPacketDescriptors,
LPOVERLAPPED Overlapped
);
typedef BOOL (WINAPI *WinUsb_ReadPipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
PUCHAR Buffer,
ULONG BufferLength,
PULONG LengthTransferred,
LPOVERLAPPED Overlapped
);
typedef BOOL (WINAPI *WinUsb_RegisterIsochBuffer_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
PVOID Buffer,
ULONG BufferLength,
PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle
);
typedef BOOL (WINAPI *WinUsb_ResetPipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID
);
typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR AlternateSetting
);
typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
ULONG PolicyType,
ULONG ValueLength,
PVOID Value
);
typedef BOOL (WINAPI *WinUsb_GetPipePolicy_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
ULONG PolicyType,
PULONG ValueLength,
PVOID Value
);
typedef BOOL (WINAPI *WinUsb_UnregisterIsochBuffer_t)(
WINUSB_ISOCH_BUFFER_HANDLE BufferHandle
);
typedef BOOL (WINAPI *WinUsb_WriteIsochPipeAsap_t)(
WINUSB_ISOCH_BUFFER_HANDLE BufferHandle,
ULONG Offset,
ULONG Length,
BOOL ContinueStream,
LPOVERLAPPED Overlapped
);
typedef BOOL (WINAPI *WinUsb_WritePipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
PUCHAR Buffer,
ULONG BufferLength,
PULONG LengthTransferred,
LPOVERLAPPED Overlapped
);
/* /!\ These must match the ones from the official libusbk.h */
typedef enum _KUSB_FNID {
KUSB_FNID_Init,
KUSB_FNID_Free,
KUSB_FNID_ClaimInterface,
KUSB_FNID_ReleaseInterface,
KUSB_FNID_SetAltInterface,
KUSB_FNID_GetAltInterface,
KUSB_FNID_GetDescriptor,
KUSB_FNID_ControlTransfer,
KUSB_FNID_SetPowerPolicy,
KUSB_FNID_GetPowerPolicy,
KUSB_FNID_SetConfiguration,
KUSB_FNID_GetConfiguration,
KUSB_FNID_ResetDevice,
KUSB_FNID_Initialize,
KUSB_FNID_SelectInterface,
KUSB_FNID_GetAssociatedInterface,
KUSB_FNID_Clone,
KUSB_FNID_QueryInterfaceSettings,
KUSB_FNID_QueryDeviceInformation,
KUSB_FNID_SetCurrentAlternateSetting,
KUSB_FNID_GetCurrentAlternateSetting,
KUSB_FNID_QueryPipe,
KUSB_FNID_SetPipePolicy,
KUSB_FNID_GetPipePolicy,
KUSB_FNID_ReadPipe,
KUSB_FNID_WritePipe,
KUSB_FNID_ResetPipe,
KUSB_FNID_AbortPipe,
KUSB_FNID_FlushPipe,
KUSB_FNID_IsoReadPipe,
KUSB_FNID_IsoWritePipe,
KUSB_FNID_GetCurrentFrameNumber,
KUSB_FNID_GetOverlappedResult,
KUSB_FNID_GetProperty,
KUSB_FNID_COUNT,
} KUSB_FNID;
typedef struct _KLIB_VERSION {
INT Major;
INT Minor;
INT Micro;
INT Nano;
} KLIB_VERSION, *PKLIB_VERSION;
typedef BOOL (WINAPI *LibK_GetProcAddress_t)(
PVOID ProcAddress,
INT DriverID,
INT FunctionID
);
typedef VOID (WINAPI *LibK_GetVersion_t)(
PKLIB_VERSION Version
);
typedef BOOL (WINAPI *LibK_ResetDevice_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle
);
//KISO_PACKET is equivalent of libusb_iso_packet_descriptor except uses absolute "offset" field instead of sequential Lengths
typedef struct _KISO_PACKET {
UINT offset;
USHORT actual_length; //changed from libusbk_shared.h "Length" for clarity
USHORT status;
} KISO_PACKET, *PKISO_PACKET;
typedef enum _KISO_FLAG {
KISO_FLAG_NONE = 0,
KISO_FLAG_SET_START_FRAME = 0x00000001,
} KISO_FLAG;
//KISO_CONTEXT is the conceptual equivalent of libusb_transfer except is isochronous-specific and must match libusbk's version
typedef struct _KISO_CONTEXT {
KISO_FLAG Flags;
UINT StartFrame;
SHORT ErrorCount;
SHORT NumberOfPackets;
UINT UrbHdrStatus;
KISO_PACKET IsoPackets[0];
} KISO_CONTEXT, *PKISO_CONTEXT;
typedef BOOL(WINAPI *LibK_IsoReadPipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
PUCHAR Buffer,
ULONG BufferLength,
LPOVERLAPPED Overlapped,
PKISO_CONTEXT IsoContext
);
typedef BOOL(WINAPI *LibK_IsoWritePipe_t)(
WINUSB_INTERFACE_HANDLE InterfaceHandle,
UCHAR PipeID,
PUCHAR Buffer,
ULONG BufferLength,
LPOVERLAPPED Overlapped,
PKISO_CONTEXT IsoContext
);
struct winusb_interface {
HMODULE hDll;
WinUsb_AbortPipe_t AbortPipe;
WinUsb_ControlTransfer_t ControlTransfer;
WinUsb_FlushPipe_t FlushPipe;
WinUsb_Free_t Free;
WinUsb_GetAssociatedInterface_t GetAssociatedInterface;
WinUsb_Initialize_t Initialize;
WinUsb_ReadPipe_t ReadPipe;
WinUsb_ResetPipe_t ResetPipe;
WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
WinUsb_SetPipePolicy_t SetPipePolicy;
WinUsb_GetPipePolicy_t GetPipePolicy;
WinUsb_WritePipe_t WritePipe;
union {
struct {
// Isochoronous functions for libusbK sub api:
LibK_IsoReadPipe_t IsoReadPipe;
LibK_IsoWritePipe_t IsoWritePipe;
// Reset device function for libusbK sub api:
LibK_ResetDevice_t ResetDevice;
};
struct {
// Isochronous functions for WinUSB sub api:
WinUsb_QueryPipeEx_t QueryPipeEx;
WinUsb_ReadIsochPipeAsap_t ReadIsochPipeAsap;
WinUsb_RegisterIsochBuffer_t RegisterIsochBuffer;
WinUsb_UnregisterIsochBuffer_t UnregisterIsochBuffer;
WinUsb_WriteIsochPipeAsap_t WriteIsochPipeAsap;
};
};
};
/* hid.dll interface */
#define HIDP_STATUS_SUCCESS 0x110000
typedef void * PHIDP_PREPARSED_DATA;
#pragma pack(push, 1)
typedef struct _HIDD_ATTIRBUTES {
ULONG Size;
USHORT VendorID;
USHORT ProductID;
USHORT VersionNumber;
} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
#pragma pack(pop)
typedef USHORT USAGE;
typedef struct _HIDP_CAPS {
USAGE Usage;
USAGE UsagePage;
USHORT InputReportByteLength;
USHORT OutputReportByteLength;
USHORT FeatureReportByteLength;
USHORT Reserved[17];
USHORT NumberLinkCollectionNodes;
USHORT NumberInputButtonCaps;
USHORT NumberInputValueCaps;
USHORT NumberInputDataIndices;
USHORT NumberOutputButtonCaps;
USHORT NumberOutputValueCaps;
USHORT NumberOutputDataIndices;
USHORT NumberFeatureButtonCaps;
USHORT NumberFeatureValueCaps;
USHORT NumberFeatureDataIndices;
} HIDP_CAPS, *PHIDP_CAPS;
typedef enum _HIDP_REPORT_TYPE {
HidP_Input,
HidP_Output,
HidP_Feature
} HIDP_REPORT_TYPE;
typedef struct _HIDP_VALUE_CAPS {
USAGE UsagePage;
UCHAR ReportID;
BOOLEAN IsAlias;
USHORT BitField;
USHORT LinkCollection;
USAGE LinkUsage;
USAGE LinkUsagePage;
BOOLEAN IsRange;
BOOLEAN IsStringRange;
BOOLEAN IsDesignatorRange;
BOOLEAN IsAbsolute;
BOOLEAN HasNull;
UCHAR Reserved;
USHORT BitSize;
USHORT ReportCount;
USHORT Reserved2[5];
ULONG UnitsExp;
ULONG Units;
LONG LogicalMin, LogicalMax;
LONG PhysicalMin, PhysicalMax;
union {
struct {
USAGE UsageMin, UsageMax;
USHORT StringMin, StringMax;
USHORT DesignatorMin, DesignatorMax;
USHORT DataIndexMin, DataIndexMax;
} Range;
struct {
USAGE Usage, Reserved1;
USHORT StringIndex, Reserved2;
USHORT DesignatorIndex, Reserved3;
USHORT DataIndex, Reserved4;
} NotRange;
} u;
} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
DLL_DECLARE_HANDLE(hid);
DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetIndexedString, (HANDLE, ULONG, PVOID, ULONG));
DLL_DECLARE_FUNC(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));
#endif