libusb 0.7.0-x64-mingw-ucrt

data/lib/libusb/compat.rb

@@ -0,0 +1,376 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+#
+#   This file is for compatibility with ruby-usb and libusb-0.1.
+#
+#   Please visit the project website at http://github.com/larskanis/libusb
+#   for support.
+
+require 'libusb'
+require 'forwardable'
+
+# Compatibility layer for ruby-usb[http://www.a-k-r.org/ruby-usb/] (API based on libusb-0.1)
+#
+# This module provides some limited compatibility to ruby-usb.
+#
+# Usage example:
+#   begin
+#     require 'usb'
+#   rescue LoadError
+#     require 'libusb/compat'
+#   end
+#   p USB.devices => [#<USB::Device ...>]
+#
+# Known issues:
+# * Exceptions are different between ruby-usb and libusb and they don't get converted
+# * libusb-1.0 doesn't explicitly manage USB-buses, so only one Bus is used currently
+module USB
+  @default_context = nil
+  def self.default_context
+    @default_context ||= LIBUSB::Context.new
+  end
+
+  @default_bus = nil
+  def self.default_bus
+    @default_bus ||= Bus.new(default_context)
+  end
+
+  USB_CLASS_PER_INTERFACE = LIBUSB::CLASS_PER_INTERFACE
+  USB_CLASS_AUDIO = LIBUSB::CLASS_AUDIO
+  USB_CLASS_COMM = LIBUSB::CLASS_COMM
+  USB_CLASS_HID = LIBUSB::CLASS_HID
+  USB_CLASS_PRINTER = LIBUSB::CLASS_PRINTER
+  USB_CLASS_PTP = LIBUSB::CLASS_PTP
+  USB_CLASS_MASS_STORAGE = LIBUSB::CLASS_MASS_STORAGE
+  USB_CLASS_HUB = LIBUSB::CLASS_HUB
+  USB_CLASS_DATA = LIBUSB::CLASS_DATA
+  USB_CLASS_VENDOR_SPEC = LIBUSB::CLASS_VENDOR_SPEC
+
+  USB_DT_DEVICE = LIBUSB::DT_DEVICE
+  USB_DT_CONFIG = LIBUSB::DT_CONFIG
+  USB_DT_STRING = LIBUSB::DT_STRING
+  USB_DT_INTERFACE = LIBUSB::DT_INTERFACE
+  USB_DT_ENDPOINT = LIBUSB::DT_ENDPOINT
+  USB_DT_HID = LIBUSB::DT_HID
+  USB_DT_REPORT = LIBUSB::DT_REPORT
+  USB_DT_PHYSICAL = LIBUSB::DT_PHYSICAL
+  USB_DT_HUB = LIBUSB::DT_HUB
+  USB_DT_DEVICE_SIZE = LIBUSB::DT_DEVICE_SIZE
+  USB_DT_CONFIG_SIZE = LIBUSB::DT_CONFIG_SIZE
+  USB_DT_INTERFACE_SIZE = LIBUSB::DT_INTERFACE_SIZE
+  USB_DT_ENDPOINT_SIZE = LIBUSB::DT_ENDPOINT_SIZE
+  USB_DT_ENDPOINT_AUDIO_SIZE = LIBUSB::DT_ENDPOINT_AUDIO_SIZE
+  USB_DT_HUB_NONVAR_SIZE = LIBUSB::DT_HUB_NONVAR_SIZE
+
+  USB_ENDPOINT_ADDRESS_MASK = LIBUSB::ENDPOINT_ADDRESS_MASK
+  USB_ENDPOINT_DIR_MASK = LIBUSB::ENDPOINT_DIR_MASK
+  USB_ENDPOINT_IN = LIBUSB::ENDPOINT_IN
+  USB_ENDPOINT_OUT = LIBUSB::ENDPOINT_OUT
+
+  USB_ENDPOINT_TYPE_MASK = LIBUSB::TRANSFER_TYPE_MASK
+  USB_ENDPOINT_TYPE_CONTROL = LIBUSB::TRANSFER_TYPE_CONTROL
+  USB_ENDPOINT_TYPE_ISOCHRONOUS = LIBUSB::TRANSFER_TYPE_ISOCHRONOUS
+  USB_ENDPOINT_TYPE_BULK = LIBUSB::TRANSFER_TYPE_BULK
+  USB_ENDPOINT_TYPE_INTERRUPT = LIBUSB::TRANSFER_TYPE_INTERRUPT
+
+  USB_REQ_GET_STATUS = LIBUSB::REQUEST_GET_STATUS
+  USB_REQ_CLEAR_FEATURE = LIBUSB::REQUEST_CLEAR_FEATURE
+  USB_REQ_SET_FEATURE = LIBUSB::REQUEST_SET_FEATURE
+  USB_REQ_SET_ADDRESS = LIBUSB::REQUEST_SET_ADDRESS
+  USB_REQ_GET_DESCRIPTOR = LIBUSB::REQUEST_GET_DESCRIPTOR
+  USB_REQ_SET_DESCRIPTOR = LIBUSB::REQUEST_SET_DESCRIPTOR
+  USB_REQ_GET_CONFIGURATION = LIBUSB::REQUEST_GET_CONFIGURATION
+  USB_REQ_SET_CONFIGURATION = LIBUSB::REQUEST_SET_CONFIGURATION
+  USB_REQ_GET_INTERFACE = LIBUSB::REQUEST_GET_INTERFACE
+  USB_REQ_SET_INTERFACE = LIBUSB::REQUEST_SET_INTERFACE
+  USB_REQ_SYNCH_FRAME = LIBUSB::REQUEST_SYNCH_FRAME
+  USB_TYPE_STANDARD = LIBUSB::REQUEST_TYPE_STANDARD
+  USB_TYPE_CLASS = LIBUSB::REQUEST_TYPE_CLASS
+  USB_TYPE_VENDOR = LIBUSB::REQUEST_TYPE_VENDOR
+  USB_TYPE_RESERVED = LIBUSB::REQUEST_TYPE_RESERVED
+  USB_RECIP_DEVICE = LIBUSB::RECIPIENT_DEVICE
+  USB_RECIP_INTERFACE = LIBUSB::RECIPIENT_INTERFACE
+  USB_RECIP_ENDPOINT = LIBUSB::RECIPIENT_ENDPOINT
+  USB_RECIP_OTHER = LIBUSB::RECIPIENT_OTHER
+
+  HAS_GET_DRIVER_NP = !FFI::Platform.windows?
+  HAS_DETACH_KERNEL_DRIVER_NP = !FFI::Platform.windows?
+
+  # not defined by libusb-1.0, but typical values are:
+  USB_MAXENDPOINTS = 32
+  USB_MAXINTERFACES = 32
+  USB_MAXALTSETTING = 128
+  USB_MAXCONFIG = 8
+
+
+  def USB.busses
+    [default_bus]
+  end
+
+  def USB.devices; default_context.devices.map{|c| Device.new(c) }; end
+  def USB.configurations() USB.devices.map {|d| d.configurations }.flatten end
+  def USB.interfaces() USB.configurations.map {|d| d.interfaces }.flatten end
+  def USB.settings() USB.interfaces.map {|d| d.settings }.flatten end
+  def USB.endpoints() USB.settings.map {|d| d.endpoints }.flatten end
+
+  def USB.find_bus(n)
+    default_bus
+  end
+
+  def USB.each_device_by_class(devclass, subclass=nil, protocol=nil)
+    devs = default_context.devices bClass: devclass, bSubClass: subclass, bProtocol: protocol
+    devs.each do |dev|
+      yield Device.new(dev)
+    end
+    nil
+  end
+
+  class Bus
+    def initialize(context)
+      @ct = context
+    end
+    def devices
+      @ct.devices.map{|d| Device.new(d) }
+    end
+
+    def configurations() self.devices.map{|d| d.configurations }.flatten end
+    def interfaces() self.configurations.map {|d| d.interfaces }.flatten end
+    def settings() self.interfaces.map {|d| d.settings }.flatten end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+
+    def find_device(n)
+      raise NotImplementedError
+    end
+  end
+
+  def USB.dev_string(base_class, sub_class, protocol)
+    LIBUSB.dev_string(base_class, sub_class, protocol)
+  end
+
+  class Device
+    extend Forwardable
+    include Comparable
+
+    def initialize(dev)
+      @dev = dev
+    end
+
+    def_delegators :@dev, :bLength, :bDescriptorType, :bcdUSB, :bDeviceClass,
+        :bDeviceSubClass, :bDeviceProtocol, :bMaxPacketSize0, :idVendor, :idProduct,
+        :bcdDevice, :iManufacturer, :iProduct, :iSerialNumber, :bNumConfigurations,
+        :manufacturer, :product, :serial_number,
+        :inspect
+
+    def <=>(o)
+      @dev<=>o.instance_variable_get(:@dev)
+    end
+
+    def open
+      h = DevHandle.new(@dev.open)
+      if block_given?
+        begin
+          yield h
+        ensure
+          h.usb_close
+        end
+      else
+        h
+      end
+    end
+
+    def bus; default_bus; end
+    def configurations; @dev.configurations.map{|c| Configuration.new(c) }; end
+    def interfaces; @dev.interfaces.map{|c| Interface.new(c) }; end
+    def settings; @dev.settings.map{|c| Setting.new(c) }; end
+    def endpoints; @dev.endpoints.map{|c| Endpoint.new(c) }; end
+  end
+
+  class Configuration
+    extend Forwardable
+    include Comparable
+
+    def initialize(cd)
+      @cd = cd
+    end
+
+    def_delegators :@cd, :bLength, :bDescriptorType, :wTotalLength, :bNumInterfaces,
+        :bConfigurationValue, :iConfiguration, :bmAttributes, :bMaxPower,
+        :inspect
+
+    def <=>(o)
+      @cd<=>o.instance_variable_get(:@cd)
+    end
+
+    def bus; default_bus; end
+    def device() Device.new(@cd.device) end
+    def interfaces; @cd.interfaces.map{|c| Interface.new(c) }; end
+    def settings() self.interfaces.map {|d| d.settings }.flatten end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+  end
+
+  class Interface
+    extend Forwardable
+    include Comparable
+
+    def initialize(i)
+      @i = i
+    end
+
+    def_delegators :@i, :inspect
+
+    def <=>(o)
+      @i<=>o.instance_variable_get(:@i)
+    end
+
+    def bus() self.configuration.device.bus end
+    def device() self.configuration.device end
+    def configuration; Configuration.new(@i.configuration); end
+    def settings; @i.alt_settings.map{|c| Setting.new(c) }; end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+  end
+
+  class Setting
+    extend Forwardable
+    include Comparable
+
+    def initialize(id)
+      @id = id
+    end
+
+    def_delegators :@id, :bLength, :bDescriptorType, :bInterfaceNumber, :bAlternateSetting,
+        :bNumEndpoints, :bInterfaceClass, :bInterfaceSubClass, :bInterfaceProtocol,
+        :iInterface, :inspect
+
+    def <=>(o)
+      @id<=>o.instance_variable_get(:@id)
+    end
+
+    def bus() self.interface.configuration.device.bus end
+    def device() self.interface.configuration.device end
+    def configuration() self.interface.configuration end
+    def interface; Interface.new(@id.interface); end
+    def endpoints() @id.endpoints.map {|d| Endpoint.new(d) }.flatten end
+  end
+
+  class Endpoint
+    extend Forwardable
+    include Comparable
+
+    def initialize(ep)
+      @ep = ep
+    end
+
+    def_delegators :@ep, :bLength, :bDescriptorType, :bEndpointAddress, :bmAttributes,
+        :wMaxPacketSize, :bInterval, :bRefresh, :bSynchAddress,
+        :inspect
+
+    def <=>(o)
+      @ep<=>o.instance_variable_get(:@ep)
+    end
+
+    def bus() self.setting.interface.configuration.device.bus end
+    def device() self.setting.interface.configuration.device end
+    def configuration() self.setting.interface.configuration end
+    def interface() self.setting.interface end
+    def setting; Setting.new(@ep.setting); end
+  end
+
+  class DevHandle
+    def initialize(dev)
+      @dev = dev
+    end
+
+    def usb_close; @dev.close; end
+    def usb_set_configuration(c); @dev.configuration=c; end
+    def usb_set_altinterface(c); @dev.set_interface_alt_setting=c; end
+    def usb_clear_halt(c); @dev.clear_halt(c); end
+    def usb_reset; @dev.reset_device; end
+    def usb_claim_interface(c); @dev.claim_interface(c); end
+    def usb_release_interface(c); @dev.release_interface(c); end
+    def usb_get_string(index, langid, buffer)
+      t = @dev.string_descriptor(index, langid)
+      buffer[0, t.length] = t
+      t.length
+    end
+    def usb_get_string_simple(index, buffer)
+      t = @dev.string_descriptor_ascii(index)
+      buffer[0, t.length] = t
+      t.length
+    end
+
+    def usb_control_msg(requesttype, request, value, index, bytes, timeout)
+      if requesttype&LIBUSB::ENDPOINT_IN != 0
+        # transfer direction in
+        res = @dev.control_transfer(bmRequestType: requesttype, bRequest: request,
+            wValue: value, wIndex: index, dataIn: bytes.bytesize, timeout: timeout)
+        bytes[0, res.bytesize] = res
+        res.bytesize
+      else
+        # transfer direction out
+        @dev.control_transfer(bmRequestType: requesttype, bRequest: request, wValue: value,
+            wIndex: index, dataOut: bytes, timeout: timeout)
+      end
+    end
+
+    def usb_bulk_write(endpoint, bytes, timeout)
+      @dev.bulk_transfer(endpoint: endpoint, dataOut: bytes, timeout: timeout)
+    end
+    def usb_bulk_read(endpoint, bytes, timeout)
+      res = @dev.bulk_transfer(endpoint: endpoint, dataIn: bytes.bytesize, timeout: timeout)
+      bytes[0, res.bytesize] = res
+      res.bytesize
+    end
+
+    def usb_interrupt_write(endpoint, bytes, timeout)
+      @dev.interrupt_transfer(endpoint: endpoint, dataOut: bytes, timeout: timeout)
+    end
+    def usb_interrupt_read(endpoint, bytes, timeout)
+      res = @dev.interrupt_transfer(endpoint: endpoint, dataIn: bytes.bytesize, timeout: timeout)
+      bytes[0, res.bytesize] = res
+      res.bytesize
+    end
+
+#   rb_define_method(rb_cUSB_DevHandle, "usb_get_descriptor", rusb_get_descriptor, 3);
+#   rb_define_method(rb_cUSB_DevHandle, "usb_get_descriptor_by_endpoint", rusb_get_descriptor_by_endpoint, 4);
+
+    if HAS_DETACH_KERNEL_DRIVER_NP
+      def usb_detach_kernel_driver_np(interface, dummy=nil)
+        @dev.detach_kernel_driver(interface)
+      end
+    end
+
+    if HAS_GET_DRIVER_NP
+      def usb_get_driver_np(interface, buffer)
+        if @dev.kernel_driver_active?(interface)
+          t = "unknown driver"
+          buffer[0, t.length] = t
+        else
+          raise Errno::ENODATA, "No data available"
+        end
+        nil
+      end
+    end
+
+    alias set_configuration usb_set_configuration
+    alias set_altinterface usb_set_altinterface
+    alias clear_halt usb_clear_halt
+    alias claim_interface usb_claim_interface
+    alias release_interface usb_release_interface
+
+    def get_string_simple(index)
+      @dev.string_descriptor_ascii(index)
+    end
+  end
+end

