libusb 0.1.0-x86-mingw32

data/test/test_libusb_compat.rb

@@ -0,0 +1,78 @@
+# 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 "test/unit"
+require "libusb/compat"
+
+class TestLibusbCompat < Test::Unit::TestCase
+  include USB
+
+  attr_accessor :usb
+
+  def test_find
+    devlist = USB.devices
+    assert_kind_of Array, devlist, "Bus#find should return an Array"
+    assert_kind_of Device, devlist.first, "Bus#find should return Devices"
+    devlist.each do |dev|
+      assert_match( /Device/, dev.inspect, "Device#inspect should work")
+    end
+  end
+
+  def test_constants
+    assert_equal 7, USB_CLASS_PRINTER, "Printer class id should be defined"
+    assert_equal 32, USB_TYPE_CLASS, "type class should be defined"
+  end
+
+  def test_descriptors
+    USB.devices.each do |dev|
+      assert_match(/Device/, dev.inspect, "Device#inspect should work")
+      dev.configurations.each do |config_desc|
+        assert_match(/Configuration/, config_desc.inspect, "Configuration#inspect should work")
+        assert dev.configurations.include?(config_desc), "Device#configurations should include this one"
+
+        config_desc.interfaces.each do |interface|
+          assert_match(/Interface/, interface.inspect, "Interface#inspect should work")
+
+          assert dev.interfaces.include?(interface), "Device#interfaces should include this one"
+          assert config_desc.interfaces.include?(interface), "Configuration#interfaces should include this one"
+
+          interface.settings.each do |if_desc|
+            assert_match(/Setting/, if_desc.inspect, "Setting#inspect should work")
+
+            assert dev.settings.include?(if_desc), "Device#settings should include this one"
+            assert config_desc.settings.include?(if_desc), "Configuration#settings should include this one"
+            assert interface.settings.include?(if_desc), "Interface#settings should include this one"
+
+            if_desc.endpoints.each do |ep|
+              assert_match(/Endpoint/, ep.inspect, "Endpoint#inspect should work")
+
+              assert dev.endpoints.include?(ep), "Device#endpoints should include this one"
+              assert config_desc.endpoints.include?(ep), "Configuration#endpoints should include this one"
+              assert interface.endpoints.include?(ep), "Interface#endpoints should include this one"
+              assert if_desc.endpoints.include?(ep), "Setting#endpoints should include this one"
+
+              assert_equal if_desc, ep.setting, "backref should be correct"
+              assert_equal interface, ep.interface, "backref should be correct"
+              assert_equal config_desc, ep.configuration, "backref should be correct"
+              assert_equal dev, ep.device, "backref should be correct"
+
+              assert_operator 0, :<, ep.wMaxPacketSize, "packet size should be > 0"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_libusb_compat_mass_storage.rb

@@ -0,0 +1,81 @@
+# 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 "test/unit"
+require "libusb/compat"
+
+class TestLibusbCompat < Test::Unit::TestCase
+  include USB
+
+  attr_accessor :devh
+
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  def setup
+    devs = []
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x01, 0x50){|dev| devs << dev }
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x06, 0x50){|dev| devs << dev }
+
+    dev = devs.last
+    abort "no mass storage device found" unless dev
+    devh = dev.open
+    if RUBY_PLATFORM=~/linux/i
+      data = " "*1000
+      begin
+        devh.usb_get_driver_np 0, data
+      rescue Errno::ENODATA
+        data = "nodata exception".ljust(1000, "\0")
+      end
+      assert_match(/\w+/, data, "There should be a driver or an exception")
+      begin
+        # second param is needed because of a bug in ruby-usb
+        devh.usb_detach_kernel_driver_np 0, 123
+      rescue RuntimeError => e
+        assert_match(/ERROR_NOT_FOUND/, e.to_s, "Raise proper exception, if no kernel driver is active")
+      end
+    end
+
+    endpoint_in = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN != 0 }
+    endpoint_out = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN == 0 }
+
+    devh.set_configuration 1
+    devh.set_configuration dev.configurations.first
+    devh.claim_interface dev.settings.first
+    devh.clear_halt(endpoint_in)
+    devh.clear_halt(endpoint_out.bEndpointAddress)
+    @devh = devh
+  end
+
+  def teardown
+    if devh
+      devh.release_interface 0
+      devh.usb_close
+    end
+  end
+
+  def test_mass_storage_reset
+    res = devh.usb_control_msg(USB_ENDPOINT_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_RESET, 0, 0, "", 2000)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def test_read_max_lun
+    bytes = [].pack('x1')
+    devh.usb_control_msg(USB_ENDPOINT_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_GET_MAX_LUN, 0, 0, bytes, 100)
+    assert [0].pack("C")==bytes || [1].pack("C")==bytes, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  end
+end

