Bring in USB4BSD, Hans Petter Selasky rework of the USB stack

that includes significant features and SMP safety.

This commit includes a more or less complete rewrite of the *BSD USB
stack, including Host Controller and Device Controller drivers and
updating all existing USB drivers to use the new USB API:

1) A brief feature list:

  - A new and mutex enabled USB API.

  - Many USB drivers are now running Giant free.

  - Linux USB kernel compatibility layer.

  - New UGEN backend and libusb library, finally solves the "driver
    unloading" problem. The new BSD licensed libusb20 library is fully
    compatible with libusb-0.1.12 from sourceforge.

  - New "usbconfig" utility, for easy configuration of USB.

  - Full support for Split transactions, which means you can use your
    full speed USB audio device on a high speed USB HUB.

  - Full support for HS ISOC transactions, which makes writing drivers
    for various HS webcams possible, for example.

  - Full support for USB on embedded platforms, mostly cache flushing
    and buffer invalidating stuff.

  - Safer parsing of USB descriptors.

  - Autodetect of annoying USB install disks.

  - Support for USB device side mode, also called USB gadget mode,
    using the same API like the USB host side. In other words the new
    USB stack is symmetric with regard to host and device side.

  - Support for USB transfers like I/O vectors, means more throughput
    and less interrupts.

  - ... see the FreeBSD quarterly status reports under "USB project"

2) To enable the driver in the default kernel build:

2.a) Remove all existing USB device options from your kernel config
file.

2.b) Add the following USB device options to your kernel configuration
file:

# USB core support
device          usb2_core

# USB controller support
device		usb2_controller
device		usb2_controller_ehci
device		usb2_controller_ohci
device		usb2_controller_uhci

# USB mass storage support
device		usb2_storage
device		usb2_storage_mass

# USB ethernet support, requires miibus
device		usb2_ethernet
device		usb2_ethernet_aue
device		usb2_ethernet_axe
device		usb2_ethernet_cdce
device		usb2_ethernet_cue
device		usb2_ethernet_kue
device		usb2_ethernet_rue
device		usb2_ethernet_dav

# USB wireless LAN support
device		usb2_wlan
device		usb2_wlan_rum
device		usb2_wlan_ral
device		usb2_wlan_zyd

# USB serial device support
device		usb2_serial
device		usb2_serial_ark
device		usb2_serial_bsa
device		usb2_serial_bser
device		usb2_serial_chcom
device		usb2_serial_cycom
device		usb2_serial_foma
device		usb2_serial_ftdi
device		usb2_serial_gensa
device		usb2_serial_ipaq
device		usb2_serial_lpt
device		usb2_serial_mct
device		usb2_serial_modem
device		usb2_serial_moscom
device		usb2_serial_plcom
device		usb2_serial_visor
device		usb2_serial_vscom

# USB bluetooth support
device		usb2_bluetooth
device		usb2_bluetooth_ng

# USB input device support
device		usb2_input
device		usb2_input_hid
device		usb2_input_kbd
device		usb2_input_ms

# USB sound and MIDI device support
device		usb2_sound

2) To enable the driver at runtime:

2.a) Unload all existing USB modules. If USB is compiled into the
kernel then you might have to build a new kernel.

2.b) Load the "usb2_xxx.ko" modules under /boot/kernel having the same
base name like the kernel device option.

Submitted by: Hans Petter Selasky hselasky at c2i dot net
Reviewed by: imp, alfred

12 files changed, 6375 insertions, 0 deletions