data/lib/libusb/configuration.rb

@@ -0,0 +1,154 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'libusb/call'
+
+module LIBUSB
+  class Configuration < FFI::Struct
+    include Comparable
+    include ContextReference
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :wTotalLength, :uint16,
+        :bNumInterfaces, :uint8,
+        :bConfigurationValue, :uint8,
+        :iConfiguration, :uint8,
+        :bmAttributes, :uint8,
+        :bMaxPower, :uint8,
+        :interface, :pointer,
+        :extra, :pointer,
+        :extra_length, :int
+
+    # Size of this descriptor (in bytes).
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type (0x02)
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # Total length of data returned for this configuration.
+    def wTotalLength
+      self[:wTotalLength]
+    end
+
+    # Number of interfaces supported by this configuration.
+    def bNumInterfaces
+      self[:bNumInterfaces]
+    end
+
+    # Identifier value for this configuration.
+    def bConfigurationValue
+      self[:bConfigurationValue]
+    end
+
+    # Index of string descriptor describing this configuration.
+    def iConfiguration
+      self[:iConfiguration]
+    end
+
+    # Configuration characteristics.
+    #
+    # * Bit 7: Reserved, set to 1. (USB 1.0 Bus Powered)
+    # * Bit 6: Self Powered
+    # * Bit 5: Remote Wakeup
+    # * Bit 4..0: Reserved, set to 0.
+    #
+    # @return [Integer]
+    #
+    # @see #self_powered?
+    # @see #remote_wakeup?
+    def bmAttributes
+      self[:bmAttributes]
+    end
+
+    # @return [Boolean]
+    def self_powered?
+      bmAttributes & 0b1000000 != 0
+    end
+
+    # @return [Boolean]
+    def remote_wakeup?
+      bmAttributes & 0b100000 != 0
+    end
+
+    # Maximum power consumption of the USB device from this bus in this configuration when the device is fully opreation.
+    #
+    # @return [Integer] Maximum Power Consumption in 2mA units
+    def bMaxPower
+      self[:bMaxPower]
+    end
+
+    # @deprecated Use {#bMaxPower} instead.
+    alias maxPower bMaxPower
+
+
+    # Extra descriptors.
+    #
+    # @return [String]
+    def extra
+      return if self[:extra].null?
+      self[:extra].read_string(self[:extra_length])
+    end
+
+    def initialize(device, *args)
+      @device = device
+      super(*args)
+
+      register_context(device.context.instance_variable_get(:@ctx), :libusb_free_config_descriptor)
+    end
+
+    # @return [Device] the device this configuration belongs to.
+    attr_reader :device
+
+    def interfaces
+      ifs = []
+      self[:bNumInterfaces].times do |i|
+        ifs << Interface.new(self, self[:interface] + i*Interface.size)
+      end
+      return ifs
+    end
+
+    def inspect
+      attrs = []
+      attrs << self.bConfigurationValue.to_s
+      attrs << "SelfPowered" if self_powered?
+      attrs << "RemoteWakeup" if remote_wakeup?
+      desc = self.description
+      attrs << desc if desc != '?'
+      "\#<#{self.class} #{attrs.join(' ')}>"
+    end
+
+    # Return name of this configuration as String.
+    def description
+      return @description if defined? @description
+      @description = device.try_string_descriptor_ascii(self.iConfiguration)
+    end
+
+    # Return all interface decriptions of the configuration as Array of {Setting}s.
+    def settings() self.interfaces.map {|d| d.settings }.flatten end
+    # Return all endpoints of all interfaces of the configuration as Array of {Endpoint}s.
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+
+    def <=>(o)
+      t = device<=>o.device
+      t = bConfigurationValue<=>o.bConfigurationValue if t==0
+      t
+    end
+  end
+end

