libusb 0.6.0-x86-linux

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

data/lib/libusb/ss_companion.rb

@@ -0,0 +1,69 @@
+# 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
+  # A structure representing the superspeed endpoint companion descriptor.
+  #
+  # This descriptor is documented in section 9.6.7 of the USB 3.0 specification. All multiple-byte fields are represented in host-endian format.
+  class SsCompanion < FFI::ManagedStruct
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bMaxBurst, :uint8,
+        :bmAttributes, :uint8,
+        :wBytesPerInterval, :uint16
+
+    # Size of this descriptor (in bytes)
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type.
+    #
+    # Will have value LIBUSB::DT_SS_ENDPOINT_COMPANION in this context.
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # The maximum number of packets the endpoint can send or recieve as part of a burst.
+    def bMaxBurst
+      self[:bMaxBurst]
+    end
+
+    # In bulk EP: bits 4:0 represents the maximum number of streams the EP supports.
+    #
+    # In isochronous EP: bits 1:0 represents the Mult - a zero based value that determines the maximum number of packets within a service interval
+    def bmAttributes
+      self[:bmAttributes]
+    end
+
+    # The total number of bytes this EP will transfer every service interval.
+    #
+    # valid only for periodic EPs.
+    def wBytesPerInterval
+      self[:wBytesPerInterval]
+    end
+
+    def inspect
+      "\#<#{self.class} burst: #{bMaxBurst} attrs: #{bmAttributes}>"
+    end
+
+    # @private
+    def self.release(ptr)
+      Call.libusb_free_ss_endpoint_companion_descriptor(ptr)
+    end
+  end
+end

data/lib/libusb/stdio.rb

@@ -0,0 +1,25 @@
+# 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
+  module Stdio
+    extend FFI::Library
+    ffi_lib FFI::Platform::LIBC
+    attach_function :free, [ :pointer ], :void
+  end
+end