data/test/test_libusb_descriptors.rb

@@ -0,0 +1,122 @@
+# 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 "test/unit"
+require "libusb"
+
+class TestLibusbDescriptors < Test::Unit::TestCase
+  include LIBUSB
+
+  attr_accessor :usb
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 0
+  end
+
+  def test_descriptors
+    usb.devices.each do |dev|
+      assert_match(/Device/, dev.inspect, "Device#inspect should work")
+      dev.configurations.each do |config_desc|
+        assert_match(/Configuration/, config_desc.inspect, "ConfigDescriptor#inspect should work")
+        assert dev.configurations.include?(config_desc), "Device#configurations should include this one"
+
+        config_desc.interfaces.each do |interface|
+          assert_match(/Interface/, interface.inspect, "Interface#inspect should work")
+
+          assert dev.interfaces.include?(interface), "Device#interfaces should include this one"
+          assert config_desc.interfaces.include?(interface), "ConfigDescriptor#interfaces should include this one"
+
+          interface.alt_settings.each do |if_desc|
+            assert_match(/Setting/, if_desc.inspect, "InterfaceDescriptor#inspect should work")
+
+            assert dev.settings.include?(if_desc), "Device#settings should include this one"
+            assert config_desc.settings.include?(if_desc), "ConfigDescriptor#settings should include this one"
+            assert interface.alt_settings.include?(if_desc), "Inteerface#alt_settings should include this one"
+
+            if_desc.endpoints.each do |ep|
+              assert_match(/Endpoint/, ep.inspect, "EndpointDescriptor#inspect should work")
+
+              assert dev.endpoints.include?(ep), "Device#endpoints should include this one"
+              assert config_desc.endpoints.include?(ep), "ConfigDescriptor#endpoints should include this one"
+              assert interface.endpoints.include?(ep), "Inteerface#endpoints should include this one"
+              assert if_desc.endpoints.include?(ep), "InterfaceDescriptor#endpoints should include this one"
+
+              assert_equal if_desc, ep.setting, "backref should be correct"
+              assert_equal interface, ep.interface, "backref should be correct"
+              assert_equal config_desc, ep.configuration, "backref should be correct"
+              assert_equal dev, ep.device, "backref should be correct"
+
+              assert_operator 0, :<, ep.wMaxPacketSize, "packet size should be > 0"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_constants
+    assert_equal 7, CLASS_PRINTER, "Printer class id should be defined"
+    assert_equal 48, ISO_USAGE_TYPE_MASK, "iso usage type should be defined"
+  end
+
+  def test_device_filter_mass_storages
+    devs1 = []
+    usb.devices.each do |dev|
+      dev.settings.each do |if_desc|
+        if if_desc.bInterfaceClass == CLASS_MASS_STORAGE &&
+              ( if_desc.bInterfaceSubClass == 0x01 ||
+                if_desc.bInterfaceSubClass == 0x06 ) &&
+              if_desc.bInterfaceProtocol == 0x50
+
+          devs1 << dev
+        end
+      end
+    end
+
+    devs2 =  usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>0x01, :bProtocol=>0x50 )
+    devs2 += usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>0x06, :bProtocol=>0x50 )
+    assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
+
+    devs3 =  usb.devices( :bClass=>[CLASS_MASS_STORAGE], :bSubClass=>[0x01,0x06], :bProtocol=>[0x50] )
+    assert_equal devs1.sort, devs3.sort, "devices and devices with array-filter should deliver the same device"
+  end
+
+  def test_device_filter_hubs
+    devs1 = []
+    usb.devices.each do |dev|
+      dev.settings.each do |if_desc|
+        if if_desc.bInterfaceClass == CLASS_HUB
+          devs1 << dev
+        end
+      end
+    end
+
+    devs2 = usb.devices( :bClass=>CLASS_HUB )
+    assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
+  end
+
+  def test_device_methods
+    usb.devices.each do |dev|
+      ep = dev.endpoints.first
+      if ep
+        assert_operator dev.max_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable packet size"
+        assert_operator dev.max_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable packet size"
+        assert_operator dev.max_iso_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable iso packet size"
+        assert_operator dev.max_iso_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable iso packet size"
+      end
+    end
+  end
+end

data/test/test_libusb_gc.rb

