libusb 0.3.3-x64-mingw32

data/lib/libusb/endpoint.rb

@@ -0,0 +1,174 @@
+# 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 Endpoint < FFI::Struct
+    include Comparable
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bEndpointAddress, :uint8,
+        :bmAttributes, :uint8,
+        :wMaxPacketSize, :uint16,
+        :bInterval, :uint8,
+        :bRefresh, :uint8,
+        :bSynchAddress, :uint8,
+        :extra, :pointer,
+        :extra_length, :int
+
+    # Size of Descriptor in Bytes (7 bytes)
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type (0x05)
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # The address of the endpoint described by this descriptor.
+    #
+    # * Bits 0..3: Endpoint Number.
+    # * Bits 4..6: Reserved. Set to Zero
+    # * Bits 7: Direction 0 = Out, 1 = In (Ignored for Control Endpoints)
+    #
+    # @return [Integer]
+    #
+    # @see #endpoint_number
+    # @see #direction
+    def bEndpointAddress
+      self[:bEndpointAddress]
+    end
+
+    # @return [Integer]
+    def endpoint_number
+      bEndpointAddress & 0b1111
+    end
+
+    # @return [Symbol]  Either +:in+ or +:out+
+    def direction
+      bEndpointAddress & ENDPOINT_IN == 0 ? :out : :in
+    end
+
+    # Attributes which apply to the endpoint when it is configured using the {Configuration#bConfigurationValue}.
+    #
+    # * Bits 1..0: Transfer Type
+    #   * 00 = Control
+    #   * 01 = Isochronous
+    #   * 10 = Bulk
+    #   * 11 = Interrupt
+    # * Bits 7..2: are reserved. If Isochronous endpoint,
+    # * Bits 3..2: Synchronisation Type (Iso Mode)
+    #   * 00 = No Synchonisation
+    #   * 01 = Asynchronous
+    #   * 10 = Adaptive
+    #   * 11 = Synchronous
+    # * Bits 5..4: Usage Type (Iso Mode)
+    #   * 00 = Data Endpoint
+    #   * 01 = Feedback Endpoint
+    #   * 10 = Explicit Feedback Data Endpoint
+    #   * 11 = Reserved
+    #
+    # @return [Integer]
+    #
+    # @see #transfer_type
+    # @see #usage_type
+    # @see #synchronization_type
+    def bmAttributes
+      self[:bmAttributes]
+    end
+
+    TransferTypes = [:control, :isochronous, :bulk, :interrupt]
+    # @return [Symbol]  One of {TransferTypes}
+    def transfer_type
+      TransferTypes[bmAttributes & 0b11]
+    end
+
+    SynchronizationTypes = [:no_synchronization, :asynchronous, :adaptive, :synchronous]
+    # @return [Symbol]  One of {SynchronizationTypes}
+    def synchronization_type
+      return unless transfer_type == :isochronous
+      SynchronizationTypes[(bmAttributes & 0b1100) >> 2]
+    end
+
+    UsageTypes = [:data, :feedback, :implicit_feedback, :unknown]
+    # @return [Symbol]  One of {UsageTypes}
+    def usage_type
+      return unless transfer_type == :isochronous
+      UsageTypes[(bmAttributes & 0b110000) >> 4]
+    end
+
+    # Maximum Packet Size this endpoint is capable of sending or receiving
+    def wMaxPacketSize
+      self[:wMaxPacketSize]
+    end
+
+    # Interval for polling endpoint data transfers. Value in frame counts.
+    # Ignored for Bulk & Control Endpoints. Isochronous must equal 1 and field
+    # may range from 1 to 255 for interrupt endpoints.
+    #
+    # The interval is respected by the kernel driver, so user mode processes
+    # using libusb don't need to care about it.
+    def bInterval
+      self[:bInterval]
+    end
+
+    # For audio devices only: the rate at which synchronization feedback is provided.
+    def bRefresh
+      self[:bRefresh]
+    end
+
+    # For audio devices only: the address if the synch endpoint.
+    def bSynchAddress
+      self[:bSynchAddress]
+    end
+
+    # Extra descriptors.
+    #
+    # @return [String]
+    def extra
+      return if self[:extra].null?
+      self[:extra].read_string(self[:extra_length])
+    end
+
+    def initialize(setting, *args)
+      @setting = setting
+      super(*args)
+    end
+
+    # @return [Setting] the setting this endpoint belongs to.
+    attr_reader :setting
+
+    def inspect
+      type = [transfer_type, synchronization_type, usage_type].compact
+      "\#<#{self.class} #{endpoint_number} #{direction} #{type.join(" ")}>"
+    end
+
+    # The {Device} this Endpoint belongs to.
+    def device() self.setting.interface.configuration.device end
+    # The {Configuration} this Endpoint belongs to.
+    def configuration() self.setting.interface.configuration end
+    # The {Interface} this Endpoint belongs to.
+    def interface() self.setting.interface end
+
+    def <=>(o)
+      t = setting<=>o.setting
+      t = bEndpointAddress<=>o.bEndpointAddress if t==0
+      t
+    end
+  end
+end

