usb-ruby 0.1.0

data/lib/usb/ss_device_capability.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module USB
+  class SSDeviceCapability
+    def self.finalizer(ptr)
+      proc do
+        FFIBindings.libusb_free_ss_usb_device_capability_descriptor(ptr) unless ptr.nil? || ptr.null?
+      rescue StandardError
+      end
+    end
+
+    def initialize(ptr)
+      raise ArgumentError, "SS device capability pointer is required" if ptr.nil? || ptr.null?
+
+      @ptr = ptr
+      @struct = FFIBindings::SSDeviceCapabilityStruct.new(@ptr)
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@ptr))
+    end
+
+    def attributes
+      @struct[:bmAttributes]
+    end
+
+    def speed_supported
+      @struct[:wSpeedSupported]
+    end
+
+    def functionality_support
+      @struct[:bFunctionalitySupport]
+    end
+
+    def u1_dev_exit_lat
+      @struct[:bU1DevExitLat]
+    end
+
+    def u2_dev_exit_lat
+      @struct[:bU2DevExitLat]
+    end
+
+    def close
+      return if @ptr.nil? || @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      FFIBindings.libusb_free_ss_usb_device_capability_descriptor(@ptr)
+      @ptr = FFI::Pointer::NULL
+      @struct = nil
+    end
+
+    alias free close
+
+    def to_ptr
+      @ptr
+    end
+
+    def inspect
+      "#<USB::SSDeviceCapability speed_supported=0x#{speed_supported.to_s(16)}>"
+    end
+  end
+end

data/lib/usb/ss_endpoint_companion.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module USB
+  class SSEndpointCompanion
+    def self.finalizer(ptr)
+      proc do
+        FFIBindings.libusb_free_ss_endpoint_companion_descriptor(ptr) unless ptr.nil? || ptr.null?
+      rescue StandardError
+      end
+    end
+
+    def initialize(ptr)
+      raise ArgumentError, "SS endpoint companion pointer is required" if ptr.nil? || ptr.null?
+
+      @ptr = ptr
+      @struct = FFIBindings::SSEndpointCompanionStruct.new(@ptr)
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@ptr))
+    end
+
+    def max_burst
+      @struct[:bMaxBurst]
+    end
+
+    def attributes
+      @struct[:bmAttributes]
+    end
+
+    def bytes_per_interval
+      @struct[:wBytesPerInterval]
+    end
+
+    def close
+      return if @ptr.nil? || @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      FFIBindings.libusb_free_ss_endpoint_companion_descriptor(@ptr)
+      @ptr = FFI::Pointer::NULL
+      @struct = nil
+    end
+
+    alias free close
+
+    def to_ptr
+      @ptr
+    end
+
+    def inspect
+      "#<USB::SSEndpointCompanion max_burst=#{max_burst} bytes_per_interval=#{bytes_per_interval}>"
+    end
+  end
+end