diff --git a/lib/libusb20/Makefile b/lib/libusb20/Makefile
new file mode 100644
index 0000000..0c0f18f
--- /dev/null
+++ b/lib/libusb20/Makefile
@@ -0,0 +1,24 @@
+#
+# $FreeBSD$
+#
+# Makefile for the FreeBSD specific LibUSB 2.0
+#
+
+LIB=		usb20
+SHLIB_MAJOR=	1
+SHLIB_MINOR=	0
+SRCS=		libusb20.c
+SRCS+=		libusb20_desc.c
+SRCS+=		libusb20_ugen20.c
+SRCS+=		libusb20_compat01.c
+SRCS+=		libusb20_compat10.c
+INCS+=		libusb20.h
+INCS+=		libusb20_desc.h
+INCS+=		libusb20_compat01.h
+INCS+=		libusb20_compat10.h
+MAN=		libusb20.3
+MKLINT=		no
+NOGCCERROR=
+
+.include <bsd.lib.mk>
+
diff --git a/lib/libusb20/libusb20.3 b/lib/libusb20/libusb20.3
new file mode 100644
index 0000000..975bc63
--- /dev/null
+++ b/lib/libusb20/libusb20.3
@@ -0,0 +1,893 @@
+.\"
+.\" Copyright (c) 2008 Hans Petter Selasky
+.\"
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd Oct 23, 2008
+.Dt LIBUSB20 3
+.Os
+.Sh NAME
+.Nm libusb20
+.
+.Nd "USB access library"
+.
+.
+.Sh LIBRARY
+.
+.
+USB access library (libusb20 -lusb20)
+.
+.
+.
+.Sh SYNOPSIS
+.
+.
+.In libusb20.h
+.
+.
+.Sh DESCRIPTION
+.
+The
+.Nm
+library implements functions to be able to easily access and control
+USB through the USB file system interface.
+.
+.
+.Sh USB TRANSFER OPERATIONS
+.
+.Pp
+.
+.Fn libusb20_tr_close
+This function will release all kernel resources associated with an USB
+.Fa xfer .
+.
+This function returns zero upon success.
+.
+Non-zero return values indicate a LIBUSB20_ERROR value.
+.
+.Pp
+.
+.Fn libusb20_tr_open
+This function will allocate kernel resources like
+.Fa MaxBufSize
+and
+.Fa MaxFrameCount
+associated with an USB
+.Fa xfer
+and bind the transfer to the specified
+.Fa ep_no .
+.
+This function returns zero upon success.
+.
+Non-zero return values indicate a LIBUSB20_ERROR value.
+.
+.Pp
+.
+.Fn libusb20_tr_get_pointer
+This function will return a pointer to the allocated USB transfer according to the
+.Fa pdev
+and
+.Fa tr_index
+arguments.
+.
+This function returns NULL in case of failure.
+.
+.Pp
+.
+.Fn libusb20_tr_get_time_complete
+This function will return the completion time of an USB transfer in
+millisecond units. This function is most useful for isochronous USB
+transfers when doing echo cancelling.
+.
+.Pp
+.
+.Fn libusb20_tr_get_actual_frames
+This function will return the actual number of USB frames after an USB
+transfer completed. A value of zero means that no data was transferred.
+.
+.Pp
+.
+.Fn libusb20_tr_get_actual_length
+This function will return the sum of the actual length for all
+transferred USB frames for the given USB transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_get_max_frames
+This function will return the maximum number of USB frames that were
+allocated when an USB transfer was setup for the given USB transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_get_max_packet_length
+This function will return the maximum packet length in bytes
+associated with the given USB transfer.
+.
+The packet length can be used round up buffer sizes so that short USB
+packets are avoided for proxy buffers.
+.
+.
+.Pp
+.
+.Fn libusb20_tr_get_max_total_length
+This function will return the maximum value for the length sum of all
+USB frames associated with an USB transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_get_status
+This function will return the status of an USB transfer.
+.
+Status values are defined by a set of LIBUSB20_TRANSFER_XXX enums.
+.
+.Pp
+.
+.Fn libusb20_tr_pending
+This function will return non-zero if the given USB transfer is
+pending for completion.
+.
+Else this function returns zero.
+.
+.Pp
+.
+.Fn libusb20_tr_callback_wrapper
+This is an internal function used to wrap asynchronous USB callbacks.
+.
+.Pp
+.
+.Fn libusb20_tr_clear_stall_sync
+This is an internal function used to synchronously clear the stall on
+the given USB transfer.
+.
+Please see the USB specification for more information on stall
+clearing.
+.
+If the given USB transfer is pending when this function is called, the
+USB transfer will complete with an error after that this function has
+been called.
+.
+.Pp
+.
+.Fn libusb20_tr_drain
+This function will stop the given USB transfer and will not return
+until the USB transfer has been stopped in hardware.
+.
+.Pp
+.
+.Fn libusb20_tr_set_buffer
+This function is used to set the
+.Fa buffer
+pointer for the given USB transfer and
+.Fa fr_index .
+.
+Typically the frame index is zero.
+.
+.
+.Pp
+.
+.Fn libusb20_tr_set_callback
+This function is used to set the USB callback for asynchronous USB
+transfers.
+.
+The callback type is defined by libusb20_tr_callback_t.
+.
+.Pp
+.
+.Fn libusb20_tr_set_flags
+This function is used to set various USB flags for the given USB transfer.
+.Bl -tag
+.It LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK
+Report a short frame as error.
+.It LIBUSB20_TRANSFER_MULTI_SHORT_NOT_OK
+Multiple short frames are not allowed.
+.It LIBUSB20_TRANSFER_FORCE_SHORT
+All transmitted frames are short terminated.
+.It LIBUSB20_TRANSFER_DO_CLEAR_STALL
+Will do a clear-stall before starting the transfer.
+.El
+.
+.Pp
+.
+.Fn libusb20_tr_set_length
+This function sets the length of a given USB transfer and frame index.
+.
+.Pp
+.
+.Fn libusb20_tr_set_priv_sc0
+This function sets private driver pointer number zero.
+.
+.Pp
+.
+.Fn libusb20_tr_set_priv_sc1
+This function sets private driver pointer number one.
+.
+.Pp
+.
+.Fn libusb20_tr_set_timeout
+This function sets the timeout for the given USB transfer.
+.
+A timeout value of zero means no timeout.
+.
+The timeout is given in milliseconds.
+.
+.Pp
+.
+.Fn libusb20_tr_set_total_frames
+This function sets the total number of frames that should be executed when the USB transfer is submitted.
+.
+The total number of USB frames must be less than the maximum number of USB frames associated with the given USB transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_setup_bulk
+This function is a helper function for setting up a single frame USB BULK transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_setup_control
+This function is a helper function for setting up a single or dual
+frame USB CONTROL transfer depending on the control transfer length.
+.
+.Pp
+.
+.Fn libusb20_tr_setup_intr
+This function is a helper function for setting up a single frame USB INTERRUPT transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_setup_isoc
+This function is a helper function for setting up a multi frame USB ISOCHRONOUS transfer.
+.
+.Pp
+.
+.Fn libusb20_tr_start
+This function will get the USB transfer started, if not already
+started.
+.
+This function will not get the transfer queued in hardware.
+.
+This function is non-blocking.
+.
+.Pp
+.
+.Fn libusb20_tr_stop
+This function will get the USB transfer stopped, if not already stopped.
+.
+This function is non-blocking, which means that the actual stop can
+happen after the return of this function.
+.
+.Pp
+.
+.Fn libusb20_tr_submit
+This function will get the USB transfer queued in hardware.
+.
+.
+.Pp
+.
+.Fn libusb20_tr_get_priv_sc0
+This function returns private driver pointer number zero associated
+with an USB transfer.
+.
+.
+.Pp
+.
+.Fn libusb20_tr_get_priv_sc1
+This function returns private driver pointer number one associated
+with an USB transfer.
+.
+.
+.Sh USB DEVICE OPERATIONS
+.
+.Pp
+.
+.Fn libusb20_dev_get_backend_name
+This function returns a zero terminated string describing the backend used.
+.
+.Pp
+.
+.Fn libusb20_dev_get_desc
+This function returns a zero terminated string describing the given USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_claim_interface
+This function will try to claim the given USB interface given by
+.Fa iface_index .
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_close
+This function will close the given USB device.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_detach_kernel_driver
+This function will try to detach the kernel driver for the USB interface given by
+.Fa iface_index .
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_config_index
+This function will try to set the configuration index on an USB
+device.
+.
+The first configuration index is zero.
+.
+The un-configure index is 255.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_debug
+This function returns the debug level of an USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_get_fd
+This function returns the file descriptor of the given USB device.
+.
+A negative value is returned when no file descriptor is present.
+.
+The file descriptor can be used for polling purposes.
+.
+.Pp
+.
+.Fn libusb20_dev_kernel_driver_active
+This function returns a non-zero value if a kernel driver is active on
+the given USB interface.
+.
+Else zero is returned.
+.
+.Pp
+.
+.Fn libusb20_dev_open
+This function opens an USB device so that setting up USB transfers
+becomes possible.
+.
+The number of USB transfers can be zero which means only control
+transfers are allowed.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+A return value of LIBUSB20_ERROR_BUSY means that the device is already
+opened.
+.
+.Pp
+.
+.Fn libusb20_dev_process
+This function is called to sync kernel USB transfers with userland USB
+transfers.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned typically indicating that the given USB device has been
+detached.
+.
+.Pp
+.
+.Fn libusb20_dev_release_interface
+This function will try to release a claimed USB interface for the specified USB device.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_request_sync
+This function will perform a synchronous control request on the given
+USB device.
+.
+Before this call will succeed the USB device must be opened.
+.
+.Fa setup
+is a pointer to a decoded and host endian SETUP packet.
+.Fa data
+is a pointer to a data transfer buffer associated with the control transaction. This argument can be NULL.
+.Fa pactlen
+is a pointer to a variable that will hold the actual transfer length after the control transaction is complete.
+.Fa timeout
+is the transaction timeout given in milliseconds.
+A timeout of zero means no timeout.
+.Fa flags
+is used to specify transaction flags, for example LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_req_string_sync
+This function will synchronously request an USB string by language ID
+and string index into the given buffer limited by a maximum length.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_req_string_simple_sync
+This function will synchronously request an USB string using the
+default language ID and convert the string into ASCII before storing
+the string into the given buffer limited by a maximum length which
+includes the terminating zero.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.
+.Pp
+.
+.Fn libusb20_dev_reset
+This function will try to BUS reset the given USB device and restore
+the last set USB configuration.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_power_mode
+This function sets the power mode of the USB device.
+.
+Valid power modes:
+.Bl -tag
+.It LIBUSB20_POWER_OFF
+.It LIBUSB20_POWER_ON
+.It LIBUSB20_POWER_SAVE
+.It LIBUSB20_POWER_SUSPEND
+.It LIBUSB20_POWER_RESUME
+.El
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_power_mode
+This function returns the currently selected power mode for the given
+USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_set_alt_index
+This function will try to set the given alternate index for the given
+USB interface index.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_owner
+This function will set the ownership of the given USB device.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_perm
+This function will set the permissions of the given USB device.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_iface_owner
+This function will set the ownership of the given USB interface.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_set_iface_perm
+This function will set the permissions of the given USB interface.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_owner
+This function will retrieve the current USB device ownership.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_perm
+This function will retrieve the current USB device permissions.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_iface_owner
+This function will retrieve the current USB interface ownership for
+the given USB interface.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_iface_perm
+This function will retrieve the current USB interface permissions for
+the given USB interface.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_dev_get_device_desc
+This function returns a pointer to the decoded and host endian version
+of the device descriptor.
+.
+The USB device need not be opened when calling this function.
+.
+.Pp
+.
+.Fn libusb20_dev_alloc_config
+This function will read out and decode the USB config descriptor for
+the given USB device and config index. This function returns a pointer
+to the decoded configuration which must eventually be passed to
+free(). NULL is returned in case of failure.
+.
+.Pp
+.
+.Fn libusb20_dev_alloc(void)
+This is an internal function to allocate a new USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_get_address
+This function returns the internal and not necessarily the real
+hardware address of the given USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_get_bus_number
+This function return the internal bus number which the given USB
+device belongs to.
+.
+.Pp
+.
+.Fn libusb20_dev_get_mode
+This function returns the current operation mode of the USB entity.
+.
+Valid return values are:
+.Bl -tag
+.It LIBUSB20_MODE_HOST
+.It LIBUSB20_MODE_DEVICE
+.El
+.
+.Pp
+.
+.Fn libusb20_dev_get_speed
+This function returns the current speed of the given USB device.
+.
+.Bl -tag
+.It LIBUSB20_SPEED_UNKNOWN
+.It LIBUSB20_SPEED_LOW
+.It LIBUSB20_SPEED_FULL
+.It LIBUSB20_SPEED_HIGH
+.It LIBUSB20_SPEED_VARIABLE
+.It LIBUSB20_SPEED_SUPER
+.El
+.
+.Pp
+.
+.Fn libusb20_dev_get_config_index
+This function returns the currently select config index for the given
+USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_free
+This function will free the given USB device and all associated USB
+transfers.
+.
+.Pp
+.
+.Fn libusb20_dev_set_debug
+This function will set the debug level for the given USB device.
+.
+.Pp
+.
+.Fn libusb20_dev_wait_process
+This function will wait until a pending USB transfer has completed on
+the given USB device.
+.
+A timeout value can be specified which is passed on to the
+.Xr 2 poll
+function.
+.
+.Sh USB BUS OPERATIONS
+.
+.Fn libusb20_bus_set_owner
+This function will set the ownership for the given USB bus.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_bus_set_perm
+This function will set the permissions for the given USB bus.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_bus_get_owner
+This function will retrieve the ownership for the given USB bus.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_bus_get_perm
+This function will retrieve the permissions for the given USB bus.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.
+.Sh USB BACKEND OPERATIONS
+.
+.Fn libusb20_be_get_dev_quirk
+This function will return the device quirk according to
+.Fa index
+into the libusb20_quirk structure pointed to by
+.Fa pq .
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+If the given quirk does not exist LIBUSB20_ERROR_NOT_FOUND is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_get_quirk_name
+This function will return the quirk name according to
+.Fa index
+into the libusb20_quirk structure pointed to by
+.Fa pq .
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+If the given quirk does not exist LIBUSB20_ERROR_NOT_FOUND is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_add_dev_quirk
+This function will add the libusb20_quirk structure pointed to by the
+.Fa pq
+argument into the device quirk list.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+If the given quirk cannot be added LIBUSB20_ERROR_NO_MEM is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_remove_dev_quirk
+This function will remove the quirk matching the libusb20_quirk structure pointed to by the
+.Fa pq
+argument from the device quirk list.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+If the given quirk does not exist LIBUSB20_ERROR_NOT_FOUND is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_set_owner
+This function will set the ownership for the given backend.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_set_perm
+This function will set the permissions for the given backend.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_get_owner
+This function will retrieve the ownership of the given backend.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_get_perm
+This function will retrieve the permissions of the given backend.
+.
+.
+This function returns zero on success else a LIBUSB20_ERROR value is
+returned.
+.
+.Pp
+.
+.Fn libusb20_be_alloc
+This is an internal function to allocate a USB backend.
+.
+.Pp
+.Fn libusb20_be_alloc_default
+.Fn libusb20_be_alloc_freebsd
+.Fn libusb20_be_alloc_linux
+These functions are used to allocate a specific USB backend or the
+operating system default USB backend. Allocating a backend is a way to
+scan for currently present USB devices.
+.
+.Pp
+.
+.Fn libusb20_be_device_foreach
+This function is used to iterate USB devices present in a USB backend.
+.
+The starting value of
+.Fa pdev
+is NULL.
+.
+This function returns the next USB device in the list.
+.
+If NULL is returned the end of the USB device list has been reached.
+.
+.Pp
+.
+.Fn libusb20_be_dequeue_device
+This function will dequeue the given USB device pointer from the
+backend USB device list.
+.
+Dequeued USB devices will not be freed when the backend is freed.
+.
+.Pp
+.
+.Fn libusb20_be_enqueue_device
+This function will enqueue the given USB device pointer in the backend USB device list.
+.
+Enqueued USB devices will get freed when the backend is freed.
+.
+.Pp
+.
+.Fn libusb20_be_free
+This function will free the given backend and all USB devices in its device list.
+.
+.
+.Sh USB DESCRIPTOR PARSING
+.
+.Fn libusb20_me_get_1
+This function will return a byte at the given byte offset of a message
+entity.
+.
+This function is safe against invalid offsets.
+.
+.Pp
+.
+.Fn libusb20_me_get_2
+This function will return a little endian 16-bit value at the given byte offset of a message
+entity.
+.
+This function is safe against invalid offsets.
+.
+.Pp
+.
+.Fn libusb20_me_encode
+This function will encode a so-called *DECODED structure into binary
+format.
+.
+The total encoded length that will fit in the given buffer is
+returned.
+.
+If the buffer pointer is NULL no data will be written to the buffer
+location.
+.
+.Pp
+.
+.Fn libusb20_me_decode
+This function will decode a binary structure into a so-called *DECODED
+structure.
+.
+The total decoded length is returned.
+.
+The buffer pointer cannot be NULL.
+.
+.
+.Sh LIBUSB VERSION 0.1 COMPATIBILITY
+.
+.Fn usb_open
+.Fn usb_close
+.Fn usb_get_string
+.Fn usb_get_string_simple
+.Fn usb_get_descriptor_by_endpoint
+.Fn usb_get_descriptor
+.Fn usb_parse_descriptor
+.Fn usb_parse_configuration
+.Fn usb_destroy_configuration
+.Fn usb_fetch_and_parse_descriptors
+.Fn usb_bulk_write
+.Fn usb_bulk_read
+.Fn usb_interrupt_write
+.Fn usb_interrupt_read
+.Fn usb_control_msg
+.Fn usb_set_configuration
+.Fn usb_claim_interface
+.Fn usb_release_interface
+.Fn usb_set_altinterface
+.Fn usb_resetep
+.Fn usb_clear_halt
+.Fn usb_reset
+.Fn usb_strerror
+.Fn usb_init
+.Fn usb_set_debug
+.Fn usb_find_busses
+.Fn usb_find_devices
+.Fn usb_device
+.Fn usb_get_busses
+These functions are compliant with LibUSB version 0.1.12.
+.
+.Sh FILES
+.
+.
+/dev/usb
+.Sh SEE ALSO
+.Xr usb2_core 4 ,
+.Xr usbconfig 8
+.
+.
+.Sh HISTORY
+.
+.
+Some parts of the
+.Nm
+API derives from the libusb project at sourceforge.
diff --git a/lib/libusb20/libusb20.c b/lib/libusb20/libusb20.c
new file mode 100644
index 0000000..432cd99
--- /dev/null
+++ b/lib/libusb20/libusb20.c
@@ -0,0 +1,1245 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <poll.h>
+#include <ctype.h>
+#include <sys/queue.h>
+
+#include "libusb20.h"
+#include "libusb20_desc.h"
+#include "libusb20_int.h"
+
+static int
+dummy_int(void)
+{
+	return (LIBUSB20_ERROR_NOT_SUPPORTED);
+}
+
+static void
+dummy_void(void)
+{
+	return;
+}
+
+static void
+dummy_callback(struct libusb20_transfer *xfer)
+{
+	;				/* style fix */
+	switch (libusb20_tr_get_status(xfer)) {
+	case LIBUSB20_TRANSFER_START:
+		libusb20_tr_submit(xfer);
+		break;
+	default:
+		/* complete or error */
+		break;
+	}
+	return;
+}
+
+#define	dummy_get_config_desc_full (void *)dummy_int
+#define	dummy_get_config_index (void *)dummy_int
+#define	dummy_set_config_index (void *)dummy_int
+#define	dummy_claim_interface (void *)dummy_int
+#define	dummy_release_interface (void *)dummy_int
+#define	dummy_set_alt_index (void *)dummy_int
+#define	dummy_reset_device (void *)dummy_int
+#define	dummy_set_power_mode (void *)dummy_int
+#define	dummy_get_power_mode (void *)dummy_int
+#define	dummy_kernel_driver_active (void *)dummy_int
+#define	dummy_detach_kernel_driver (void *)dummy_int
+#define	dummy_do_request_sync (void *)dummy_int
+#define	dummy_tr_open (void *)dummy_int
+#define	dummy_tr_close (void *)dummy_int
+#define	dummy_tr_clear_stall_sync (void *)dummy_int
+#define	dummy_process (void *)dummy_int
+
+#define	dummy_tr_submit (void *)dummy_void
+#define	dummy_tr_cancel_async (void *)dummy_void
+
+static const struct libusb20_device_methods libusb20_dummy_methods = {
+	LIBUSB20_DEVICE(LIBUSB20_DECLARE, dummy)
+};
+
+void
+libusb20_tr_callback_wrapper(struct libusb20_transfer *xfer)
+{
+	;				/* style fix */
+
+repeat:
+
+	if (!xfer->is_pending) {
+		xfer->status = LIBUSB20_TRANSFER_START;
+	} else {
+		xfer->is_pending = 0;
+	}
+
+	(xfer->callback) (xfer);
+
+	if (xfer->is_restart) {
+		xfer->is_restart = 0;
+		goto repeat;
+	}
+	if (xfer->is_draining &&
+	    (!xfer->is_pending)) {
+		xfer->is_draining = 0;
+		xfer->status = LIBUSB20_TRANSFER_DRAINED;
+		(xfer->callback) (xfer);
+	}
+	return;
+}
+
+int
+libusb20_tr_close(struct libusb20_transfer *xfer)
+{
+	int error;
+
+	if (!xfer->is_opened) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	error = (xfer->pdev->methods->tr_close) (xfer);
+
+	if (xfer->pLength) {
+		free(xfer->pLength);
+	}
+	if (xfer->ppBuffer) {
+		free(xfer->ppBuffer);
+	}
+	/* clear some fields */
+	xfer->is_opened = 0;
+	xfer->maxFrames = 0;
+	xfer->maxTotalLength = 0;
+	xfer->maxPacketLen = 0;
+	return (error);
+}
+
+int
+libusb20_tr_open(struct libusb20_transfer *xfer, uint32_t MaxBufSize,
+    uint32_t MaxFrameCount, uint8_t ep_no)
+{
+	uint32_t size;
+	int error;
+
+	if (xfer->is_opened) {
+		return (LIBUSB20_ERROR_BUSY);
+	}
+	if (MaxFrameCount == 0) {
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	xfer->maxFrames = MaxFrameCount;
+
+	size = MaxFrameCount * sizeof(xfer->pLength[0]);
+	xfer->pLength = malloc(size);
+	if (xfer->pLength == NULL) {
+		return (LIBUSB20_ERROR_NO_MEM);
+	}
+	memset(xfer->pLength, 0, size);
+
+	size = MaxFrameCount * sizeof(xfer->ppBuffer[0]);
+	xfer->ppBuffer = malloc(size);
+	if (xfer->ppBuffer == NULL) {
+		free(xfer->pLength);
+		return (LIBUSB20_ERROR_NO_MEM);
+	}
+	memset(xfer->ppBuffer, 0, size);
+
+	error = (xfer->pdev->methods->tr_open) (xfer, MaxBufSize,
+	    MaxFrameCount, ep_no);
+
+	if (error) {
+		free(xfer->ppBuffer);
+		free(xfer->pLength);
+	} else {
+		xfer->is_opened = 1;
+	}
+	return (error);
+}
+
+struct libusb20_transfer *
+libusb20_tr_get_pointer(struct libusb20_device *pdev, uint16_t trIndex)
+{
+	if (trIndex >= pdev->nTransfer) {
+		return (NULL);
+	}
+	return (pdev->pTransfer + trIndex);
+}
+
+uint32_t
+libusb20_tr_get_actual_frames(struct libusb20_transfer *xfer)
+{
+	return (xfer->aFrames);
+}
+
+uint16_t
+libusb20_tr_get_time_complete(struct libusb20_transfer *xfer)
+{
+	return (xfer->timeComplete);
+}
+
+uint32_t
+libusb20_tr_get_actual_length(struct libusb20_transfer *xfer)
+{
+	uint32_t x;
+	uint32_t actlen = 0;
+
+	for (x = 0; x != xfer->aFrames; x++) {
+		actlen += xfer->pLength[x];
+	}
+	return (actlen);
+}
+
+uint32_t
+libusb20_tr_get_max_frames(struct libusb20_transfer *xfer)
+{
+	return (xfer->maxFrames);
+}
+
+uint32_t
+libusb20_tr_get_max_packet_length(struct libusb20_transfer *xfer)
+{
+	/*
+	 * Special Case NOTE: If the packet multiplier is non-zero for
+	 * High Speed USB, the value returned is equal to
+	 * "wMaxPacketSize * multiplier" !
+	 */
+	return (xfer->maxPacketLen);
+}
+
+uint32_t
+libusb20_tr_get_max_total_length(struct libusb20_transfer *xfer)
+{
+	return (xfer->maxTotalLength);
+}
+
+uint8_t
+libusb20_tr_get_status(struct libusb20_transfer *xfer)
+{
+	return (xfer->status);
+}
+
+uint8_t
+libusb20_tr_pending(struct libusb20_transfer *xfer)
+{
+	return (xfer->is_pending);
+}
+
+void   *
+libusb20_tr_get_priv_sc0(struct libusb20_transfer *xfer)
+{
+	return (xfer->priv_sc0);
+}
+
+void   *
+libusb20_tr_get_priv_sc1(struct libusb20_transfer *xfer)
+{
+	return (xfer->priv_sc1);
+}
+
+void
+libusb20_tr_stop(struct libusb20_transfer *xfer)
+{
+	if (!xfer->is_pending) {
+		/* transfer not pending */
+		return;
+	}
+	if (xfer->is_cancel) {
+		/* already cancelling */
+		return;
+	}
+	xfer->is_cancel = 1;		/* we are cancelling */
+
+	(xfer->pdev->methods->tr_cancel_async) (xfer);
+	return;
+}
+
+void
+libusb20_tr_drain(struct libusb20_transfer *xfer)
+{
+	/* make sure that we are cancelling */
+	libusb20_tr_stop(xfer);
+
+	if (xfer->is_pending) {
+		xfer->is_draining = 1;
+	}
+	return;
+}
+
+void
+libusb20_tr_clear_stall_sync(struct libusb20_transfer *xfer)
+{
+	(xfer->pdev->methods->tr_clear_stall_sync) (xfer);
+	return;
+}
+
+void
+libusb20_tr_set_buffer(struct libusb20_transfer *xfer, void *buffer, uint16_t frIndex)
+{
+	xfer->ppBuffer[frIndex] = buffer;
+	return;
+}
+
+void
+libusb20_tr_set_callback(struct libusb20_transfer *xfer, libusb20_tr_callback_t *cb)
+{
+	xfer->callback = cb;
+	return;
+}
+
+void
+libusb20_tr_set_flags(struct libusb20_transfer *xfer, uint8_t flags)
+{
+	xfer->flags = flags;
+	return;
+}
+
+void
+libusb20_tr_set_length(struct libusb20_transfer *xfer, uint32_t length, uint16_t frIndex)
+{
+	xfer->pLength[frIndex] = length;
+	return;
+}
+
+void
+libusb20_tr_set_priv_sc0(struct libusb20_transfer *xfer, void *sc0)
+{
+	xfer->priv_sc0 = sc0;
+	return;
+}
+
+void
+libusb20_tr_set_priv_sc1(struct libusb20_transfer *xfer, void *sc1)
+{
+	xfer->priv_sc1 = sc1;
+	return;
+}
+
+void
+libusb20_tr_set_timeout(struct libusb20_transfer *xfer, uint32_t timeout)
+{
+	xfer->timeout = timeout;
+	return;
+}
+
+void
+libusb20_tr_set_total_frames(struct libusb20_transfer *xfer, uint32_t nFrames)
+{
+	if (nFrames > xfer->maxFrames) {
+		/* should not happen */
+		nFrames = xfer->maxFrames;
+	}
+	xfer->nFrames = nFrames;
+	return;
+}
+
+void
+libusb20_tr_setup_bulk(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint32_t timeout)
+{
+	xfer->ppBuffer[0] = pBuf;
+	xfer->pLength[0] = length;
+	xfer->timeout = timeout;
+	xfer->nFrames = 1;
+	return;
+}
+
+void
+libusb20_tr_setup_control(struct libusb20_transfer *xfer, void *psetup, void *pBuf, uint32_t timeout)
+{
+	uint16_t len;
+
+	xfer->ppBuffer[0] = psetup;
+	xfer->pLength[0] = 8;		/* fixed */
+	xfer->timeout = timeout;
+
+	len = ((uint8_t *)psetup)[6] | (((uint8_t *)psetup)[7] << 8);
+
+	if (len != 0) {
+		xfer->nFrames = 2;
+		xfer->ppBuffer[1] = pBuf;
+		xfer->pLength[1] = len;
+	} else {
+		xfer->nFrames = 1;
+	}
+	return;
+}
+
+void
+libusb20_tr_setup_intr(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint32_t timeout)
+{
+	xfer->ppBuffer[0] = pBuf;
+	xfer->pLength[0] = length;
+	xfer->timeout = timeout;
+	xfer->nFrames = 1;
+	return;
+}
+
+void
+libusb20_tr_setup_isoc(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint16_t frIndex)
+{
+	if (frIndex >= xfer->maxFrames) {
+		/* should not happen */
+		return;
+	}
+	xfer->ppBuffer[frIndex] = pBuf;
+	xfer->pLength[frIndex] = length;
+	return;
+}
+
+void
+libusb20_tr_submit(struct libusb20_transfer *xfer)
+{
+	if (xfer->is_pending) {
+		/* should not happen */
+		return;
+	}
+	xfer->is_pending = 1;		/* we are pending */
+	xfer->is_cancel = 0;		/* not cancelling */
+	xfer->is_restart = 0;		/* not restarting */
+
+	(xfer->pdev->methods->tr_submit) (xfer);
+	return;
+}
+
+void
+libusb20_tr_start(struct libusb20_transfer *xfer)
+{
+	if (xfer->is_pending) {
+		if (xfer->is_cancel) {
+			/* cancelling - restart */
+			xfer->is_restart = 1;
+		}
+		/* transfer not pending */
+		return;
+	}
+	/* get into the callback */
+	libusb20_tr_callback_wrapper(xfer);
+	return;
+}
+
+/* USB device operations */
+
+int
+libusb20_dev_claim_interface(struct libusb20_device *pdev, uint8_t ifaceIndex)
+{
+	int error;
+
+	if (ifaceIndex >= 32) {
+		error = LIBUSB20_ERROR_INVALID_PARAM;
+	} else if (pdev->claimed_interfaces & (1 << ifaceIndex)) {
+		error = LIBUSB20_ERROR_NOT_FOUND;
+	} else {
+		error = (pdev->methods->claim_interface) (pdev, ifaceIndex);
+	}
+	if (!error) {
+		pdev->claimed_interfaces |= (1 << ifaceIndex);
+	}
+	return (error);
+}
+
+int
+libusb20_dev_close(struct libusb20_device *pdev)
+{
+	struct libusb20_transfer *xfer;
+	uint16_t x;
+	int error = 0;
+
+	if (!pdev->is_opened) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	for (x = 0; x != pdev->nTransfer; x++) {
+		xfer = pdev->pTransfer + x;
+
+		libusb20_tr_drain(xfer);
+	}
+
+	if (pdev->pTransfer != NULL) {
+		free(pdev->pTransfer);
+		pdev->pTransfer = NULL;
+	}
+	error = (pdev->beMethods->close_device) (pdev);
+
+	pdev->methods = &libusb20_dummy_methods;
+
+	pdev->is_opened = 0;
+
+	return (error);
+}
+
+int
+libusb20_dev_detach_kernel_driver(struct libusb20_device *pdev, uint8_t ifaceIndex)
+{
+	int error;
+
+	error = (pdev->methods->detach_kernel_driver) (pdev, ifaceIndex);
+	return (error);
+}
+
+struct LIBUSB20_DEVICE_DESC_DECODED *
+libusb20_dev_get_device_desc(struct libusb20_device *pdev)
+{
+	return (&(pdev->ddesc));
+}
+
+int
+libusb20_dev_get_fd(struct libusb20_device *pdev)
+{
+	return (pdev->file);
+}
+
+int
+libusb20_dev_kernel_driver_active(struct libusb20_device *pdev, uint8_t ifaceIndex)
+{
+	int error;
+
+	error = (pdev->methods->kernel_driver_active) (pdev, ifaceIndex);
+	return (error);
+}
+
+int
+libusb20_dev_open(struct libusb20_device *pdev, uint16_t nTransferMax)
+{
+	struct libusb20_transfer *xfer;
+	uint32_t size;
+	uint16_t x;
+	int error;
+
+	if (pdev->is_opened) {
+		return (LIBUSB20_ERROR_BUSY);
+	}
+	if (nTransferMax >= 256) {
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	} else if (nTransferMax != 0) {
+		size = sizeof(pdev->pTransfer[0]) * nTransferMax;
+		pdev->pTransfer = malloc(size);
+		if (pdev->pTransfer == NULL) {
+			return (LIBUSB20_ERROR_NO_MEM);
+		}
+		memset(pdev->pTransfer, 0, size);
+	}
+	/* initialise all transfers */
+	for (x = 0; x != nTransferMax; x++) {
+
+		xfer = pdev->pTransfer + x;
+
+		xfer->pdev = pdev;
+		xfer->trIndex = x;
+		xfer->callback = &dummy_callback;
+	}
+
+	error = (pdev->beMethods->open_device) (pdev, nTransferMax);
+
+	if (error) {
+		if (pdev->pTransfer != NULL) {
+			free(pdev->pTransfer);
+			pdev->pTransfer = NULL;
+		}
+		pdev->file = -1;
+		pdev->file_ctrl = -1;
+		pdev->nTransfer = 0;
+	} else {
+		pdev->is_opened = 1;
+		pdev->nTransfer = nTransferMax;
+	}
+	return (error);
+}
+
+int
+libusb20_dev_release_interface(struct libusb20_device *pdev, uint8_t ifaceIndex)
+{
+	int error;
+
+	if (ifaceIndex >= 32) {
+		error = LIBUSB20_ERROR_INVALID_PARAM;
+	} else if (!(pdev->claimed_interfaces & (1 << ifaceIndex))) {
+		error = LIBUSB20_ERROR_NOT_FOUND;
+	} else {
+		error = (pdev->methods->release_interface) (pdev, ifaceIndex);
+	}
+	if (!error) {
+		pdev->claimed_interfaces &= ~(1 << ifaceIndex);
+	}
+	return (error);
+}
+
+int
+libusb20_dev_reset(struct libusb20_device *pdev)
+{
+	int error;
+
+	error = (pdev->methods->reset_device) (pdev);
+	return (error);
+}
+
+int
+libusb20_dev_set_power_mode(struct libusb20_device *pdev, uint8_t power_mode)
+{
+	int error;
+
+	error = (pdev->methods->set_power_mode) (pdev, power_mode);
+	return (error);
+}
+
+uint8_t
+libusb20_dev_get_power_mode(struct libusb20_device *pdev)
+{
+	int error;
+	uint8_t power_mode;
+
+	error = (pdev->methods->get_power_mode) (pdev, &power_mode);
+	if (error)
+		power_mode = LIBUSB20_POWER_ON;	/* fake power mode */
+	return (power_mode);
+}
+
+int
+libusb20_dev_set_alt_index(struct libusb20_device *pdev, uint8_t ifaceIndex, uint8_t altIndex)
+{
+	int error;
+
+	error = (pdev->methods->set_alt_index) (pdev, ifaceIndex, altIndex);
+	return (error);
+}
+
+int
+libusb20_dev_set_config_index(struct libusb20_device *pdev, uint8_t configIndex)
+{
+	int error;
+
+	error = (pdev->methods->set_config_index) (pdev, configIndex);
+	return (error);
+}
+
+int
+libusb20_dev_request_sync(struct libusb20_device *pdev,
+    struct LIBUSB20_CONTROL_SETUP_DECODED *setup, void *data,
+    uint16_t *pactlen, uint32_t timeout, uint8_t flags)
+{
+	int error;
+
+	error = (pdev->methods->do_request_sync) (pdev,
+	    setup, data, pactlen, timeout, flags);
+	return (error);
+}
+
+int
+libusb20_dev_req_string_sync(struct libusb20_device *pdev,
+    uint8_t index, uint16_t langid, void *ptr, uint16_t len)
+{
+	struct LIBUSB20_CONTROL_SETUP_DECODED req;
+	int error;
+
+	if (len < 4) {
+		/* invalid length */
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
+
+	/*
+	 * We need to read the USB string in two steps else some USB
+	 * devices will complain.
+	 */
+	req.bmRequestType =
+	    LIBUSB20_REQUEST_TYPE_STANDARD |
+	    LIBUSB20_RECIPIENT_DEVICE |
+	    LIBUSB20_ENDPOINT_IN;
+	req.bRequest = LIBUSB20_REQUEST_GET_DESCRIPTOR;
+	req.wValue = (LIBUSB20_DT_STRING << 8) | index;
+	req.wIndex = langid;
+	req.wLength = 4;		/* bytes */
+
+	error = libusb20_dev_request_sync(pdev, &req,
+	    ptr, NULL, 1000, LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK);
+	if (error) {
+		return (error);
+	}
+	req.wLength = *(uint8_t *)ptr;	/* bytes */
+	if (req.wLength > len) {
+		/* partial string read */
+		req.wLength = len;
+	}
+	error = libusb20_dev_request_sync(pdev, &req,
+	    ptr, NULL, 1000, LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK);
+
+	if (error) {
+		return (error);
+	}
+	if (((uint8_t *)ptr)[1] != LIBUSB20_DT_STRING) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);			/* success */
+}
+
+int
+libusb20_dev_req_string_simple_sync(struct libusb20_device *pdev,
+    uint8_t index, void *ptr, uint16_t len)
+{
+	char *buf;
+	int error;
+	uint16_t langid;
+	uint16_t n;
+	uint16_t i;
+	uint16_t c;
+	uint8_t temp[255];
+	uint8_t swap;
+
+	/* the following code derives from the FreeBSD USB kernel */
+
+	if ((len < 1) || (ptr == NULL)) {
+		/* too short buffer */
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	/*
+	 * Make sure that there is sensible contents in the buffer in case
+	 * of an error:
+	 */
+	*(uint8_t *)ptr = 0;
+
+	error = libusb20_dev_req_string_sync(pdev,
+	    0, 0, temp, sizeof(temp));
+	if (error < 0)
+		return (error);
+
+	langid = temp[2] | (temp[3] << 8);
+
+	error = libusb20_dev_req_string_sync(pdev, index,
+	    langid, temp, sizeof(temp));
+	if (error < 0)
+		return (error);
+
+	if (temp[0] < 2) {
+		/* string length is too short */
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	/* reserve one byte for terminating zero */
+	len--;
+
+	/* find maximum length */
+	n = (temp[0] / 2) - 1;
+	if (n > len) {
+		n = len;
+	}
+	/* reset swap state */
+	swap = 3;
+
+	/* setup output buffer pointer */
+	buf = ptr;
+
+	/* convert and filter */
+	for (i = 0; (i != n); i++) {
+		c = temp[(2 * i) + 2] | (temp[(2 * i) + 3] << 8);
+
+		/* convert from Unicode, handle buggy strings */
+		if (((c & 0xff00) == 0) && (swap & 1)) {
+			/* Little Endian, default */
+			*buf = c;
+			swap = 1;
+		} else if (((c & 0x00ff) == 0) && (swap & 2)) {
+			/* Big Endian */
+			*buf = c >> 8;
+			swap = 2;
+		} else {
+			*buf = '.';
+		}
+		/*
+		 * Filter by default - we don't allow greater and less than
+		 * signs because they might confuse the dmesg printouts!
+		 */
+		if ((*buf == '<') || (*buf == '>') || (!isprint(*buf))) {
+			*buf = '.';
+		}
+		buf++;
+	}
+	*buf = 0;			/* zero terminate string */
+
+	return (0);
+}
+
+struct libusb20_config *
+libusb20_dev_alloc_config(struct libusb20_device *pdev, uint8_t configIndex)
+{
+	struct libusb20_config *retval = NULL;
+	uint8_t *ptr;
+	uint16_t len;
+	uint8_t do_close;
+	int error;
+
+	if (!pdev->is_opened) {
+		error = libusb20_dev_open(pdev, 0);
+		if (error) {
+			return (NULL);
+		}
+		do_close = 1;
+	} else {
+		do_close = 0;
+	}
+	error = (pdev->methods->get_config_desc_full) (pdev,
+	    &ptr, &len, configIndex);
+
+	if (error) {
+		goto done;
+	}
+	/* parse new config descriptor */
+	retval = libusb20_parse_config_desc(ptr);
+
+	/* free config descriptor */
+	free(ptr);
+
+done:
+	if (do_close) {
+		error = libusb20_dev_close(pdev);
+	}
+	return (retval);
+}
+
+struct libusb20_device *
+libusb20_dev_alloc(void)
+{
+	struct libusb20_device *pdev;
+
+	pdev = malloc(sizeof(*pdev));
+	if (pdev == NULL) {
+		return (NULL);
+	}
+	memset(pdev, 0, sizeof(*pdev));
+
+	pdev->file = -1;
+	pdev->file_ctrl = -1;
+	pdev->methods = &libusb20_dummy_methods;
+	return (pdev);
+}
+
+uint8_t
+libusb20_dev_get_config_index(struct libusb20_device *pdev)
+{
+	int error;
+	uint8_t index;
+	uint8_t do_close;
+
+	if (!pdev->is_opened) {
+		error = libusb20_dev_open(pdev, 0);
+		if (error == 0) {
+			do_close = 1;
+		} else {
+			do_close = 0;
+		}
+	} else {
+		do_close = 0;
+	}
+
+	error = (pdev->methods->get_config_index) (pdev, &index);
+	if (error) {
+		index = 0 - 1;		/* current config index */
+	}
+	if (do_close) {
+		if (libusb20_dev_close(pdev)) {
+			/* ignore */
+		}
+	}
+	return (index);
+}
+
+uint8_t
+libusb20_dev_get_mode(struct libusb20_device *pdev)
+{
+	return (pdev->usb_mode);
+}
+
+uint8_t
+libusb20_dev_get_speed(struct libusb20_device *pdev)
+{
+	return (pdev->usb_speed);
+}
+
+/* if this function returns an error, the device is gone */
+int
+libusb20_dev_process(struct libusb20_device *pdev)
+{
+	int error;
+
+	error = (pdev->methods->process) (pdev);
+	return (error);
+}
+
+void
+libusb20_dev_wait_process(struct libusb20_device *pdev, int timeout)
+{
+	struct pollfd pfd[2];
+
+	if (!pdev->is_opened) {
+		return;
+	}
+	pfd[0].fd = pdev->file;
+	pfd[0].events = (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
+	pfd[0].revents = 0;
+	pfd[1].fd = 0;			/* standard input */
+	pfd[1].events = (POLLIN | POLLRDNORM);
+	pfd[1].revents = 0;
+
+	if (poll(pfd, 2, timeout)) {
+		/* ignore any error */
+	}
+	return;
+}
+
+void
+libusb20_dev_free(struct libusb20_device *pdev)
+{
+	if (pdev == NULL) {
+		/* be NULL safe */
+		return;
+	}
+	if (pdev->is_opened) {
+		if (libusb20_dev_close(pdev)) {
+			/* ignore any errors */
+		}
+	}
+	free(pdev);
+	return;
+}
+
+const char *
+libusb20_dev_get_backend_name(struct libusb20_device *pdev)
+{
+	return ((pdev->beMethods->get_backend_name) ());
+}
+
+const char *
+libusb20_dev_get_desc(struct libusb20_device *pdev)
+{
+	return (pdev->usb_desc);
+}
+
+void
+libusb20_dev_set_debug(struct libusb20_device *pdev, int debug)
+{
+	pdev->debug = debug;
+	return;
+}
+
+int
+libusb20_dev_get_debug(struct libusb20_device *pdev)
+{
+	return (pdev->debug);
+}
+
+uint8_t
+libusb20_dev_get_address(struct libusb20_device *pdev)
+{
+	return (pdev->device_address);
+}
+
+uint8_t
+libusb20_dev_get_bus_number(struct libusb20_device *pdev)
+{
+	return (pdev->bus_number);
+}
+
+int
+libusb20_dev_set_owner(struct libusb20_device *pdev, uid_t user, gid_t group)
+{
+	return ((pdev->beMethods->dev_set_owner) (pdev, user, group));
+}
+
+int
+libusb20_dev_set_perm(struct libusb20_device *pdev, mode_t mode)
+{
+	return ((pdev->beMethods->dev_set_perm) (pdev, mode));
+}
+
+int
+libusb20_dev_set_iface_owner(struct libusb20_device *pdev, uint8_t iface_index, uid_t user, gid_t group)
+{
+	return ((pdev->beMethods->dev_set_iface_owner) (pdev, iface_index, user, group));
+}
+
+int
+libusb20_dev_set_iface_perm(struct libusb20_device *pdev, uint8_t iface_index, mode_t mode)
+{
+	return ((pdev->beMethods->dev_set_iface_perm) (pdev, iface_index, mode));
+}
+
+int
+libusb20_dev_get_owner(struct libusb20_device *pdev, uid_t *user, gid_t *group)
+{
+	uid_t a;
+	gid_t b;
+
+	if (user == NULL)
+		user = &a;
+	if (group == NULL)
+		group = &b;
+
+	return ((pdev->beMethods->dev_get_owner) (pdev, user, group));
+}
+
+int
+libusb20_dev_get_perm(struct libusb20_device *pdev, mode_t *mode)
+{
+	mode_t a;
+
+	if (mode == NULL)
+		mode = &a;
+	return ((pdev->beMethods->dev_get_perm) (pdev, mode));
+}
+
+int
+libusb20_dev_get_iface_owner(struct libusb20_device *pdev, uint8_t iface_index, uid_t *user, gid_t *group)
+{
+	uid_t a;
+	gid_t b;
+
+	if (user == NULL)
+		user = &a;
+	if (group == NULL)
+		group = &b;
+
+	return ((pdev->beMethods->dev_get_iface_owner) (pdev, iface_index, user, group));
+}
+
+int
+libusb20_dev_get_iface_perm(struct libusb20_device *pdev, uint8_t iface_index, mode_t *mode)
+{
+	mode_t a;
+
+	if (mode == NULL)
+		mode = &a;
+	return ((pdev->beMethods->dev_get_iface_perm) (pdev, iface_index, mode));
+}
+
+/* USB bus operations */
+
+int
+libusb20_bus_set_owner(struct libusb20_backend *pbe, uint8_t bus, uid_t user, gid_t group)
+{
+	return ((pbe->methods->bus_set_owner) (pbe, bus, user, group));
+}
+
+int
+libusb20_bus_set_perm(struct libusb20_backend *pbe, uint8_t bus, mode_t mode)
+{
+	return ((pbe->methods->bus_set_perm) (pbe, bus, mode));
+}
+
+int
+libusb20_bus_get_owner(struct libusb20_backend *pbe, uint8_t bus, uid_t *user, gid_t *group)
+{
+	uid_t a;
+	gid_t b;
+
+	if (user == NULL)
+		user = &a;
+	if (group == NULL)
+		group = &b;
+	return ((pbe->methods->bus_get_owner) (pbe, bus, user, group));
+}
+
+int
+libusb20_bus_get_perm(struct libusb20_backend *pbe, uint8_t bus, mode_t *mode)
+{
+	mode_t a;
+
+	if (mode == NULL)
+		mode = &a;
+	return ((pbe->methods->bus_get_perm) (pbe, bus, mode));
+}
+
+/* USB backend operations */
+
+int
+libusb20_be_get_dev_quirk(struct libusb20_backend *pbe,
+    uint16_t index, struct libusb20_quirk *pq)
+{
+	return ((pbe->methods->root_get_dev_quirk) (pbe, index, pq));
+}
+
+int
+libusb20_be_get_quirk_name(struct libusb20_backend *pbe,
+    uint16_t index, struct libusb20_quirk *pq)
+{
+	return ((pbe->methods->root_get_quirk_name) (pbe, index, pq));
+}
+
+int
+libusb20_be_add_dev_quirk(struct libusb20_backend *pbe,
+    struct libusb20_quirk *pq)
+{
+	return ((pbe->methods->root_add_dev_quirk) (pbe, pq));
+}
+
+int
+libusb20_be_remove_dev_quirk(struct libusb20_backend *pbe,
+    struct libusb20_quirk *pq)
+{
+	return ((pbe->methods->root_remove_dev_quirk) (pbe, pq));
+}
+
+int
+libusb20_be_set_owner(struct libusb20_backend *pbe, uid_t user, gid_t group)
+{
+	return ((pbe->methods->root_set_owner) (pbe, user, group));
+}
+
+int
+libusb20_be_set_perm(struct libusb20_backend *pbe, mode_t mode)
+{
+	return ((pbe->methods->root_set_perm) (pbe, mode));
+}
+
+int
+libusb20_be_get_owner(struct libusb20_backend *pbe, uid_t *user, gid_t *group)
+{
+	uid_t a;
+	gid_t b;
+
+	if (user == NULL)
+		user = &a;
+	if (group == NULL)
+		group = &b;
+	return ((pbe->methods->root_get_owner) (pbe, user, group));
+}
+
+int
+libusb20_be_get_perm(struct libusb20_backend *pbe, mode_t *mode)
+{
+	mode_t a;
+
+	if (mode == NULL)
+		mode = &a;
+	return ((pbe->methods->root_get_perm) (pbe, mode));
+}
+
+struct libusb20_device *
+libusb20_be_device_foreach(struct libusb20_backend *pbe, struct libusb20_device *pdev)
+{
+	if (pbe == NULL) {
+		pdev = NULL;
+	} else if (pdev == NULL) {
+		pdev = TAILQ_FIRST(&(pbe->usb_devs));
+	} else {
+		pdev = TAILQ_NEXT(pdev, dev_entry);
+	}
+	return (pdev);
+}
+
+struct libusb20_backend *
+libusb20_be_alloc(const struct libusb20_backend_methods *methods)
+{
+	struct libusb20_backend *pbe;
+
+	pbe = malloc(sizeof(*pbe));
+	if (pbe == NULL) {
+		return (NULL);
+	}
+	memset(pbe, 0, sizeof(*pbe));
+
+	TAILQ_INIT(&(pbe->usb_devs));
+
+	pbe->methods = methods;		/* set backend methods */
+
+	/* do the initial device scan */
+	if (pbe->methods->init_backend) {
+		(pbe->methods->init_backend) (pbe);
+	}
+	return (pbe);
+}
+
+struct libusb20_backend *
+libusb20_be_alloc_linux(void)
+{
+	struct libusb20_backend *pbe;
+
+#ifdef __linux__
+	pbe = libusb20_be_alloc(&libusb20_linux_backend);
+#else
+	pbe = NULL;
+#endif
+	return (pbe);
+}
+
+struct libusb20_backend *
+libusb20_be_alloc_ugen20(void)
+{
+	struct libusb20_backend *pbe;
+
+#ifdef __FreeBSD__
+	pbe = libusb20_be_alloc(&libusb20_ugen20_backend);
+#else
+	pbe = NULL;
+#endif
+	return (pbe);
+}
+
+struct libusb20_backend *
+libusb20_be_alloc_default(void)
+{
+	struct libusb20_backend *pbe;
+
+	pbe = libusb20_be_alloc_linux();
+	if (pbe) {
+		return (pbe);
+	}
+	pbe = libusb20_be_alloc_ugen20();
+	if (pbe) {
+		return (pbe);
+	}
+	return (NULL);			/* no backend found */
+}
+
+void
+libusb20_be_free(struct libusb20_backend *pbe)
+{
+	struct libusb20_device *pdev;
+
+	if (pbe == NULL) {
+		/* be NULL safe */
+		return;
+	}
+	while ((pdev = libusb20_be_device_foreach(pbe, NULL))) {
+		libusb20_be_dequeue_device(pbe, pdev);
+		libusb20_dev_free(pdev);
+	}
+	if (pbe->methods->exit_backend) {
+		(pbe->methods->exit_backend) (pbe);
+	}
+	return;
+}
+
+void
+libusb20_be_enqueue_device(struct libusb20_backend *pbe, struct libusb20_device *pdev)
+{
+	pdev->beMethods = pbe->methods;	/* copy backend methods */
+	TAILQ_INSERT_TAIL(&(pbe->usb_devs), pdev, dev_entry);
+	return;
+}
+
+void
+libusb20_be_dequeue_device(struct libusb20_backend *pbe,
+    struct libusb20_device *pdev)
+{
+	TAILQ_REMOVE(&(pbe->usb_devs), pdev, dev_entry);
+	return;
+}
diff --git a/lib/libusb20/libusb20.h b/lib/libusb20/libusb20.h
new file mode 100644
index 0000000..7fb8e68
--- /dev/null
+++ b/lib/libusb20/libusb20.h
@@ -0,0 +1,313 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ * Copyright (c) 2007-2008 Daniel Drake.  All rights reserved.
+ * Copyright (c) 2001 Johannes Erdfelt.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _LIBUSB20_H_
+#define	_LIBUSB20_H_
+
+#include <stdint.h>
+#include <time.h>
+#include <string.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/endian.h>
+
+#ifdef __cplusplus
+extern	"C" {
+#endif
+#if 0
+};					/* style */
+
+#endif
+
+/** \ingroup misc
+ * Error codes. Most libusb20 functions return 0 on success or one of
+ * these codes on failure.
+ */
+enum libusb20_error {
+	/** Success (no error) */
+	LIBUSB20_SUCCESS = 0,
+
+	/** Input/output error */
+	LIBUSB20_ERROR_IO = -1,
+
+	/** Invalid parameter */
+	LIBUSB20_ERROR_INVALID_PARAM = -2,
+
+	/** Access denied (insufficient permissions) */
+	LIBUSB20_ERROR_ACCESS = -3,
+
+	/** No such device (it may have been disconnected) */
+	LIBUSB20_ERROR_NO_DEVICE = -4,
+
+	/** Entity not found */
+	LIBUSB20_ERROR_NOT_FOUND = -5,
+
+	/** Resource busy */
+	LIBUSB20_ERROR_BUSY = -6,
+
+	/** Operation timed out */
+	LIBUSB20_ERROR_TIMEOUT = -7,
+
+	/** Overflow */
+	LIBUSB20_ERROR_OVERFLOW = -8,
+
+	/** Pipe error */
+	LIBUSB20_ERROR_PIPE = -9,
+
+	/** System call interrupted (perhaps due to signal) */
+	LIBUSB20_ERROR_INTERRUPTED = -10,
+
+	/** Insufficient memory */
+	LIBUSB20_ERROR_NO_MEM = -11,
+
+	/** Operation not supported or unimplemented on this platform */
+	LIBUSB20_ERROR_NOT_SUPPORTED = -12,
+
+	/** Other error */
+	LIBUSB20_ERROR_OTHER = -99,
+};
+
+/** \ingroup asyncio
+ * libusb20_tr_get_status() values */
+enum libusb20_transfer_status {
+	/** Transfer completed without error. Note that this does not
+	 * indicate that the entire amount of requested data was
+	 * transferred. */
+	LIBUSB20_TRANSFER_COMPLETED,
+
+	/** Callback code to start transfer */
+	LIBUSB20_TRANSFER_START,
+
+	/** Drain complete callback code */
+	LIBUSB20_TRANSFER_DRAINED,
+
+	/** Transfer failed */
+	LIBUSB20_TRANSFER_ERROR,
+
+	/** Transfer timed out */
+	LIBUSB20_TRANSFER_TIMED_OUT,
+
+	/** Transfer was cancelled */
+	LIBUSB20_TRANSFER_CANCELLED,
+
+	/** For bulk/interrupt endpoints: halt condition detected
+	 * (endpoint stalled). For control endpoints: control request
+	 * not supported. */
+	LIBUSB20_TRANSFER_STALL,
+
+	/** Device was disconnected */
+	LIBUSB20_TRANSFER_NO_DEVICE,
+
+	/** Device sent more data than requested */
+	LIBUSB20_TRANSFER_OVERFLOW,
+};
+
+/** \ingroup asyncio
+ * libusb20_tr_set_flags() values */
+enum libusb20_transfer_flags {
+	/** Report a short frame as error */
+	LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK = 0x0001,
+
+	/** Multiple short frames are not allowed */
+	LIBUSB20_TRANSFER_MULTI_SHORT_NOT_OK = 0x0002,
+
+	/** All transmitted frames are short terminated */
+	LIBUSB20_TRANSFER_FORCE_SHORT = 0x0004,
+
+	/** Will do a clear-stall before xfer */
+	LIBUSB20_TRANSFER_DO_CLEAR_STALL = 0x0008,
+};
+
+/** \ingroup misc
+ * libusb20_dev_get_mode() values
+ */
+enum libusb20_device_mode {
+	LIBUSB20_MODE_HOST,		/* default */
+	LIBUSB20_MODE_DEVICE,
+};
+
+/** \ingroup misc
+ * libusb20_dev_get_speed() values
+ */
+enum {
+	LIBUSB20_SPEED_UNKNOWN,		/* default */
+	LIBUSB20_SPEED_LOW,
+	LIBUSB20_SPEED_FULL,
+	LIBUSB20_SPEED_HIGH,
+	LIBUSB20_SPEED_VARIABLE,
+	LIBUSB20_SPEED_SUPER,
+};
+
+/** \ingroup misc
+ * libusb20_dev_set_power() values
+ */
+enum {
+	LIBUSB20_POWER_OFF,
+	LIBUSB20_POWER_ON,
+	LIBUSB20_POWER_SAVE,
+	LIBUSB20_POWER_SUSPEND,
+	LIBUSB20_POWER_RESUME,
+};
+
+struct libusb20_transfer;
+struct libusb20_backend;
+struct libusb20_backend_methods;
+struct libusb20_device;
+struct libusb20_device_methods;
+struct libusb20_config;
+struct LIBUSB20_CONTROL_SETUP_DECODED;
+struct LIBUSB20_DEVICE_DESC_DECODED;
+
+typedef void (libusb20_tr_callback_t)(struct libusb20_transfer *xfer);
+
+struct libusb20_quirk {
+	uint16_t vid;			/* vendor ID */
+	uint16_t pid;			/* product ID */
+	uint16_t bcdDeviceLow;		/* low revision value, inclusive */
+	uint16_t bcdDeviceHigh;		/* high revision value, inclusive */
+	uint16_t reserved[2];		/* for the future */
+	/* quirk name, UQ_XXX, including terminating zero */
+	char	quirkname[64 - 12];
+};
+
+/* USB transfer operations */
+
+int	libusb20_tr_close(struct libusb20_transfer *xfer);
+int	libusb20_tr_open(struct libusb20_transfer *xfer, uint32_t pMaxBufSize, uint32_t MaxFrameCount, uint8_t ep_no);
+struct libusb20_transfer *libusb20_tr_get_pointer(struct libusb20_device *pdev, uint16_t tr_index);
+uint16_t libusb20_tr_get_time_complete(struct libusb20_transfer *xfer);
+uint32_t libusb20_tr_get_actual_frames(struct libusb20_transfer *xfer);
+uint32_t libusb20_tr_get_actual_length(struct libusb20_transfer *xfer);
+uint32_t libusb20_tr_get_max_frames(struct libusb20_transfer *xfer);
+uint32_t libusb20_tr_get_max_packet_length(struct libusb20_transfer *xfer);
+uint32_t libusb20_tr_get_max_total_length(struct libusb20_transfer *xfer);
+uint8_t	libusb20_tr_get_status(struct libusb20_transfer *xfer);
+uint8_t	libusb20_tr_pending(struct libusb20_transfer *xfer);
+void	libusb20_tr_callback_wrapper(struct libusb20_transfer *xfer);
+void	libusb20_tr_clear_stall_sync(struct libusb20_transfer *xfer);
+void	libusb20_tr_drain(struct libusb20_transfer *xfer);
+void	libusb20_tr_set_buffer(struct libusb20_transfer *xfer, void *buffer, uint16_t fr_index);
+void	libusb20_tr_set_callback(struct libusb20_transfer *xfer, libusb20_tr_callback_t *cb);
+void	libusb20_tr_set_flags(struct libusb20_transfer *xfer, uint8_t flags);
+void	libusb20_tr_set_length(struct libusb20_transfer *xfer, uint32_t length, uint16_t fr_index);
+void	libusb20_tr_set_priv_sc0(struct libusb20_transfer *xfer, void *sc0);
+void	libusb20_tr_set_priv_sc1(struct libusb20_transfer *xfer, void *sc1);
+void	libusb20_tr_set_timeout(struct libusb20_transfer *xfer, uint32_t timeout);
+void	libusb20_tr_set_total_frames(struct libusb20_transfer *xfer, uint32_t nFrames);
+void	libusb20_tr_setup_bulk(struct libusb20_transfer *xfer, void *pbuf, uint32_t length, uint32_t timeout);
+void	libusb20_tr_setup_control(struct libusb20_transfer *xfer, void *psetup, void *pbuf, uint32_t timeout);
+void	libusb20_tr_setup_intr(struct libusb20_transfer *xfer, void *pbuf, uint32_t length, uint32_t timeout);
+void	libusb20_tr_setup_isoc(struct libusb20_transfer *xfer, void *pbuf, uint32_t length, uint16_t fr_index);
+void	libusb20_tr_start(struct libusb20_transfer *xfer);
+void	libusb20_tr_stop(struct libusb20_transfer *xfer);
+void	libusb20_tr_submit(struct libusb20_transfer *xfer);
+void   *libusb20_tr_get_priv_sc0(struct libusb20_transfer *xfer);
+void   *libusb20_tr_get_priv_sc1(struct libusb20_transfer *xfer);
+
+
+/* USB device operations */
+
+const char *libusb20_dev_get_backend_name(struct libusb20_device *pdev);
+const char *libusb20_dev_get_desc(struct libusb20_device *pdev);
+int	libusb20_dev_claim_interface(struct libusb20_device *pdev, uint8_t iface_index);
+int	libusb20_dev_close(struct libusb20_device *pdev);
+int	libusb20_dev_detach_kernel_driver(struct libusb20_device *pdev, uint8_t iface_index);
+int	libusb20_dev_set_config_index(struct libusb20_device *pdev, uint8_t configIndex);
+int	libusb20_dev_get_debug(struct libusb20_device *pdev);
+int	libusb20_dev_get_fd(struct libusb20_device *pdev);
+int	libusb20_dev_kernel_driver_active(struct libusb20_device *pdev, uint8_t iface_index);
+int	libusb20_dev_open(struct libusb20_device *pdev, uint16_t transfer_max);
+int	libusb20_dev_process(struct libusb20_device *pdev);
+int	libusb20_dev_release_interface(struct libusb20_device *pdev, uint8_t iface_index);
+int	libusb20_dev_request_sync(struct libusb20_device *pdev, struct LIBUSB20_CONTROL_SETUP_DECODED *setup, void *data, uint16_t *pactlen, uint32_t timeout, uint8_t flags);
+int	libusb20_dev_req_string_sync(struct libusb20_device *pdev, uint8_t index, uint16_t langid, void *ptr, uint16_t len);
+int	libusb20_dev_req_string_simple_sync(struct libusb20_device *pdev, uint8_t index, void *ptr, uint16_t len);
+int	libusb20_dev_reset(struct libusb20_device *pdev);
+int	libusb20_dev_set_power_mode(struct libusb20_device *pdev, uint8_t power_mode);
+uint8_t	libusb20_dev_get_power_mode(struct libusb20_device *pdev);
+int	libusb20_dev_set_alt_index(struct libusb20_device *pdev, uint8_t iface_index, uint8_t alt_index);
+int	libusb20_dev_set_owner(struct libusb20_device *pdev, uid_t user, gid_t group);
+int	libusb20_dev_set_perm(struct libusb20_device *pdev, mode_t mode);
+int	libusb20_dev_set_iface_owner(struct libusb20_device *pdev, uint8_t iface_index, uid_t user, gid_t group);
+int	libusb20_dev_set_iface_perm(struct libusb20_device *pdev, uint8_t iface_index, mode_t mode);
+int	libusb20_dev_get_owner(struct libusb20_device *pdev, uid_t *user, gid_t *group);
+int	libusb20_dev_get_perm(struct libusb20_device *pdev, mode_t *mode);
+int	libusb20_dev_get_iface_owner(struct libusb20_device *pdev, uint8_t iface_index, uid_t *user, gid_t *group);
+int	libusb20_dev_get_iface_perm(struct libusb20_device *pdev, uint8_t iface_index, mode_t *mode);
+
+struct LIBUSB20_DEVICE_DESC_DECODED *libusb20_dev_get_device_desc(struct libusb20_device *pdev);
+struct libusb20_config *libusb20_dev_alloc_config(struct libusb20_device *pdev, uint8_t config_index);
+struct libusb20_device *libusb20_dev_alloc(void);
+uint8_t	libusb20_dev_get_address(struct libusb20_device *pdev);
+uint8_t	libusb20_dev_get_bus_number(struct libusb20_device *pdev);
+uint8_t	libusb20_dev_get_mode(struct libusb20_device *pdev);
+uint8_t	libusb20_dev_get_speed(struct libusb20_device *pdev);
+uint8_t	libusb20_dev_get_config_index(struct libusb20_device *pdev);
+void	libusb20_dev_free(struct libusb20_device *pdev);
+void	libusb20_dev_set_debug(struct libusb20_device *pdev, int debug);
+void	libusb20_dev_wait_process(struct libusb20_device *pdev, int timeout);
+
+/* USB bus operations */
+
+int	libusb20_bus_set_owner(struct libusb20_backend *pbe, uint8_t bus, uid_t user, gid_t group);
+int	libusb20_bus_set_perm(struct libusb20_backend *pbe, uint8_t bus, mode_t mode);
+int	libusb20_bus_get_owner(struct libusb20_backend *pbe, uint8_t bus, uid_t *user, gid_t *group);
+int	libusb20_bus_get_perm(struct libusb20_backend *pbe, uint8_t bus, mode_t *mode);
+
+/* USB global operations */
+
+int	libusb20_be_get_dev_quirk(struct libusb20_backend *pbe, uint16_t index, struct libusb20_quirk *pq);
+int	libusb20_be_get_quirk_name(struct libusb20_backend *pbe, uint16_t index, struct libusb20_quirk *pq);
+int	libusb20_be_add_dev_quirk(struct libusb20_backend *pbe, struct libusb20_quirk *pq);
+int	libusb20_be_remove_dev_quirk(struct libusb20_backend *pbe, struct libusb20_quirk *pq);
+int	libusb20_be_set_owner(struct libusb20_backend *be, uid_t user, gid_t group);
+int	libusb20_be_set_perm(struct libusb20_backend *be, mode_t mode);
+int	libusb20_be_get_owner(struct libusb20_backend *be, uid_t *user, gid_t *group);
+int	libusb20_be_get_perm(struct libusb20_backend *be, mode_t *mode);
+
+/* USB backend operations */
+
+struct libusb20_backend *libusb20_be_alloc(const struct libusb20_backend_methods *methods);
+struct libusb20_backend *libusb20_be_alloc_default(void);
+struct libusb20_backend *libusb20_be_alloc_freebsd(void);
+struct libusb20_backend *libusb20_be_alloc_linux(void);
+struct libusb20_device *libusb20_be_device_foreach(struct libusb20_backend *pbe, struct libusb20_device *pdev);
+void	libusb20_be_dequeue_device(struct libusb20_backend *pbe, struct libusb20_device *pdev);
+void	libusb20_be_enqueue_device(struct libusb20_backend *pbe, struct libusb20_device *pdev);
+void	libusb20_be_free(struct libusb20_backend *pbe);
+
+#if 0
+{					/* style */
+#endif
+#ifdef __cplusplus
+}
+
+#endif
+
+#endif					/* _LIBUSB20_H_ */
diff --git a/lib/libusb20/libusb20_compat01.c b/lib/libusb20/libusb20_compat01.c
new file mode 100644
index 0000000..e9d9ebe
--- /dev/null
+++ b/lib/libusb20/libusb20_compat01.c
@@ -0,0 +1,902 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * This file contains the emulation layer for LibUSB v0.1 from sourceforge.
+ */
+
+#include <sys/queue.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libusb20.h"
+#include "libusb20_desc.h"
+#include "libusb20_int.h"
+#include "libusb20_compat01.h"
+
+/*
+ * The two following macros were taken from the original LibUSB v0.1
+ * for sake of compatibility:
+ */
+#define	LIST_ADD(begin, ent)	   \
+  do {				   \
+    if (begin) {		   \
+      ent->next = begin;	   \
+      ent->next->prev = ent;	   \
+    } else {			   \
+      ent->next = NULL;		   \
+    }				   \
+    ent->prev = NULL;		   \
+    begin = ent;		   \
+  } while(0)
+
+#define	LIST_DEL(begin, ent)		 \
+  do {					 \
+    if (ent->prev) {			 \
+      ent->prev->next = ent->next;	 \
+    } else {				 \
+      begin = ent->next;		 \
+    }					 \
+    if (ent->next) {			 \
+      ent->next->prev = ent->prev;	 \
+    }					 \
+    ent->prev = NULL;			 \
+    ent->next = NULL;			 \
+  } while (0)
+
+struct usb_bus *usb_busses = NULL;
+
+static struct usb_bus usb_global_bus = {
+	.dirname = {"/dev/usb"},
+	.root_dev = NULL,
+	.devices = NULL,
+};
+
+static struct libusb20_backend *usb_backend = NULL;
+
+struct usb_parse_state {
+
+	struct {
+		struct libusb20_endpoint *currep;
+		struct libusb20_interface *currifc;
+		struct libusb20_config *currcfg;
+		struct libusb20_me_struct *currextra;
+	}	a;
+
+	struct {
+		struct usb_config_descriptor *currcfg;
+		struct usb_interface_descriptor *currifc;
+		struct usb_endpoint_descriptor *currep;
+		struct usb_interface *currifcw;
+		uint8_t *currextra;
+	}	b;
+
+	uint8_t	preparse;
+};
+
+static uint8_t
+usb_get_first_claimed_interface(usb_dev_handle * dev)
+{
+	struct libusb20_device *pdev = (void *)dev;
+	uint32_t x;
+	uint8_t y;
+
+	x = pdev->claimed_interfaces;
+
+	for (y = 0; y != 32; y++) {
+		if (x & (1 << y))
+			break;
+	}
+
+	if (y == 32)
+		y = 0xFF;		/* dummy */
+
+	return (y);
+}
+
+static struct libusb20_transfer *
+usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no)
+{
+	struct libusb20_device *pdev = (void *)dev;
+	struct libusb20_transfer *xfer;
+	int err;
+	uint32_t bufsize;
+	uint8_t x;
+	uint8_t speed;
+
+	x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2;
+
+	if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) {
+		/* this is a IN endpoint */
+		x |= 1;
+	}
+	speed = libusb20_dev_get_speed(pdev);
+
+	/* select a sensible buffer size */
+	if (speed == LIBUSB20_SPEED_LOW) {
+		bufsize = 256;
+	} else if (speed == LIBUSB20_SPEED_FULL) {
+		bufsize = 4096;
+	} else {
+		bufsize = 16384;
+	}
+
+	xfer = libusb20_tr_get_pointer(pdev, x);
+
+	if (xfer == NULL)
+		return (xfer);
+
+	err = libusb20_tr_open(xfer, bufsize, 1, ep_no);
+	if (err == LIBUSB20_ERROR_BUSY) {
+		/* already opened */
+		return (xfer);
+	} else if (err) {
+		return (NULL);
+	}
+	/* success */
+	return (xfer);
+}
+
+usb_dev_handle *
+usb_open(struct usb_device *dev)
+{
+	int err;
+
+	err = libusb20_dev_open(dev->dev, 16 * 2);
+	if (err == LIBUSB20_ERROR_BUSY) {
+		/*
+		 * Workaround buggy USB applications which open the USB
+		 * device multiple times:
+		 */
+		return (dev->dev);
+	}
+	if (err)
+		return (NULL);
+
+	return (dev->dev);
+}
+
+int
+usb_close(usb_dev_handle * dev)
+{
+	int err;
+
+	err = libusb20_dev_close((void *)dev);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_get_string(usb_dev_handle * dev, int index,
+    int langid, char *buf, size_t buflen)
+{
+	int err;
+
+	err = libusb20_dev_req_string_sync((void *)dev,
+	    index, langid, buf, buflen);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_get_string_simple(usb_dev_handle * dev, int index,
+    char *buf, size_t buflen)
+{
+	int err;
+
+	err = libusb20_dev_req_string_simple_sync((void *)dev,
+	    index, buf, buflen);
+
+	if (err)
+		return (-1);
+
+	return (strlen(buf));
+}
+
+int
+usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type,
+    uint8_t index, void *buf, int size)
+{
+	memset(buf, 0, size);
+
+	return (usb_control_msg(udev, ep | USB_ENDPOINT_IN,
+	    USB_REQ_GET_DESCRIPTOR, (type << 8) + index, 0,
+	    buf, size, 1000));
+}
+
+int
+usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t index,
+    void *buf, int size)
+{
+	memset(buf, 0, size);
+
+	return (usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
+	    (type << 8) + index, 0, buf, size, 1000));
+}
+
+int
+usb_parse_descriptor(uint8_t *source, char *description, void *dest)
+{
+	uint8_t *sp = source;
+	uint8_t *dp = dest;
+	uint16_t w;
+	uint32_t d;
+	char *cp;
+
+	for (cp = description; *cp; cp++) {
+		switch (*cp) {
+		case 'b':		/* 8-bit byte */
+			*dp++ = *sp++;
+			break;
+			/*
+			 * 16-bit word, convert from little endian to CPU
+			 */
+		case 'w':
+			w = (sp[1] << 8) | sp[0];
+			sp += 2;
+			/* Align to word boundary */
+			dp += ((dp - (uint8_t *)0) & 1);
+			*((uint16_t *)dp) = w;
+			dp += 2;
+			break;
+			/*
+			 * 32-bit dword, convert from little endian to CPU
+			 */
+		case 'd':
+			d = (sp[3] << 24) | (sp[2] << 16) |
+			    (sp[1] << 8) | sp[0];
+			sp += 4;
+			/* Align to word boundary */
+			dp += ((dp - (uint8_t *)0) & 1);
+			/* Align to double word boundary */
+			dp += ((dp - (uint8_t *)0) & 2);
+			*((uint32_t *)dp) = d;
+			dp += 4;
+			break;
+		}
+	}
+	return (sp - source);
+}
+
+static void
+usb_parse_extra(struct usb_parse_state *ps, uint8_t **pptr, int *plen)
+{
+	void *ptr;
+	uint16_t len;
+
+	ptr = ps->a.currextra->ptr;
+	len = ps->a.currextra->len;
+
+	if (ps->preparse == 0) {
+		memcpy(ps->b.currextra, ptr, len);
+		*pptr = ps->b.currextra;
+		*plen = len;
+	}
+	ps->b.currextra += len;
+	return;
+}
+
+static void
+usb_parse_endpoint(struct usb_parse_state *ps)
+{
+	struct usb_endpoint_descriptor *bep;
+	struct libusb20_endpoint *aep;
+
+	aep = ps->a.currep;
+	bep = ps->b.currep++;
+
+	if (ps->preparse == 0) {
+		/* copy descriptor fields */
+		bep->bLength = aep->desc.bLength;
+		bep->bDescriptorType = aep->desc.bDescriptorType;
+		bep->bEndpointAddress = aep->desc.bEndpointAddress;
+		bep->bmAttributes = aep->desc.bmAttributes;
+		bep->wMaxPacketSize = aep->desc.wMaxPacketSize;
+		bep->bInterval = aep->desc.bInterval;
+		bep->bRefresh = aep->desc.bRefresh;
+		bep->bSynchAddress = aep->desc.bSynchAddress;
+	}
+	ps->a.currextra = &aep->extra;
+	usb_parse_extra(ps, &bep->extra, &bep->extralen);
+	return;
+}
+
+static void
+usb_parse_iface_sub(struct usb_parse_state *ps)
+{
+	struct libusb20_interface *aifc;
+	struct usb_interface_descriptor *bifc;
+	uint8_t x;
+
+	aifc = ps->a.currifc;
+	bifc = ps->b.currifc++;
+
+	if (ps->preparse == 0) {
+		/* copy descriptor fields */
+		bifc->bLength = aifc->desc.bLength;
+		bifc->bDescriptorType = aifc->desc.bDescriptorType;
+		bifc->bInterfaceNumber = aifc->desc.bInterfaceNumber;
+		bifc->bAlternateSetting = aifc->desc.bAlternateSetting;
+		bifc->bNumEndpoints = aifc->num_endpoints;
+		bifc->bInterfaceClass = aifc->desc.bInterfaceClass;
+		bifc->bInterfaceSubClass = aifc->desc.bInterfaceSubClass;
+		bifc->bInterfaceProtocol = aifc->desc.bInterfaceProtocol;
+		bifc->iInterface = aifc->desc.iInterface;
+		bifc->endpoint = ps->b.currep;
+	}
+	for (x = 0; x != aifc->num_endpoints; x++) {
+		ps->a.currep = aifc->endpoints + x;
+		usb_parse_endpoint(ps);
+	}
+
+	ps->a.currextra = &aifc->extra;
+	usb_parse_extra(ps, &bifc->extra, &bifc->extralen);
+	return;
+}
+
+static void
+usb_parse_iface(struct usb_parse_state *ps)
+{
+	struct libusb20_interface *aifc;
+	struct usb_interface *bifc;
+	uint8_t x;
+
+	aifc = ps->a.currifc;
+	bifc = ps->b.currifcw++;
+
+	if (ps->preparse == 0) {
+		/* initialise interface wrapper */
+		bifc->altsetting = ps->b.currifc;
+		bifc->num_altsetting = aifc->num_altsetting + 1;
+	}
+	usb_parse_iface_sub(ps);
+
+	for (x = 0; x != aifc->num_altsetting; x++) {
+		ps->a.currifc = aifc->altsetting + x;
+		usb_parse_iface_sub(ps);
+	}
+	return;
+}
+
+static void
+usb_parse_config(struct usb_parse_state *ps)
+{
+	struct libusb20_config *acfg;
+	struct usb_config_descriptor *bcfg;
+	uint8_t x;
+
+	acfg = ps->a.currcfg;
+	bcfg = ps->b.currcfg;
+
+	if (ps->preparse == 0) {
+		/* initialise config wrapper */
+		bcfg->bLength = acfg->desc.bLength;
+		bcfg->bDescriptorType = acfg->desc.bDescriptorType;
+		bcfg->wTotalLength = acfg->desc.wTotalLength;
+		bcfg->bNumInterfaces = acfg->num_interface;
+		bcfg->bConfigurationValue = acfg->desc.bConfigurationValue;
+		bcfg->iConfiguration = acfg->desc.iConfiguration;
+		bcfg->bmAttributes = acfg->desc.bmAttributes;
+		bcfg->MaxPower = acfg->desc.bMaxPower;
+		bcfg->interface = ps->b.currifcw;
+	}
+	for (x = 0; x != acfg->num_interface; x++) {
+		ps->a.currifc = acfg->interface + x;
+		usb_parse_iface(ps);
+	}
+
+	ps->a.currextra = &acfg->extra;
+	usb_parse_extra(ps, &bcfg->extra, &bcfg->extralen);
+	return;
+}
+
+int
+usb_parse_configuration(struct usb_config_descriptor *config,
+    uint8_t *buffer)
+{
+	struct usb_parse_state ps;
+	uint8_t *ptr;
+	uint32_t a;
+	uint32_t b;
+	uint32_t c;
+	uint32_t d;
+
+	if ((buffer == NULL) || (config == NULL)) {
+		return (-1);
+	}
+	memset(&ps, 0, sizeof(ps));
+
+	ps.a.currcfg = libusb20_parse_config_desc(buffer);
+	ps.b.currcfg = config;
+	if (ps.a.currcfg == NULL) {
+		/* could not parse config or out of memory */
+		return (-1);
+	}
+	/* do the pre-parse */
+	ps.preparse = 1;
+	usb_parse_config(&ps);
+
+	a = ((uint8_t *)(ps.b.currifcw) - ((uint8_t *)0));
+	b = ((uint8_t *)(ps.b.currifc) - ((uint8_t *)0));
+	c = ((uint8_t *)(ps.b.currep) - ((uint8_t *)0));
+	d = ((uint8_t *)(ps.b.currextra) - ((uint8_t *)0));
+
+	/* allocate memory for our configuration */
+	ptr = malloc(a + b + c + d);
+
+	/* "currifcw" must be first, hence this pointer is freed */
+	ps.b.currifcw = (void *)(ptr);
+	ps.b.currifc = (void *)(ptr + a);
+	ps.b.currep = (void *)(ptr + a + b);
+	ps.b.currextra = (void *)(ptr + a + b + c);
+
+	/* generate a libusb v0.1 compatible structure */
+	ps.preparse = 0;
+	usb_parse_config(&ps);
+
+	/* free config structure */
+	free(ps.a.currcfg);
+
+	return (0);			/* success */
+}
+
+void
+usb_destroy_configuration(struct usb_device *dev)
+{
+	uint8_t c;
+
+	if (dev->config == NULL) {
+		return;
+	}
+	for (c = 0; c != dev->descriptor.bNumConfigurations; c++) {
+		struct usb_config_descriptor *cf = &dev->config[c];
+
+		if (cf->interface != NULL) {
+			free(cf->interface);
+			cf->interface = NULL;
+		}
+	}
+
+	free(dev->config);
+	dev->config = NULL;
+	return;
+}
+
+void
+usb_fetch_and_parse_descriptors(usb_dev_handle * udev)
+{
+	struct usb_device *dev;
+	struct libusb20_device *pdev;
+	uint8_t *ptr;
+	int error;
+	uint32_t size;
+	uint16_t len;
+	uint8_t x;
+
+	if (udev == NULL) {
+		/* be NULL safe */
+		return;
+	}
+	dev = usb_device(udev);
+	pdev = (void *)udev;
+
+	if (dev->descriptor.bNumConfigurations == 0) {
+		/* invalid device */
+		return;
+	}
+	size = dev->descriptor.bNumConfigurations *
+	    sizeof(struct usb_config_descriptor);
+
+	dev->config = malloc(size);
+	if (dev->config == NULL) {
+		/* out of memory */
+		return;
+	}
+	memset(dev->config, 0, size);
+
+	for (x = 0; x != dev->descriptor.bNumConfigurations; x++) {
+
+		error = (pdev->methods->get_config_desc_full) (
+		    pdev, &ptr, &len, x);
+
+		if (error) {
+			usb_destroy_configuration(dev);
+			return;
+		}
+		usb_parse_configuration(dev->config + x, ptr);
+
+		/* free config buffer */
+		free(ptr);
+	}
+	return;
+}
+
+static int
+usb_std_io(usb_dev_handle * dev, int ep, char *bytes, int size,
+    int timeout, int is_intr)
+{
+	struct libusb20_transfer *xfer;
+	uint32_t temp;
+	uint32_t maxsize;
+	uint32_t actlen;
+	char *oldbytes;
+
+	xfer = usb_get_transfer_by_ep_no(dev, ep);
+	if (xfer == NULL)
+		return (-1);
+
+	if (libusb20_tr_pending(xfer)) {
+		/* there is already a transfer ongoing */
+		return (-1);
+	}
+	maxsize = libusb20_tr_get_max_total_length(xfer);
+	oldbytes = bytes;
+
+	/*
+	 * We allow transferring zero bytes which is the same
+	 * equivalent to a zero length USB packet.
+	 */
+	do {
+
+		temp = size;
+		if (temp > maxsize) {
+			/* find maximum possible length */
+			temp = maxsize;
+		}
+		if (is_intr)
+			libusb20_tr_setup_intr(xfer, bytes, temp, timeout);
+		else
+			libusb20_tr_setup_bulk(xfer, bytes, temp, timeout);
+
+		libusb20_tr_start(xfer);
+
+		while (1) {
+
+			if (libusb20_dev_process((void *)dev) != 0) {
+				/* device detached */
+				return (-1);
+			}
+			if (libusb20_tr_pending(xfer) == 0) {
+				/* transfer complete */
+				break;
+			}
+			/* wait for USB event from kernel */
+			libusb20_dev_wait_process((void *)dev, -1);
+		}
+
+		if (libusb20_tr_get_status(xfer)) {
+			/* transfer error */
+			return (-1);
+		}
+		actlen = libusb20_tr_get_actual_length(xfer);
+
+		bytes += actlen;
+		size -= actlen;
+
+		if (actlen != temp) {
+			/* short transfer */
+			break;
+		}
+	} while (size > 0);
+
+	return (bytes - oldbytes);
+}
+
+int
+usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes,
+    int size, int timeout)
+{
+	return (usb_std_io(dev, ep, bytes, size, timeout, 0));
+}
+
+int
+usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes,
+    int size, int timeout)
+{
+	return (usb_std_io(dev, ep, bytes, size, timeout, 0));
+}
+
+int
+usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes,
+    int size, int timeout)
+{
+	return (usb_std_io(dev, ep, bytes, size, timeout, 1));
+}
+
+int
+usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes,
+    int size, int timeout)
+{
+	return (usb_std_io(dev, ep, bytes, size, timeout, 1));
+}
+
+int
+usb_control_msg(usb_dev_handle * dev, int requesttype, int request,
+    int value, int index, char *bytes, int size, int timeout)
+{
+	struct LIBUSB20_CONTROL_SETUP_DECODED req;
+	int err;
+	uint16_t actlen;
+
+	LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
+
+	req.bmRequestType = requesttype;
+	req.bRequest = request;
+	req.wValue = value;
+	req.wIndex = index;
+	req.wLength = size;
+
+	err = libusb20_dev_request_sync((void *)dev, &req, bytes,
+	    &actlen, timeout, 0);
+
+	if (err)
+		return (-1);
+
+	return (actlen);
+}
+
+int
+usb_set_configuration(usb_dev_handle * dev, int configuration)
+{
+	int err;
+
+	err = libusb20_dev_set_config_index((void *)dev, configuration);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_claim_interface(usb_dev_handle * dev, int interface)
+{
+	int err;
+
+	err = libusb20_dev_claim_interface((void *)dev, interface);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_release_interface(usb_dev_handle * dev, int interface)
+{
+	int err;
+
+	err = libusb20_dev_release_interface((void *)dev, interface);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_set_altinterface(usb_dev_handle * dev, int alternate)
+{
+	int err;
+	uint8_t iface;
+
+	iface = usb_get_first_claimed_interface(dev);
+
+	err = libusb20_dev_set_alt_index((void *)dev, iface, alternate);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+int
+usb_resetep(usb_dev_handle * dev, unsigned int ep)
+{
+	/* emulate an endpoint reset through clear-STALL */
+	return (usb_clear_halt(dev, ep));
+}
+
+int
+usb_clear_halt(usb_dev_handle * dev, unsigned int ep)
+{
+	struct libusb20_transfer *xfer;
+
+	xfer = usb_get_transfer_by_ep_no(dev, ep);
+	if (xfer == NULL)
+		return (-1);
+
+	libusb20_tr_clear_stall_sync(xfer);
+
+	return (0);
+}
+
+int
+usb_reset(usb_dev_handle * dev)
+{
+	int err;
+
+	err = libusb20_dev_reset((void *)dev);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+char   *
+usb_strerror(void)
+{
+	/* TODO */
+	return ("Unknown error");
+}
+
+void
+usb_init(void)
+{
+	/* nothing to do */
+	return;
+}
+
+void
+usb_set_debug(int level)
+{
+	/* use kernel UGEN debugging if you need to see what is going on */
+	return;
+}
+
+int
+usb_find_busses(void)
+{
+	usb_busses = &usb_global_bus;
+	return (0);
+}
+
+int
+usb_find_devices(void)
+{
+	struct libusb20_device *pdev;
+	struct usb_device *udev;
+	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
+	struct libusb20_backend *pold;
+	int err;
+
+	/* cleanup after last device search */
+
+	pold = usb_backend;
+
+	pdev = NULL;
+	while ((pdev = libusb20_be_device_foreach(pold, pdev))) {
+		if (!pdev->is_opened) {
+			/*
+			 * if the device has not been opened we free the
+			 * device data
+			 */
+			udev = pdev->priv01Data;
+			libusb20_be_dequeue_device(pold, pdev);
+			libusb20_dev_free(pdev);
+			if (udev != NULL) {
+				LIST_DEL(usb_global_bus.devices, udev);
+				free(udev);
+			}
+			pdev = NULL;	/* restart search */
+		}
+	}
+
+	/* do a new backend device search */
+
+	usb_backend = libusb20_be_alloc_default();
+	if (usb_backend == NULL) {
+		usb_backend = pold;	/* restore */
+		return (-1);
+	}
+	/* iterate all devices */
+
+	pdev = NULL;
+	while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) {
+		udev = malloc(sizeof(*udev));
+		if (udev == NULL)
+			break;
+
+		memset(udev, 0, sizeof(*udev));
+
+		udev->bus = &usb_global_bus;
+
+		snprintf(udev->filename, sizeof(udev->filename),
+		    "/dev/ugen%u.%u",
+		    libusb20_dev_get_bus_number(pdev),
+		    libusb20_dev_get_address(pdev));
+
+		ddesc = libusb20_dev_get_device_desc(pdev);
+
+		udev->descriptor.bLength = sizeof(udev->descriptor);
+		udev->descriptor.bDescriptorType = ddesc->bDescriptorType;
+		udev->descriptor.bcdUSB = ddesc->bcdUSB;
+		udev->descriptor.bDeviceClass = ddesc->bDeviceClass;
+		udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass;
+		udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol;
+		udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0;
+		udev->descriptor.idVendor = ddesc->idVendor;
+		udev->descriptor.idProduct = ddesc->idProduct;
+		udev->descriptor.bcdDevice = ddesc->bcdDevice;
+		udev->descriptor.iManufacturer = ddesc->iManufacturer;
+		udev->descriptor.iProduct = ddesc->iProduct;
+		udev->descriptor.iSerialNumber = ddesc->iSerialNumber;
+		udev->descriptor.bNumConfigurations =
+		    ddesc->bNumConfigurations;
+		if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
+			/* truncate number of configurations */
+			udev->descriptor.bNumConfigurations = USB_MAXCONFIG;
+		}
+		/* link together the two structures */
+		udev->dev = pdev;
+		pdev->priv01Data = udev;
+
+		err = libusb20_dev_open(pdev, 0);
+		if (err == 0) {
+			/* XXX get all config descriptors by default */
+			usb_fetch_and_parse_descriptors((void *)pdev);
+			libusb20_dev_close(pdev);
+		}
+		LIST_ADD(usb_global_bus.devices, udev);
+	}
+
+	/* move old devices over to the new USB backend */
+
+	while ((pdev = libusb20_be_device_foreach(pold, pdev))) {
+		libusb20_be_dequeue_device(pold, pdev);
+		libusb20_be_enqueue_device(usb_backend, pdev);
+	}
+
+	/* free old backend, if any */
+
+	libusb20_be_free(pold);
+
+	return (0);			/* success */
+}
+
+struct usb_device *
+usb_device(usb_dev_handle * dev)
+{
+	struct libusb20_device *pdev;
+
+	pdev = (void *)dev;
+
+	return (pdev->priv01Data);
+}
+
+struct usb_bus *
+usb_get_busses(void)
+{
+	return (usb_busses);
+}
diff --git a/lib/libusb20/libusb20_compat01.h b/lib/libusb20/libusb20_compat01.h
new file mode 100644
index 0000000..333793d
--- /dev/null
+++ b/lib/libusb20/libusb20_compat01.h
@@ -0,0 +1,310 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _LIBUSB20_COMPAT_01_H_
+#define	_LIBUSB20_COMPAT_01_H_
+
+#include <sys/stdint.h>
+#include <sys/endian.h>
+#include <sys/types.h>
+#include <sys/param.h>
+
+/* USB interface class codes */
+
+#define	USB_CLASS_PER_INTERFACE         0
+#define	USB_CLASS_AUDIO                 1
+#define	USB_CLASS_COMM                  2
+#define	USB_CLASS_HID                   3
+#define	USB_CLASS_PRINTER               7
+#define	USB_CLASS_PTP                   6
+#define	USB_CLASS_MASS_STORAGE          8
+#define	USB_CLASS_HUB                   9
+#define	USB_CLASS_DATA                  10
+#define	USB_CLASS_VENDOR_SPEC           0xff
+
+/* USB descriptor types */
+
+#define	USB_DT_DEVICE                   0x01
+#define	USB_DT_CONFIG                   0x02
+#define	USB_DT_STRING                   0x03
+#define	USB_DT_INTERFACE                0x04
+#define	USB_DT_ENDPOINT                 0x05
+
+#define	USB_DT_HID                      0x21
+#define	USB_DT_REPORT                   0x22
+#define	USB_DT_PHYSICAL                 0x23
+#define	USB_DT_HUB                      0x29
+
+/* USB descriptor type sizes */
+
+#define	USB_DT_DEVICE_SIZE              18
+#define	USB_DT_CONFIG_SIZE              9
+#define	USB_DT_INTERFACE_SIZE           9
+#define	USB_DT_ENDPOINT_SIZE            7
+#define	USB_DT_ENDPOINT_AUDIO_SIZE      9
+#define	USB_DT_HUB_NONVAR_SIZE          7
+
+/* USB descriptor header */
+struct usb_descriptor_header {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+};
+
+/* USB string descriptor */
+struct usb_string_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint16_t wData[1];
+};
+
+/* USB HID descriptor */
+struct usb_hid_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint16_t bcdHID;
+	uint8_t	bCountryCode;
+	uint8_t	bNumDescriptors;
+	/* uint8_t  bReportDescriptorType; */
+	/* uint16_t wDescriptorLength; */
+	/* ... */
+};
+
+/* USB endpoint descriptor */
+#define	USB_MAXENDPOINTS        32
+struct usb_endpoint_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint8_t	bEndpointAddress;
+#define	USB_ENDPOINT_ADDRESS_MASK       0x0f
+#define	USB_ENDPOINT_DIR_MASK           0x80
+	uint8_t	bmAttributes;
+#define	USB_ENDPOINT_TYPE_MASK          0x03
+#define	USB_ENDPOINT_TYPE_CONTROL       0
+#define	USB_ENDPOINT_TYPE_ISOCHRONOUS   1
+#define	USB_ENDPOINT_TYPE_BULK          2
+#define	USB_ENDPOINT_TYPE_INTERRUPT     3
+	uint16_t wMaxPacketSize;
+	uint8_t	bInterval;
+	uint8_t	bRefresh;
+	uint8_t	bSynchAddress;
+
+	uint8_t *extra;			/* Extra descriptors */
+	int	extralen;
+};
+
+/* USB interface descriptor */
+#define	USB_MAXINTERFACES       32
+struct usb_interface_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint8_t	bInterfaceNumber;
+	uint8_t	bAlternateSetting;
+	uint8_t	bNumEndpoints;
+	uint8_t	bInterfaceClass;
+	uint8_t	bInterfaceSubClass;
+	uint8_t	bInterfaceProtocol;
+	uint8_t	iInterface;
+
+	struct usb_endpoint_descriptor *endpoint;
+
+	uint8_t *extra;			/* Extra descriptors */
+	int	extralen;
+};
+
+#define	USB_MAXALTSETTING       128	/* Hard limit */
+struct usb_interface {
+	struct usb_interface_descriptor *altsetting;
+
+	int	num_altsetting;
+};
+
+/* USB configuration descriptor */
+#define	USB_MAXCONFIG           8
+struct usb_config_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint16_t wTotalLength;
+	uint8_t	bNumInterfaces;
+	uint8_t	bConfigurationValue;
+	uint8_t	iConfiguration;
+	uint8_t	bmAttributes;
+	uint8_t	MaxPower;
+
+	struct usb_interface *interface;
+
+	uint8_t *extra;			/* Extra descriptors */
+	int	extralen;
+};
+
+/* USB device descriptor */
+struct usb_device_descriptor {
+	uint8_t	bLength;
+	uint8_t	bDescriptorType;
+	uint16_t bcdUSB;
+	uint8_t	bDeviceClass;
+	uint8_t	bDeviceSubClass;
+	uint8_t	bDeviceProtocol;
+	uint8_t	bMaxPacketSize0;
+	uint16_t idVendor;
+	uint16_t idProduct;
+	uint16_t bcdDevice;
+	uint8_t	iManufacturer;
+	uint8_t	iProduct;
+	uint8_t	iSerialNumber;
+	uint8_t	bNumConfigurations;
+};
+
+/* USB setup packet */
+struct usb_ctrl_setup {
+	uint8_t	bRequestType;
+#define	USB_RECIP_DEVICE                0x00
+#define	USB_RECIP_INTERFACE             0x01
+#define	USB_RECIP_ENDPOINT              0x02
+#define	USB_RECIP_OTHER                 0x03
+#define	USB_TYPE_STANDARD               (0x00 << 5)
+#define	USB_TYPE_CLASS                  (0x01 << 5)
+#define	USB_TYPE_VENDOR                 (0x02 << 5)
+#define	USB_TYPE_RESERVED               (0x03 << 5)
+#define	USB_ENDPOINT_IN                 0x80
+#define	USB_ENDPOINT_OUT                0x00
+	uint8_t	bRequest;
+#define	USB_REQ_GET_STATUS              0x00
+#define	USB_REQ_CLEAR_FEATURE           0x01
+#define	USB_REQ_SET_FEATURE             0x03
+#define	USB_REQ_SET_ADDRESS             0x05
+#define	USB_REQ_GET_DESCRIPTOR          0x06
+#define	USB_REQ_SET_DESCRIPTOR          0x07
+#define	USB_REQ_GET_CONFIGURATION       0x08
+#define	USB_REQ_SET_CONFIGURATION       0x09
+#define	USB_REQ_GET_INTERFACE           0x0A
+#define	USB_REQ_SET_INTERFACE           0x0B
+#define	USB_REQ_SYNCH_FRAME             0x0C
+	uint16_t wValue;
+	uint16_t wIndex;
+	uint16_t wLength;
+};
+
+/* Error codes */
+#define	USB_ERROR_BEGIN                 500000
+
+/* Byte swapping */
+#define	USB_LE16_TO_CPU(x) le16toh(x)
+
+/* Data types */
+struct usb_device;
+struct usb_bus;
+
+/*
+ * To maintain compatibility with applications already built with libusb,
+ * we must only add entries to the end of this structure. NEVER delete or
+ * move members and only change types if you really know what you're doing.
+ */
+struct usb_device {
+	struct usb_device *next;
+	struct usb_device *prev;
+
+	char	filename[PATH_MAX + 1];
+
+	struct usb_bus *bus;
+
+	struct usb_device_descriptor descriptor;
+	struct usb_config_descriptor *config;
+
+	void   *dev;
+
+	uint8_t	devnum;
+
+	uint8_t	num_children;
+	struct usb_device **children;
+};
+
+struct usb_bus {
+	struct usb_bus *next;
+	struct usb_bus *prev;
+
+	char	dirname[PATH_MAX + 1];
+
+	struct usb_device *devices;
+	uint32_t location;
+
+	struct usb_device *root_dev;
+};
+
+struct usb_dev_handle;
+typedef struct usb_dev_handle usb_dev_handle;
+
+/* Variables */
+extern struct usb_bus *usb_busses;
+
+#ifdef __cplusplus
+extern	"C" {
+#endif
+#if 0
+}					/* style */
+
+#endif
+
+/* Function prototypes from "libusb20_compat01.c" */
+
+usb_dev_handle *usb_open(struct usb_device *dev);
+int	usb_close(usb_dev_handle * dev);
+int	usb_get_string(usb_dev_handle * dev, int index, int langid, char *buf, size_t buflen);
+int	usb_get_string_simple(usb_dev_handle * dev, int index, char *buf, size_t buflen);
+int	usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type, uint8_t index, void *buf, int size);
+int	usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t index, void *buf, int size);
+int	usb_parse_descriptor(uint8_t *source, char *description, void *dest);
+int	usb_parse_configuration(struct usb_config_descriptor *config, uint8_t *buffer);
+void	usb_destroy_configuration(struct usb_device *dev);
+void	usb_fetch_and_parse_descriptors(usb_dev_handle * udev);
+int	usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes, int size, int timeout);
+int	usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes, int size, int timeout);
+int	usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes, int size, int timeout);
+int	usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes, int size, int timeout);
+int	usb_control_msg(usb_dev_handle * dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout);
+int	usb_set_configuration(usb_dev_handle * dev, int configuration);
+int	usb_claim_interface(usb_dev_handle * dev, int interface);
+int	usb_release_interface(usb_dev_handle * dev, int interface);
+int	usb_set_altinterface(usb_dev_handle * dev, int alternate);
+int	usb_resetep(usb_dev_handle * dev, unsigned int ep);
+int	usb_clear_halt(usb_dev_handle * dev, unsigned int ep);
+int	usb_reset(usb_dev_handle * dev);
+char   *usb_strerror(void);
+void	usb_init(void);
+void	usb_set_debug(int level);
+int	usb_find_busses(void);
+int	usb_find_devices(void);
+struct usb_device *usb_device(usb_dev_handle * dev);
+struct usb_bus *usb_get_busses(void);
+
+#if 0
+{					/* style */
+#endif
+#ifdef __cplusplus
+}
+
+#endif
+
+#endif					/* _LIBUSB20_COMPAT01_H_ */
diff --git a/lib/libusb20/libusb20_compat10.c b/lib/libusb20/libusb20_compat10.c
new file mode 100644
index 0000000..3624485
--- /dev/null
+++ b/lib/libusb20/libusb20_compat10.c
@@ -0,0 +1,29 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * This file contains the emulation layer for LibUSB v1.0 from sourceforge.
+ */
diff --git a/lib/libusb20/libusb20_compat10.h b/lib/libusb20/libusb20_compat10.h
new file mode 100644
index 0000000..d98895f
--- /dev/null
+++ b/lib/libusb20/libusb20_compat10.h
@@ -0,0 +1,25 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
diff --git a/lib/libusb20/libusb20_desc.c b/lib/libusb20/libusb20_desc.c
new file mode 100644
index 0000000..fbbd96f
--- /dev/null
+++ b/lib/libusb20/libusb20_desc.c
@@ -0,0 +1,771 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <poll.h>
+#include <sys/queue.h>
+
+#include "libusb20.h"
+#include "libusb20_desc.h"
+#include "libusb20_int.h"
+
+static const uint32_t libusb20_me_encode_empty[2];	/* dummy */
+
+LIBUSB20_MAKE_STRUCT_FORMAT(LIBUSB20_DEVICE_DESC);
+LIBUSB20_MAKE_STRUCT_FORMAT(LIBUSB20_ENDPOINT_DESC);
+LIBUSB20_MAKE_STRUCT_FORMAT(LIBUSB20_INTERFACE_DESC);
+LIBUSB20_MAKE_STRUCT_FORMAT(LIBUSB20_CONFIG_DESC);
+LIBUSB20_MAKE_STRUCT_FORMAT(LIBUSB20_CONTROL_SETUP);
+
+/*------------------------------------------------------------------------*
+ *	libusb20_parse_config_desc
+ *
+ * Return values:
+ * NULL: Out of memory.
+ * Else: A valid config structure pointer which must be passed to "free()"
+ *------------------------------------------------------------------------*/
+struct libusb20_config *
+libusb20_parse_config_desc(const void *config_desc)
+{
+	struct libusb20_config *lub_config;
+	struct libusb20_interface *lub_interface;
+	struct libusb20_interface *lub_alt_interface;
+	struct libusb20_interface *last_if;
+	struct libusb20_endpoint *lub_endpoint;
+	struct libusb20_endpoint *last_ep;
+
+	struct libusb20_me_struct pcdesc;
+	const uint8_t *ptr;
+	uint32_t size;
+	uint16_t niface_no_alt;
+	uint16_t niface;
+	uint16_t nendpoint;
+	uint8_t iface_no;
+
+	ptr = config_desc;
+	if (ptr[1] != LIBUSB20_DT_CONFIG) {
+		return (NULL);		/* not config descriptor */
+	}
+	/*
+	 * The first "bInterfaceNumber" should never have the value 0xff.
+	 * Then it is corrupt.
+	 */
+	niface_no_alt = 0;
+	nendpoint = 0;
+	niface = 0;
+	iface_no = 0 - 1;
+	ptr = NULL;
+
+	/* get "wTotalLength" and setup "pcdesc" */
+	pcdesc.ptr = LIBUSB20_ADD_BYTES(config_desc, 0);
+	pcdesc.len =
+	    ((uint8_t *)config_desc)[2] |
+	    (((uint8_t *)config_desc)[3] << 8);
+	pcdesc.type = LIBUSB20_ME_IS_RAW;
+
+	/* descriptor pre-scan */
+	while ((ptr = libusb20_desc_foreach(&pcdesc, ptr))) {
+		if (ptr[1] == LIBUSB20_DT_ENDPOINT) {
+			nendpoint++;
+		} else if ((ptr[1] == LIBUSB20_DT_INTERFACE) && (ptr[0] >= 4)) {
+			niface++;
+			/* check "bInterfaceNumber" */
+			if (ptr[2] != iface_no) {
+				iface_no = ptr[2];
+				niface_no_alt++;
+			}
+		}
+	}
+
+	/* sanity checking */
+	if (niface >= 256) {
+		return (NULL);		/* corrupt */
+	}
+	if (nendpoint >= 256) {
+		return (NULL);		/* corrupt */
+	}
+	size = sizeof(*lub_config) +
+	    (niface * sizeof(*lub_interface)) +
+	    (nendpoint * sizeof(*lub_endpoint)) +
+	    pcdesc.len;
+
+	lub_config = malloc(size);
+	if (lub_config == NULL) {
+		return (NULL);		/* out of memory */
+	}
+	lub_interface = (void *)(lub_config + 1);
+	lub_alt_interface = (void *)(lub_interface + niface_no_alt);
+	lub_endpoint = (void *)(lub_interface + niface);
+
+	/*
+	 * Make a copy of the config descriptor, so that the caller can free
+	 * the inital config descriptor pointer!
+	 */
+	ptr = (void *)(lub_endpoint + nendpoint);
+	memcpy(LIBUSB20_ADD_BYTES(ptr, 0), config_desc, pcdesc.len);
+	pcdesc.ptr = LIBUSB20_ADD_BYTES(ptr, 0);
+	config_desc = LIBUSB20_ADD_BYTES(ptr, 0);
+
+	/* init config structure */
+
+	ptr = config_desc;
+
+	LIBUSB20_INIT(LIBUSB20_CONFIG_DESC, &lub_config->desc);
+
+	if (libusb20_me_decode(ptr, ptr[0], &lub_config->desc)) {
+		/* ignore */
+	}
+	lub_config->num_interface = 0;
+	lub_config->interface = lub_interface;
+	lub_config->extra.ptr = LIBUSB20_ADD_BYTES(ptr, ptr[0]);
+	lub_config->extra.len = -ptr[0];
+	lub_config->extra.type = LIBUSB20_ME_IS_RAW;
+
+	/* reset states */
+	niface = 0;
+	iface_no = 0 - 1;
+	ptr = NULL;
+	lub_interface--;
+	lub_endpoint--;
+	last_if = NULL;
+	last_ep = NULL;
+
+	/* descriptor pre-scan */
+	while ((ptr = libusb20_desc_foreach(&pcdesc, ptr))) {
+		if (ptr[1] == LIBUSB20_DT_ENDPOINT) {
+			if (last_if) {
+				lub_endpoint++;
+				last_ep = lub_endpoint;
+				last_if->num_endpoints++;
+
+				LIBUSB20_INIT(LIBUSB20_ENDPOINT_DESC, &last_ep->desc);
+
+				if (libusb20_me_decode(ptr, ptr[0], &last_ep->desc)) {
+					/* ignore */
+				}
+				last_ep->extra.ptr = LIBUSB20_ADD_BYTES(ptr, ptr[0]);
+				last_ep->extra.len = 0;
+				last_ep->extra.type = LIBUSB20_ME_IS_RAW;
+			} else {
+				lub_config->extra.len += ptr[0];
+			}
+
+		} else if ((ptr[1] == LIBUSB20_DT_INTERFACE) && (ptr[0] >= 4)) {
+			if (ptr[2] != iface_no) {
+				/* new interface */
+				iface_no = ptr[2];
+				lub_interface++;
+				lub_config->num_interface++;
+				last_if = lub_interface;
+				niface++;
+			} else {
+				/* one more alternate setting */
+				lub_interface->num_altsetting++;
+				last_if = lub_alt_interface;
+				lub_alt_interface++;
+			}
+
+			LIBUSB20_INIT(LIBUSB20_INTERFACE_DESC, &last_if->desc);
+
+			if (libusb20_me_decode(ptr, ptr[0], &last_if->desc)) {
+				/* ignore */
+			}
+			/*
+			 * Sometimes USB devices have corrupt interface
+			 * descriptors and we need to overwrite the provided
+			 * interface number!
+			 */
+			last_if->desc.bInterfaceNumber = niface - 1;
+			last_if->extra.ptr = LIBUSB20_ADD_BYTES(ptr, ptr[0]);
+			last_if->extra.len = 0;
+			last_if->extra.type = LIBUSB20_ME_IS_RAW;
+			last_if->endpoints = lub_endpoint + 1;
+			last_if->altsetting = lub_alt_interface;
+			last_if->num_altsetting = 0;
+			last_if->num_endpoints = 0;
+			last_ep = NULL;
+		} else {
+			/* unknown descriptor */
+			if (last_if) {
+				if (last_ep) {
+					last_ep->extra.len += ptr[0];
+				} else {
+					last_if->extra.len += ptr[0];
+				}
+			} else {
+				lub_config->extra.len += ptr[0];
+			}
+		}
+	}
+	return (lub_config);
+}
+
+/*------------------------------------------------------------------------*
+ *	libusb20_desc_foreach
+ *
+ * Safe traversal of USB descriptors.
+ *
+ * Return values:
+ * NULL: End of descriptors
+ * Else: Pointer to next descriptor
+ *------------------------------------------------------------------------*/
+const uint8_t *
+libusb20_desc_foreach(const struct libusb20_me_struct *pdesc,
+    const uint8_t *psubdesc)
+{
+	void *end;
+
+	if (pdesc == NULL) {
+		return (NULL);
+	}
+	end = LIBUSB20_ADD_BYTES(pdesc->ptr, pdesc->len);
+
+	if (psubdesc == NULL) {
+		psubdesc = LIBUSB20_ADD_BYTES(pdesc->ptr, 0);
+	} else {
+		psubdesc = LIBUSB20_ADD_BYTES(psubdesc, psubdesc[0]);
+	}
+	return (((((void *)psubdesc) >= ((void *)(pdesc->ptr))) &&
+	    (((void *)psubdesc) < end) &&
+	    (LIBUSB20_ADD_BYTES(psubdesc, psubdesc[0]) >= ((void *)(pdesc->ptr))) &&
+	    (LIBUSB20_ADD_BYTES(psubdesc, psubdesc[0]) <= end) &&
+	    (psubdesc[0] >= 3)) ? psubdesc : NULL);
+}
+
+/*------------------------------------------------------------------------*
+ *	libusb20_me_get_1 - safety wrapper to read out one byte
+ *------------------------------------------------------------------------*/
+uint8_t
+libusb20_me_get_1(const struct libusb20_me_struct *ie, uint16_t offset)
+{
+	if (offset < ie->len) {
+		return (*((uint8_t *)LIBUSB20_ADD_BYTES(ie->ptr, offset)));
+	}
+	return (0);
+}
+
+/*------------------------------------------------------------------------*
+ *	libusb20_me_get_2 - safety wrapper to read out one word
+ *------------------------------------------------------------------------*/
+uint16_t
+libusb20_me_get_2(const struct libusb20_me_struct *ie, uint16_t offset)
+{
+	return (libusb20_me_get_1(ie, offset) |
+	    (libusb20_me_get_1(ie, offset + 1) << 8));
+}
+
+/*------------------------------------------------------------------------*
+ *	libusb20_me_encode - encode a message structure
+ *
+ * Description of parameters:
+ * "len" - maximum length of output buffer
+ * "ptr" - pointer to output buffer. If NULL, no data will be written
+ * "pd" - source structure
+ *
+ * Return values:
+ * 0..65535 - Number of bytes used, limited by the "len" input parameter.
+ *------------------------------------------------------------------------*/
+uint16_t
+libusb20_me_encode(void *ptr, uint16_t len, const void *pd)
+{
+	const uint8_t *pf;		/* pointer to format data */
+	uint8_t *buf;			/* pointer to output buffer */
+
+	uint32_t pd_offset;		/* decoded structure offset */
+	uint16_t len_old;		/* old length */
+	uint16_t pd_count;		/* decoded element count */
+	uint8_t me;			/* message element */
+
+	/* initialise */
+
+	len_old = len;
+	buf = ptr;
+	pd_offset = sizeof(void *);
+	pf = (*((struct libusb20_me_format **)pd))->format;
+
+	/* scan */
+
+	while (1) {
+
+		/* get information element */
+
+		me = (pf[0]) & LIBUSB20_ME_MASK;
+		pd_count = pf[1] | (pf[2] << 8);
+		pf += 3;
+
+		/* encode the message element */
+
+		switch (me) {
+		case LIBUSB20_ME_INT8:
+			while (pd_count--) {
+				uint8_t temp;
+
+				if (len < 1)	/* overflow */
+					goto done;
+				if (buf) {
+					temp = *((const uint8_t *)
+					    LIBUSB20_ADD_BYTES(pd, pd_offset));
+					buf[0] = temp;
+					buf += 1;
+				}
+				pd_offset += 1;
+				len -= 1;
+			}
+			break;
+
+		case LIBUSB20_ME_INT16:
+			pd_offset = -((-pd_offset) & ~1);	/* align */
+			while (pd_count--) {
+				uint16_t temp;
+
+				if (len < 2)	/* overflow */
+					goto done;
+
+				if (buf) {
+					temp = *((const uint16_t *)
+					    LIBUSB20_ADD_BYTES(pd, pd_offset));
+					buf[1] = (temp >> 8) & 0xFF;
+					buf[0] = temp & 0xFF;
+					buf += 2;
+				}
+				pd_offset += 2;
+				len -= 2;
+			}
+			break;
+
+		case LIBUSB20_ME_INT32:
+			pd_offset = -((-pd_offset) & ~3);	/* align */
+			while (pd_count--) {
+				uint32_t temp;
+
+				if (len < 4)	/* overflow */
+					goto done;
+				if (buf) {
+					temp = *((const uint32_t *)
+					    LIBUSB20_ADD_BYTES(pd, pd_offset));
+					buf[3] = (temp >> 24) & 0xFF;
+					buf[2] = (temp >> 16) & 0xFF;
+					buf[1] = (temp >> 8) & 0xFF;
+					buf[0] = temp & 0xFF;
+					buf += 4;
+				}
+				pd_offset += 4;
+				len -= 4;
+			}
+			break;
+
+		case LIBUSB20_ME_INT64:
+			pd_offset = -((-pd_offset) & ~7);	/* align */
+			while (pd_count--) {
+				uint64_t temp;
+
+				if (len < 8)	/* overflow */
+					goto done;
+				if (buf) {
+
+					temp = *((const uint64_t *)
+					    LIBUSB20_ADD_BYTES(pd, pd_offset));
+					buf[7] = (temp >> 56) & 0xFF;
+					buf[6] = (temp >> 48) & 0xFF;
+					buf[5] = (temp >> 40) & 0xFF;
+					buf[4] = (temp >> 32) & 0xFF;
+					buf[3] = (temp >> 24) & 0xFF;
+					buf[2] = (temp >> 16) & 0xFF;
+					buf[1] = (temp >> 8) & 0xFF;
+					buf[0] = temp & 0xFF;
+					buf += 8;
+				}
+				pd_offset += 8;
+				len -= 8;
+			}
+			break;
+
+		case LIBUSB20_ME_STRUCT:
+			pd_offset = -((-pd_offset) &
+			    ~(LIBUSB20_ME_STRUCT_ALIGN - 1));	/* align */
+			while (pd_count--) {
+				void *src_ptr;
+				uint16_t src_len;
+				struct libusb20_me_struct *ps;
+
+				ps = LIBUSB20_ADD_BYTES(pd, pd_offset);
+
+				switch (ps->type) {
+				case LIBUSB20_ME_IS_RAW:
+					src_len = ps->len;
+					src_ptr = ps->ptr;
+					break;
+
+				case LIBUSB20_ME_IS_ENCODED:
+					if (ps->len == 0) {
+						/*
+						 * Length is encoded
+						 * in the data itself
+						 * and should be
+						 * correct:
+						 */
+						ps->len = 0 - 1;
+					}
+					src_len = libusb20_me_get_1(pd, 0);
+					src_ptr = LIBUSB20_ADD_BYTES(ps->ptr, 1);
+					if (src_len == 0xFF) {
+						/* length is escaped */
+						src_len = libusb20_me_get_2(pd, 1);
+						src_ptr =
+						    LIBUSB20_ADD_BYTES(ps->ptr, 3);
+					}
+					break;
+
+				case LIBUSB20_ME_IS_DECODED:
+					/* reserve 3 length bytes */
+					src_len = libusb20_me_encode(NULL,
+					    0 - 1 - 3, ps->ptr);
+					src_ptr = NULL;
+					break;
+
+				default:	/* empty structure */
+					src_len = 0;
+					src_ptr = NULL;
+					break;
+				}
+
+				if (src_len > 0xFE) {
+					if (src_len > (uint16_t)(0 - 1 - 3))
+						/* overflow */
+						goto done;
+
+					if (len < (src_len + 3))
+						/* overflow */
+						goto done;
+
+					if (buf) {
+						buf[0] = 0xFF;
+						buf[1] = (src_len & 0xFF);
+						buf[2] = (src_len >> 8) & 0xFF;
+						buf += 3;
+					}
+					len -= (src_len + 3);
+				} else {
+					if (len < (src_len + 1))
+						/* overflow */
+						goto done;
+
+					if (buf) {
+						buf[0] = (src_len & 0xFF);
+						buf += 1;
+					}
+					len -= (src_len + 1);
+				}
+
+				/* check for buffer and non-zero length */
+
+				if (buf && src_len) {
+					if (ps->type == LIBUSB20_ME_IS_DECODED) {
+						/*
+						 * Repeat encode
+						 * procedure - we have
+						 * room for the
+						 * complete structure:
+						 */
+						uint16_t dummy;
+
+						dummy = libusb20_me_encode(buf,
+						    0 - 1 - 3, ps->ptr);
+					} else {
+						bcopy(src_ptr, buf, src_len);
+					}
+					buf += src_len;
+				}
+				pd_offset += sizeof(struct libusb20_me_struct);
+			}
+			break;
+
+		default:
+			goto done;
+		}
+	}
+done:
+	return (len_old - len);
+}
+
+/*------------------------------------------------------------------------*
+ *	libusb20_me_decode - decode a message into a decoded structure
+ *
+ * Description of parameters:
+ * "ptr" - message pointer
+ * "len" - message length
+ * "pd" - pointer to decoded structure
+ *
+ * Returns:
+ * "0..65535" - number of bytes decoded, limited by "len"
+ *------------------------------------------------------------------------*/
+uint16_t
+libusb20_me_decode(const void *ptr, uint16_t len, void *pd)
+{
+	const uint8_t *pf;		/* pointer to format data */
+	const uint8_t *buf;		/* pointer to input buffer */
+
+	uint32_t pd_offset;		/* decoded structure offset */
+	uint16_t len_old;		/* old length */
+	uint16_t pd_count;		/* decoded element count */
+	uint8_t me;			/* message element */
+
+	/* initialise */
+
+	len_old = len;
+	buf = ptr;
+	pd_offset = sizeof(void *);
+	pf = (*((struct libusb20_me_format **)pd))->format;
+
+	/* scan */
+
+	while (1) {
+
+		/* get information element */
+
+		me = (pf[0]) & LIBUSB20_ME_MASK;
+		pd_count = pf[1] | (pf[2] << 8);
+		pf += 3;
+
+		/* decode the message element by type */
+
+		switch (me) {
+		case LIBUSB20_ME_INT8:
+			while (pd_count--) {
+				uint8_t temp;
+
+				if (len < 1) {
+					len = 0;
+					temp = 0;
+				} else {
+					len -= 1;
+					temp = buf[0];
+					buf++;
+				}
+				*((uint8_t *)LIBUSB20_ADD_BYTES(pd,
+				    pd_offset)) = temp;
+				pd_offset += 1;
+			}
+			break;
+
+		case LIBUSB20_ME_INT16:
+			pd_offset = -((-pd_offset) & ~1);	/* align */
+			while (pd_count--) {
+				uint16_t temp;
+
+				if (len < 2) {
+					len = 0;
+					temp = 0;
+				} else {
+					len -= 2;
+					temp = buf[1] << 8;
+					temp |= buf[0];
+					buf += 2;
+				}
+				*((uint16_t *)LIBUSB20_ADD_BYTES(pd,
+				    pd_offset)) = temp;
+				pd_offset += 2;
+			}
+			break;
+
+		case LIBUSB20_ME_INT32:
+			pd_offset = -((-pd_offset) & ~3);	/* align */
+			while (pd_count--) {
+				uint32_t temp;
+
+				if (len < 4) {
+					len = 0;
+					temp = 0;
+				} else {
+					len -= 4;
+					temp = buf[3] << 24;
+					temp |= buf[2] << 16;
+					temp |= buf[1] << 8;
+					temp |= buf[0];
+					buf += 4;
+				}
+
+				*((uint32_t *)LIBUSB20_ADD_BYTES(pd,
+				    pd_offset)) = temp;
+				pd_offset += 4;
+			}
+			break;
+
+		case LIBUSB20_ME_INT64:
+			pd_offset = -((-pd_offset) & ~7);	/* align */
+			while (pd_count--) {
+				uint64_t temp;
+
+				if (len < 8) {
+					len = 0;
+					temp = 0;
+				} else {
+					len -= 8;
+					temp = ((uint64_t)buf[7]) << 56;
+					temp |= ((uint64_t)buf[6]) << 48;
+					temp |= ((uint64_t)buf[5]) << 40;
+					temp |= ((uint64_t)buf[4]) << 32;
+					temp |= buf[3] << 24;
+					temp |= buf[2] << 16;
+					temp |= buf[1] << 8;
+					temp |= buf[0];
+					buf += 8;
+				}
+
+				*((uint64_t *)LIBUSB20_ADD_BYTES(pd,
+				    pd_offset)) = temp;
+				pd_offset += 8;
+			}
+			break;
+
+		case LIBUSB20_ME_STRUCT:
+			pd_offset = -((-pd_offset) &
+			    ~(LIBUSB20_ME_STRUCT_ALIGN - 1));	/* align */
+			while (pd_count--) {
+				uint16_t temp;
+				uint16_t dummy;
+				struct libusb20_me_struct *ps;
+
+				ps = LIBUSB20_ADD_BYTES(pd, pd_offset);
+
+				if (ps->type == LIBUSB20_ME_IS_ENCODED) {
+					/*
+					 * Pre-store a de-constified
+					 * pointer to the raw
+					 * structure:
+					 */
+					ps->ptr = LIBUSB20_ADD_BYTES(buf, 0);
+
+					/*
+					 * Get the correct number of
+					 * length bytes:
+					 */
+					if (len != 0) {
+						if (buf[0] == 0xFF) {
+							ps->len = 3;
+						} else {
+							ps->len = 1;
+						}
+					} else {
+						ps->len = 0;
+					}
+				}
+				/* get the structure length */
+
+				if (len != 0) {
+					if (buf[0] == 0xFF) {
+						if (len < 3) {
+							len = 0;
+							temp = 0;
+						} else {
+							len -= 3;
+							temp = buf[1] |
+							    (buf[2] << 8);
+							buf += 3;
+						}
+					} else {
+						len -= 1;
+						temp = buf[0];
+						buf += 1;
+					}
+				} else {
+					len = 0;
+					temp = 0;
+				}
+				/* check for invalid length */
+
+				if (temp > len) {
+					len = 0;
+					temp = 0;
+				}
+				/* check wanted structure type */
+
+				switch (ps->type) {
+				case LIBUSB20_ME_IS_ENCODED:
+					/* check for zero length */
+					if (temp == 0) {
+						/*
+						 * The pointer must
+						 * be valid:
+						 */
+						ps->ptr = LIBUSB20_ADD_BYTES(
+						    libusb20_me_encode_empty, 0);
+						ps->len = 1;
+					} else {
+						ps->len += temp;
+					}
+					break;
+
+				case LIBUSB20_ME_IS_RAW:
+					/* update length and pointer */
+					ps->len = temp;
+					ps->ptr = LIBUSB20_ADD_BYTES(buf, 0);
+					break;
+
+				case LIBUSB20_ME_IS_EMPTY:
+				case LIBUSB20_ME_IS_DECODED:
+					/* check for non-zero length */
+					if (temp != 0) {
+						/* update type */
+						ps->type = LIBUSB20_ME_IS_DECODED;
+						ps->len = 0;
+						/*
+						 * Recursivly decode
+						 * the next structure
+						 */
+						dummy = libusb20_me_decode(buf,
+						    temp, ps->ptr);
+					} else {
+						/* update type */
+						ps->type = LIBUSB20_ME_IS_EMPTY;
+						ps->len = 0;
+					}
+					break;
+
+				default:
+					/*
+					 * nothing to do - should
+					 * not happen
+					 */
+					ps->ptr = NULL;
+					ps->len = 0;
+					break;
+				}
+				buf += temp;
+				len -= temp;
+				pd_offset += sizeof(struct libusb20_me_struct);
+			}
+			break;
+
+		default:
+			goto done;
+		}
+	}
+done:
+	return (len_old - len);
+}
diff --git a/lib/libusb20/libusb20_desc.h b/lib/libusb20/libusb20_desc.h
new file mode 100644
index 0000000..76bcca8
--- /dev/null
+++ b/lib/libusb20/libusb20_desc.h
@@ -0,0 +1,534 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ * Copyright (c) 2007-2008 Daniel Drake.  All rights reserved.
+ * Copyright (c) 2001 Johannes Erdfelt.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * NOTE: This file contains the definition of some standard USB
+ * structures. All structures which name ends by *DECODED use host byte
+ * order.
+ */
+
+/*
+ * NOTE: This file uses a lot of macros. If you want to see what the
+ * macros become when they are expanded then run the following
+ * commands from your shell:
+ *
+ * cpp libusb20_desc.h > temp.h
+ * indent temp.h
+ * less temp.h
+ */
+
+#ifndef _LIBUSB20_DESC_H_
+#define	_LIBUSB20_DESC_H_
+
+#ifdef __cplusplus
+extern	"C" {
+#endif
+#if 0
+};					/* style */
+
+#endif
+/* basic macros */
+
+#define	LIBUSB20__NOT(...) __VA_ARGS__
+#define	LIBUSB20_NOT(arg) LIBUSB20__NOT(LIBUSB20_YES arg(() LIBUSB20_NO))
+#define	LIBUSB20_YES(...) __VA_ARGS__
+#define	LIBUSB20_NO(...)
+#define	LIBUSB20_END(...) __VA_ARGS__
+#define	LIBUSB20_MAX(a,b) (((a) > (b)) ? (a) : (b))
+#define	LIBUSB20_MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+#define	LIBUSB20_ADD_BYTES(ptr,off) \
+  ((void *)(((const uint8_t *)(ptr)) + (off)))
+
+/* basic message elements */
+enum {
+	LIBUSB20_ME_INT8,
+	LIBUSB20_ME_INT16,
+	LIBUSB20_ME_INT32,
+	LIBUSB20_ME_INT64,
+	LIBUSB20_ME_STRUCT,
+	LIBUSB20_ME_MAX,		/* used to indicate end */
+};
+
+/* basic message element modifiers */
+enum {
+	LIBUSB20_ME_IS_UNSIGNED = 0x00,
+	LIBUSB20_ME_IS_SIGNED = 0x80,
+	LIBUSB20_ME_MASK = 0x7F,
+};
+
+enum {
+	LIBUSB20_ME_IS_RAW,		/* structure excludes length field
+					 * (hardcoded value) */
+	LIBUSB20_ME_IS_ENCODED,		/* structure includes length field */
+	LIBUSB20_ME_IS_EMPTY,		/* no structure */
+	LIBUSB20_ME_IS_DECODED,		/* structure is recursive */
+};
+
+/* basic helper structures and macros */
+
+#define	LIBUSB20_ME_STRUCT_ALIGN sizeof(void *)
+
+struct libusb20_me_struct {
+	void   *ptr;			/* data pointer */
+	uint16_t len;			/* defaults to zero */
+	uint16_t type;			/* defaults to LIBUSB20_ME_IS_EMPTY */
+} __aligned(LIBUSB20_ME_STRUCT_ALIGN);
+
+struct libusb20_me_format {
+	const uint8_t *format;		/* always set */
+	const char *desc;		/* optionally set */
+	const char *fields;		/* optionally set */
+};
+
+#define	LIBUSB20_ME_STRUCT(n, field, arg, ismeta)		\
+  ismeta ( LIBUSB20_ME_STRUCT, 1, 0, )			\
+  LIBUSB20_NOT(ismeta) ( struct libusb20_me_struct field; )
+
+#define	LIBUSB20_ME_STRUCT_ARRAY(n, field, arg, ismeta)	\
+  ismeta ( LIBUSB20_ME_STRUCT , (arg) & 0xFF,		\
+	   ((arg) / 0x100) & 0xFF, )			\
+  LIBUSB20_NOT(ismeta) ( struct libusb20_me_struct field [arg]; )
+
+#define	LIBUSB20_ME_INTEGER(n, field, ismeta, un, u, bits, a, size)	\
+  ismeta ( LIBUSB20_ME_INT##bits |					\
+	   LIBUSB20_ME_IS_##un##SIGNED ,				\
+	   (size) & 0xFF, ((size) / 0x100) & 0xFF, )		\
+  LIBUSB20_NOT(ismeta) ( u##int##bits##_t				\
+		    __aligned((bits) / 8) field a; )
+
+#define	LIBUSB20_ME_UINT8_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 8, , 1)
+
+#define	LIBUSB20_ME_UINT8_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 8, [arg], arg)
+
+#define	LIBUSB20_ME_SINT8_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 8, , 1)
+
+#define	LIBUSB20_ME_SINT8_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 8, [arg], arg)
+
+#define	LIBUSB20_ME_UINT16_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 16, , 1)
+
+#define	LIBUSB20_ME_UINT16_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 16, [arg], arg)
+
+#define	LIBUSB20_ME_SINT16_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 16, , 1)
+
+#define	LIBUSB20_ME_SINT16_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 16, [arg], arg)
+
+#define	LIBUSB20_ME_UINT32_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 32, , 1)
+
+#define	LIBUSB20_ME_UINT32_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 32, [arg], arg)
+
+#define	LIBUSB20_ME_SINT32_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 32, , 1)
+
+#define	LIBUSB20_ME_SINT32_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 32, [arg], arg)
+
+#define	LIBUSB20_ME_UINT64_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 64, , 1)
+
+#define	LIBUSB20_ME_UINT64_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 64, [arg], arg)
+
+#define	LIBUSB20_ME_SINT64_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 64, , 1)
+
+#define	LIBUSB20_ME_SINT64_ARRAY_T(n, field, arg, ismeta) \
+  LIBUSB20_ME_INTEGER(n, field, ismeta,,, 64, [arg], arg)
+
+#define	LIBUSB20_MAKE_DECODED_FIELD(n, type, field, arg) \
+  LIBUSB20_ME_##type (n, field, arg, LIBUSB20_NO)
+
+#define	LIBUSB20_MAKE_STRUCT(name)			\
+  extern const struct libusb20_me_format			\
+	 name##_FORMAT[1];				\
+  struct name##_DECODED {				\
+    const struct libusb20_me_format *name##_FORMAT;	\
+    name (LIBUSB20_MAKE_DECODED_FIELD,)			\
+  }
+
+#define	LIBUSB20_MAKE_STRUCT_FORMAT(name)		\
+  const struct libusb20_me_format			\
+    name##_FORMAT[1] = {{			\
+      .format = LIBUSB20_MAKE_FORMAT(name),	\
+      .desc = #name,				\
+      .fields = NULL,				\
+  }}
+
+#define	LIBUSB20_MAKE_FORMAT_SUB(n, type, field, arg) \
+  LIBUSB20_ME_##type (n, field, arg, LIBUSB20_YES)
+
+#define	LIBUSB20_MAKE_FORMAT(what) (const uint8_t []) \
+  { what (LIBUSB20_MAKE_FORMAT_SUB, ) LIBUSB20_ME_MAX, 0, 0 }
+
+#define	LIBUSB20_INIT(what, ptr) do {		\
+    memset(ptr, 0, sizeof(*(ptr)));		\
+    (ptr)->what##_FORMAT = what##_FORMAT;	\
+} while (0)
+
+#define	LIBUSB20_DEVICE_DESC(m,n) \
+  m(n, UINT8_T, bLength, ) \
+  m(n, UINT8_T, bDescriptorType, ) \
+  m(n, UINT16_T, bcdUSB, ) \
+  m(n, UINT8_T, bDeviceClass, ) \
+  m(n, UINT8_T, bDeviceSubClass, ) \
+  m(n, UINT8_T, bDeviceProtocol, ) \
+  m(n, UINT8_T, bMaxPacketSize0, ) \
+  m(n, UINT16_T, idVendor, ) \
+  m(n, UINT16_T, idProduct, ) \
+  m(n, UINT16_T, bcdDevice, ) \
+  m(n, UINT8_T, iManufacturer, ) \
+  m(n, UINT8_T, iProduct, ) \
+  m(n, UINT8_T, iSerialNumber, ) \
+  m(n, UINT8_T, bNumConfigurations, ) \
+
+LIBUSB20_MAKE_STRUCT(LIBUSB20_DEVICE_DESC);
+
+#define	LIBUSB20_ENDPOINT_DESC(m,n) \
+  m(n, UINT8_T,  bLength, ) \
+  m(n, UINT8_T,  bDescriptorType, ) \
+  m(n, UINT8_T,  bEndpointAddress, ) \
+  m(n, UINT8_T,  bmAttributes, ) \
+  m(n, UINT16_T, wMaxPacketSize, ) \
+  m(n, UINT8_T,  bInterval, ) \
+  m(n, UINT8_T,  bRefresh, ) \
+  m(n, UINT8_T,  bSynchAddress, ) \
+
+LIBUSB20_MAKE_STRUCT(LIBUSB20_ENDPOINT_DESC);
+
+#define	LIBUSB20_INTERFACE_DESC(m,n) \
+  m(n, UINT8_T,  bLength, ) \
+  m(n, UINT8_T,  bDescriptorType, ) \
+  m(n, UINT8_T,  bInterfaceNumber, ) \
+  m(n, UINT8_T,  bAlternateSetting, ) \
+  m(n, UINT8_T,  bNumEndpoints, ) \
+  m(n, UINT8_T,  bInterfaceClass, ) \
+  m(n, UINT8_T,  bInterfaceSubClass, ) \
+  m(n, UINT8_T,  bInterfaceProtocol, ) \
+  m(n, UINT8_T,  iInterface, ) \
+
+LIBUSB20_MAKE_STRUCT(LIBUSB20_INTERFACE_DESC);
+
+#define	LIBUSB20_CONFIG_DESC(m,n) \
+  m(n, UINT8_T,  bLength, ) \
+  m(n, UINT8_T,  bDescriptorType, ) \
+  m(n, UINT16_T, wTotalLength, ) \
+  m(n, UINT8_T,  bNumInterfaces, ) \
+  m(n, UINT8_T,  bConfigurationValue, ) \
+  m(n, UINT8_T,  iConfiguration, ) \
+  m(n, UINT8_T,  bmAttributes, ) \
+  m(n, UINT8_T,  bMaxPower, ) \
+
+LIBUSB20_MAKE_STRUCT(LIBUSB20_CONFIG_DESC);
+
+#define	LIBUSB20_CONTROL_SETUP(m,n) \
+  m(n, UINT8_T,  bmRequestType, ) \
+  m(n, UINT8_T,  bRequest, ) \
+  m(n, UINT16_T, wValue, ) \
+  m(n, UINT16_T, wIndex, ) \
+  m(n, UINT16_T, wLength, ) \
+
+LIBUSB20_MAKE_STRUCT(LIBUSB20_CONTROL_SETUP);
+
+/* standard USB stuff */
+
+/** \ingroup desc
+ * Device and/or Interface Class codes */
+enum libusb20_class_code {
+	/** In the context of a \ref LIBUSB20_DEVICE_DESC "device
+	 * descriptor", this bDeviceClass value indicates that each
+	 * interface specifies its own class information and all
+	 * interfaces operate independently.
+	 */
+	LIBUSB20_CLASS_PER_INTERFACE = 0,
+
+	/** Audio class */
+	LIBUSB20_CLASS_AUDIO = 1,
+
+	/** Communications class */
+	LIBUSB20_CLASS_COMM = 2,
+
+	/** Human Interface Device class */
+	LIBUSB20_CLASS_HID = 3,
+
+	/** Printer dclass */
+	LIBUSB20_CLASS_PRINTER = 7,
+
+	/** Picture transfer protocol class */
+	LIBUSB20_CLASS_PTP = 6,
+
+	/** Mass storage class */
+	LIBUSB20_CLASS_MASS_STORAGE = 8,
+
+	/** Hub class */
+	LIBUSB20_CLASS_HUB = 9,
+
+	/** Data class */
+	LIBUSB20_CLASS_DATA = 10,
+
+	/** Class is vendor-specific */
+	LIBUSB20_CLASS_VENDOR_SPEC = 0xff,
+};
+
+/** \ingroup desc
+ * Descriptor types as defined by the USB specification. */
+enum libusb20_descriptor_type {
+	/** Device descriptor. See LIBUSB20_DEVICE_DESC. */
+	LIBUSB20_DT_DEVICE = 0x01,
+
+	/** Configuration descriptor. See LIBUSB20_CONFIG_DESC. */
+	LIBUSB20_DT_CONFIG = 0x02,
+
+	/** String descriptor */
+	LIBUSB20_DT_STRING = 0x03,
+
+	/** Interface descriptor. See LIBUSB20_INTERFACE_DESC. */
+	LIBUSB20_DT_INTERFACE = 0x04,
+
+	/** Endpoint descriptor. See LIBUSB20_ENDPOINT_DESC. */
+	LIBUSB20_DT_ENDPOINT = 0x05,
+
+	/** HID descriptor */
+	LIBUSB20_DT_HID = 0x21,
+
+	/** HID report descriptor */
+	LIBUSB20_DT_REPORT = 0x22,
+
+	/** Physical descriptor */
+	LIBUSB20_DT_PHYSICAL = 0x23,
+
+	/** Hub descriptor */
+	LIBUSB20_DT_HUB = 0x29,
+};
+
+/* Descriptor sizes per descriptor type */
+#define	LIBUSB20_DT_DEVICE_SIZE			18
+#define	LIBUSB20_DT_CONFIG_SIZE			9
+#define	LIBUSB20_DT_INTERFACE_SIZE		9
+#define	LIBUSB20_DT_ENDPOINT_SIZE		7
+#define	LIBUSB20_DT_ENDPOINT_AUDIO_SIZE		9	/* Audio extension */
+#define	LIBUSB20_DT_HUB_NONVAR_SIZE		7
+
+#define	LIBUSB20_ENDPOINT_ADDRESS_MASK	0x0f	/* in bEndpointAddress */
+#define	LIBUSB20_ENDPOINT_DIR_MASK	0x80
+
+/** \ingroup desc
+ * Endpoint direction. Values for bit 7 of the
+ * \ref LIBUSB20_ENDPOINT_DESC::bEndpointAddress "endpoint address" scheme.
+ */
+enum libusb20_endpoint_direction {
+	/** In: device-to-host */
+	LIBUSB20_ENDPOINT_IN = 0x80,
+
+	/** Out: host-to-device */
+	LIBUSB20_ENDPOINT_OUT = 0x00,
+};
+
+#define	LIBUSB20_TRANSFER_TYPE_MASK	0x03	/* in bmAttributes */
+
+/** \ingroup desc
+ * Endpoint transfer type. Values for bits 0:1 of the
+ * \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "endpoint attributes" field.
+ */
+enum libusb20_transfer_type {
+	/** Control endpoint */
+	LIBUSB20_TRANSFER_TYPE_CONTROL = 0,
+
+	/** Isochronous endpoint */
+	LIBUSB20_TRANSFER_TYPE_ISOCHRONOUS = 1,
+
+	/** Bulk endpoint */
+	LIBUSB20_TRANSFER_TYPE_BULK = 2,
+
+	/** Interrupt endpoint */
+	LIBUSB20_TRANSFER_TYPE_INTERRUPT = 3,
+};
+
+/** \ingroup misc
+ * Standard requests, as defined in table 9-3 of the USB2 specifications */
+enum libusb20_standard_request {
+	/** Request status of the specific recipient */
+	LIBUSB20_REQUEST_GET_STATUS = 0x00,
+
+	/** Clear or disable a specific feature */
+	LIBUSB20_REQUEST_CLEAR_FEATURE = 0x01,
+
+	/* 0x02 is reserved */
+
+	/** Set or enable a specific feature */
+	LIBUSB20_REQUEST_SET_FEATURE = 0x03,
+
+	/* 0x04 is reserved */
+
+	/** Set device address for all future accesses */
+	LIBUSB20_REQUEST_SET_ADDRESS = 0x05,
+
+	/** Get the specified descriptor */
+	LIBUSB20_REQUEST_GET_DESCRIPTOR = 0x06,
+
+	/** Used to update existing descriptors or add new descriptors */
+	LIBUSB20_REQUEST_SET_DESCRIPTOR = 0x07,
+
+	/** Get the current device configuration value */
+	LIBUSB20_REQUEST_GET_CONFIGURATION = 0x08,
+
+	/** Set device configuration */
+	LIBUSB20_REQUEST_SET_CONFIGURATION = 0x09,
+
+	/** Return the selected alternate setting for the specified
+	 * interface */
+	LIBUSB20_REQUEST_GET_INTERFACE = 0x0A,
+
+	/** Select an alternate interface for the specified interface */
+	LIBUSB20_REQUEST_SET_INTERFACE = 0x0B,
+
+	/** Set then report an endpoint's synchronization frame */
+	LIBUSB20_REQUEST_SYNCH_FRAME = 0x0C,
+};
+
+/** \ingroup misc
+ * Request type bits of the
+ * \ref libusb20_control_setup::bmRequestType "bmRequestType" field in
+ * control transfers. */
+enum libusb20_request_type {
+	/** Standard */
+	LIBUSB20_REQUEST_TYPE_STANDARD = (0x00 << 5),
+
+	/** Class */
+	LIBUSB20_REQUEST_TYPE_CLASS = (0x01 << 5),
+
+	/** Vendor */
+	LIBUSB20_REQUEST_TYPE_VENDOR = (0x02 << 5),
+
+	/** Reserved */
+	LIBUSB20_REQUEST_TYPE_RESERVED = (0x03 << 5),
+};
+
+/** \ingroup misc
+ * Recipient bits of the
+ * \ref libusb20_control_setup::bmRequestType "bmRequestType" field in
+ * control transfers. Values 4 through 31 are reserved. */
+enum libusb20_request_recipient {
+	/** Device */
+	LIBUSB20_RECIPIENT_DEVICE = 0x00,
+
+	/** Interface */
+	LIBUSB20_RECIPIENT_INTERFACE = 0x01,
+
+	/** Endpoint */
+	LIBUSB20_RECIPIENT_ENDPOINT = 0x02,
+
+	/** Other */
+	LIBUSB20_RECIPIENT_OTHER = 0x03,
+};
+
+#define	LIBUSB20_ISO_SYNC_TYPE_MASK		0x0C
+
+/** \ingroup desc
+ * Synchronization type for isochronous endpoints. Values for bits 2:3
+ * of the \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "bmAttributes"
+ * field in LIBUSB20_ENDPOINT_DESC.
+ */
+enum libusb20_iso_sync_type {
+	/** No synchronization */
+	LIBUSB20_ISO_SYNC_TYPE_NONE = 0,
+
+	/** Asynchronous */
+	LIBUSB20_ISO_SYNC_TYPE_ASYNC = 1,
+
+	/** Adaptive */
+	LIBUSB20_ISO_SYNC_TYPE_ADAPTIVE = 2,
+
+	/** Synchronous */
+	LIBUSB20_ISO_SYNC_TYPE_SYNC = 3,
+};
+
+#define	LIBUSB20_ISO_USAGE_TYPE_MASK 0x30
+
+/** \ingroup desc
+ * Usage type for isochronous endpoints. Values for bits 4:5 of the
+ * \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "bmAttributes" field in
+ * LIBUSB20_ENDPOINT_DESC.
+ */
+enum libusb20_iso_usage_type {
+	/** Data endpoint */
+	LIBUSB20_ISO_USAGE_TYPE_DATA = 0,
+
+	/** Feedback endpoint */
+	LIBUSB20_ISO_USAGE_TYPE_FEEDBACK = 1,
+
+	/** Implicit feedback Data endpoint */
+	LIBUSB20_ISO_USAGE_TYPE_IMPLICIT = 2,
+};
+
+struct libusb20_endpoint {
+	struct LIBUSB20_ENDPOINT_DESC_DECODED desc;
+	struct libusb20_me_struct extra;
+} __aligned(sizeof(void *));
+
+struct libusb20_interface {
+	struct LIBUSB20_INTERFACE_DESC_DECODED desc;
+	struct libusb20_me_struct extra;
+	struct libusb20_interface *altsetting;
+	struct libusb20_endpoint *endpoints;
+	uint8_t	num_altsetting;
+	uint8_t	num_endpoints;
+} __aligned(sizeof(void *));
+
+struct libusb20_config {
+	struct LIBUSB20_CONFIG_DESC_DECODED desc;
+	struct libusb20_me_struct extra;
+	struct libusb20_interface *interface;
+	uint8_t	num_interface;
+} __aligned(sizeof(void *));
+
+uint8_t	libusb20_me_get_1(const struct libusb20_me_struct *ie, uint16_t offset);
+uint16_t libusb20_me_get_2(const struct libusb20_me_struct *ie, uint16_t offset);
+uint16_t libusb20_me_encode(void *ptr, uint16_t len, const void *pd);
+uint16_t libusb20_me_decode(const void *ptr, uint16_t len, void *pd);
+const uint8_t *libusb20_desc_foreach(const struct libusb20_me_struct *pdesc, const uint8_t *psubdesc);
+struct libusb20_config *libusb20_parse_config_desc(const void *config_desc);
+
+#if 0
+{					/* style */
+#endif
+#ifdef __cplusplus
+}
+
+#endif
+
+#endif					/* _LIBUSB20_DESC_H_ */
diff --git a/lib/libusb20/libusb20_int.h b/lib/libusb20/libusb20_int.h
new file mode 100644
index 0000000..6c849b9
--- /dev/null
+++ b/lib/libusb20/libusb20_int.h
@@ -0,0 +1,252 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * This file describes internal structures.
+ */
+
+#ifndef _LIBUSB20_INT_H_
+#define	_LIBUSB20_INT_H_
+
+struct libusb20_device;
+struct libusb20_backend;
+struct libusb20_transfer;
+struct libusb20_quirk;
+
+union libusb20_session_data {
+	unsigned long session_data;
+	struct timespec tv;
+	uint32_t plugtime;
+};
+
+/* USB backend specific */
+typedef const char *(libusb20_get_backend_name_t)(void);
+typedef int (libusb20_root_get_dev_quirk_t)(struct libusb20_backend *pbe, uint16_t index, struct libusb20_quirk *pq);
+typedef int (libusb20_root_get_quirk_name_t)(struct libusb20_backend *pbe, uint16_t index, struct libusb20_quirk *pq);
+typedef int (libusb20_root_add_dev_quirk_t)(struct libusb20_backend *pbe, struct libusb20_quirk *pq);
+typedef int (libusb20_root_remove_dev_quirk_t)(struct libusb20_backend *pbe, struct libusb20_quirk *pq);
+typedef int (libusb20_bus_get_owner_t)(struct libusb20_backend *pbe, uint8_t bus, uid_t *user, gid_t *group);
+typedef int (libusb20_bus_get_perm_t)(struct libusb20_backend *pbe, uint8_t bus, mode_t *mode);
+typedef int (libusb20_bus_set_owner_t)(struct libusb20_backend *pbe, uint8_t bus, uid_t user, gid_t group);
+typedef int (libusb20_bus_set_perm_t)(struct libusb20_backend *pbe, uint8_t bus, mode_t mode);
+typedef int (libusb20_close_device_t)(struct libusb20_device *pdev);
+typedef int (libusb20_dev_get_iface_owner_t)(struct libusb20_device *pdev, uint8_t iface_index, uid_t *user, gid_t *group);
+typedef int (libusb20_dev_get_iface_perm_t)(struct libusb20_device *pdev, uint8_t iface_index, mode_t *mode);
+typedef int (libusb20_dev_get_owner_t)(struct libusb20_device *pdev, uid_t *user, gid_t *group);
+typedef int (libusb20_dev_get_perm_t)(struct libusb20_device *pdev, mode_t *mode);
+typedef int (libusb20_dev_set_iface_owner_t)(struct libusb20_device *pdev, uint8_t iface_index, uid_t user, gid_t group);
+typedef int (libusb20_dev_set_iface_perm_t)(struct libusb20_device *pdev, uint8_t iface_index, mode_t mode);
+typedef int (libusb20_dev_set_owner_t)(struct libusb20_device *pdev, uid_t user, gid_t group);
+typedef int (libusb20_dev_set_perm_t)(struct libusb20_device *pdev, mode_t mode);
+typedef int (libusb20_init_backend_t)(struct libusb20_backend *pbe);
+typedef int (libusb20_open_device_t)(struct libusb20_device *pdev, uint16_t transfer_count_max);
+typedef int (libusb20_root_get_owner_t)(struct libusb20_backend *pbe, uid_t *user, gid_t *group);
+typedef int (libusb20_root_get_perm_t)(struct libusb20_backend *pbe, mode_t *mode);
+typedef int (libusb20_root_set_owner_t)(struct libusb20_backend *pbe, uid_t user, gid_t group);
+typedef int (libusb20_root_set_perm_t)(struct libusb20_backend *pbe, mode_t mode);
+typedef void (libusb20_exit_backend_t)(struct libusb20_backend *pbe);
+
+#define	LIBUSB20_DEFINE(n,field) \
+  libusb20_##field##_t *field;
+
+#define	LIBUSB20_DECLARE(n,field) \
+  /* .field = */ n##_##field,
+
+#define	LIBUSB20_BACKEND(m,n) \
+  /* description of this backend */ \
+  m(n, get_backend_name) \
+  /* optional backend methods */ \
+  m(n, init_backend) \
+  m(n, exit_backend) \
+  m(n, bus_set_owner) \
+  m(n, bus_get_owner) \
+  m(n, bus_set_perm) \
+  m(n, bus_get_perm) \
+  m(n, dev_get_iface_owner) \
+  m(n, dev_get_iface_perm) \
+  m(n, dev_get_owner) \
+  m(n, dev_get_perm) \
+  m(n, dev_set_iface_owner) \
+  m(n, dev_set_iface_perm) \
+  m(n, dev_set_owner) \
+  m(n, dev_set_perm) \
+  m(n, root_get_dev_quirk) \
+  m(n, root_get_quirk_name) \
+  m(n, root_add_dev_quirk) \
+  m(n, root_remove_dev_quirk) \
+  m(n, root_set_owner) \
+  m(n, root_get_owner) \
+  m(n, root_set_perm) \
+  m(n, root_get_perm) \
+  /* mandatory device methods */ \
+  m(n, open_device) \
+  m(n, close_device) \
+
+struct libusb20_backend_methods {
+	LIBUSB20_BACKEND(LIBUSB20_DEFINE,)
+};
+
+/* USB dummy methods */
+typedef int (libusb20_dummy_int_t)(void);
+typedef void (libusb20_dummy_void_t)(void);
+
+/* USB device specific */
+typedef int (libusb20_claim_interface_t)(struct libusb20_device *pdev, uint8_t iface_index);
+typedef int (libusb20_detach_kernel_driver_t)(struct libusb20_device *pdev, uint8_t iface_index);
+typedef int (libusb20_do_request_sync_t)(struct libusb20_device *pdev, struct LIBUSB20_CONTROL_SETUP_DECODED *setup, void *data, uint16_t *pactlen, uint32_t timeout, uint8_t flags);
+typedef int (libusb20_get_config_desc_full_t)(struct libusb20_device *pdev, uint8_t **ppbuf, uint16_t *plen, uint8_t index);
+typedef int (libusb20_get_config_index_t)(struct libusb20_device *pdev, uint8_t *pindex);
+typedef int (libusb20_kernel_driver_active_t)(struct libusb20_device *pdev, uint8_t iface_index);
+typedef int (libusb20_process_t)(struct libusb20_device *pdev);
+typedef int (libusb20_release_interface_t)(struct libusb20_device *pdev, uint8_t iface_index);
+typedef int (libusb20_reset_device_t)(struct libusb20_device *pdev);
+typedef int (libusb20_set_power_mode_t)(struct libusb20_device *pdev, uint8_t power_mode);
+typedef int (libusb20_get_power_mode_t)(struct libusb20_device *pdev, uint8_t *power_mode);
+typedef int (libusb20_set_alt_index_t)(struct libusb20_device *pdev, uint8_t iface_index, uint8_t alt_index);
+typedef int (libusb20_set_config_index_t)(struct libusb20_device *pdev, uint8_t index);
+
+/* USB transfer specific */
+typedef int (libusb20_tr_open_t)(struct libusb20_transfer *xfer, uint32_t MaxBufSize, uint32_t MaxFrameCount, uint8_t ep_no);
+typedef int (libusb20_tr_close_t)(struct libusb20_transfer *xfer);
+typedef int (libusb20_tr_clear_stall_sync_t)(struct libusb20_transfer *xfer);
+typedef void (libusb20_tr_submit_t)(struct libusb20_transfer *xfer);
+typedef void (libusb20_tr_cancel_async_t)(struct libusb20_transfer *xfer);
+
+#define	LIBUSB20_DEVICE(m,n) \
+  m(n, claim_interface) \
+  m(n, detach_kernel_driver) \
+  m(n, do_request_sync) \
+  m(n, get_config_desc_full) \
+  m(n, get_config_index) \
+  m(n, kernel_driver_active) \
+  m(n, process) \
+  m(n, release_interface) \
+  m(n, reset_device) \
+  m(n, set_power_mode) \
+  m(n, get_power_mode) \
+  m(n, set_alt_index) \
+  m(n, set_config_index) \
+  m(n, tr_cancel_async) \
+  m(n, tr_clear_stall_sync) \
+  m(n, tr_close) \
+  m(n, tr_open) \
+  m(n, tr_submit) \
+
+struct libusb20_device_methods {
+	LIBUSB20_DEVICE(LIBUSB20_DEFINE,)
+};
+
+struct libusb20_backend {
+	TAILQ_HEAD(, libusb20_device) usb_devs;
+	const struct libusb20_backend_methods *methods;
+};
+
+struct libusb20_transfer {
+	struct libusb20_device *pdev;	/* the USB device we belong to */
+	libusb20_tr_callback_t *callback;
+	void   *priv_sc0;		/* private client data */
+	void   *priv_sc1;		/* private client data */
+	/*
+	 * Pointer to a list of buffer pointers:
+	 */
+	void  **ppBuffer;
+	/*
+	 * Pointer to frame lengths, which are updated to actual length
+	 * after the USB transfer completes:
+	 */
+	uint32_t *pLength;
+	uint32_t maxTotalLength;
+	uint32_t maxFrames;		/* total number of frames */
+	uint32_t nFrames;		/* total number of frames */
+	uint32_t aFrames;		/* actual number of frames */
+	uint32_t timeout;
+	/* isochronous completion time in milliseconds */
+	uint16_t timeComplete;
+	uint16_t trIndex;
+	uint16_t maxPacketLen;
+	uint8_t	flags;			/* see LIBUSB20_TRANSFER_XXX */
+	uint8_t	status;			/* see LIBUSB20_TRANSFER_XXX */
+	uint8_t	is_opened;
+	uint8_t	is_pending;
+	uint8_t	is_cancel;
+	uint8_t	is_draining;
+	uint8_t	is_restart;
+};
+
+struct libusb20_device {
+
+	/* device descriptor */
+	struct LIBUSB20_DEVICE_DESC_DECODED ddesc;
+
+	/* device timestamp */
+	union libusb20_session_data session_data;
+
+	/* our device entry */
+	TAILQ_ENTRY(libusb20_device) dev_entry;
+
+	/* device methods */
+	const struct libusb20_device_methods *methods;
+
+	/* backend methods */
+	const struct libusb20_backend_methods *beMethods;
+
+	/* list of USB transfers */
+	struct libusb20_transfer *pTransfer;
+
+	/* private backend data */
+	void   *privBeData;
+
+	/* libUSB v0.1 compat data */
+	void   *priv01Data;
+
+	/* claimed interfaces */
+	uint32_t claimed_interfaces;
+
+	/* device file handle */
+	int	file;
+
+	/* device file handle (control transfers only) */
+	int	file_ctrl;
+
+	/* debugging level */
+	int	debug;
+
+	/* number of USB transfers */
+	uint16_t nTransfer;
+
+	uint8_t	bus_number;
+	uint8_t	device_address;
+	uint8_t	usb_mode;
+	uint8_t	usb_speed;
+	uint8_t	is_opened;
+
+	char	usb_desc[96];
+};
+
+extern const struct libusb20_backend_methods libusb20_ugen20_backend;
+extern const struct libusb20_backend_methods libusb20_linux_backend;
+
+#endif					/* _LIBUSB20_INT_H_ */
diff --git a/lib/libusb20/libusb20_ugen20.c b/lib/libusb20/libusb20_ugen20.c
new file mode 100644
index 0000000..ffbd861
--- /dev/null
+++ b/lib/libusb20/libusb20_ugen20.c
@@ -0,0 +1,1077 @@
+/* $FreeBSD$ */
+/*-
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/types.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "libusb20.h"
+#include "libusb20_desc.h"
+#include "libusb20_int.h"
+
+#include <dev/usb2/include/usb2_standard.h>
+#include <dev/usb2/include/usb2_ioctl.h>
+#include <dev/usb2/include/usb2_mfunc.h>
+#include <dev/usb2/include/usb2_error.h>
+#include <dev/usb2/include/usb2_revision.h>
+
+static libusb20_init_backend_t ugen20_init_backend;
+static libusb20_open_device_t ugen20_open_device;
+static libusb20_close_device_t ugen20_close_device;
+static libusb20_get_backend_name_t ugen20_get_backend_name;
+static libusb20_exit_backend_t ugen20_exit_backend;
+static libusb20_bus_set_owner_t ugen20_bus_set_owner;
+static libusb20_bus_get_owner_t ugen20_bus_get_owner;
+static libusb20_bus_set_perm_t ugen20_bus_set_perm;
+static libusb20_bus_get_perm_t ugen20_bus_get_perm;
+static libusb20_dev_get_iface_owner_t ugen20_dev_get_iface_owner;
+static libusb20_dev_get_iface_perm_t ugen20_dev_get_iface_perm;
+static libusb20_dev_get_owner_t ugen20_dev_get_owner;
+static libusb20_dev_get_perm_t ugen20_dev_get_perm;
+static libusb20_dev_set_iface_owner_t ugen20_dev_set_iface_owner;
+static libusb20_dev_set_iface_perm_t ugen20_dev_set_iface_perm;
+static libusb20_dev_set_owner_t ugen20_dev_set_owner;
+static libusb20_dev_set_perm_t ugen20_dev_set_perm;
+static libusb20_root_get_dev_quirk_t ugen20_root_get_dev_quirk;
+static libusb20_root_get_quirk_name_t ugen20_root_get_quirk_name;
+static libusb20_root_add_dev_quirk_t ugen20_root_add_dev_quirk;
+static libusb20_root_remove_dev_quirk_t ugen20_root_remove_dev_quirk;
+static libusb20_root_set_owner_t ugen20_root_set_owner;
+static libusb20_root_get_owner_t ugen20_root_get_owner;
+static libusb20_root_set_perm_t ugen20_root_set_perm;
+static libusb20_root_get_perm_t ugen20_root_get_perm;
+
+const struct libusb20_backend_methods libusb20_ugen20_backend = {
+	LIBUSB20_BACKEND(LIBUSB20_DECLARE, ugen20)
+};
+
+/* USB device specific */
+static libusb20_get_config_desc_full_t ugen20_get_config_desc_full;
+static libusb20_get_config_index_t ugen20_get_config_index;
+static libusb20_set_config_index_t ugen20_set_config_index;
+static libusb20_claim_interface_t ugen20_claim_interface;
+static libusb20_release_interface_t ugen20_release_interface;
+static libusb20_set_alt_index_t ugen20_set_alt_index;
+static libusb20_reset_device_t ugen20_reset_device;
+static libusb20_set_power_mode_t ugen20_set_power_mode;
+static libusb20_get_power_mode_t ugen20_get_power_mode;
+static libusb20_kernel_driver_active_t ugen20_kernel_driver_active;
+static libusb20_detach_kernel_driver_t ugen20_detach_kernel_driver;
+static libusb20_do_request_sync_t ugen20_do_request_sync;
+static libusb20_process_t ugen20_process;
+
+/* USB transfer specific */
+static libusb20_tr_open_t ugen20_tr_open;
+static libusb20_tr_close_t ugen20_tr_close;
+static libusb20_tr_clear_stall_sync_t ugen20_tr_clear_stall_sync;
+static libusb20_tr_submit_t ugen20_tr_submit;
+static libusb20_tr_cancel_async_t ugen20_tr_cancel_async;
+
+static const struct libusb20_device_methods libusb20_ugen20_device_methods = {
+	LIBUSB20_DEVICE(LIBUSB20_DECLARE, ugen20)
+};
+
+static const char *
+ugen20_get_backend_name(void)
+{
+	return ("FreeBSD UGEN 2.0");
+}
+
+static uint32_t
+ugen20_path_convert_one(const char **pp)
+{
+	const char *ptr;
+	uint32_t temp = 0;
+
+	ptr = *pp;
+
+	while ((*ptr >= '0') && (*ptr <= '9')) {
+		temp *= 10;
+		temp += (*ptr - '0');
+		if (temp >= 1000000) {
+			/* catch overflow early */
+			return (0 - 1);
+		}
+		ptr++;
+	}
+
+	if (*ptr == '.') {
+		/* skip dot */
+		ptr++;
+	}
+	*pp = ptr;
+
+	return (temp);
+}
+
+static int
+ugen20_enumerate(struct libusb20_device *pdev, const char *id)
+{
+	const char *tmp = id;
+	struct usb2_device_descriptor ddesc;
+	struct usb2_device_info devinfo;
+	uint32_t plugtime;
+	char buf[64];
+	int f;
+	int error;
+
+	pdev->bus_number = ugen20_path_convert_one(&tmp);
+	pdev->device_address = ugen20_path_convert_one(&tmp);
+
+	snprintf(buf, sizeof(buf), "/dev/ugen%u.%u",
+	    pdev->bus_number, pdev->device_address);
+
+	f = open(buf, O_RDWR);
+	if (f < 0) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	if (ioctl(f, USB_GET_PLUGTIME, &plugtime)) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	}
+	/* store when the device was plugged */
+	pdev->session_data.plugtime = plugtime;
+
+	if (ioctl(f, USB_GET_DEVICE_DESC, &ddesc)) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	}
+	LIBUSB20_INIT(LIBUSB20_DEVICE_DESC, &(pdev->ddesc));
+
+	libusb20_me_decode(&ddesc, sizeof(ddesc), &(pdev->ddesc));
+
+	if (pdev->ddesc.bNumConfigurations == 0) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	} else if (pdev->ddesc.bNumConfigurations >= 8) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	}
+	if (ioctl(f, USB_GET_DEVICEINFO, &devinfo)) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	}
+	switch (devinfo.udi_mode) {
+	case USB_MODE_DEVICE:
+		pdev->usb_mode = LIBUSB20_MODE_DEVICE;
+		break;
+	default:
+		pdev->usb_mode = LIBUSB20_MODE_HOST;
+		break;
+	}
+
+	switch (devinfo.udi_speed) {
+	case USB_SPEED_LOW:
+		pdev->usb_speed = LIBUSB20_SPEED_LOW;
+		break;
+	case USB_SPEED_FULL:
+		pdev->usb_speed = LIBUSB20_SPEED_FULL;
+		break;
+	case USB_SPEED_HIGH:
+		pdev->usb_speed = LIBUSB20_SPEED_HIGH;
+		break;
+	case USB_SPEED_VARIABLE:
+		pdev->usb_speed = LIBUSB20_SPEED_VARIABLE;
+		break;
+	case USB_SPEED_SUPER:
+		pdev->usb_speed = LIBUSB20_SPEED_SUPER;
+		break;
+	default:
+		pdev->usb_speed = LIBUSB20_SPEED_UNKNOWN;
+		break;
+	}
+
+	/* generate a nice description for printout */
+
+	snprintf(pdev->usb_desc, sizeof(pdev->usb_desc),
+	    "ugen%u.%u: <%s %s> at usbus%u", pdev->bus_number,
+	    pdev->device_address, devinfo.udi_product,
+	    devinfo.udi_vendor, pdev->bus_number);
+
+	error = 0;
+done:
+	close(f);
+	return (error);
+}
+
+struct ugen20_urd_state {
+	struct usb2_read_dir urd;
+	uint32_t nparsed;
+	int	f;
+	uint8_t *ptr;
+	const char *src;
+	const char *dst;
+	uint8_t	buf[256];
+	uint8_t	dummy_zero[1];
+};
+
+static int
+ugen20_readdir(struct ugen20_urd_state *st)
+{
+	;				/* style fix */
+repeat:
+	if (st->ptr == NULL) {
+		st->urd.urd_startentry += st->nparsed;
+		st->urd.urd_data = st->buf;
+		st->urd.urd_maxlen = sizeof(st->buf);
+		st->nparsed = 0;
+
+		if (ioctl(st->f, USB_READ_DIR, &st->urd)) {
+			return (EINVAL);
+		}
+		st->ptr = st->buf;
+	}
+	if (st->ptr[0] == 0) {
+		if (st->nparsed) {
+			st->ptr = NULL;
+			goto repeat;
+		} else {
+			return (ENXIO);
+		}
+	}
+	st->src = (void *)(st->ptr + 1);
+	st->dst = st->src + strlen(st->src) + 1;
+	st->ptr = st->ptr + st->ptr[0];
+	st->nparsed++;
+
+	if ((st->ptr < st->buf) ||
+	    (st->ptr > st->dummy_zero)) {
+		/* invalid entry */
+		return (EINVAL);
+	}
+	return (0);
+}
+
+static int
+ugen20_init_backend(struct libusb20_backend *pbe)
+{
+	struct ugen20_urd_state state;
+	struct libusb20_device *pdev;
+
+	memset(&state, 0, sizeof(state));
+
+	state.f = open("/dev/usb", O_RDONLY);
+	if (state.f < 0)
+		return (LIBUSB20_ERROR_OTHER);
+
+	while (ugen20_readdir(&state) == 0) {
+
+		if ((state.src[0] != 'u') ||
+		    (state.src[1] != 'g') ||
+		    (state.src[2] != 'e') ||
+		    (state.src[3] != 'n')) {
+			continue;
+		}
+		pdev = libusb20_dev_alloc();
+		if (pdev == NULL) {
+			continue;
+		}
+		if (ugen20_enumerate(pdev, state.src + 4)) {
+			libusb20_dev_free(pdev);
+			continue;
+		}
+		/* put the device on the backend list */
+		libusb20_be_enqueue_device(pbe, pdev);
+	}
+	close(state.f);
+	return (0);			/* success */
+}
+
+static int
+ugen20_open_device(struct libusb20_device *pdev, uint16_t nMaxTransfer)
+{
+	struct usb2_fs_endpoint *pfse = NULL;
+	struct usb2_fs_init fs_init = { /* zero */ };
+	uint32_t size;
+	uint32_t plugtime;
+	char buf[64];
+	int f;
+	int g;
+	int error;
+
+	snprintf(buf, sizeof(buf), "/dev/ugen%u.%u",
+	    pdev->bus_number, pdev->device_address);
+
+	/*
+	 * We need two file handles, one for the control endpoint and one
+	 * for BULK, INTERRUPT and ISOCHRONOUS transactions due to optimised
+	 * kernel locking.
+	 */
+	g = open(buf, O_RDWR);
+	if (g < 0) {
+		return (LIBUSB20_ERROR_NO_DEVICE);
+	}
+	f = open(buf, O_RDWR);
+	if (f < 0) {
+		close(g);
+		return (LIBUSB20_ERROR_NO_DEVICE);
+	}
+	if (ioctl(f, USB_GET_PLUGTIME, &plugtime)) {
+		error = LIBUSB20_ERROR_OTHER;
+		goto done;
+	}
+	/* check that the correct device is still plugged */
+	if (pdev->session_data.plugtime != plugtime) {
+		error = LIBUSB20_ERROR_NO_DEVICE;
+		goto done;
+	}
+	if (nMaxTransfer != 0) {
+
+		size = nMaxTransfer * sizeof(*pfse);
+
+		pfse = malloc(size);
+		if (!pfse) {
+			error = LIBUSB20_ERROR_NO_MEM;
+			goto done;
+		}
+		memset(pfse, 0, size);
+
+		fs_init.pEndpoints = pfse;
+		fs_init.ep_index_max = nMaxTransfer;
+
+		if (ioctl(f, USB_FS_INIT, &fs_init)) {
+			error = LIBUSB20_ERROR_OTHER;
+			goto done;
+		}
+	}
+	/* set methods */
+	pdev->methods = &libusb20_ugen20_device_methods;
+	pdev->privBeData = pfse;
+	pdev->file = f;
+	pdev->file_ctrl = g;
+	error = 0;
+done:
+	if (error) {
+		if (pfse) {
+			free(pfse);
+		}
+		close(f);
+		close(g);
+	}
+	return (error);
+}
+
+static int
+ugen20_close_device(struct libusb20_device *pdev)
+{
+	struct usb2_fs_uninit fs_uninit = { /* zero */ };
+	int error = 0;
+
+	if (pdev->privBeData) {
+		if (ioctl(pdev->file, USB_FS_UNINIT, &fs_uninit)) {
+			error = LIBUSB20_ERROR_OTHER;
+		}
+		free(pdev->privBeData);
+	}
+	pdev->nTransfer = 0;
+	pdev->privBeData = NULL;
+	close(pdev->file);
+	close(pdev->file_ctrl);
+	pdev->file = -1;
+	pdev->file_ctrl = -1;
+	return (error);
+}
+
+static void
+ugen20_exit_backend(struct libusb20_backend *pbe)
+{
+	return;				/* nothing to do */
+}
+
+static int
+ugen20_get_config_desc_full(struct libusb20_device *pdev,
+    uint8_t **ppbuf, uint16_t *plen, uint8_t index)
+{
+	struct usb2_gen_descriptor gen_desc = { /* zero */ };
+	struct usb2_config_descriptor cdesc;
+	uint8_t *ptr;
+	uint16_t len;
+	int error;
+
+	gen_desc.ugd_data = &cdesc;
+	gen_desc.ugd_maxlen = sizeof(cdesc);
+	gen_desc.ugd_config_index = index;
+
+	error = ioctl(pdev->file_ctrl, USB_GET_FULL_DESC, &gen_desc);
+	if (error) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	len = UGETW(cdesc.wTotalLength);
+	if (len < sizeof(cdesc)) {
+		/* corrupt descriptor */
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	ptr = malloc(len);
+	if (!ptr) {
+		return (LIBUSB20_ERROR_NO_MEM);
+	}
+	gen_desc.ugd_data = ptr;
+	gen_desc.ugd_maxlen = len;
+
+	error = ioctl(pdev->file_ctrl, USB_GET_FULL_DESC, &gen_desc);
+	if (error) {
+		free(ptr);
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	/* make sure that the device doesn't fool us */
+	memcpy(ptr, &cdesc, sizeof(cdesc));
+
+	*ppbuf = ptr;
+	*plen = len;
+
+	return (0);			/* success */
+}
+
+static int
+ugen20_get_config_index(struct libusb20_device *pdev, uint8_t *pindex)
+{
+	int temp;
+
+	if (ioctl(pdev->file_ctrl, USB_GET_CONFIG, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	*pindex = temp;
+
+	return (0);
+}
+
+static int
+ugen20_set_config_index(struct libusb20_device *pdev, uint8_t index)
+{
+	int temp = index;
+
+	if (ioctl(pdev->file_ctrl, USB_SET_CONFIG, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_claim_interface(struct libusb20_device *pdev, uint8_t iface_index)
+{
+	int temp = iface_index;
+
+	if (ioctl(pdev->file_ctrl, USB_CLAIM_INTERFACE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_release_interface(struct libusb20_device *pdev, uint8_t iface_index)
+{
+	int temp = iface_index;
+
+	if (ioctl(pdev->file_ctrl, USB_RELEASE_INTERFACE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_set_alt_index(struct libusb20_device *pdev,
+    uint8_t iface_index, uint8_t alt_index)
+{
+	struct usb2_alt_interface alt_iface = { /* zero */ };
+
+	alt_iface.uai_interface_index = iface_index;
+	alt_iface.uai_alt_index = alt_index;
+
+	if (ioctl(pdev->file_ctrl, USB_SET_ALTINTERFACE, &alt_iface)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_reset_device(struct libusb20_device *pdev)
+{
+	int temp = 0;
+
+	if (ioctl(pdev->file_ctrl, USB_DEVICEENUMERATE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_set_power_mode(struct libusb20_device *pdev, uint8_t power_mode)
+{
+	int temp;
+
+	switch (power_mode) {
+	case LIBUSB20_POWER_OFF:
+		temp = USB_POWER_MODE_OFF;
+		break;
+	case LIBUSB20_POWER_ON:
+		temp = USB_POWER_MODE_ON;
+		break;
+	case LIBUSB20_POWER_SAVE:
+		temp = USB_POWER_MODE_SAVE;
+		break;
+	case LIBUSB20_POWER_SUSPEND:
+		temp = USB_POWER_MODE_SUSPEND;
+		break;
+	case LIBUSB20_POWER_RESUME:
+		temp = USB_POWER_MODE_RESUME;
+		break;
+	default:
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	if (ioctl(pdev->file_ctrl, USB_SET_POWER_MODE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);
+}
+
+static int
+ugen20_get_power_mode(struct libusb20_device *pdev, uint8_t *power_mode)
+{
+	int temp;
+
+	if (ioctl(pdev->file_ctrl, USB_GET_POWER_MODE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	switch (temp) {
+	case USB_POWER_MODE_OFF:
+		temp = LIBUSB20_POWER_OFF;
+		break;
+	case USB_POWER_MODE_ON:
+		temp = LIBUSB20_POWER_ON;
+		break;
+	case USB_POWER_MODE_SAVE:
+		temp = LIBUSB20_POWER_SAVE;
+		break;
+	case USB_POWER_MODE_SUSPEND:
+		temp = LIBUSB20_POWER_SUSPEND;
+		break;
+	case USB_POWER_MODE_RESUME:
+		temp = LIBUSB20_POWER_RESUME;
+		break;
+	default:
+		temp = LIBUSB20_POWER_ON;
+		break;
+	}
+	*power_mode = temp;
+	return (0);			/* success */
+}
+
+static int
+ugen20_kernel_driver_active(struct libusb20_device *pdev,
+    uint8_t iface_index)
+{
+	int temp = iface_index;
+
+	if (ioctl(pdev->file_ctrl, USB_IFACE_DRIVER_ACTIVE, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);			/* kernel driver is active */
+}
+
+static int
+ugen20_detach_kernel_driver(struct libusb20_device *pdev,
+    uint8_t iface_index)
+{
+	int temp = iface_index;
+
+	if (ioctl(pdev->file_ctrl, USB_IFACE_DRIVER_DETACH, &temp)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	return (0);			/* kernel driver is active */
+}
+
+static int
+ugen20_do_request_sync(struct libusb20_device *pdev,
+    struct LIBUSB20_CONTROL_SETUP_DECODED *setup,
+    void *data, uint16_t *pactlen, uint32_t timeout, uint8_t flags)
+{
+	struct usb2_ctl_request req = { /* zero */ };
+
+	req.ucr_data = data;
+	if (!(flags & LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK)) {
+		req.ucr_flags |= USB_SHORT_XFER_OK;
+	}
+	if (libusb20_me_encode(&req.ucr_request,
+	    sizeof(req.ucr_request), setup)) {
+		/* ignore */
+	}
+	if (ioctl(pdev->file_ctrl, USB_DO_REQUEST, &req)) {
+		return (LIBUSB20_ERROR_OTHER);
+	}
+	if (pactlen) {
+		/* get actual length */
+		*pactlen = req.ucr_actlen;
+	}
+	return (0);			/* kernel driver is active */
+}
+
+static int
+ugen20_process(struct libusb20_device *pdev)
+{
+	struct usb2_fs_complete temp;
+	struct usb2_fs_endpoint *fsep;
+	struct libusb20_transfer *xfer;
+
+	while (1) {
+
+		if (ioctl(pdev->file, USB_FS_COMPLETE, &temp)) {
+			if (errno == EBUSY) {
+				break;
+			} else {
+				/* device detached */
+				return (LIBUSB20_ERROR_OTHER);
+			}
+		}
+		fsep = pdev->privBeData;
+		xfer = pdev->pTransfer;
+		fsep += temp.ep_index;
+		xfer += temp.ep_index;
+
+		/* update transfer status */
+
+		if (fsep->status == 0) {
+			xfer->aFrames = fsep->aFrames;
+			xfer->timeComplete = fsep->isoc_time_complete;
+			xfer->status = LIBUSB20_TRANSFER_COMPLETED;
+		} else if (fsep->status == USB_ERR_CANCELLED) {
+			xfer->aFrames = 0;
+			xfer->timeComplete = 0;
+			xfer->status = LIBUSB20_TRANSFER_CANCELLED;
+		} else if (fsep->status == USB_ERR_STALLED) {
+			xfer->aFrames = 0;
+			xfer->timeComplete = 0;
+			xfer->status = LIBUSB20_TRANSFER_STALL;
+		} else if (fsep->status == USB_ERR_TIMEOUT) {
+			xfer->aFrames = 0;
+			xfer->timeComplete = 0;
+			xfer->status = LIBUSB20_TRANSFER_TIMED_OUT;
+		} else {
+			xfer->aFrames = 0;
+			xfer->timeComplete = 0;
+			xfer->status = LIBUSB20_TRANSFER_ERROR;
+		}
+		libusb20_tr_callback_wrapper(xfer);
+	}
+	return (0);			/* done */
+}
+
+static int
+ugen20_tr_open(struct libusb20_transfer *xfer, uint32_t MaxBufSize,
+    uint32_t MaxFrameCount, uint8_t ep_no)
+{
+	struct usb2_fs_open temp = { /* zero */ };
+	struct usb2_fs_endpoint *fsep;
+
+	fsep = xfer->pdev->privBeData;
+	fsep += xfer->trIndex;
+
+	temp.max_bufsize = MaxBufSize;
+	temp.max_frames = MaxFrameCount;
+	temp.ep_index = xfer->trIndex;
+	temp.ep_no = ep_no;
+
+	if (ioctl(xfer->pdev->file, USB_FS_OPEN, &temp)) {
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	/* maximums might have changed - update */
+	xfer->maxFrames = temp.max_frames;
+
+	/* "max_bufsize" should be multiple of "max_packet_length" */
+	xfer->maxTotalLength = temp.max_bufsize;
+	xfer->maxPacketLen = temp.max_packet_length;
+
+	/* setup buffer and length lists */
+	fsep->ppBuffer = xfer->ppBuffer;/* zero copy */
+	fsep->pLength = xfer->pLength;	/* zero copy */
+
+	return (0);			/* success */
+}
+
+static int
+ugen20_tr_close(struct libusb20_transfer *xfer)
+{
+	struct usb2_fs_close temp = { /* zero */ };
+
+	temp.ep_index = xfer->trIndex;
+
+	if (ioctl(xfer->pdev->file, USB_FS_CLOSE, &temp)) {
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	return (0);			/* success */
+}
+
+static int
+ugen20_tr_clear_stall_sync(struct libusb20_transfer *xfer)
+{
+	struct usb2_fs_clear_stall_sync temp = { /* zero */ };
+
+	/* if the transfer is active, an error will be returned */
+
+	temp.ep_index = xfer->trIndex;
+
+	if (ioctl(xfer->pdev->file, USB_FS_CLEAR_STALL_SYNC, &temp)) {
+		return (LIBUSB20_ERROR_INVALID_PARAM);
+	}
+	return (0);			/* success */
+}
+
+static void
+ugen20_tr_submit(struct libusb20_transfer *xfer)
+{
+	struct usb2_fs_start temp = { /* zero */ };
+	struct usb2_fs_endpoint *fsep;
+
+	fsep = xfer->pdev->privBeData;
+	fsep += xfer->trIndex;
+
+	fsep->nFrames = xfer->nFrames;
+	fsep->flags = 0;
+	if (!(xfer->flags & LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK)) {
+		fsep->flags |= USB_FS_FLAG_SINGLE_SHORT_OK;
+	}
+	if (!(xfer->flags & LIBUSB20_TRANSFER_MULTI_SHORT_NOT_OK)) {
+		fsep->flags |= USB_FS_FLAG_MULTI_SHORT_OK;
+	}
+	if (xfer->flags & LIBUSB20_TRANSFER_FORCE_SHORT) {
+		fsep->flags |= USB_FS_FLAG_FORCE_SHORT;
+	}
+	if (xfer->flags & LIBUSB20_TRANSFER_DO_CLEAR_STALL) {
+		fsep->flags |= USB_FS_FLAG_CLEAR_STALL;
+	}
+	fsep->timeout = xfer->timeout;
+
+	temp.ep_index = xfer->trIndex;
+
+	if (ioctl(xfer->pdev->file, USB_FS_START, &temp)) {
+		/* ignore any errors - should never happen */
+	}
+	return;				/* success */
+}
+
+static void
+ugen20_tr_cancel_async(struct libusb20_transfer *xfer)
+{
+	struct usb2_fs_stop temp = { /* zero */ };
+
+	temp.ep_index = xfer->trIndex;
+
+	if (ioctl(xfer->pdev->file, USB_FS_STOP, &temp)) {
+		/* ignore any errors - should never happen */
+	}
+	return;
+}
+
+static int
+ugen20_be_ioctl(uint32_t cmd, void *data)
+{
+	int f;
+	int err;
+
+	f = open("/dev/usb", O_RDONLY);
+	if (f < 0)
+		return (LIBUSB20_ERROR_OTHER);
+	err = ioctl(f, cmd, data);
+	if (err == -1) {
+		if (errno == EPERM) {
+			err = LIBUSB20_ERROR_ACCESS;
+		} else {
+			err = LIBUSB20_ERROR_OTHER;
+		}
+	}
+	close(f);
+	return (err);
+}
+
+static int
+ugen20_be_do_perm(uint32_t get_cmd, uint32_t set_cmd, uint8_t bus,
+    uint8_t dev, uint8_t iface, uid_t *uid,
+    gid_t *gid, mode_t *mode)
+{
+	struct usb2_dev_perm perm = { /* zero */ };
+	int err;
+
+	perm.bus_index = bus;
+	perm.dev_index = dev;
+	perm.iface_index = iface;
+
+	err = ugen20_be_ioctl(get_cmd, &perm);
+	if (err)
+		return (err);
+
+	if (set_cmd == 0) {
+		if (uid)
+			*uid = perm.user_id;
+		if (gid)
+			*gid = perm.group_id;
+		if (mode)
+			*mode = perm.mode;
+		return (0);
+	}
+	if (uid)
+		perm.user_id = *uid;
+	if (gid)
+		perm.group_id = *gid;
+	if (mode)
+		perm.mode = *mode;
+
+	return (ugen20_be_ioctl(set_cmd, &perm));
+}
+
+static int
+ugen20_bus_set_owner(struct libusb20_backend *pbe,
+    uint8_t bus, uid_t user, gid_t group)
+{
+	return (ugen20_be_do_perm(USB_GET_BUS_PERM, USB_SET_BUS_PERM,
+	    bus, 0, 0, &user, &group, NULL));
+}
+
+static int
+ugen20_bus_get_owner(struct libusb20_backend *pbe, uint8_t bus,
+    uid_t *user, gid_t *group)
+{
+	return (ugen20_be_do_perm(USB_GET_BUS_PERM, 0,
+	    bus, 0, 0, user, group, NULL));
+}
+
+static int
+ugen20_bus_set_perm(struct libusb20_backend *pbe,
+    uint8_t bus, mode_t mode)
+{
+	return (ugen20_be_do_perm(USB_GET_BUS_PERM, USB_SET_BUS_PERM,
+	    bus, 0, 0, NULL, NULL, &mode));
+}
+
+static int
+ugen20_bus_get_perm(struct libusb20_backend *pbe,
+    uint8_t bus, mode_t *mode)
+{
+	return (ugen20_be_do_perm(USB_GET_BUS_PERM, 0,
+	    bus, 0, 0, NULL, NULL, mode));
+}
+
+static int
+ugen20_dev_get_iface_owner(struct libusb20_device *pdev,
+    uint8_t iface_index, uid_t *user, gid_t *group)
+{
+	return (ugen20_be_do_perm(USB_GET_IFACE_PERM, 0,
+	    pdev->bus_number, pdev->device_address, iface_index,
+	    user, group, NULL));
+}
+
+static int
+ugen20_dev_get_iface_perm(struct libusb20_device *pdev,
+    uint8_t iface_index, mode_t *mode)
+{
+	return (ugen20_be_do_perm(USB_GET_IFACE_PERM, 0,
+	    pdev->bus_number, pdev->device_address, iface_index,
+	    NULL, NULL, mode));
+}
+
+static int
+ugen20_dev_get_owner(struct libusb20_device *pdev,
+    uid_t *user, gid_t *group)
+{
+	return (ugen20_be_do_perm(USB_GET_DEVICE_PERM, 0,
+	    pdev->bus_number, pdev->device_address, 0,
+	    user, group, NULL));
+}
+
+static int
+ugen20_dev_get_perm(struct libusb20_device *pdev, mode_t *mode)
+{
+	return (ugen20_be_do_perm(USB_GET_DEVICE_PERM, 0,
+	    pdev->bus_number, pdev->device_address, 0,
+	    NULL, NULL, mode));
+}
+
+static int
+ugen20_dev_set_iface_owner(struct libusb20_device *pdev,
+    uint8_t iface_index, uid_t user, gid_t group)
+{
+	return (ugen20_be_do_perm(USB_GET_IFACE_PERM, USB_SET_IFACE_PERM,
+	    pdev->bus_number, pdev->device_address, iface_index,
+	    &user, &group, NULL));
+}
+
+static int
+ugen20_dev_set_iface_perm(struct libusb20_device *pdev,
+    uint8_t iface_index, mode_t mode)
+{
+	return (ugen20_be_do_perm(USB_GET_IFACE_PERM, USB_SET_IFACE_PERM,
+	    pdev->bus_number, pdev->device_address, iface_index,
+	    NULL, NULL, &mode));
+}
+
+static int
+ugen20_root_get_dev_quirk(struct libusb20_backend *pbe,
+    uint16_t index, struct libusb20_quirk *pq)
+{
+	struct usb2_gen_quirk q;
+	int err;
+
+	memset(&q, 0, sizeof(q));
+
+	q.index = index;
+
+	err = ugen20_be_ioctl(USB_DEV_QUIRK_GET, &q);
+
+	if (err) {
+		if (errno == EINVAL) {
+			return (LIBUSB20_ERROR_NOT_FOUND);
+		}
+	} else {
+		pq->vid = q.vid;
+		pq->pid = q.pid;
+		pq->bcdDeviceLow = q.bcdDeviceLow;
+		pq->bcdDeviceHigh = q.bcdDeviceHigh;
+		strlcpy(pq->quirkname, q.quirkname, sizeof(pq->quirkname));
+	}
+	return (err);
+}
+
+static int
+ugen20_root_get_quirk_name(struct libusb20_backend *pbe, uint16_t index,
+    struct libusb20_quirk *pq)
+{
+	struct usb2_gen_quirk q;
+	int err;
+
+	memset(&q, 0, sizeof(q));
+
+	q.index = index;
+
+	err = ugen20_be_ioctl(USB_QUIRK_NAME_GET, &q);
+
+	if (err) {
+		if (errno == EINVAL) {
+			return (LIBUSB20_ERROR_NOT_FOUND);
+		}
+	} else {
+		strlcpy(pq->quirkname, q.quirkname, sizeof(pq->quirkname));
+	}
+	return (err);
+}
+
+static int
+ugen20_root_add_dev_quirk(struct libusb20_backend *pbe,
+    struct libusb20_quirk *pq)
+{
+	struct usb2_gen_quirk q;
+	int err;
+
+	memset(&q, 0, sizeof(q));
+
+	q.vid = pq->vid;
+	q.pid = pq->pid;
+	q.bcdDeviceLow = pq->bcdDeviceLow;
+	q.bcdDeviceHigh = pq->bcdDeviceHigh;
+	strlcpy(q.quirkname, pq->quirkname, sizeof(q.quirkname));
+
+	err = ugen20_be_ioctl(USB_DEV_QUIRK_ADD, &q);
+	if (err) {
+		if (errno == ENOMEM) {
+			return (LIBUSB20_ERROR_NO_MEM);
+		}
+	}
+	return (err);
+}
+
+static int
+ugen20_root_remove_dev_quirk(struct libusb20_backend *pbe,
+    struct libusb20_quirk *pq)
+{
+	struct usb2_gen_quirk q;
+	int err;
+
+	memset(&q, 0, sizeof(q));
+
+	q.vid = pq->vid;
+	q.pid = pq->pid;
+	q.bcdDeviceLow = pq->bcdDeviceLow;
+	q.bcdDeviceHigh = pq->bcdDeviceHigh;
+	strlcpy(q.quirkname, pq->quirkname, sizeof(q.quirkname));
+
+	err = ugen20_be_ioctl(USB_DEV_QUIRK_REMOVE, &q);
+	if (err) {
+		if (errno == EINVAL) {
+			return (LIBUSB20_ERROR_NOT_FOUND);
+		}
+	}
+	return (err);
+}
+
+static int
+ugen20_dev_set_owner(struct libusb20_device *pdev,
+    uid_t user, gid_t group)
+{
+	return (ugen20_be_do_perm(USB_GET_DEVICE_PERM, USB_SET_DEVICE_PERM,
+	    pdev->bus_number, pdev->device_address, 0,
+	    &user, &group, NULL));
+}
+
+static int
+ugen20_dev_set_perm(struct libusb20_device *pdev, mode_t mode)
+{
+	return (ugen20_be_do_perm(USB_GET_DEVICE_PERM, USB_SET_DEVICE_PERM,
+	    pdev->bus_number, pdev->device_address, 0,
+	    NULL, NULL, &mode));
+}
+
+static int
+ugen20_root_set_owner(struct libusb20_backend *pbe,
+    uid_t user, gid_t group)
+{
+	return (ugen20_be_do_perm(USB_GET_ROOT_PERM, USB_SET_ROOT_PERM, 0, 0, 0,
+	    &user, &group, NULL));
+}
+
+static int
+ugen20_root_get_owner(struct libusb20_backend *pbe, uid_t *user, gid_t *group)
+{
+	return (ugen20_be_do_perm(USB_GET_ROOT_PERM, 0, 0, 0, 0,
+	    user, group, NULL));
+}
+
+static int
+ugen20_root_set_perm(struct libusb20_backend *pbe, mode_t mode)
+{
+	return (ugen20_be_do_perm(USB_GET_ROOT_PERM, USB_SET_ROOT_PERM, 0, 0, 0,
+	    NULL, NULL, &mode));
+}
+
+static int
+ugen20_root_get_perm(struct libusb20_backend *pbe, mode_t *mode)
+{
+	return (ugen20_be_do_perm(USB_GET_ROOT_PERM, 0, 0, 0, 0,
+	    NULL, NULL, mode));
+}