data/lib/libusb/eventmachine.rb

@@ -0,0 +1,183 @@
+# 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'
+require 'eventmachine'
+
+module LIBUSB
+class Context
+  # Register libusb's file descriptors and timeouts to EventMachine.
+  #
+  # @example
+  #   require 'libusb/eventmachine'
+  #   context = LIBUSB::Context.new
+  #   EventMachine.run do
+  #     context.eventmachine_register
+  #   end
+  #
+  # @see
+  #   DevHandle#eventmachine_bulk_transfer
+  #   DevHandle#eventmachine_control_transfer
+  #   DevHandle#eventmachine_interrupt_transfer
+  def eventmachine_register
+    @eventmachine_attached_fds = {}
+    @eventmachine_timer = nil
+
+    pollfds = self.pollfds
+    if pollfds
+      pollfds.each do |pollfd|
+        eventmachine_add_pollfd(pollfd)
+      end
+
+      self.on_pollfd_added do |pollfd|
+        eventmachine_add_pollfd(pollfd)
+      end
+
+      self.on_pollfd_removed do |pollfd|
+        eventmachine_rm_pollfd(pollfd)
+      end
+    else
+      # Libusb pollfd API is not available on this platform.
+      # Use simple polling timer, instead:
+      EventMachine.add_periodic_timer(0.01) do
+        @eventmachine_timer = self.handle_events 0
+      end
+    end
+  end
+
+  def eventmachine_unregister
+    @eventmachine_timer.cancel if @eventmachine_timer
+    @eventmachine_attached_fds.each do |fd, watcher|
+      watcher.detach
+    end
+  end
+
+  class EMPollfdHandler < EventMachine::Connection
+    def initialize
+      @callbacks = []
+      super
+    end
+
+    def on_need_handle_events(&block)
+      @callbacks << block
+    end
+
+    def need_handle_events
+      @callbacks.each do |cb|
+        cb.call
+      end
+    end
+    alias notify_readable need_handle_events
+    alias notify_writable need_handle_events
+  end
+
+  private
+  def eventmachine_add_pollfd(pollfd)
+    conn = EventMachine.watch(pollfd.io, EMPollfdHandler)
+    conn.notify_readable = pollfd.pollin?
+    conn.notify_writable = pollfd.pollout?
+    cb = proc do
+      if @eventmachine_timer
+        @eventmachine_timer.cancel
+        @eventmachine_timer = nil
+      end
+
+      self.handle_events 0
+      timeout = self.next_timeout
+#         puts "libusb new timeout: #{timeout.inspect}"
+      if timeout
+        @eventmachine_timer = EventMachine.add_timer(timeout, &cb)
+      end
+    end
+    conn.on_need_handle_events(&cb)
+
+    @eventmachine_attached_fds[pollfd.fd] = conn
+#       puts "libusb pollfd added: #{pollfd.inspect}"
+  end
+
+  def eventmachine_rm_pollfd(pollfd)
+    @eventmachine_attached_fds[pollfd.fd].detach
+#       puts "libusb pollfd removed: #{pollfd.inspect}"
+  end
+end
+
+class DevHandle
+  class EMTransfer
+    include EM::Deferrable
+
+    def initialize(opts, dev_handle, transfer_method)
+      dev_handle.send(transfer_method, opts) do |res|
+        EM.next_tick do
+          if res.kind_of?(LIBUSB::Error)
+            fail res
+          else
+            succeed res
+          end
+        end
+      end
+    end
+  end
+
+  # Execute an eventmachine driven USB interrupt transfer.
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#interrupt_transfer
+  def eventmachine_interrupt_transfer(opts={})
+    eventmachine_transfer(opts, :interrupt_transfer)
+  end
+
+  # Execute an eventmachine driven USB bulk transfer.
+  #
+  # @example
+  #   tr = devh.eventmachine_bulk_transfer( :endpoint => 0x02, :dataOut => "data" )
+  #   tr.callback do |data|
+  #     puts "sent: #{data.inspect}"
+  #   end
+  #   tr.errback do |ex|
+  #     puts "send-err: #{ex}"
+  #   end
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#bulk_transfer
+  def eventmachine_bulk_transfer(opts={})
+    eventmachine_transfer(opts, :bulk_transfer)
+  end
+
+  # Execute an eventmachine driven USB control transfer.
+  #
+  # @example
+  #   tr = devh.eventmachine_control_transfer(
+  #     :bmRequestType=>ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+  #     :bRequest=>0x01,
+  #     :wValue=>0, :wIndex=>0, :dataIn=>1 )
+  #   tr.callback do |data|
+  #     puts "recved: #{data.inspect}"
+  #   end
+  #   tr.errback do |ex|
+  #     puts "recv-err: #{ex}"
+  #   end
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#control_transfer
+  def eventmachine_control_transfer(opts={})
+    eventmachine_transfer(opts, :control_transfer)
+  end
+
+  private
+  def eventmachine_transfer(opts, method)
+    EMTransfer.new opts, self, method
+  end
+end
+end

