libusb 0.1.3-x86-mingw32 → 0.2.0-x86-mingw32

data/lib/libusb/call.rb

@@ -0,0 +1,271 @@
+# 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 'rubygems'
+require 'ffi'
+
+module LIBUSB
+  # C level interface
+  module Call
+    extend FFI::Library
+
+    if FFI::Platform.windows?
+      bundled_dll = File.join(File.dirname(__FILE__), '..', 'libusb-1.0.dll')
+      ffi_lib(['libusb-1.0', bundled_dll])
+    else
+      ffi_lib 'libusb-1.0'
+    end
+
+    ClassCodes = enum :libusb_class_code, [
+      :CLASS_PER_INTERFACE, 0,
+      :CLASS_AUDIO, 1,
+      :CLASS_COMM, 2,
+      :CLASS_HID, 3,
+      :CLASS_PRINTER, 7,
+      :CLASS_PTP, 6,
+      :CLASS_MASS_STORAGE, 8,
+      :CLASS_HUB, 9,
+      :CLASS_DATA, 10,
+      :CLASS_WIRELESS, 0xe0,
+      :CLASS_APPLICATION, 0xfe,
+      :CLASS_VENDOR_SPEC, 0xff
+    ]
+
+    Errors = enum :libusb_error, [
+      :SUCCESS, 0,
+      :ERROR_IO, -1,
+      :ERROR_INVALID_PARAM, -2,
+      :ERROR_ACCESS, -3,
+      :ERROR_NO_DEVICE, -4,
+      :ERROR_NOT_FOUND, -5,
+      :ERROR_BUSY, -6,
+      :ERROR_TIMEOUT, -7,
+      :ERROR_OVERFLOW, -8,
+      :ERROR_PIPE, -9,
+      :ERROR_INTERRUPTED, -10,
+      :ERROR_NO_MEM, -11,
+      :ERROR_NOT_SUPPORTED, -12,
+      :ERROR_OTHER, -99,
+    ]
+
+    # Transfer status codes
+    TransferStatus = enum :libusb_transfer_status, [
+      :TRANSFER_COMPLETED,
+      :TRANSFER_ERROR,
+      :TRANSFER_TIMED_OUT,
+      :TRANSFER_CANCELLED,
+      :TRANSFER_STALL,
+      :TRANSFER_NO_DEVICE,
+      :TRANSFER_OVERFLOW,
+    ]
+
+    # libusb_transfer.flags values
+    TransferFlags = enum :libusb_transfer_flags, [
+      :TRANSFER_SHORT_NOT_OK, 1 << 0,
+      :TRANSFER_FREE_BUFFER, 1 << 1,
+      :TRANSFER_FREE_TRANSFER, 1 << 2,
+      :TRANSFER_ADD_ZERO_PACKET, 1 << 3,
+    ]
+
+    TransferTypes = enum :libusb_transfer_type, [
+      :TRANSFER_TYPE_CONTROL, 0,
+      :TRANSFER_TYPE_ISOCHRONOUS, 1,
+      :TRANSFER_TYPE_BULK, 2,
+      :TRANSFER_TYPE_INTERRUPT, 3,
+    ]
+
+    StandardRequests = enum :libusb_standard_request, [
+      :REQUEST_GET_STATUS, 0x00,
+      :REQUEST_CLEAR_FEATURE, 0x01,
+      :REQUEST_SET_FEATURE, 0x03,
+      :REQUEST_SET_ADDRESS, 0x05,
+      :REQUEST_GET_DESCRIPTOR, 0x06,
+      :REQUEST_SET_DESCRIPTOR, 0x07,
+      :REQUEST_GET_CONFIGURATION, 0x08,
+      :REQUEST_SET_CONFIGURATION, 0x09,
+      :REQUEST_GET_INTERFACE, 0x0A,
+      :REQUEST_SET_INTERFACE, 0x0B,
+      :REQUEST_SYNCH_FRAME, 0x0C,
+    ]
+
+    EndpointDirections = enum :libusb_endpoint_direction, [
+      :ENDPOINT_IN, 0x80,
+      :ENDPOINT_OUT, 0x00,
+    ]
+
+    DescriptorTypes = enum :libusb_descriptor_type, [
+      :DT_DEVICE, 0x01,
+      :DT_CONFIG, 0x02,
+      :DT_STRING, 0x03,
+      :DT_INTERFACE, 0x04,
+      :DT_ENDPOINT, 0x05,
+      :DT_HID, 0x21,
+      :DT_REPORT, 0x22,
+      :DT_PHYSICAL, 0x23,
+      :DT_HUB, 0x29,
+    ]
+
+    RequestTypes = enum :libusb_request_type, [
+      :REQUEST_TYPE_STANDARD, (0x00 << 5),
+      :REQUEST_TYPE_CLASS, (0x01 << 5),
+      :REQUEST_TYPE_VENDOR, (0x02 << 5),
+      :REQUEST_TYPE_RESERVED, (0x03 << 5),
+    ]
+
+    RequestRecipients = enum :libusb_request_recipient, [
+      :RECIPIENT_DEVICE, 0x00,
+      :RECIPIENT_INTERFACE, 0x01,
+      :RECIPIENT_ENDPOINT, 0x02,
+      :RECIPIENT_OTHER, 0x03,
+    ]
+
+    IsoSyncTypes = enum :libusb_iso_sync_type, [
+      :ISO_SYNC_TYPE_NONE, 0,
+      :ISO_SYNC_TYPE_ASYNC, 1,
+      :ISO_SYNC_TYPE_ADAPTIVE, 2,
+      :ISO_SYNC_TYPE_SYNC, 3,
+    ]
+
+    Speeds = enum :libusb_speed, [
+      :SPEED_UNKNOWN, 0,
+      :SPEED_LOW, 1,
+      :SPEED_FULL, 2,
+      :SPEED_HIGH, 3,
+      :SPEED_SUPER, 4,
+    ]
+
+    Capabilities = enum :libusb_capability, [
+      :CAP_HAS_CAPABILITY, 0,
+    ]
+
+    typedef :pointer, :libusb_context
+    typedef :pointer, :libusb_device_handle
+
+    def self.try_attach_function(method, *args)
+      if ffi_libraries.find{|lib| lib.find_function(method) }
+        attach_function method, *args
+      end
+    end
+
+    try_attach_function 'libusb_get_version', [], :pointer
+
+    attach_function 'libusb_init', [ :pointer ], :int
+    attach_function 'libusb_exit', [ :pointer ], :void
+    attach_function 'libusb_set_debug', [:pointer, :int], :void
+    try_attach_function 'libusb_has_capability', [:libusb_capability], :int
+
+    attach_function 'libusb_get_device_list', [:pointer, :pointer], :size_t
+    attach_function 'libusb_free_device_list', [:pointer, :int], :void
+    attach_function 'libusb_ref_device', [:pointer], :pointer
+    attach_function 'libusb_unref_device', [:pointer], :void
+
+    attach_function 'libusb_get_device_descriptor', [:pointer, :pointer], :int
+    attach_function 'libusb_get_active_config_descriptor', [:pointer, :pointer], :int
+    attach_function 'libusb_get_config_descriptor', [:pointer, :uint8, :pointer], :int
+    attach_function 'libusb_get_config_descriptor_by_value', [:pointer, :uint8, :pointer], :int
+    attach_function 'libusb_free_config_descriptor', [:pointer], :void
+    attach_function 'libusb_get_bus_number', [:pointer], :uint8
+    try_attach_function 'libusb_get_port_number', [:pointer], :uint8
+    try_attach_function 'libusb_get_parent', [:pointer], :pointer
+    try_attach_function 'libusb_get_port_path', [:pointer, :pointer, :pointer, :uint8], :uint8
+    attach_function 'libusb_get_device_address', [:pointer], :uint8
+    try_attach_function 'libusb_get_device_speed', [:pointer], :libusb_speed
+    attach_function 'libusb_get_max_packet_size', [:pointer, :uint8], :int
+    attach_function 'libusb_get_max_iso_packet_size', [:pointer, :uint8], :int
+
+    attach_function 'libusb_open', [:pointer, :pointer], :int
+    attach_function 'libusb_close', [:pointer], :void
+    attach_function 'libusb_get_device', [:libusb_device_handle], :pointer
+
+    attach_function 'libusb_set_configuration', [:libusb_device_handle, :int], :int, :blocking=>true
+    attach_function 'libusb_claim_interface', [:libusb_device_handle, :int], :int
+    attach_function 'libusb_release_interface', [:libusb_device_handle, :int], :int, :blocking=>true
+
+    attach_function 'libusb_open_device_with_vid_pid', [:pointer, :int, :int], :pointer
+
+    attach_function 'libusb_set_interface_alt_setting', [:libusb_device_handle, :int, :int], :int, :blocking=>true
+    attach_function 'libusb_clear_halt', [:libusb_device_handle, :int], :int, :blocking=>true
+    attach_function 'libusb_reset_device', [:libusb_device_handle], :int, :blocking=>true
+
+    attach_function 'libusb_kernel_driver_active', [:libusb_device_handle, :int], :int
+    attach_function 'libusb_detach_kernel_driver', [:libusb_device_handle, :int], :int
+    attach_function 'libusb_attach_kernel_driver', [:libusb_device_handle, :int], :int
+
+    attach_function 'libusb_get_string_descriptor_ascii', [:pointer, :uint8, :pointer, :int], :int
+
+    attach_function 'libusb_alloc_transfer', [:int], :pointer
+    attach_function 'libusb_submit_transfer', [:pointer], :int
+    attach_function 'libusb_cancel_transfer', [:pointer], :int
+    attach_function 'libusb_free_transfer', [:pointer], :void
+
+    attach_function 'libusb_handle_events', [:libusb_context], :int, :blocking=>true
+
+
+    callback :libusb_transfer_cb_fn, [:pointer], :void
+
+    class IsoPacketDescriptor < FFI::Struct
+      layout :length, :uint,
+          :actual_length, :uint,
+          :status, :libusb_transfer_status
+    end
+
+    # Setup packet for control transfers.
+    class ControlSetup < FFI::Struct
+      layout :bmRequestType, :uint8,
+          :bRequest, :uint8,
+          :wValue, :uint16,
+          :wIndex, :uint16,
+          :wLength, :uint16
+    end
+
+    class Transfer < FFI::ManagedStruct
+      layout :dev_handle, :libusb_device_handle,
+        :flags, :uint8,
+        :endpoint, :uchar,
+        :type, :uchar,
+        :timeout, :uint,
+        :status, :libusb_transfer_status,
+        :length, :int,
+        :actual_length, :int,
+        :callback, :libusb_transfer_cb_fn,
+        :user_data, :pointer,
+        :buffer, :pointer,
+        :num_iso_packets, :int
+
+      def self.release(ptr)
+        Call.libusb_free_transfer(ptr)
+      end
+    end
+
+    class DeviceDescriptor < FFI::Struct
+      include Comparable
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bcdUSB, :uint16,
+          :bDeviceClass, :uint8,
+          :bDeviceSubClass, :uint8,
+          :bDeviceProtocol, :uint8,
+          :bMaxPacketSize0, :uint8,
+          :idVendor, :uint16,
+          :idProduct, :uint16,
+          :bcdDevice, :uint16,
+          :iManufacturer, :uint8,
+          :iProduct, :uint8,
+          :iSerialNumber, :uint8,
+          :bNumConfigurations, :uint8
+    end
+  end
+end

