summaryrefslogtreecommitdiff
path: root/libusb
diff options
context:
space:
mode:
authorPeter Stuge <peter@stuge.se>2010-03-18 12:44:55 +0000
committerPeter Stuge <peter@stuge.se>2010-03-18 12:44:55 +0000
commitf43d8e65dba4e71b3113d094881cf52f64e7d646 (patch)
tree312093eb8aa80857cea8034727ad688a13577ee7 /libusb
parentb7d9c71fb3c15f1943ec9794504a43f9771e9389 (diff)
downloadlibusb-f43d8e65dba4e71b3113d094881cf52f64e7d646.tar.gz
removed trailing whitespaces (Windows backend)r214b
Diffstat (limited to 'libusb')
-rw-r--r--libusb/os/poll_windows.c32
-rw-r--r--libusb/os/windows_usb.c342
-rw-r--r--libusb/os/windows_usb.h14
3 files changed, 194 insertions, 194 deletions
diff --git a/libusb/os/poll_windows.c b/libusb/os/poll_windows.c
index a7072b2..4497cc6 100644
--- a/libusb/os/poll_windows.c
+++ b/libusb/os/poll_windows.c
@@ -25,7 +25,7 @@
*
* The way this layer works is by using OVERLAPPED with async I/O transfers, as
* OVERLAPPED have an associated event which is flagged for I/O completion.
- *
+ *
* For USB pollable async I/O, you would typically:
* - obtain a Windows HANDLE to a file or device that has been opened in
* OVERLAPPED mode
@@ -34,7 +34,7 @@
* twice, once in _O_RDONLY and once in _O_WRONLY mode to obtain 2 separate
* pollable fds
* - leave the core functions call the poll routine and flag POLLIN/POLLOUT
- *
+ *
* The pipe pollable synchronous I/O works using the overlapped event associated
* with a fake pipe. The read/write functions are only meant to be used in that
* context.
@@ -69,7 +69,7 @@
// cygwin produces a warning unless these prototypes are defined
extern int _close(int fd);
extern int _snprintf(char *buffer, size_t count, const char *format, ...);
-extern int cygwin_attach_handle_to_fd(char *name, int fd, HANDLE handle, int bin, int access);
+extern int cygwin_attach_handle_to_fd(char *name, int fd, HANDLE handle, int bin, int access);
// _open_osfhandle() is not available on cygwin, but we can emulate
// it for our needs with cygwin_attach_handle_to_fd()
static inline int _open_osfhandle(intptr_t osfhandle, int flags)
@@ -119,7 +119,7 @@ LONG pipe_number = 0;
static volatile LONG compat_spinlock = 0;
// CancelIoEx, available on Vista and later only, provides the ability to cancel
-// a single transfer (OVERLAPPED) when used. As it may not be part of any of the
+// a single transfer (OVERLAPPED) when used. As it may not be part of any of the
// platform headers, we hook into the Kernel32 system DLL directly to seek it.
static BOOL (__stdcall *pCancelIoEx)(HANDLE, LPOVERLAPPED) = NULL;
#define CancelIoEx_Available (pCancelIoEx != NULL)
@@ -154,7 +154,7 @@ void init_polling(void)
if (!is_polling_set) {
pCancelIoEx = (BOOL (__stdcall *)(HANDLE,LPOVERLAPPED))
GetProcAddress(GetModuleHandle("KERNEL32"), "CancelIoEx");
- usbi_dbg("Will use CancelIo%s for I/O cancellation",
+ usbi_dbg("Will use CancelIo%s for I/O cancellation",
CancelIoEx_Available?"Ex":"");
for (i=0; i<MAX_FDS; i++) {
poll_fd[i] = INVALID_WINFD;
@@ -200,7 +200,7 @@ int _fd_to_index_and_lock(int fd)
return -1;
}
-OVERLAPPED *create_overlapped(void)
+OVERLAPPED *create_overlapped(void)
{
OVERLAPPED *overlapped = calloc(1, sizeof(OVERLAPPED));
if (overlapped == NULL) {
@@ -219,7 +219,7 @@ void free_overlapped(OVERLAPPED *overlapped)
if (overlapped == NULL)
return;
- if ( (overlapped->hEvent != 0)
+ if ( (overlapped->hEvent != 0)
&& (overlapped->hEvent != INVALID_HANDLE_VALUE) ) {
CloseHandle(overlapped->hEvent);
}
@@ -371,14 +371,14 @@ out0:
}
/*
- * Create both an fd and an OVERLAPPED from an open Windows handle, so that
+ * Create both an fd and an OVERLAPPED from an open Windows handle, so that
* it can be used with our polling function
* The handle MUST support overlapped transfers (usually requires CreateFile
* with FILE_FLAG_OVERLAPPED)
* Return a pollable file descriptor struct, or INVALID_WINFD on error
*
* Note that the fd returned by this function is a per-transfer fd, rather
- * than a per-session fd and cannot be used for anything else but our
+ * than a per-session fd and cannot be used for anything else but our
* custom functions (the fd itself points to the NUL: device)
* if you plan to do R/W on the same handle, you MUST create 2 fds: one for
* read and one for write. Using a single R/W fd is unsupported and will
@@ -485,7 +485,7 @@ void _free_index(int index)
}
/*
- * Release a pollable file descriptor.
+ * Release a pollable file descriptor.
*
* Note that the associated Windows handle is not closed by this call
*/
@@ -603,13 +603,13 @@ int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
unsigned j;
// To address the possibility of missing new fds between the time the new
- // pollable fd set is assembled, and the ResetEvent() call below, an
+ // pollable fd set is assembled, and the ResetEvent() call below, an
// additional new_fd[] HANDLE table is used for any new fd that was created
// since the last call to poll (see below)
ResetEvent(fd_update);
// At this stage, any new fd creation will be detected through the fd_update
- // event notification, and any previous creation that we may have missed
+ // event notification, and any previous creation that we may have missed
// will be picked up through the existing new_fd[] table.
#endif
@@ -667,7 +667,7 @@ int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
triggered = -1;
goto poll_exit;
}
-
+
poll_dbg("fd[%d]=%d (overlapped = %p) got events %04X", i, poll_fd[index].fd, poll_fd[index].overlapped, fds[i].events);
// The following macro only works if overlapped I/O was reported pending
@@ -700,7 +700,7 @@ int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
// have been added since the last call to poll, but are not (yet) part
// of the pollable fd set. Typically, these would be from fds that have
// been created between the construction of the fd set and the calling
- // of poll.
+ // of poll.
// Event if we won't be able to return usable poll data on these events,
// make sure we monitor them to return an EINTR code
usbi_mutex_lock(&new_fd_mutex); // We could probably do without
@@ -726,7 +726,7 @@ int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
} else {
poll_dbg("starting %d ms wait for %d handles...", timeout, (int)nb_handles_to_wait_on);
}
- ret = WaitForMultipleObjects(nb_handles_to_wait_on, handles_to_wait_on,
+ ret = WaitForMultipleObjects(nb_handles_to_wait_on, handles_to_wait_on,
FALSE, (timeout<0)?INFINITE:(DWORD)timeout);
object_index = ret-WAIT_OBJECT_0;
if ((object_index >= 0) && ((DWORD)object_index < nb_handles_to_wait_on)) {
@@ -820,7 +820,7 @@ ssize_t usbi_write(int fd, const void *buf, size_t count)
index = _fd_to_index_and_lock(fd);
- if ( (index < 0) || (poll_fd[index].overlapped == NULL)
+ if ( (index < 0) || (poll_fd[index].overlapped == NULL)
|| (poll_fd[index].rw != RW_WRITE) ) {
errno = EBADF;
if (index >= 0) {
diff --git a/libusb/os/windows_usb.c b/libusb/os/windows_usb.c
index e21a984..1e66f96 100644
--- a/libusb/os/windows_usb.c
+++ b/libusb/os/windows_usb.c
@@ -22,8 +22,8 @@
// COMPILATION OPTIONS:
// - Use HidD_(G/S)et(In/Out)putReport instead of (Read/Write)File for HID
-// Note that http://msdn.microsoft.com/en-us/library/ms789883.aspx:
-// "In addition, some devices might not support HidD_GetInputReport,
+// Note that http://msdn.microsoft.com/en-us/library/ms789883.aspx:
+// "In addition, some devices might not support HidD_GetInputReport,
// and will become unresponsive if this routine is used."
// => Don't blame libusb if you can't read or write HID reports when the
// option below is enabled.
@@ -56,7 +56,7 @@
// The 2 macros below are used in conjunction with safe loops.
#define LOOP_CHECK(fcall) { r=fcall; if (r != LIBUSB_SUCCESS) continue; }
-#define LOOP_BREAK(err) { r=err; continue; }
+#define LOOP_BREAK(err) { r=err; continue; }
extern void usbi_fd_notification(struct libusb_context *ctx);
@@ -118,7 +118,7 @@ const uint64_t epoch_time = UINT64_C(116444736000000000); // 1970.01.01 00:00:00
enum windows_version windows_version = WINDOWS_UNSUPPORTED;
// Concurrency
static int concurrent_usage = -1;
-// Timer thread
+// Timer thread
// NB: index 0 is for monotonic and 1 is for the thread exit event
HANDLE timer_thread = NULL;
HANDLE timer_mutex = NULL;
@@ -169,9 +169,9 @@ static inline BOOLEAN guid_eq(const GUID *guid1, const GUID *guid2) {
static char* guid_to_string(const GUID guid)
{
static char guid_string[MAX_GUID_STRING_LENGTH];
-
+
sprintf(guid_string, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
- (unsigned int)guid.Data1, guid.Data2, guid.Data3,
+ (unsigned int)guid.Data1, guid.Data2, guid.Data3,
guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
return guid_string;
@@ -226,13 +226,13 @@ static char* sanitize_path(const char* path)
root_size = sizeof(root_prefix)-1;
// Microsoft indiscriminatly uses '\\?\', '\\.\', '##?#" or "##.#" for root prefixes.
- if (!((size > 3) && (((path[0] == '\\') && (path[1] == '\\') && (path[3] == '\\')) ||
+ if (!((size > 3) && (((path[0] == '\\') && (path[1] == '\\') && (path[3] == '\\')) ||
((path[0] == '#') && (path[1] == '#') && (path[3] == '#'))))) {
add_root = root_size;
size += add_root;
}
- if ((ret_path = (char*)calloc(size, 1)) == NULL)
+ if ((ret_path = (char*)calloc(size, 1)) == NULL)
return NULL;
safe_strncpy(&ret_path[add_root], size-add_root, path, strlen(path));
@@ -259,7 +259,7 @@ static int Cfgmgr32_init(void)
DLL_LOAD(Cfgmgr32.dll, CM_Get_Parent, TRUE);
DLL_LOAD(Cfgmgr32.dll, CM_Get_Child, TRUE);
DLL_LOAD(Cfgmgr32.dll, CM_Get_Sibling, TRUE);
- DLL_LOAD(Cfgmgr32.dll, CM_Get_Device_IDA, TRUE);
+ DLL_LOAD(Cfgmgr32.dll, CM_Get_Device_IDA, TRUE);
DLL_LOAD(Cfgmgr32.dll, CM_Get_Device_IDW, TRUE);
return LIBUSB_SUCCESS;
@@ -275,10 +275,10 @@ static int Cfgmgr32_init(void)
* index: zero based index of the interface in the device info list
*
* Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
- * structure returned and call this function repeatedly using the same guid (with an
+ * structure returned and call this function repeatedly using the same guid (with an
* incremented index starting at zero) until all interfaces have been returned.
*/
-SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ctx,
+SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ctx,
HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, GUID guid, unsigned index)
{
SP_DEVICE_INTERFACE_DATA dev_interface_data;
@@ -296,7 +296,7 @@ SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ct
dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiEnumDeviceInfo(*dev_info, index, dev_info_data)) {
if (GetLastError() != ERROR_NO_MORE_ITEMS) {
- usbi_err(ctx, "Could not obtain device info data for index %u: %s",
+ usbi_err(ctx, "Could not obtain device info data for index %u: %s",
index, windows_error_str(0));
}
SetupDiDestroyDeviceInfoList(*dev_info);
@@ -308,7 +308,7 @@ SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ct
dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(*dev_info, NULL, &guid, index, &dev_interface_data)) {
if (GetLastError() != ERROR_NO_MORE_ITEMS) {
- usbi_err(ctx, "Could not obtain interface data for index %u: %s",
+ usbi_err(ctx, "Could not obtain interface data for index %u: %s",
index, windows_error_str(0));
}
SetupDiDestroyDeviceInfoList(*dev_info);
@@ -320,11 +320,11 @@ SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ct
if (!SetupDiGetDeviceInterfaceDetail(*dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
// The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
- usbi_err(ctx, "could not access interface data (dummy) for index %u: %s",
+ usbi_err(ctx, "could not access interface data (dummy) for index %u: %s",
index, windows_error_str(0));
goto err_exit;
}
- }
+ }
else {
usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong.");
goto err_exit;
@@ -335,10 +335,10 @@ SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ct
goto err_exit;
}
- dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
- if (!SetupDiGetDeviceInterfaceDetail(*dev_info, &dev_interface_data,
+ dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+ if (!SetupDiGetDeviceInterfaceDetail(*dev_info, &dev_interface_data,
dev_interface_details, size, &size, NULL)) {
- usbi_err(ctx, "could not access interface data (actual) for index %u: %s",
+ usbi_err(ctx, "could not access interface data (actual) for index %u: %s",
index, windows_error_str(0));
}
@@ -371,7 +371,7 @@ static void windows_assign_endpoints(struct libusb_device *dev, int iface, int a
usbi_dbg("(re)assigned endpoint %02X to interface %d", priv->usb_interface[iface].endpoint[i], iface);
}
}
- libusb_free_config_descriptor(conf_desc);
+ libusb_free_config_descriptor(conf_desc);
}
}
@@ -420,7 +420,7 @@ static int windows_init(struct libusb_context *ctx)
CloseHandle(semaphore);
return LIBUSB_ERROR_OTHER;
}
-
+
// NB: concurrent usage supposes that init calls are equally balanced with
// exit calls. If init is called more than exit, we will not exit properly
if ( ++concurrent_usage == 0 ) { // First init?
@@ -460,7 +460,7 @@ static int windows_init(struct libusb_context *ctx)
}
}
- // Because QueryPerformanceCounter might report different values when
+ // Because QueryPerformanceCounter might report different values when
// running on different cores, we create a separate thread for the timer
// calls, which we glue to the first core always to prevent timing discrepancies.
r = LIBUSB_ERROR_NO_MEM;
@@ -524,7 +524,7 @@ static int windows_init(struct libusb_context *ctx)
if (hcd_root == NULL)
r = LIBUSB_ERROR_NO_DEVICE;
- else
+ else
r = LIBUSB_SUCCESS;
init_exit: // Holds semaphore here.
@@ -533,7 +533,7 @@ init_exit: // Holds semaphore here.
SetEvent(timer_request[1]); // actually the signal to quit the thread.
if (WAIT_OBJECT_0 != WaitForSingleObject(timer_thread, INFINITE)) {
usbi_warn(ctx, "could not wait for timer thread to quit");
- TerminateThread(timer_thread, 1); // shouldn't happen, but we're destroying
+ TerminateThread(timer_thread, 1); // shouldn't happen, but we're destroying
// all objects it might have held anyway.
}
CloseHandle(timer_thread);
@@ -565,7 +565,7 @@ init_exit: // Holds semaphore here.
/*
* Initialize device structure, including active config
- */
+ */
static int initialize_device(struct libusb_device *dev, libusb_bus_t busnum,
libusb_devaddr_t devaddr, char *path, int connection_index, uint8_t active_config,
struct libusb_device *parent_dev)
@@ -602,7 +602,7 @@ static int initialize_device(struct libusb_device *dev, libusb_bus_t busnum,
* Note that we follow the Linux convention and use the "Linux Foundation root hub"
* vendor ID as well as the product ID to indicate the hub speed
*/
-static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
+static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
{
DWORD size;
USB_HUB_CAPABILITIES hub_caps;
@@ -619,7 +619,7 @@ static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
priv->dev_descriptor.idVendor = 0x1d6b; // Linux Foundation root hub
if (windows_version >= WINDOWS_VISTA_AND_LATER) {
size = sizeof(USB_HUB_CAPABILITIES_EX);
- if (DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES_EX, &hub_caps_ex,
+ if (DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES_EX, &hub_caps_ex,
size, &hub_caps_ex, size, &size, NULL)) {
// Sanity check. HCD hub should always be root
if (!hub_caps_ex.CapabilityFlags.HubIsRoot) {
@@ -629,9 +629,9 @@ static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
}
} else {
size = sizeof(USB_HUB_CAPABILITIES);
- if (!DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES, &hub_caps,
+ if (!DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES, &hub_caps,
size, &hub_caps, size, &size, NULL)) {
- usbi_warn(ctx, "could not read hub capabilities (std) for hub %s: %s",
+ usbi_warn(ctx, "could not read hub capabilities (std) for hub %s: %s",
priv->path, windows_error_str(0));
priv->dev_descriptor.idProduct = 1; // Indicate 1x speed
} else {
@@ -645,7 +645,7 @@ static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
/*
* fetch and cache all the config descriptors through I/O
*/
-static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle)
+static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle)
{
DWORD size, ret_size;
struct libusb_context *ctx = DEVICE_CTX(dev);
@@ -666,12 +666,12 @@ static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle
for (i=0; i<dev->num_configurations; i++)
priv->config_descriptor[i] = NULL;
- for (i=0, r=LIBUSB_SUCCESS; ; i++)
+ for (i=0, r=LIBUSB_SUCCESS; ; i++)
{
// safe loop: release all dynamic resources
safe_free(cd_buf_actual);
- // safe loop: end of loop condition
+ // safe loop: end of loop condition
if ((i >= dev->num_configurations) || (r != LIBUSB_SUCCESS))
break;
@@ -731,7 +731,7 @@ static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle
}
usbi_dbg("cached config descriptor #%d (%d bytes)", i+1, cd_data->wTotalLength);
-
+
// Sanity check. Ensures that indexes for our list of config desc is in the right order
if (i != (cd_data->bConfigurationValue-1)) {
usbi_warn(ctx, "program assertion failed - config descriptors are being read out of order");
@@ -751,8 +751,8 @@ static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle
/*
* Recursively enumerates and finds all hubs & devices
*/
-static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs **_discdevs,
- HANDLE hub_handle, libusb_bus_t busnum, struct libusb_device *parent_dev, uint8_t nb_ports)
+static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs **_discdevs,
+ HANDLE hub_handle, libusb_bus_t busnum, struct libusb_device *parent_dev, uint8_t nb_ports)
{
struct discovered_devs *discdevs = *_discdevs;
struct libusb_device *dev = NULL;
@@ -761,7 +761,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
USB_HUB_NAME_FIXED s_hubname;
USB_NODE_CONNECTION_INFORMATION conn_info;
USB_NODE_INFORMATION hub_node;
- bool is_hcd, need_unref = false;
+ bool is_hcd, need_unref = false;
int i, r;
LPCWSTR wstr;
char *tmp_str = NULL, *path_str = NULL;
@@ -793,7 +793,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
// Loop through all the ports on this hub
for (i = 1, r = LIBUSB_SUCCESS; ; i++)
{
- // safe loop: release all dynamic resources
+ // safe loop: release all dynamic resources
if (need_unref) {
safe_unref_device(dev);
need_unref = false;
@@ -802,7 +802,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
safe_free(path_str);
safe_closehandle(handle);
- // safe loop: end of loop condition
+ // safe loop: end of loop condition
if ((i > nb_ports) || (r != LIBUSB_SUCCESS))
break;
@@ -819,17 +819,17 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
if (conn_info.ConnectionStatus == NoDeviceConnected) {
continue;
- }
+ }
if (conn_info.DeviceAddress == 0) {
- usbi_warn(ctx, "program assertion failed - device address is zero "
+ usbi_warn(ctx, "program assertion failed - device address is zero "
"(conflicts with root hub), ignoring device");
continue;
}
s_hubname.u.node.ConnectionIndex = i; // Only used for non HCDs (s_hubname is an union)
- }
- else
+ }
+ else
{
// HCDs have only 1 node, and it's always a hub
conn_info.DeviceAddress = 0;
@@ -838,9 +838,9 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
}
// If this node is a hub (HCD or not), open it
- if (conn_info.DeviceIsHub) {
+ if (conn_info.DeviceIsHub) {
size = size_initial;
- if (!DeviceIoControl(hub_handle, getname_ioctl, &s_hubname, size,
+ if (!DeviceIoControl(hub_handle, getname_ioctl, &s_hubname, size,
&s_hubname, size, &size, NULL)) {
usbi_warn(ctx, "could not get hub path (dummy): %s", windows_error_str(0));
continue;
@@ -877,7 +877,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
}
// Open Hub
- handle = CreateFileA(path_str, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
+ handle = CreateFileA(path_str, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_FLAG_OVERLAPPED, NULL);
if(handle == INVALID_HANDLE_VALUE) {
usbi_warn(ctx, "could not open hub %s: %s", path_str, windows_error_str(0));
@@ -902,25 +902,25 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
if (dev) {
usbi_dbg("using existing device for session %ld", session_id);
priv = __device_priv(dev);
- // Because we are rebuilding the list, there's no guarantee
+ // Because we are rebuilding the list, there's no guarantee
// the parent device pointer is still the same.
// Other device data should still be reusable
priv->parent_dev = parent_dev;
} else {
usbi_dbg("allocating new device for session %ld", session_id);
- if ((dev = usbi_alloc_device(ctx, session_id)) == NULL) {
+ if ((dev = usbi_alloc_device(ctx, session_id)) == NULL) {
LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
}
need_unref = true;
- LOOP_CHECK(initialize_device(dev, busnum, devaddr, path_str, i,
+ LOOP_CHECK(initialize_device(dev, busnum, devaddr, path_str, i,
conn_info.CurrentConfigurationValue, parent_dev));
priv = __device_priv(dev);
path_str = NULL; // protect our path from being freed
// Setup the cached descriptors. Note that only non HCDs can fetch descriptors
- if (!is_hcd) {
+ if (!is_hcd) {
// The device descriptor has been read with conn_info
memcpy(&priv->dev_descriptor, &(conn_info.DeviceDescriptor), sizeof(USB_DEVICE_DESCRIPTOR));
dev->num_configurations = priv->dev_descriptor.bNumConfigurations;
@@ -936,7 +936,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
}
discdevs = discovered_devs_append(*_discdevs, dev);
- if (!discdevs) {
+ if (!discdevs) {
LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
}
@@ -948,7 +948,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
size = sizeof(USB_NODE_INFORMATION);
if (!DeviceIoControl(handle, IOCTL_USB_GET_NODE_INFORMATION, &hub_node, size,
&hub_node, size, &size, NULL)) {
- usbi_warn(ctx, "could not retreive information for hub %s: %s",
+ usbi_warn(ctx, "could not retreive information for hub %s: %s",
priv->path, windows_error_str(0));
continue;
}
@@ -960,7 +960,7 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
usbi_dbg("%d ports Hub: %s", hub_node.u.HubInformation.HubDescriptor.bNumberOfPorts, priv->path);
- usb_enumerate_hub(ctx, _discdevs, handle, busnum, dev,
+ usb_enumerate_hub(ctx, _discdevs, handle, busnum, dev,
hub_node.u.HubInformation.HubDescriptor.bNumberOfPorts);
}
}
@@ -974,8 +974,8 @@ static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs
*/
static int set_composite_device(struct libusb_context *ctx, DEVINST devinst, struct windows_device_priv *priv)
{
-// indexes for additional interface GUIDs, not available from "USB"
-// SetupDiGetClassDevs enumeration should go here. Typically, these are
+// indexes for additional interface GUIDs, not available from "USB"
+// SetupDiGetClassDevs enumeration should go here. Typically, these are
// device interfaces that begin with something else than "\\?\usb\"
enum libusb_hid_report_type {
HID_DEVICE_INTERFACE_GUID_INDEX = 0,
@@ -1062,7 +1062,7 @@ enum libusb_hid_report_type {
{
guid = guid_table[j];
- for (i = 0; ; i++)
+ for (i = 0; ; i++)
{
safe_free(dev_interface_details);
dev_interface_details = get_interface_details(ctx, &dev_info, &dev_info_data, guid, i);
@@ -1073,30 +1073,30 @@ enum libusb_hid_report_type {
// for an USB path we can recognize
if (j == HID_DEVICE_INTERFACE_GUID_INDEX) {
if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve HID parent info data for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve HID parent info data for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
-
+
if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve HID parent's path for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve HID parent's path for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
}
// In case we can't read the driver string through SPDRP_SERVICE (which is
- // the case for HID), we need the ClassGUID for comparison.
- if(!SetupDiGetDeviceRegistryPropertyW(dev_info, &dev_info_data, SPDRP_CLASSGUID,
+ // the case for HID), we need the ClassGUID for comparison.
+ if(!SetupDiGetDeviceRegistryPropertyW(dev_info, &dev_info_data, SPDRP_CLASSGUID,
NULL, (BYTE*)guid_string_w, sizeof(guid_string_w), &size)) {
- usbi_warn(ctx, "could not read class GUID for device %s, skipping: %s",
+ usbi_warn(ctx, "could not read class GUID for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
CLSIDFromString(guid_string_w, &class_guid);
// Attempt to read the driver string
- if(!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_SERVICE,
+ if(!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_SERVICE,
NULL, (BYTE*)driver, MAX_KEY_LENGTH, &size)) {
driver[0] = 0;
}
@@ -1106,7 +1106,7 @@ enum libusb_hid_report_type {
|| (guid_eq(&class_guid, usb_api_backend[api].class_guid)) ) {
api_type[nb_paths] = api;
if (j == HID_DEVICE_INTERFACE_GUID_INDEX) {
- hid_path[nb_paths] = sanitize_path(path);
+ hid_path[nb_paths] = sanitize_path(path);
} else {
hid_path[nb_paths] = NULL;
}
@@ -1120,7 +1120,7 @@ enum libusb_hid_report_type {
}
}
- // Finally, match the interface paths with the interfaces. We do that
+ // Finally, match the interface paths with the interfaces. We do that
// by looking at the children of the composite device
// NB: if the interfaces are not found in their expected position,
// claim_interface will issue a warning
@@ -1142,7 +1142,7 @@ enum libusb_hid_report_type {
r = CM_Get_Device_ID(child_devinst, path, MAX_PATH_LENGTH, 0);
if (r != CR_SUCCESS) {
- usbi_err(ctx, "could not retrieve simple path for interface %d: CR error %d",
+ usbi_err(ctx, "could not retrieve simple path for interface %d: CR error %d",
i, r);
continue;
}
@@ -1151,7 +1151,7 @@ enum libusb_hid_report_type {
usbi_err(ctx, "could not sanitize path for interface %d", i);
continue;
}
-
+
// Because MI_## are not necessarily in sequential order (some composite HID
// devices will have only MI_00 & MI_03 for instance), we retrieve the actual
// interface number from the path's MI value
@@ -1165,7 +1165,7 @@ enum libusb_hid_report_type {
}
}
if (sanitized_short[j] == 0) {
- usbi_warn(ctx, "failure to read interface number for %s. Using default value %d",
+ usbi_warn(ctx, "failure to read interface number for %s. Using default value %d",
sanitized_short, interface_number);
}
@@ -1174,7 +1174,7 @@ enum libusb_hid_report_type {
|| (safe_strcmp(hid_path[j], sanitized_short) == 0 ) ) {
// HID devices can have multiple collections (COL##) for each MI_## interface
if (priv->usb_interface[interface_number].path != NULL) {
- usbi_dbg("interface_path[%d] already set - ignoring HID collection: %s",
+ usbi_dbg("interface_path[%d] already set - ignoring HID collection: %s",
interface_number, sanitized_path[j]);
if (api_type[j] != USB_API_HID) {
usbi_warn(ctx, "program assertion failed - not an HID collection");
@@ -1193,7 +1193,7 @@ enum libusb_hid_report_type {
safe_free(sanitized_short);
if (priv->usb_interface[interface_number].path == NULL) {
- usbi_warn(ctx, "interface_path[%d]: unhandled API - interface will be disabled",
+ usbi_warn(ctx, "interface_path[%d]: unhandled API - interface will be disabled",
interface_number);
continue;
}
@@ -1232,7 +1232,7 @@ static int set_hid_device(struct libusb_context *ctx, struct windows_device_priv
interface_number = 0;
HidD_GetHidGuid(&guid);
- for (i = 0; ; i++)
+ for (i = 0; ; i++)
{
// safe loop: free up any (unprotected) dynamic resource
safe_free(dev_interface_details);
@@ -1246,13 +1246,13 @@ static int set_hid_device(struct libusb_context *ctx, struct windows_device_priv
// Retrieve parent's path using PnP Configuration Manager (CM)
if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
-
+
if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
@@ -1281,7 +1281,7 @@ static int set_hid_device(struct libusb_context *ctx, struct windows_device_priv
* This function retrieves and sets the paths of all non-hub devices
* NB: No I/O with device is required during this call
*/
-static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *discdevs)
+static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *discdevs)
{
struct windows_device_priv *priv;
struct windows_device_priv *parent_priv;
@@ -1300,8 +1300,8 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
bool found;
// TODO (after first official release): MI_## automated driver installation
- guid = GUID_DEVINTERFACE_USB_DEVICE;
- for (i = 0; ; i++)
+ guid = GUID_DEVINTERFACE_USB_DEVICE;
+ for (i = 0; ; i++)
{
// safe loop: free up any (unprotected) dynamic resource
safe_free(dev_interface_details);
@@ -1314,35 +1314,35 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
break;
// Check that the driver installation is OK
- if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_INSTALL_STATE,
- &reg_type, (BYTE*)&install_state, 4, &size))
+ if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_INSTALL_STATE,
+ &reg_type, (BYTE*)&install_state, 4, &size))
&& (size != 4) ){
- usbi_warn(ctx, "could not detect installation state of driver for %s: %s",
+ usbi_warn(ctx, "could not detect installation state of driver for %s: %s",
dev_interface_details->DevicePath, windows_error_str(0));
} else if (install_state != 0) {
- usbi_warn(ctx, "driver for device %s is reporting an issue (code: %d) - skipping",
+ usbi_warn(ctx, "driver for device %s is reporting an issue (code: %d) - skipping",
dev_interface_details->DevicePath, install_state);
continue;
}
-
+
// The SPDRP_ADDRESS for USB devices should be the device port number on the hub
- if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_ADDRESS,
+ if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_ADDRESS,
&reg_type, (BYTE*)&port_nr, 4, &size))
&& (size != 4) ){
- usbi_warn(ctx, "could not retrieve port number for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve port number for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
// Retrieve parent's path using PnP Configuration Manager (CM)
if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
-
+
if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
- usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
+ usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
continue;
}
@@ -1355,7 +1355,7 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
continue;
}
- // With the parent path and port number, we should be able to locate our device
+ // With the parent path and port number, we should be able to locate our device
// by comparing these values to the ones we got when enumerating hubs
found = false;
for (j=0; j<discdevs->len; j++) {
@@ -1368,20 +1368,20 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
parent_priv = __device_priv(priv->parent_dev);
// NB: we compare strings of different lengths below => strncmp
- if ( (safe_strncmp(parent_priv->path, sanitized_path, strlen(sanitized_path)) == 0)
+ if ( (safe_strncmp(parent_priv->path, sanitized_path, strlen(sanitized_path)) == 0)
&& (port_nr == priv->connection_index) ) {
priv->path = sanitize_path(dev_interface_details->DevicePath);
- usbi_dbg("path (%d:%d): %s", discdevs->devices[j]->bus_number,
+ usbi_dbg("path (%d:%d): %s", discdevs->devices[j]->bus_number,
discdevs->devices[j]->device_address, priv->path);
// Check the service name to know what kind of device we have.
// The service name is really the driver name without ".sys" ("WinUSB", "HidUsb", ...)
// It tells us if we can use WinUSB, if we have a composite device, and the API to use
- if(!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_SERVICE,
+ if(!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_SERVICE,
&reg_type, (BYTE*)reg_key, MAX_KEY_LENGTH, &size)) {
- usbi_err(ctx, "could not retrieve driver information for device %s, skipping: %s",
+ usbi_err(ctx, "could not retrieve driver information for device %s, skipping: %s",
dev_interface_details->DevicePath, windows_error_str(0));
break;
}
@@ -1400,7 +1400,7 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
safe_free(priv->hid);
priv->hid = calloc(1, sizeof(struct hid_device_priv));
if (priv->hid == NULL) {
- usbi_err(ctx, "could not allocate HID data for %s, skipping",
+ usbi_err(ctx, "could not allocate HID data for %s, skipping",
dev_interface_details->DevicePath);
priv->apib = &usb_api_backend[USB_API_UNSUPPORTED];
safe_free(priv->path);
@@ -1412,7 +1412,7 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
// For other devices, the first interface is the same as the device
priv->usb_interface[0].path = safe_strdup(priv->path); // needs strdup
// The following is needed if we want to API calls to work for both simple
- // and composite devices, as
+ // and composite devices, as
for(k=0; k<USB_MAXINTERFACES; k++) {
priv->usb_interface[k].apib = &usb_api_backend[api];
}
@@ -1437,7 +1437,7 @@ static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *
*/
static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
{
- struct windows_hcd_priv* hcd;
+ struct windows_hcd_priv* hcd;
HANDLE handle = INVALID_HANDLE_VALUE;
int r = LIBUSB_SUCCESS;
libusb_bus_t bus;
@@ -1493,7 +1493,7 @@ static void windows_exit(void)
CloseHandle(semaphore);
return;
}
-
+
// Only works if exits and inits are balanced exactly
if (--concurrent_usage < 0) { // Last exit
while (hcd_root != NULL)
@@ -1616,9 +1616,9 @@ static int windows_get_configuration(struct libusb_device_handle *dev_handle, in
return LIBUSB_SUCCESS;
}
-/*
- * from http://msdn.microsoft.com/en-us/library/ms793522.aspx: "The port driver
- * does not currently expose a service that allows higher-level drivers to set
+/*
+ * from http://msdn.microsoft.com/en-us/library/ms793522.aspx: "The port driver
+ * does not currently expose a service that allows higher-level drivers to set
* the configuration."
*/
static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
@@ -1629,7 +1629,7 @@ static int windows_set_configuration(struct libusb_device_handle *dev_handle, in
if (config >= USB_MAXCONFIG)
return LIBUSB_ERROR_INVALID_PARAM;
- r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_OUT |
+ r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_OUT |
LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
LIBUSB_REQUEST_SET_CONFIGURATION, (uint16_t)config,
0, NULL, 0, 1000);
@@ -1848,7 +1848,7 @@ static int windows_cancel_transfer(struct usbi_transfer *itransfer)
}
}
-static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
+static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
{
struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
@@ -1886,7 +1886,7 @@ static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t
usbi_handle_transfer_completion(itransfer, status);
}
-static void windows_handle_callback (struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
+static void windows_handle_callback (struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
{
struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
@@ -1921,9 +1921,9 @@ static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds,
num_ready--;
- // Because a Windows OVERLAPPED is used for poll emulation,
+ // Because a Windows OVERLAPPED is used for poll emulation,
// a pollable fd is created and stored with each transfer
- usbi_mutex_lock(&ctx->flying_transfers_lock);
+ usbi_mutex_lock(&ctx->flying_transfers_lock);
list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
transfer_priv = usbi_transfer_get_os_priv(transfer);
if (transfer_priv->pollable_fd.fd == fds[i].fd) {
@@ -1931,7 +1931,7 @@ static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds,
break;
}
}
- usbi_mutex_unlock(&ctx->flying_transfers_lock);
+ usbi_mutex_unlock(&ctx->flying_transfers_lock);
if (found) {
// Handle async requests that completed synchronously first
@@ -1939,7 +1939,7 @@ static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds,
io_result = NO_ERROR;
io_size = (DWORD)transfer_priv->pollable_fd.overlapped->InternalHigh;
// Regular async overlapped
- } else if (GetOverlappedResult(transfer_priv->pollable_fd.handle,
+ } else if (GetOverlappedResult(transfer_priv->pollable_fd.handle,
transfer_priv->pollable_fd.overlapped, &io_size, false)) {
io_result = NO_ERROR;
} else {
@@ -1971,12 +1971,12 @@ unsigned __stdcall windows_clock_gettime_threaded(void* param)
if (!QueryPerformanceFrequency(&li_frequency)) {
usbi_dbg("no hires timer available on this platform");
hires_frequency = 0;
- hires_ticks_to_ps = UINT64_C(0);
+ hires_ticks_to_ps = UINT64_C(0);
} else {
hires_frequency = li_frequency.QuadPart;
// The hires frequency can go as high as 4 GHz, so we'll use a conversion
// to picoseconds to compute the tv_nsecs part in clock_gettime
- hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
+ hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
}
@@ -2012,7 +2012,7 @@ unsigned __stdcall windows_clock_gettime_threaded(void* param)
ReleaseMutex(timer_mutex);
nb_responses = InterlockedExchange((LONG*)&request_count[0], 0);
- if ( (nb_responses)
+ if ( (nb_responses)
&& (ReleaseSemaphore(timer_response, nb_responses, NULL) == 0) ) {
usbi_dbg("unable to release timer semaphore %d: %s", windows_error_str(0));
}
@@ -2057,7 +2057,7 @@ static int windows_clock_gettime(int clk_id, struct timespec *tp)
case USBI_CLOCK_REALTIME:
// We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
// with a predef epoch_time to have an epoch that starts at 1970.01.01 00:00
- // Note however that our resolution is bounded by the Windows system time
+ // Note however that our resolution is bounded by the Windows system time
// functions and is at best of the order of 1 ms (or, usually, worse)
GetSystemTimeAsFileTime(&ftime);
rtime.LowPart = ftime.dwLowDateTime;
@@ -2251,7 +2251,7 @@ const struct windows_usb_api_backend usb_api_backend[USB_API_MAX] = {
hid_abort_transfers,
hid_abort_transfers,
hid_copy_transfer_data,
- },
+ },
};
@@ -2263,10 +2263,10 @@ static int winusb_init(struct libusb_context *ctx)
DLL_LOAD(winusb.dll, WinUsb_Initialize, TRUE);
DLL_LOAD(winusb.dll, WinUsb_Free, TRUE);
DLL_LOAD(winusb.dll, WinUsb_GetAssociatedInterface, TRUE);
- DLL_LOAD(winusb.dll, WinUsb_GetDescriptor, TRUE);
+ DLL_LOAD(winusb.dll, WinUsb_GetDescriptor, TRUE);
DLL_LOAD(winusb.dll, WinUsb_QueryInterfaceSettings, TRUE);
DLL_LOAD(winusb.dll, WinUsb_QueryDeviceInformation, TRUE);
- DLL_LOAD(winusb.dll, WinUsb_SetCurrentAlternateSetting, TRUE);
+ DLL_LOAD(winusb.dll, WinUsb_SetCurrentAlternateSetting, TRUE);
DLL_LOAD(winusb.dll, WinUsb_GetCurrentAlternateSetting, TRUE);
DLL_LOAD(winusb.dll, WinUsb_QueryPipe, TRUE);
DLL_LOAD(winusb.dll, WinUsb_SetPipePolicy, TRUE);
@@ -2282,7 +2282,7 @@ static int winusb_init(struct libusb_context *ctx)
return LIBUSB_SUCCESS;
}
-static int winusb_exit(void)
+static int winusb_exit(void)
{
return LIBUSB_SUCCESS;
}
@@ -2290,7 +2290,7 @@ static int winusb_exit(void)
// NB: open and close must ensure that they only handle interface of
// the right API type, as these functions can be called wholesale from
// composite_open(), with interfaces belonging to different APIs
-static int winusb_open(struct libusb_device_handle *dev_handle)
+static int winusb_open(struct libusb_device_handle *dev_handle)
{
struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
struct windows_device_priv *priv = __device_priv(dev_handle->dev);
@@ -2303,9 +2303,9 @@ static int winusb_open(struct libusb_device_handle *dev_handle)
// WinUSB requires a seperate handle for each interface
for (i = 0; i < USB_MAXINTERFACES; i++) {
- if ( (priv->usb_interface[i].path != NULL)
+ if ( (priv->usb_interface[i].path != NULL)
&& (priv->usb_interface[i].apib->id == USB_API_WINUSB) ) {
- file_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
+ file_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
if (file_handle == INVALID_HANDLE_VALUE) {
usbi_err(ctx, "could not open device %s (interface %d): %s", priv->path, i, windows_error_str(0));
@@ -2359,11 +2359,11 @@ static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int i
CHECK_WINUSB_AVAILABLE;
- // interfaces for composite devices are always independent, therefore
+ // interfaces for composite devices are always independent, therefore
// "alt" interfaces are only found on non-composite
if ((!is_composite) && (iface != 0)) {
winusb_handle = handle_priv->interface_handle[0].api_handle;
- // It is a requirement on Windows that to claim an interface >= 1
+ // It is a requirement on Windows that to claim an interface >= 1
// on a non-composite WinUSB device, you must first have claimed interface 0
if ((winusb_handle == 0) || (winusb_handle == INVALID_HANDLE_VALUE)) {
#if defined(AUTO_CLAIM)
@@ -2379,7 +2379,7 @@ static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int i
return LIBUSB_ERROR_ACCESS;
#endif
}
- if (!WinUsb_GetAssociatedInterface(winusb_handle, (UCHAR)(iface-1),
+ if (!WinUsb_GetAssociatedInterface(winusb_handle, (UCHAR)(iface-1),
&handle_priv->interface_handle[iface].api_handle)) {
handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
switch(GetLastError()) {
@@ -2419,14 +2419,14 @@ static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int i
if (!WinUsb_QueryInterfaceSettings(winusb_handle, 0, &if_desc)) {
usbi_err(ctx, "could not query interface settings for interface %d: %s", iface, windows_error_str(0));
} else if (if_desc.bInterfaceNumber != iface) {
- usbi_warn(ctx, "program assertion failed - WinUSB interface %d found at position %d",
+ usbi_warn(ctx, "program assertion failed - WinUSB interface %d found at position %d",
if_desc.bInterfaceNumber, iface);
}
usbi_dbg("claimed interface %d", iface);
handle_priv->active_interface = iface;
- // With handle and enpoints set (in parent), we can setup the default
+ // With handle and enpoints set (in parent), we can setup the default
// pipe properties (copied from libusb-win32-v1)
// see http://download.microsoft.com/download/D/1/D/D1DD7745-426B-4CC3-A269-ABBBE427C0EF/DVC-T705_DDC08.pptx
for (i=0; i<priv->usb_interface[iface].nb_endpoints; i++) {
@@ -2480,9 +2480,9 @@ static int get_valid_interface(struct libusb_device_handle *dev_handle)
int i;
for (i=0; i<USB_MAXINTERFACES; i++) {
- if ( (handle_priv->interface_handle[i].dev_handle != 0)
+ if ( (handle_priv->interface_handle[i].dev_handle != 0)
&& (handle_priv->interface_handle[i].dev_handle != INVALID_HANDLE_VALUE)
- && (handle_priv->interface_handle[i].api_handle != 0)
+ && (handle_priv->interface_handle[i].api_handle != 0)
&& (handle_priv->interface_handle[i].api_handle != INVALID_HANDLE_VALUE)) {
return i;
}
@@ -2493,7 +2493,7 @@ static int get_valid_interface(struct libusb_device_handle *dev_handle)
/*
* Lookup interface by endpoint address. -1 if not found
*/
-static int interface_by_endpoint(struct windows_device_priv *priv,
+static int interface_by_endpoint(struct windows_device_priv *priv,
struct windows_device_handle_priv *handle_priv, uint8_t endpoint_address)
{
int i, j;
@@ -2730,12 +2730,12 @@ static int winusb_abort_transfers(struct usbi_transfer *itransfer)
return LIBUSB_SUCCESS;
}
-/*
+/*
* from the "How to Use WinUSB to Communicate with a USB Device" Microsoft white paper
* (http://www.microsoft.com/whdc/connect/usb/winusb_howto.mspx):
* "WinUSB does not support host-initiated reset port and cycle port operations" and
* IOCTL_INTERNAL_USB_CYCLE_PORT is only available in kernel mode and the
- * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
+ * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
* cycle the pipes (and even then, the control pipe can not be reset using WinUSB)
*/
// TODO (2nd official release): see if we can force eject the device and redetect it (reuse hotplug?)
@@ -2759,23 +2759,23 @@ static int winusb_reset_device(struct libusb_device_handle *dev_handle)
usbi_remove_pollfd(ctx, wfd.fd);
usbi_free_fd(wfd.fd);
wfd = handle_to_winfd(winusb_handle);
- }
+ }
if ( (winusb_handle != 0) && (winusb_handle != INVALID_HANDLE_VALUE)) {
for (j=0; j<priv->usb_interface[i].nb_endpoints; j++) {
usbi_dbg("resetting ep %02X", priv->usb_interface[i].endpoint[j]);
if (!WinUsb_AbortPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) {
- usbi_err(ctx, "WinUsb_AbortPipe (pipe address %02X) failed: %s",
+ usbi_err(ctx, "WinUsb_AbortPipe (pipe address %02X) failed: %s",
priv->usb_interface[i].endpoint[j], windows_error_str(0));
}
// FlushPipe seems to fail on OUT pipes
- if ( (priv->usb_interface[i].endpoint[j] & LIBUSB_ENDPOINT_IN)
+ if ( (priv->usb_interface[i].endpoint[j] & LIBUSB_ENDPOINT_IN)
&& (!WinUsb_FlushPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) ) {
- usbi_err(ctx, "WinUsb_FlushPipe (pipe address %02X) failed: %s",
+ usbi_err(ctx, "WinUsb_FlushPipe (pipe address %02X) failed: %s",
priv->usb_interface[i].endpoint[j], windows_error_str(0));
}
if (!WinUsb_ResetPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) {
- usbi_err(ctx, "WinUsb_ResetPipe (pipe address %02X) failed: %s",
+ usbi_err(ctx, "WinUsb_ResetPipe (pipe address %02X) failed: %s",
priv->usb_interface[i].endpoint[j], windows_error_str(0));
}
}
@@ -2785,7 +2785,7 @@ static int winusb_reset_device(struct libusb_device_handle *dev_handle)
return LIBUSB_SUCCESS;
}
-static int winusb_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
+static int winusb_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
{
itransfer->transferred += io_size;
return LIBUSB_TRANSFER_COMPLETED;
@@ -2849,7 +2849,7 @@ static int _hid_get_config_descriptor(struct hid_device_priv* dev, void *data, s
if (dev->output_report_size)
num_endpoints++;
- config_total_len = LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE
+ config_total_len = LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE
+ LIBUSB_DT_HID_SIZE + num_endpoints * LIBUSB_DT_ENDPOINT_SIZE;
@@ -2858,7 +2858,7 @@ static int _hid_get_config_descriptor(struct hid_device_priv* dev, void *data, s
hd = (struct libusb_hid_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE
+ LIBUSB_DT_INTERFACE_SIZE);
ed = (struct libusb_endpoint_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE
- + LIBUSB_DT_INTERFACE_SIZE
+ + LIBUSB_DT_INTERFACE_SIZE
+ LIBUSB_DT_HID_SIZE);
cd->bLength = LIBUSB_DT_CONFIG_SIZE;
@@ -2997,8 +2997,8 @@ static int _hid_get_report_descriptor(struct hid_device_priv* dev, void *data, s
if (dev->input_report_size) {
/* usage (vendor defined) */
d[i++] = 0x09; d[i++] = 0x01;
- /* logical minimum (0) */
- d[i++] = 0x15; d[i++] = 0x00;
+ /* logical minimum (0) */
+ d[i++] = 0x15; d[i++] = 0x00;
/* logical maximum (255) */
d[i++] = 0x25; d[i++] = 0xFF;
/* report size (8 bits) */
@@ -3012,8 +3012,8 @@ static int _hid_get_report_descriptor(struct hid_device_priv* dev, void *data, s
if (dev->output_report_size) {
/* usage (vendor defined) */
d[i++] = 0x09; d[i++] = 0x02;
- /* logical minimum (0) */
- d[i++] = 0x15; d[i++] = 0x00;
+ /* logical minimum (0) */
+ d[i++] = 0x15; d[i++] = 0x00;
/* logical maximum (255) */
d[i++] = 0x25; d[i++] = 0xFF;
/* report size (8 bits) */
@@ -3067,7 +3067,7 @@ static int _hid_get_descriptor(struct hid_device_priv* dev, HANDLE hid_handle, i
return LIBUSB_ERROR_INVALID_PARAM;
}
-static int _hid_get_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
+static int _hid_get_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
struct windows_transfer_priv *tp, size_t *size, OVERLAPPED* overlapped)
{
uint8_t *buf;
@@ -3090,8 +3090,8 @@ static int _hid_get_report(struct hid_device_priv* dev, HANDLE hid_handle, int i
buf[0] = (uint8_t)id;
usbi_dbg("report ID: 0x%02X", buf[0]);
// NB: HidD_GetInputReport returns the last Input Report read whereas ReadFile
- // waits for input to be generated => in case your HID device requires human
- // action to generate a report, it may wait indefinitely.
+ // waits for input to be generated => in case your HID device requires human
+ // action to generate a report, it may wait indefinitely.
#if !defined(USE_HIDD_FOR_REPORTS)
// Use ReadFile instead of HidD_GetInputReport for async I/O
tp->hid_expected_size = read_size; // read_size is modified below!
@@ -3135,7 +3135,7 @@ static int _hid_get_report(struct hid_device_priv* dev, HANDLE hid_handle, int i
return r;
}
-static int _hid_set_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
+static int _hid_set_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
struct windows_transfer_priv *tp, size_t *size, OVERLAPPED* overlapped)
{
uint8_t *buf;
@@ -3168,13 +3168,13 @@ static int _hid_set_report(struct hid_device_priv* dev, HANDLE hid_handle, int i
}
tp->hid_buffer = buf;
return LIBUSB_SUCCESS;
- }
+ }
#else
if (!HidD_SetOutputReport(hid_handle, buf, write_size)) {
usbi_dbg("Failed to Write HID Output Report: %s", windows_error_str(0));
safe_free(buf);
return LIBUSB_ERROR_IO;
- }
+ }
#endif
// Transfer completed synchronously
if (write_size == 0) {
@@ -3217,7 +3217,7 @@ static int _hid_get_feature(struct hid_device_priv* dev, HANDLE hid_handle, int
case ERROR_INVALID_FUNCTION:
r = LIBUSB_ERROR_NOT_FOUND;
break;
- default:
+ default:
usbi_dbg("error %s", windows_error_str(err));
r = LIBUSB_ERROR_OTHER;
break;
@@ -3253,7 +3253,7 @@ static int _hid_set_feature(struct hid_device_priv* dev, HANDLE hid_handle, int
switch (err) {
case ERROR_INVALID_FUNCTION:
r = LIBUSB_ERROR_NOT_FOUND;
- default:
+ default:
usbi_dbg("error %s", windows_error_str(r));
r = LIBUSB_ERROR_OTHER;
}
@@ -3263,7 +3263,7 @@ static int _hid_set_feature(struct hid_device_priv* dev, HANDLE hid_handle, int
}
static int _hid_class_request(struct hid_device_priv* dev, HANDLE hid_handle, int request_type,
- int request, int value, int index, void *data, struct windows_transfer_priv *tp,
+ int request, int value, int index, void *data, struct windows_transfer_priv *tp,
size_t *size, OVERLAPPED* overlapped)
{
int report_type = (value >> 8) & 0xFF;
@@ -3273,22 +3273,22 @@ static int _hid_class_request(struct hid_device_priv* dev, HANDLE hid_handle, in
return LIBUSB_ERROR_INVALID_PARAM;
if (LIBUSB_REQ_OUT(request_type)
- && request == HID_REQ_SET_REPORT
+ && request == HID_REQ_SET_REPORT
&& report_type == HID_REPORT_TYPE_OUTPUT)
return _hid_set_report(dev, hid_handle, report_id, data, tp, size, overlapped);
if (LIBUSB_REQ_IN(request_type)
- && request == HID_REQ_GET_REPORT
+ && request == HID_REQ_GET_REPORT
&& report_type == HID_REPORT_TYPE_INPUT)
return _hid_get_report(dev, hid_handle, report_id, data, tp, size, overlapped);
if (LIBUSB_REQ_OUT(request_type)
- && request == HID_REQ_SET_REPORT
+ && request == HID_REQ_SET_REPORT
&& report_type == HID_REPORT_TYPE_FEATURE)
return _hid_set_feature(dev, hid_handle, report_id, data, size);
if (LIBUSB_REQ_IN(request_type)
- && request == HID_REQ_GET_REPORT
+ && request == HID_REQ_GET_REPORT
&& report_type == HID_REPORT_TYPE_FEATURE)
return _hid_get_feature(dev, hid_handle, report_id, data, size);
@@ -3319,10 +3319,10 @@ static int hid_init(struct libusb_context *ctx)
DLL_LOAD(hid.dll, HidP_GetValueCaps, TRUE);
api_hid_available = true;
- return LIBUSB_SUCCESS;
+ return LIBUSB_SUCCESS;
}
-static int hid_exit(void)
+static int hid_exit(void)
{
return LIBUSB_SUCCESS;
}
@@ -3330,7 +3330,7 @@ static int hid_exit(void)
// NB: open and close must ensure that they only handle interface of
// the right API type, as these functions can be called wholesale from
// composite_open(), with interfaces belonging to different APIs
-static int hid_open(struct libusb_device_handle *dev_handle)
+static int hid_open(struct libusb_device_handle *dev_handle)
{
struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
struct windows_device_priv *priv = __device_priv(dev_handle->dev);
@@ -3352,20 +3352,20 @@ static int hid_open(struct libusb_device_handle *dev_handle)
}
for (i = 0; i < USB_MAXINTERFACES; i++) {
- if ( (priv->usb_interface[i].path != NULL)
+ if ( (priv->usb_interface[i].path != NULL)
&& (priv->usb_interface[i].apib->id == USB_API_HID) ) {
- hid_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
+ hid_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
/*
* http://www.lvr.com/hidfaq.htm: Why do I receive "Access denied" when attempting to access my HID?
- * "Windows 2000 and later have exclusive read/write access to HIDs that are configured as a system
- * keyboards or mice. An application can obtain a handle to a system keyboard or mouse by not
- * requesting READ or WRITE access with CreateFile. Applications can then use HidD_SetFeature and
+ * "Windows 2000 and later have exclusive read/write access to HIDs that are configured as a system
+ * keyboards or mice. An application can obtain a handle to a system keyboard or mouse by not
+ * requesting READ or WRITE access with CreateFile. Applications can then use HidD_SetFeature and
* HidD_GetFeature (if the device supports Feature reports)."
*/
if (hid_handle == INVALID_HANDLE_VALUE) {
usbi_warn(ctx, "could not open HID device in R/W mode (keyboard or mouse?) - trying without");
- hid_handle = CreateFileA(priv->usb_interface[i].path, 0, FILE_SHARE_WRITE | FILE_SHARE_READ,
+ hid_handle = CreateFileA(priv->usb_interface[i].path, 0, FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
if (hid_handle == INVALID_HANDLE_VALUE) {
usbi_err(ctx, "could not open device %s (interface %d): %s", priv->path, i, windows_error_str(0));
@@ -3412,7 +3412,7 @@ static int hid_open(struct libusb_device_handle *dev_handle)
priv->hid->input_report_id = 0;
if (size > 0) {
value_caps = malloc(size * sizeof(HIDP_VALUE_CAPS));
- if ( (value_caps != NULL)
+ if ( (value_caps != NULL)
&& (HidP_GetValueCaps(HidP_Input, value_caps, &size, preparsed_data) == HIDP_STATUS_SUCCESS)
&& (size >= 1) ) {
priv->hid->input_report_id = value_caps[0].ReportID;
@@ -3436,7 +3436,7 @@ static int hid_open(struct libusb_device_handle *dev_handle)
priv->hid->output_report_id = 0;
if (size > 0) {
value_caps = malloc(size * sizeof(HIDP_VALUE_CAPS));
- if ( (value_caps != NULL)
+ if ( (value_caps != NULL)
&& (HidP_GetValueCaps(HidP_Output, value_caps, &size, preparsed_data) == HIDP_STATUS_SUCCESS)
&& (size >= 1) ) {
priv->hid->output_report_id = value_caps[0].ReportID;
@@ -3459,11 +3459,11 @@ static int hid_open(struct libusb_device_handle *dev_handle)
priv->hid->feature_report_size = capabilities.FeatureReportByteLength;
// Fetch string descriptors
- HidD_GetManufacturerString(hid_handle, priv->hid->man_string,
+ HidD_GetManufacturerString(hid_handle, priv->hid->man_string,
sizeof(priv->hid->man_string));
- HidD_GetProductString(hid_handle, priv->hid->prod_string,
+ HidD_GetProductString(hid_handle, priv->hid->prod_string,
sizeof(priv->hid->prod_string));
- HidD_GetSerialNumberString(hid_handle, priv->hid->ser_string,
+ HidD_GetSerialNumberString(hid_handle, priv->hid->ser_string,
sizeof(priv->hid->ser_string));
} while(0);
@@ -3607,7 +3607,7 @@ static int hid_submit_control_transfer(struct usbi_transfer *itransfer)
case LIBUSB_REQUEST_TYPE_STANDARD:
switch(setup->request) {
case LIBUSB_REQUEST_GET_DESCRIPTOR:
- r = _hid_get_descriptor(priv->hid, wfd.handle, LIBUSB_REQ_RECIPIENT(setup->request_type),
+ r = _hid_get_descriptor(priv->hid, wfd.handle, LIBUSB_REQ_RECIPIENT(setup->request_type),
(setup->value >> 8) & 0xFF, setup->value & 0xFF, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, &size);
break;
case LIBUSB_REQUEST_GET_CONFIGURATION:
@@ -3658,7 +3658,7 @@ static int hid_submit_control_transfer(struct usbi_transfer *itransfer)
// set InternalHigh to the number of bytes transferred
wfd.overlapped->InternalHigh = (DWORD)size;
r = LIBUSB_SUCCESS;
- }
+ }
if (r == LIBUSB_SUCCESS) {
// Use priv_transfer to store data needed for async polling
@@ -3855,15 +3855,15 @@ static int hid_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_s
*/
static int composite_init(struct libusb_context *ctx)
{
- return LIBUSB_SUCCESS;
+ return LIBUSB_SUCCESS;
}
-static int composite_exit(void)
+static int composite_exit(void)
{
return LIBUSB_SUCCESS;
}
-static int composite_open(struct libusb_device_handle *dev_handle)
+static int composite_open(struct libusb_device_handle *dev_handle)
{
struct windows_device_priv *priv = __device_priv(dev_handle->dev);
unsigned api;
@@ -3882,7 +3882,7 @@ static int composite_open(struct libusb_device_handle *dev_handle)
return LIBUSB_SUCCESS;
}
-static void composite_close(struct libusb_device_handle *dev_handle)
+static void composite_close(struct libusb_device_handle *dev_handle)
{
struct windows_device_priv *priv = __device_priv(dev_handle->dev);
unsigned api;
@@ -3999,7 +3999,7 @@ static int composite_abort_transfers(struct usbi_transfer *itransfer)
return priv->usb_interface[transfer_priv->interface_number].apib->abort_transfers(itransfer);
}
-static int composite_reset_device(struct libusb_device_handle *dev_handle)
+static int composite_reset_device(struct libusb_device_handle *dev_handle)
{
struct windows_device_priv *priv = __device_priv(dev_handle->dev);
unsigned api;
diff --git a/libusb/os/windows_usb.h b/libusb/os/windows_usb.h
index 6a54d7e..330b7bb 100644
--- a/libusb/os/windows_usb.h
+++ b/libusb/os/windows_usb.h
@@ -188,7 +188,7 @@ struct libusb_hid_descriptor {
#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_MAX_REPORT_SIZE 1024
#define HID_IN_EP 0x81
#define HID_OUT_EP 0x02
#define LIBUSB_REQ_RECIPIENT(request_type) ((request_type) & 0x1F)
@@ -236,7 +236,7 @@ struct windows_device_priv {
char *path; // each interface needs a Windows device interface path,
struct windows_usb_api_backend const *apib; // an API backend (multiple drivers support),
int8_t nb_endpoints; // and a set of endpoint addresses (USB_MAXENDPOINTS)
- uint8_t *endpoint;
+ uint8_t *endpoint;
} usb_interface[USB_MAXINTERFACES];
uint8_t composite_api_flags; // HID and composite devices require additional data
struct hid_device_priv *hid;
@@ -449,7 +449,7 @@ DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Device_IDW, (DEVINST, PWCHAR, ULONG, ULONG
// Most of the structures below need to be packed
#pragma pack(push, 1)
-typedef struct _USB_INTERFACE_DESCRIPTOR {
+typedef struct _USB_INTERFACE_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
UCHAR bInterfaceNumber;
@@ -461,7 +461,7 @@ typedef struct _USB_INTERFACE_DESCRIPTOR {
UCHAR iInterface;
} USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
-typedef struct _USB_CONFIGURATION_DESCRIPTOR {
+typedef struct _USB_CONFIGURATION_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
USHORT wTotalLength;
@@ -486,7 +486,7 @@ typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
USB_CONFIGURATION_DESCRIPTOR data;
} USB_CONFIGURATION_DESCRIPTOR_SHORT;
-typedef struct _USB_ENDPOINT_DESCRIPTOR {
+typedef struct _USB_ENDPOINT_DESCRIPTOR {
UCHAR bLength;
UCHAR bDescriptorType;
UCHAR bEndpointAddress;
@@ -619,7 +619,7 @@ typedef struct _USB_HUB_CAPABILITIES_EX {
#define DEVICE_SPEED 0x01
#define LowSpeed 0x01
#define FullSpeed 0x02
-#define HighSpeed 0x03
+#define HighSpeed 0x03
typedef enum _USBD_PIPE_TYPE {
UsbdPipeTypeControl,
@@ -672,7 +672,7 @@ typedef void* PHIDP_PREPARSED_DATA;
#pragma pack(1)
typedef struct {
- ULONG Size;
+ ULONG Size;
USHORT VendorID;
USHORT ProductID;
USHORT VersionNumber;