libusb 0.6.4 → 0.7.0

data/lib/libusb/context.rb

@@ -95,23 +95,87 @@ module LIBUSB
       end
     end
 
-
     # Initialize libusb context.
-    def initialize
+    #
+    # @param [Hash{Call::Options => Object}] options   Options are available since libusb-1.0.27
+    # @option options [Integer, Symbol] :OPTION_LOG_LEVEL   The log Level as a Integer or Symbol. See Call::LogLevels
+    # @option options [nil] :OPTION_USE_USBDK  Enable the use of USBDK driver. Pass a +nil+ as value like so: +OPTION_USE_USBDK: nil+
+    # @option options [nil] :OPTION_NO_DEVICE_DISCOVERY  Disable device discovery for use with libusb_wrap_sys_device(). Pass a +nil+ as value like so: +OPTION_NO_DEVICE_DISCOVERY: nil+
+    # @option options [Proc] :OPTION_LOG_CB   Set a context related log callback Proc. It is called with parameters (context, level, logstring).
+    def initialize(options={})
       m = FFI::MemoryPointer.new :pointer
-      res = Call.libusb_init(m)
-      LIBUSB.raise_error res, "in libusb_init" if res!=0
+      if options.empty?
+        res = Call.libusb_init(m)
+        LIBUSB.raise_error res, "in libusb_init" if res!=0
+      else
+        raise ArgumentError, "options require libusb-1.0.27+" unless Call.respond_to?(:libusb_init_context)
+        i_opts = options.size
+        p_opts = FFI::MemoryPointer.new(Call::InitOption, i_opts)
+        options.each_with_index do |(k, v), i|
+          opt = Call::InitOption.new(p_opts + i * Call::InitOption.size)
+          opt[:option] = k
+
+          ffitype, ffival = LIBUSB.send(:option_args_to_ffi, k, Array(v), self)
+          case ffitype
+            when NilClass then nil
+            when :libusb_log_level then
+              opt[:value][:ival] = ffival
+            when :libusb_log_cb then
+              opt[:value][:log_cbval] = ffival
+            else raise ArgumentError, "internal error: unexpected ffitype: #{ffitype.inspect}"
+          end
+        end
+        res = Call.libusb_init_context(m, p_opts, i_opts)
+        LIBUSB.raise_error res, "in libusb_init_context" if res!=0
+      end
       @ctx = m.read_pointer
       @on_pollfd_added = nil
       @on_pollfd_removed = nil
       @hotplug_callbacks = {}
+
+      def @ctx.free_context(id)
+        @free_context = true
+        if @refs == 0
+          # puts "final libusb_exit #{to_i} #{id} #{caller[0]}"
+          if id # Is Context is about to be garbage collected?
+            # In GC mode there's no way to call the registered collbacks, since they are GC'ed as well.
+            # So disable callbacks now.
+            Call.libusb_set_log_cb(self, nil, LOG_CB_CONTEXT)
+            Call.libusb_set_pollfd_notifiers(self, nil, nil, nil)
+          end
+          Call.libusb_exit(self)
+          @refs = nil
+        end
+      end
+      def @ctx.ref_context
+        @refs += 1
+        # puts "ref_context #{to_i} #{@refs} #{caller[1]}"
+        self
+      end
+      def @ctx.unref_context
+        @refs -= 1
+        # puts "unref_context #{to_i} #{@refs}"
+        raise "more unref_context than ref_context" if @refs < 0
+        free_context(true) if @refs == 0 && @free_context
+        self
+      end
+      def @ctx.setref_context
+        @refs = 0
+        @free_context = false
+      end
+      def @ctx.refs
+        @refs
+      end
+      @ctx.setref_context
+      ObjectSpace.define_finalizer(self, @ctx.method(:free_context))
     end
 
     # Deinitialize libusb.
     #
     # Should be called after closing all open devices and before your application terminates.
     def exit
-      Call.libusb_exit(@ctx)
+      raise RemainingReferencesError, "#{@ctx.refs} remaining references to LIBUSB::Context" if @ctx.refs.to_i > 0
+      @ctx.free_context nil
     end
 
     # @deprecated Use {Context#set_option} instead using the +:OPTION_LOG_LEVEL+ option.
@@ -119,30 +183,37 @@ module LIBUSB
       Call.libusb_set_debug(@ctx, level)
     end
 