@@ -0,0 +1,37 @@
+# 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/>.
+#
+# These tests should be started with valgrind to check for
+# invalid memmory access.
+
+require "test/unit"
+require "libusb"
+
+class TestLibusbGc < Test::Unit::TestCase
+  include LIBUSB
+
+  def get_some_endpoint
+    Context.new.devices.each do |dev|
+      return dev.endpoints.last unless dev.endpoints.empty?
+    end
+  end
+
+  def test_descriptors
+    ep = get_some_endpoint
+    ps = ep.wMaxPacketSize
+    GC.start
+    assert_equal ps, ep.wMaxPacketSize, "GC should not free EndpointDescriptor"
+  end
+end

data/test/test_libusb_iso_transfer.rb

@@ -0,0 +1,45 @@
+# 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 "test/unit"
+require "libusb"
+
+class TestLibusbIsoTransfer < Test::Unit::TestCase
+  include LIBUSB
+
+  def setup
+    c = Context.new
+    @dev = c.devices.first.open
+  end
+
+  def teardown
+    @dev.close if @dev
+  end
+
+  def test_iso_transfer
+    tr = IsochronousTransfer.new 10, :dev_handle=>@dev
+    assert_equal 10, tr.num_packets, "number of packets should match"
+
+    tr.buffer = " "*130
+    tr.packet_lengths = 13
+    tr[7].length = 12
+    assert_equal 12, tr[7].length, "packet length should be set"
+    assert_equal 13, tr[8].length, "packet length should be set"
+
+    assert_raise(LIBUSB::ERROR_IO, "the randomly choosen device will probably not handle iso transfer") do
+      tr.submit!
+    end
+  end
+end