data/lib/libusb/compat.rb

@@ -97,8 +97,8 @@ module USB
   USB_RECIP_ENDPOINT = LIBUSB::RECIPIENT_ENDPOINT
   USB_RECIP_OTHER = LIBUSB::RECIPIENT_OTHER
 
-  HAS_GET_DRIVER_NP = RUBY_PLATFORM=~/mswin|mingw/ ? false : true
-  HAS_DETACH_KERNEL_DRIVER_NP = RUBY_PLATFORM=~/mswin|mingw/ ? false : true
+  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

data/lib/libusb/configuration.rb

@@ -0,0 +1,139 @@
+# 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::ManagedStruct
+    include Comparable
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :wTotalLength, :uint16,
+        :bNumInterfaces, :uint8,
+        :bConfigurationValue, :uint8,
+        :iConfiguration, :uint8,
+        :bmAttributes, :uint8,
+        :maxPower, :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]
+    def bmAttributes
+      self[:bmAttributes]
+    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 maxPower
+      self[:maxPower]
+    end
+
+    # 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)
+    end
+
+    def self.release(ptr)
+      Call.libusb_free_config_descriptor(ptr)
+    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
+      bits = self.bmAttributes
+      attrs << "SelfPowered" if (bits & 0b1000000) != 0
+      attrs << "RemoteWakeup" if (bits & 0b100000) != 0
+      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,138 @@
+# 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.to_h.each{|k,v| const_set(k,v) }
+  Call::TransferTypes.to_h.each{|k,v| const_set(k,v) }
+  Call::StandardRequests.to_h.each{|k,v| const_set(k,v) }
+  Call::RequestTypes.to_h.each{|k,v| const_set(k,v) }
+  Call::DescriptorTypes.to_h.each{|k,v| const_set(k,v) }
+  Call::EndpointDirections.to_h.each{|k,v| const_set(k,v) }
+  Call::RequestRecipients.to_h.each{|k,v| const_set(k,v) }
+  Call::IsoSyncTypes.to_h.each{|k,v| const_set(k,v) }
+  Call::Speeds.to_h.each{|k,v| const_set(k,v) }
+  Call::Capabilities.to_h.each{|k,v| const_set(k,v) }
+
+  # Base class of libusb errors
+  class Error < RuntimeError
+  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
+
+
+  # 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 Bluk-Only"],
+    [0x08, 0x02, 0x50, "MassStorage ATAPI Bluk-Only"],
+    [0x08, 0x03, 0x50, "MassStorage QIC-157 Bluk-Only"],
+    [0x08, 0x04, nil, "MassStorage UFI"],
+    [0x08, 0x05, 0x50, "MassStorage SFF-8070i Bluk-Only"],
+    [0x08, 0x06, 0x50, "MassStorage SCSI Bluk-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
+      "Unkonwn(%02x,%02x,%02x)" % [base_class, sub_class, protocol]
+    end
+  end
+end