-    def expect_option_args(exp, is)
-      raise ArgumentError, "wrong number of arguments (given #{is+1}, expected #{exp+1})" if is != exp
+    private def wrap_log_cb(block, mode)
+      if block
+        cb_proc = proc do |p_ctx, lev, str|
+          ctx = case p_ctx
+            when FFI::Pointer::NULL then nil
+            when @ctx then self
+            else p_ctx.to_i
+          end
+          block.call(ctx, lev, str)
+        end
+      end
+
+      # Avoid garbage collection of the proc, since only the function pointer is given to libusb
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_GLOBAL != 0
+        @@log_cb_proc = cb_proc
+      end
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_CONTEXT != 0
+        @log_cb_proc = cb_proc
+      end
+      cb_proc
     end
-    private :expect_option_args
 
-    # Set a libusb option from the {Call::Options option list}.
+    # Set a context related libusb option from the {Call::Options option list}.
     #
     # @param [Symbol, Fixnum] option
     # @param args  Zero or more arguments depending on +option+
+    # @see set_options
     def set_option(option, *args)
       if Call.respond_to?(:libusb_set_option)
         # Available since libusb-1.0.22
-
-        ffi_args = case option
-          when :OPTION_LOG_LEVEL, LIBUSB::OPTION_LOG_LEVEL
-            expect_option_args(1, args.length)
-            [:libusb_log_level, args[0]]
-          when :OPTION_USE_USBDK, LIBUSB::OPTION_USE_USBDK
-            expect_option_args(0, args.length)
-            []
-          else
-            raise ArgumentError, "unknown option #{option.inspect}"
-        end
-
+        ffi_args = LIBUSB.send(:option_args_to_ffi, option, args, self)
         res = Call.libusb_set_option(@ctx, option, *ffi_args)
         LIBUSB.raise_error res, "in libusb_set_option" if res<0
 
@@ -154,6 +225,69 @@ module LIBUSB
       end
     end
 
+    # Convenience function to set context related options in the libusb library.
+    #
+    # Use this function to configure any number of options within the library.
+    # It takes a Hash the same way as given to {Context.initialize}.
+    # See also {Call::Options option list}.
+    #
+    # @param [Hash{Call::Options => Object}] options   Option hash
+    # @see set_option
+    def set_options(options={})
+      options.each do |k, v|
+        set_option(k, *Array(v))
+      end
+    end
+
+    if Call.respond_to?(:libusb_set_log_cb)
+      # Set log handler.
+      #
+      # libusb will redirect its log messages to the provided method block.
+      # libusb supports redirection of per context and global log messages.
+      # Log messages sent to the context will be sent to the global log handler too.
+      #
+      # If libusb is compiled without message logging or USE_SYSTEM_LOGGING_FACILITY
+      # is defined then global callback function will never be called.
+      # If ENABLE_DEBUG_LOGGING is defined then per context callback function will
+      # never be called.
+      #
+      # To disable the log callback, execute set_log_cb without a block.
+      #
+      # Available since libusb-1.0.23, LIBUSB_API_VERSION >= 0x01000107
+      #
+      # @param [Symbol, Integer] mode   mode of callback function operation.
+      #       Several modes can be selected for a single callback function, see Call::LogCbMode for a description.
+      #
+      # @yieldparam [Context, nil] context  The context which is related to the log message, or +nil+ if it is a global log message.
+      # @yieldparam [Symbol] level   The log level, see Call::LogLevels for a description.
+      # @yieldparam [String] str   The log message.
+      #
+      # @see Call::LogCbMode
+      #
+      def set_log_cb(mode, &block)
+        cb_proc = wrap_log_cb(block, mode)
+        Call.libusb_set_log_cb(@ctx, cb_proc, mode)
+        self
+      end
+    end
+
+    if Call.respond_to?(:libusb_wrap_sys_device)
+      def wrap_sys_device(dev_io)
+        dev_io = dev_io.is_a?(IO) ? dev_io.fileno : dev_io
+
+        ppHandle = FFI::MemoryPointer.new :pointer
+        res = Call.libusb_wrap_sys_device(@ctx, dev_io, ppHandle)
+        LIBUSB.raise_error res, "in libusb_wrap_sys_device" if res!=0
+        handle = DevHandle.new self, ppHandle.read_pointer
+        return handle unless block_given?
+        begin
+          yield handle
+        ensure
+          handle.close
+        end
+      end
+    end
+
     def device_list
       pppDevs = FFI::MemoryPointer.new :pointer
       size = Call.libusb_get_device_list(@ctx, pppDevs)
