usb 2.1.3 → 2.2.0

package/libusb/libusb/os/events_windows.c

@@ -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;
+}

package/libusb/{msvc/missing.h → libusb/os/events_windows.h}

@@ -1,6 +1,7 @@
 /*
- * Header file for missing WinCE functionality
- * Copyright © 2012-2013 RealVNC Ltd.
+ * 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
@@ -17,16 +18,29 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef MISSING_H
-#define MISSING_H
+#ifndef LIBUSB_EVENTS_WINDOWS_H
+#define LIBUSB_EVENTS_WINDOWS_H
 
-/* Windows CE doesn't have SleepEx() - Fallback to Sleep() */
-#define SleepEx(m, a) Sleep(m)
+typedef HANDLE usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"HANDLE %p"
 
-/* Windows CE doesn't have any APIs to query environment variables.
- *
- * This contains a registry based implementation of getenv.
- */
-char *getenv(const char *name);
+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

package/libusb/libusb/os/haiku_pollfs.cpp

@@ -97,20 +97,20 @@ WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
 			unsigned long session_id = (unsigned long)&fDevice;
 
 			usbi_mutex_lock(&active_contexts_lock);
-			list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+			for_each_context(ctx) {
 				struct libusb_device *dev = usbi_get_device_by_session_id(ctx, session_id);
 				if (dev) {
-					usbi_dbg("using previously allocated device with location %lu", session_id);
+					usbi_dbg(NULL, "using previously allocated device with location %lu", session_id);
 					libusb_unref_device(dev);
 					continue;
 				}
-				usbi_dbg("allocating new device with location %lu", session_id);
+				usbi_dbg(NULL, "allocating new device with location %lu", session_id);
 				dev = usbi_alloc_device(ctx, session_id);
 				if (!dev) {
-					usbi_dbg("device allocation failed");
+					usbi_dbg(NULL, "device allocation failed");
 					continue;
 				}
-				*((USBDevice **)dev->os_priv) = fDevice;
+				*((USBDevice **)usbi_get_device_priv(dev)) = fDevice;
 
 				// Calculate pseudo-device-address
 				int addr, tmp;
@@ -125,11 +125,16 @@ WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
 					addr += tmp + 1;
 					parent_path.GetParent(&parent_path);
 				}
-				sscanf(path.Path(), "/dev/bus/usb/%d", &dev->bus_number);
+				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("device sanitization failed");
+					usbi_dbg(NULL, "device sanitization failed");
 					libusb_unref_device(dev);
 					continue;
 				}
@@ -167,13 +172,13 @@ WatchedEntry::~WatchedEntry()
 		unsigned long session_id = (unsigned long)&fDevice;
 
 		usbi_mutex_lock(&active_contexts_lock);
-		list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
+		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("device with location %lu not found", session_id);
+				usbi_dbg(ctx, "device with location %lu not found", session_id);
 			}
 		}
 		usbi_mutex_static_unlock(&active_contexts_lock);

package/libusb/libusb/os/haiku_usb.h

@@ -38,22 +38,22 @@ public:
 	const char*				Location() const;
 	uint8					CountConfigurations() const;
 	const usb_device_descriptor*		Descriptor() const;
-	const usb_configuration_descriptor*	ConfigurationDescriptor(uint32) const;
+	const usb_configuration_descriptor*	ConfigurationDescriptor(uint8) const;
 	const usb_configuration_descriptor*	ActiveConfiguration() const;
 	uint8					EndpointToIndex(uint8) const;
 	uint8					EndpointToInterface(uint8) const;
-	int					ClaimInterface(int);
-	int					ReleaseInterface(int);
-	int					CheckInterfacesFree(int);
-	int					SetActiveConfiguration(int);
-	int					ActiveConfigurationIndex() 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;
-	int					fActiveConfiguration;
+	uint8					fActiveConfiguration;
 	char*					fPath;
 	map<uint8,uint8>			fConfigToIndex;
 	map<uint8,uint8>*			fEndpointToIndex;