data/test/test_libusb_mass_storage.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/>.
+#
+# This test requires a connected, but not mounted mass storage device with
+# read/write access allowed. Based on the following specifications:
+#   http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf
+#   http://en.wikipedia.org/wiki/SCSI_command
+#
+
+require "test/unit"
+require "libusb"
+
+class TestLibusbMassStorage < Test::Unit::TestCase
+  include LIBUSB
+
+  class CSWError < RuntimeError; end
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  attr_accessor :usb
+  attr_accessor :device
+  attr_accessor :dev
+  attr_accessor :endpoint_in
+  attr_accessor :endpoint_out
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 3
+    @asynchron = false
+
+    @device = usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>[0x06,0x01], :bProtocol=>0x50 ).last
+    abort "no mass storage device found" unless @device
+
+    @endpoint_in = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN != 0 }
+    @endpoint_out = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN == 0 }
+    @dev = @device.open
+
+    if RUBY_PLATFORM=~/linux/i && dev.kernel_driver_active?(0)
+      dev.detach_kernel_driver(0)
+    end
+    dev.claim_interface(0)
+
+    # clear any pending data
+    dev.clear_halt(endpoint_in)
+  end
+
+  def teardown
+    dev.release_interface(0) if dev
+    dev.close if dev
+  end
+
+  def do_transfer(method, args)
+    if @asynchron
+      stop = false
+      transfer = dev.send(method, args) do |tr|
+        stop = true
+        assert_equal transfer, tr, "block argument should be the transfer instance"
+#         p transfer.status
+      end
+
+      transfer.submit
+      usb.handle_events
+      until stop
+        sleep 0.001
+        usb.handle_events
+      end
+      transfer.result
+    else
+      dev.send(method, args)
+    end
+  end
+  def control_transfer(args)
+    do_transfer(:control_transfer, args)
+  end
+  def bulk_transfer(args)
+    do_transfer(:bulk_transfer, args)
+  end
+
+  def send_mass_storage_command(cdb, data_length, direction=ENDPOINT_IN)
+    @tag ||= 0
+    @tag += 1
+    expected_tag = @tag
+    lun = 0
+
+    cbw = ['USBC', expected_tag, data_length, direction, lun, cdb.length, cdb].pack('a*VVCCCa*')
+    cbw = cbw.ljust(31, "\0")
+
+    num_bytes = bulk_transfer(:endpoint=>endpoint_out, :dataOut=>cbw)
+    assert_equal 31, num_bytes, "31 bytes CBW should be sent"
+
+    recv = bulk_transfer(:endpoint=>endpoint_in, :dataIn=>data_length)
+
+    get_mass_storage_status(expected_tag)
+    return recv
+  end
+
+  def get_mass_storage_status(expected_tag)
+    retries = 5
+    buffer = begin
+      bulk_transfer(:endpoint=>endpoint_in, :dataIn=>13)
+    rescue LIBUSB::ERROR_PIPE => err
+      if (retries-=1)>=0
+        dev.clear_halt(endpoint_in)
+        retry
+      end
+      raise
+    end
+    assert_equal 13, buffer.bytesize, "CSW should be 13 bytes long"
+
+    dCSWSignature, dCSWTag, dCSWDataResidue, bCSWStatus = buffer.unpack('a4VVC')
+
+    assert_equal 'USBS', dCSWSignature, "CSW should start with USBS"
+    assert_equal expected_tag, dCSWTag, "CSW-tag should be like CBW-tag"
+    raise CSWError, "CSW returned error #{bCSWStatus}" unless bCSWStatus==0
+    buffer
+  end
+
+  def send_inquiry
+    expected_length = 0x24 # INQUIRY_LENGTH
+    cdb = [ 0x12, 0, 0, # Inquiry
+            expected_length, 0,
+            ].pack('CCCnC')
+
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def get_capacity
+    expected_length = 0x08 # READ_CAPACITY_LENGTH
+    cdb = [ 0x25, # Read Capacity
+            ].pack('Cx9')
+
+    cap = send_mass_storage_command( cdb, expected_length )
+
+    max_lba, block_size = cap.unpack('NN')
+    device_size = (max_lba + 1) * block_size / (1024*1024*1024.0);
+    printf("   Max LBA: %08X, Block Size: %08X (%.2f GB)\n", max_lba, block_size, device_size);
+  end
+
+  def read_block(start, nr_blocks)
+    expected_length = 0x200 * nr_blocks
+    cdb = [ 0x28, 0, # Read(10)
+            start, 0,
+            nr_blocks, 0,
+            ].pack('CCNCnC')
+    data = send_mass_storage_command( cdb, expected_length )
+  end
+
+  def invalid_command
+    expected_length = 0x100
+    cdb = [ 0x26, 0, # invalid command
+            ].pack('CC')
+    data = send_mass_storage_command( cdb, expected_length )
+  end
+
+  def mass_storage_reset
+    res = control_transfer(
+      :bmRequestType=>ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      :bRequest=>BOMS_RESET,
+      :wValue=>0, :wIndex=>0)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+
+    res = control_transfer(
+      :bmRequestType=>ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      :bRequest=>BOMS_RESET,
+      :wValue=>0, :wIndex=>0, :dataOut=>'')
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def read_max_lun
+    res = control_transfer(
+      :bmRequestType=>ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      :bRequest=>BOMS_GET_MAX_LUN,
+      :wValue=>0, :wIndex=>0, :dataIn=>1)
+    assert [0].pack("C")==res || [1].pack("C")==res, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  end
+
+  def test_read_access
+    send_inquiry
+    get_capacity
+
+    data = read_block(0, 1)
+    assert_equal 512, data.length, "Read block should be 512 bytes"
+
+    # closing device handle shouldn't matter, in the meantime
+    dev.close
+    @dev = @device.open
+    dev.claim_interface(0)
+
+    data = read_block(0, 2)
+    assert_equal 1024, data.length, "Read block should be 1024 bytes"
+  end
+#   def test_read_access_async
+#     @asynchron = true
+#     test_read_access
+#   end
+
+  def test_read_failed
+    count = 0
+    th = Thread.new do
+      loop do
+        count+=1
+        sleep 0.01
+      end
+    end
+    assert_raise(CSWError, LIBUSB::ERROR_TIMEOUT) do
+      invalid_command
+    end
+    th.kill
+    dev.clear_halt(endpoint_in)
+    dev.clear_halt(endpoint_out)
+    assert_operator 20, :<=, count, "libusb_handle_events should not block a parallel Thread"
+  end
+#   def test_read_failed_async
+#     @asynchron = true
+#     test_read_failed
+#   end
+
+  def test_max_lun
+    read_max_lun
+  end
+#   def test_max_lun_async
+#     @asynchron = true
+#     read_max_lun
+#   end
+
+  def test_mass_storage_reset
+    mass_storage_reset
+  end
+#   def test_mass_storage_reset_async
+#     @asynchron = true
+#     mass_storage_reset
+#   end
+
+  def test_read_long
+    1000.times do |bl|
+      data = read_block(bl, 1)
+      assert_equal 512, data.length, "Read block should be 512 bytes"
+    end
+  end
+
+  def test_attach_kernel_driver
+    dev.release_interface(0)
+    if RUBY_PLATFORM=~/linux/i
+      dev.attach_kernel_driver(0)
+      assert dev.kernel_driver_active?(0), "kernel driver should be active again"
+    end
+    dev.close
+    @dev = nil
+  end
+
+  def test_wrong_argument
+    assert_raise(ArgumentError){ dev.bulk_transfer(:endpoint=>endpoint_in, :dataOut=>"data") }
+    assert_raise(ArgumentError){ dev.interrupt_transfer(:endpoint=>endpoint_in, :dataOut=>"data") }
+    assert_raise(ArgumentError){ dev.control_transfer(
+      :bmRequestType=>ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      :bRequest=>BOMS_RESET,
+      :wValue=>0, :wIndex=>0, :dataIn=>123) }
+  end
+end