@@ -327,14 +461,18 @@ module LIBUSB
     # This block will be invoked for every new file descriptor that
     # libusb uses as an event source.
     #
+    # To disable the notification callback, execute on_pollfd_added without a block.
+    #
     # Note that file descriptors may have been added even before you register these
     # notifiers (e.g. at {Context#initialize} time).
     #
     # @yieldparam [Pollfd] pollfd  The added file descriptor is yielded to the block
     def on_pollfd_added &block
-      @on_pollfd_added = proc do |fd, events, _|
-        pollfd = Pollfd.new fd, events
-        block.call pollfd
+      @on_pollfd_added = if block
+        proc do |fd, events, _|
+          pollfd = Pollfd.new fd, events
+          block.call pollfd
+        end
       end
       Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
     end
@@ -344,6 +482,8 @@ module LIBUSB
     # This block will be invoked for every removed file descriptor that
     # libusb uses as an event source.
     #
+    # To disable the notification callback, execute on_pollfd_removed without a block.
+    #
     # Note that the removal notifier may be called during {Context#exit}
     # (e.g. when it is closing file descriptors that were opened and added to the poll
     # set at {Context#initialize} time). If you don't want this, overwrite the notifier
@@ -351,9 +491,11 @@ module LIBUSB
     #
     # @yieldparam [Pollfd] pollfd  The removed file descriptor is yielded to the block
     def on_pollfd_removed &block
-      @on_pollfd_removed = proc do |fd, _|
-        pollfd = Pollfd.new fd
-        block.call pollfd
+      @on_pollfd_removed = if block
+        proc do |fd, _|
+          pollfd = Pollfd.new fd
+          block.call pollfd
+        end
       end
       Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
     end
@@ -393,19 +535,18 @@ module LIBUSB
     # @yieldparam [Symbol] event  a {Call::HotplugEvents HotplugEvents} symbol
     # @yieldreturn [Symbol] +:finish+ to deregister the callback, +:repeat+ to receive additional events
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def on_hotplug_event(args={}, &block)
-      events = args.delete(:events) || (HOTPLUG_EVENT_DEVICE_ARRIVED | HOTPLUG_EVENT_DEVICE_LEFT)
-      flags = args.delete(:flags) || 0
-      vendor_id = args.delete(:vendor_id) || HOTPLUG_MATCH_ANY
-      product_id = args.delete(:product_id) || HOTPLUG_MATCH_ANY
-      dev_class = args.delete(:dev_class) || HOTPLUG_MATCH_ANY
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
+    def on_hotplug_event(events: HOTPLUG_EVENT_DEVICE_ARRIVED | HOTPLUG_EVENT_DEVICE_LEFT,
+                         flags: 0,
+                         vendor_id: HOTPLUG_MATCH_ANY,
+                         product_id: HOTPLUG_MATCH_ANY,
+                         dev_class: HOTPLUG_MATCH_ANY,
+                         &block)
 
       handle = HotplugCallback.new self, @ctx, @hotplug_callbacks
 
       block2 = proc do |ctx, pDevice, event, _user_data|
         raise "internal error: unexpected context" unless @ctx==ctx
-        dev = Device.new @ctx, pDevice
+        dev = Device.new self, pDevice
 
         blres = block.call(dev, event)
 

data/lib/libusb/context_reference.rb

@@ -0,0 +1,38 @@
+# 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/>.
+
+module LIBUSB
+  module ContextReference
+    def register_context(ctx, free_sym)
+      ptr = pointer
+      def ptr.free_struct(id)
+        return unless @ctx
+        Call.send(@free_sym, self)
+        @ctx.unref_context
+      end
+      ptr.instance_variable_set(:@free_sym, free_sym)
+      ptr.instance_variable_set(:@ctx, ctx.ref_context)
+      ObjectSpace.define_finalizer(self, ptr.method(:free_struct))
+    end
+
+    def free
+      ptr = pointer
+      ptr.free_struct nil
+      ptr.instance_variable_set(:@ctx, nil)
+    end
+  end
+
+  private_constant :ContextReference
+end

data/lib/libusb/dependencies.rb