data/lib/usb/transfer.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module USB
+  class Transfer
+    CALLBACK = FFI::Function.new(:void, [:pointer]) do |transfer_ptr|
+      transfer = from_pointer(transfer_ptr)
+      transfer&.send(:invoke_callback)
+    end
+
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def from_pointer(ptr)
+        registry[ptr.address]
+      end
+
+      def control(handle:, bm_request_type:, b_request:, w_value:, w_index:, data_or_length:, timeout: 1000)
+        data =
+          if data_or_length.is_a?(Integer)
+            "\x00".b * data_or_length
+          else
+            data_or_length.to_s.b
+          end
+
+        setup = [bm_request_type, b_request, w_value, w_index, data.bytesize].pack("CCvvv")
+        transfer = new
+        transfer.dev_handle = handle
+        transfer.type = TRANSFER_TYPE_CONTROL
+        transfer.timeout = timeout
+        transfer.buffer = setup + data
+        transfer
+      end
+
+      def bulk(handle:, endpoint:, data:, timeout: 1000)
+        transfer = new
+        transfer.dev_handle = handle
+        transfer.endpoint = endpoint
+        transfer.type = TRANSFER_TYPE_BULK
+        transfer.timeout = timeout
+        transfer.buffer = data
+        transfer
+      end
+
+      def interrupt(handle:, endpoint:, data:, timeout: 1000)
+        transfer = new
+        transfer.dev_handle = handle
+        transfer.endpoint = endpoint
+        transfer.type = TRANSFER_TYPE_INTERRUPT
+        transfer.timeout = timeout
+        transfer.buffer = data
+        transfer
+      end
+
+      def isochronous(handle:, endpoint:, data:, num_iso_packets:, timeout: 1000)
+        transfer = new(num_iso_packets: num_iso_packets)
+        transfer.dev_handle = handle
+        transfer.endpoint = endpoint
+        transfer.type = TRANSFER_TYPE_ISOCHRONOUS
+        transfer.timeout = timeout
+        transfer.buffer = data
+        transfer
+      end
+
+      def finalizer(ptr)
+        proc do
+          FFIBindings.libusb_free_transfer(ptr) unless ptr.nil? || ptr.null?
+        rescue StandardError
+        end
+      end
+    end
+
+    def initialize(num_iso_packets: 0)
+      FFIBindings.ensure_loaded!
+      @ptr = FFIBindings.libusb_alloc_transfer(num_iso_packets)
+      raise Error, "libusb_alloc_transfer returned null" if @ptr.null?
+
+      @struct = FFIBindings::TransferStruct.new(@ptr)
+      @struct[:callback] = CALLBACK
+      @struct[:user_data] = FFI::Pointer::NULL
+      @callback = nil
+      @buffer = nil
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@ptr))
+    end
+
+    def free
+      return if @ptr.nil? || @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      self.class.registry.delete(@ptr.address)
+      FFIBindings.libusb_free_transfer(@ptr)
+      @ptr = FFI::Pointer::NULL
+      @struct = nil
+      @buffer = nil
+    end
+
+    def dev_handle=(handle)
+      @struct[:dev_handle] = handle.is_a?(DeviceHandle) ? handle.to_ptr : handle
+    end
+
+    def endpoint=(endpoint)
+      @struct[:endpoint] = endpoint
+    end
+
+    def type=(transfer_type)
+      @struct[:type] = transfer_type
+    end
+
+    def timeout=(milliseconds)
+      @struct[:timeout] = milliseconds
+    end
+
+    def buffer=(data)
+      bytes = data.to_s.b
+      @buffer = FFI::MemoryPointer.new(:uint8, [bytes.bytesize, 1].max)
+      @buffer.put_bytes(0, bytes) unless bytes.empty?
+      @struct[:buffer] = @buffer
+      @struct[:length] = bytes.bytesize
+    end
+
+    def flags
+      @struct[:flags]
+    end
+
+    def flags=(value)
+      @struct[:flags] = value
+    end
+
+    def status
+      @struct[:status]
+    end
+
+    def actual_length
+      @struct[:actual_length]
+    end
+
+    def submit
+      free_transfer = (flags & TRANSFER_FREE_TRANSFER) != 0
+      self.class.registry[@ptr.address] = self
+      Error.raise_on_error(FFIBindings.libusb_submit_transfer(@ptr))
+      ObjectSpace.undefine_finalizer(self) if free_transfer
+      self
+    rescue StandardError
+      self.class.registry.delete(@ptr.address)
+      raise
+    end
+
+    def cancel
+      Error.raise_on_error(FFIBindings.libusb_cancel_transfer(@ptr))
+      self
+    end
+
+    def on_complete(&block)
+      @callback = block
+      self
+    end
+
+    def callback
+      @callback
+    end
+
+    def iso_packet(index)
+      raise IndexError, "iso packet index out of bounds" if index.negative? || index >= num_iso_packets
+
+      IsoPacket.new(self, FFIBindings::IsoPacketDescriptorStruct.new(iso_packet_pointer(index)))
+    end
+
+    def set_iso_packet_lengths(length)
+      num_iso_packets.times do |index|
+        iso_packet(index).length = length
+      end
+      self
+    end
+
+    def num_iso_packets
+      @struct[:num_iso_packets]
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def invoke_callback
+      free_transfer = !@struct.nil? && (flags & TRANSFER_FREE_TRANSFER) != 0
+      self.class.registry.delete(@ptr.address)
+      @callback&.call(self)
+      return unless free_transfer
+
+      @ptr = FFI::Pointer::NULL
+      @struct = nil
+      @buffer = nil
+    end
+
+    def iso_packet_pointer(index)
+      @ptr + FFIBindings::TransferStruct.size + (index * FFIBindings::IsoPacketDescriptorStruct.size)
+    end
+  end
+end