data/lib/libusb/constants.rb

@@ -0,0 +1,170 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'libusb/call'
+
+module LIBUSB
+  [
+    Call::ClassCodes,
+    Call::TransferTypes,
+    Call::StandardRequests,
+    Call::RequestTypes,
+    Call::DescriptorTypes,
+    Call::EndpointDirections,
+    Call::RequestRecipients,
+    Call::IsoSyncTypes,
+    Call::Speeds,
+    Call::Capabilities,
+    Call::SupportedSpeeds,
+    Call::Usb20ExtensionAttributes,
+    Call::SsUsbDeviceCapabilityAttributes,
+    Call::BosTypes,
+    Call::HotplugEvents,
+    Call::HotplugFlags,
+    Call::LogLevels,
+    Call::LogCbMode,
+    Call::Options,
+  ].each do |enum|
+    enum.to_h.each{|k,v| const_set(k,v) }
+  end
+
+  # Base class of libusb errors
+  class Error < RuntimeError
+    # The data already transferred before the exception was raised
+    # @return [Fixnum] Number of bytes sent for an outgoing transfer
+    # @return [String] Received data for an ingoing transfer
+    attr_reader :transferred
+
+    def initialize(msg=nil, transferred=nil)
+      super(msg)
+      @transferred = transferred
+    end
+  end
+
+  class RemainingReferencesError < Error
+  end
+
+  # @private
+  ErrorClassForResult = {}
+
+  # define an exception class for each error code
+  Call::Errors.to_h.each do |k,v|
+    klass = Class.new(Error)
+    klass.send(:define_method, :code){ v }
+    const_set(k, klass)
+    ErrorClassForResult[v] = klass
+  end
+
+  def self.raise_error(res, text)
+    klass = ErrorClassForResult[res]
+    raise klass, "#{klass} #{text}"
+  end
+
+  CONTROL_SETUP_SIZE = 8
+  DT_DEVICE_SIZE = 18
+  DT_CONFIG_SIZE = 9
+  DT_INTERFACE_SIZE = 9
+  DT_ENDPOINT_SIZE = 7
+  DT_ENDPOINT_AUDIO_SIZE = 9 # Audio extension
+  DT_HUB_NONVAR_SIZE = 7
+
+  ENDPOINT_ADDRESS_MASK = 0x0f    # in bEndpointAddress
+  ENDPOINT_DIR_MASK = 0x80
+  TRANSFER_TYPE_MASK = 0x03    # in bmAttributes
+  ISO_SYNC_TYPE_MASK = 0x0C
+  ISO_USAGE_TYPE_MASK = 0x30
+
+  POLLIN = 1
+  POLLOUT = 4
+
+  # Wildcard matching for hotplug events.
+  HOTPLUG_MATCH_ANY = -1
+
+
+  # http://www.usb.org/developers/defined_class
+  # @private
+  CLASS_CODES = [
+    [0x01, nil, nil, "Audio"],
+    [0x02, nil, nil, "Comm"],
+    [0x03, nil, nil, "HID"],
+    [0x05, nil, nil, "Physical"],
+    [0x06, 0x01, 0x01, "StillImaging"],
+    [0x06, nil, nil, "Image"],
+    [0x07, nil, nil, "Printer"],
+    [0x08, 0x01, nil, "MassStorage RBC Bulk-Only"],
+    [0x08, 0x02, 0x50, "MassStorage ATAPI Bulk-Only"],
+    [0x08, 0x03, 0x50, "MassStorage QIC-157 Bulk-Only"],
+    [0x08, 0x04, nil, "MassStorage UFI"],
+    [0x08, 0x05, 0x50, "MassStorage SFF-8070i Bulk-Only"],
+    [0x08, 0x06, 0x50, "MassStorage SCSI Bulk-Only"],
+    [0x08, nil, nil, "MassStorage"],
+    [0x09, 0x00, 0x00, "Full speed Hub"],
+    [0x09, 0x00, 0x01, "Hi-speed Hub with single TT"],
+    [0x09, 0x00, 0x02, "Hi-speed Hub with multiple TTs"],
+    [0x09, nil, nil, "Hub"],
+    [0x0a, nil, nil, "CDC"],
+    [0x0b, nil, nil, "SmartCard"],
+    [0x0d, 0x00, 0x00, "ContentSecurity"],
+    [0x0e, nil, nil, "Video"],
+    [0xdc, 0x01, 0x01, "Diagnostic USB2"],
+    [0xdc, nil, nil, "Diagnostic"],
+    [0xe0, 0x01, 0x01, "Bluetooth"],
+    [0xe0, 0x01, 0x02, "UWB"],
+    [0xe0, 0x01, 0x03, "RemoteNDIS"],
+    [0xe0, 0x02, 0x01, "Host Wire Adapter Control/Data"],
+    [0xe0, 0x02, 0x02, "Device Wire Adapter Control/Data"],
+    [0xe0, 0x02, 0x03, "Device Wire Adapter Isochronous"],
+    [0xe0, nil, nil, "Wireless Controller"],
+    [0xef, 0x01, 0x01, "Active Sync"],
+    [0xef, 0x01, 0x02, "Palm Sync"],
+    [0xef, 0x02, 0x01, "Interface Association Descriptor"],
+    [0xef, 0x02, 0x02, "Wire Adapter Multifunction Peripheral"],
+    [0xef, 0x03, 0x01, "Cable Based Association Framework"],
+    [0xef, nil, nil, "Miscellaneous"],
+    [0xfe, 0x01, 0x01, "Device Firmware Upgrade"],
+    [0xfe, 0x02, 0x00, "IRDA Bridge"],
+    [0xfe, 0x03, 0x00, "USB Test and Measurement"],
+    [0xfe, 0x03, 0x01, "USB Test and Measurement (USBTMC USB488)"],
+    [0xfe, nil, nil, "Application Specific"],
+    [0xff, nil, nil, "Vendor specific"],
+  ]
+  # @private
+  CLASS_CODES_HASH1 = {}
+  # @private
+  CLASS_CODES_HASH2 = {}
+  # @private
+  CLASS_CODES_HASH3 = {}
+  CLASS_CODES.each {|base_class, sub_class, protocol, desc|
+    if protocol
+      CLASS_CODES_HASH3[[base_class, sub_class, protocol]] = desc
+    elsif sub_class
+      CLASS_CODES_HASH2[[base_class, sub_class]] = desc
+    else
+      CLASS_CODES_HASH1[base_class] = desc
+    end
+  }
+
+  def self.dev_string(base_class, sub_class, protocol)
+    if desc = CLASS_CODES_HASH3[[base_class, sub_class, protocol]]
+      desc
+    elsif desc = CLASS_CODES_HASH2[[base_class, sub_class]]
+      desc + " (%02x)" % [protocol]
+    elsif desc = CLASS_CODES_HASH1[base_class]
+      desc + " (%02x,%02x)" % [sub_class, protocol]
+    else
+      "Unknown(%02x,%02x,%02x)" % [base_class, sub_class, protocol]
+    end
+  end
+end