@@ -1,7 +1,7 @@
 module LIBUSB
-  LIBUSB_VERSION = ENV['LIBUSB_VERSION'] || '1.0.22'
+  LIBUSB_VERSION = ENV['LIBUSB_VERSION'] || '1.0.27'
   LIBUSB_SOURCE_URI = "https://github.com/libusb/libusb/releases/download/v#{LIBUSB_VERSION}/libusb-#{LIBUSB_VERSION}.tar.bz2"
-  LIBUSB_SOURCE_SHA1 = '10116aa265aac4273a0c894faa089370262ec0dc'
+  LIBUSB_SOURCE_SHA256 = 'ffaa41d741a8a3bee244ac8e54a72ea05bf2879663c098c82fc5757853441575'
 
   MINI_PORTILE_VERSION = '~> 2.1'
 end

data/lib/libusb/dev_handle.rb

@@ -372,19 +372,22 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def bulk_transfer(args={}, &block)
-      timeout = args.delete(:timeout) || 1000
-      endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
+    def bulk_transfer(timeout: 1000,
+                      endpoint:,
+                      dataIn: nil,
+                      dataOut: nil,
+                      allow_device_memory: false,
+                      &block)
+
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       if endpoint&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || raise(ArgumentError, "no :dataIn given for bulk read")
+        dataIn || raise(ArgumentError, "no :dataIn given for bulk read")
       else
-        dataOut = args.delete(:dataOut) || raise(ArgumentError, "no :dataOut given for bulk write")
+        dataOut || raise(ArgumentError, "no :dataOut given for bulk write")
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @bulk_transfer ||= BulkTransfer.new dev_handle: self, allow_device_memory: true
+      @bulk_transfer ||= BulkTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @bulk_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -440,19 +443,21 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def interrupt_transfer(args={}, &block)
-      timeout = args.delete(:timeout) || 1000
-      endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
+    def interrupt_transfer(timeout: 1000,
+                           endpoint:,
+                           dataIn: nil,
+                           dataOut: nil,
+                           allow_device_memory: false,
+                           &block)
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       if endpoint&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || raise(ArgumentError, "no :dataIn given for interrupt read")
+        dataIn || raise(ArgumentError, "no :dataIn given for interrupt read")
       else
-        dataOut = args.delete(:dataOut) || raise(ArgumentError, "no :dataOut given for interrupt write")
+        dataOut || raise(ArgumentError, "no :dataOut given for interrupt write")
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @interrupt_transfer ||= InterruptTransfer.new dev_handle: self, allow_device_memory: true
+      @interrupt_transfer ||= InterruptTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @interrupt_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -497,22 +502,27 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def control_transfer(args={}, &block)
-      bmRequestType = args.delete(:bmRequestType) || raise(ArgumentError, "param :bmRequestType not given")
-      bRequest = args.delete(:bRequest) || raise(ArgumentError, "param :bRequest not given")
-      wValue = args.delete(:wValue) || raise(ArgumentError, "param :wValue not given")
-      wIndex = args.delete(:wIndex) || raise(ArgumentError, "param :wIndex not given")
-      timeout = args.delete(:timeout) || 1000
+    def control_transfer(bmRequestType:,
+                         bRequest:,
+                         wValue:,
+                         wIndex:,
+                         timeout: 1000,
+                         dataIn: nil,
+                         dataOut: nil,
+                         allow_device_memory: false,
+                         &block)
+
       if bmRequestType&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || 0
+        raise ArgumentError, "invalid param :dataOut" unless dataOut.nil?
+        dataIn ||= 0
         dataOut = ''
       else
-        dataOut = args.delete(:dataOut) || ''
+        raise ArgumentError, "invalid param :dataIn" unless dataIn.nil?
+        dataOut ||= ''
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @control_transfer ||= ControlTransfer.new dev_handle: self, allow_device_memory: true
+      @control_transfer ||= ControlTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @control_transfer
       tr.timeout = timeout
       if dataIn

data/lib/libusb/device.rb

@@ -21,24 +21,27 @@ module LIBUSB
   # Devices of the system can be obtained with {Context#devices} .
   class Device
     include Comparable
+    include ContextReference
 
     # @return [Context] the context this device belongs to.
     attr_reader :context
 
     def initialize context, pDev
       @context = context