data/lib/usb/usb20_extension.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module USB
+  class USB20Extension
+    def self.finalizer(ptr)
+      proc do
+        FFIBindings.libusb_free_usb_2_0_extension_descriptor(ptr) unless ptr.nil? || ptr.null?
+      rescue StandardError
+      end
+    end
+
+    def initialize(ptr)
+      raise ArgumentError, "USB 2.0 extension pointer is required" if ptr.nil? || ptr.null?
+
+      @ptr = ptr
+      @struct = FFIBindings::USB20ExtensionStruct.new(@ptr)
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@ptr))
+    end
+
+    def attributes
+      @struct[:bmAttributes]
+    end
+
+    def supports_lpm?
+      (attributes & 0x02) != 0
+    end
+
+    def close
+      return if @ptr.nil? || @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      FFIBindings.libusb_free_usb_2_0_extension_descriptor(@ptr)
+      @ptr = FFI::Pointer::NULL
+      @struct = nil
+    end
+
+    alias free close
+
+    def to_ptr
+      @ptr
+    end
+
+    def inspect
+      "#<USB::USB20Extension attributes=0x#{attributes.to_s(16)}>"
+    end
+  end
+end

data/lib/usb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module USB
+  VERSION = "0.1.0"
+end

data/lib/usb.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+require_relative "usb/version"
+require_relative "usb/constants"
+require_relative "usb/error"
+require_relative "usb/ffi_bindings"
+require_relative "usb/context"
+require_relative "usb/device"
+require_relative "usb/device_handle"
+require_relative "usb/device_descriptor"
+require_relative "usb/config_descriptor"
+require_relative "usb/interface"
+require_relative "usb/interface_descriptor"
+require_relative "usb/endpoint_descriptor"
+require_relative "usb/ss_endpoint_companion"
+require_relative "usb/bos_descriptor"
+require_relative "usb/bos_dev_capability"
+require_relative "usb/usb20_extension"
+require_relative "usb/ss_device_capability"
+require_relative "usb/container_id"
+require_relative "usb/transfer"
+require_relative "usb/iso_packet"
+require_relative "usb/hotplug"
+require_relative "usb/event_handling"
+require_relative "usb/pollfds"
+
+module USB
+  class << self
+    def version
+      FFIBindings.ensure_loaded!
+      ptr = FFIBindings.libusb_get_version
+      return nil if ptr.null?
+
+      version = FFIBindings::VersionStruct.new(ptr)
+      "#{version[:major]}.#{version[:minor]}.#{version[:micro]}"
+    end
+
+    def has_capability?(capability)
+      FFIBindings.ensure_loaded!
+      FFIBindings.libusb_has_capability(capability) != 0
+    end
+
+    def devices(**filters)
+      Context.open { |context| context.devices(**filters) }
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: usb-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: usb-ruby provides idiomatic Ruby access to libusb 1.0 via FFI without
+  native extensions.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/usb.rb
+- lib/usb/bos_descriptor.rb
+- lib/usb/bos_dev_capability.rb
+- lib/usb/config_descriptor.rb
+- lib/usb/constants.rb
+- lib/usb/container_id.rb
+- lib/usb/context.rb
+- lib/usb/device.rb
+- lib/usb/device_descriptor.rb
+- lib/usb/device_handle.rb
+- lib/usb/endpoint_descriptor.rb
+- lib/usb/error.rb
+- lib/usb/event_handling.rb
+- lib/usb/ffi_bindings.rb
+- lib/usb/hotplug.rb
+- lib/usb/interface.rb
+- lib/usb/interface_descriptor.rb
+- lib/usb/iso_packet.rb
+- lib/usb/pollfds.rb
+- lib/usb/ss_device_capability.rb
+- lib/usb/ss_endpoint_companion.rb
+- lib/usb/transfer.rb
+- lib/usb/usb20_extension.rb
+- lib/usb/version.rb
+homepage: https://github.com/ydah/usb-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/usb-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby FFI bindings for libusb 1.0
+test_files: []