@@ -65,11 +65,11 @@ class USBDeviceHandle {
 public:
 				USBDeviceHandle(USBDevice *dev);
 	virtual			~USBDeviceHandle();
-	int			ClaimInterface(int);
-	int			ReleaseInterface(int);
-	int			SetConfiguration(int);
-	int			SetAltSetting(int, int);
-	int			ClearHalt(int);
+	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();

package/libusb/libusb/os/haiku_usb_backend.cpp

@@ -26,7 +26,7 @@
 
 #include "haiku_usb.h"
 
-int _errno_to_libusb(int status)
+static int _errno_to_libusb(int status)
 {
 	return status;
 }
@@ -127,7 +127,7 @@ USBTransfer::Do(int fRawFD)
 			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 ((int16)(fLibusbTransfer->iso_packet_desc[i]).length != (fLibusbTransfer->iso_packet_desc[i]).length) {
+				if ((fLibusbTransfer->iso_packet_desc[i]).length > (unsigned int)INT16_MAX) {
 					fUsbiTransfer->transferred = -1;
 					usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
 					break;
@@ -201,7 +201,7 @@ status_t
 USBDeviceHandle::SubmitTransfer(struct usbi_transfer *itransfer)
 {
 	USBTransfer *transfer = new USBTransfer(itransfer, fUSBDevice);
-	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = transfer;
+	*((USBTransfer **)usbi_get_transfer_priv(itransfer)) = transfer;
 	BAutolock locker(fTransfersLock);
 	fTransfers.AddItem(transfer);
 	release_sem(fTransfersSem);
@@ -215,16 +215,16 @@ USBDeviceHandle::CancelTransfer(USBTransfer *transfer)
 	fTransfersLock.Lock();
 	bool removed = fTransfers.RemoveItem(transfer);
 	fTransfersLock.Unlock();
-	if(removed)
+	if (removed)
 		usbi_signal_transfer_completion(transfer->UsbiTransfer());
 	return LIBUSB_SUCCESS;
 }
 
 USBDeviceHandle::USBDeviceHandle(USBDevice *dev)
 	:
-	fTransfersThread(-1),
 	fUSBDevice(dev),
 	fClaimedInterfaces(0),
+	fTransfersThread(-1),
 	fInitCheck(false)
 {
 	fRawFD = open(dev->Location(), O_RDWR | O_CLOEXEC);
@@ -242,7 +242,7 @@ USBDeviceHandle::~USBDeviceHandle()
 {
 	if (fRawFD > 0)
 		close(fRawFD);
-	for(int i = 0; i < 32; i++) {
+	for (int i = 0; i < 32; i++) {
 		if (fClaimedInterfaces & (1U << i))
 			ReleaseInterface(i);
 	}
@@ -252,7 +252,7 @@ USBDeviceHandle::~USBDeviceHandle()
 }
 
 int
-USBDeviceHandle::ClaimInterface(int inumber)
+USBDeviceHandle::ClaimInterface(uint8 inumber)
 {
 	int status = fUSBDevice->ClaimInterface(inumber);
 	if (status == LIBUSB_SUCCESS)
@@ -261,7 +261,7 @@ USBDeviceHandle::ClaimInterface(int inumber)
 }
 
 int
-USBDeviceHandle::ReleaseInterface(int inumber)
+USBDeviceHandle::ReleaseInterface(uint8 inumber)
 {
 	fUSBDevice->ReleaseInterface(inumber);
 	fClaimedInterfaces &= ~(1U << inumber);
@@ -269,10 +269,10 @@ USBDeviceHandle::ReleaseInterface(int inumber)
 }
 
 int
-USBDeviceHandle::SetConfiguration(int config)
+USBDeviceHandle::SetConfiguration(uint8 config)
 {
 	int config_index = fUSBDevice->CheckInterfacesFree(config);
-	if(config_index == LIBUSB_ERROR_BUSY || config_index == LIBUSB_ERROR_NOT_FOUND)
+	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;
@@ -280,12 +280,12 @@ USBDeviceHandle::SetConfiguration(int config)
 			command.config.status != B_USB_RAW_STATUS_SUCCESS) {
 		return _errno_to_libusb(command.config.status);
 	}
-	fUSBDevice->SetActiveConfiguration(config_index);
+	fUSBDevice->SetActiveConfiguration((uint8)config_index);
 	return LIBUSB_SUCCESS;
 }
 
 int
-USBDeviceHandle::SetAltSetting(int inumber, int alt)
+USBDeviceHandle::SetAltSetting(uint8 inumber, uint8 alt)
 {
 	usb_raw_command command;
 	command.alternate.config_index = fUSBDevice->ActiveConfigurationIndex();
@@ -295,23 +295,22 @@ USBDeviceHandle::SetAltSetting(int inumber, int alt)
 		usbi_err(NULL, "Error retrieving active alternate interface");
 		return _errno_to_libusb(command.alternate.status);
 	}
-	if (command.alternate.alternate_info == alt) {
-		usbi_dbg("Setting alternate interface successful");
+	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 DISONNECTED PROBABLY
+			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("Setting alternate interface successful");
+	usbi_dbg(NULL, "Setting alternate interface successful");
 	return LIBUSB_SUCCESS;
 }
 
-
 int
-USBDevice::ClearHalt(int endpoint)
+USBDeviceHandle::ClearHalt(uint8 endpoint)
 {
 	usb_raw_command command;
 	command.control.request_type = USB_REQTYPE_ENDPOINT_OUT;
@@ -324,15 +323,16 @@ USBDevice::ClearHalt(int endpoint)
 			command.control.status != B_USB_RAW_STATUS_SUCCESS) {
 		return _errno_to_libusb(command.control.status);
 	}
+	return LIBUSB_SUCCESS;
 }
 
 
 USBDevice::USBDevice(const char *path)
 	:
-	fPath(NULL),
-	fActiveConfiguration(0),	//0?
-	fConfigurationDescriptors(NULL),
 	fClaimedInterfaces(0),
+	fConfigurationDescriptors(NULL),
+	fActiveConfiguration(0),	//0?
+	fPath(NULL),
 	fEndpointToIndex(NULL),
 	fEndpointToInterface(NULL),
 	fInitCheck(false)
@@ -345,7 +345,7 @@ USBDevice::~USBDevice()
 {
 	free(fPath);
 	if (fConfigurationDescriptors) {
-		for(int i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+		for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
 			if (fConfigurationDescriptors[i])
 				delete fConfigurationDescriptors[i];
 		}
@@ -382,7 +382,7 @@ USBDevice::Descriptor() const
 }
 
 const usb_configuration_descriptor *
-USBDevice::ConfigurationDescriptor(uint32 index) const
+USBDevice::ConfigurationDescriptor(uint8 index) const
 {
 	if (index > CountConfigurations())
 		return NULL;
@@ -395,13 +395,13 @@ USBDevice::ActiveConfiguration() const
 	return (usb_configuration_descriptor *) fConfigurationDescriptors[fActiveConfiguration];
 }
 
-int
+uint8
 USBDevice::ActiveConfigurationIndex() const
 {
 	return fActiveConfiguration;
 }
 
-int USBDevice::ClaimInterface(int interface)
+int USBDevice::ClaimInterface(uint8 interface)
 {
 	if (interface > ActiveConfiguration()->number_interfaces)
 		return LIBUSB_ERROR_NOT_FOUND;
@@ -411,27 +411,26 @@ int USBDevice::ClaimInterface(int interface)
 	return LIBUSB_SUCCESS;
 }
 
-int USBDevice::ReleaseInterface(int interface)
+int USBDevice::ReleaseInterface(uint8 interface)
 {
 	fClaimedInterfaces &= ~(1U << interface);
 	return LIBUSB_SUCCESS;
 }
 
 int
-USBDevice::CheckInterfacesFree(int config)
+USBDevice::CheckInterfacesFree(uint8 config)
 {
 	if (fConfigToIndex.count(config) == 0)
 		return LIBUSB_ERROR_NOT_FOUND;
 	if (fClaimedInterfaces == 0)
-		return fConfigToIndex[(uint8)config];
+		return fConfigToIndex[config];
 	return LIBUSB_ERROR_BUSY;
 }
 
-int
-USBDevice::SetActiveConfiguration(int config_index)
+void
+USBDevice::SetActiveConfiguration(uint8 config_index)
 {
 	fActiveConfiguration = config_index;
-	return LIBUSB_SUCCESS;
 }
 
 uint8
@@ -463,7 +462,7 @@ USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
 	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 (int i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+	for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
 		usb_configuration_descriptor tmp_config;
 		command.config.descriptor = &tmp_config;
 		command.config.config_index = i;
@@ -479,14 +478,14 @@ USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
 		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_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC, &command, sizeof(command)) ||
+		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 (int j = 0; j < tmp_config.number_interfaces; j++) {
+		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)) ||
@@ -495,8 +494,8 @@ USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
 				close(fRawFD);
 				return B_ERROR;
 			}
-			int num_alternate = command.alternate.alternate_info;
-			for (int k = 0; k < num_alternate; k++) {
+			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;
@@ -508,7 +507,7 @@ USBDevice::Initialise()		//Do we need more error checking, etc? How to report?
 					close(fRawFD);
 					return B_ERROR;
 				}
-				for (int l = 0; l < tmp_interface.num_endpoints; l++) {
+				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;