-      def pDev.unref_device(id)
-        Call.libusb_unref_device(self)
-      end
-      ObjectSpace.define_finalizer(self, pDev.method(:unref_device))
-      Call.libusb_ref_device(pDev)
       @pDev = pDev
+      register_context(context.instance_variable_get(:@ctx), :libusb_unref_device)
+      Call.libusb_ref_device(pDev)
 
       @pDevDesc = Call::DeviceDescriptor.new
       res = Call.libusb_get_device_descriptor(@pDev, @pDevDesc)
       LIBUSB.raise_error res, "in libusb_get_device_descriptor" if res!=0
     end
 
+    # The pointer for ContextReference
+    private def pointer
+      @pDev
+    end
+
     # Open the device and obtain a device handle.
     #
     # A handle allows you to perform I/O on the device in question.
@@ -160,6 +163,44 @@ module LIBUSB
       res
     end
 
+    if Call.respond_to?(:libusb_get_max_alt_packet_size)
+
+      # Calculate the maximum packet size which a specific endpoint is capable of
+      # sending or receiving in the duration of 1 microframe
+      #
+      # Only the active configuration is examined. The calculation is based on the
+      # wMaxPacketSize field in the endpoint descriptor as described in section
+      # 9.6.6 in the USB 2.0 specifications.
+      #
+      # If acting on an isochronous or interrupt endpoint, this function will
+      # multiply the value found in bits 0:10 by the number of transactions per
+      # microframe (determined by bits 11:12). Otherwise, this function just
+      # returns the numeric value found in bits 0:10. For USB 3.0 device, it
+      # will attempts to retrieve the Endpoint Companion Descriptor to return
+      # wBytesPerInterval.
+      #
+      # This function is useful for setting up isochronous transfers, for example
+      # you might pass the return value from this function to
+      # +IsochronousTransfer.packet_lengths=+ in order to set the length field of every
+      # isochronous packet in a transfer.
+      #
+      # Available since libusb-1.0.27.
+      #
+      # @param [Interface, Fixnum] interface  the interface or its bInterfaceNumber of the interface the endpoint belongs to
+      # @param [Setting, Fixnum] alternate_setting  the alternate setting or its bAlternateSetting
+      # @param [Endpoint, Fixnum] endpoint  (address of) the endpoint in question
+      # @return [Fixnum]  the maximum packet size which can be sent/received on this endpoint
+      # @see max_iso_packet_size
+      def max_alt_packet_size(interface, alternate_setting, endpoint)
+        interface = interface.bInterfaceNumber if interface.respond_to? :bInterfaceNumber
+        alternate_setting = alternate_setting.bAlternateSetting if alternate_setting.respond_to? :bAlternateSetting
+        endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
+        res = Call.libusb_get_max_alt_packet_size(@pDev, interface, alternate_setting, endpoint)
+        LIBUSB.raise_error res, "in libusb_get_max_alt_packet_size" unless res>=0
+        res
+      end
+    end
+
     # Calculate the maximum packet size which a specific endpoint is capable is
     # sending or receiving in the duration of 1 microframe.
     #
@@ -179,6 +220,7 @@ module LIBUSB
     #
     # @param [Endpoint, Fixnum] endpoint  (address of) the endpoint in question
     # @return [Fixnum] the maximum packet size which can be sent/received on this endpoint
+    # @see max_alt_packet_size
     def max_iso_packet_size(endpoint)
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       res = Call.libusb_get_max_iso_packet_size(@pDev, endpoint)
@@ -310,7 +352,7 @@ module LIBUSB
     def manufacturer
       return @manufacturer if defined? @manufacturer
       @manufacturer = try_string_descriptor_ascii(self.iManufacturer)
-      @manufacturer.strip! if @manufacturer
+      @manufacturer = @manufacturer.strip if @manufacturer
       @manufacturer
     end
 
@@ -319,7 +361,7 @@ module LIBUSB
     def product
       return @product if defined? @product
       @product = try_string_descriptor_ascii(self.iProduct)
-      @product.strip! if @product
+      @product = @product.strip if @product
       @product
     end
 
@@ -328,7 +370,7 @@ module LIBUSB
     def serial_number
       return @serial_number if defined? @serial_number
       @serial_number = try_string_descriptor_ascii(self.iSerialNumber)
-      @serial_number.strip! if @serial_number
+      @serial_number = @serial_number.strip if @serial_number
       @serial_number
     end
 