data/lib/libusb/interface.rb

@@ -0,0 +1,60 @@
+# 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 Interface < FFI::Struct
+    include Comparable
+
+    layout :altsetting, :pointer,
+        :num_altsetting, :int
+
+    # Number of this interface.
+    def bInterfaceNumber
+      settings.first.bInterfaceNumber
+    end
+
+    def initialize(configuration, *args)
+      @configuration = configuration
+      super(*args)
+    end
+
+    # @return [Configuration] the configuration this interface belongs to.
+    attr_reader :configuration
+
+    def alt_settings
+      ifs = []
+      self[:num_altsetting].times do |i|
+        ifs << Setting.new(self, self[:altsetting] + i*Setting.size)
+      end
+      return ifs
+    end
+    alias settings alt_settings
+
+    def inspect
+      "\#<#{self.class} #{bInterfaceNumber}>"
+    end
+
+    # The {Device} this Interface belongs to.
+    def device() self.configuration.device end
+    # Return all endpoints of all alternative settings as Array of {Endpoint}s.
+    def endpoints() self.alt_settings.map {|d| d.endpoints }.flatten end
+
+    def <=>(o)
+      configuration<=>o.configuration
+    end
+  end
+end

data/lib/libusb/setting.rb

@@ -0,0 +1,132 @@
+# 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 Setting < FFI::Struct
+    include Comparable
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bInterfaceNumber, :uint8,
+        :bAlternateSetting, :uint8,
+        :bNumEndpoints, :uint8,
+        :bInterfaceClass, :uint8,
+        :bInterfaceSubClass, :uint8,
+        :bInterfaceProtocol, :uint8,
+        :iInterface, :uint8,
+        :endpoint, :pointer,
+        :extra, :pointer,
+        :extra_length, :int
+
+    # Size of this descriptor (in bytes).
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type (0x04)
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # Number of the interface this setting belongs to.
+    def bInterfaceNumber
+      self[:bInterfaceNumber]
+    end
+
+    # Value used to select this alternate setting for this interface.
+    def bAlternateSetting
+      self[:bAlternateSetting]
+    end
+
+    # Number of endpoints used by this interface (excluding the control endpoint).
+    def bNumEndpoints
+      self[:bNumEndpoints]
+    end
+
+    # USB-IF class code for this interface.
+    def bInterfaceClass
+      self[:bInterfaceClass]
+    end
+
+    # USB-IF subclass code for this interface, qualified by the {Setting#bInterfaceClass} value.
+    def bInterfaceSubClass
+      self[:bInterfaceSubClass]
+    end
+
+    # USB-IF protocol code for this interface, qualified by the {Setting#bInterfaceClass} and {Setting#bInterfaceSubClass} values.
+    def bInterfaceProtocol
+      self[:bInterfaceProtocol]
+    end
+
+    # Index of string descriptor describing this interface.
+    def iInterface
+      self[:iInterface]
+    end
+
+    # Extra descriptors.
+    #
+    # @return [String]
+    def extra
+      return if self[:extra].null?
+      self[:extra].read_string(self[:extra_length])
+    end
+
+    def initialize(interface, *args)
+      @interface = interface
+      super(*args)
+    end
+
+    # @return [Interface] the interface this setting belongs to.
+    attr_reader :interface
+
+    def endpoints
+      ifs = []
+      self[:bNumEndpoints].times do |i|
+        ifs << Endpoint.new(self, self[:endpoint] + i*Endpoint.size)
+      end
+      return ifs
+    end
+
+    def inspect
+      attrs = []
+      attrs << self.bAlternateSetting.to_s
+      devclass = LIBUSB.dev_string(self.bInterfaceClass, self.bInterfaceSubClass, self.bInterfaceProtocol)
+      attrs << devclass
+      desc = self.description
+      attrs << desc if desc != '?'
+      "\#<#{self.class} #{attrs.join(' ')}>"
+    end
+
+    # Return name of this interface as String.
+    def description
+      return @description if defined? @description
+      @description = device.try_string_descriptor_ascii(self.iInterface)
+    end
+
+    # The {Device} this Setting belongs to.
+    def device() self.interface.configuration.device end
+    # The {Configuration} this Setting belongs to.
+    def configuration() self.interface.configuration end
+
+    def <=>(o)
+      t = interface<=>o.interface
+      t = bInterfaceNumber<=>o.bInterfaceNumber if t==0
+      t = bAlternateSetting<=>o.bAlternateSetting if t==0
+      t
+    end
+  end
+end