data/lib/libusb/endpoint.rb

@@ -181,13 +181,14 @@ module LIBUSB
       # @return [SsCompanion]
       def ss_companion
         ep_comp = FFI::MemoryPointer.new :pointer
+        ctx = device.context.instance_variable_get(:@ctx)
         res = Call.libusb_get_ss_endpoint_companion_descriptor(
-          device.context.instance_variable_get(:@ctx),
+          ctx,
           pointer,
           ep_comp
         )
         LIBUSB.raise_error res, "in libusb_get_ss_endpoint_companion_descriptor" if res!=0
-        SsCompanion.new ep_comp.read_pointer
+        SsCompanion.new ctx, ep_comp.read_pointer
       end
     end
   end

data/lib/libusb/eventmachine.rb

@@ -62,6 +62,10 @@ class Context
     @eventmachine_attached_fds.each do |fd, watcher|
       watcher.detach
     end
+
+    # Deregister callbacks
+    on_pollfd_added
+    on_pollfd_removed
   end
 
   class EMPollfdHandler < EventMachine::Connection
@@ -118,7 +122,7 @@ class DevHandle
     include EM::Deferrable
 
     def initialize(opts, dev_handle, transfer_method)
-      dev_handle.send(transfer_method, opts) do |res|
+      dev_handle.send(transfer_method, **opts) do |res|
         EM.next_tick do
           if res.kind_of?(LIBUSB::Error)
             fail res
@@ -134,7 +138,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#interrupt_transfer
-  def eventmachine_interrupt_transfer(opts={})
+  def eventmachine_interrupt_transfer(**opts)
     eventmachine_transfer(opts, :interrupt_transfer)
   end
 
@@ -151,7 +155,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#bulk_transfer
-  def eventmachine_bulk_transfer(opts={})
+  def eventmachine_bulk_transfer(**opts)
     eventmachine_transfer(opts, :bulk_transfer)
   end
 
@@ -171,7 +175,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#control_transfer
-  def eventmachine_control_transfer(opts={})
+  def eventmachine_control_transfer(**opts)
     eventmachine_transfer(opts, :control_transfer)
   end
 

data/lib/libusb/gem_helper.rb

@@ -87,9 +87,9 @@ module LIBUSB
 
       self.ruby_platform = ruby_platform
       self.recipe = LIBUSB::LibusbRecipe.new
-      recipe.host = host_platform
-      recipe.configure_options << "--host=#{recipe.host}"
-      recipe.configure_options << "CC=#{recipe.host}-gcc -static-libgcc" if recipe.host =~ /mingw/
+      recipe.host = ruby_platform
+      recipe.configure_options << "--host=#{host_platform}"
+      recipe.configure_options << "CC=#{host_platform}-gcc -static-libgcc" if recipe.host =~ /mingw/
       self.libusb_dll = Pathname.new(recipe.path) + libusb_dllname
 
       file libusb_dll do
@@ -98,8 +98,11 @@ module LIBUSB
 
       task "libusb_dll:#{ruby_platform}" => libusb_dll
 
-      desc 'Cross compile libusb for win32'
-      task :cross => [ "libusb_dll:#{ruby_platform}" ] do |t|
+      desc 'Cross compile libusb for all targets'
+      task :cross => "cross:#{ruby_platform}"
+
+      desc "Cross compile libusb for #{ruby_platform}"
+      task "cross:#{ruby_platform}" => [ "libusb_dll:#{ruby_platform}" ] do |t|
         spec = Gem::Specification::load("libusb.gemspec").dup
         spec.platform = Gem::Platform.new(ruby_platform)
         spec.extensions = []

data/lib/libusb/libusb_recipe.rb

@@ -11,7 +11,8 @@ module LIBUSB
     def initialize
       super("libusb", LIBUSB_VERSION)
       self.target = File.join(ROOT, "ports")
-      self.files = [url: LIBUSB_SOURCE_URI, sha1: LIBUSB_SOURCE_SHA1]
+      self.files = [url: LIBUSB_SOURCE_URI, sha256: LIBUSB_SOURCE_SHA256]
+      self.patch_files = Dir[File.join(ROOT, "patches", self.name, self.version, "*.patch")].sort
       self.configure_options = []
     end
 
@@ -24,7 +25,5 @@ module LIBUSB
       self.activate
       self
     end
-
-    public :files_hashs
   end
 end