fp-device: Gracefully handle capture calls on devices with no support

We always assumed a device can verify, but nothing prevents from having
a device that only can identify or capture.

So, given that we've more fine grained checks, let's stop the task if
this is the case.

.gitlab-ci.yml

@@ -61,9 +61,9 @@ test:
     variables:
       - $CI_PIPELINE_SOURCE == "schedule"
   script:
-    - meson --werror -Ddrivers=all -Db_coverage=true -Dsdcp_virt_binary=/usr/local/bin/sdcp_virt_device . _build
+    - meson --werror -Ddrivers=all -Db_coverage=true . _build
     - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --timeout-multiplier 3
+    - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
     - ninja -C _build coverage
     - cat _build/meson-logs/coverage.txt
   artifacts:
@@ -78,9 +78,9 @@ test_valgrind:
     variables:
       - $CI_PIPELINE_SOURCE == "schedule"
   script:
-    - meson -Ddrivers=all -Dsdcp_virt_binary=/usr/local/bin/sdcp_virt_device . _build
+    - meson -Ddrivers=all . _build
     - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --setup=valgrind
+    - meson test -C _build --print-errorlogs --no-stdsplit --setup=valgrind
 
 test_scan_build:
   stage: test
@@ -149,17 +149,5 @@ container_fedora_build:
       - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
   variables:
     GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
-    # a list of packages to install; we only include mbedtls here
-    FDO_DISTRIBUTION_PACKAGES: $LIBFPRINT_DEPENDENCIES mbedtls-devel
-    FDO_DISTRIBUTION_EXEC: |
-      cd /tmp
-      mkdir -p /usr/local/bin
-      git clone https://github.com/benzea/SecureDeviceConnectionProtocol.git
-      # Don't bother with cmake
-      gcc -l mbedcrypto -I SecureDeviceConnectionProtocol/src/include \
-        SecureDeviceConnectionProtocol/src/test/virt_device.c \
-        SecureDeviceConnectionProtocol/src/client/client.c \
-        SecureDeviceConnectionProtocol/src/test/helpers.c \
-        SecureDeviceConnectionProtocol/src/test/testkeys.c \
-        -o /usr/local/bin/sdcp_virt_device
-      rm -rf SecureDeviceConnectionProtocol
+    # a list of packages to install
+    FDO_DISTRIBUTION_PACKAGES: $LIBFPRINT_DEPENDENCIES

data/autosuspend.hwdb

@@ -135,6 +135,10 @@ usb:v27C6p639C*
 usb:v27C6p6594*
  ID_AUTOSUSPEND=1
 
+# Supported by libfprint driver nb1010
+usb:v298Dp1010*
+ ID_AUTOSUSPEND=1
+
 # Supported by libfprint driver synaptics
 usb:v06CBp00BD*
 usb:v06CBp00E9*
@@ -143,7 +147,7 @@ usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
 usb:v06CBp00C9*
-usb:v06CBp00E7*
+usb:v06CBp0100*
  ID_AUTOSUSPEND=1
 
 # Supported by libfprint driver upeksonly
@@ -195,6 +199,10 @@ usb:v138Ap0017*
 usb:v138Ap0018*
  ID_AUTOSUSPEND=1
 
+# Supported by libfprint driver vfs7552
+usb:v138Ap0091*
+ ID_AUTOSUSPEND=1
+
 # Known unsupported devices
 usb:v04F3p036B*
 usb:v04F3p0C00*
@@ -202,6 +210,7 @@ usb:v04F3p0C4B*
 usb:v04F3p0C4C*
 usb:v04F3p0C4F*
 usb:v04F3p0C57*
+usb:v04F3p0C5E*
 usb:v04F3p2706*
 usb:v06CBp0081*
 usb:v06CBp0088*
@@ -212,13 +221,18 @@ usb:v06CBp00A2*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
+usb:v06CBp00C4*
 usb:v06CBp00CB*
 usb:v06CBp00D8*
 usb:v06CBp00DA*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
+usb:v0A5Cp5840*
+usb:v0A5Cp5841*
+usb:v0A5Cp5842*
 usb:v0A5Cp5843*
+usb:v0A5Cp5845*
 usb:v10A5p0007*
 usb:v1188p9545*
 usb:v138Ap0007*
@@ -227,7 +241,6 @@ usb:v138Ap003C*
 usb:v138Ap003D*
 usb:v138Ap003F*
 usb:v138Ap0090*
-usb:v138Ap0091*
 usb:v138Ap0092*
 usb:v138Ap0094*
 usb:v138Ap0097*

data/meson.build

@@ -1,6 +1,8 @@
-if get_option('udev_rules')
+if udev_hwdb_dir != ''
     # This file has to be updated using
     # ninja -C <builddir> libfprint/sync-udev-hwdb
+    # Note that the unsupported device list needs to be manually synced from
+    # the wiki. See comment in libfprint/fprint-list-uev-hwdb.c
 
     install_data('autosuspend.hwdb',
         rename: '60-autosuspend-@0@.hwdb'.format(versioned_libname),

demo/org.freedesktop.libfprint.Demo.json

@@ -50,7 +50,7 @@
         {
             "name": "libfprint",
             "buildsystem": "meson",
-            "config-opts": [ "-Dudev_rules=false", "-Dx11-examples=false", "-Dgtk-examples=true", "-Ddrivers=all" ],
+            "config-opts": [ "-Dudev_hwdb=disabled", "-Dx11-examples=false", "-Dgtk-examples=true", "-Ddrivers=all" ],
             "sources": [
                 {
                     "type": "git",

doc/libfprint-2-sections.txt

@@ -32,9 +32,11 @@ fp_device_get_device_id
 fp_device_get_name
 fp_device_get_scan_type
 fp_device_get_nr_enroll_stages
+fp_device_get_finger_status
 fp_device_has_storage
 fp_device_supports_identify
 fp_device_supports_capture
+fp_device_is_open
 fp_device_open
 fp_device_close
 fp_device_enroll
@@ -85,12 +87,6 @@ FP_TYPE_IMAGE_DEVICE
 FpImageDevice
 </SECTION>
 
-<SECTION>
-<FILE>fp-sdcp-device</FILE>
-FP_TYPE_SDCP_DEVICE
-FpSdcpDevice
-</SECTION>
-
 <SECTION>
 <FILE>fp-print</FILE>
 FP_TYPE_PRINT
@@ -135,8 +131,11 @@ fpi_get_driver_types
 FpDeviceClass
 FpTimeoutFunc
 FpiDeviceAction
+FpiDeviceFeature
 FpIdEntry
+FpiDeviceUdevSubtypeFlags
 fpi_device_get_usb_device
+fpi_device_get_udev_data
 fpi_device_get_virtual_env
 fpi_device_get_current_action
 fpi_device_retry_new
@@ -154,6 +153,9 @@ fpi_device_action_is_cancelled
 fpi_device_add_timeout
 fpi_device_set_nr_enroll_stages
 fpi_device_set_scan_type
+fpi_device_remove
+fpi_device_report_finger_status
+fpi_device_report_finger_status_changes
 fpi_device_action_error
 fpi_device_probe_complete
 fpi_device_open_complete
@@ -166,6 +168,8 @@ fpi_device_delete_complete
 fpi_device_enroll_progress
 fpi_device_verify_report
 fpi_device_identify_report
+fpi_device_list_complete
+fpi_device_class_auto_initialize_features
 </SECTION>
 
 <SECTION>
@@ -190,26 +194,7 @@ fpi_image_device_deactivate_complete
 fpi_image_device_report_finger_status
 fpi_image_device_image_captured
 fpi_image_device_retry_scan
-</SECTION>
-
-<SECTION>
-<FILE>fpi-sdcp-device</FILE>
-<TITLE>Internal FpSdcpDevice</TITLE>
-FpiSdcpClaim
-FpSdcpDeviceClass
-fpi_sdcp_claim_copy
-fpi_sdcp_claim_free
-fpi_sdcp_claim_get_type
-fpi_sdcp_claim_new
-fpi_sdcp_device_connect_complete
-fpi_sdcp_device_get_connect_data
-fpi_sdcp_device_get_reconnect_data
-fpi_sdcp_device_reconnect_complete
-fpi_sdcp_device_enroll_commit_complete
-fpi_sdcp_device_enroll_ready
-fpi_sdcp_device_enroll_set_nonce
-fpi_sdcp_device_identify_retry
-fpi_sdcp_device_identify_complete
+fpi_image_device_set_bz3_threshold
 </SECTION>
 
 <SECTION>
@@ -253,10 +238,10 @@ fpi_ssm_mark_completed
 fpi_ssm_mark_failed
 fpi_ssm_set_data
 fpi_ssm_get_data
+fpi_ssm_get_device
 fpi_ssm_get_error
 fpi_ssm_dup_error
 fpi_ssm_get_cur_state
-fpi_ssm_next_state_timeout_cb
 fpi_ssm_usb_transfer_cb
 FpiSsm
 </SECTION>

doc/libfprint-2.types

@@ -0,0 +1,8 @@
+#include <libfprint-2/fprint.h>
+#include <libfprint-2/fp-image-device.h>
+
+fp_context_get_type
+fp_device_get_type
+fp_image_device_get_type
+fp_image_get_type
+fp_print_get_type

doc/libfprint-docs.xml

@@ -28,7 +28,6 @@
     <xi:include href="xml/fp-context.xml"/>
     <xi:include href="xml/fp-device.xml"/>
     <xi:include href="xml/fp-image-device.xml"/>
-    <xi:include href="xml/fp-sdcp-device.xml"/>
     <xi:include href="xml/fp-print.xml"/>
     <xi:include href="xml/fp-image.xml"/>
   </part>
@@ -39,7 +38,6 @@
       <title>Device methods for drivers</title>
       <xi:include href="xml/fpi-device.xml"/>
       <xi:include href="xml/fpi-image-device.xml"/>
-      <xi:include href="xml/fpi-sdcp-device.xml"/>
     </chapter>
 
     <chapter id="driver-helpers">

doc/meson.build

@@ -30,6 +30,7 @@ gnome.gtkdoc(versioned_libname,
     content_files: content_files,
     expand_content_files: expand_content_files,
     ignore_headers: private_headers,
+    gobject_typesfile: 'libfprint-2.types',
     fixxref_args: [
         '--html-dir=@0@'.format(docpath),
         '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),

libfprint/drivers/goodixmoc/goodix.c

@@ -1579,4 +1579,7 @@ fpi_device_goodixmoc_class_init (FpiDeviceGoodixMocClass *klass)
   dev_class->cancel = gx_fp_cancel;
   dev_class->verify   = gx_fp_verify_identify;
   dev_class->identify = gx_fp_verify_identify;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+  dev_class->features |= FPI_DEVICE_FEATURE_DUPLICATES_CHECK;
 }

libfprint/drivers/nb1010.c

@@ -0,0 +1,445 @@
+/*
+ * Next Biometrics driver for libfprint
+ *
+ * Copyright (C) 2021 Huan Wang <fredwanghuan@gmail.com>
+ * Copyright (C) 2011-2012 Andrej Krutak <dev@andree.sk>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define FP_COMPONENT "nb1010"
+#include "fpi-log.h"
+
+#include "drivers_api.h"
+
+#define FRAME_HEIGHT 180
+#define FRAME_WIDTH 256
+
+#define NB1010_EP_OUT 0x02 | FPI_USB_ENDPOINT_OUT
+#define NB1010_EP_IN 0x03 | FPI_USB_ENDPOINT_IN
+
+#define NB1010_SENSITIVITY_BIT 12
+
+#define NB1010_CMD_RECV_LEN 16
+#define NB1010_CAPTURE_RECV_LEN 540
+#define NB1010_CAPTURE_HEADER_LEN 25
+
+#define NB1010_LINE_PER_PARTIAL 2
+#define NB1010_N_PARTIAL (FRAME_HEIGHT / NB1010_LINE_PER_PARTIAL)
+
+#define NB1010_DEFAULT_TIMEOUT 500
+#define NB1010_TRANSITION_DELAY 50
+
+/* Loop ssm states */
+enum {
+  M_WAIT_PRINT,
+  M_REQUEST_PRINT,
+  M_CHECK_PRINT,
+  M_READ_PRINT_PRESTART,
+  M_READ_PRINT_START,
+  M_READ_PRINT_POLL,
+  M_SUBMIT_PRINT,
+
+  /* Number of states */
+  M_LOOP_NUM_STATES,
+};
+
+/*
+ * The Follow Commands are obtained by decoding the usbcap, so it does not expose all the command available to the device.
+ * Known:
+ * 1. every command starts with 0x80
+ * 2. second byte is the comand, third byte is the seqence nubmer, init with rand, gets incremented
+ *    everytime a new instruction is sent to the device. However device does not care or check the sequence, just echo back
+ *    whatever chosen by the host.
+ * 3. cmd: 0x07 check, expect [0x80, 0x29...] as response
+ * 4. cmd: 0x16 ???, expect [0x80, 0x20...] as response. Happens during device init.
+ * 5. cmd: 0x13 print device, expect [0x80, 0x23...] as response. Response contains the device string
+ * 6. cmd: 0x38 check finger, expect [0x80, 0x37...] as response. The 14th byte indicate whether finger present [0-255]
+ * 7. cmd: 0x0d ???, expect [0x80, 0x20...] as response. Happens before capture.
+ * 8. cmd: 0x12 capture, expect [0x80, 0x20...] as response. After capture read 90 times in sequence to get all the frame.
+ */
+
+static guint8 nb1010_cmd_check_finger[] = {
+  0x80, 0x38, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
+};
+
+/* pre capture, dont know what does it do, but appears everytime a capture begins */
+static guint8 nb1010_cmd_precapture[] = {
+  0x80, 0x0d, 0x03, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+};
+
+static guint8 nb1010_cmd_capture[] = {
+  0x80, 0x12, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+};
+
+struct _FpiDeviceNb1010
+{
+  FpImageDevice parent;
+  FpiSsm       *ssm;
+  guint8       *scanline_buf;
+  gboolean      deactivating;
+  int           partial_received;
+};
+G_DECLARE_FINAL_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FPI, DEVICE_NB1010, FpImageDevice);
+G_DEFINE_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FP_TYPE_IMAGE_DEVICE);
+
+static void
+nb1010_dev_init (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  GError *error = NULL;
+
+  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+
+  self->scanline_buf = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT);
+
+  fpi_image_device_open_complete (dev, error);
+  fp_dbg ("nb1010 Initialized");
+}
+
+static void
+nb1010_dev_deinit (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  GError *error = NULL;
+
+  g_clear_pointer (&self->scanline_buf, g_free);
+
+  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+  fpi_image_device_close_complete (dev, error);
+  fp_dbg ("nb1010 Deinitialized");
+}
+
+static void
+nb1010_dev_activate (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  self->deactivating = FALSE;
+
+  fpi_image_device_activate_complete (dev, NULL);
+  fp_dbg ("nb1010 Activated");
+}
+
+static void
+nb1010_dev_deactivated (FpImageDevice *dev, GError * err)
+{
+  fpi_image_device_deactivate_complete (dev, err);
+  fp_dbg ("nb1010 Deactivated");
+}
+
+static void
+nb1010_dev_deactivate (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  self->deactivating = TRUE;
+  if (self->ssm == NULL)
+    nb1010_dev_deactivated (dev, NULL);
+}
+
+static void
+nb1010_request_fingerprint (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT,
+                                   nb1010_cmd_check_finger, G_N_ELEMENTS (nb1010_cmd_check_finger),
+                                   NULL);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           fpi_ssm_usb_transfer_cb, NULL);
+}
+
+static void
+nb1010_check_fingerprint_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                             gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  if (transfer->buffer[NB1010_SENSITIVITY_BIT] > 0x30)
+    fpi_ssm_next_state (transfer->ssm);
+  else
+    fpi_ssm_jump_to_state (transfer->ssm, M_WAIT_PRINT);
+}
+
+static void
+nb1010_cmd_check_fingerprint (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_check_fingerprint_cb, NULL);
+}
+
+static void
+nb1010_read_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                            gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpiUsbTransfer *new_transfer = NULL;
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  new_transfer = fpi_usb_transfer_new ( dev );
+  new_transfer->short_is_error = TRUE;
+  new_transfer->ssm = transfer->ssm;
+
+  fpi_usb_transfer_fill_bulk (new_transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN);
+  fpi_usb_transfer_submit (new_transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           fpi_ssm_usb_transfer_cb, NULL);
+}
+
+static void
+nb1010_write_ignore_read (FpiDeviceNb1010 *dev, guint8 *buf, gsize len)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, buf, len, NULL);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_ignore_data_cb, NULL);
+}
+
+
+static void
+nb1010_read_capture_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                        gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  g_assert (transfer->actual_length == NB1010_CAPTURE_RECV_LEN);
+
+  size_t offset = self->partial_received * NB1010_LINE_PER_PARTIAL * FRAME_WIDTH;
+
+  memcpy (self->scanline_buf + offset,
+          transfer->buffer + NB1010_CAPTURE_HEADER_LEN, NB1010_LINE_PER_PARTIAL * FRAME_WIDTH);
+
+  self->partial_received++;
+  if (self->partial_received == NB1010_N_PARTIAL)
+    {
+      fpi_ssm_next_state (transfer->ssm);
+      return;
+    }
+
+  fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer), NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_capture_cb, NULL);
+}
+
+static void
+nb1010_read_capture (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new ( FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CAPTURE_RECV_LEN);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_capture_cb, NULL);
+}
+
+static int
+submit_image (FpiSsm        *ssm,
+              FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpImage *img;
+
+  img = fp_image_new (FRAME_WIDTH, FRAME_HEIGHT);
+  if (img == NULL)
+    return 0;
+
+  memcpy (img->data, self->scanline_buf, FRAME_WIDTH * FRAME_HEIGHT);
+  fpi_image_device_image_captured (dev, img);
+
+  return 1;
+}
+
+static void
+m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
+{
+  fp_dbg ("nb1010 ssm complete cb");
+
+  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev);
+
+  self->ssm = NULL;
+
+  if (self->deactivating)
+    nb1010_dev_deactivated (dev, error);
+  else if (error != NULL)
+    fpi_image_device_session_error (dev, error);
+}
+
+static void
+m_loop_state (FpiSsm *ssm, FpDevice *_dev)
+{
+  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev);
+
+  if (self->deactivating)
+    {
+      fp_dbg ("deactivating, marking completed");
+      fpi_ssm_mark_completed (ssm);
+      return;
+    }
+
+  switch (fpi_ssm_get_cur_state (ssm))
+    {
+    case M_WAIT_PRINT:
+      /* Wait fingerprint scanning */
+      fpi_ssm_next_state_delayed (ssm, NB1010_TRANSITION_DELAY, NULL);
+      break;
+
+    case M_REQUEST_PRINT:
+      nb1010_request_fingerprint (self);
+      break;
+
+    case M_CHECK_PRINT:
+      nb1010_cmd_check_fingerprint (self);
+      break;
+
+    case M_READ_PRINT_PRESTART:
+      fpi_image_device_report_finger_status (dev, TRUE);
+      nb1010_write_ignore_read (self, nb1010_cmd_precapture, G_N_ELEMENTS (nb1010_cmd_precapture));
+      break;
+
+    case M_READ_PRINT_START:
+      self->partial_received = 0;
+      nb1010_write_ignore_read (self, nb1010_cmd_capture, G_N_ELEMENTS (nb1010_cmd_capture));
+      break;
+
+    case M_READ_PRINT_POLL:
+      nb1010_read_capture (self);
+      break;
+
+    case M_SUBMIT_PRINT:
+      if (submit_image (ssm, dev))
+        {
+          fpi_ssm_mark_completed (ssm);
+          fpi_image_device_report_finger_status (dev, FALSE);
+        }
+      else
+        {
+          fpi_ssm_jump_to_state (ssm, M_WAIT_PRINT);
+        }
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static void
+nb1010_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpiSsm *ssm_loop;
+
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    {
+      ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES);
+      self->ssm = ssm_loop;
+      fpi_ssm_start (ssm_loop, m_loop_complete);
+    }
+}
+
+
+static const FpIdEntry id_table[] = {
+  { .vid = 0x298d,  .pid = 0x1010, },
+  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+};
+
+static void
+fpi_device_nb1010_init (FpiDeviceNb1010 *self)
+{
+}
+
+static void
+fpi_device_nb1010_class_init (FpiDeviceNb1010Class *klass)
+{
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+
+  dev_class->id = FP_COMPONENT;
+  dev_class->full_name = "NextBiometrics NB-1010-U";
+  dev_class->type = FP_DEVICE_TYPE_USB;
+  dev_class->id_table = id_table;
+  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
+
+  img_class->img_height = FRAME_HEIGHT;
+  img_class->img_width = FRAME_WIDTH;
+
+  img_class->bz3_threshold = 24;
+
+  img_class->img_open = nb1010_dev_init;
+  img_class->img_close = nb1010_dev_deinit;
+  img_class->activate = nb1010_dev_activate;
+  img_class->deactivate = nb1010_dev_deactivate;
+  img_class->change_state = nb1010_dev_change_state;
+}

libfprint/drivers/synaptics/synaptics.c

@@ -31,14 +31,14 @@ static void init_identify_msg (FpDevice *device);
 static void compose_and_send_identify_msg (FpDevice *device);
 
 static const FpIdEntry id_table[] = {
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xBD,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xDF,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xF9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xFC,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC2,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE7,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00BD,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00E9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -1158,7 +1158,8 @@ prob_msg_cb (FpiDeviceSynaptics *self,
                                                  g_usb_device_get_serial_number_index (usb_dev),
                                                  &error);
 
-  if (resp->result == BMKT_SUCCESS)
+  /* BMKT_OPERATION_DENIED is returned if the sensor is already initialized */
+  if (resp->result == BMKT_SUCCESS || resp->result == BMKT_OPERATION_DENIED)
     {
       g_usb_device_close (usb_dev, NULL);
       fpi_device_probe_complete (FP_DEVICE (self), serial, NULL, error);
@@ -1196,9 +1197,6 @@ dev_probe (FpDevice *device)
       return;
     }
 
-  if (!g_usb_device_reset (usb_dev, &error))
-    goto err_close;
-
   if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
     goto err_close;
 
@@ -1342,9 +1340,6 @@ dev_init (FpDevice *device)
 
   self->interrupt_cancellable = g_cancellable_new ();
 
-  if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
-    goto error;
-
   /* Claim usb interface */
   if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error))
     goto error;
@@ -1410,4 +1405,6 @@ fpi_device_synaptics_class_init (FpiDeviceSynapticsClass *klass)
   dev_class->delete = delete_print;
   dev_class->cancel = cancel;
   dev_class->list = list;
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/upeksonly.c

@@ -693,8 +693,6 @@ sm_read_reg_cb (FpiUsbTransfer *transfer, FpDevice *device,
       fp_dbg ("read reg result = %02x", self->read_reg_result);
       fpi_ssm_next_state (transfer->ssm);
     }
-
-  g_free (transfer->buffer);
 }
 
 static void
@@ -731,7 +729,6 @@ sm_await_intr_cb (FpiUsbTransfer *transfer, FpDevice *device,
 
   if (error)
     {
-      g_free (transfer->buffer);
       fpi_ssm_mark_failed (transfer->ssm, error);
       return;
     }
@@ -739,7 +736,6 @@ sm_await_intr_cb (FpiUsbTransfer *transfer, FpDevice *device,
   fp_dbg ("interrupt received: %02x %02x %02x %02x",
           transfer->buffer[0], transfer->buffer[1],
           transfer->buffer[2], transfer->buffer[3]);
-  g_free (transfer->buffer);
 
   self->finger_state = FINGER_DETECTED;
   fpi_image_device_report_finger_status (dev, TRUE);

libfprint/drivers/upekts.c

@@ -1555,4 +1555,6 @@ fpi_device_upekts_class_init (FpiDeviceUpektsClass *klass)
   dev_class->verify = verify;
   dev_class->enroll = enroll;
   /* dev_class->cancel = cancel; */
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/virtual-device-listener.c

@@ -28,35 +28,35 @@
 
 #include "virtual-device-private.h"
 
-struct _FpDeviceVirtualListener
+struct _FpiDeviceVirtualListener
 {
-  GSocketListener                     parent_instance;
+  GSocketListener                      parent_instance;
 
-  GSocketConnection                  *connection;
-  GCancellable                       *cancellable;
-  guint                               cancellable_id;
+  GSocketConnection                   *connection;
+  GCancellable                        *cancellable;
+  guint                                cancellable_id;
 
-  FpDeviceVirtualListenerConnectionCb ready_cb;
-  gpointer                            ready_cb_data;
+  FpiDeviceVirtualListenerConnectionCb ready_cb;
+  gpointer                             ready_cb_data;
 
-  gint                                socket_fd;
-  gint                                client_fd;
+  gint                                 socket_fd;
+  gint                                 client_fd;
 };
 
-G_DEFINE_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, G_TYPE_SOCKET_LISTENER)
+G_DEFINE_TYPE (FpiDeviceVirtualListener, fpi_device_virtual_listener, G_TYPE_SOCKET_LISTENER)
 
-static void start_listen (FpDeviceVirtualListener *self);
+static void start_listen (FpiDeviceVirtualListener *self);
 
-FpDeviceVirtualListener *
-fp_device_virtual_listener_new (void)
+FpiDeviceVirtualListener *
+fpi_device_virtual_listener_new (void)
 {
-  return g_object_new (fp_device_virtual_listener_get_type (), NULL);
+  return g_object_new (fpi_device_virtual_listener_get_type (), NULL);
 }
 
 static void
-fp_device_virtual_listener_dispose (GObject *object)
+fpi_device_virtual_listener_dispose (GObject *object)
 {
-  FpDeviceVirtualListener *self = FP_DEVICE_VIRTUAL_LISTENER (object);
+  FpiDeviceVirtualListener *self = FPI_DEVICE_VIRTUAL_LISTENER (object);
 
   if (self->cancellable_id)
     {
@@ -70,19 +70,19 @@ fp_device_virtual_listener_dispose (GObject *object)
 
   self->ready_cb = NULL;
 
-  G_OBJECT_CLASS (fp_device_virtual_listener_parent_class)->dispose (object);
+  G_OBJECT_CLASS (fpi_device_virtual_listener_parent_class)->dispose (object);
 }
 
 static void
-fp_device_virtual_listener_class_init (FpDeviceVirtualListenerClass *klass)
+fpi_device_virtual_listener_class_init (FpiDeviceVirtualListenerClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->dispose = fp_device_virtual_listener_dispose;
+  object_class->dispose = fpi_device_virtual_listener_dispose;
 }
 
 static void
-fp_device_virtual_listener_init (FpDeviceVirtualListener *self)
+fpi_device_virtual_listener_init (FpiDeviceVirtualListener *self)
 {
 }
 
@@ -90,7 +90,7 @@ static void
 new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *self = user_data;
+  FpiDeviceVirtualListener *self = user_data;
   GSocketConnection *connection;
 
   connection = g_socket_listener_accept_finish (G_SOCKET_LISTENER (source_object),
@@ -123,7 +123,7 @@ new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data
 }
 
 static void
-start_listen (FpDeviceVirtualListener *self)
+start_listen (FpiDeviceVirtualListener *self)
 {
   g_socket_listener_accept_async (G_SOCKET_LISTENER (self),
                                   self->cancellable,
@@ -132,27 +132,27 @@ start_listen (FpDeviceVirtualListener *self)
 }
 
 static void
-on_cancelled (GCancellable            *cancellable,
-              FpDeviceVirtualListener *self)
+on_cancelled (GCancellable             *cancellable,
+              FpiDeviceVirtualListener *self)
 {
-  fp_device_virtual_listener_connection_close (self);
+  fpi_device_virtual_listener_connection_close (self);
   g_socket_listener_close (G_SOCKET_LISTENER (self));
   g_clear_object (&self->cancellable);
   self->ready_cb = NULL;
 }
 
 gboolean
-fp_device_virtual_listener_start (FpDeviceVirtualListener            *self,
-                                  const char                         *address,
-                                  GCancellable                       *cancellable,
-                                  FpDeviceVirtualListenerConnectionCb cb,
-                                  gpointer                            user_data,
-                                  GError                            **error)
+fpi_device_virtual_listener_start (FpiDeviceVirtualListener            *self,
+                                   const char                          *address,
+                                   GCancellable                        *cancellable,
+                                   FpiDeviceVirtualListenerConnectionCb cb,
+                                   gpointer                             user_data,
+                                   GError                             **error)
 {
   g_autoptr(GSocketAddress) addr = NULL;
   G_DEBUG_HERE ();
 
-  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+  g_return_val_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
   g_return_val_if_fail (cb != NULL, FALSE);
   g_return_val_if_fail (self->ready_cb == NULL, FALSE);
 
@@ -191,9 +191,9 @@ fp_device_virtual_listener_start (FpDeviceVirtualListener            *self,
 }
 
 gboolean
-fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *self)
+fpi_device_virtual_listener_connection_close (FpiDeviceVirtualListener *self)
 {
-  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+  g_return_val_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
 
   if (!self->connection)
     return FALSE;
@@ -211,7 +211,7 @@ on_stream_read_cb (GObject      *source_object,
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(GTask) task = user_data;
-  FpDeviceVirtualListener *self = g_task_get_source_object (task);
+  FpiDeviceVirtualListener *self = g_task_get_source_object (task);
   gboolean all;
   gboolean success;
   gsize bytes;
@@ -282,17 +282,17 @@ on_stream_read_cb (GObject      *source_object,
 }
 
 void
-fp_device_virtual_listener_read (FpDeviceVirtualListener *self,
-                                 gboolean                 all,
-                                 void                    *buffer,
-                                 gsize                    count,
-                                 GAsyncReadyCallback      callback,
-                                 gpointer                 user_data)
+fpi_device_virtual_listener_read (FpiDeviceVirtualListener *self,
+                                  gboolean                  all,
+                                  void                     *buffer,
+                                  gsize                     count,
+                                  GAsyncReadyCallback       callback,
+                                  gpointer                  user_data)
 {
   g_autoptr(GTask) task = NULL;
   GInputStream *stream;
 
-  g_return_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self));
+  g_return_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self));
 
   task = g_task_new (self, self->cancellable, callback, user_data);
   g_object_set_data (G_OBJECT (task), "all", GINT_TO_POINTER (all));
@@ -324,9 +324,9 @@ fp_device_virtual_listener_read (FpDeviceVirtualListener *self,
 }
 
 gsize
-fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *self,
-                                        GAsyncResult            *result,
-                                        GError                 **error)
+fpi_device_virtual_listener_read_finish (FpiDeviceVirtualListener *self,
+                                         GAsyncResult             *result,
+                                         GError                  **error)
 {
   g_return_val_if_fail (g_task_is_valid (result, self), 0);
 
@@ -334,10 +334,10 @@ fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *self,
 }
 
 gboolean
-fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
-                                       const char              *buffer,
-                                       gsize                    count,
-                                       GError                 **error)
+fpi_device_virtual_listener_write_sync (FpiDeviceVirtualListener *self,
+                                        const char               *buffer,
+                                        gsize                     count,
+                                        GError                  **error)
 {
   if (!self->connection || g_io_stream_is_closed (G_IO_STREAM (self->connection)))
     {

libfprint/drivers/virtual-device-private.h

@@ -32,59 +32,59 @@
 
 #define MAX_LINE_LEN 1024
 
-G_DECLARE_FINAL_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, FP, DEVICE_VIRTUAL_LISTENER, GSocketListener)
+G_DECLARE_FINAL_TYPE (FpiDeviceVirtualListener, fpi_device_virtual_listener, FPI, DEVICE_VIRTUAL_LISTENER, GSocketListener)
 
-typedef void (*FpDeviceVirtualListenerConnectionCb) (FpDeviceVirtualListener *listener,
-                                                     gpointer                 user_data);
+typedef void (*FpiDeviceVirtualListenerConnectionCb) (FpiDeviceVirtualListener *listener,
+                                                      gpointer                  user_data);
 
-FpDeviceVirtualListener * fp_device_virtual_listener_new (void);
+FpiDeviceVirtualListener * fpi_device_virtual_listener_new (void);
 
-gboolean fp_device_virtual_listener_start (FpDeviceVirtualListener            *listener,
-                                           const char                         *address,
-                                           GCancellable                       *cancellable,
-                                           FpDeviceVirtualListenerConnectionCb cb,
-                                           gpointer                            user_data,
-                                           GError                            **error);
+gboolean fpi_device_virtual_listener_start (FpiDeviceVirtualListener            *listener,
+                                            const char                          *address,
+                                            GCancellable                        *cancellable,
+                                            FpiDeviceVirtualListenerConnectionCb cb,
+                                            gpointer                             user_data,
+                                            GError                             **error);
 
-gboolean fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *listener);
+gboolean fpi_device_virtual_listener_connection_close (FpiDeviceVirtualListener *listener);
 
-void fp_device_virtual_listener_read (FpDeviceVirtualListener *listener,
-                                      gboolean                 all,
-                                      void                    *buffer,
-                                      gsize                    count,
-                                      GAsyncReadyCallback      callback,
-                                      gpointer                 user_data);
-gsize fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *listener,
-                                              GAsyncResult            *result,
-                                              GError                 **error);
+void fpi_device_virtual_listener_read (FpiDeviceVirtualListener *listener,
+                                       gboolean                  all,
+                                       void                     *buffer,
+                                       gsize                     count,
+                                       GAsyncReadyCallback       callback,
+                                       gpointer                  user_data);
+gsize fpi_device_virtual_listener_read_finish (FpiDeviceVirtualListener *listener,
+                                               GAsyncResult             *result,
+                                               GError                  **error);
 
-gboolean fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
-                                                const char              *buffer,
-                                                gsize                    count,
-                                                GError                 **error);
+gboolean fpi_device_virtual_listener_write_sync (FpiDeviceVirtualListener *self,
+                                                 const char               *buffer,
+                                                 gsize                     count,
+                                                 GError                  **error);
 
 
 struct _FpDeviceVirtualDevice
 {
-  FpDevice                 parent;
+  FpDevice                  parent;
 
-  FpDeviceVirtualListener *listener;
-  GCancellable            *cancellable;
+  FpiDeviceVirtualListener *listener;
+  GCancellable             *cancellable;
 
-  char                     recv_buf[MAX_LINE_LEN];
+  char                      recv_buf[MAX_LINE_LEN];
 
-  GPtrArray               *pending_commands;
+  GPtrArray                *pending_commands;
 
-  GHashTable              *prints_storage;
+  GHashTable               *prints_storage;
 
-  guint                    wait_command_id;
-  guint                    sleep_timeout_id;
-  guint                    enroll_stages_passed;
-  gboolean                 match_reported;
-  gboolean                 supports_cancellation;
-  gboolean                 injected_synthetic_cmd;
-  gboolean                 ignore_wait;
-  gboolean                 keep_alive;
+  guint                     wait_command_id;
+  guint                     sleep_timeout_id;
+  guint                     enroll_stages_passed;
+  gboolean                  match_reported;
+  gboolean                  supports_cancellation;
+  gboolean                  injected_synthetic_cmd;
+  gboolean                  ignore_wait;
+  gboolean                  keep_alive;
 };
 
 /* Not really final here, but we can do this to share the FpDeviceVirtualDevice

libfprint/drivers/virtual-device-storage.c

@@ -244,4 +244,7 @@ fpi_device_virtual_device_storage_class_init (FpDeviceVirtualDeviceStorageClass
   dev_class->identify = dev_identify;
   dev_class->list = dev_list;
   dev_class->delete = dev_delete;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+  dev_class->features |= FPI_DEVICE_FEATURE_DUPLICATES_CHECK;
 }

libfprint/drivers/virtual-device.c

@@ -217,10 +217,10 @@ process_cmds (FpDeviceVirtualDevice * self,
 static void
 write_key_to_listener (void *key, void *val, void *user_data)
 {
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (user_data);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (user_data);
 
-  if (!fp_device_virtual_listener_write_sync (listener, key, strlen (key), NULL) ||
-      !fp_device_virtual_listener_write_sync (listener, "\n", 1, NULL))
+  if (!fpi_device_virtual_listener_write_sync (listener, key, strlen (key), NULL) ||
+      !fpi_device_virtual_listener_write_sync (listener, "\n", 1, NULL))
     g_warning ("Error writing reply to LIST command");
 }
 
@@ -230,10 +230,10 @@ recv_instruction_cb (GObject      *source_object,
                      gpointer      user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
   fp_dbg ("Got instructions of length %ld", bytes);
 
   if (error)
@@ -306,23 +306,23 @@ recv_instruction_cb (GObject      *source_object,
         }
     }
 
-  fp_device_virtual_listener_connection_close (listener);
+  fpi_device_virtual_listener_connection_close (listener);
 }
 
 static void
 recv_instruction (FpDeviceVirtualDevice *self)
 {
-  fp_device_virtual_listener_read (self->listener,
-                                   FALSE,
-                                   self->recv_buf,
-                                   sizeof (self->recv_buf),
-                                   recv_instruction_cb,
-                                   self);
+  fpi_device_virtual_listener_read (self->listener,
+                                    FALSE,
+                                    self->recv_buf,
+                                    sizeof (self->recv_buf),
+                                    recv_instruction_cb,
+                                    self);
 }
 
 static void
-on_listener_connected (FpDeviceVirtualListener *listener,
-                       gpointer                 user_data)
+on_listener_connected (FpiDeviceVirtualListener *listener,
+                       gpointer                  user_data)
 {
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
 
@@ -334,7 +334,7 @@ dev_init (FpDevice *dev)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(GCancellable) cancellable = NULL;
-  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  g_autoptr(FpiDeviceVirtualListener) listener = NULL;
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
 
   G_DEBUG_HERE ();
@@ -355,15 +355,15 @@ dev_init (FpDevice *dev)
       return;
     }
 
-  listener = fp_device_virtual_listener_new ();
+  listener = fpi_device_virtual_listener_new ();
   cancellable = g_cancellable_new ();
 
-  if (!fp_device_virtual_listener_start (listener,
-                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
-                                         cancellable,
-                                         on_listener_connected,
-                                         self,
-                                         &error))
+  if (!fpi_device_virtual_listener_start (listener,
+                                          fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                          cancellable,
+                                          on_listener_connected,
+                                          self,
+                                          &error))
     {
       fpi_device_open_complete (dev, g_steal_pointer (&error));
       return;
@@ -776,4 +776,6 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
   dev_class->verify = dev_verify;
   dev_class->enroll = dev_enroll;
   dev_class->cancel = dev_cancel;
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/virtual-image.c

@@ -36,14 +36,14 @@
 
 struct _FpDeviceVirtualImage
 {
-  FpImageDevice            parent;
+  FpImageDevice             parent;
 
-  FpDeviceVirtualListener *listener;
-  GCancellable            *cancellable;
+  FpiDeviceVirtualListener *listener;
+  GCancellable             *cancellable;
 
-  gboolean                 automatic_finger;
-  FpImage                 *recv_img;
-  gint                     recv_img_hdr[2];
+  gboolean                  automatic_finger;
+  FpImage                  *recv_img;
+  gint                      recv_img_hdr[2];
 };
 
 G_DECLARE_FINAL_TYPE (FpDeviceVirtualImage, fpi_device_virtual_image, FPI, DEVICE_VIRTUAL_IMAGE, FpImageDevice)
@@ -57,12 +57,12 @@ recv_image_img_recv_cb (GObject      *source_object,
                         gpointer      user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   FpDeviceVirtualImage *self;
   FpImageDevice *device;
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
 
   if (!bytes || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
       g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED))
@@ -88,10 +88,10 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 {
   g_autoptr(GError) error = NULL;
   FpDeviceVirtualImage *self;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
 
   if (error)
     {
@@ -111,7 +111,7 @@ recv_image_hdr_recv_cb (GObject      *source_object,
   if (self->recv_img_hdr[0] > 5000 || self->recv_img_hdr[1] > 5000)
     {
       g_warning ("Image header suggests an unrealistically large image, disconnecting client.");
-      fp_device_virtual_listener_connection_close (listener);
+      fpi_device_virtual_listener_connection_close (listener);
     }
 
   if (self->recv_img_hdr[0] < 0 || self->recv_img_hdr[1] < 0)
@@ -147,7 +147,7 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 
         default:
           /* disconnect client, it didn't play fair */
-          fp_device_virtual_listener_connection_close (listener);
+          fpi_device_virtual_listener_connection_close (listener);
         }
 
       /* And, listen for more images from the same client. */
@@ -157,28 +157,28 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 
   self->recv_img = fp_image_new (self->recv_img_hdr[0], self->recv_img_hdr[1]);
   g_debug ("image data: %p", self->recv_img->data);
-  fp_device_virtual_listener_read (listener,
-                                   TRUE,
-                                   (guint8 *) self->recv_img->data,
-                                   self->recv_img->width * self->recv_img->height,
-                                   recv_image_img_recv_cb,
-                                   self);
+  fpi_device_virtual_listener_read (listener,
+                                    TRUE,
+                                    (guint8 *) self->recv_img->data,
+                                    self->recv_img->width * self->recv_img->height,
+                                    recv_image_img_recv_cb,
+                                    self);
 }
 
 static void
 recv_image (FpDeviceVirtualImage *self)
 {
-  fp_device_virtual_listener_read (self->listener,
-                                   TRUE,
-                                   self->recv_img_hdr,
-                                   sizeof (self->recv_img_hdr),
-                                   recv_image_hdr_recv_cb,
-                                   self);
+  fpi_device_virtual_listener_read (self->listener,
+                                    TRUE,
+                                    self->recv_img_hdr,
+                                    sizeof (self->recv_img_hdr),
+                                    recv_image_hdr_recv_cb,
+                                    self);
 }
 
 static void
-on_listener_connected (FpDeviceVirtualListener *listener,
-                       gpointer                 user_data)
+on_listener_connected (FpiDeviceVirtualListener *listener,
+                       gpointer                  user_data)
 {
   FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
   FpiImageDeviceState state;
@@ -188,32 +188,39 @@ on_listener_connected (FpDeviceVirtualListener *listener,
   g_object_get (self,
                 "fpi-image-device-state", &state,
                 NULL);
-  /* Only read if we are in AWAIT_FINGER_* or CAPTURE states */
-  if (state <= FPI_IMAGE_DEVICE_STATE_DEACTIVATING)
-    return;
 
-  recv_image (self);
+  switch (state)
+    {
+    case FPI_IMAGE_DEVICE_STATE_IDLE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+      recv_image (self);
+
+    default:
+      break;
+    }
 }
 
 static void
 dev_init (FpImageDevice *dev)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  g_autoptr(FpiDeviceVirtualListener) listener = NULL;
   g_autoptr(GCancellable) cancellable = NULL;
   FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
 
   G_DEBUG_HERE ();
 
-  listener = fp_device_virtual_listener_new ();
+  listener = fpi_device_virtual_listener_new ();
   cancellable = g_cancellable_new ();
 
-  if (!fp_device_virtual_listener_start (listener,
-                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
-                                         cancellable,
-                                         on_listener_connected,
-                                         self,
-                                         &error))
+  if (!fpi_device_virtual_listener_start (listener,
+                                          fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                          cancellable,
+                                          on_listener_connected,
+                                          self,
+                                          &error))
     {
       fpi_image_device_open_complete (dev, g_steal_pointer (&error));
       return;

libfprint/drivers/virtual-sdcp.c

@@ -1,676 +0,0 @@
-/*
- * Virtual driver for SDCP device debugging
- *
- * Copyright (C) 2020 Benjamin Berg <bberg@redhat.com>
- *
- * This library 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 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/*
- * This is a virtual test driver to test the basic SDCP functionality.
- * It uses the test binaries from Microsoft, which were extended to allow
- * a simple chat with the device.
- * The environment variable contains the to be executed binary including
- * arguments. This binary should be compiled from the code in
- *   https://github.com/Microsoft/SecureDeviceConnectionProtocol
- * or, until it is merged upstream
- *   https://github.com/benzea/SecureDeviceConnectionProtocol
- *
- * Note that using this as an external executable has the advantage that we
- * do not need to link against mbedtls or any other crypto library.
- */
-
-#define FP_COMPONENT "virtual_sdcp"
-
-#include "fpi-log.h"
-#include "fpi-ssm.h"
-
-#include "../fpi-sdcp-device.h"
-
-#include <glib/gstdio.h>
-#include <gio/gio.h>
-
-struct _FpDeviceVirtualSdcp
-{
-  FpSdcpDevice   parent;
-
-  GSubprocess   *proc;
-  GOutputStream *proc_stdin;
-  GInputStream  *proc_stdout;
-
-  /* Only valid while a read/write is pending */
-  GByteArray *msg_out;
-  GByteArray *msg_in;
-
-  GByteArray *connect_msg;
-};
-
-G_DECLARE_FINAL_TYPE (FpDeviceVirtualSdcp, fpi_device_virtual_sdcp, FPI, DEVICE_VIRTUAL_SDCP, FpSdcpDevice)
-G_DEFINE_TYPE (FpDeviceVirtualSdcp, fpi_device_virtual_sdcp, FP_TYPE_SDCP_DEVICE)
-
-guint8 ca_1[] = {
-  0x30, 0x82, 0x03, 0xFD, 0x30, 0x82, 0x03, 0x82, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x13, 0x33,
-  0x00, 0x00, 0x00, 0x07, 0xE8, 0x9D, 0x61, 0x62, 0x4D, 0x46, 0x0F, 0x95, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x07, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x30, 0x81,
-  0x84, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13,
-  0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67,
-  0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
-  0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15,
-  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72,
-  0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x2E, 0x30, 0x2C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25,
-  0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x53, 0x65,
-  0x63, 0x75, 0x72, 0x65, 0x20, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x50, 0x43, 0x41,
-  0x20, 0x32, 0x30, 0x31, 0x38, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x38, 0x30, 0x31, 0x33, 0x31, 0x31,
-  0x39, 0x35, 0x34, 0x35, 0x33, 0x5A, 0x17, 0x0D, 0x32, 0x38, 0x30, 0x31, 0x33, 0x31, 0x32, 0x30,
-  0x30, 0x34, 0x35, 0x33, 0x5A, 0x30, 0x7D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06,
-  0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57,
-  0x61, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55,
-  0x04, 0x07, 0x13, 0x07, 0x52, 0x65, 0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06,
-  0x03, 0x55, 0x04, 0x0A, 0x13, 0x15, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20,
-  0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x27, 0x30, 0x25, 0x06,
-  0x03, 0x55, 0x04, 0x03, 0x13, 0x1E, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48, 0x65,
-  0x6C, 0x6C, 0x6F, 0x20, 0x31, 0x39, 0x42, 0x39, 0x32, 0x39, 0x36, 0x35, 0x20, 0x43, 0x41, 0x20,
-  0x32, 0x30, 0x31, 0x38, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02,
-  0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xBE,
-  0x4B, 0x90, 0x6E, 0x24, 0xFC, 0xA1, 0x53, 0xC8, 0xA7, 0x3C, 0x70, 0xE8, 0x97, 0xCD, 0x1B, 0x31,
-  0xE4, 0x95, 0x91, 0x7A, 0x58, 0xA2, 0x86, 0xA8, 0x70, 0xF6, 0x09, 0x30, 0x77, 0x99, 0x3D, 0x10,
-  0xDF, 0xF7, 0x95, 0x0F, 0x68, 0x83, 0xE6, 0xA4, 0x11, 0x7C, 0xDA, 0x82, 0xE7, 0x0B, 0x8B, 0xF2,
-  0x9D, 0x6B, 0x5B, 0xF5, 0x3E, 0x77, 0xB4, 0xC1, 0x0E, 0x49, 0x00, 0x83, 0xBA, 0x94, 0xF8, 0xA3,
-  0x82, 0x01, 0xD7, 0x30, 0x82, 0x01, 0xD3, 0x30, 0x10, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01,
-  0x82, 0x37, 0x15, 0x01, 0x04, 0x03, 0x02, 0x01, 0x00, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E,
-  0x04, 0x16, 0x04, 0x14, 0x13, 0x93, 0xC8, 0xCD, 0xF2, 0x23, 0x9A, 0x2D, 0xC6, 0x9B, 0x2A, 0xEB,
-  0x9A, 0xAB, 0x99, 0x0B, 0x56, 0x04, 0x5E, 0x7C, 0x30, 0x65, 0x06, 0x03, 0x55, 0x1D, 0x20, 0x04,
-  0x5E, 0x30, 0x5C, 0x30, 0x06, 0x06, 0x04, 0x55, 0x1D, 0x20, 0x00, 0x30, 0x52, 0x06, 0x0C, 0x2B,
-  0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x4C, 0x83, 0x7D, 0x01, 0x01, 0x30, 0x42, 0x30, 0x40, 0x06,
-  0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70, 0x3A,
-  0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E,
-  0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x44, 0x6F, 0x63, 0x73, 0x2F,
-  0x52, 0x65, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0x68, 0x74, 0x6D, 0x00, 0x30,
-  0x19, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14, 0x02, 0x04, 0x0C, 0x1E, 0x0A,
-  0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x43, 0x00, 0x41, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x1D,
-  0x0F, 0x04, 0x04, 0x03, 0x02, 0x01, 0x86, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01,
-  0xFF, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xFF, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04,
-  0x18, 0x30, 0x16, 0x80, 0x14, 0xDA, 0xCA, 0x4B, 0xD0, 0x4C, 0x56, 0x03, 0x27, 0x5F, 0x97, 0xEB,
-  0x75, 0xA3, 0x02, 0xC3, 0xBF, 0x45, 0x9C, 0xF8, 0xB1, 0x30, 0x68, 0x06, 0x03, 0x55, 0x1D, 0x1F,
-  0x04, 0x61, 0x30, 0x5F, 0x30, 0x5D, 0xA0, 0x5B, 0xA0, 0x59, 0x86, 0x57, 0x68, 0x74, 0x74, 0x70,
-  0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74,
-  0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x63, 0x72, 0x6C, 0x2F,
-  0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x25, 0x32, 0x30, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x25,
-  0x32, 0x30, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x25, 0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63,
-  0x65, 0x73, 0x25, 0x32, 0x30, 0x50, 0x43, 0x41, 0x25, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x2E,
-  0x63, 0x72, 0x6C, 0x30, 0x75, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04,
-  0x69, 0x30, 0x67, 0x30, 0x65, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86,
-  0x59, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72,
-  0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73,
-  0x2F, 0x63, 0x65, 0x72, 0x74, 0x73, 0x2F, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x25, 0x32,
-  0x30, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x25, 0x32, 0x30, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x25,
-  0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32, 0x30, 0x50, 0x43, 0x41, 0x25,
-  0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x2E, 0x63, 0x72, 0x74, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86,
-  0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x03, 0x69, 0x00, 0x30, 0x66, 0x02, 0x31, 0x00, 0x87, 0xB6,
-  0x82, 0xF3, 0xDA, 0xBE, 0xB1, 0x7B, 0x98, 0x7D, 0x3D, 0x0A, 0x90, 0xA8, 0xF5, 0xBF, 0x15, 0xC3,
-  0xEE, 0x8A, 0x4E, 0xC0, 0x7B, 0x10, 0x1D, 0xA9, 0xE3, 0x0B, 0xEC, 0x2C, 0x53, 0x4E, 0xA7, 0xBD,
-  0xF1, 0x6C, 0xAD, 0x18, 0x55, 0xBA, 0x25, 0x73, 0x55, 0xB7, 0x5B, 0x12, 0x24, 0xF4, 0x02, 0x31,
-  0x00, 0xAF, 0x02, 0x9C, 0x4B, 0x92, 0xD0, 0x72, 0xA5, 0x80, 0xCA, 0x69, 0x2B, 0x38, 0x50, 0x64,
-  0xD8, 0x58, 0x9E, 0xEA, 0xD6, 0x35, 0xCF, 0x68, 0x98, 0x92, 0x81, 0x09, 0x61, 0xC2, 0xBD, 0xB1,
-  0x4C, 0x7F, 0xAE, 0x55, 0x7B, 0xFC, 0x22, 0xDD, 0xD6, 0xB7, 0x7C, 0xB5, 0xA8, 0x18, 0x5D, 0x33,
-  0x04
-};
-guint8 ca_2[] = {
-  0x30, 0x82, 0x04, 0x56, 0x30, 0x82, 0x03, 0xDC, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x13, 0x33,
-  0x00, 0x00, 0x00, 0x03, 0x6C, 0xCF, 0xED, 0xE2, 0x44, 0x70, 0x19, 0xBF, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x03, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03, 0x30, 0x81,
-  0x94, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13,
-  0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67,
-  0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
-  0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15,
-  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72,
-  0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x3E, 0x30, 0x3C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x35,
-  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x45, 0x43, 0x43, 0x20, 0x44, 0x65,
-  0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x52, 0x6F, 0x6F, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69,
-  0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79,
-  0x20, 0x32, 0x30, 0x31, 0x37, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x38, 0x30, 0x31, 0x32, 0x35, 0x31,
-  0x39, 0x34, 0x39, 0x33, 0x38, 0x5A, 0x17, 0x0D, 0x33, 0x33, 0x30, 0x31, 0x32, 0x35, 0x31, 0x39,
-  0x35, 0x39, 0x33, 0x38, 0x5A, 0x30, 0x81, 0x84, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
-  0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A,
-  0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03,
-  0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65, 0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C,
-  0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74,
-  0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x2E, 0x30, 0x2C,
-  0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48,
-  0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x44, 0x65, 0x76, 0x69,
-  0x63, 0x65, 0x73, 0x20, 0x50, 0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x38, 0x30, 0x76, 0x30, 0x10,
-  0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22,
-  0x03, 0x62, 0x00, 0x04, 0x1D, 0xDD, 0x08, 0x02, 0x03, 0x25, 0x75, 0x20, 0xE2, 0x71, 0x8B, 0xAD,
-  0x28, 0x09, 0x82, 0xE9, 0x06, 0xEE, 0x83, 0xC5, 0x3A, 0x6C, 0x4B, 0x71, 0x92, 0x50, 0x4E, 0x20,
-  0xE9, 0x72, 0xB4, 0xFC, 0x53, 0x2A, 0xEF, 0x5D, 0xCC, 0x9A, 0xB4, 0xCD, 0x76, 0xB8, 0x94, 0x97,
-  0x44, 0xB2, 0x71, 0x0E, 0xC9, 0xB1, 0x16, 0x03, 0xA1, 0x65, 0x2B, 0xB9, 0xE8, 0x5D, 0x5F, 0xF2,
-  0x30, 0x2E, 0xDD, 0xB1, 0x2B, 0x20, 0xFC, 0xBE, 0x00, 0x88, 0xEA, 0x1F, 0xA7, 0x7F, 0x99, 0x84,
-  0x98, 0x7C, 0x71, 0x3E, 0x4D, 0x34, 0x83, 0x69, 0x9B, 0x08, 0xCB, 0x78, 0xB2, 0x4B, 0xBD, 0xD7,
-  0x3E, 0xBE, 0x67, 0xA0, 0xA3, 0x82, 0x01, 0xFC, 0x30, 0x82, 0x01, 0xF8, 0x30, 0x10, 0x06, 0x09,
-  0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x15, 0x01, 0x04, 0x03, 0x02, 0x01, 0x00, 0x30, 0x1D,
-  0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0xDA, 0xCA, 0x4B, 0xD0, 0x4C, 0x56, 0x03,
-  0x27, 0x5F, 0x97, 0xEB, 0x75, 0xA3, 0x02, 0xC3, 0xBF, 0x45, 0x9C, 0xF8, 0xB1, 0x30, 0x65, 0x06,
-  0x03, 0x55, 0x1D, 0x20, 0x04, 0x5E, 0x30, 0x5C, 0x30, 0x06, 0x06, 0x04, 0x55, 0x1D, 0x20, 0x00,
-  0x30, 0x52, 0x06, 0x0C, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x4C, 0x83, 0x7D, 0x01, 0x01,
-  0x30, 0x42, 0x30, 0x40, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x34,
-  0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F,
-  0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F,
-  0x44, 0x6F, 0x63, 0x73, 0x2F, 0x52, 0x65, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x6F, 0x72, 0x79, 0x2E,
-  0x68, 0x74, 0x6D, 0x00, 0x30, 0x19, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14,
-  0x02, 0x04, 0x0C, 0x1E, 0x0A, 0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x43, 0x00, 0x41, 0x30,
-  0x0B, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x04, 0x04, 0x03, 0x02, 0x01, 0x86, 0x30, 0x0F, 0x06, 0x03,
-  0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xFF, 0x30, 0x1F, 0x06,
-  0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x14, 0xDA, 0x5B, 0xF1, 0x0E, 0x66,
-  0x47, 0xD1, 0x5D, 0x13, 0x5F, 0x5B, 0x7A, 0xEB, 0xEB, 0x5F, 0x01, 0x08, 0xB5, 0x49, 0x30, 0x7A,
-  0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x73, 0x30, 0x71, 0x30, 0x6F, 0xA0, 0x6D, 0xA0, 0x6B, 0x86,
-  0x69, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72,
-  0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73,
-  0x2F, 0x63, 0x72, 0x6C, 0x2F, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x25, 0x32,
-  0x30, 0x45, 0x43, 0x43, 0x25, 0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32,
-  0x30, 0x52, 0x6F, 0x6F, 0x74, 0x25, 0x32, 0x30, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63,
-  0x61, 0x74, 0x65, 0x25, 0x32, 0x30, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x25,
-  0x32, 0x30, 0x32, 0x30, 0x31, 0x37, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x81, 0x87, 0x06, 0x08, 0x2B,
-  0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x7B, 0x30, 0x79, 0x30, 0x77, 0x06, 0x08, 0x2B,
-  0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x6B, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F,
-  0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F,
-  0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x63, 0x65, 0x72, 0x74, 0x73, 0x2F, 0x4D,
-  0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x25, 0x32, 0x30, 0x45, 0x43, 0x43, 0x25, 0x32,
-  0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32, 0x30, 0x52, 0x6F, 0x6F, 0x74, 0x25,
-  0x32, 0x30, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x25, 0x32, 0x30,
-  0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x25, 0x32, 0x30, 0x32, 0x30, 0x31, 0x37,
-  0x2E, 0x63, 0x72, 0x74, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03,
-  0x03, 0x68, 0x00, 0x30, 0x65, 0x02, 0x30, 0x56, 0x2A, 0xAD, 0x72, 0x4C, 0xB9, 0x8C, 0xB3, 0x23,
-  0x80, 0xF5, 0x5F, 0xF8, 0x21, 0x94, 0x66, 0x0F, 0x76, 0x77, 0xE2, 0x7B, 0x03, 0xDD, 0x30, 0x5E,
-  0xCB, 0x90, 0xCA, 0x78, 0xE6, 0x0B, 0x2D, 0x12, 0xE5, 0xF7, 0x67, 0x31, 0x58, 0x71, 0xE6, 0xF3,
-  0x64, 0xC1, 0x04, 0xB3, 0x8B, 0xE9, 0xE2, 0x02, 0x31, 0x00, 0xB9, 0x20, 0x61, 0xB9, 0xD0, 0x5E,
-  0x3A, 0xA4, 0xA2, 0x8A, 0xFE, 0x1D, 0xFC, 0x27, 0x61, 0x0B, 0x98, 0x16, 0x8C, 0x02, 0x9C, 0x20,
-  0x7F, 0xEE, 0xF3, 0xCB, 0x1F, 0x0A, 0x37, 0x62, 0xB1, 0x8E, 0xCE, 0xD9, 0x9A, 0x9E, 0xAC, 0xE6,
-  0x1A, 0xD4, 0xB8, 0xF1, 0xA8, 0x2B, 0xB1, 0xB4, 0x40, 0x9B
-};
-
-
-static void
-msg_written_cb (GObject      *source_object,
-                GAsyncResult *res,
-                gpointer      user_data)
-{
-  GError *error = NULL;
-  GOutputStream *stream = G_OUTPUT_STREAM (source_object);
-  FpiSsm *ssm = user_data;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (fpi_ssm_get_device (ssm));
-
-  g_clear_pointer (&self->msg_out, g_byte_array_unref);
-  g_assert (self->msg_out == NULL);
-
-  if (!g_output_stream_write_all_finish (stream, res, NULL, &error))
-    {
-      fpi_ssm_mark_failed (ssm, error);
-      return;
-    }
-
-  fpi_ssm_next_state (ssm);
-}
-
-static void
-msg_received_cb (GObject      *source_object,
-                 GAsyncResult *res,
-                 gpointer      user_data)
-{
-  GError *error = NULL;
-  GInputStream *stream = G_INPUT_STREAM (source_object);
-  FpiSsm *ssm = user_data;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (fpi_ssm_get_device (ssm));
-  gsize read;
-
-  g_assert (self->msg_out == NULL);
-
-  if (!g_input_stream_read_all_finish (stream, res, &read, &error) ||
-      read != self->msg_in->len)
-    {
-      g_clear_pointer (&self->msg_in, g_byte_array_unref);
-
-      if (!error)
-        error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                          "Received EOF while reading from test binary.");
-
-      fpi_ssm_mark_failed (ssm, error);
-      return;
-    }
-
-  fpi_ssm_next_state (ssm);
-}
-
-enum {
-  SEND_MESSAGE,
-  RECV_MESSAGE,
-  SEND_RECV_STATES
-};
-
-static void
-send_recv_ssm (FpiSsm *ssm, FpDevice *dev)
-{
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-
-  switch (fpi_ssm_get_cur_state (ssm))
-    {
-    case SEND_MESSAGE:
-      g_output_stream_write_all_async (self->proc_stdin,
-                                       self->msg_out->data,
-                                       self->msg_out->len,
-                                       G_PRIORITY_DEFAULT,
-                                       fpi_device_get_cancellable (FP_DEVICE (dev)),
-                                       msg_written_cb,
-                                       ssm);
-      break;
-
-    case RECV_MESSAGE:
-      g_input_stream_read_all_async (self->proc_stdout,
-                                     self->msg_in->data,
-                                     self->msg_in->len,
-                                     G_PRIORITY_DEFAULT,
-                                     fpi_device_get_cancellable (FP_DEVICE (dev)),
-                                     msg_received_cb,
-                                     ssm);
-      break;
-    }
-}
-
-static void
-connect_2_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  g_autoptr(GBytes) recv_data = NULL;
-  g_autoptr(GBytes) r_d = NULL;
-  g_autoptr(FpiSdcpClaim) claim = NULL;
-  g_autoptr(GBytes) mac = NULL;
-  g_autoptr(GBytes) ca_1_bytes = NULL, ca_2_bytes = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  guint16 cert_size;
-
-  if (error)
-    {
-      fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), NULL, NULL, NULL, error);
-      g_clear_pointer (&self->connect_msg, g_byte_array_unref);
-      return;
-    }
-
-  memcpy (&cert_size, self->connect_msg->data + 32, 2);
-  g_byte_array_append (self->connect_msg, self->msg_in->data, self->msg_in->len);
-  g_clear_pointer (&self->msg_in, g_byte_array_unref);
-  /* Double check that the size is correct. */
-  g_assert (self->connect_msg->len == 32 + (2 + cert_size + 65 + 65 + 32 + 64 + 64) + 32);
-  recv_data = g_byte_array_free_to_bytes (g_steal_pointer (&self->connect_msg));
-
-  claim = fpi_sdcp_claim_new ();
-  r_d = g_bytes_new_from_bytes (recv_data, 0, 32);
-  claim->cert_m = g_bytes_new_from_bytes (recv_data, 34, cert_size);
-  claim->pk_d = g_bytes_new_from_bytes (recv_data, 34 + cert_size, 65);
-  claim->pk_f = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65, 65);
-  claim->h_f = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65, 32);
-  claim->s_m = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32, 64);
-  claim->s_d = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32 + 64, 64);
-  mac = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32 + 64 + 64, 32);
-
-  ca_1_bytes = g_bytes_new_static (ca_1, G_N_ELEMENTS (ca_1));
-  ca_2_bytes = g_bytes_new_static (ca_2, G_N_ELEMENTS (ca_2));
-
-  fpi_sdcp_device_set_intermediat_cas (FP_SDCP_DEVICE (dev),
-                                       ca_1_bytes,
-                                       ca_2_bytes);
-
-  fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), r_d, claim, mac, NULL);
-}
-
-static void
-connect_1_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  guint16 cert_size;
-
-  if (error)
-    {
-      fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), NULL, NULL, NULL, error);
-      return;
-    }
-
-  g_clear_pointer (&self->connect_msg, g_byte_array_unref);
-  self->connect_msg = g_steal_pointer (&self->msg_in);
-
-  memcpy (&cert_size, self->connect_msg->data + 32, 2);
-
-  /* Nothing to send and the rest to receive. */
-  self->msg_out = g_byte_array_new ();
-  self->msg_in = g_byte_array_new ();
-  g_byte_array_set_size (self->msg_in, 32 + (2 + cert_size + 65 + 65 + 32 + 64 + 64) + 32 - self->connect_msg->len);
-
-  /* New SSM */
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect 2");
-  fpi_ssm_start (ssm, connect_2_cb);
-}
-
-static void
-connect (FpSdcpDevice *dev)
-{
-  g_autoptr(GBytes) r_h = NULL;
-  g_autoptr(GBytes) pk_h = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  FpiSsm *ssm;
-
-  G_DEBUG_HERE ();
-
-  g_assert (self->proc);
-  g_assert (self->connect_msg == NULL);
-
-  fpi_sdcp_device_get_connect_data (dev, &r_h, &pk_h);
-
-  self->msg_out = g_byte_array_new ();
-  g_byte_array_append (self->msg_out, (const guint8 *) "C", 1);
-  g_byte_array_append (self->msg_out,
-                       g_bytes_get_data (r_h, NULL),
-                       g_bytes_get_size (r_h));
-  g_byte_array_append (self->msg_out,
-                       g_bytes_get_data (pk_h, NULL),
-                       g_bytes_get_size (pk_h));
-
-  self->msg_in = g_byte_array_new ();
-  g_byte_array_set_size (self->msg_in, 34);
-
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect");
-  fpi_ssm_start (ssm, connect_1_cb);
-}
-
-static void
-reconnect_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  g_autoptr(GBytes) mac = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-
-  if (error)
-    {
-      fpi_sdcp_device_reconnect_complete (FP_SDCP_DEVICE (dev), mac, error);
-      return;
-    }
-
-  mac = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
-
-  fpi_sdcp_device_reconnect_complete (FP_SDCP_DEVICE (dev), mac, NULL);
-}
-
-static void
-reconnect (FpSdcpDevice *dev)
-{
-  g_autoptr(GBytes) r_h = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  FpiSsm *ssm;
-
-  G_DEBUG_HERE ();
-
-  g_assert (self->proc);
-
-  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
-
-  self->msg_out = g_byte_array_new ();
-  g_byte_array_append (self->msg_out, (const guint8 *) "R", 1);
-  g_byte_array_append (self->msg_out,
-                       g_bytes_get_data (r_h, NULL),
-                       g_bytes_get_size (r_h));
-
-  self->msg_in = g_byte_array_new ();
-  g_byte_array_set_size (self->msg_in, 32);
-
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect 2");
-  fpi_ssm_start (ssm, reconnect_cb);
-}
-
-static void
-enroll_begin_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  g_autoptr(GBytes) nonce = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-
-  if (error)
-    {
-      fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), error);
-      return;
-    }
-
-  nonce = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
-
-  fpi_sdcp_device_enroll_set_nonce (FP_SDCP_DEVICE (dev), nonce);
-
-  /* Claim that we completed one enroll step. */
-  fpi_device_enroll_progress (dev, 1, NULL, NULL);
-
-  /* And signal that we are ready to commit. */
-  fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), NULL);
-}
-
-static void
-enroll_begin (FpSdcpDevice *dev)
-{
-  g_autoptr(GBytes) r_h = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  FpiSsm *ssm;
-
-  G_DEBUG_HERE ();
-
-  g_assert (self->proc);
-
-  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
-
-  self->msg_out = g_byte_array_new ();
-  g_byte_array_append (self->msg_out, (const guint8 *) "E", 1);
-
-  /* Expect 32 byte nonce */
-  self->msg_in = g_byte_array_new ();
-  g_byte_array_set_size (self->msg_in, 32);
-
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "enroll_begin");
-  fpi_ssm_start (ssm, enroll_begin_cb);
-}
-
-static void
-enroll_commit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-
-  g_clear_pointer (&self->msg_in, g_byte_array_unref);
-
-  if (error)
-    {
-      fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), error);
-      return;
-    }
-
-  /* Signal that we have committed. We don't expect a response
-   * from the virtual device (even though that is kind of broken).
-   */
-  fpi_sdcp_device_enroll_commit_complete (FP_SDCP_DEVICE (dev), NULL);
-}
-
-static void
-enroll_commit (FpSdcpDevice *dev, GBytes *id_in)
-{
-  g_autoptr(GBytes) r_h = NULL;
-  g_autoptr(GBytes) id = id_in;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  FpiSsm *ssm;
-
-  G_DEBUG_HERE ();
-
-  g_assert (self->proc);
-
-  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
-
-  self->msg_out = g_byte_array_new ();
-  self->msg_in = g_byte_array_new ();
-  if (id)
-    {
-      g_byte_array_append (self->msg_out, (const guint8 *) "F", 1);
-      g_byte_array_append (self->msg_out,
-                           g_bytes_get_data (id, NULL),
-                           g_bytes_get_size (id));
-
-      /* NOTE: No response from device, assume commit works. */
-    }
-  else
-    {
-      /* Cancel enroll (does not receive a reply) */
-      g_byte_array_append (self->msg_out, (const guint8 *) "G", 1);
-
-      /* NOTE: No response from device, assume cancellation works. */
-    }
-
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "enroll_commit");
-  fpi_ssm_start (ssm, enroll_commit_cb);
-}
-
-static void
-identify_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  g_autoptr(GBytes) reply = NULL;
-  g_autoptr(GBytes) id = NULL;
-  g_autoptr(GBytes) mac = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-
-  if (error)
-    {
-      fpi_sdcp_device_identify_complete (FP_SDCP_DEVICE (dev), NULL, NULL, error);
-      return;
-    }
-
-  reply = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
-  id = g_bytes_new_from_bytes (reply, 0, 32);
-  mac = g_bytes_new_from_bytes (reply, 32, 32);
-
-  fpi_sdcp_device_identify_complete (FP_SDCP_DEVICE (self), id, mac, NULL);
-}
-
-static void
-identify (FpSdcpDevice *dev)
-{
-  g_autoptr(GBytes) nonce = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  FpiSsm *ssm;
-
-  G_DEBUG_HERE ();
-
-  g_assert (self->proc);
-
-  fpi_sdcp_device_get_identify_data (dev, &nonce);
-
-  self->msg_out = g_byte_array_new ();
-  g_byte_array_append (self->msg_out, (const guint8 *) "I", 1);
-  g_byte_array_append (self->msg_out, g_bytes_get_data (nonce, NULL), g_bytes_get_size (nonce));
-
-  /* Expect 64 byte nonce */
-  self->msg_in = g_byte_array_new ();
-  g_byte_array_set_size (self->msg_in, 64);
-
-  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "identify");
-  fpi_ssm_start (ssm, identify_cb);
-}
-
-static void
-probe (FpDevice *dev)
-{
-  g_auto(GStrv) argv = NULL;
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
-  GError *error = NULL;
-  const char *env;
-
-  /* We launch the test binary alread at probe time and quit only when
-   * the object is finalized. This allows testing reconnect properly.
-   *
-   * Also, we'll fail probe if something goes wrong executing it.
-   */
-  env = fpi_device_get_virtual_env (FP_DEVICE (self));
-
-  if (!g_shell_parse_argv (env, NULL, &argv, &error))
-    goto out;
-
-  self->proc = g_subprocess_newv ((const char * const *) argv,
-                                  G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE,
-                                  &error);
-  if (!self->proc)
-    goto out;
-
-  self->proc_stdin = g_object_ref (g_subprocess_get_stdin_pipe (self->proc));
-  self->proc_stdout = g_object_ref (g_subprocess_get_stdout_pipe (self->proc));
-
-
-out:
-  fpi_device_probe_complete (dev, "virtual-sdcp", NULL, error);
-}
-
-static void
-dev_close (FpDevice *dev)
-{
-  /* No-op, needs to be defined. */
-  fpi_device_close_complete (dev, NULL);
-}
-
-static void
-fpi_device_virtual_sdcp_init (FpDeviceVirtualSdcp *self)
-{
-}
-
-static void
-fpi_device_virtual_sdcp_finalize (GObject *obj)
-{
-  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (obj);
-
-  /* Just kill the subprocess, no need to be graceful here. */
-  if (self->proc)
-    g_subprocess_force_exit (self->proc);
-
-  g_clear_object (&self->proc);
-  g_clear_object (&self->proc_stdin);
-  g_clear_object (&self->proc_stdout);
-
-  G_OBJECT_CLASS (fpi_device_virtual_sdcp_parent_class)->finalize (obj);
-}
-
-static const FpIdEntry driver_ids[] = {
-  { .virtual_envvar = "FP_VIRTUAL_SDCP" },
-  { .virtual_envvar = NULL }
-};
-
-static void
-fpi_device_virtual_sdcp_class_init (FpDeviceVirtualSdcpClass *klass)
-{
-  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
-  FpSdcpDeviceClass *sdcp_class = FP_SDCP_DEVICE_CLASS (klass);
-
-  obj_class->finalize = fpi_device_virtual_sdcp_finalize;
-
-  dev_class->id = FP_COMPONENT;
-  dev_class->full_name = "Virtual SDCP device talking to MS test code";
-  dev_class->type = FP_DEVICE_TYPE_VIRTUAL;
-  dev_class->id_table = driver_ids;
-  dev_class->nr_enroll_stages = 1;
-
-  /* The SDCP base class may need to override this in the long run */
-  dev_class->probe = probe;
-  dev_class->close = dev_close;
-
-  sdcp_class->connect = connect;
-  sdcp_class->reconnect = reconnect;
-
-  sdcp_class->enroll_begin = enroll_begin;
-  sdcp_class->enroll_commit = enroll_commit;
-
-  sdcp_class->identify = identify;
-}

libfprint/drivers_api.h

@@ -29,4 +29,5 @@
 #include "fpi-log.h"
 #include "fpi-print.h"
 #include "fpi-usb-transfer.h"
+#include "fpi-spi-transfer.h"
 #include "fpi-ssm.h"

libfprint/fp-context.c

@@ -24,6 +24,18 @@
 #include "fpi-device.h"
 #include <gusb.h>
 
+#include <config.h>
+
+#ifdef HAVE_UDEV
+#include <sys/ioctl.h>
+#include <sys/unistd.h>
+#include <sys/types.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <linux/hidraw.h>
+#include <gudev/gudev.h>
+#endif
+
 /**
  * SECTION: fp-context
  * @title: FpContext
@@ -434,6 +446,103 @@ fp_context_enumerate (FpContext *context)
         }
     }
 
+
+#ifdef HAVE_UDEV
+  {
+    g_autoptr(GUdevClient) udev_client = g_udev_client_new (NULL);
+
+    /* This uses a very simple algorithm to allocate devices to drivers and assumes that no two drivers will want the same device. Future improvements
+     * could add a usb_discover style udev_discover that returns a score, however for internal devices the potential overlap should be very low between
+     * separate drivers.
+     */
+
+    g_autoptr(GList) spidev_devices = g_udev_client_query_by_subsystem (udev_client, "spidev");
+    g_autoptr(GList) hidraw_devices = g_udev_client_query_by_subsystem (udev_client, "hidraw");
+
+    /* for each potential driver, try to match all requested resources. */
+    for (i = 0; i < priv->drivers->len; i++)
+      {
+        GType driver = g_array_index (priv->drivers, GType, i);
+        g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
+        const FpIdEntry *entry;
+
+        if (cls->type != FP_DEVICE_TYPE_UDEV)
+          continue;
+
+        for (entry = cls->id_table; entry->udev_types; entry++)
+          {
+            GList *matched_spidev = NULL, *matched_hidraw = NULL;
+
+            if (entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_SPIDEV)
+              {
+                for (matched_spidev = spidev_devices; matched_spidev; matched_spidev = matched_spidev->next)
+                  {
+                    const gchar * sysfs = g_udev_device_get_sysfs_path (matched_spidev->data);
+                    if (!sysfs)
+                      continue;
+                    if (strstr (sysfs, entry->spi_acpi_id))
+                      break;
+                  }
+                /* If match was not found exit */
+                if (matched_spidev == NULL)
+                  continue;
+              }
+            if (entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_HIDRAW)
+              {
+                for (matched_hidraw = hidraw_devices; matched_hidraw; matched_hidraw = matched_hidraw->next)
+                  {
+                    const gchar * devnode = g_udev_device_get_device_file (matched_hidraw->data);
+                    int temp_hid = -1, res;
+                    struct hidraw_devinfo info;
+
+                    if (!devnode)
+                      continue;
+
+                    temp_hid = open (devnode, O_RDWR);
+                    if (temp_hid < 0)
+                      continue;
+
+                    res = ioctl (temp_hid, HIDIOCGRAWINFO, &info);
+                    close (temp_hid);
+                    if (res < 0)
+                      continue;
+                    if (info.vendor == entry->hid_id.vid && info.product == entry->hid_id.pid)
+                      break;
+                  }
+                /* If match was not found exit */
+                if (matched_hidraw == NULL)
+                  continue;
+              }
+            priv->pending_devices++;
+            g_async_initable_new_async (driver,
+                                        G_PRIORITY_LOW,
+                                        priv->cancellable,
+                                        async_device_init_done_cb,
+                                        context,
+                                        "fpi-driver-data", entry->driver_data,
+                                        "fpi-udev-data-spidev", (matched_spidev ? g_udev_device_get_device_file (matched_spidev->data) : NULL),
+                                        "fpi-udev-data-hidraw", (matched_hidraw ? g_udev_device_get_device_file (matched_hidraw->data) : NULL),
+                                        NULL);
+            /* remove entries from list to avoid conflicts */
+            if (matched_spidev)
+              {
+                g_object_unref (matched_spidev->data);
+                spidev_devices = g_list_delete_link (spidev_devices, matched_spidev);
+              }
+            if (matched_hidraw)
+              {
+                g_object_unref (matched_hidraw->data);
+                hidraw_devices = g_list_delete_link (hidraw_devices, matched_hidraw);
+              }
+          }
+      }
+
+    /* free all unused elemnts in both lists */
+    g_list_foreach (spidev_devices, (GFunc) g_object_unref, NULL);
+    g_list_foreach (hidraw_devices, (GFunc) g_object_unref, NULL);
+  }
+#endif
+
   while (priv->pending_devices)
     g_main_context_iteration (NULL, TRUE);
 }

libfprint/fp-device-private.h

@@ -28,18 +28,23 @@ typedef struct
 
   GUsbDevice  *usb_device;
   const gchar *virtual_env;
+  struct
+  {
+    gchar *spidev_path;
+    gchar *hidraw_path;
+  } udev_data;
 
-  gboolean     is_removed;
-  gboolean     is_open;
+  gboolean   is_removed;
+  gboolean   is_open;
 
-  gchar       *device_id;
-  gchar       *device_name;
-  FpScanType   scan_type;
+  gchar     *device_id;
+  gchar     *device_name;
+  FpScanType scan_type;
 
-  guint64      driver_data;
+  guint64    driver_data;
 
-  gint         nr_enroll_stages;
-  GSList      *sources;
+  gint       nr_enroll_stages;
+  GSList    *sources;
 
   /* We always make sure that only one task is run at a time. */
   FpiDeviceAction     current_action;

libfprint/fp-device.c

@@ -50,6 +50,8 @@ enum {
   PROP_FINGER_STATUS,
   PROP_FPI_ENVIRON,
   PROP_FPI_USB_DEVICE,
+  PROP_FPI_UDEV_DATA_SPIDEV,
+  PROP_FPI_UDEV_DATA_HIDRAW,
   PROP_FPI_DRIVER_DATA,
   N_PROPS
 };
@@ -138,6 +140,8 @@ fp_device_constructed (GObject *object)
   FpDeviceClass *cls = FP_DEVICE_GET_CLASS (self);
   FpDevicePrivate *priv = fp_device_get_instance_private (self);
 
+  g_assert (cls->features != FPI_DEVICE_FEATURE_NONE);
+
   priv->type = cls->type;
   if (cls->nr_enroll_stages)
     priv->nr_enroll_stages = cls->nr_enroll_stages;
@@ -169,6 +173,8 @@ fp_device_finalize (GObject *object)
 
   g_clear_object (&priv->usb_device);
   g_clear_pointer (&priv->virtual_env, g_free);
+  g_clear_pointer (&priv->udev_data.spidev_path, g_free);
+  g_clear_pointer (&priv->udev_data.hidraw_path, g_free);
 
   G_OBJECT_CLASS (fp_device_parent_class)->finalize (object);
 }
@@ -248,6 +254,20 @@ fp_device_set_property (GObject      *object,
         g_assert (g_value_get_object (value) == NULL);
       break;
 
+    case PROP_FPI_UDEV_DATA_SPIDEV:
+      if (cls->type == FP_DEVICE_TYPE_UDEV)
+        priv->udev_data.spidev_path = g_value_dup_string (value);
+      else
+        g_assert (g_value_get_string (value) == NULL);
+      break;
+
+    case PROP_FPI_UDEV_DATA_HIDRAW:
+      if (cls->type == FP_DEVICE_TYPE_UDEV)
+        priv->udev_data.hidraw_path = g_value_dup_string (value);
+      else
+        g_assert (g_value_get_string (value) == NULL);
+      break;
+
     case PROP_FPI_DRIVER_DATA:
       priv->driver_data = g_value_get_uint64 (value);
       break;
@@ -425,6 +445,32 @@ fp_device_class_init (FpDeviceClass *klass)
                          "Private: The USB device for the device",
                          G_USB_TYPE_DEVICE,
                          G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+  /**
+   * FpDevice::fpi-udev-data-spidev: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
+  properties[PROP_FPI_UDEV_DATA_SPIDEV] =
+    g_param_spec_string ("fpi-udev-data-spidev",
+                         "Udev data: spidev path",
+                         "Private: The path to /dev/spidevN.M",
+                         NULL,
+                         G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+  /**
+   * FpDevice::fpi-udev-data-hidraw: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
+  properties[PROP_FPI_UDEV_DATA_HIDRAW] =
+    g_param_spec_string ("fpi-udev-data-hidraw",
+                         "Udev data: hidraw path",
+                         "Private: The path to /dev/hidrawN",
+                         NULL,
+                         G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
 
   /**
    * FpDevice::fpi-driver-data: (skip)
@@ -583,7 +629,7 @@ fp_device_supports_identify (FpDevice *device)
 
   g_return_val_if_fail (FP_IS_DEVICE (device), FALSE);
 
-  return cls->identify != NULL;
+  return cls->identify && !!(cls->features & FPI_DEVICE_FEATURE_IDENTIFY);
 }
 
 /**
@@ -601,7 +647,7 @@ fp_device_supports_capture (FpDevice *device)
 
   g_return_val_if_fail (FP_IS_DEVICE (device), FALSE);
 
-  return cls->capture != NULL;
+  return cls->capture && !!(cls->features & FPI_DEVICE_FEATURE_CAPTURE);
 }
 
 /**
@@ -620,7 +666,7 @@ fp_device_has_storage (FpDevice *device)
 
   g_return_val_if_fail (FP_IS_DEVICE (device), FALSE);
 
-  return cls->list != NULL;
+  return !!(cls->features & FPI_DEVICE_FEATURE_STORAGE);
 }
 
 /**
@@ -673,6 +719,7 @@ fp_device_open (FpDevice           *device,
       break;
 
     case FP_DEVICE_TYPE_VIRTUAL:
+    case FP_DEVICE_TYPE_UDEV:
       break;
 
     default:
@@ -908,6 +955,7 @@ fp_device_verify (FpDevice           *device,
 {
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpDeviceClass *cls = FP_DEVICE_GET_CLASS (device);
   FpMatchData *data;
 
   task = g_task_new (device, cancellable, callback, user_data);
@@ -928,6 +976,14 @@ fp_device_verify (FpDevice           *device,
       return;
     }
 
+  if (!cls->verify || !(cls->features & FPI_DEVICE_FEATURE_VERIFY))
+    {
+      g_task_return_error (task,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
+                                                     "Device has no verification support"));
+      return;
+    }
+
   priv->current_action = FPI_DEVICE_ACTION_VERIFY;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
@@ -941,7 +997,7 @@ fp_device_verify (FpDevice           *device,
   // Attach the match data as task data so that it is destroyed
   g_task_set_task_data (priv->current_task, data, (GDestroyNotify) match_data_free);
 
-  FP_DEVICE_GET_CLASS (device)->verify (device);
+  cls->verify (device);
 }
 
 /**
@@ -1038,6 +1094,14 @@ fp_device_identify (FpDevice           *device,
       return;
     }
 
+  if (!fp_device_supports_identify (device))
+    {
+      g_task_return_error (task,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
+                                                     "Device has not identification support"));
+      return;
+    }
+
   priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
@@ -1127,6 +1191,7 @@ fp_device_capture (FpDevice           *device,
 {
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpDeviceClass *cls = FP_DEVICE_GET_CLASS (device);
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
@@ -1146,13 +1211,21 @@ fp_device_capture (FpDevice           *device,
       return;
     }
 
+  if (!cls->capture || !(cls->features & FPI_DEVICE_FEATURE_CAPTURE))
+    {
+      g_task_return_error (task,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
+                                                     "Device has no verification support"));
+      return;
+    }
+
   priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
   priv->wait_for_finger = wait_for_finger;
 
-  FP_DEVICE_GET_CLASS (device)->capture (device);
+  cls->capture (device);
 }
 
 /**
@@ -1201,6 +1274,7 @@ fp_device_delete_print (FpDevice           *device,
 {
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpDeviceClass *cls = FP_DEVICE_GET_CLASS (device);
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
@@ -1221,7 +1295,7 @@ fp_device_delete_print (FpDevice           *device,
     }
 
   /* Succeed immediately if delete is not implemented. */
-  if (!FP_DEVICE_GET_CLASS (device)->delete)
+  if (!cls->delete || !(cls->features & FPI_DEVICE_FEATURE_STORAGE_DELETE))
     {
       g_task_return_boolean (task, TRUE);
       return;
@@ -1235,7 +1309,7 @@ fp_device_delete_print (FpDevice           *device,
                         g_object_ref (enrolled_print),
                         g_object_unref);
 
-  FP_DEVICE_GET_CLASS (device)->delete (device);
+  cls->delete (device);
 }
 
 /**

libfprint/fp-device.h

@@ -38,10 +38,12 @@ G_DECLARE_DERIVABLE_TYPE (FpDevice, fp_device, FP, DEVICE, GObject)
 /**
  * FpDeviceType:
  * @FP_DEVICE_TYPE_VIRTUAL: The device is a virtual device
+ * @FP_DEVICE_TYPE_UDEV: The device is a udev device
  * @FP_DEVICE_TYPE_USB: The device is a USB device
  */
 typedef enum {
   FP_DEVICE_TYPE_VIRTUAL,
+  FP_DEVICE_TYPE_UDEV,
   FP_DEVICE_TYPE_USB,
 } FpDeviceType;
 
@@ -92,7 +94,6 @@ typedef enum {
  * @FP_DEVICE_ERROR_DATA_FULL: No space on device available for operation
  * @FP_DEVICE_ERROR_DATA_DUPLICATE: Enrolling template duplicates storaged templates
  * @FP_DEVICE_ERROR_REMOVED: The device has been removed.
- * @FP_DEVICE_ERROR_UNTRUSTED: Device cannot be trusted
  *
  * Error codes for device operations. More specific errors from other domains
  * such as #G_IO_ERROR or #G_USB_DEVICE_ERROR may also be reported.
@@ -110,7 +111,6 @@ typedef enum {
   FP_DEVICE_ERROR_DATA_DUPLICATE,
   /* Leave some room to add more DATA related errors */
   FP_DEVICE_ERROR_REMOVED = 0x100,
-  FP_DEVICE_ERROR_UNTRUSTED,
 } FpDeviceError;
 
 GQuark fp_device_retry_quark (void);

libfprint/fp-image-device.c

@@ -190,9 +190,7 @@ fp_image_device_constructed (GObject *obj)
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
 
-  /* Set default values. */
-  fpi_device_set_nr_enroll_stages (FP_DEVICE (self), IMG_ENROLL_STAGES);
-
+  /* Set default threshold. */
   priv->bz3_threshold = BOZORTH3_DEFAULT_THRESHOLD;
   if (cls->bz3_threshold > 0)
     priv->bz3_threshold = cls->bz3_threshold;
@@ -210,6 +208,9 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
   object_class->get_property = fp_image_device_get_property;
   object_class->constructed = fp_image_device_constructed;
 
+  /* Set default enroll stage count. */
+  fp_device_class->nr_enroll_stages = IMG_ENROLL_STAGES;
+
   fp_device_class->open = fp_image_device_open;
   fp_device_class->close = fp_image_device_close;
   fp_device_class->enroll = fp_image_device_start_capture_action;
@@ -219,6 +220,8 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
 
   fp_device_class->cancel = fp_image_device_cancel_action;
 
+  fpi_device_class_auto_initialize_features (fp_device_class);
+
   /* Default implementations */
   klass->activate = fp_image_device_default_activate;
   klass->deactivate = fp_image_device_default_deactivate;

libfprint/fp-print.c

@@ -281,7 +281,7 @@ fp_print_class_init (FpPrintClass *klass)
                        "Type",
                        "Private: The type of the print data",
                        FPI_TYPE_PRINT_TYPE,
-                       FPI_PRINT_UNDEFINED,
+                       FPI_PRINT_RAW,
                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
 
   /**
@@ -582,7 +582,7 @@ fp_print_equal (FpPrint *self, FpPrint *other)
   if (g_strcmp0 (self->device_id, other->device_id))
     return FALSE;
 
-  if (self->type == FPI_PRINT_RAW || self->type == FPI_PRINT_SDCP)
+  if (self->type == FPI_PRINT_RAW)
     {
       return g_variant_equal (self->data, other->data);
     }
@@ -847,7 +847,7 @@ fp_print_deserialize (const guchar *data,
           g_ptr_array_add (result->prints, g_steal_pointer (&xyt));
         }
     }
-  else if (type == FPI_PRINT_RAW || type == FPI_PRINT_SDCP)
+  else if (type == FPI_PRINT_RAW)
     {
       g_autoptr(GVariant) fp_data = g_variant_get_child_value (print_data, 0);
 

libfprint/fp-sdcp-device-private.h

@@ -1,58 +0,0 @@
-/*
- * FpSdcpDevice - A base class for SDCP enabled devices
- * Copyright (C) 2020 Benjamin Berg <bberg@redhat.com>
- *
- * This library 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 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include "fpi-sdcp-device.h"
-
-#include <nss.h>
-#include <keyhi.h>
-#include <keythi.h>
-#include <pk11pub.h>
-
-typedef struct
-{
-  GError *enroll_pre_commit_error;
-
-  /* XXX: Do we want a separate SDCP session object?
-   */
-
-  GPtrArray *intermediate_cas;
-
-  /* Host random for the connection */
-  guint8            host_random[32];
-
-  NSSInitContext   *nss_init_context;
-  PK11SlotInfo     *slot;
-  SECKEYPrivateKey *host_key_private;
-  SECKEYPublicKey  *host_key_public;
-
-  /* Master secret is required for reconnects.
-   * TODO: We probably want to serialize this to disk so it can survive
-   *       fprintd idle shutdown. */
-  PK11SymKey *master_secret;
-  PK11SymKey *mac_secret;
-
-} FpSdcpDevicePrivate;
-
-void fpi_sdcp_device_connect (FpSdcpDevice *self);
-void fpi_sdcp_device_reconnect (FpSdcpDevice *self);
-
-void fpi_sdcp_device_enroll (FpSdcpDevice *self);
-void fpi_sdcp_device_identify (FpSdcpDevice *self);

libfprint/fp-sdcp-device.c

@@ -1,141 +0,0 @@
-/*
- * FpSdcpDevice - A base class for SDCP enabled devices
- * Copyright (C) 2020 Benjamin Berg <bberg@redhat.com>
- *
- * This library 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 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#define FP_COMPONENT "sdcp_device"
-#include "fpi-log.h"
-
-#include "fp-sdcp-device-private.h"
-
-/**
- * SECTION: fp-sdcp-device
- * @title: FpSdcpDevice
- * @short_description: SDCP device subclass
- *
- * This is a base class for devices implementing the SDCP security protocol.
- */
-
-G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpSdcpDevice, fp_sdcp_device, FP_TYPE_DEVICE)
-
-#if 0
-/* XXX: We'll very likely want/need some properties on this class. */
-enum {
-  PROP_0,
-  N_PROPS
-};
-
-static GParamSpec *properties[N_PROPS];
-#endif
-
-/*******************************************************/
-
-/* Callbacks/vfuncs */
-static void
-fp_sdcp_device_open (FpDevice *device)
-{
-  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
-  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
-
-  /* Try a reconnect if we still have the mac secret. */
-  if (priv->mac_secret)
-    fpi_sdcp_device_reconnect (self);
-  else
-    fpi_sdcp_device_connect (self);
-}
-
-static void
-fp_sdcp_device_enroll (FpDevice *device)
-{
-  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
-
-  fpi_sdcp_device_enroll (self);
-}
-
-static void
-fp_sdcp_device_identify (FpDevice *device)
-{
-  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
-
-  fpi_sdcp_device_identify (self);
-}
-
-/*********************************************************/
-
-static void
-fp_sdcp_device_finalize (GObject *object)
-{
-  FpSdcpDevice *self = (FpSdcpDevice *) object;
-  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
-
-  g_clear_pointer (&priv->intermediate_cas, g_ptr_array_unref);
-  g_clear_pointer (&priv->slot, PK11_FreeSlot);
-  g_clear_pointer (&priv->host_key_private, SECKEY_DestroyPrivateKey);
-  g_clear_pointer (&priv->host_key_public, SECKEY_DestroyPublicKey);
-  g_clear_pointer (&priv->master_secret, PK11_FreeSymKey);
-  g_clear_pointer (&priv->mac_secret, PK11_FreeSymKey);
-  g_clear_pointer (&priv->nss_init_context, NSS_ShutdownContext);
-
-  G_OBJECT_CLASS (fp_sdcp_device_parent_class)->finalize (object);
-}
-
-static void
-fp_sdcp_device_get_property (GObject    *object,
-                             guint       prop_id,
-                             GValue     *value,
-                             GParamSpec *pspec)
-{
-  switch (prop_id)
-    {
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-    }
-}
-
-static void
-fp_sdcp_device_constructed (GObject *obj)
-{
-  G_OBJECT_CLASS (fp_sdcp_device_parent_class)->constructed (obj);
-}
-
-static void
-fp_sdcp_device_class_init (FpSdcpDeviceClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  FpDeviceClass *fp_device_class = FP_DEVICE_CLASS (klass);
-
-  object_class->finalize = fp_sdcp_device_finalize;
-  object_class->get_property = fp_sdcp_device_get_property;
-  object_class->constructed = fp_sdcp_device_constructed;
-
-  fp_device_class->open = fp_sdcp_device_open;
-  fp_device_class->enroll = fp_sdcp_device_enroll;
-  fp_device_class->verify = fp_sdcp_device_identify;
-  fp_device_class->identify = fp_sdcp_device_identify;
-
-#if 0
-  g_object_class_install_properties (object_class, N_PROPS, properties);
-#endif
-}
-
-static void
-fp_sdcp_device_init (FpSdcpDevice *self)
-{
-  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
-
-  priv->intermediate_cas = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
-}

libfprint/fp-sdcp-device.h

@@ -1,29 +0,0 @@
-/*
- * FpSdcpDevice - A base class for SDCP enabled devices
- * Copyright (C) 2020 Benjamin Berg <bberg@redhat.com>
- *
- * This library 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 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include <fp-device.h>
-
-G_BEGIN_DECLS
-
-#define FP_TYPE_SDCP_DEVICE (fp_sdcp_device_get_type ())
-G_DECLARE_DERIVABLE_TYPE (FpSdcpDevice, fp_sdcp_device, FP, SDCP_DEVICE, FpDevice)
-
-G_END_DECLS

libfprint/fpi-assembling.h

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include <fprint.h>
+#include "fp-image.h"
 
 /**
  * fpi_frame:

libfprint/fpi-device.c

@@ -46,6 +46,40 @@ fp_device_get_instance_private (FpDevice *self)
                             g_type_class_get_instance_private_offset (dev_class));
 }
 
+/**
+ * fpi_device_class_auto_initialize_features:
+ *
+ * Initializes the #FpDeviceClass @features flags checking what device vfuncs
+ * are implemented.
+ * Drivers should call this at the end of the class initialization.
+ */
+void
+fpi_device_class_auto_initialize_features (FpDeviceClass *device_class)
+{
+  g_return_if_fail (FP_IS_DEVICE_CLASS (device_class));
+
+  if (device_class->capture)
+    device_class->features |= FPI_DEVICE_FEATURE_CAPTURE;
+
+  if (device_class->verify)
+    device_class->features |= FPI_DEVICE_FEATURE_VERIFY;
+
+  if (device_class->identify)
+    device_class->features |= FPI_DEVICE_FEATURE_IDENTIFY;
+
+  if (device_class->list)
+    {
+      device_class->features |= FPI_DEVICE_FEATURE_STORAGE;
+      device_class->features |= FPI_DEVICE_FEATURE_STORAGE_LIST;
+    }
+
+  if (device_class->delete)
+    {
+      device_class->features |= FPI_DEVICE_FEATURE_STORAGE;
+      device_class->features |= FPI_DEVICE_FEATURE_STORAGE_DELETE;
+    }
+}
+
 /**
  * fpi_device_retry_new:
  * @error: The #FpDeviceRetry error value describing the issue
@@ -143,10 +177,6 @@ fpi_device_error_new (FpDeviceError error)
       msg = "This device has been removed from the system.";
       break;
 
-    case FP_DEVICE_ERROR_UNTRUSTED:
-      msg = "Could not verify integrity of the device, it cannot be trusted!";
-      break;
-
     default:
       g_warning ("Unsupported error, returning general error instead!");
       error = FP_DEVICE_ERROR_GENERAL;
@@ -339,6 +369,38 @@ fpi_device_get_usb_device (FpDevice *device)
   return priv->usb_device;
 }
 
+/**
+ * fpi_device_get_udev_data:
+ * @device: The #FpDevice
+ * @subtype: Which subtype to get information about
+ *
+ * Get a subtype-specific hardware resource for this #FpDevice. Only permissible to call if the
+ * #FpDevice is of type %FP_DEVICE_TYPE_UDEV.
+ *
+ * Returns: Depends on @subtype; for SPIDEV/HIDRAW returns a path to the relevant device.
+ */
+gpointer
+fpi_device_get_udev_data (FpDevice *device, FpiDeviceUdevSubtypeFlags subtype)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_val_if_fail (FP_IS_DEVICE (device), NULL);
+  g_return_val_if_fail (priv->type == FP_DEVICE_TYPE_UDEV, NULL);
+
+  switch (subtype)
+    {
+    case FPI_DEVICE_UDEV_SUBTYPE_HIDRAW:
+      return priv->udev_data.hidraw_path;
+
+    case FPI_DEVICE_UDEV_SUBTYPE_SPIDEV:
+      return priv->udev_data.spidev_path;
+
+    default:
+      g_return_val_if_reached (NULL);
+      return NULL;
+    }
+}
+
 /**
  * fpi_device_get_virtual_env:
  * @device: The #FpDevice
@@ -981,6 +1043,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
       break;
 
     case FP_DEVICE_TYPE_VIRTUAL:
+    case FP_DEVICE_TYPE_UDEV:
       break;
 
     default:

libfprint/fpi-device.h

@@ -24,6 +24,18 @@
 #include "fp-image.h"
 #include "fpi-print.h"
 
+#include <config.h>
+
+/**
+ * FpiDeviceUdevSubtype:
+ * @FPI_DEVICE_UDEV_SUBTYPE_SPIDEV: The device requires an spidev node
+ * @FPI_DEVICE_UDEV_SUBTYPE_HIDRAW: The device requires a hidraw node
+ */
+typedef enum {
+  FPI_DEVICE_UDEV_SUBTYPE_SPIDEV = 1 << 0,
+  FPI_DEVICE_UDEV_SUBTYPE_HIDRAW = 1 << 1,
+} FpiDeviceUdevSubtypeFlags;
+
 /**
  * FpIdEntry:
  *
@@ -43,10 +55,44 @@ struct _FpIdEntry
       guint vid;
     };
     const gchar *virtual_envvar;
+    struct
+    {
+      FpiDeviceUdevSubtypeFlags udev_types;
+      const gchar              *spi_acpi_id;
+      struct
+      {
+        guint pid;
+        guint vid;
+      } hid_id;
+    };
   };
   guint64 driver_data;
 };
 
+/**
+ * FpiDeviceFeature:
+ * @FPI_DEVICE_FEATURE_NONE: Device does not support any feature
+ * @FPI_DEVICE_FEATURE_CAPTURE: Supports image capture
+ * @FPI_DEVICE_FEATURE_IDENTIFY: Supports finger identification
+ * @FPI_DEVICE_FEATURE_VERIFY: Supports finger verification
+ * @FPI_DEVICE_FEATURE_STORAGE: Device has a persistent storage
+ * @FPI_DEVICE_FEATURE_STORAGE_LIST: Supports listing the storage templates
+ * @FPI_DEVICE_FEATURE_STORAGE_DELETE: Supports deleting stored templates
+ * @FPI_DEVICE_FEATURE_STORAGE_CLEAR: Supports clearing the whole storage
+ * @FPI_DEVICE_FEATURE_DUPLICATES_CHECK: Natively supports duplicates detection
+ */
+typedef enum /*< flags >*/ {
+  FPI_DEVICE_FEATURE_NONE = 0,
+  FPI_DEVICE_FEATURE_CAPTURE = 1 << 0,
+  FPI_DEVICE_FEATURE_IDENTIFY = 1 << 1,
+  FPI_DEVICE_FEATURE_VERIFY = 1 << 2,
+  FPI_DEVICE_FEATURE_STORAGE = 1 << 3,
+  FPI_DEVICE_FEATURE_STORAGE_LIST = 1 << 4,
+  FPI_DEVICE_FEATURE_STORAGE_DELETE = 1 << 5,
+  FPI_DEVICE_FEATURE_STORAGE_CLEAR = 1 << 6,
+  FPI_DEVICE_FEATURE_DUPLICATES_CHECK = 1 << 7,
+} FpiDeviceFeature;
+
 /**
  * FpDeviceClass:
  * @id: ID string for the driver. Should be a valid C identifier and should
@@ -54,6 +100,8 @@ struct _FpIdEntry
  * @full_name: Human readable description of the driver
  * @type: The type of driver
  * @id_table: The table of IDs to bind the driver to
+ * @features: The features the device supports, it can be initialized using
+ *   fpi_device_class_auto_initialize_features() on @class_init.
  * @nr_enroll_stages: The number of enroll stages supported devices need; use
  *   fpi_device_set_nr_enroll_stages() from @probe if this is dynamic.
  * @scan_type: The scan type of supported devices; use
@@ -111,6 +159,7 @@ struct _FpDeviceClass
   const gchar     *full_name;
   FpDeviceType     type;
   const FpIdEntry *id_table;
+  FpiDeviceFeature features;
 
   /* Defaults for device properties */
   gint       nr_enroll_stages;
@@ -131,6 +180,8 @@ struct _FpDeviceClass
   void (*cancel)   (FpDevice *device);
 };
 
+void fpi_device_class_auto_initialize_features (FpDeviceClass *device_class);
+
 /**
  * FpTimeoutFunc:
  * @device: The #FpDevice passed to fpi_device_add_timeout()
@@ -171,6 +222,8 @@ typedef enum {
 
 GUsbDevice  *fpi_device_get_usb_device (FpDevice *device);
 const gchar *fpi_device_get_virtual_env (FpDevice *device);
+gpointer     fpi_device_get_udev_data (FpDevice                 *device,
+                                       FpiDeviceUdevSubtypeFlags subtype);
 //const gchar *fpi_device_get_spi_dev (FpDevice *device);
 
 

libfprint/fpi-image-device.c

@@ -306,7 +306,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
                                   g_steal_pointer (&print), error);
 
       /* Start another scan or deactivate. */
-      if (priv->enroll_stage == IMG_ENROLL_STAGES)
+      if (priv->enroll_stage == fp_device_get_nr_enroll_stages (device))
         {
           fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
           fpi_image_device_deactivate (self, FALSE);

libfprint/fpi-print.h

@@ -11,13 +11,11 @@ G_BEGIN_DECLS
  * @FPI_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
  * @FPI_PRINT_RAW: A raw print where the data is directly compared
  * @FPI_PRINT_NBIS: NBIS minutiae comparison
- * @FPI_PRINT_SDCP: Print from an SDCP conforming device
  */
 typedef enum {
   FPI_PRINT_UNDEFINED = 0,
   FPI_PRINT_RAW,
   FPI_PRINT_NBIS,
-  FPI_PRINT_SDCP,
 } FpiPrintType;
 
 /**

libfprint/fpi-sdcp-device.h

@@ -1,142 +0,0 @@
-/*
- * FpSdcpDevice - A base class for SDCP enabled devices
- * Copyright (C) 2020 Benjamin Berg <bberg@redhat.com>
- *
- * This library 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 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include <glib-2.0/glib.h>
-#include "fpi-device.h"
-#include "fp-sdcp-device.h"
-
-/**
- * FpiSdcpClaim:
- * @cert_m: The per-model ECDSA certificate (x509 ASN.1 DER encoded)
- * @pk_d: The device public key (65 bytes)
- * @pk_f: The firmware public key (65 bytes)
- * @h_f: The firmware hash
- * @s_m: Signature over @pk_d using the per-model private key (64 bytes)
- * @s_d: Signature over h_f and pk_f using the device private key (64 bytes)
- *
- * Structure to hold the claim as produced by the device during a secure
- * connect. See the SDCP specification for more details.
- *
- * Note all of these may simply be memory views into a larger #GBytes created
- * using g_bytes_new_from_bytes().
- */
-struct _FpiSdcpClaim
-{
-  /*< public >*/
-  GBytes *cert_m;
-  GBytes *pk_d;
-  GBytes *pk_f;
-  GBytes *h_f;
-  GBytes *s_m;
-  GBytes *s_d;
-};
-typedef struct _FpiSdcpClaim FpiSdcpClaim;
-
-GType          fpi_sdcp_claim_get_type (void) G_GNUC_CONST;
-FpiSdcpClaim  *fpi_sdcp_claim_new (void);
-FpiSdcpClaim  *fpi_sdcp_claim_copy (FpiSdcpClaim *other);
-void           fpi_sdcp_claim_free (FpiSdcpClaim *claim);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSdcpClaim, fpi_sdcp_claim_free)
-
-
-/**
- * FpSdcpDeviceClass:
- * @connect: Establish SDCP connection. Similar to open in #FpDeviceClass
- *   but called connect to mirror the SDCP specification.
- * @reconnect: Perform a faster reconnect. Drivers do not need to provide this
- *   function. If reconnect fails, then a normal connect will be tried.
- * @enroll_begin: Start the enrollment procedure. In the absence of an error,
- *   the driver must call fpi_sdcp_device_enroll_set_nonce() at any point. It
- *   also must report enrollment progress using fpi_device_enroll_progress().
- *   It should also store available metadata about the print in device memory.
- *   The operation is completed with fpi_sdcp_device_enroll_ready().
- * @enroll_commit: Complete the enrollment procedure. This commits the newly
- *   enrolled print to the device memory. Will only be called if enroll_begin
- *   succeeded. The passed id may be %NULL, in that case the driver must
- *   abort the enrollment process. id is owned by the base class and remains
- *   valid throughout the operation.
- * @identify: Start identification process. On completion, the driver must call
- *   fpi_sdcp_device_identify_complete(). To request the user to retry the
- *   fpi_sdcp_device_identify_retry() function is used.
- *
- *
- * These are the main entry points for drivers implementing SDCP.
- *
- * Drivers *must* eventually call the corresponding function to finish the
- * operation.
- *
- * XXX: Is the use of fpi_device_action_error() acceptable?
- *
- * Drivers *must* also handle cancellation properly for any long running
- * operation (i.e. any operation that requires capturing). It is entirely fine
- * to ignore cancellation requests for short operations (e.g. open/close).
- *
- * This API is solely intended for drivers. It is purely internal and neither
- * API nor ABI stable.
- */
-struct _FpSdcpDeviceClass
-{
-  FpDeviceClass parent_class;
-
-  void          (*connect)       (FpSdcpDevice *dev);
-  void          (*reconnect)     (FpSdcpDevice *dev);
-  void          (*close)         (FpSdcpDevice *dev);
-  void          (*enroll_begin)  (FpSdcpDevice *dev);
-  void          (*enroll_commit) (FpSdcpDevice *dev,
-                                  GBytes       *id);
-  void          (*identify)      (FpSdcpDevice *dev);
-};
-
-void fpi_sdcp_device_set_intermediat_cas (FpSdcpDevice *self,
-                                          GBytes       *ca_1,
-                                          GBytes       *ca_2);
-
-void fpi_sdcp_device_get_connect_data (FpSdcpDevice *self,
-                                       GBytes      **r_h,
-                                       GBytes      **pk_h);
-void fpi_sdcp_device_connect_complete (FpSdcpDevice *self,
-                                       GBytes       *r_d,
-                                       FpiSdcpClaim *claim,
-                                       GBytes       *mac,
-                                       GError       *error);
-
-void fpi_sdcp_device_get_reconnect_data (FpSdcpDevice *self,
-                                         GBytes      **r_h);
-void fpi_sdcp_device_reconnect_complete (FpSdcpDevice *self,
-                                         GBytes       *mac,
-                                         GError       *error);
-
-void fpi_sdcp_device_enroll_set_nonce (FpSdcpDevice *self,
-                                       GBytes       *nonce);
-void fpi_sdcp_device_enroll_ready (FpSdcpDevice *self,
-                                   GError       *error);
-void fpi_sdcp_device_enroll_commit_complete (FpSdcpDevice *self,
-                                             GError       *error);
-
-void fpi_sdcp_device_get_identify_data (FpSdcpDevice *self,
-                                        GBytes      **nonce);
-void fpi_sdcp_device_identify_retry (FpSdcpDevice *self,
-                                     GError       *error);
-void fpi_sdcp_device_identify_complete (FpSdcpDevice *self,
-                                        GBytes       *id,
-                                        GBytes       *mac,
-                                        GError       *error);

libfprint/fpi-spi-transfer.c

@@ -0,0 +1,432 @@
+/*
+ * FPrint SPI transfer handling
+ * Copyright (C) 2019-2020 Benjamin Berg <bberg@redhat.com>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "fpi-spi-transfer.h"
+#include <sys/ioctl.h>
+#include <linux/spi/spidev.h>
+#include <errno.h>
+
+/**
+ * SECTION:fpi-spi-transfer
+ * @title: SPI transfer helpers
+ * @short_description: Helpers to ease SPI transfers
+ *
+ * #FpiSpiTransfer is a structure to simplify the SPI transfer handling
+ * for the linux spidev device. The main goal are to ease memory management
+ * and provide a usable asynchronous API to libfprint drivers.
+ *
+ * Currently only transfers with a write and subsequent read are supported.
+ *
+ * Drivers should always use this API rather than calling read/write/ioctl on
+ * the spidev device.
+ *
+ * Setting G_MESSAGES_DEBUG and FP_DEBUG_TRANSFER will result in the message
+ * content to be dumped.
+ */
+
+
+G_DEFINE_BOXED_TYPE (FpiSpiTransfer, fpi_spi_transfer, fpi_spi_transfer_ref, fpi_spi_transfer_unref)
+
+static void
+dump_buffer (guchar *buf, gssize dump_len)
+{
+  g_autoptr(GString) line = NULL;
+
+  line = g_string_new ("");
+  /* Dump the buffer. */
+  for (gssize i = 0; i < dump_len; i++)
+    {
+      g_string_append_printf (line, "%02x ", buf[i]);
+      if ((i + 1) % 16 == 0)
+        {
+          g_debug ("%s", line->str);
+          g_string_set_size (line, 0);
+        }
+    }
+
+  if (line->len)
+    g_debug ("%s", line->str);
+}
+
+static void
+log_transfer (FpiSpiTransfer *transfer, gboolean submit, GError *error)
+{
+  if (g_getenv ("FP_DEBUG_TRANSFER"))
+    {
+      if (submit)
+        {
+          g_debug ("Transfer %p submitted, write length %zd, read length %zd",
+                   transfer,
+                   transfer->length_wr,
+                   transfer->length_rd);
+
+          if (transfer->buffer_wr)
+            dump_buffer (transfer->buffer_wr, transfer->length_wr);
+        }
+      else
+        {
+          g_autofree gchar *error_str = NULL;
+          if (error)
+            error_str = g_strdup_printf ("with error (%s)", error->message);
+          else
+            error_str = g_strdup ("successfully");
+
+          g_debug ("Transfer %p completed %s, write length %zd, read length %zd",
+                   transfer,
+                   error_str,
+                   transfer->length_wr,
+                   transfer->length_rd);
+          if (transfer->buffer_rd)
+            dump_buffer (transfer->buffer_rd, transfer->length_rd);
+        }
+    }
+}
+
+/**
+ * fpi_spi_transfer_new:
+ * @device: The #FpDevice the transfer is for
+ * @spidev_fd: The file descriptor for the spidev device
+ *
+ * Creates a new #FpiSpiTransfer.
+ *
+ * Returns: (transfer full): A newly created #FpiSpiTransfer
+ */
+FpiSpiTransfer *
+fpi_spi_transfer_new (FpDevice * device, int spidev_fd)
+{
+  FpiSpiTransfer *self;
+
+  g_assert (FP_IS_DEVICE (device));
+
+  self = g_slice_new0 (FpiSpiTransfer);
+  self->ref_count = 1;
+
+  /* Purely to enhance the debug log output. */
+  self->length_wr = -1;
+  self->length_rd = -1;
+
+  self->device = device;
+  self->spidev_fd = spidev_fd;
+
+  return self;
+}
+
+static void
+fpi_spi_transfer_free (FpiSpiTransfer *self)
+{
+  g_assert (self);
+  g_assert_cmpint (self->ref_count, ==, 0);
+
+  if (self->free_buffer_wr && self->buffer_wr)
+    self->free_buffer_wr (self->buffer_wr);
+  if (self->free_buffer_rd && self->buffer_rd)
+    self->free_buffer_rd (self->buffer_rd);
+  self->buffer_wr = NULL;
+  self->buffer_rd = NULL;
+
+  g_slice_free (FpiSpiTransfer, self);
+}
+
+/**
+ * fpi_spi_transfer_ref:
+ * @self: A #FpiSpiTransfer
+ *
+ * Increments the reference count of @self by one.
+ *
+ * Returns: (transfer full): @self
+ */
+FpiSpiTransfer *
+fpi_spi_transfer_ref (FpiSpiTransfer *self)
+{
+  g_return_val_if_fail (self, NULL);
+  g_return_val_if_fail (self->ref_count, NULL);
+
+  g_atomic_int_inc (&self->ref_count);
+
+  return self;
+}
+
+/**
+ * fpi_spi_transfer_unref:
+ * @self: A #FpiSpiTransfer
+ *
+ * Decrements the reference count of @self by one, freeing the structure when
+ * the reference count reaches zero.
+ */
+void
+fpi_spi_transfer_unref (FpiSpiTransfer *self)
+{
+  g_return_if_fail (self);
+  g_return_if_fail (self->ref_count);
+
+  if (g_atomic_int_dec_and_test (&self->ref_count))
+    fpi_spi_transfer_free (self);
+}
+
+/**
+ * fpi_spi_transfer_write:
+ * @transfer: The #FpiSpiTransfer
+ * @length: The buffer size to allocate
+ *
+ * Prepare the write part of an SPI transfer allocating a new buffer
+ * internally that will be free'ed automatically.
+ */
+void
+fpi_spi_transfer_write (FpiSpiTransfer *transfer,
+                        gsize           length)
+{
+  fpi_spi_transfer_write_full (transfer,
+                               g_malloc0 (length),
+                               length,
+                               g_free);
+}
+
+/**
+ * fpi_spi_transfer_write_full:
+ * @transfer: The #FpiSpiTransfer
+ * @buffer: The data to write.
+ * @length: The size of @buffer
+ * @free_func: (destroy buffer): Destroy notify for @buffer
+ *
+ * Prepare the write part of an SPI transfer.
+ */
+void
+fpi_spi_transfer_write_full (FpiSpiTransfer *transfer,
+                             guint8         *buffer,
+                             gsize           length,
+                             GDestroyNotify  free_func)
+{
+  g_assert (buffer != NULL);
+  g_return_if_fail (transfer);
+
+  /* Write is always before read, so ensure both are NULL. */
+  g_return_if_fail (transfer->buffer_wr == NULL);
+  g_return_if_fail (transfer->buffer_rd == NULL);
+
+  transfer->buffer_wr = buffer;
+  transfer->length_wr = length;
+  transfer->free_buffer_wr = free_func;
+}
+
+/**
+ * fpi_spi_transfer_read:
+ * @transfer: The #FpiSpiTransfer
+ * @length: The buffer size to allocate
+ *
+ * Prepare the read part of an SPI transfer allocating a new buffer
+ * internally that will be free'ed automatically.
+ */
+void
+fpi_spi_transfer_read (FpiSpiTransfer *transfer,
+                       gsize           length)
+{
+  fpi_spi_transfer_read_full (transfer,
+                              g_malloc0 (length),
+                              length,
+                              g_free);
+}
+
+/**
+ * fpi_spi_transfer_read_full:
+ * @transfer: The #FpiSpiTransfer
+ * @buffer: Buffer to read data into.
+ * @length: The size of @buffer
+ * @free_func: (destroy buffer): Destroy notify for @buffer
+ *
+ * Prepare the read part of an SPI transfer.
+ */
+void
+fpi_spi_transfer_read_full (FpiSpiTransfer *transfer,
+                            guint8         *buffer,
+                            gsize           length,
+                            GDestroyNotify  free_func)
+{
+  g_assert (buffer != NULL);
+  g_return_if_fail (transfer);
+  g_return_if_fail (transfer->buffer_rd == NULL);
+
+  transfer->buffer_rd = buffer;
+  transfer->length_rd = length;
+  transfer->free_buffer_rd = free_func;
+}
+
+static void
+transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+  GTask *task = G_TASK (res);
+  FpiSpiTransfer *transfer = g_task_get_task_data (task);
+  GError *error = NULL;
+  FpiSpiTransferCallback callback;
+
+  g_task_propagate_boolean (task, &error);
+
+  log_transfer (transfer, FALSE, error);
+
+  callback = transfer->callback;
+  transfer->callback = NULL;
+  callback (transfer, transfer->device, transfer->user_data, error);
+}
+
+static void
+transfer_thread_func (GTask        *task,
+                      gpointer      source_object,
+                      gpointer      task_data,
+                      GCancellable *cancellable)
+{
+  FpiSpiTransfer *transfer = (FpiSpiTransfer *) task_data;
+  struct spi_ioc_transfer xfer[2];
+  int transfers = 0;
+  int status;
+
+  if (transfer->buffer_wr == NULL && transfer->buffer_rd == NULL)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_INVALID_ARGUMENT,
+                               "Transfer with neither write or read!");
+      return;
+    }
+
+  memset (xfer, 0, sizeof (xfer));
+
+  if (transfer->buffer_wr)
+    {
+      xfer[transfers].tx_buf = (guint64) transfer->buffer_wr;
+      xfer[transfers].len = transfer->length_wr;
+
+      transfers += 1;
+    }
+
+  if (transfer->buffer_rd)
+    {
+      xfer[transfers].rx_buf = (guint64) transfer->buffer_rd;
+      xfer[transfers].len = transfer->length_rd;
+
+      transfers += 1;
+    }
+
+  /* This ioctl cannot be interrupted. */
+  status = ioctl (transfer->spidev_fd, SPI_IOC_MESSAGE (transfers), xfer);
+
+  if (status < 0)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               g_io_error_from_errno (errno),
+                               "Error invoking ioctl for SPI transfer (%d)",
+                               errno);
+    }
+  else
+    {
+      g_task_return_boolean (task, TRUE);
+    }
+}
+
+/**
+ * fpi_spi_transfer_submit:
+ * @transfer: (transfer full): The transfer to submit, must have been filled.
+ * @cancellable: Cancellable to use, e.g. fpi_device_get_cancellable()
+ * @callback: Callback on completion or error
+ * @user_data: Data to pass to callback
+ *
+ * Submit an SPI transfer with a specific timeout and callback functions.
+ *
+ * The underlying transfer cannot be cancelled. The current implementation
+ * will only call @callback after the transfer has been completed.
+ *
+ * Note that #FpiSpiTransfer will be stolen when this function is called.
+ * So that all associated data will be free'ed automatically, after the
+ * callback ran unless fpi_usb_transfer_ref() is explicitly called.
+ */
+void
+fpi_spi_transfer_submit (FpiSpiTransfer        *transfer,
+                         GCancellable          *cancellable,
+                         FpiSpiTransferCallback callback,
+                         gpointer               user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  g_return_if_fail (transfer);
+  g_return_if_fail (callback);
+
+  /* Recycling is allowed, but not two at the same time. */
+  g_return_if_fail (transfer->callback == NULL);
+
+  transfer->callback = callback;
+  transfer->user_data = user_data;
+
+  log_transfer (transfer, TRUE, NULL);
+
+  task = g_task_new (transfer->device,
+                     cancellable,
+                     transfer_finish_cb,
+                     NULL);
+  g_task_set_task_data (task,
+                        g_steal_pointer (&transfer),
+                        (GDestroyNotify) fpi_spi_transfer_unref);
+
+  g_task_run_in_thread (task, transfer_thread_func);
+}
+
+/**
+ * fpi_spi_transfer_submit_sync:
+ * @transfer: The transfer to submit, must have been filled.
+ * @error: Location to store #GError to
+ *
+ * Synchronously submit an SPI transfer. Use of this function is discouraged
+ * as it will block all other operations in the application.
+ *
+ * Note that you still need to fpi_spi_transfer_unref() the
+ * #FpiSpiTransfer afterwards.
+ *
+ * Returns: #TRUE on success, otherwise #FALSE and @error will be set
+ */
+gboolean
+fpi_spi_transfer_submit_sync (FpiSpiTransfer *transfer,
+                              GError        **error)
+{
+  g_autoptr(GTask) task = NULL;
+  GError *err = NULL;
+  gboolean res;
+
+  g_return_val_if_fail (transfer, FALSE);
+
+  /* Recycling is allowed, but not two at the same time. */
+  g_return_val_if_fail (transfer->callback == NULL, FALSE);
+
+  log_transfer (transfer, TRUE, NULL);
+
+  task = g_task_new (transfer->device,
+                     NULL,
+                     NULL,
+                     NULL);
+  g_task_set_task_data (task,
+                        fpi_spi_transfer_ref (transfer),
+                        (GDestroyNotify) fpi_spi_transfer_unref);
+
+  g_task_run_in_thread_sync (task, transfer_thread_func);
+
+  res = g_task_propagate_boolean (task, &err);
+
+  log_transfer (transfer, FALSE, err);
+
+  g_propagate_error (error, err);
+
+  return res;
+}

libfprint/fpi-spi-transfer.h

@@ -0,0 +1,113 @@
+/*
+ * FPrint spidev transfer handling
+ * Copyright (C) 2019-2020 Benjamin Berg <bberg@redhat.com>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+#include "fpi-compat.h"
+#include "fpi-device.h"
+
+G_BEGIN_DECLS
+
+#define FPI_TYPE_SPI_TRANSFER (fpi_spi_transfer_get_type ())
+
+typedef struct _FpiSpiTransfer FpiSpiTransfer;
+typedef struct _FpiSsm         FpiSsm;
+
+typedef void (*FpiSpiTransferCallback)(FpiSpiTransfer *transfer,
+                                       FpDevice       *dev,
+                                       gpointer        user_data,
+                                       GError         *error);
+
+/**
+ * FpiSpiTransfer:
+ * @device: The #FpDevice that the transfer belongs to.
+ * @ssm: Storage slot to associate the transfer with a state machine.
+ *   Used by fpi_ssm_spi_transfer_cb() to modify the given state machine.
+ * @length_wr: The length of the write buffer
+ * @length_rd: The length of the read buffer
+ * @buffer_wr: The write buffer.
+ * @buffer_rd: The read buffer.
+ *
+ * Helper for handling SPI transfers. Currently transfers can either be pure
+ * write/read transfers or a write followed by a read (full duplex support
+ * can easily be added if desired).
+ */
+struct _FpiSpiTransfer
+{
+  /*< public >*/
+  FpDevice *device;
+
+  FpiSsm   *ssm;
+
+  gssize    length_wr;
+  gssize    length_rd;
+
+  guchar   *buffer_wr;
+  guchar   *buffer_rd;
+
+  /*< private >*/
+  guint ref_count;
+
+  int   spidev_fd;
+
+  /* Callbacks */
+  gpointer               user_data;
+  FpiSpiTransferCallback callback;
+
+  /* Data free function */
+  GDestroyNotify free_buffer_wr;
+  GDestroyNotify free_buffer_rd;
+};
+
+GType              fpi_spi_transfer_get_type (void) G_GNUC_CONST;
+FpiSpiTransfer     *fpi_spi_transfer_new (FpDevice *device,
+                                          int       spidev_fd);
+FpiSpiTransfer     *fpi_spi_transfer_ref (FpiSpiTransfer *self);
+void               fpi_spi_transfer_unref (FpiSpiTransfer *self);
+
+void               fpi_spi_transfer_write (FpiSpiTransfer *transfer,
+                                           gsize           length);
+
+FP_GNUC_ACCESS (read_only, 2, 3)
+void               fpi_spi_transfer_write_full (FpiSpiTransfer *transfer,
+                                                guint8         *buffer,
+                                                gsize           length,
+                                                GDestroyNotify  free_func);
+
+void               fpi_spi_transfer_read (FpiSpiTransfer *transfer,
+                                          gsize           length);
+
+FP_GNUC_ACCESS (write_only, 2, 3)
+void               fpi_spi_transfer_read_full (FpiSpiTransfer *transfer,
+                                               guint8         *buffer,
+                                               gsize           length,
+                                               GDestroyNotify  free_func);
+
+void               fpi_spi_transfer_submit (FpiSpiTransfer        *transfer,
+                                            GCancellable          *cancellable,
+                                            FpiSpiTransferCallback callback,
+                                            gpointer               user_data);
+
+gboolean           fpi_spi_transfer_submit_sync (FpiSpiTransfer *transfer,
+                                                 GError        **error);
+
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSpiTransfer, fpi_spi_transfer_unref)
+
+G_END_DECLS

libfprint/fpi-ssm.c

@@ -181,6 +181,22 @@ fpi_ssm_get_data (FpiSsm *machine)
   return machine->ssm_data;
 }
 
+/**
+ * fpi_ssm_get_device:
+ * @machine: an #FpiSsm state machine
+ *
+ * Retrieve the device that the SSM is for.
+ *
+ * Returns: #FpDevice
+ */
+FpDevice *
+fpi_ssm_get_device (FpiSsm *machine)
+{
+  g_return_val_if_fail (machine, NULL);
+
+  return machine->dev;
+}
+
 static void
 fpi_ssm_clear_delayed_action (FpiSsm *machine)
 {
@@ -617,20 +633,6 @@ fpi_ssm_jump_to_state_delayed (FpiSsm       *machine,
   g_source_set_name (machine->timeout, source_name);
 }
 
-/**
- * fpi_ssm_get_device:
- * @machine: an #FpiSsm state machine
- *
- * Returns the device that the SSM has been associated with.
- *
- * Returns: (transfer none): the #FpDevice.
- */
-FpDevice *
-fpi_ssm_get_device (FpiSsm *machine)
-{
-  return machine->dev;
-}
-
 /**
  * fpi_ssm_get_cur_state:
  * @machine: an #FpiSsm state machine
@@ -735,3 +737,56 @@ fpi_ssm_usb_transfer_with_weak_pointer_cb (FpiUsbTransfer *transfer,
 
   fpi_ssm_usb_transfer_cb (transfer, device, weak_ptr, error);
 }
+
+/**
+ * fpi_ssm_spi_transfer_cb:
+ * @transfer: a #FpiSpiTransfer
+ * @device: a #FpDevice
+ * @unused_data: User data (unused)
+ * @error: The #GError or %NULL
+ *
+ * Can be used in as a #FpiSpiTransfer callback handler to automatically
+ * advance or fail a statemachine on transfer completion.
+ *
+ * Make sure to set the #FpiSsm on the transfer.
+ */
+void
+fpi_ssm_spi_transfer_cb (FpiSpiTransfer *transfer, FpDevice *device,
+                         gpointer unused_data, GError *error)
+{
+  g_return_if_fail (transfer->ssm);
+
+  if (error)
+    fpi_ssm_mark_failed (transfer->ssm, error);
+  else
+    fpi_ssm_next_state (transfer->ssm);
+}
+
+/**
+ * fpi_ssm_spi_transfer_with_weak_pointer_cb:
+ * @transfer: a #FpiSpiTransfer
+ * @device: a #FpDevice
+ * @weak_ptr: A #gpointer pointer to nullify. You can pass a pointer to any
+ *            #gpointer to nullify when the callback is completed. I.e a
+ *            pointer to the current #FpiSpiTransfer.
+ * @error: The #GError or %NULL
+ *
+ * Can be used in as a #FpiSpiTransfer callback handler to automatically
+ * advance or fail a statemachine on transfer completion.
+ * Passing a #gpointer* as @weak_ptr permits to nullify it once we're done
+ * with the transfer.
+ *
+ * Make sure to set the #FpiSsm on the transfer.
+ */
+void
+fpi_ssm_spi_transfer_with_weak_pointer_cb (FpiSpiTransfer *transfer,
+                                           FpDevice *device, gpointer weak_ptr,
+                                           GError *error)
+{
+  g_return_if_fail (transfer->ssm);
+
+  if (weak_ptr)
+    g_nullify_pointer ((gpointer *) weak_ptr);
+
+  fpi_ssm_spi_transfer_cb (transfer, device, weak_ptr, error);
+}

libfprint/fpi-ssm.h

@@ -92,9 +92,8 @@ void fpi_ssm_mark_failed (FpiSsm *machine,
 void fpi_ssm_set_data (FpiSsm        *machine,
                        gpointer       ssm_data,
                        GDestroyNotify ssm_data_destroy);
-
-FpDevice * fpi_ssm_get_device (FpiSsm *machine);
 gpointer fpi_ssm_get_data (FpiSsm *machine);
+FpDevice * fpi_ssm_get_device (FpiSsm *machine);
 GError * fpi_ssm_get_error (FpiSsm *machine);
 GError * fpi_ssm_dup_error (FpiSsm *machine);
 int fpi_ssm_get_cur_state (FpiSsm *machine);
@@ -113,4 +112,15 @@ void fpi_ssm_usb_transfer_with_weak_pointer_cb (FpiUsbTransfer *transfer,
                                                 gpointer        weak_ptr,
                                                 GError         *error);
 
+typedef struct _FpiSpiTransfer FpiSpiTransfer;
+
+void fpi_ssm_spi_transfer_cb (FpiSpiTransfer *transfer,
+                              FpDevice       *device,
+                              gpointer        unused_data,
+                              GError         *error);
+void fpi_ssm_spi_transfer_with_weak_pointer_cb (FpiSpiTransfer *transfer,
+                                                FpDevice       *device,
+                                                gpointer        weak_ptr,
+                                                GError         *error);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSsm, fpi_ssm_free)

libfprint/fprint-list-supported-devices.c

@@ -83,8 +83,6 @@ main (int argc, char **argv)
   g_print ("\n");
   g_print ("This is a list of supported devices in libfprint's development version. Those drivers might not all be available in the stable, released version. If in doubt, contact your distribution or systems integrator for details.\n");
   g_print ("\n");
-  g_print ("The quality and functionality of drivers varies widely. libfprint maintainers may not be able to help with issues arising from their use.\n");
-  g_print ("\n");
   g_print ("## USB devices\n");
   g_print ("\n");
   g_print ("USB ID | Driver\n");

libfprint/fprint-list-udev-hwdb.c

@@ -35,6 +35,7 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x04f3, .pid = 0x0c4c },
   { .vid = 0x04f3, .pid = 0x0c4f },
   { .vid = 0x04f3, .pid = 0x0c57 },
+  { .vid = 0x04f3, .pid = 0x0c5e },
   { .vid = 0x04f3, .pid = 0x2706 },
   { .vid = 0x06cb, .pid = 0x0081 },
   { .vid = 0x06cb, .pid = 0x0088 },
@@ -45,13 +46,18 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x06cb, .pid = 0x00b7 },
   { .vid = 0x06cb, .pid = 0x00bb },
   { .vid = 0x06cb, .pid = 0x00be },
+  { .vid = 0x06cb, .pid = 0x00c4 },
   { .vid = 0x06cb, .pid = 0x00cb },
   { .vid = 0x06cb, .pid = 0x00d8 },
   { .vid = 0x06cb, .pid = 0x00da },
   { .vid = 0x0a5c, .pid = 0x5801 },
   { .vid = 0x0a5c, .pid = 0x5805 },
   { .vid = 0x0a5c, .pid = 0x5834 },
+  { .vid = 0x0a5c, .pid = 0x5840 },
+  { .vid = 0x0a5c, .pid = 0x5841 },
+  { .vid = 0x0a5c, .pid = 0x5842 },
   { .vid = 0x0a5c, .pid = 0x5843 },
+  { .vid = 0x0a5c, .pid = 0x5845 },
   { .vid = 0x10a5, .pid = 0x0007 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },
@@ -60,7 +66,6 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x138a, .pid = 0x003d },
   { .vid = 0x138a, .pid = 0x003f },
   { .vid = 0x138a, .pid = 0x0090 },
-  { .vid = 0x138a, .pid = 0x0091 },
   { .vid = 0x138a, .pid = 0x0092 },
   { .vid = 0x138a, .pid = 0x0094 },
   { .vid = 0x138a, .pid = 0x0097 },

libfprint/meson.build

@@ -16,6 +16,7 @@ libfprint_private_sources = [
     'fpi-print.c',
     'fpi-ssm.c',
     'fpi-usb-transfer.c',
+    'fpi-spi-transfer.c',
 ]
 
 libfprint_public_headers = [
@@ -40,6 +41,7 @@ libfprint_private_headers = [
     'fpi-minutiae.h',
     'fpi-print.h',
     'fpi-usb-transfer.h',
+    'fpi-spi-transfer.h',
     'fpi-ssm.h',
 ]
 
@@ -78,147 +80,126 @@ nbis_sources = [
     'nbis/mindtct/xytreps.c',
 ]
 
-driver_sources = {
-    'upekts' :
-        [ 'drivers/upekts.c', 'drivers/upek_proto.c' ],
-    'upektc' :
-        [ 'drivers/upektc.c' ],
-    'upeksonly' :
-        [ 'drivers/upeksonly.c' ],
-    'uru4000' :
-        [ 'drivers/uru4000.c' ],
-    'aes1610' :
-        [ 'drivers/aes1610.c' ],
-    'aes1660' :
-        [ 'drivers/aes1660.c' ],
-    'aes2501' :
-        [ 'drivers/aes2501.c' ],
-    'aes2550' :
-        [ 'drivers/aes2550.c' ],
-    'aes2660' :
-        [ 'drivers/aes2660.c' ],
-    'aes3500' :
-        [ 'drivers/aes3500.c' ],
-    'aes4000' :
-        [ 'drivers/aes4000.c' ],
-    'vcom5s' :
-        [ 'drivers/vcom5s.c' ],
-    'vfs101' :
-        [ 'drivers/vfs101.c' ],
-    'vfs301' :
-        [ 'drivers/vfs301.c', 'drivers/vfs301_proto.c' ],
-    'vfs5011' :
-        [ 'drivers/vfs5011.c' ],
-    'upektc_img' :
-        [ 'drivers/upektc_img.c',  'drivers/upek_proto.c' ],
-    'etes603' :
-        [ 'drivers/etes603.c' ],
-    'vfs0050' :
-        [ 'drivers/vfs0050.c' ],
-    'elan' :
-        [ 'drivers/elan.c' ],
-    'virtual_image' :
-        [ 'drivers/virtual-image.c' ],
-    'virtual_device' :
-        [ 'drivers/virtual-device.c' ],
-    'virtual_device_storage' :
-        [ 'drivers/virtual-device-storage.c' ],
-    'virtual_sdcp' :
-        [ 'drivers/virtual-sdcp.c' ],
-    'synaptics' :
-        [ 'drivers/synaptics/synaptics.c', 'drivers/synaptics/bmkt_message.c' ],
-    'goodixmoc' :
-        [ 'drivers/goodixmoc/goodix.c', 'drivers/goodixmoc/goodix_proto.c' ],
-}
-
-helper_sources = {
-    'sdcp' :
-        [ 'fp-sdcp-device.c', 'fpi-sdcp-device.c' ],
-    'aeslib' :
-        [ 'drivers/aeslib.c' ],
-    'aesx660' :
-        [ 'drivers/aesx660.c' ],
-    'aes3k' :
-        [ 'drivers/aes3k.c' ],
-    'virtual' :
-        [ 'drivers/virtual-device-listener.c' ],
-}
-
-driver_helpers = {
-    'aes1610' : [ 'aeslib' ],
-    'aes1660' : [ 'aeslib', 'aesx660' ],
-    'aes2501' : [ 'aeslib' ],
-    'aes2550' : [ 'aeslib' ],
-    'aes2660' : [ 'aeslib', 'aesx660' ],
-    'aes3500' : [ 'aeslib', 'aes3k' ],
-    'aes4000' : [ 'aeslib', 'aes3k' ],
-    'virtual_image'          : [ 'virtual' ],
-    'virtual_device'         : [ 'virtual' ],
-    'virtual_device_storage' : [ 'virtual' ],
-    'virtual_sdcp' : [ 'sdcp' ],
-}
-
-helpers = []
-foreach driver : drivers
-    if driver in driver_helpers
-        foreach helper : driver_helpers[driver]
-            if helper not in helpers
-                helpers += helper
-            endif
-        endforeach
-    endif
-endforeach
-
+aeslib = false
+aesx660 = false
+aes3k = false
 drivers_sources = []
 drivers_cflags = []
 foreach driver: drivers
-    drivers_sources += driver_sources[driver]
-endforeach
-foreach helper : helpers
-    drivers_sources += helper_sources[helper]
-endforeach
-
-optional_deps = []
-
-# Resolve extra dependencies
-foreach i : helpers + drivers
-    driver = i
-    foreach d, helper : driver_helpers
-        if i in helpers
-            driver = d
-            break
-        endif
-    endforeach
-
-    if i == 'aes3k'
-        imaging_dep = dependency('pixman-1', required: false)
-        if not imaging_dep.found()
-            error('pixman is required for @0@ and possibly others'.format(driver))
-        endif
-
-        libfprint_conf.set10('HAVE_PIXMAN', true)
-        optional_deps += imaging_dep
-    elif i == 'uru4000'
-        nss_dep = dependency('nss', required: false)
-        if not nss_dep.found()
-            error('nss is required for uru4000')
-        endif
-
-        optional_deps += nss_dep
-    elif i == 'sdcp'
-        nss_dep = dependency('nss', version: '>=3.55', required: false)
-        if not nss_dep.found()
-            error('nss >=3.55 is required for SDCP support (@0@ and possibly others)'.format(driver))
-        endif
-
-        optional_deps += nss_dep
-    else
-       deps = []
-       continue
+    if driver == 'upekts'
+        drivers_sources += [ 'drivers/upekts.c', 'drivers/upek_proto.c' ]
+    endif
+    if driver == 'upektc'
+        drivers_sources += [ 'drivers/upektc.c' ]
+    endif
+    if driver == 'upeksonly'
+        drivers_sources += [ 'drivers/upeksonly.c' ]
+    endif
+    if driver == 'uru4000'
+        drivers_sources += [ 'drivers/uru4000.c' ]
+    endif
+    if driver == 'aes1610'
+        drivers_sources += [ 'drivers/aes1610.c' ]
+        aeslib = true
+    endif
+    if driver == 'aes1660'
+        drivers_sources += [ 'drivers/aes1660.c' ]
+        aeslib = true
+        aesx660 = true
+    endif
+    if driver == 'aes2501'
+        drivers_sources += [ 'drivers/aes2501.c' ]
+        aeslib = true
+    endif
+    if driver == 'aes2550'
+        drivers_sources += [ 'drivers/aes2550.c' ]
+        aeslib = true
+    endif
+    if driver == 'aes2660'
+        drivers_sources += [ 'drivers/aes2660.c' ]
+        aeslib = true
+        aesx660 = true
+    endif
+    if driver == 'aes3500'
+        drivers_sources += [ 'drivers/aes3500.c' ]
+        aeslib = true
+        aes3k = true
+    endif
+    if driver == 'aes4000'
+        drivers_sources += [ 'drivers/aes4000.c' ]
+        aeslib = true
+        aes3k = true
+    endif
+    if driver == 'vcom5s'
+        drivers_sources += [ 'drivers/vcom5s.c' ]
+    endif
+    if driver == 'vfs101'
+        drivers_sources += [ 'drivers/vfs101.c' ]
+    endif
+    if driver == 'vfs301'
+        drivers_sources += [ 'drivers/vfs301.c', 'drivers/vfs301_proto.c' ]
+    endif
+    if driver == 'vfs5011'
+        drivers_sources += [ 'drivers/vfs5011.c' ]
+    endif
+    if driver == 'vfs7552'
+        drivers_sources += [ 'drivers/vfs7552.c' ]
+    endif
+    if driver == 'upektc_img'
+        drivers_sources += [ 'drivers/upektc_img.c',  'drivers/upek_proto.c' ]
+    endif
+    if driver == 'etes603'
+        drivers_sources += [ 'drivers/etes603.c' ]
+    endif
+    if driver == 'vfs0050'
+        drivers_sources += [ 'drivers/vfs0050.c' ]
+    endif
+    if driver == 'elan'
+        drivers_sources += [ 'drivers/elan.c' ]
+    endif
+    if driver == 'virtual_image'
+        drivers_sources += [ 'drivers/virtual-image.c' ]
+    endif
+    if driver == 'virtual_device'
+        drivers_sources += [ 'drivers/virtual-device.c' ]
+    endif
+    if driver == 'virtual_device_storage'
+        drivers_sources += [ 'drivers/virtual-device-storage.c' ]
+    endif
+    if driver.startswith('virtual_')
+        drivers_sources += [ 'drivers/virtual-device-listener.c' ]
+    endif
+    if driver == 'synaptics'
+    drivers_sources += [
+        'drivers/synaptics/synaptics.c',
+        'drivers/synaptics/bmkt_message.c',
+    ]
+    endif
+    if driver == 'goodixmoc'
+    drivers_sources += [
+        'drivers/goodixmoc/goodix.c',
+        'drivers/goodixmoc/goodix_proto.c',
+    ]
+    endif
+    if driver == 'nb1010'
+    drivers_sources += [
+        'drivers/nb1010.c',
+    ]
     endif
-
 endforeach
 
+if aeslib
+    drivers_sources += [ 'drivers/aeslib.c' ]
+endif
+if aesx660
+    drivers_sources += ['drivers/aesx660.c' ]
+endif
+if aes3k
+    drivers_sources += ['drivers/aes3k.c' ]
+endif
+
+other_sources = []
+
 fp_enums = gnome.mkenums_simple('fp-enums',
     sources: libfprint_public_headers,
     install_header: true,
@@ -236,28 +217,6 @@ enums_dep = declare_dependency(
     sources: [ fp_enums_h, fpi_enums_h ]
 )
 
-# Export the drivers' types to the core code
-drivers_type_list = []
-drivers_type_func = []
-drivers_type_list += '#include <glib-object.h>'
-drivers_type_list += '#include "fpi-context.h"'
-drivers_type_list += ''
-drivers_type_func += 'GArray *'
-drivers_type_func += 'fpi_get_driver_types (void)'
-drivers_type_func += '{'
-drivers_type_func += '  GArray *drivers = g_array_new (TRUE, FALSE, sizeof (GType));'
-drivers_type_func += '  GType t;'
-drivers_type_func += ''
-foreach driver: supported_drivers
-    drivers_type_list += 'extern GType (fpi_device_' + driver + '_get_type) (void);'
-    drivers_type_func += '  t = fpi_device_' + driver + '_get_type ();'
-    drivers_type_func += '  g_array_append_val (drivers, t);'
-    drivers_type_func += ''
-endforeach
-drivers_type_list += ''
-drivers_type_func += '  return drivers;'
-drivers_type_func += '}'
-
 drivers_sources += configure_file(input: 'empty_file',
     output: 'fpi-drivers.c',
     capture: true,
@@ -272,8 +231,11 @@ deps = [
     glib_dep,
     gobject_dep,
     gusb_dep,
+    gudev_dep,
+    imaging_dep,
     mathlib_dep,
-] + optional_deps
+    nss_dep,
+]
 
 # These are empty and only exist so that the include directories are created
 # in the build tree. This silences a build time warning.
@@ -320,6 +282,7 @@ libfprint = shared_library(versioned_libname.split('lib')[1],
     sources: [
         fp_enums,
         libfprint_sources,
+        other_sources,
     ],
     soversion: soversion,
     version: libversion,

meson.build

@@ -92,11 +92,15 @@ virtual_drivers = [
     'virtual_image',
     'virtual_device',
     'virtual_device_storage',
-    'virtual_sdcp',
 ]
+
+udev_drivers = [
+]
+
 default_drivers = [
     'upektc_img',
     'vfs5011',
+    'vfs7552',
     'aes3500',
     'aes4000',
     'aes1610',
@@ -116,6 +120,7 @@ default_drivers = [
     'upeksonly',
     'upekts',
     'goodixmoc',
+    'nb1010'
 ]
 
 # FIXME: All the drivers should be fixed by adjusting the byte order.
@@ -125,7 +130,7 @@ endian_independent_drivers = virtual_drivers + [
     'synaptics',
 ]
 
-all_drivers = default_drivers + virtual_drivers
+all_drivers = default_drivers + virtual_drivers + udev_drivers
 
 if drivers == [ 'all' ]
     drivers = all_drivers
@@ -151,6 +156,38 @@ else
     endforeach
 endif
 
+nss_dep = dependency('', required: false)
+imaging_dep = dependency('', required: false)
+gudev_dep = dependency('', required: false)
+libfprint_conf.set10('HAVE_PIXMAN', false)
+foreach driver: drivers
+    if driver == 'uru4000'
+        nss_dep = dependency('nss', required: false)
+        if not nss_dep.found()
+            error('NSS is required for the URU4000/URU4500 driver')
+        endif
+    endif
+    if driver == 'aes3500' or driver == 'aes4000'
+        imaging_dep = dependency('pixman-1', required: false)
+        if not imaging_dep.found()
+            error('pixman is required for imaging support')
+        endif
+
+        libfprint_conf.set10('HAVE_PIXMAN', true)
+    endif
+	if udev_drivers.contains(driver)
+		gudev_dep = dependency('gudev-1.0', required: false)
+		if not gudev_dep.found()
+			error('udev is required for SPI support')
+		endif
+
+		libfprint_conf.set10('HAVE_UDEV', true)
+	endif
+    if not all_drivers.contains(driver)
+        error('Invalid driver \'' + driver + '\'')
+    endif
+endforeach
+
 supported_drivers = []
 foreach driver: drivers
     if build_machine.endian() == 'little' or driver in endian_independent_drivers
@@ -165,17 +202,51 @@ if default_drivers_are_enabled and supported_drivers != drivers
     default_drivers_are_enabled = false
 endif
 
+# Export the drivers' types to the core code
+drivers_type_list = []
+drivers_type_func = []
+drivers_type_list += '#include <glib-object.h>'
+drivers_type_list += '#include "fpi-context.h"'
+drivers_type_list += ''
+drivers_type_func += 'GArray *'
+drivers_type_func += 'fpi_get_driver_types (void)'
+drivers_type_func += '{'
+drivers_type_func += '  GArray *drivers = g_array_new (TRUE, FALSE, sizeof (GType));'
+drivers_type_func += '  GType t;'
+drivers_type_func += ''
+foreach driver: supported_drivers
+    drivers_type_list += 'extern GType (fpi_device_' + driver + '_get_type) (void);'
+    drivers_type_func += '  t = fpi_device_' + driver + '_get_type ();'
+    drivers_type_func += '  g_array_append_val (drivers, t);'
+    drivers_type_func += ''
+endforeach
+drivers_type_list += ''
+drivers_type_func += '  return drivers;'
+drivers_type_func += '}'
+
 root_inc = include_directories('.')
 
-if get_option('udev_rules')
+udev_hwdb = get_option('udev_hwdb')
+if not udev_hwdb.disabled()
+    # systemd v248 includes our autosuspend rules
+    udev_versioned_dep = dependency('udev', version: '>= 248', required: false)
     udev_hwdb_dir = get_option('udev_hwdb_dir')
+    if udev_hwdb.auto()
+        if udev_versioned_dep.found()
+            udev_hwdb_dir = ''
+        endif
+    else
+        if udev_versioned_dep.found()
+            warning('udev hwdb will be installed by both systemd and libfprint')
+        endif
+    endif
 
     if udev_hwdb_dir == 'auto'
         udev_dep = dependency('udev')
         udev_hwdb_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/hwdb.d'
     endif
 else
-    udev_hwdb_dir = false
+    udev_hwdb_dir = ''
 endif
 
 if get_option('gtk-examples')
@@ -187,11 +258,9 @@ if get_option('gtk-examples')
     endif
 endif
 
-# Some dependency resolving happens inside here
-subdir('libfprint')
-
 configure_file(output: 'config.h', configuration: libfprint_conf)
 
+subdir('libfprint')
 subdir('examples')
 if get_option('doc')
     gnome = import('gnome')

meson_options.txt

@@ -6,10 +6,10 @@ option('introspection',
        description: 'Build GObject Introspection repository',
        type: 'boolean',
        value: true)
-option('udev_rules',
-       description: 'Whether to create a udev rules file',
-       type: 'boolean',
-       value: true)
+option('udev_hwdb',
+       description: 'Whether to create a udev hwdb',
+       type: 'feature',
+       value: 'auto')
 option('udev_hwdb_dir',
        description: 'Installation path for udev hwdb',
        type: 'string',
@@ -22,8 +22,3 @@ option('doc',
        description: 'Whether to build the API documentation',
        type: 'boolean',
        value: true)
-
-option('sdcp_virt_binary',
-       description: 'Path to virtual SDCP test binary, please refer to CI for more details.',
-       type: 'string',
-       value: '')

scripts/uncrustify.sh

@@ -12,11 +12,8 @@ case "$1" in
         ;;
 esac
 
-ARGS=4
-JOBS=4
-
 pushd "$SRCROOT"
-git ls-tree --name-only -r HEAD | grep -E '.*\.[ch]$' | grep -v nbis | grep -v fpi-byte | grep -v build/ | xargs -n$ARGS -P $JOBS uncrustify -c "$CFG" $OPTS
+uncrustify -c "$CFG" $OPTS `git ls-tree --name-only -r HEAD | grep -E '.*\.[ch]$' | grep -v nbis | grep -v fpi-byte | grep -v build/`
 RES=$?
 popd
-exit $RES
+exit $RES

tests/meson.build

@@ -12,9 +12,6 @@ envs.prepend('LD_LIBRARY_PATH', join_paths(meson.build_root(), 'libfprint'))
 # random numbers rather than proper ones)
 envs.set('FP_DEVICE_EMULATION', '1')
 
-# Path to SDCP virtual device binary, only used for virtual-sdcp test
-envs.set('SDCP_VIRT_BINARY', get_option('sdcp_virt_binary'))
-
 # Set a colon-separated list of native drivers we enable in tests
 envs.set('FP_DRIVERS_WHITELIST', ':'.join([
     'virtual_image',
@@ -31,7 +28,9 @@ drivers_tests = [
     'vfs0050',
     'vfs301',
     'vfs5011',
+    'vfs7552',
     'goodixmoc',
+    'nb1010',
 ]
 
 if get_option('introspection')
@@ -72,7 +71,6 @@ if get_option('introspection')
                     suite: ut_suite,
                     depends: libfprint_typelib,
                     env: envs,
-                    workdir: meson.current_source_dir(),
                 )
             endforeach
         else
@@ -83,46 +81,6 @@ if get_option('introspection')
         endif
     endforeach
 
-    if 'virtual_sdcp' in drivers and get_option('sdcp_virt_binary') != ''
-        python3 = find_program('python3')
-        unittest_inspector = find_program('unittest_inspector.py')
-        base_args = files('virtual-sdcp.py')
-        suite = []
-
-        r = run_command(unittest_inspector, files('virtual-sdcp.py'))
-        unit_tests = r.stdout().strip().split('\n')
-
-        if r.returncode() == 0 and unit_tests.length() > 0
-            suite += 'virtual-sdcp'
-        else
-            unit_tests = ['virtual-sdcp']
-        endif
-
-        sdcp_envs = envs
-        sdcp_envs.set('FP_DEVICE_EMULATION', '0')
-        foreach ut: unit_tests
-            ut_suite = suite
-            ut_args = base_args
-            if unit_tests.length() > 1
-                ut_args += ut
-                ut_suite += ut.split('.')[0]
-            endif
-            test(ut,
-                python3,
-                args: ut_args,
-                suite: ut_suite,
-                depends: libfprint_typelib,
-                env: sdcp_envs,
-                workdir: meson.current_source_dir(),
-            )
-        endforeach
-    else
-        test('virtual-sdcp',
-            find_program('sh'),
-            args: ['-c', 'exit 77']
-        )
-    endif
-
     foreach driver_test: drivers_tests
         driver_envs = envs
         driver_envs.set('FP_DRIVERS_WHITELIST', driver_test)
@@ -133,7 +91,6 @@ if get_option('introspection')
                 find_program('umockdev-test.py'),
                 args: join_paths(meson.current_source_dir(), driver_test),
                 env: driver_envs,
-                workdir: meson.current_source_dir(),
                 suite: ['drivers'],
                 timeout: 10,
                 depends: libfprint_typelib,

tests/nb1010/capture.ioctl

@@ -0,0 +1,98 @@
+@DEV /dev/bus/usb/001/003
+USBDEVFS_GET_CAPABILITIES 0 FD010000
+USBDEVFS_REAPURBNDELAY 0 3 2 0 0 8 8 0 8038010008000000
+ USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 803701001000000000000000F7000000
+USBDEVFS_REAPURBNDELAY 0 3 2 0 0 12 12 0 800D03000C00000000040000
+ USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 80200300100000000000000000000000
+USBDEVFS_REAPURBNDELAY 0 3 2 0 0 32 32 0 8012040020000000020000000000000000000000000000000000000020000000
+ USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 80200400100000000000000003000000
+  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000010000000001000001E5E5E5E5E5E4E4E4E5E5E5E4E6E7E6E6BEE6E4E5E4E3E5E6E3E4E4E3E5E6E4E5E6E5E5E5E4E4E5E5E3E3E2E3E3E4E4E4E4E5E5E5E2E2E3C9E2E4E3E4E3E3E4E4E8E8E7E8E5E5E3E4E5E3E4E5E3E4E5E3E4E4E5E5E3E4E4E4E4E5E5E5E3E3E2E3E4E3E3E3E2E3E3E3E3E5E5E5E5E5E4E5E3E4E4E3E5E66AE3E4E5E4E5E5E4E4E5E4E2E2E3E6E5E5E4E4E3E5E3E6E6E7E6E4E4E3E2E5E5E5E6E4E6E5E2E2E3E2E3E4E3E3E4E5E3E5E5E5E3E4E4E6E4E5E5E4E3E4E2E3E5E4E4E5E6E4E5E2E3E2E3E2E3E4E4E5E4E3E3E5E6E6E6E4E4E3E3E6E5E5E6E5E5E5E6E5E5E5E5E5E4E0E4E4E3E2E3E3E3E2E4E3E4E4E5E5E4E5E6E2E3E3E2E4E4E4E3E4E2E4E6E4E5E4E4E6E6E7E7E6E7E6E7E8E6E7E7E8E8E8E8E7E6E7E6E7E5E7E7E7E7E7E6E6E4E4E6E3E4E3E4E4E3E3E4E2E3E4E3E4E3E4E5E3E5E4E5E4E4E3E2E5E5E5E4E5E6E7E6E4E5E4E5E6E7E7E8E2E3E4E4E7E5E7E6E6E3E4E5E7E7E7E8E6E5E6E6E6E5E5E6E6E5E6E4E4E5E4E4E7E7E5E5E5E6E4E7E7E6E5E6E4E4E6E6E6E6E5E5E5E5E5E5E5E4E5E6E4E5E6E6E4E4E5E4E4E6E6E6E6E6E6E5E6E7E7E6E5E7E5E5E7E6E5E7E5E5E7E5E6E4E5E6E7E6E5E7E4E5E5E5E8E6E7E0E6E6E7E7E8E8E9E9E3E5E5E4E6E5E6E7E6E5E5E6E6E5E5E6E5E4E4E3E6E6E6E6E5E4E3E4E6E7E6E5E6E7E5E5E6E6E7E7E7E7E8E6E7E5E7E5E7E6E7E8E6E6E7E5E5E5E5E5E5E2E6E5E7E6E7E7000000
+   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000030000000001000001E7E7E7E7E6E6E6E6E7E7E7E8E8E8E6E8E9E7E8E9E0E4E5E4E8E7E8E7E5E4E4E5E6E1E5E5E7E6E6E6E6E5E4E4E5E4E3E5E5E6E4E5E4E5E5E5E2E6E4E3E5E5E5E6E6E6E5E5E6E5E6E6E7E6E6E7E5E4E5E5E4E5E5E7E7E7E7E7E5E4E4E4E4E3E3E3E5E5E6E5E6E6E5E5E4E4E4E2E6E6E4E5E6E6E8E6E7E6E5E8E6E6E4E5E6E6E7E6E6E6E6E6E6E6E6E5E5E7E5E5E5E6E6E7E5E6E5E5E5E5E5E4E6E6E8E6E0E6E6E7E7E7E8E8E6E6E7E6E7E6E8E6E6E5E6E6E7E6E6E5E5E6E4E5E6E5E6E6E6E4E6E5E7E6E6E6E2E6E7E6E6E5E5E6E7E7E6E5E5E5E6E5E7E7E6E6E5E3E5E3DEE5E6E5E4E5E2E5E6E5E4E5E6E4E5E5E5E5E4E4E6E6E7E7E6E7E6E5E6E4E6E5E4E5E3E4E8E6E7E6E8E7E7E9E7E5E7E9E6E6E5E7E8E7E7E7E7E6E6E6E7E6E7E5E3E4E6E5E4E4E4E6E4E5E3E7DDE5E6E5E6E5E5E7E3E4E5E4E4E5E4E5E3E3DCE4E6E5E6E7E4E4E4E6E5E4E7E7E4E4E3E5E6E6E7E7E5E4E6E5E4E4E5E5E6E5E5E5E6E6E5E6E3E6E5E6E4E2E2E4E5E6E4E4E4E5E4E5E9E9E8E7E6E6E7E7E8E7E7E7E5E4E5E3E6E8E7E7E5E5E3E4E4E5E3E4E5E5E5E5E6E5E4E5E6E7E7E7E5E7E6E6E4E6E6E6E5E4E094E5E6E6E6E7E5E6E5E7E6E7E6E5E6E6E7E7E6E6E6E6E7E8E7E7E5E5E6E6E6E8E6E6E5E5E7E7E7E6E7E5E7E5E5E8E8E7E7E7E5E7E4E6E5E4E6E5E7E4E5E7E6E6E6E7E5E6E6E6E4E6E6E5E7E6E6E5E5E3E6E8E7E6E7E4E2E4E4E6E6E7E6000000
+    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000050000000001000001E6E6E6E6E8E7E7E7E8E6E7E8E9E8E8E8E8E8E8E9E7E6E6E9E6E7E4E6E5E5E6E5E5E6E7E6E6E5E6E6E4E5E4E4E3E5E2E4E5E4E4E5DDE3E4B5E5E7E6E5E5E6E5E1E6E7E7E7E5E6E7E5E5E5E5E5E6E5D6E5A1E4E6E6E4E5E4E3E4E4E4E5E4E5E4E5E6E6E6E6E7E7E6E7E4E4E5E4E6E5E4E6E47AE5E5E7E7E6E7E4E4E5E3E6E4E5E5E4E4E2E3E6E7E7E4E5E6E7E6E6E7E6E7E5E6E6E4E6E7E6E5D4E7E8E7E3E4E5E4E6E6E5E7E5E4E5E3E3E5E7E6E4E3E4E6E6E7E7E7E4E4E5E4E6E7E6E8E7E6E6E7E9E8E9E9E7E6E6E6E4E6E5E4E6E6E7E4E6E6E7E6E7E6E6E5E4E4E5E5E6E5E6E4E6E6E5E6E6E4E5E5E5E6E5E7E6E6E6E7E5E6E5E5E7E6E8E6E4E4E5E5E5E6E5E5E8E8E7E7E6E6E6E6E8E6E8EAE7E9E8E8E8E8E8E9E6E6E7E6E4E5E6E4E5E4E3E5E5E5E5E5E4E5E48B80E4E5E0E7E5E8E6E4E5E5E5E6E2D2E6E7E6E5E6E2E3E5E3E6E8E417D4E3E6E6E6E4E5E5E6E4E6E6E5E6E5E5E7E7E6E7E6E5E4E5E4E5E4E6E7E6E7E7E5E4E6E3E6E4E5E780E6E5E6E4E4E3E4E4E5E6E4E5E5E5E4E7E7E7E6E4E5E4E5E6E1E8E8E6E7E7E8E7E5E5E6E0E5E5D0E4E4E3E4E7E4E6E5E3E4E4E5E5E6E5E6E5E4E3E3DEE2E6E6E5E5E5E4E2E4E6E692E7E6E6E4E6E5E5E3E5E5E6E4E4E4E5E4E5E5E6E6E4E5E6E7E5E5E6E5E5E5E5E6E5E5E5E7E5E7E7E6E6E6E6E6E6E5E6E4E4E5E4E5E6E4E4E6E5E5E6E6E7E7E5E4E5E4E5E6E3E5E5E3E5E5E5000000
+     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000070000000001000001E5E5E5E5E7E7E8E7E4E8E8E9E9E7E8E8E9E8E9E8E6E8E7E659E5E5E578E5E5E4E5E4E5E5E3AFE4E2E4E0E3E5E0E3E5E5E6E6E7E6E3CDE4E3E6E400E1E3E4E6E3E8E7E6E7E4E3E5E4E5E5E5E5E5E6E5E6E6E6E5E7E4E5E4E5E5E5E4E1D8E6E719E5E7E7E6E5E5E4E6E5E4E4E5E0E7E7E7E7E7E678E6E7E7E5E4E6E6E5E6E6E5E6E4E5E4E4E6E3E6E1E5E6E5E6E4E7E6E6E6E4E5E6E7E6E5E6E7E2E6E7E4E6E6E6E7E7E5E6E6E5E7E6E6E8E7E6E5E5E3E2E4E4E5E6E6E7E4E6E6A6E4E6E5E6E5E5E7E5E6E4E4E3E4E4E7E5E5E4E4E3E5E6E7E6E5E7E4E5E5E5E6E6E6E6E4E4E5E5E7E6E5E7E3E4E3E4E8E7E6E7E5E6E4E5E4E6E5E5E6E5E4E4E7E5E7E6E4E3E5E5E6E6E7E7E7E7E7E7E8E8E8EAE8E8E7E8E9E8E8E9E9E8D8E8E7E6E6E789E3E1E4E3E390E4E5E6E5E6E4E4E5E2E6E5E7E6E7E5E5E5E1E3E5030CE1000019E4E3E3E4E5E3E5E7E5E6E6E6E7E7E6E6E6E6E5E7E6E6E5E5E6E5E7E5E69BE4E7E6E6E5E5E4E4E4E7E7E6E7E4E4E4E5E7E7E7E6E5E5E7E7E6E5E6E6E4E4E4E5E6E7E7E7E5E7E6E5E5E4E6E6E5E4E4E4D8E6E6E5E5E6E6E6E4E5E3E2E6E3E6E7E3E3E4E3E6E6E6E6E5E6E7E7E4E5E6E6E6E7E5E3E5E5E6E7E4E5E4E4E7E7BCE5E5E4E5E6E6E7E7E6D6E4E6E4E7E6DDE5E7E6E7E6E5E631E4E8E7E7E6E7E6E6E7E8E7E6E7E7E5E5E5E5E4E0E6E7E6E6E6E7E5E5E5E7E7E8E7E8E7E6E5E7E7E6E7E5E4E4E5000000
+      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000090000000001000001E5E5E6E5E5BEE1E6EAE6E8E9E7E7E6E6EAE6E9E7E6E7E6E7E5E7E3E7E4E3E2E5E5E4D8E4E4E5E4E5E4E4E44599E3E5E6E3E2E1E3E5E4E03100E100000078E5E5E4E4E5E5E6E6E5E5E3E4E5E4E6E7E4E6E7E5E4E4E5E3E3E4E42B0000D6E5E4E6E6E6E5E5E5E3E3E4E5E4E4E6E4E5E4E4E8E6E7E8E6E6E6E6E7E6E6E7E5E6E5E6E5E5E6E5E5E6E6E4E6E6E6E4E3E2E5E6E6E5B7E5E3E5E5E5E5E6E5E6E5E4E5E6E585E4E5E6E5E7E6E4E3E6E5E4E5E5E5E6E4E4E6E6E5E7E6E5E5E4E3E5E5E5E5E4E5E5E4E4E5E5E4E5E4E4E5E6E6E6E5E5E5E6E5E4E4E0E1E3E4E4E59BE3E5E5E4B5BEE5E6E5D6E5E5E6E5E4E5E6E4E6E4E5E6E5E6E5E4E7E5E5E5E5E5E4E5E2E7E6E7E6E8E7E7E8E7E6E7E7E8E9E8E8E8E7E8E7E8D2E7E7E6E5E4E6E6DDE6E22DE3E4E7E9E6E5E7E2E2E3A62278E4E7E4E4E5E4E6E7E078E08B0000001B249DB3E4E0E3E6E5E7E7E6E6E8E4E6E4E8E6E4E5E4E4E4E4E2E6E6851D00009BE4E4E6E5E6E5E5E4E3E5E8E7E7E8E6E5E6E500B7E6E5E6E5B33628E4E5E7E6E5E5E5E7E5E6E2E5E5E5E4E6E5E3E3E6E6E4E5E8E7E8E7E6E5E5E5E6E1E6E5E6E5E5E4CBE6E6E7E8E7E7E6E5E5E4E5E5E6E7E8E6E3E4E4E8E8E7E7E5E4E6E3E5E6E5E6E6E5E5E5E7E3E6E7E7E7E7E7E6E7E5E6E5E6E7E7E4E5E3E4E6E5E6E7E5E4E5E5E7E5E5E5E6E6E5E5E7E7E5E7E8E8E6E7E8E5E5E7E5E7E6E7E4E5E5E5E6E5E5E5000000
+       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000B0000000001000001E3E4E4E4E6E7E6E6E8E6E8E7E9E2E8E8E9E9E9E8E6E7E1E6E5E4E5E5E4E5E2E47300E3E4E3E4E3E3E4E3D6E1432B0043E6E7E7E5E5E5E5DFE3E0000026000024E5E6E5E4E5E2E4E5E5E4E0E34141E3E4E4E3E3E3E6E4E4E5E4E3000000B3E5E5E5E6E5E6E8E610E4E4E5E5E5E7E8905F001D83E2E5E2E4E3E2E1A600E4E6E7E5E3E5E4E3E4E5E7E6E8E5E4E4E5E4E5E5E6E5E6E5E4E4E4E4E4E3E4E4E4E4E2E3E6E7E6E6E5E4E3E2E6E5E7E5E4E2E5E3E7E5E5E5E5E4E5E7E7E6E6E6E5E4E3E3E3E5E7E5E5E5E5E4E6E6E5E5E6E5E6E6E6E3E5E4E6E6E4E5E6E4E4E5E5E5E4E3E3E4E4E3E4E5E6E3E4E4E5E4E7E6E5E5E7E5E6E6E7E4E6E6E6E5E6E6E4E5E5E2E7E7E7E7E7E6E7E8E6E7E7E8EBEAE9E9E4E7E8E7E8E7E9E8E7E3C0E7E5E6E6E324242B89C7E5E6E5E2E473E4E5050012E5E5E2E6E59BE5E6E589000000520100D0E6E5D4E4E3E5E4E5E4E5A6031B0092E5E3E4E4E2E4E5E3E4E50022000017E3E6E7E6E6E3E10057E3E5E5E6E4E30000039F0CE3E4E4E3E3E6E05B2D05E7E6E7E6E5E5E4E9E7E6E9E1E4E4E3E6E5E5E5E6E6E6E7E6E4E5E7E6E4E6E5E6E4E4E4E7E6E7E8E5E6E4E5E7E7E8E8E6E6E4E5E6E4E6E5E4E5E5E6E7E6E6E6E7E5E6E7E7E6E6E7E5E2E6E6E6E7E6E7E7E8E7E7E97EE7E7E6E6E6E5E6E5E5E5E5E5E5E6E7E6E6E7E6E6E7E7E6E5E6E6E6E5E6E5E6E6E8E7E6E7E5AAE7E8E8E7E6E5E5E6000000
+        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000D0000000001000001E3E3E3E2E6E6E7E6E8E6E6E7E6E7E7E7E3E4E4E1E5E0E0E5E6E6CBE5DEE4E1E07E002B0000DBE2E1E5E4E4E5E300001243E40001E2E1D0E0006A000024000000E5E6E7E8E4E3E3E4E2E3E3E300380000E6E4E6E5E3E2E3E2E3E30000000000E2E485E4E5E00599000EDBE3E4E4E4E3B100000000E4E6E5E5E3E400D2317AE4E1E2E1E3E3E5E4E5E5E7E6E6E5A4222BE2E1E5E4E4E600E6E6DCE4E5E4E0E3E3E3E4E5E4E3E3E1E4E3E5E4E6E6E3E3E2E3E4E5E4E4E2E2E3E2E694E5E4E2E2E3C9E6E8E6E7E5E6E4E4E3E4E5E4E5E5E4E5E4E5E5E4E4E4E2E4E4E2E2CBE5E5E7E5E5E5E5E4E5E6DDE5E5E5E2E4E3E6E4E5E3E3E4E4E6E5E6E6E4E4E5E4E4E5E5E5E7E7E6E7E7E5E6E7E6E6E7E7E9EAE9E8E8E8E8E9E5E3E0E6E3E4E3DFE1E2E2E3BC476D831720191080E4E5E5E27300260000152DE2E3E0E29FE30000007800009BE4E4E4E5E5E4E3E5E4E36F00000010DEE3E4E5E517E2E3E5E50000000083E3D0E7E4E4E2789400AF83E4E5E6E6E5E40000330041E4E4E4E3E5712FE20CE4E4E4E4E3E3E5E4E6E5E6E6E6E3CB5FE5E3E5E6E5E4E7E5E7E5E5E3E3E5E5E6E4E4E5E5E5E5E4E5E4E2E5E4E7E5E4E3E4E2E4E5E5E4B3E6E4E6E8E5E7E7E3E4E5A6E6E7E6E6E4E4E2DFE5E5E4E5E6E5E6E5E4E5E6E4E6E3E6E3E6E6E5E4E6E6E7E6E4E5DDE5E6E7E6E6E3E5E0E7E5E6E7E5E6E4E4E5E8E7E6E0E2E5E5E4E4E3E4E4000000
+         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000F0000000001000001E5E4E5E5E6E6E6E6E7E7E8E8E9E7E8E6E8E090E8E6E6E5E4E5E5E3E5E5E4E5E5E2E4050001000094E1E2E3E2E3D00E4300150064E105B1DDE4DC5D0000000000E0E5E3E2E7E5E5E3E2E3E2DB2200001B01E2E2E3E4E37CE1E3E4E3240000000049E3E5E4E6CBE4BA9B459BE5E4E3E2C90020410000E7E6E5E6E03600B55BE4E5E6E3E4E3E6B1E4A8E5E5E5E4E58B3A33E3E5E5E5E5E5E4E3DFE4E4E4E6E6E5E4E4E5E6AFE2E4E4E3E5E5E5E4E6E6E5E6006AE3E7E0E4E3E3E6E5E4E4E3E4E4E3E6E6E6E7E5E5E347E2E4E4E4E4E5E7E4E4E3E5E4E6E6E4C9E3E6E6E4E5E5E5E7E6E5E5E5E5E4E5E3E4E4E2E6E2E6E7E7E7E675E4E6E8E5E8E6E5E6E3E5E4E4E4E7E7E7E7E6D8E6E5E8E8E8E8E7E6E4E5E9E9EBEAE4E5E59D1D0C266FE1E2E1E1E61B000003000C6F6DE4E5E4E0E1CB0000000C0EDF7E01E1E1E6E5D80000000000E3E4E5E4E4E4E3E4E5E1E1A6DB830E00E5E4E4E4E3E2E3E3E0E2E3870028000096E4E6DE8E00451B0C68E4E5E3E5A80000000000E3E7E4E43A003E0038E4E3E5E5E5E4E449DE4E00C9E6E5E6E0B1B7E7E5E6E7E7E6E673220000E5BAE5E6E7E5E4E0E3E46FE4E5E7E4E4E5E7E7E6E700E3E3E3E5E6E5E5E5991BC5E2E5E7E7E6E5E6E7E7E5E35F20E5E5E6E5E4E3E4E5E6E6E6E5E5E4E5DBE6E6E7E4E4E4E4E8E6E6E6E4E4E5E4E6E7E5E2E3E5E5E4E0E571E4E7E6E7E7E7E6E2E6E5E5E7E6000000
+          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000110000000001000001E4E4E5E2E8E7E7E9E6E6E7E8E6E7E8E4E5E7E6E6E4E4E378E29600C9E1E2E3E2B1E2000000DC003EACB5E0E3E21BE00000C20000D2E08315E3E3E3191000002B00E2E5E3E4E4E3E4E0E5E4BCE2E528004C0500E4E4E3E3B3920AE2E3E400002600BCE1E1E30500735D000000E6E5E3E7D800000066E7E7E6E4E300001968E5E4E2E3E4B5DDAC83730E03E3E3E4E3626DE5E4E4E5E5E4E3E3E2000000E3E3E2E4E3E28900E3E4E3E3D6E4E4E3E4E4E4E20CE0E0E3E5E4E2E52F07004331A8E3E3E3E3E5E3E4E4C7AFD4E3E2E4E6E4E5E6E4E4E2E1E5E4E5D4E6E0E4E6E5E4E4E5E6E6E5E4E4E5E5E5E4E3E3DCE3E5E6E5E6E3E4E7E4E5E4E6E4E4E5E6E4E4E4E4E7E6E6E8E7E6E8E7E8E7E3E7E6E7E5E7E7E7E8E7E5E37A43000000789FE3E3E3E1E44C0E000000129D0C99E3E3E1E31000000000209FDFE4E5E4E2C9003A000036E4E4E5E5E5E6BC22070A75E54E4C0E0000001DE3E4E2E3E6E6E6E60E225DB50099E3E3E68500000000000000E5E3E5E61B31007AE5E4E4E6E4260000BEE3C24EE6E8E13E80A82D01D600E5E4E319AFE8E7E5E7E5E6E6E6855900E519E0E4E4E5E6E3E3BAE4E5E5E7E6E6E6E400009D00E3E5E5E6E7E5E564A1D20A00D8E5E6E6E5E6E1CDE6E4E4E6E7E7E5E6E6E6E4E5E4E4E5E7E6E6E6E5E5E6E6E6E6E6E7E6E4E7E6E7E7E6E7E4E4E1E5E8E6EAE9E7E6E7E5DFE7E7E6E6E5E5E6E6E4E5E5000000
+           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000130000000001000001E5E5E4E5E1E6E6E6E7E7E7E7E6E6E6E7E7E7E6E6E5E5E5E51D001543DD89ACE3E59DE1E30000007E493885E1E4E5E3B30A0C004E004CE3E2E3E34CE2A40000032DE3E6E7E4E4E12F0038362BE2E3E43C00002B0059E5E6E6E6E6E5E24C000000003638E1E3E4000000079B6800E3E6E7E5E496000A1700C9E5E60000C0E4000000E2E5E650000007000000E3E5E4E1BEE72DE541C0E5E6E56A00E3E5DBB7E4E4E4E4E5E5E2D6E5E5E3E5E6E4BA00000050E5E5E3E4E5E5E4008500000012E4E4E3E5E4E4B5E4E6E6E5E5E6E4E3E5E50003E4E4E3E5E5E4E6E6E4E5E4E4E6E5E6E7E7E6E6E5E5E5E3E4E3E4E6E7E6E6E6E6E6E6E7E6E0E5E4E7E5E6E5E4E4E4E4E7E7E6E7E8CBE8E7E8E7E6E6E7E5E8E8E9E7E7E8E8E8E7E6E6993E129DE13ADCE7E4E3E35D4E000000000AB7E4E4E4E2570000000000008BDBE11BD25D07170CAFE3E3E3E6E5E007012B001028E5E638001000154EE3E4E4E5E4E2E2E2173A00000E1741E3E10110000A4CBC00A4E4E4E5E5E6000000050AE4E62D0100E4000020E6E7E7E1E2008568200C05E2E6E7E6E3E6E6000CBEE7E5E400E5E33AE4E4E6E7E5E6E6E2E2E4E3E5E6E6E5AC000000E3E6E4E5E4E6E6E5758B8050AF33E4E5E7E6E7E68BB3E4E6E5E2E5E5E6E503D2002DE2E6E6E3E6E5E7E6E8E7E6E6E5E4E6E6E5E7E6E5E5E6E5E5E5E5E5E6E6E7E5E7E6E5B7E6E6E7E6E7E6E7E5E4E5E5000000
+            USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000150000000001000001E4E5E5E5E7E6E7E7E8E2E8DDE7E8E6E700CBE7E8E7E6E6E7E5E33307004E002DE4E4E4A1AC312F9DE071059BB5E4E3E2E5435D0700000028E4E3E2E4DD19000000DFE5E4E6E36F0A0000992F00E0E4E000003C0C20E1E4E2E4E3E5E2E1AFE0000115AF89E5E62B47001B00003654E4E5E1E2E2100A00126DE4E7E5E4DE000000002DD2E5E4E100000C1D9D0C43E3E6E5E6E7732207A4E4E4E39BE252A10028E4E5E4E6E3E3E1E47EE4E4E4E4E3DB3643E4E5E4E6E4E5E5E590E5E27E7EE4E4E5E4525DE5E7E6E7E7E7E3E5E4E38B000000E1E4E4E5E4E5E6E5E4E4E5E6E6E5E5E5E5E4E4E8E8E6E6E3E3E6E4E5E6E7E5E5E4C9E4E5E5E5E7E6E6E4E5E4E3E5E4E7E7E7E6E6E7E2E1EAE8E8E8E9E7DCE89DE8E8E7E6E5E6E6E4E300201B0000004728E4E4E3DD000000A1439DC0C7E5DFE6E40E000000001573E2E4E5E3125D1B00E4E3E6E6E3E42B000000000020E2CDE2201B12003ACDE1E2E3E2E4E2E4E00A00000015D6E6E322003615197C50E0E3E5E2E5010000000AE2E3E4E5E63A000C00E4E6E6E4C9014500000300DBE7E6E8E3E5E61549E2E4E5E5E5E6E600E3730AE6E4E6E08EE4920AE5E5E5E3000EBE475FE5E6E4E6E4E5DFDEE6E2E6E5E4E5E6E673E5E7E5E4E4E4E6E1E6E4000C007528E5E5E5E4E6E6E7E5E6E6E6E7E4E4E5E6E6E7E6E6E6E7E6E1E4E5E5E4E4E5E4E6E6E5E6E6E1BA07E6E7E6E5E4E5E5E5000000
+             USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000170000000001000001E6E7E6E5E7E6E7E7E8E8E7E9E7E9EAE8E7E7E6E6E6E7E7E7E4E3E2070010000000B7E2E2D8DCC7590000CDE1D4E0E4E2E2E483000000002B0AE3E2DCE0450E05058BE2E150E4E3520105050320C5E2E1940107000043DCE2E4E5E5E4E3E4E320105B2094D2E4E2E0E2011252000071E3E5E6E43100000000E5E4E4E7E4E22815031D00E4E2E4D8AF002B4100E5E6D6E6E5E1E5E30E3600E5E5E3E4780A120300E3E6E7E5DDE2389DE5E4E5E00000963A2DE1E4E4E2E4DF68DC077EE5E4E4E1E43850E3E5E5E4E4E4E5E6E5E6E426DDA60AE3E4E4E1E4E6E4E5E5E478E5E5E4E6E6E5E5E5E7E6E7E6E4E4E5E6E6E4E4E5E4E5E5E4E5E4E1E5E1E4E6E4E5E5E5E6E7E7E7E7E6E7E7E6E8E8E7E8E7E8E8E8E8E992E9E7E6E7E8E4E0E5050007E33E6DE1E3DDE289E4E32F00282FE1E3E2E3E3DBE41B000000010085E5C289780000A6E2E14717B3E443490A00000064B5E5E20E003100003ADFE5E3E4E6E37E623E3C4307B3E5DEE4E00E00120C4C0CDEE5E2E1E500000E0043E3E2E4E4E5BA002B00190057E5E4E6E4000000002FDCE6E5E6E5E6E700000071E4E6E57510070152E7E8E8E8BC3AE2D2E6E5E4E60000E2AFACD0E4E2E5E2E66F3C5FE1E4E0E6E3E3666A9B339BE6E5E4E6E4E4E4E49D901BE2E4E2E3E6E7E5E7E5E2E5E2E1E4E4E4E6E7E6E7E7E6E6E7E6E6E6E7E6E6E6E5E7E7E6E7E5E5E5E6E7E7E8E7E4E4E5E5000000
+              USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000190000000001000001E4E4E5E4E6E6E6E5CBE5E7E6E7E7E7E6E7E56DE6E4E6E6E5E4E3E2830C007C1564DC24E2E5E4E3E357000E01030A20E0C789B7E2C54300071BE0E0E383E324006FE4C5597E00A48500000033000085E326E30000000528996FE2E4E4A4E1E26F00100700177EE5E5E16A0000000A4E625FE2E00000000000E3E5E6E6E54C00000000001BE3E5E3E2002B012F50E1E3E4E5E0E20073000000E2E2E5E25728CD31E5E4E4E54CDFE400E3E4E4E100000A3CD8E5E3E6E4E05B5B000CE3E5E3E4E31278A4C0B3BEA8E5E7E4E4E4E2E38B3807E1E4E4E4E6E4E5E5C7BCE5E6E3E4E5E4C7E4E5E6E4E2E4E4E5E4E4E5E6E5E6E5E5E4E5E4E5E4E6E4E3E4E4E5E3D4E4E5E7E7E7E8E8E7E7E7E8E7E0E8E6E5E6E5E5BE2BE7E2E4E4E3E4E3E50020000000382062A4E2E2E1A48500050E000A0A22E3E4BE451D20D60A05E0C9E2D09D6DDC7CE1E207152B94E1315F1D261952E4E1C5D2362F0307057AE2E4E5E6E2E2E3541D0533240010DBE6E5000001001700E0E3E6E55F0C1010E57E8590E6E473240000000000E3E5E5E6E459431DBCE1E8E0E6AC570000000000E4E5E5E178943C17E2E3E5E0B1E40000E5E4E55B50E0594978E5E6E6E1904EB77300D6E6E5E3E42001A6949FE5E5E5E7E5E6E5E5E4E2789BE4E4E5E5E4E5E5B1DE8EE2E4E5E5E4E4E7E5E6E5E6E7E6E7E6E5E4E6E5E6E5E6E3E4E5E4E6E8E6E1DDE7E6E5E3E2E3E6000000
+               USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001B0000000001000001E5E5E5E6E8E7E7E7E5E6E7E6E8E7E9E8E7E2E4E5BCDB33C2E3E2E0E22D00000001287C9FCBE1BE940000000000016431E1E3965B00171724E2C7E0D8E0D6E14CE1E1E16A000762E233002200000CCDE1E1DF07000000000064A6E0E1E4E3E12B10280000ACE3B7E4E2000000003C0119E3DFE2680031901900000064E2E3E2AF00000052E3E3E4E1A43A070100A6C7E3E3DC228B0000000000E2E5E3E278000083E5E5E4E5E5730085E4E3E100895FAFC5E4E3E3E2457852AF28C7E4E4E2E310002641C2E5E4E4E3E296E3E3E5E4E5E2E3E3E2E4E5E0B1AC4CE3E3B1D6E6E5E5E4E2E5E4E5E5E4E3E6E5E5E5E5E5E6E5E3E6E3E5E5E3E3E4E4E4E5E3E2E3E5E3E7E7E8E8E7E6E7E7E7E5E6E6E7E7E9E8E8E8E5E400360C1749E1E4E1DF0000BA2001055252C2E44E000000002B0022685BB5D2A8102F3622C2E0E2E3E49657E5E3E4E1C0430547E4E0855D00000028E2E2E46F3E0000E20033E575E5E5E4E4E2432F1D00006D0578E11B000000190071C5E5E7CBE0E2000000000068E6E6E4C00012002D26E4E5E6E50300E4E3E6E58BE6E2C0E6E10A5D3C0000E1E5E5E6002B7A41E5E6E4E6E03E87E5E6E4E2E3E4E3E4E1E4E44159E26D5BE0E6E6E3E3E1DBE5B74E59E5E6E6E3E01DAAE3E6E5E5E5E6E5E4E6E6E592C9DC9FACE4E6E5E5E5E6E7E6E7E6E6E5E5E6E6E6E8E7E6E7E5E6E6E8E7E5E5E5E5E7E7E7E6E0E4E0E4000000
+                USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001D0000000001000001E5E5E5E5E6E6E6E2E8E6E7E7E6E7E7E8E8E7E6E40000000CE1E3E3E1E20E2B00052652432D31E2A6E00700006600382DE1E1E5E3002F7A00004E4536E2E35DE5E6E3876F000005AAE3E01200003A2FC9E2E5D015000000001DE46AE3E2E4D8E22F000000003A0003E4780000004E3100AAE5E4E4E4E4000000050000DDE53E00000043220026E5E6E5470045C2E2E6BE6DE4D8E2E76622E10075E2E4E5E4DBE400E2E2E5E5E4E4E5E2E3E4E2032F36E4E5E4E6E0E34EE3DEE3E4E6E5E2DB0E015D7512E5E6E6E5E6E2207AE5E4E5E5E4E6E4E5E5E4DFC0AAD845B5E3E6E6E6E5E5E3E2E5E4E5E5E3E5E4E6E6E8E7E7E7E7E5E7E7E5E4E5E6E6E5E4E6E5E5E5E4E7E7E8E6E5E6E6E6E7E7E6E615E7E7E8E6E7E60000000000AFE3E3E5E4E35F01002600150001D0E3D83A000000000C49E0E0E3D600000000001B0552E1E3E2E5E4E0150300000000E3E34300A83300D6E1E3C05D2000000000AADBE5E3E49F6FE50C00E200000C194728017A003A0000737EE4E4E3E400000000000000E7D0380049000000003AE4E4E4000500E30E00A4E4E6E5E400689D000CAFE5E20022001BE2E3E4E6E4E2E5E5E4E6E60E5900E1E6E5E4E4E5E3E4E4E1E4E5E5E6E347B54C0A83E7E6E6E7E59207E0DBE6E6E1E6E3E5E4E1E46F50DEB5E3E5E4E6E5E5E5E6E6E6E6E6E6E7E7E5E6E7E8E6E5E6E6E6E6E4E5E6E7E7E6E5E5E4E3E4E5E6E4000000
+                 USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001F0000000001000001E3E4E4E5E7E6E5E6E7E7DFE5E7E8E7E7E9E9E5E200000000E1E2E2E0E3E3730C0015000C052DC2A67EE03C0700000C2B6820E3E4DC1922000000000162E4E5E4E0E25D0000000000B5E43E00120A36E4B3E3E3E3C90E152F7812BAE2E4A6E3D2E3100000000331E3E2E1E37A4303003600ACE3E3E8E6E400000000CDE6E6E5E700B72D94000E909DE7E38919E2E0050000C9E4E4E3874C0000B5E2E7E2D005E3DCE5E4E0E2C236103CE4E5E5E2007868E6E6E494003E0596E2E5E5E5E3E3E3E492E3E4E3E5E7E4E0545FC533BAE5E4E5E5E5E4E6E5E7E5E5E1E4E4E4E6E6E5E4E3E3E5E4E6E6E4E6E5E0E4E6E7E5E6E6E8E5E5E6E7E6E6E8E6E5E3E4E5E2E5E5E6E6E6E6E7E6E7E7E7E5E6E7E8E8E6E7E6E6E8E7D40000000000E3E3E4E0E53C001031000AB7E3E4E3E3B1920038222654A8E3E32B6F31000000000017E2E3E3E549E1450000000000E462000012AFE3E1E1E3E1E30C260A683AE1E0E3E3E4E3D6E1014E0001002212D8CD2FE10100010500E3E5E6A6E6A1280017030094E1E189E410002B00B1D2C5E5B145E2E4030000A4E4DD00E20000001DE5E5E5E5E4337AE5E7E5E67ADB4500DCE5E5000000E3E3E6E4503E9B49A8E4E4E0E30000008EE5E5E6E4E5E552E264E4E39DE5E5E6E6E5E6E5E5E2E6E7E6E7E6E6E6E5E5E5E5E7E6E8E7E5E5E6E5E7E7DEE4E6E6E6E3E6E6E6E6E5E4E5E5E0E5E5E3A6E5E4E3000000
+                  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000210000000001000001E5E6E6E4E8E6E7DDE7E7E7E5E6E8E8E7E7E6E8E8E4E3E05F001280E6E3E4E390382419004CB5E2E392E080780C1D000A2D75E3DFE3BA2020013E000000E3E3E3E5DD1D000000000000BCE347006D260057E0E5C95B5F0022000000C2AAE1E3E4E6220A170C20360A00E1E4E6002F00E10000E5E5E322E4220000032250C2E0D8E4E5000000B375623EE4E5E0E5E000000003E4E4E30700C9000543E3E4E215196659E4E3E57E2D0C5BE3E44700000092E4E6E36A0015E3E1E2E4E33300A80000E4E6E4E5E3E4E6E3D675E2E0E3E3E5E5E5E6E4E4E4E3E6E5E6E4E5E6E4E5E5E5E4E4E4E4E4E7E5E6E5E6E6E7E5E7B3E5E6E5E5E5E6E6E6E5B7E445E8E4E0E2E3E7E7E7E7E7E6E7E7E8E8E7E7EAE9E9E9E7E6E6E6E7E6E5711DE2E3D2E3E5E4D4A4240E54032224E1D8E46887BE2B00071B00D8E2AFD82F00890000003AE2E4E1E1BE5D2FBE710E0031ACE49F547115070E54E5E6E249050500000000E2E0E4E4A83E00052010001D0E68E5E4E30000E000105DE6E6DEE6E6360015000001E3CDE4E41D0049310AE1E5E6E6E5E6E50000001DDEE6E50A000500260059E3D4228E508E59E7E4E5005FE2E5E520170000DCE6E6E603C74799E6E5E5E30003000000BEE7E7E4E5E22DA1E2E0E3E3E6E6E7E6E7E6E5E6E5E5E6E6E7E7E6E8E5E5E4E5E7E7E6E5E5E5E4E6E6E6E6E4E7E7E7E9E8E6E7E6E7E5E7E7E6E6E6E6E0E3E5E4000000
+                   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000230000000001000001E4E4E5E5E7E6E5E6E8CBE8E8E9E8E7E8E8E9E9E8E7E4E4A67CC062E2E4E2E4E3E34731000019076AE0E2C964122B100000001BE1E2D264000000079FE2E2E2E3E203E1E39D00000000C0DEE2200C0015BCE4DEE4E5900A0000001000C094E4E4E3990000007A0000B7E2E4E466000300000ADEC5E6E5E6E50000003C0007E0E4E4E2DE017C57008E24E2E4E3E4E500002FE4E5E494E4B500003E0110DF470031A4000E99E287001D87E0E568220AE2E5E5E3E4E5E21099E0E6E5B7DBC5505BE2E5E5E6E4E1CD8BAA89C2E6E5E4E5E6E4786AE3E4E3E4E3E4E6E6E6E7E5E5E5E4E5E1E5E3E6E5E6E6E8E6E3E6E5E7E5E6E6E6E6E5E5E5E5E5E4E4E1E6E5E5E5E4E7E7E8E7E7E1E6E6E5E6E7E6E6E7E5E6E6E7E7E7E7BC52416FE4E296B5BEE3E0E3DC0C010000013ABEE4BC6F0000001900008589E4713601001933BCE4E4E49FE4E3C552412F1B030033E3E49600000A002FC7E6B5415949000000170E38E6E6E6BC000000000022752628E2E30C0033120564966FE5E6E32F0E000C000092E4E6E7E8331D24052DAAE5E5E4E4E4D07C0031E2E5E6E5193C2845000CDEE500E3E50578C0E345003A00E4E5570050E4E4E5E5E6A854472DE5E6E6E4E341070071E6E5E5E220C7A6DDE3B7E5E5E4E4E5E3E2C759925FE4E3E1E6E7E7E5E4E5E4E6E5E6E7E6E5E5E5C5E6E6E6E5E7E7E6E759E5CDE6E6E6CBE6E5E07A7AE5E4E5E5000000
+                    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000250000000001000001E4E5C9E5E7E7E8E7E8E6E7E6E9E7E5E9E4E6E6E6E3786D57001BE1E1E2A1C2E2E1E400000000000000E0E3942600000000158026BEE2CD4500419062D0E0E18EE4E3E4DE667C0000000ADBE0E20C000000008EE4E34C92152415281D0700E1E2E5E500000000000000594EE2E224003C006603527AE2E4BE570A00102D47E3E4E5E5E562001D072054E2E1E3E4B7A817001983E4E3E54599A85BCD0C9DE422DB005D7CE4E40E280C002FE4E4D805E0E4E4E4DE7AE1E3C7E5E4E592646F318EE5E6E5E5E5D89FC09DE2E3E4E3E4E4E5BE64E3AC5F7AE4E4E4E3E3E4E3E4E3E4E4E5E5E5AFE4E5E4E6E6E6E6E6E5E5E5E6E5E5E5E6E6E4E4E5E3E4E5E6E3E4E4E3E7E7E8E7E7E6E7E4E6E6E5E5E5E7E3E7E6E5E5E4E5E0E20A0031001DD2E5E4E4E4E1AA4E000000000071E3DB622F000A36000E0CDCE0B5A63E12B3E2E3E4E2E3E6E6E6B3C73C00001536A8E36A4500100E00ACE3E4E42D3E002F000E22D4E3E4E5E4E2E37A45000000220389D099809F0017000A0EC0E4E41B010000010ACD8B00E2E5E2151B00E3E5E5E6E6E30AA67EBC572290E4E4412403750000E2E3E38B000028E5E347151231B1E4E4E5E5E6E5E3E4E58EC766C9E5E4E23E33C754E4E4E4E3E3CD1BE443BEE5E5E4E7E4E4E44EE6E0DDE4E7E6E5E5E6E4E8E7E5E3E5BCE5E6E5E7E4E4E5E3E7E7E6E8E5E1E6E5E6E6E6E7E7E6E4E6E4E3BCE6E5E5E6E5000000
+                     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000270000000001000001E3E5E5E5E7E6E6E6E7E7E6E6E8E8E8E7E5E6E4E5E4E4E4AF00000000996AB5E1E1E1DE0000000101103ED6E2E14300000000031538DDE24C03003CE0CDA1579BDEE3E1A6E187070E4EE3E3E4E2E36600001952B1E2E4D40700120000017CE5B7C7E3E1E419000000000328DBE390E13E6D0000000054E6E4E42600280528000001C7E357018E0141E6E6E7E4E478002FA42D073CE3E5E000224C2800A8E5E5E47826DCE5E46D0385AF71E4E4E5E4E5E4E3E39F2B2600BEE2E5AF3826E545E5E3E5E4E69D120750AFE4E4E6E4E4E200B32FE245E1E4E5E4E0E3E2E2E2E4E4E3E2E3E4E3E4E6E6E4E5E5E6E5E5E4E3E4E5E5E4E6E5E5E5E4E6E5E6E4E1E2E4E5E1E6E7E6E7E6E6E6E6E6E6E6E6E5E6C5E5E5E6E5E7E56FE45200191D38929BB1E2E2E3686F000A000E3A4C62E4E25200000C364E00173CA178BA20009DE2102022E0E4E2E5E6527ADF17E1E2BAE4E0DE500005E1E2CBE6AC261000752400ACCDE2E3E3E49B7128261703281294E3E2E3E3A60E030000248EE4E2750000005707002217E3590A47E52FE5E3E1E4E3E222CD3C3600571DE6E31900A62057E4E4E5E27EE2E2E3E4E4E2E00071E5E5E3E5E5E4E6E36F2B0057E5E6E4E08B006A41E1E4E7E6E3E2D01DE3E4E6E6E6E6E2DC00E32B9243E6E5E4E4E5E2D0E2E3E0E3E3E3E3E2E3E4E5E3E6E6E2E5E4E6E6E6E3E5E4E6E6E7E7E6E6E5E7E7E7E8E3E5E0E5000000
+                      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000290000000001000001E3E4E4E4E7E8E7E7E7E8E6E4E9E6E8E6E3E5E6E6E6E5E4E4E00A17000054DD9487E58BDD00002BB7202694E3D4E1360000122B00197EBCDDE27A009F520031005BD8E3CDE04E4E310020E2E5E5E1C29D0010992B5DE3E280010C0000005DD8E3D0E4E3E2E27A192D001D45B5A4E5E0BAC717007A000068E3E4500000000000000031E3C9BC000000E5E53CE3E2009B190315032F2666E3C70005668BE3E4DC0003001DE1E2E4E4E4E4E4E5E2E5E4E4E5E4E4E23E526A78E4E5E29DB100CBE5E4E5DB1089E16DE3E6E6E4E4E5E4474517E1E4E5E4E3E4D6BCE380E4E0E2E2E3E3E5E4E6E4E4E6E6E4E3E5E5E4E6E5E4E4E3E5E6E4E8E6B5E6E794E7E6E5E4E4E4E6E7E7E6E6E6E7E6E7E7E7E6E6E6E6E7C2285BE6E7E6E1E5C9380000000C5B9BE2E4E2E30A051983DBDD8BE2E371D2360000002B0054DCE2D86AE266005B2D0775E4E4E5E383BA1D0007E0E3E3E4E3AC0000003E75DBE3E3E02401051003E0E4E2E5E4E4B5AC3349000010A4E483D050201500241B0112BAC7E119123C0A000000E1E5E475380341E4E289E3E3DCE10A03226D00B3E5E3E3E5E5E6E5E55078490571E1E5E5E6E5E6E52443E4E5E5E5E4E6E7E6E59F874EB1E5E54E59B1E4E4E4E26A6464E2C7E5E6E5E4E4E483E5E04E33E5E5E7E7E5E7E5C7E3E5E6E8E4E6E5E4E5E4E4E5E6E5E4E4E3E5E6E8E6E7E5E2E1E5E5E8E6E6E6E6E5E6E0E5E6E5E5000000
+                       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002B0000000001000001E3E3E4E4E7E7E7E7E8E6E8E8E6E8E8E568101BE7E7E6E6E5AA3300002F0017E1CDE1E4E3E143003633D8A8E5B1E1A69F120105150319A8B3E56AE5450CE36419128BE2E5E47C9678000C2F7EDEE3BA620E36001033D4D2E2785D7300052D5DA1E1CDE4E4E2E026121728871750C2B7BA20001200002405413CC21D00660000003600E5E7170EE0D2E5C2E2E4E2E3E10000E3310020B5C0E2E5E5E7E5E49626E1005DA1E5E5E4E5E5DB9D8B36A8E3E3E4E4E6E2E3E5E387E1E5E6E4E2E3E4E4E4DDD80E0CE1E2E5E5E5E5E4E3B5E0E27A94E4E4E5E4E4E6E3E1C7D4E0E4E5E5E3E1E4E2E4E6E5E4E3E4E5E5E4E5E5E4E4E3E4E6E6E6E5E5E5E4E2E4E2E0E3E4E3E5E6E6E6E7E5E7E6E8E6E6E6E6E8E7E40E0119E7E6E5E3E32B943600000000E4E2E3E3B76D240019033154B7E3E1E4E0453E0A0E001003E3DDE2E2E138010024C7E1C5E3E5E1D84900000059E4E5541B0500381210127EE4E22BB13C0E071000B7E5E5E5C7CB244C00A60A004900C0E8000047006400000317E2E2E0E50E0E001220DEE5E4E3E6E728573ADCE5E5AC5F0000410C07E5C9E3E1E2E3E4E5E2009200ACE4E5E5E4E1AF03244333DBE5E6E4E3E4E5E2E5E4E6E5E4E5E3E5E1E5DFE4E30590014EE5E5E5E7E5E4E6D8E4BE3AE4E6E7E7E8E6E7C000070CDFE7E6E5E5E4E3D8E5E6E7E6E6E7E5E5E6E7E7E7E7E6E6E4E7E5E6E5E6E6E3E6E6DEE1E5E4000000
+                        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002D0000000001000001E3E2E4E4E6E6E5E6E7E6E7E6E8E8E8E6AFE3E5E4E4E6E190E2E19000001589C0A887D8C9920000000012478315E2E2C58926004300330087E2E4C9E1E05200003A6DE0E3E2E0D80000E100C5C7E3B72D00032F05000000E3E5E200100007000028E5E4E7E1ACE4364E2619000083ACE30A000000AF2D6D3C2FE1E4E5E6DFC7520000E4E7E6E2E5E092E185E4E645C20A4E05030700A8E443E3E5E0E4E66A94310043E5E5E4E3E3E5AC751722E6E5E4E5E4E352CDE3E0E3E5E3E5E5E2E6E4E4D2E05438AFE3E4E3E3E4E2E4C0854185A1DCE7E4E6E4E4E2660124E4E4E4E4E3E2E4E5E2E4E6E5E6E5E4E5E5E4E6E6E6E5E3E4E5E4E6E6E5E3E5E4E5E699E4E5E6E5E8E7E7E7E7E7E7E9DBE8E8EAE8E8E300050A5BE0E6BC4CE5E5D06D103A1296E16F38E2C5AF000000000080D8E4E1E3B10100000020D0E1E3E5E3B1381533261D5743DFE3E4DB0000000341D2E4E3E2121500C5002B00E4E7E34345000E00000022AFE3E5E2E1E3E2412800856880E6E2E10C00001200050EE4E5E5E3E40000000064E3E6E4CDA4E2E4DCE5E4E4E152891241500054E8E5E3E6E4E5D61B0073203EE2E5E4E4410EC7E23107E4E5E4E4E3E52D832D75E5E5E5E5E5E3E5E5BE8038C0C0E5E5E6E5E6E6E5E4E0E44562C9E6E6E4E5E2E2E19928006DE6E6E5E5E5E5E4E6D4E5E5E6E5E6E6E5E6E7E5E6E6E5E4E2E4E5E6E7E6E6E6E6E2E2E4E4E1000000
+                         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002F0000000001000001E1E5E5E4E7E7E6E6E7E6E5E5E9E7E62D00E57A12D0E0E6E6E45F00DF00190001058780E4AC1B0000000000319BE0E0E3E1010C0000432BB1E4E3E490542D0000002438E27CE1B55F0000001BE5E1E3E45D100022000000DBE3E2C2360300002D000026E4E5E3E2E3B51D3600005DE2C7E3B10300000100100022E5E4E3E0001500000041E5E59212E3E438E1E4E2DF5D45240C125D002DE5E4E6E4B1170057004373E2E4E2E2E001E0990085E6E4E2E4E4E43A6AA49BE0E4E3E4E4E4E5E5E3C215418BE3E5E4E5E6BE6D59E46433E5E6E2E6E5E1B5E3E2E2D066E2E6E4E3E5E4E5E4E5E6E5E5E5E6E5E5E5E4E3E5E4E4E6E6E6E7E2E5E4E3E6E6E7E68EE5E5E4E5E6E6D2E7E6E6E6E8E8E8E8E7E6E8332200050305E6E5E6E4DE03120000AA00001B00A8E29F20000000001B9F31E3E390E226033157E1D2E5E4E4C045052400005D38E1D4E2BE50BE2D31208EE4E3E3E15D000C0003529DD8E3E3DB17000000002DA6AFE4E396E15F5F2220EBE5E0E3E39F2F491915056415E27554E3E50500000000D2E3E46200E6E12F8EE5E5E3A8E7E600100C0700E6E2E3E4E3002D8928527AE1E2E7E778D2BE240E33C5E4E5E5E4E3DB59E0711BE0E3E5E5E5E2E3E4E4B39DE6E6E6E5E5E5E6D6E559E5E5E5E5E5E5E4E1BECBE3E2CDE5E3E5E2E3E5E3E5E4E3E4D0E690E6E6E5E5E6E7E4E6E5E6E5E4E6E7E6E8E7E4E3E5E4E2DEE4E4000000
+                          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000310000000001000001E2E4E4E4E7E5E5E6E6E3E5E5E6E7E70000003CDD3A966DD2E2E2C90000010000001924E2E2960A0000000000003180E226E173030700CDE1E2DBAFE49B7E03000000105DDCDBAC7C3E36000C005BD0E2E77107000022007AC5B762D4D40000520000BC7CE0E2E1E0E1E07A0003E77EE2BAD65B9D00003801263C01CDE0751500002415E1E4E3E399E0E14E6FA8E6E5E6E501001B001D1043E4E5E1A6750000004C2D36E4E3E21073501B00B7E3E2E2E3E5E41228E2DBE0E1E5B7E5E4E0E2E3C0C026E2E3E4E2E4E31066E59468E3E4E3E3E1D800B18EE4ACE1E2E3E2E4E3E4E3E5E5E6E6E4E3E5E4E6E6E5E4E4E2E3E5E2E4E5E3DDE4E5E4E5E4E5E2E5CDE4E4E4E7E8E6E7E7E7E7E7E6E6E7E6E6E8000036E2B5E2E0E3E5E5E3E4E20A000000597E99E0D094C23600007107000AE05FE3B3BC00282407DCBE8936E1AF6A3100000003037EE1E5E05F200000000CC2EBEAB1030000101D5B92EA9F28D6363E000000105D2D9D7C68A6411712458EE254E3E2544E0000122B2899DF9FC5AAA61B380015E09BE3E5E5E5E3003320AFDFE4495959832649055FE2E5E3E4546410000317E4E2E4E5E4E50C0715C9E2E4E4E5E6DD317C54175DE6E5E4E0E7E0DFBAE4DFCBE5E3E0E5E5E42D6A62E2E2E4E6E4E6E389DBE5E4E0E4CDE5E4E7E3E4E3E594E4E4E4E1E3E5E5E4E5E6E5E4E4E3E4E7E6E6E6E4E4E4E4E5E5E4E7E5DEE6E5000000
+                           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000330000000001000001E2E4E3E4E7E7E6D8E5E7E6E6E6E6E61903389994E1E1CB36E068E2A11500317A1D1573E3A8DBDE33000C0000002426D2E1C9E0000000009971152D99E19B620000120C262BBCDDC0E1E6003A000EBEE5EA5D7CC900000000E5E8E9890066122D000000265DDBE0E6E478004C001500DB83E3E1BA5401005941A6E2E012E2E4870001122BE2E4E3E5E3E324E09BE1E3E4E5A800100A203C22E1E4E4E4E149030700A8E2E4E4E4E40000000068DFE3E2E3E37507472DE0E2E4E3E3E4E48E66E4E3E6E5E4E6E3E4E41B263E8ED0E3E1E3E5E4E268039FE4E2E3E3E4E4E4E3E3E4E4E3E4E3E2E3E4E4E6E4E5E4E6E5E6E6E4E5E4E5E4E4E5E4E5E6E4E7E5E4A1E4E4E5E7E7E7E6E6E5E6E7E7E8E6E0E7E8E3000000E1E4E3E0E3E3E1E1E0E07E2B01000000AF36C2DE7C0000000000000AE1D88E0043000026000000007AE00A120000000000D0E4A1E6DBE200000000D6E1E9EBE79400000000D6EAE1E580364C000000010017E6E8EBE3E215005B2D000CA4E2E3E24500002BE022000041DB90120024000043E3E5E5E4E5B5C0E6E6E6E4E5E501576F179901E4E3E4E4E33E260007CDE5E5E19F00000001E2E4E3E3E4E457000080E1D8E2E4E4E4E5E5E4923ACBE6E5E5E5E4E4E159E010C7E3E5E3E5E3E3E4E3520049E4E4E4E5E4E5E6E4E4E2E2E4E4E4E6E4E4E5E5E5E6E5E3E2E4E3E5E6E5E6E3E2E3E5E7E7E7E6E0E4E1E6000000
+                            USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000350000000001000001E1E4E4E5E7E6E7E8E7E6E3E6EAE9E7BE00070000334EBAA4DDE2E0E2C99BE11D28000052E0E29F2B00000020000000001DE2E0B7800A28150000646FE1E25B000000000000E5E1E1E2BCD800000022E2EBEBE8640E2412036F9080E7E37A00050000000028C5E094CBD499000000170089E1DCE1150000000A28962DC503430A000305006AE2E6E5E6830019E1E3E5E4E4E12B2B00000012E5E4E3E4E21200410047E5E4E2730000AC2200E1E4E4E55F0007260AE3E3E4E4E4E33EE0E1003AC0E5E5E4E4E6E55400E1E4CDC0E5E4E5E5E5E2E3E4E450E5E7E4E3E5E4E7E4C5E0E1E3E4E5E4E3E3E4E3E3E4E3E6E6E3E3E1E4E4E4E6E6E4E4E5E5E5E5E4E2E2E5E4E7E8E7E8E6E7E7E8E7E7E7E9E7AAE9E07505710057D815C9E2E3E5E4E0E2AF280E0C9D2FE47CE20700000E0000001200E4E35296E08B00001500126FE368DD00120000000059B7E0E2577E1B003871E1E8C773070A000007544E7CE48747240000000000501BDEDEE8E0000000504CBECBE2E5E96624002F1B1B433EE2E101004C000EA1E3E4E2E04E4507006ABAE6B70710156A4131004CE6E7E4520A000000E4E2E3E3000043000000E6E6E6E7E5311B0022E2E5E5E3E6DC00332400B1E4E6E7E6E4E7E51BE10007AFC9E6E5E4E5E4E38EE026E6E7E6E5E6E7E552668EE6E6E7E7E6E6E4E5E6E6E5E7E7E5E396E3E6E6E3E5E6E6E4E4E7E7E8E6E1E5E6E6000000
+                             USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000370000000001000001E3E5E5E5E7E7E7E6E8E8E7E5E5E8E6E8E500000010006D246F9FA4E3E3E4E3C0E33E005F1DE3E05092000000000A0373A4E3E2577AE0E10007AC000000E1CB2F6D00BA00000001C7E3DCDE661D1759DBE5E3E89900000001006FE1E1E4E4E2C7335F3A00000000198EA6A8281500284100BAE4E5EBEA62001726000017DBDB000000000015E3E5E3D05D26006AE5E1E6E4E30000000A0000E4E1E3E4E21D150000C2E0E4E4A42F002D009450E5E5E4E3002F1B4307E4E3E4E4E3E412E4E500E4E4E4E4E5E6E5E5E4003CCBE4E4E4E6E5E3E4E0664EE5E0E4E4E6E5E42BE2E1E2E2E3E6E4E4E5E5E5E4E6E5E5E6E6E7E5E6E3E4E4E6E5E5E4E6E3E6E7E3E6E0E5E5E7E7E7E5E5E6E5E6E6E5E5269FE7E7E9E4150E0A71E09678E2E1A65BCBE0E16D330C0A008BA47105000000001001004CE3E0D49BD89F0000002D1200B5E3E212000019170005E1E4E0BE1B000005B7BADBE5CD00002D000147E0E6E6E4D8243A1B73D2000000E0EB9FD052384700000041B1E5EBE99289B5000000003CC50000E5000000E0E6E5AF781759E7E6E6E7E6E5DB01002200226FE3E1E5E5A6382043E4E1E2E3E4E54147859B64E3E3E3E4CDE09DE4E4E5E4E5E6E5E6C2000000E3E6E7E3E5E8E6E5E6E6E4E5E48EE4E6E65DAC225FE4E5E5E6E6E6E5E59BE7E3E6E6E3E6E5E5E6E4E5E3E5E6E7E4E6E5E6E6E5E6E4E6E7E6E6E6E6E7E7E6E4E4E5000000
+                              USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000390000000001000001E0E5E3E4E4E2E7E7E6E7E9E7E5E8E7E6E7E503150000A100050085D0C9E2E2C2E180D6545DA4E2DCD02B0E0000000000008ED694E3E30001000000000E1BE0E205003112002494EBEAE03A000000000043E2E9E500000000002D15E77EE36D281507000000034389E6E5E1E3E3751D00000C4CE2CBE2AF9F781B1003781B7C000000001D2FC5E4CB070C5B643AE3E6E5E6E5E8E50096009612E5E4E45D833A246F15ACE4E5CD1017450045E4E3E2E4DF3C8E3E1BD4E4E3E6E6E6E138410738E2E6E6E6E5E685E3E4E4E4E4E3E4E2E1BA38D0857CE4E1E2E49DE5E5E2E2E4DED0E6E5E5E5E6E6E7E4E4E2E3E5E5E5E4E5E5E3E4E6E4E4E4E3E4E5E5E6E4E5E7E6E3E6E7E6E7E7E6E6E7E8E9E7000015E8E7E79F1700190100000041E3DE8E667E9FE1AC193892BA9FE17C030000000000006F24E3E5E56A680E2B22070A7EE5C2525D360A005041E2EBE0BE0000E10301E4E7E75400000028386200DF15E4E31700150000473838B3E1DBB3E3BA9F0020000092D2E7BEEAAFDCE3942633003E96004C453822E4E5E3313A283A66E4DF054C2B223E002D00332880E3E48E0000229405E7E5E6E6498B0E4105E1E3E5E5E478E0872B57E4E4E4E5E37A472D49E5E5E7E5E6C03A0307DBE6E6E6E8E5E5E5E2433C36E2E6E6E7E7E7E5E1E3CD94E4E5E5E3E2E4E6E4E6E7E5E2E5E6E8E6E7E8E6E6E6E5E7E7E6E8E6E7E5E7E5E5E4E3000000
+                               USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003B0000000001000001E3E5E6E6E3E5E6E6E6E6E7E5000000C0E7E7E70000033EE500006FE1E48BE24E2D80C26FB3C24CDB5DD42800BE0012C70096E1E3D4E5E00005000000000E7ACBC71200002B0A17E0E6B5E0190000001D64E9EBBA000000000007758362EAE5DB00000000001564474CE56F1DDF0E008000000059E6E2EBC0DEE1803C004100E10A450054E2E3E459500E54DBE3E30000005D002F00E000333EE4E3E457363C00005DE2E4E5E6E5330031E0E4E5E6E5E63AC00028E5E7E6E7E2E4478B003CE3E4E6E5E46205E3AA01E3E5E6E3E5E5E2E6E37EDDE7E6E3E5E4E4E42D00B5E3E1E5E5E5E5E4E5E5E4E4E7E5E2E6E4E3E4E6E5E4E3E4E3E4E6E5E6E5E7E5E4E4E6E4E4E7E7E7E7E6E7E7E3E5E6E65B000083E6E8E8A10003001500202D8EE080E25F0585E2E3A8E15DE2DC54E2190001001B264EBCE3E3787A1900000000000517E3E390000064070C33E1A8E3E1000000009BE7E4E3050010000028504E75E9E79B242D030000121D0000D878DBE2000000150020A6E9E4E2CDE01B000036310022E400006AE1DDE4E4E29F7C38ACE300E4472247260E9D001D4CC0E3E1E20003B3000054E3E4E412000050E6E6E7E6E45743E4DE3AE3E5E5E4E2E219000041E1E5E7E6DF945D8E0C8EC9E6E5E8E5E6E6E5E6E4E5E6E4E4E3E45400E3E55FE3E3E3E5E6E4E5E4E4E5E4E6E6E6E5E5E4E4E7E7E3E6E5E4E4E6E7E5E4E4E3E5E5E5E2000000
+                                USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003D0000000001000001E1E3E4E4E6E6E7E6E6E7E6E600000000E2E0E5C2593600003E288041E2C2D0A84E90877EBEE1DDE1BEE199E10000003328E1B1E2E0E0800000002400000052C2E4A68000000000005B62E4E3330000D0E2C0E4CBB5AC22E3000000000C85E7C2928017070057000000B5E58592D2000000009B68E5E3E2DBE200107CC20000E2E56A26E7E3D0E0E4E41B00E0E4E626D07A262083002B000083D4E1E1DE0000E400001DE3E4CB00A44E0A43E4E5E0E2126F3A0A0AE4E5E6E6E27868BC003EE2E2E2E1E22B28E3E1AFDEE6E6E5E5E4E6E5E2E4E5E6E6E5E3E00A12E03350E2E2E0E5E1E4E3E4E4E6E5E4E4E5E4E6E4E5E5E5E4E4E5E3E4E2E7E4E5E4E3E5E522DBE3E6E6E6E7E6E7E6E7E6E6E417006F1980E4E3E443190000000E6D718BBAE119191D660CD8E2E2E3DEE092640038663C80DBE2E4DCD8101B000000002D003E6ADC712220000000000E50E9E7E171151D0010CBE2E2991500010A00000000E1E38B332400380000000022851DDC9F170000000A8083EBE2D0E2E31B22006A1285E1E2E3EAE7E2E3E1D028283EE2E8C9070A20DBC954753C1000E5E4E5DC22226800002DE6E5C70105003349E5E4E6E5E54C2431E5E3E4E3E2E3685B6D24E1E3E3E6E5E47E5F595728E7E6E5E6E73EE1E5E5E4E5E5E5E5E5E4E0D4E317E0E5E4E5E7E5E6E6E5E6E5E6E6E7E7E6E4E3E3E4E7E5E5E5E5E4E5E5E6E6E6E6E4E4E3E0000000
+                                 USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003F0000000001000001E2E5E5E4E6E6E6E6E7E7E7E8E400177EDBAAE4E7ACA6000000000012C0E2E30000380E0150BC6DDBE2B3685924381D9017E2E2E5C0E0E394DD57001000000C01CBE27A5F008B380024E2E1EBE95900000000387C2B9466000010000000E1A6E4E4E300000000710000104185BCD0781000200092EBE1E3E0E0E26A000000992026C2EBC0BE49DD6D942FACD6EAE6B1E3E343E4000073288B3EE3E3E3BC3AAC00220A41E2E7E25417002BB3C2E5E5E4E08E5B17E4E4E2E5E4E5E092E5E4E4E2E4E5E5E1E226945922E0E6E7E666B1BCDEE3E4E5E4E5E5E4E3E5E3E2E4E4E5E4E6E5E5E5E5E7E6E8E5E6E6E4E7E6E4E5E4E4E4E5E5E1E5E5E5E5E4E4E5BCE4E5E5E3E4E7E6E7E7E6E7E9E8E8E8E74778E5E4C7CBE3E33E00000015000017E2C2150007008B034E204178E185E1E13E2FAC077C7EE1DCE4DDE5E1E13E00005D1768D6895931000E01246292E1EBB35D0000002B1B00456F9654071719000100BEE4E5E50E000000000000000000B1E8E245001792DCEBA8E0DFC5E28000000C909D28B3C9EBEBE2E4E5A83AC57C64E2C2AFE6C200001B00000096C9E5E4E2BAE3BA000545E7E4902062E5E43CE4E5E3E5175D1092E4E3E4E2E3E31010C2E6E5E5E6E6E7E7E5E3544CE4E6E5E4E4E2E666E4E4E5E6E6E6E6E6E5E2E5E4E4E5E5E5E4E6E6E6E3E6E6E5E6E6E6E7E8E5E5E4E5E6E6E5E6E8E1E5E5E8E7E7E77EE371E3000000
+                                  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000410000000001000001E3E4E5E5E6E6E4E4E8E9E8E9E77E00000041E3E7E30503000000000C00C9E3641B241B00000C104E89DE5971125D07120EE26F079DE4E4E4D0B7002B0000000036E1DF891900000005AAE5E90019000000190003E57385730075000033000000E3EB544900000000000000000087E13A000019C7E5E345E0BAE2EB64001500E2E4E0CBE0E5E1E3E2DC0EE05FE2BABE0C38120A0059593E009FDEE5E4E3E2E0E30024C0E4E5E30571C57350E7E4E3410100642F71E3E5E3D29B99CB5DE4E4E3E6E5E35D5B0EE4E5E5E4E1E2E073960E85BEE4E3E3E5E4E4E5E5E3E4E4E4E3E3E3E3E4E5E2E6E5E5E6E3E5E4E5E5E6E3E3E6E6E7E7E5E5E4DFE6E5E5E6E3E3E4B7E5E7E7E7E5E6E6E2E8E8E7E7E900000A00D0DFB7E5E1070000000000A1E2E0E200000005120C0059CDE0CBC989521003DFE1121BA12D94E4E200000005330000008EE3E2450E010000BAE2E4DE2F000000430000E8199B2D3A00000000000000E2E6E55D00000700000500229228E1A6003C00E31B45159FD8E396870003000CE4E3EBEBE8E6E4E568890ECBEAE2E4E3000000000000001B80E2E4E3E4E4E5BE171536E4E5AF100EBE2489E4E4E50E0EC0206496E4E5E6E5A817003CE4E2E4E4E6E399D6E5E6E4E5E6E5E4B766D038285DE4E3E5E4E3E2E4E7E2DEE4E1E4E5E5E5E5E4E4E4E3E6E4E5E4E6E4E5E6E5E7E4E5E4E6E6E7E4E5E5E6E5E6B1E5E2E5000000
+                                   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000430000000001000001E2E4E4E4E7E7E7E7E8E7E8EAE1B100000000BEE09B2F00000000005B9FBA2B57050000003841000062C5E2E3D07E9D196F891D00000036E2E27500000062000000E1E28BE1B5008E1722C7E3D4BA9F5F003A3E008B7C3671B5000000003C0000A1E8E93300000000AA411B00006AE17A1BE6D6E7003E49A6DBE3E792AA00000024E5E9EBEBE6E4E500001000170EA8E3E4D6360E001233C9E4E3E3E4E3E2E3E320CDE4E2A47810500C20C5E6E3E33A470000E1E6E4E5C73300AA0092E4E3E4E4E47347E2E4E56AE5E4E4E494E5E54C8BBEE3E4E2E3C50050E2E3E2D2E1E2E4E6E3E6E4E2E4E3E4E5E3E6E6E689E7E5E7E6E6E7E7E5E4E3E2E5E5E5E5E2E2E2E3E5E7E7E5E6E6E7E2E9E8E8E8E9E80503E059206AE547012B0000002D3875B54ED033000000000019005BE3E157E0E07EBE0A0015310E00CDE19D000000000003E2E1E2E2E1012600000036E1E03A9B31007A64500E28B168E500000000170000BC0001E900000000000000000096E26A001D9226190112AFD6E5E86F6F3C003305EBE1EBEBE4E3E3E3010000004390DFE3E3E50028C9E6E1E6E4E6E2E4E3E4544C7CE6E4E5E436DB3600E5E6E6E1D685159FE5E6E6E4E2960000008EE5E4E6E3E23E94AFE4E5E5E3E5E4AAC2ACAAE0D4E4E5E3E4E068E4E112DDE2E5E3E2E2E3E6E5E4E4E2E4E4E3E3E5E6E5E4E5E6E4E6E7E7E9E5E5E6E4E6E6E5E7E5E3E3E3000000
+                                    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000450000000001000001E2E5E5E5E5E5E5E5E4E5E5E6E7E5E7E8E03A1524E3E43A68000012100047D8E100075200000000000E8EE1E28BE185E4A8AF4CB55D002F9BA4E119000003001B3373C7E4E319006F000375DCE0C7E1102BC54920000000C0E00000000C000000030096E40000000000000000007EDBE1923EEB3819623371E0E4EBEA1B00126D0000D4EBE8E4E3E1E0101D00052B3817E4E457312F454CE4E5E6E6E2E5E7E6E7E3E2E4DFE4E3E3E0E200E3E3E5E5E5E1E5E5E4E4E6E5E6E4200001E2E5E5E46D1B0000C7E4E5E4E3E3E3E4E3E58971E4E5E5E4E2E152DC6A00D6E4E3E2E2E3E2E3E5E5E2E3E4E3E2E2E2E3E3E6E5E2E6E2E5E5E6E5E5E5E5E2E7E6E5E7E6E6E3E4E6E6E6E7E6E6E6E7E7E7E7E7E8E8E8E77E0C41E2E5E68B00030A05009D71C90A38680041000A0000AA57BCE5E4E3E5E16FE33A0C2BA1E3E0E2E2520005005F009DE3E29D1900000000E4E0E5DEE1AA6F0E050A00003AE8E6DE5B1D0000009D501BE6E9000000004107AA224C24E0E5809B3A410012000003E4EAE82B2F0000001DE3E5E3E5E7E9E5E5E000007C572BE1E29F073617009BE554E4E4E3E4E40C00339FE5E6E5E34347E4E3E4E5E3E6E6AFE3E3E2E7E7E6E70520A6E4E3E5E5A622E32807E2E5E5E6E6E685E4E45438E6E5E6E4E4E1AAE11733E2E3E3E2E48594E5E5E5E4E5E4E5E3E4E4E4E5E7E6E7E8E6E6E8E6E7E6E6E5E4E6E6E6E5E4E2E5000000
+                                     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000470000000001000001E2E4E5E5E7E7E7E6E8E7E8E7E5E6E7E7E8E7ACE6E4E6E5DE85000000002D50C000CB47002012333C490E002D7EE3C0E5E2E1105F100005E3E1D4DE41000000470000E3D4E1D40007002645E3E2E0E0E2158524DF0005A4E2E5E1360E1B00000071D4E1E94E2B20050E000A0C4C506AE2E2E5D8E74E000000E5E3E450E3E1000A00A89BE3E2E3E380E20043900026E0E3E0755B5252120C00B1D6E1E2B7E43100DB0050E3E6E7D05700AFE5E4E4E3317C20E2E5E5E3E4E69D1919E6E7E3E4E4122817520012E4E4E4E6E559902857E4E5E5E5E475AAE2DE38A4E3E5E5E4E2D896E4E5E4E5E5E4E4E3E4E4E5E4E6E5E6E6E4E5E4E5E7E4E5E6E5E5E4E5E6E4DFE5E4E6E7E7E6E7E6E6E8E7E7E7E7E7E7E7E6E4E1E0E3DFE3E4AF1700000012284592DC663E000E0000001B927AE1E4E4E4E5E1A65B0000002D52E4E46A171000000000E1E3E3800E66244771AFE2E0DDE83E503A220087E0E3E7E3E22B000100243A59C5E775AF9F313E2000000073D4AFE8E8E6DF05000003EAEBE6EBE1C0802F002B523A71E4E2660000E22F00003A6690E3B520001D0000005980E7E5E6A13EBC1771E3E5E55F45339024E5E4DC33264966E3E4E5E5E59D1D57E6E6E7A4E6E1380C7350E2E4E4E5E7E580E0D092E4E5E8E5E6E5E1E4D6E1E6E2E6E4E5E4E4E2E4E6E4E5E3E4E3E3E4E4E5E4E5E5E6E5E7E6E5E6E7E7E8E8E4E7E7E7E7E5D6E6000000
+                                      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000490000000001000001E3E6E5E6E6E7E6E6E7E8E5E7E6E7E7E8E6E4E7E7E3D4E3E3DE45003C000E6A22BEE1B1010A0000870054A8B5CDE5E5E689B7E1360000000A0EBAE3DF750007001B1B05CBE2E2E0457C471D2B1285D8E7D0410031BCE1C9E5EBE4E233000000244C9D5FAF92E0BE0328000000000057E7E7EB3E000C000000CDE9EBEBB5C968107E2F38009DE5E7730028003E001900A4A6E3E3220312E6920000E1E1E2DF57A68E3328E4E4E48771E2E25DD4E6E48B785DE3E5E4E2E3030C1536E3E5E3E4E4AF9FC94783E4E5E6E6CBE0E6B5E3E4E6E5E6E6E5E689D054E2E5E5E5E4E4E4AFE3E6E3E5E6E3E5E4E5E3E5E3E4E6E6E6E6E6E5E4E4E4E7E6E6E8E5E4E5E5E4E5E6E5E7E7E7E7E7E6E7E2E5E7E6E7DBE8E803E5E7E1E1E5E4E3E3E1411B005B719DE1E0D4C91D000000001D174CE3E2E6E5CD5B5700006200001278E1E473830C0510203194D8E25BC9150E00150062E0E2AC83154E78D4E4E5EBEAE5E2E4E03600361B19AFE357890A000C0000000007E5EBE45B0ED00A0A2F26E2E8E6E2E1E1009F52102BDFE1E5C9101700193103E49F85E52836000C5B12001792E1E4E16D337E3C17DBE4E5E6BEE6E16894E2E65F1794E3E5E5E5A10000006AE1E4E5E4E33CBA5FACE2E5E6E6E4A42857BA85E5E5E5E6E6E7AFE58533E1E1E5E5E3E6BAE4D2E5E4E3E4E5E5E4E6E4E4E3E4E6E6E6E7E5E6E4E3E5E6E6E6E6E6E7E7E6E6E6E6000000
+                                       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004B0000000001000001E1E5E5E5E7E7E7E6E7E1E7E6E6E6E6E6E5E5E4E29FDE49E2E1E3E1E28075B1E2E4E3E43322001200005B0068D8E3E1E2E4E319000000000000D0E2E39BB50C0100280C1252E1D4E28900000019BA96E0E2CB450300D4A6E4E5E6E6E5E0E3E08B9F190C3CC2D06D1B00000000005447E2E8E4D8000000000038E0E4E3D8E2E10C000026C9C0E2E41964000001001700E4E2E5E04100000701000A4154E1E4D06F730180E2E28BE4E3E5E52B2BE3E4E3B7E3E5E6E4E4010031004C52E3E4E4DB00310000E4E4E5E5E5899DE44EE5E6E7E8E5E4640EE3D2E2E4E3E3E4E3E2E1E0E2E2E3E3E4E3E3E3E4E6E6E4E5E5E6E5E6E7E8E6E6E4E4E6E6E6E7E6E5E6E5E5E6E3E7E7E7E8E7E5E6E7E3E7E6E7E7E7E8E557385219A628DBE2836F49A12B789675E1E03A5B12002F73AFA4E1E2E0E2E3E2E16D9400002800001D948EC7E17CA1000000173368E3E4990000850015D0E3E2AF15000C0001E0E4E0E4E5E441B1E3E20728E2E3E1E39D000041000022504CE2E531150C0300003864C9E1E5E55D524E641064DEE6E7E3122D0007E500001DE3E27AE200BE8EAC002BCBE4E6C0E57322B7E5E2E3E5E5E4E3E47300E1E4E4D6E4E4E4E5E45B00000092E2E5E6E6E40ADF3E28E1E7E6E7E2E4E79D6DE3E5E6E5E7E6E7DF5700E5E6E3E4E4E4E3E3E4E3E3E4E4E5E6DCE5E5E3E4E1E6E3E5E5E7E7E5E6E6E6E5E3E6E7E6E8E6E5E3E5E5000000
+                                        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004D0000000001000001E2E6E6E6E6E5E7E6CBE6E62BE6E5E7E7E34531192003DFDED8E1BE000000102803AA5038002F00190049B189E3E3E1ACE1E3CD3C00050010001B3EBCDDB7A42F012DD236007AE2E2E03A000000013C73E1C7C222200A006250E1D0E4E3C70C1700B580E3DBD0B5E4D8000000A622C7E073D2E1A843001B28177CE2E1E3E5D6A1174741A694DBD89DE5E20000000A171592B5E1E4E2E13600A6477EE3E54CB57C201BCBE6E5E4E4E4E2E4A6171599E4E3E6E0E5E3E5DE00003AE3E4E3E5E696103A0089E3E4E2E4E0E0E5A457E5E5E5E5E6E49999E3E4E5E4E6E5E5E5E3E3E5E4E3E4E4E3E4E4E3E4E2E1E1E2E4E5E5E6E6E5E5E5E6E4E4E6E4E4E5E4E7E5E6DBE5E6E6E6E7E7E7BAE6E7E6C9E5E7E6E9E5BC004C000071E078DF50000000000A00D2A801000C003A0059629BCBDEBC73DEE3E3E32F2600000000008B45E2E09D0038E3310743DDE0DB6A000A12052443A8E26F5F0000000028E1BCDCE37C0000000000DFE6DFE0E3E0CBDB1924B7DBE5E36DE58515AC1000151B24B7E1E399C06F2620D29DE3E4E3E4D20C570010157AE7C0DCE6E3E3E3DCE2000EE4E2D85007006866E2E3E1E4E5E5C91D3115E0E3E5E5E5E6E5E43C2B542D17E4E5E3E2335F0036B3E2E3E1E6C58968D483E5E5E4E5E6E200CBA1E2E3E3E3E5E3E3BA525DE5E3E4E4E3E5E6E4E5E4E5E3E5E3E4E5E5E4E6E6E6E6E6E4E7E6E5E6E4E4E4E4E4000000
+                                         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004F0000000001000001E3E5E7E6E7E8E7E7E3E7E5E4E6E4E7E7E3E500172B00385DE2E3411D0000002D43D8DF001038002D0E68E0C9E14C730E416AE2C7E25412000000005DE2E1835B8000000019AADEE2DEAAAA22151700E392E138000000920038E2E4E15D361500470000948BE1E1E1E1DFE1E3C2E0E2E4D87EE4E3AC170000001DC54EC0E4E3DDA133077A7CE2E4E3DD7A0A2B1D5000001BDC64E3E4E4E4E22B0041E147E43845000000AFE4DBE4E3E5E44C001DC9D0E5E3E4E4E5E5D2C7E1D4E4E6E2E4E4E1BA785068E4E3E32D640024E3E3E2E4E5E4E5E4E2E06AE0E2E4E5E4CDE3E2D2E2E2E6E3E4E6E4E0E3E3E3E2E1E4E3E3E3E5E6E6E6E7E3E5E4E6E7E6E4E5E5E5E5E4E5E7E7E7E8E7E4E7E8E8E8E6E652E6E8E8E4001500000022DEAADE0000BA570059A1E4E4265F0000009FE1E3C9782B3615C0E2E3A41D000000A10094E19BBCE3430E000000473AD089CB2F0000000E71E3DD6600000000005778E5E25D120017B7170000005FD4E4642F80E2E5E2E5E3E3E2E4E4E300260000173C03E3E4E6E550494C1B243EE5E2E28B150C00123E010EC752E5E2E5E0EA2B0000D0E57A5B1B002B01BEE4E4E2E0628B5D0038E5E5E2E3E4E5E3E5E5E5E3E4E4E3E4E6E2E3DB807CE5E5E6E5A8BC9F0033E4E4E4E3E24926008B24E3E3E5E4E322C7BEE4E5E6E5E5E5E4E4E1E3E5E4E4E4E2E5E5E6E5E5E5E4E0E8E6E6E7E7E6E5E5E6E5E4E5000000
+                                          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000510000000001000001E1E4E4E5E5E6E7E7E6E7E7E7E03307E7E8E8E0220000002D90E3E18B00000000003CC96D57190047ACE1DDDC9F41000E004E59E4E42800000000006AD4E1E2DB3A280000000000E380DFD0006F005422DFE27500030000005452D6E554751B000000000000338096893E00E266E1E3E1E0AC66E36200006200000A9BE4E4A4C9BC055726009DE6E5DC52013C000000006FE0E1E2D000787E830000B79BE33C5B891745E3E5E5E4783A0E012D0EAFE3E3E2E3E3E2E6E4C55FE3E4E3E4E3E4E4E1E1E4E5E4E4E35D12DC0143E3E4E4E5E5DD8EE35089E6E6E6E5E3E2B1E4E4E4E5E4E3E3E2E3E2E2D2E1E4E3E4E4E4E6E5E5E5E5E5E5E4E5E5E6E5E5E5E5E3E4E5E5E5E5E6E8E8E7E7E7E8E7E7E63E03E6E8E5E717002205667AB7E3E1000C00AFE1DEE389264C2D716F3675E1787822005D7E36E2E3AA000000000100B5E1E2E4E11B33000000363CE2E3AC5724050A9DE2E359E35F00221D4C68E0E4E18771070000960000229BE199000075786DE2E3A49B2DDBE1260000000000D0E4E6E65D8500001B38857CE3E38E00000105000C31E0E4E5E1200000000A7517E2E29DE0946619E5E0E5E1B38000AC9900E4E3E3E2E3E4E36F5F59C5E5E5E5E4E7E5E6E1E5E6E1E6E4E5D071DD17C5E4E5E5E5E37CE3E5D8D8E5E6E3E5E5E399E2E3E4E4E6E4E6E5E2E3E4E3E5E5E4E3E4E6E4E5E4E5E3E4E6E6E6E4E6E5E6E4E6E4E4E6000000
+                                           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000530000000001000001E5E7E6E6E8E7E8E7E8E8DCE6E8B1BAE6E7E6E72D002F3C1D0CE0E1E47822003C0059E4D29F994522000024E0E1475712121BACDBE2E0B5030000010A6F3AE4E178262D0100031728C073E068005B3A057ED489E3A4190C1200B3E249E6C2311500000000263C0CE05B00006A75E2ACBCE56AD6E2E0CD2B0000010012D2E4E5B3BA0A12000012A8E3E4AA003300C2000020E5E4E28B2D0000006F7A00DDE478AC68203EA8E4E3E1E3C5E33A0500E4CBE1E4E6E5C03A7538A6E6E6E6E6B5003E15E4E8E5E6E4E3E4E2E5E5E4E6E5E4E3C7DEE3E4E5E6E7E8E7E4E3E5E4E4E3E5E3E5E7E4E3E3E2E1E3E3E1E2E2E5E6E6E5E6E4E6E6E6E7E7E7E7E7E6E8E3E4E4E5E5E7E7E7E7E6E7E6E9E7E8E2E7E7C985E8E7E4E207051B1533E6E4E35D1703220E5792E06FA44100002F1B2DE28E2F2F00073E9DE2BCC0B30A00005D243671E1E08EAF030000331B00E1E5DB89E0261226E3E3E3E09462002D2F78D0DEE45B07000005000017B1DFE2071D053EE34C00E0DEE3E5E41519000000003689E5E5360500200000269BE4E5BE941D00100005E3E0E0B100410047310000E28EE6E47305124596E4E5E3E4E3E371472FE5E0E1D4E4E32F000028E287E4E4A60000001DE3E6E6E6E5E6E7E5E6E5E4E7E7E6E2E0E3E0C2E5E3E4E5E6E5E5E3E6E6E4E6E4E4E7E7E3E6E4E3E4E1E3E3E5E4E5E5E6E5E5E5E5E4E5E7E6E6E6E6E7E6E5E5E5000000
+                                            USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000550000000001000001E4E6E5E5E6E6E7E5E7E7E7E7E605003C5BE1E2D0318900000033DEE2D050152B0533AFE3D85D153A2F0C1717C7BE522D410E3E36D6E2E2940000005900033ED6E49496380E310A3E529BE1E1B12424030159E3B39B94170000006ABCE1E4A1900500002B001712A668E27C0043337A1B2F8BE1D6E3E1E0000000001B41B1E3E2430090000017E2C5E5E310680050200A26E3E7E1A4E1000E000000E2E6E5E2C5B33AB71BDEE5E5E2E1529D26031D90E5E5E6E633006D0E9DE4E5E6E60AE10C85E6E4E5E6E68E49D4E5E6E5E6E7E4E4D092E4E5E7E5E4E4E5E3E3E3E4E3E3E4E4E5E6E5E3E6E4E4E5E5E2E3E4E6E6E5E7E5E6E4E6E6E7E5E7E6E6E6E5E6E6E6E6E5E6E6E6E8E6E7E7E7E7E6E6E300001920E2E3E2E1D000000000DFA87A0741360A1B38E3E39B00311B904E07318752220A100A7E94E1E3AF4300002B000712BAE3E12801002B3319A1BA87E0DE50001000C5E3E380A80000B7000094ACE3E0572D502824000100D00790381BD8000000002447E2E1E3E100000000000033E3E2D65000010007AFE3D0E46A0A5441170E00DFE4E5DE240500001200AAE3E4E3E23A41544703E4E3527E0312E50054D2E3E6E6E69D3E3E66E3E4E7E6E700575F015DE4E5E5E445921DA4E2E5E7E4E4E3E4BEE3E4E6E6E5E6E5E4E3E3E3E0E3E5E3E5E6E5E6E3E3E2E2E4E3E5E4E5E4E4E5DFE6E5E4E6E6E6E6E6E7E6E7E6E5E5E6000000
+                                             USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000570000000001000001E5E8E7E5E2E7E8E6E8E4E5E57C00000E78C0E5E6E12F000100009BCDA40A017100003CAFE3BA0C070054000036E33A4717000015C7C0E5E12B6200032028009FE1E36F579B010E7822BE80E4CD2015E30007CBE2E2E124000000002B80D6E1A63A190000000000AAA1B3E2E3E0D000E10000001DC55BE336000000247A6285DBDBA40000000057665DE4E4C0D8000500571BBAE5E194012424490EE0C0E3E3E22400000059E1C29417500126DE80E2E3E6E6E6E6DF49E4E5E5E6E5E4E5504C01DEE4E3E45D5F5924E0E3E5E5E3E5E41B9FE5E6E5E6E7E4E5E4E5E4E5E4E4E2E3E5E5E4E4E3E1E2E1E3E5E5E5E4E3E5E4E7E6E6E2E4E6E6E7E6E6E5E5E5E5E6E5E4E7E7E6E7E6E7E4E7E5E6E500E1000000E2E4E3E100000000005BE2C5000064000524E0E3E21045000000241DB147000092000047E0E2A8A4850C1D00009BDBA4E0C5DB9F170115000C43E3E00000000000DFE1C959C90700001DC0A6E2E2D8C7AC00015D0000C9E0E1E0E1000000D0001000D0D8E2E1E3E4E2002D78B7E2E3E490151900053AA6E2E49478261505008B0185E6EA66D633336F4700CDE5E5E7E38320001BE2E2AF6F5073D287DDE3E0E1E2E53C547CDEE3E6E7E7E8E6D2A47CE3E4E4E56D201000A8E5E5E3E6E4CD68E03EE2E4E8E6E5E5E5E2E4E4E4E5E1E5E4E4E3E3E4E3E5E2E4E4E5E4E5E4E4E4E5E5E4E3E5E5E6E5E6E6E7E6E6E5E6E3000000
+                                              USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000590000000001000001E1E5E4E1E7E6E6E6E7E7E7E7E3050010B5C783E5BC960003000A0052E14C003C00A60024D2E1DBA4C700002007475F00000000006FBC75E2E1DF26331700491BA4E1DEE000660000000071E1E03E000000334CDFB3C9801D00001D3600DD68E11B33000000003EE0E1C9E2E0D405003800000022C9E0E0E3E3E283192B50DFE2E2B11D710043005D73E3B12B000700E20003DDE7EBC257734C5062629BE2E4DF3E717A5B7CDCE2E3503E87E405E4E2E2DDE1DD33D257E5E5E3E4E3E4E4E5B57AE4E4E4E6A4311900E1E5E5E2E16AAFE3E043DDE3E4E5E4E3E2E3E5E5E3E5E4E3E3E5E5E4E5E4E3E4E3E4E5E5E4E5E5E4E5E5E5E4E3E4E5E5E5E6E5E5E6E6E7E6E4E6E8E7E7E8E8E8E7E6E6E3E7E2E76A125B4EE5B57A0000005B006FD09038000503002BE0E39D94A42B07011D75DDC9282F12002BD2E0E2DB1BB3620000001D002FE2C5AA380000410A01E1E3E03C00000117E0E3E1E1A600330C365DCDE2E1E0A105000000036ABADDC2E0E15B0031012B009673E3E1E3DEE1BC004E3EDDE2E0BC0000000300BC50AAE30A173E3CE56603E1E2E9EADCE5E2DDDCE3D8E4AF3807CB000028D4E1C007DE9D8B96E6E4E5E5E6E894AF5FE3E4E1E2E4E4E06AE5E4E5E5E5E6DBD6DB00E6E4E5E468A8E3E4E3E3E4E6E5E4E3E3E4E3E2E2E6E5E6E6E4E5E2E5E3E4E6E3E3E2E3E3E6E5E6E7E6E5E5E5E5E6E4E6E7E7E7E7E6E3E5E5000000
+                                               USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005B0000000001000001E3E5E4E5E6E6E5E6E6E7E5E5E8AF9F000000C9E4E5E3150000050000D8CD4E4E96123EDDE3E37131000000000075E1C07838AC0005B5B7E4E3C70E0000000000006DE0E3E3B52D00000C24E1E0D2E22B2D19129DE3BCE0E00C1B0038C5D8E1E1E15B1D0000000A1D4ECBE0E0D800002F00001959E2D0339D00003ED400009FE2E2E12F96000000200062E39D220000E4BA0047E2E6E87524A4E2E0E2DBE3D6E1E3E3E2E3E4E6E4E2E059C250383EBAE1E3E436383CCD52E2E3E4E3E4437383E3E3E5E3C0A4E3496AE4E5E5E4E7E4E5E3E2DDE5E3E3E3E3E1E2E3E2E3E4E3E4E5E4E4E2E3E2E3E4E1E6E3E4E4E4E5E5E5E5E6E4E5E6E3E4E5E4E4E6E6E4E5E4E5E5E6E7E7E7E7E6E7E7E5E5E5E9E7AC0E8E000CE0E190E25D00000000A8874C38105B31E0D0E152070E03000A008EE0E2924141100050B5E1E1E1AC07005000244141E2E5E2D62B032417073CE8DFE19600282633E1E2B3005003030A28283AE0E26D2F00000000014171E6E3A6000000000038A6737EDD280C0000E1B59B85E2E2E3E11D00001D018075E3DF3805016D0003D4E3C7D23E0C0E2249DFE0E4E6E5E4E4E4E3E5E6E6E400E0E31924E0E4E2E5B30E1700AFB5E4E5E6E519193333E1E6E6E5E13126A868E4E4E4E4E2E5E5C954E1E2E3E6E5E5E0E4E3E4E6E6E5E5E7E6E5E4E4E1E4E5E4E5E5E3E4E6E6E6E6E7E7E7E7E9E6E3E7E8E6E9E7E6E6E6E5000000
+                                                USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005D0000000001000001E4E685E5E7E7E7E7E8E7E7E6E9E5E53C43010A22B5E4D2780085000087E4000A01E2E0E2B3641B0054050500005233E4E36A361900008EE4E4E4D08B101B003A07A6C9C5E4891736005F2283E1E33A0000000199DBE29BB7A6050000001B0080C9DED65F0007000E2490E3E2E0DDC003000107385DE3E39F00011210E2DCE1E1E3E4E5000068800028D0E6E4DE011200730075DFE2AC0C1D0015284CE0E4E5AAE1E3E6E4E4E5E4E5E2E3001983D8E4E5E43354D62226E6E5E5E4BE00003610E4E5E5E5E4DE9F009BE6E7E0E4E59DE6E5E3E3E4E4E6E6E5E7E3E3E3E4E6E5E4E5E5E5E6E6E4E4E5E4E6E4E4E3E5E4E4E5E7E6E6E6E5E5E4E5E6E5E7E7E6E5E6E2E5E5A4E5E7E7E7E1E6E7E7E7E6E9E8310020030E17E2E3DB0500000001D200003164D6E0E0646D00000A05002B59DEE48E7A6600000017A1DCE1E252202233000052AABEE5E30E000054053A64E4DB00640000E3DDE3E1E49F17000E000CAFC0C7C21200000020DB00E37CE2E1E2A8903600003A24ACB1360000000092E2E3E1E1E4E4E30000000001C7E2E4DE26C533E1D44331C7DCA4C910A10045BEE3DC503A7EE3E4C7E3E4E5E6E5E12243E2E4E2E2E1C5000010E5E5E5E3A10A80412FE4E5E5E5629BE2A810E6E4E5E2AA6F00E1E4E3E5E5E6E5E4E4E4E2E6E4E5E4E5E5E5E5E4E4E6E7E6E5E5E6E5E3E7E5E5E7E7E5E5E5E5E6E5E5E5E5E7E7E5E2E6E7000000
+                                                 USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005F0000000001000001E483E594E7E4E6E7E6E4E6E6E9E9E9E600203E0066E2E3E2C707000000E220265DC5E0E18389E0A605002010458BE3E3E2E1750000287C5FBECB80CD73E05D0A001B2F03D8E3625B00000000BED89B00000000D8CBE4C7968B2F000000000036D2805400001B000000BADC68B380CDDFC20000000589C7240043000000C771E3E3E2E2E3BC241000005950E3E1B3DFE1E3E41D3ECDDEC72B360000BCE3D012072D52CDBAE2E0E3E5E3E5453CB5ACE3E3E0680CE52819E3E4E3E3262400B7E0E5E4E1E3E30A12002DE6E4E3E27EA4E447E4E3E3E4E7E4E5E4E6E3E5E4E4E4E4E4E6E5E3E6E5E4E3E4E2E4E3E4E4E3E6E4E5E6E4E5E4E7E7E5E6E5E5E7E5E6E4E6E6E7C7E7E7E7E7E6E8E8E8E6E6E4E6E17319152D1DE1E396AA5F00336DA120330045E1CBC77EE4DD75000A00006FAFE4E3DB170A0000196F68DCC5E2A4BE52010019016475C9734E0E07000000E2852F0C001D1B20E1E3C0DE960007000C3ABAE0E1A41B032B2FDB31E10033A1E354E3710005000000E0CD00010C0000009971E5E5E6E5E5D80E001787E1E3E37CE1E3E1E09BC95FE3E183545920E2E2960059A6A82D71E4E4E5E3E5E3E26843D4E3E2B38BE0B14E78E6E6E4E5572283BA57E5E8E5E4907CC987E3E5E6E3E2E5B3E5E1E4E6E4E4E5E4E5E3E5E4E5E4E4E4E3E3E5E4E4E5E3E3E3E3E4E6E6E6E4E6E5E6E7E6E5E4E6E7E7E7E4E5E6E7E6E5E5E4000000
+                                                  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000610000000001000001E6E6E6E6E6E1E3E5E6E7E6E6E7E5E5E4E4D60000010000C9E2E1E268DDE12D001DBE2403624CE3E1E2A63C7A208390DCE2D88000781D0036DEDCE1C0E1E1C0AF280000000000E09F1200000012CDE600004E0100D2C0E0C9A49F0000000000010000DC7A8E263AC9E194B3DFBCDC0000E10000E2000000CBAA0E01000322193EDFE2DE87000000E2007CE3DDE2DCE2E3E2E19D7A8750DBDEE3E2E2C7C75B000E000038E3E2E3E1E5E7E5E5E4E1E2CBE3E6D6411B855289E4E3E3E5416AD2E4E4E3E4E2E3E2A6E5E5E4E0A1D4E4E3E4E4E4E4E5E2E4E3E6E6E5E5E5E4E3E3E4E4E4E6E3E4E3E4E3E4E4E4E5E4E4E5E4E3E8E6E6E7E6E5E6E7E4E5E7E5E5E5E5E5E6E8E8E8E5E5E7E6E8E8E8E8E3E5E4E2E1E1000000001719BAE0E0E2E2D65D5054903C280000E2DFE1B36F2424240E24E0DBD62B00000087493CDEBCD8E49092000000A4002696E0DC0A0000009BE9E1B5000000ACA1E3B7E201000000000000004EBAE0BEE3E1DF99A4CB6800000005174E000000000087E23E590A00000A00A8BEBCB73A0E000000385FE1E4D0E5E4E43C005915AC6AC2E1E4E4E2E30515360071E3D2E2CBE8E4E3E3DEE3E3E2E4E4E6E038E49000E4E3DBE4E500009BE4E5E3E6E1E2AFC0E6E6E5E5E5E3E487E4E6E6E5E6E5E5E4B1E5E5E3E3E2E5E4E4E5E4E5E5E4E2E5E1E4E4E4E3E4E5E5E5E6E5E6E6E4E5E7E7E7E5E5E6E7E5E4E6E4000000
+                                                   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000630000000001000001E3E4E5E4E7E8E7E7E8E7E6E5E6E6E4E6E400000000000049A694E17392E23A45B7470A1D714EE2E0E09F570E0010003AD8E39F0E000C0C9B90D6E1C26DE3E073000000000092E2E2D2D05B0010DFE7E72F000000002F62E0C54E00000043000000150AE00052BAE1DEBEB53A4C0000008764000000000110A805000000000000DDD2E18B9F4E2D00498EDBE1E4DBE3E5E3E34C15416DCDE338E2E17C6A6433665B80E4E1E3E6E4E4E4C2E1E4E4E5E4E9E4E2E09F8092E0E3E5E56607A110AFE1E2E6BCA8E2A4E0E3E6E7E8E5E2E2E0E3E5E4E5E4E3E3E0E2E2E2E2E2E2E2E1E0E5E6E5E5E6E6E4E4E3E5E5E5E5E5E4E5E5E5E5E4E5E3E5E5E5E5E4E5E6E4E6E5E5E7E6E7E9E7E7E7E6E7E4E522E2E5E4E2D6280C000010001538E3A6CDE3E2E0E4D010260E1B26BEE3D06D0789C700015BDEE3C5280E241B43DEE1030E7EE2835015243E284350E1E0E0E5E2E1E6E6E52000000000C201E0E3E2A10000000300000075E2C778E4E3E3E2E2A6645F000000002D6D00150024E1E205005900003C59E5E4C728001900E1E3E3DFE0E5E4E1B57A0E0012B7E3E4E3E5DED2E2E4CB6DB5DFE1E1E4E8E5E88545DDE3E5E5E2E3E6E6E6E500E0E3E4E5E454AFB515E1E0E7E6E5E4C7E4E5E7E4E5E4E2E4E5E3E6E3E5E5E5E3E2E2E4E5E4E5E2E4E1E3E3E4E5E6E5E5E5E6E6E4E7E6E6E5E4E5E4E5E6E6E6E6E6E4E8E6E6E5E4E6E4E4E5000000
+                                                    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000650000000001000001E4E5E5E4E7E7E7E8E6E6E5E6E05FE2E9E1E4D850000000000012E1E15496E1E2E3E324010000004EE2D0000000330005A1B3E1C966380AA48B5DE1544C20E1E39B0C71003E2D0A90E1AFDFDEA875E5E2AA00000000206DE1BED2E1C0000000000712005B57DFE4E5E2E341A6DC000000009FDF380E000075E1E200000000011000E0E159D06F9D3143E4E5E5E3E4E2E29BE1E1576ABCC5D6E3E2E3B3CBB1227C7ED4E512E3E5E3E5A46F000089E4E4E3E3E1E2E4E4E3E5E1E4E4C543190EC9E4E5E4E5DBE1E1E1E3E6E5E26AE1E2E0E3E4E0E6E5E3E4E2E5E1E5E4E4E4E2E2E4E2E4E5E4E4E4E4E6E4E6E4E5E3E4E3E3E4E4E5E5E6E6E4E4E3E5E6E6E3E4E3E6E6E7E7E7E8E6E5E7E9E6E8E9E6E4E6E3E3E100DB1907E00A0036C0C9C9C9E4E3E2201B0000005DE1E3E23C00000500123AE2E3E2451B0020A6E1E0590000B3E2E10015006A201D2D6A3E2FE2E2E2E0D0A4000003103366E3E2CD269400000A120000498BACE1E2E2E2E396001B00000015D0D60E000A00B7D8E32F030700000031E3E2CBE5C91D4C73E3E3E4E7E6E4E2E3CB5250891DE0BAE1E4E3E443C06880E4E4AAD2EAE4E6E5E5D8050000DFE3E4E4E4E5E5E7E7E6E5E6E58E8747C0B1E4E6E6E5E1D057E1E4E6E6E6DBE4E1E4E3E4E5E5E5E4E1E3E4E5E6E5E6E5E3E4E2E2E5E4E6E4E5E6E5E6E7E7E6E5E4E6E5E5E5E6E5E0E5E5E5E6E6E8E6E3E3E3E5000000
+                                                     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000670000000001000001E7E7E7E7E7E6E6E6E7E7E6E7E32BE4E6E4E2E03A00008700007CE0E2B3E1E3DCE2E141000000332BE3E3964E001B201252B3E1DF38240E332BE1BC5B001000DDE5C9A12D0C245B4E004CE2E19FE2E2D29B00001B005B5B71E2E18EA45B00000A5200000047E3E4E2E2E3E08B2803000020E3E2DE283A3C17DFE1AF2D00000000001DE3E0E27E31314326E4E3E5E0E0E4E4AA593C87876D31A8E3E8E3E3E3E296E1E5D4E0E6E2E3E4E11D262241E5EBE2E4E2E4E7E4E5E5E4E3E3E1A18BB3E2E4D6E0E07A49A4E4E7E6E6E5E3E3E1E6E4E3E4E6E6E6E0E1E3E2E6E6E5E3E2E3E4E6E5E6E3E3DCE5E4E4E5E5E4E5E7E5E5E3E5E5E5E6E5E6E7E6E7E8E7E6E4E5E5E7E8E6E7E6E2E6E0E8E7E9E7E4E1BAD0E6E2E4AC1D0100000033AC5BE2E3E2E1E2AA26000083005B96E2AAA612681B0E0312E4E4800AB30028E3521900000000E1E2504E000A00000000A1E17AE2E5DB41000000363C47AF68E30AAF0E00000749004C0019B3E2E2E5E3E16600681B0300E1E4E32F871B01BAE1E262002D500010A6E0E0E24500000005C2E4E4E4E2E3E2E2E20000387C2271D8E09B7AE28EDFDEE1E2E3E3E3E0E224A150DE1BE2E6E2E4E3E4E7E6E6E5E3E5E7E48BDBE2E2E2E5CB68E6E226E3E5E5E4E0CDE5E0E5E4E2E5E4E5E6E2E4E3E6E4E5E6E4E4E5E5E4E5E5E5E3E2E2E2E3E4E4E4E5E5E5E3E5E6E5E4E7E6E5E6E5E5E5E7E4E5E4E5000000
+                                                      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000690000000001000001E5E6E5E6E6E6E5E7E6E5E6E5E645471080E4E1E4E1333E000020003ADCC7E3D68BE32800000A0078E3E2D0E09B43002B002DC2E3E107000001E42D0050800000A6E4E1434E000062000022929DDDE2C900570000000E662B49C2E0A66D3C0087000000151DE1E2E3E5E2E17C003C100C207CA4A48B3C38246FE2E40100000000007EDEE29603007100009DE3E1D8E2E3E3E3AF00A110E3D8CDD66645E02F28E3E3B1E3E3E4E2E38907B1E1B766E0E1E0E1C507E2E4E5E4E4E3E4E5E4E5C2E1E0E1E420AFE200DEE4E3E6E0E290E4E4E5E2E4E4E5E2E4E3E3E5E5E3E4E3E2E3E2E6E5E5E5E4E1E2E3E2E5E5E6E4E0E2E3E3E5E3E5E5E4E3E4E2E4E5E5E4E5E5E5E6E6E6E7E8E6E7E4E8E8E2E8E2263E28B1E2E6E4DC5D003617BC6252E0E1E062E2757C1D541962CBE3DCE4E2E4E16A050062B3E1E3B34C506FE219030000001203E2E3E2526400000000037AE0E4E2E02B38000000105D00B3D0E1CB66B10700003C20001B78E3E596E4E138152812173ADEE0DDE0C28BE2E4EBE69B000000000047E3E2E20000000000E1220CA4E4E3E5E5E441001549D280E0A4E0C7C059DCE26690E3E6E5E3E23A64E5E15DE4E4E4E29D5BC9E4E7E3E5E2E4E5E5E5E4E2E3E3E56ADB5B5DE4E3E4E13CE3E3E6E3E4E3E2E4E4E6E6E5E6E4E4E5E2E3E4E2E4E2E3E6E6E5E0E3E5E5E6E5E6E6E1E5E5E5E6E6E7E6E5E6E5E6E5E6E7E6E4E5E5000000
+                                                       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006B0000000001000001E7E7E8E7E7E7E3E8E4E7E6E7E58B331033ACD2E2E4E1A6D8002F0CE2E336D0E19BE3E25F0C07283E10E0DEE2E2E2C000000017E1E5D6751566E09B3C000500000ECDE1D2E028170E007E5BDDE1D6DFE08524056A000000B7D071DEE1261038000000001700E0E3E3E4E47E621700000089E1E3E375623C664CE4EBBC00002D00000089E5E2CB2F0017C9470078E0E5E4E6E6E6E50A1724319BE4E3CBAC9401E2E200AFE3E6E6EAEBBC00002D45E5E5E6E4C2C233D4E5E8E5E2E4E5E4E4E5E6E5E2E5E4E1D8AFE3E3E5E5E699E5E4E4E3E6E6E7E5E6E4E4E5E5E6E6E4E6E4E3E4E3E5E6E6E3E3E5E4E5E6E5E5E7E1E4E4E6E5E6E5E8E4E6E6E6E6E5E7E6E4E6DCE6E7E7E6E6E2E6E3E6E6E8E7E8E600000017C7E0E2E3E21500D000D626E2E2E2E1B3E2660001000105A6C5E31DC01900000000009BE1E0A4E3E1B550003E00100059E0E0E2DD62281B0C032BE3E5E2E2E2B700000000319F00961BE07AE0DE0000001B2600C5E2E0E3B51245000000000AAFE2E0BE0A00153187EBE017001533004C0ADCE5CBDFBAE6E1C07A66E5E3E2E1AFDBE7E3E02D59E0E5E4E389E1E1E0E36231E5E4E3E0B100732B1BE8E4E5E4E2C7000731E5E5E5E3E5E5E5E1E2E3E3E7E6E8E5C7B3E2E4E5E2E6E5E5E1E3E6E4E5E5E4E5E5E2E2E0E5E4E4E4E4DDE3E3E2E5E6E5E2E4E4E5E5E6E6E8E6E6E6E6E8E7E7E7E6E5E5E6E8E7E7E2E4E2E3000000
+                                                        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006D0000000001000001E4E4E4E5E7E6E6E6E7E7E6E5E7E67500000000E2E1E3E1280019DFDE000094C96A877E3C2417077CE1E262E16FC01700E138000100E1E2E0E3E2B7D25F1973001D0EC5E11DCDCB710026004EE2E2E3E0E3A8310000172F00001D50C28E0010000000E3E100B1E3E038AAB5592F0000330043D6DFD466A43E1BE1E9E2E4000000000010BED8E2E071DCE4B1C7E6C2E4DFE2783EAFE4E338226FAAE25B80E3E8E2030E54DBE4E4E9E017382000E8E3E3E4E6B1497A92E4E6E5E5E4E5E1E4E4E5E5E2E3E2E4E4E3D2E3E4E4E4E3E7E6E5E4E3E3E4E2E4E4E1E4E4E4E3E4E4E3E1E3E4E4E5E5E5E2E1E4E4E3E5E5E3E2E4E3E3E5E5E3E8E6E6E7E4E4E5E4E5E4E4E49FE8E8E7E6E6E5E2E7E7E7E6E4E6E500800052AF12E19BC003202800000085E08368B70000000022A8E254E2E4DF4C00000000001BE0E18BE5DFD610000003642466DCE3878E0000000000013AE1E2E1E06A71413805C9C70050CDA4E2BA52BE310A01000085E4E10031E2AFC764000E7E2BDBDBB587C96422E0EAE38B17003C002080DCD2DDE4E7E9E2E26DB568E4E2E3AA3A33E4E8E2837EAAE4DFE4E9E6AF173E54DEDFE6DEB303C5594ED0E4E5E4DDB1D2E317E6E5E6E6E5E4E4E4E5E5E5E4E4E5E5E6E6E0E1E6E5E5E6E4E5E5E3E6E4E4E4E5E5E4E4E4E4E3E7E5E5E3E1E3E4E3E6E2E2E1E3E3E5E6E5E6E2E4E5E4E5E6E7E8E5E6E4E6E6E6E8E4E4E4E5000000
+                                                         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006F0000000001000001E6E6E6E5E7E7E6E7E9E8E7E7E8E5E7200000005BC2E380E1852D9B0043593371E4E5E14100994100003A6A71E3E16A156400010003A6E3A1E3E3C5C503032B12001DDDDBE5E2BE410000000017C9E0E3E2E2B7CD261D28075BDEBEE2E2E0E06D2800000010E4E5E22043E1E2E224000000C0DDE3DE687A590068E3EBE4C2C510000103A6C7E14726E9E5E1949BE1E2E2E5E3E3E447B1666D52A8E290E7E5E4E47110035489E2E1C026B5BA1DE2E3E39DC9C9AC4E10E3E7E5E2E664AFE4E3E3E4E5E3E5E5E5E5E5E6E4E4E5E6E7E6E6E5E4E3E4E2E5E6E4E4E2E4E5E2E2E3DDE2E5E5E6E6E4C2E4E4E5E5E6E6E1E4E4E7E6E4E4E5E6E5E4E4E6E5E6E7E8E6E6E7E5E6E5E5E7E8E7E8E8E7E8E6E6E5E8E6E507001B2FB383E3A6B7E152000A1D836DE1D03800280E0020314CE4E0E2E0E15D240C0015D6E457E1E3E4E1C7540300001B73E2D850E3DD3A20000012E2DCE1E2E392A8313A00121B224CE1E3E20C3A0000000000BEE200008700E14E628926038EE3E5E38B002D223CE37ADBEB908E2800DFE2EBEBBA45E1CBC0000E5DBEAAE29FB30A0ACB00E4DEE2E4E487E4E3E100008EE6E6E4E5E4E46DB39DD2E4E4E4D6102478A48EE5E7E4E496E4E0E1E3E3E5E2E6E3E6E6E4E7E5E4E5E6E5E6E4E5E6E7E7E7E6E4E2E4E2E5E4E6E4E387E3E5E3E6E6E7E1CDE6E5E5E6E6E6E5E5E6E3E5E6E6E6E5E4E3E5E3E5E1E5E3E4E5000000
+                                                          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000710000000001000001E6E7E5E5E5E6E7DDE6E6E5E5E6E6E6E6E3DD0052002F5BE1E1E4E3A42610207E80ACE2832600000A89A8227CE4E1D8D2520E003E000AE08EE3E3E1C25F120078000062E3D8E192893E001528265FA8A68EE0C7AFDE05000503479F10E0E192A6002200009BE310010087C5DB92330C00001BE3E5E2AC0C3C432BE2E2EAE871280000E2E4E9EBEBE3E4E3E21985C7E0E4E4C2661B0EE4DE4EE4E4E2E3E4E4E27C001931C5E6E4E4E2E57AD22883E3E7E5A83E49E36DE6E7E7E3E55DE3E5E4E5E6E5E4E4E3E5E2E6E8E5E6E459E6E5E4E2E4E5E6E5E5E6E4E3E5E5E5E5E3E4E4E2E7E5E6E6E4E2E0E2E6E5E8E7E6E2E5E7E3E5E5E6E6E69FE6E6E6E7E6E6ACE0E5E7E7E7E7B5E6E9E7E7E7E6E7E6E7E1E6E2E01503102DE0E0E2E3E4E0001919717333E5A61B36412B001D3807E2E4E4E33C121B1900286DE3E2D2E3E34500000CD6004CAFE5E2AFA6E1682401001264D6DFA8E0450017017C151D87E1E5E5E0AFDE0E002BACE324000000E0E3E26A26190071E0E3E3E2E01D0C4CB3E5E6A1660000000549E6EAE4E4E1E2621D5045D4E5E0C26D056401017EE3E3E3E5E6E5BE1B000500B549E5E7C7CB2DE4121DE1E3E4D8E5E5E4E3E3E4E7E5E6E5E2E4E1E4E3E6E6E4E5DDE2E5E5E4E5E4E5E6E4E6E4E3E6E4E6E5E7E5E5E3E5E5E4E4E4E2E0E4E5E7E4E6E5DCE0E3E7E7E6E5E6E4E4E4E4E7E7E7E6E4E6E7E8E7E8E4E5E5E4000000
+                                                           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000730000000001000001E5E5E6E6E7E6E6E7E5E4E5E5E7E7E7CB94E326000059A1E2E2E1E2E20A000C002638E2DB382B265000120ADF87E3D2E0E22F000000002DE180BEE18E6449000100070319E3E0E03AE08B2400000A0049E0E0E3E18B80030000008BCB0CE4E2B30C20A1007AE100001701808BE4D41D15000096E3E4E2DD4E2466C9C0EBE4A40000000000DDE3E2E5E1190100001BE0E0E2D6AF223A07CDE4E3E5E2E3E3E5E2D8524C5B33E5E2E2D271714900AAE4E4E1E4E520E20047E3E4E2E4E3C5E3E3E3E5E5E2E4E3E6E0E4E7E5E4E5E6E6E4E3E4E3E4E5E5E5E4E3E2E4E6E5E5E3E4E2E1E5E7E5E5E2E5E3E3E5E4E3E4E4E4E4E3E3E5E5E4E6E6E4E6E3E5E6E6E6E4E6E7E7E7E7E7E6E5E6E7E7E7E8E6E6E2E8E6E464005022B5A1E2E0E3C03C00000005263852E3A8E17E2200002226923896E3E4620000E2000531C949E5D4D2D010002B2400007EE2C5D2C9176200000100335DE0E4E3E3E16F220000008722D0E3E045284178E350001068227AE5E28B24000031387AE9EBE33A28016D85E9E12D00E517016D9BE8E9EB501B43C90033E4E1E3E1E15B1971E2E3E4E3E4E2E6E6E6E5A194AC54E3E4E4E4D8B785E6E3E4E4E6E6E5E3D2E2A4E7E9E6E5E3DEDFD4E5E6E5E56FE4E3E6E8E6E7E5E4E6E5E5E8E7E4E6E4E6E5E2E2E3E4E5E7E6E4E5E1E4E5E7E6E7E5E5E4E5E5E4E6E6E6E6E3E6E6E6E8E7E7E6E5E5E5E5E6E6E5E5CBDF000000
+                                                            USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000750000000001000001E7E7E7E7E6E7E6E6E8E7E7E7E7E7E7E6E4645BE24101D2E2E4E2E4000000000000156DE2E4453C1710000C0E3C28E3E4BEE252000000364CAC17B7E25FC924121B2D0343E0E3E5C0A4543824002400003638E2E2E15B3C0000000000002BD6E3E19626BCB1E2000C1B1D5BE2E1E1C70003000033E6E6E0001B100019D0E3312F150A92459BE5E9B75B0E00000038E0E3E5E6E5B73CD2D4DFE4E3E3E3E6A1E3E3C72887E2E4E5E4E3E0E1E0E4E5E5E5E3E2E2E5E5E07EE4E5E5E4E5E3E1E1E4E3E7E6E5E5E2E4E6E6E7E7E4E8E6E3E5E7E4E5E5E6E6E1E1E4E3E2E3E4E5E4E2E4E4E5E4E6E4E4E6E6E4E6E7E8E4E4E4E3E5E5E6E6E5E5E5E5E7E5E7E7E5E6E5E7E7E7E6E7E7E7E2E7E6E6E7E6E9E7E8E9E4E400380145E3E5DFE1E164000000000054E0E3B3E380450024004E0592E2C99FDDA6001D100045B3E271E3E4E2E18500000E3E28DFE4E15D9F2B3300000E9F5033E3D2E3E12F00030000006AE2E2E2E53E0589E4288BE300003696E4E3BE5700000000E0DDE2570015000028E09417E2D8B3D2E1E6E6E0AF7826000015DDD2E4E349C9BAE5155BE3E3E4E3E5E0E0E8E4E37EE4E5E6E2E3E1A6CBE2E6E6E5E4E5E6E5E5E4E4E4E7E5E236E5E2E3E3E4E4E4E5E5E6E7E6E7E5E4E5E6E4E4E5E5E3E5E4E6E6E6E5E3E4E4E6E6E5E4E3E5E2E6E5E7E5E5E6E7E6E5E7E5E5E6E5E5E4E5E4E6E6E5E5E5E4E4E5E5E3E4E4E4000000
+                                                             USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000770000000001000001E5E6E5E6E6E7E6E4E7E7E7E6E8E4E4E7E78E073100E1DFE3E0E2E32D15000C0000002BA8E3BE8038010E20280003E2E2E2E3D426000000001D8BBEE2D0E1837C001B004E0036D4E4E299683E0A364141AADCE3E2E1E12B00000C0000005BD6D2E1E289BE5D0E1000000036B7E0A46600002F000089E4E30E0100000196DFE275505450E2DEE4E4E0AC315B00455FE6E1E0E25764E2CB03C9E4E2E4E4E6E0E1E4E5E6E3E7E6E7DDE2E3C783CDE5E5E3E4E59FE3E4E0E3E5E6E6E6D0E1E2E4E3E4E6E7E5E6E6E6E6E4E4E4E5E6E5E5E4E4E2E4E4E4E3E1E1E4E4E4E5E6E3E0E3E3E2E4E5E4E4E4E4E0E4E6E3E4E5E5E2E1E4E6E6E7E5C9E5E6E6E7E7E7E5E5E4E5E6E7E7E7E6E6E6E7E8E7E7E8E5C5DDE6E4E4592426C0E2E1E5D0D0A8BE2600070E2F4E9DD4C2733C493600280A75E5E3E2E1D22D0700031B2B5B599DE0CBA873000000000047E0E4E3E3E25705DE00753A5066E3E4E385750045001D17127359DEBEE3E3E42F4500003E0054D8E545220000190000E4E0E42D28000001E1E6D63A662B22BAE3E3E0922015000CE1E3E2E5E3E6E4D4007CC741D2E1E4E5E0E2E3E4E3E6E3E4E4E4E4D064D0E0E4E6E3E4E5E5E6E2E3E4E5E6E5E4E5E1E5E4E5DEE7E7E5E4E2E4E5E5E5E3E5E8E6E5E5E6E6E6E7E6E4E1E2E4E5E5E4E4E49DE4E3E5E5E5E5E5E5E6E5E5E6E5E5E6E6DBE3E3E5E5E5E7E5E5E4E6E8E8E7E4E3E5E6000000
+                                                              USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000790000000001000001E4E5E5E5E8E8E6E7E8E7E7E7001780E1E2E1AF100EE32DDFE1E3E2E2C79B68001541806AE06AE1002600150000055FA6E2E1DE33200A242DD62F99DFE3E3E0A143005D00002D80DFE1BE2D0C050A001D003AE2D4E1DE9F965D929D1B0043280054E4E2E2E4E23300000E00E0E2E3A49D0000170A89E4E4E13A5B28005285D6E3A1E2E6E0E4E1E1E1E2330A221983E3B5E6E5E4E1E1B1CD2D28A8E2E35FDFD400E38BE4E5E5E6E6E4E2BEE55BE6E4E0E2E4E4E3E3E2E3E2E4E6E5E5E4E2E3E5E7E5E5E5E2E3E6E7E7E5E4E5E5E1E6E5E7E3E4E4E3E6E5E3E3E3E5E6E5E4E2E4E3E5E5E4E6E5E4E6E4E5E5E5E5E6E6E5E6E5E4E5E6E5E6E5E5E5E5E5E6E4E3E5E1E7E7E7E6E7E7E6E6E8E7E7E7000726E0E3E4E371E2E31D0000E0E1E0E1E17A1B000141503183DD006F0E541200430EA64CDEE1CB01200012000E2FC7E1E3E4DD6F00000003B52DAFE3E10A001200780000AAE08EE273E1E02D6F1715002B3126C2E2E4E3E3E1752000010054E0E2DD3E22000000B5E4E6DF6A6D9403260094E3E5E5CBE2E3E3E5E3E23A002F0064E2E4E3E4E4E10000330094E59BE2E4E0362B0000E0E5E5E4E3E5E3E3E536E2E5CBE5E3E6E45BE2E4E5E7E7E2E3E7E4E4E6E5E7E6E6E3E3E4E6E5E7E5E6E5E3E6E8E4E4E3E6E4E6E5E5E4E3E3E5E3E2E2BCE1E6E6E5E6E5E5E6E5E6E6E7E8E5E6E3E4E3E3E6E5E7E7E6E6E7E6E5E7E6E5E785000000
+                                                               USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007B0000000001000001E6E7E7E7E7E7E8E7E8E8E8E80038990000E3B59DE36607E30115E0A4E5E2A417001B1D22D0D2E4E46F000001000C00196FE4E683942F10071B19003347E29BE2570E00003E1268B7E3E2C0E2800000240083A8BAC2E389C0332200B5031B0000CBE4E4E4E4ACA1260000283EA6E4E3E34500100A1DE2E1D0B7850045286DE1E3E1DDE3D0E5E2E3E300006800267CE2E5E8E6E1E40000850068E4E2E4DBE2680AE200E3E4E5E2E6E5E412E5A6E5E1E1E5E3E5E3E40EE3E5E7E5E3D8E4E3E4E5E5E8E6E8E2E2E5E4E5E6E5E6E4E6E6E5E6E6E5E6E6E4E5E5E2E4E4E5E3E5E5E1E5E6E6E6E6E5E5E6E7E1E3E5E4E7E7E5E6E5E5E6E5E6E6E6E5E3E5E7E6E5D2E4E4E7E8E8E8E8CBE7E8E8E8E8E700001B000000E4E56DB10012000CA6AA47DCB39B0A0000153A83B3E7520A0E003A0E102B3A75E4E3E0430000BE0C0045E1E2DEC0AC0E000300384EE1E5DBBE83150003001DAC5DB7E2E4A4BA9090380000260000E3E0E2E2E13A00000024000099D6A64C03200019008E47E1E2872B0000005D43E1D0E3E4E6E4E6E48000001219D8E3E4E3E4DF5400002B0000E1E4E4E3E4E000002654E3E0E4E5E4E4E5E7E4E7E6E3E6E4E4E2E7E5D0E6DDE4E2E4E6E6E5E7E7E6E0E4E6E3E7E4E6E4E5E4E3E7E6E6D0E4E6E4E4E5E6E2E4E6E5E7E6E4B5E4E7E4E5E5E5E8E6E6E6E4E6E6E7E6E7E7E7E5E6E7E8E5E5E5E6E6E5E6E7E4E3E4DD000000
+                                                                USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007D0000000001000001E4E5E6E5E7E4E7E7E7E7E7E8E7C900010000E5E5E3E40007001D906DE0E0A8B70020000A0024AFE38726001D000000000399E2E3C5E10305E483125F07E3E4A69B264C00000015DED8DDE0711B0C0064000199E0DEE3E296E1DD7133DE005F00D8E0E3E4D6E100008019000000D0E100200000000043B3A6E380C200006D030089E3DDE6E5E2E3E3E1DBD0E0E4E5E5E1E7E5E5E2BE780E0005E3E0E0E2E2E3000A00E4E2E1E4D2E3E6E3E8E7E5E1E3E4E4E4E3E3E4E2E3E1E2E5E6E5E5E5E6E5E6E5E0E3E6E6E7E7E3E3E1E3E4E4E5E7E4E6E4E5E5E4E4E6E5E4E5E0E2E4E1E4E5E6E7E5E5E4E2E3E5E6E5E5E6E4E6E7E5E6E5E7E7E6E7E7E4E7E6E7E6E5E6E5E7E8E7E7E8E7E7E7EAEAE4E9E600000000C9E4E4E2E23600003143E1D8E0E2D8000A1DAF2489A1E1E32D2F0380071905389685E3ACE083380500010A92E1AFA180BE2D000000001DE38BE3E1A496621900CDA671E2E2E4E3E8A4381D0059E9DFE0A8E3E5E0DD0000000000416A92E3000012B7000064D6DFE0D46A1B28150010E154E2E4E6E5E57E28688B41E4E3E6E5E3E6E5E371851B24DEE5E2E3E5E39D2DBAC2BCE6E4E4E7E5E4E5E7E7DDE4E6E3E0E3E4E6E7E4E5D4E6E5E3E4E2E3E6E5E6E5E7E3E5E5E5E5E7E7E5E6E5E5E3E3E5E6E6E5E4E4E6E5E6E5E5E4E5E4E6E5E6E6E5E5E7E5E5E5E5E5E6E6E7E6E7E6E6E8E8E8E8E7E7E7E5E6E6E7E7E5E7E6000000
+                                                                 USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007F0000000001000001E4E5E5E6E6E4E7E6E9E9E9E8DC00000000B3E4E3E3E2A8260E24006283E0E347895033E2662D5FE0E1C21B050015012D5B66B5E3E2A883192819010778B3E3E1E0DF6400669B002431E0E2A19FD0924E000000195DE3E0B3E254C53800106DE2D0E3D8E3E2D0830A000012C53C00E1E20007000000432DE4E2E3592896171957DEE0E2E5E5E2D4240000001500AFE3E3E4E4E6E5E6E0685B3CE1E3E4E2E3D66428B7C2E3E1E2E4E4E4E5E7E6E3E4E2E4E2E5E4E2E4E5E0E4E3E4E4E4E4E4E5E4E8E7E4E6E4E4E5E6E7E6E3E5E5E4E4E2E4E3E3E1E5E4E5E6E6E5E0E5E3E7E6E6E6E6E6E4E4E5E4E4E3E4E4E6DEE2E5E4E6E7E7E7E5E5E4E4E5E5E5E6E3E4E4E1E5E6E5E6E8E7E6E8E7E7E8E8E900000000E3E4E4E2E1E3A4430E2B2F47E1E1A82819D0D6E35F4141E3E147875D45192D006689D4E1E199070001000000E0E3E1E3E4470000E3000031C0E1E4E2B50000005B000015A4DFE1D69FE22003B7AAE3BEE2E1E2E59DBA940E280003BAC510AF334E0C00000E0EB3E3BA9B450E260000A4E3E3E3E5E3DC9D9201240CA6492BE6E4E01D7C7805002643E1E2E5E5E5E0CDA8E2E3E7E6E4E6E47854E4E5E4E5E4E4E5E5E5E5E6E6E6E6E6E6E5E6E5E5E5E5E6E5E4E7E5E5E6E5E5E5E2E1E6E8E2E7E4E6E4E4E4E1E6E5E4E3E3E3E1E3E3E3E5E5E5E5E1E5E6E5E5E4E6E5E5E5E0E1E4E4E4E4E5E5E6E4E7E5E8E7E6E5E6E6000000
+                                                                  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000810000000001000001E6E7E7E5E7E7E8E8E6E7E5E7E5DB000007E3B1BCE1E1DC752D0000011D94E0E39200265BC9E0E27166E29F9996170059003399E0E5B5DC19000100000031E0AFE4E4DD100000007E0E2DCDE4E1D86F00008E0000170C6FE19D78803A0A7E87E0DEEBE0DCE1E2E2E39F12000ED2C7E1E2BE6D000C000C00D2E2DD1BA6BC1B00000000E4D2E4E5E3D02817B1E40026C5ACE4E445BE7A00D0D200C5E1E4E6E4E1E4B3E3D8E6E5E3E5E59B0CE2E6E5E6E3E5E5E5E5E6E4E5E1E3E6E6E5E5E3E4E3E5E7E7E8E6E6E6E7E6E6E6E5E6E5E5E6E5E6E5E4E7E5E3E7E5E5E5E4E1E4E5E5E6E5E3E5E5E4E4E5E3E3E5E5E7E8E4E6E6E7E6E7E7E7E6E8E5E5E3E6E4E6E5E6E6E5E8E7E5E9E6E7E9E8E8E8EAE6E6E7E5E5E417BA90E0E1E03C00A82000C58BB7E0B5246A6DE2E5A666E0E1E4785B00310017AA2FBEE4DBCB26009200000E00A8E466E480476A2B5247E0E3E4E27C9F73002F285747E3E1C0C7E592B10A45B5204CE8DE80E3E4E5DB000000000EC7C7E1DEC7052F000000A8E3E1AAE1E26F5D0000E100E2E5E1E0B7002801262443DCE2E2E55D9B5422E31B00AAE3E3E5E4E2E08585A4E5E4E6E5E4E4D2E1E3E6E5E7E6E3E4E6E6E6E6E4E5E6E4E6E5E5E6E6E6E6E5E6E4E4E5E7E6E5E4E5E3E5E6E5E6E6E6E6E6E6E4E5E5E6E5E6E5E4E5E4E5E5E5E5E7E6E2E3E3E4E4E5E4E7E6E3E6E4E4E5E5E7E6E5E6E3E4E6E6E7E4E694000000
+                                                                   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000830000000001000001E6E7E7E8E7E7E8E0E9EAE9E8E6E7E8E9E3CD0C99E1E3E3E000000100001B9092E3E33E0E000062E0C5E5E3E08E7A05000010002450E1E2E27E311D0000649D83C5D8E3E32D1B05E3E2A457E1E5D2E2993C7E157C36E3E2E4EAEBE8A83126E36FC7D4DD5FE0E3E4E000008B00E2DBE0E1DE7C543126000066C2E3E2E25B4C000000C50AD0E6E3E2E0262B0033504757E4E0E6E3B74900000020E2E4E4E4E4E3CDD0C7E3E7E6E5E6E4E2E2E199E3E5E5E4E5E6E6E5E6E5E6E4E5E4E5E5E3E4E6E3E4E5E6E5E5E7E7E7E5E3E6E4E8E7E9E8E5E4E2E5E6E7E7E3E5E5E7E2E5E5E5E4E4E5E4E5E6E6E7E6E7E5E6E6E6E6E5E4E5E4E6E7E7E6E5E6E7E7E6E6E7ACE6E4E5E4DCE6E6E7E6E7E8E8E8E9E8E6E8E6E51B89E32DE2E1E3E2B1013C2219649BE2D8E0170E000390E2BAE4E3E0A84100006D0A0785B3E3E4A4963100002FC7E1E1E6C7E2D66D4C267EE3E1E2E3E4E5E4DE4E6A7A36C2E1E5EBEBEBE2178EDF90DE00008071E3E5E531000E000073E5E3E5E2E23E1931287AE2E2E3E400310000121D0C5FE4E1E05F784778D000B1E4E2E2E583E1E4543A0A0C85E6E4E5E4E4E171AFD8E5E6E3E5BEE431E5E4E6E6E5E4E7E5E6E7E5E4E4E5E8E6E6E6E2E4E5E6E6E6E7E5E7E7E8E7E6E6E6E6E5E6E8E6E6E4E5E6E8E6E4E7E6E3E5E5E5E5E6E4E7E7E5E5E8E6E6E5E5E6E5E5E5E6E6E6E6E5E6E8E6E5E6E5E6E7E7E8E7C0E6E7000000
+                                                                    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000850000000001000001E6E6E5E7E7E7E6E6E8E8E8E7E4E3E5E2E33C49E2BCE1E2A6E00A00333CD8E0D2E3E0B57100A4200AB5E2DBE2E2CD4E5B0300005771E1BEE3D6C5070C01153190B5E2E2E3457C24102F1BE2C9E4E4E4E2B77C4E28209D66E2E4EBE9EBE4E0C019009B414543E1E5E59F5B100000288BE5E5E4CB0000000071E4E5E2E3B7D615003892A6E2E4E3E1850C8B0712005FE3E2E4E4DF9FE1C7E141A8CBE4E7E1E4E3E3E4E5E3E5E3E3E4E2E4DEC7E5E6E4E4E4E3E485E4E3E4E4E7E6E6E7E5E5E4E6E5E5E2E6E8E4E5E4E6E6E4E5E6E7E5E6E5E6E6E6E7E5E4E6E5E5E5E3E6E6E5E6E5E4E5E5E5E5E5E5E5E2E3E4E4E8E5E7E5E3E6E5E6E7E5E6E5E7E6E6E7E4E5E5E5E5E6E6E6E0E5E5E0E7E7E6E8E2E4E6E6E4B34CE2E0E4E4E1DF0E220000059B54B7E0E0949903001B129BE2E2E2E2E1B524831B220A2D5DE3E371262B032D8EE0E1E3E1D8DD663E0000008080E2E5DCCB226F9D4C00E078E1E0E9EBE33C6400AF00E1E047D075E3DF006D00470000E0C06AE366000A100000E3ACE3E2E3E252031724A883E2E2E59F9B380A57004EE5E5E6E5E3E2E47C2FA1E2E3E1E5E5E5E7E580E3E2E5E6E5E7E3E6E2E3E5E6E6E4E4E3E5E4E4E3E4E6E6E2E2E6E6E4E5E6E7E6E7E6E6E5E4E5E1E6E5E6E6E7E6E5E6E2E6E4E5E6E6E6E5E6E5E5E6E7E6E6E6E5E4E4E6E8E6E6E6E5E1E6E4E6E5E5E5E5E2E6C9E6E6E6E7E6E5E6E6E3E5E4E5000000
+                                                                     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000870000000001000001E4E6E6E6E7E7E7E7E7E6E7E7E7E7E6E4E47C00544EE1E2E2E3890012000015CB80D6E08B31104E0000384EE4E4E0E1E2495F19001BD4C9E3E2E0640087B764D6D6E5E4E2E3E136005F2B0078ACE2E2C0BEA1050000478BDDE2EBEBE2C26A1B12E133903AA1E0E2DBD0E71D0000000000E1E0E3430026003CE0CBE2E3E1070C0C1092E2E2DCE2E0AA9FE000000C12C7E1E4E3E3E3E33336C2E5E4E5E3E5E6E5E589E3E0E6E5E5E4E2E5E3E4E4E6E4E4E4E5E7E6E6E6E4E7E6E4E6E6E6E3E4E4E4E7E5E5E6E5E4E5E7E3E4E4E6E8E6E5E6E5E6E4E5E5E1E5E4E5E5E4E5E4E4E4E4E4E4E3E6E4E3E4E2E6E5E6E6E6E5E5E6E4E4E4E6E6E6E5E5E7E6E5E6E4E4E4E2E4E6E7E6E7E7E3E7E7E7E8E7E7E6E3E5E200007A1BB1E3E3E34E52220C4C2059BE96E2E2BEBC593C005D2066E6E5E266E0470C5F1BB3E5D2E5E37C509B2D73C9E3D4E4E4C0D6D63C000087E28BE4E4E0E39F0000802B89AF2DE0EAE645DEE5E1E4E9B71010E1E2E2EBC79900E40000E0E2E6E08B002200171DE5E4E4BC0000E20033DEE4E1E4E6E3E2E317473643E1D0E4E4E4E4E571B30AE6E5E5E7E5E4E4E4E164E4E5E4E3E3E0E4E4E5E5E5E6E4E3E2E6E6E6E6E7E7E7E3E3E4E4E5E6E5E5E8E5E6E7E7E6E5E5E6E6E7E6E7E6E6E5E6E5E7E7E6E6E4E6E5E6E6E4E5E4E3E5E6E5E0E6E5E4E5E4E8E7E6E7E6E5E7E6E6E7E7E7E6E696E7E8E7E7E7E5E6E5E5000000
+                                                                      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000890000000001000001E2E7E7E4E8E8E6E8E8E7E7E7E7E6E8E6E1BE4C542F50DEE3B5D8640024E171419DC2E3E092DB3673282F3C9FE0E4E371005D99360057BEE0E4E278E4D81959AFC7E2E4E5E2E0CB6F00006AAFE2D2E3E2E18E8E034E0000599689E7E45D73E5E5E4E4789D00336AE2EAD0EB000000006AE2E15D1B2022E02036E3E4E6E21B00000049E0E1E3E2E1E5E58B8B2415AFE4E2E6E4E6E6E43C000ED4E3E4E6E4E4E3E3E3E2E3E3E6E5E5E4E3E5E7E6E9E7E6E6E4E5E4E4E6E6E6E894E7E8E7E5AAE5E5E7E6E7E8E6E4E5E5E6E5E5E6E6E6E2E7E7E6E6E6E6E7DDE5E3E6E6E7E6E4E4E4E6E7E7E7E7E7E7E6E6E6E7E7E8E6E5E6E5E6E6E6E6E6E6E4E6E5E7E8E6E6E6E5E5E8E8E7E7E7E7E7E9E9E7E8E7E6E6E7E1E1014112ACE1E3E2E05996D847572073E352E0E3DEA67A542F1B4EE3E6E5E4331D5422000515DFE5E1CBE3960A411DE375E3E3E5E2E1365B6FAF12E1B3E1E6C7E378100124000078DBAFD4DE9283E4E4BE5B1D0017ACE4E9EBE98700001BD6E6E5E149009680199268E6E38E714122711D31E5E5E4E6E6E4E4A11B24E5E7E4E6E3E6E6E252C512E4E6E7E6E3E4E3E4E79FE3E7E7E3E4E4E2E4E5E4E7E4E5E2E4E5E4E5E6E6E8E7E6E4E7E6DFE6E6E5E7E6E6E9E8E6E6E6E7E7E8E7E7E6E6E6E6E7E7E5E6E6E4E6E5E5E7E5E6E4E6E4E6E5E6E5E4E5E4E4E6E6E5E8E7E6E4E5E7E7E7E7E7E8E5E7E5E6E5E7E7E5E6E5000000
+                                                                       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008B0000000001000001E1E5E6E5E7E3E6E6E8E8E7E8E5E5E6E6E3E20E17832675E2E4E147E3E16A280054E1E180E5E5E05D3A500E4178BAE4E57C07892B0A590000E6E1E1544C3C5283498BE3AFE6E3DCAA0112E05B49E0B5E1E1E43C000000000028E396DDE2E2E4E4E65990000000E3E5E4EBEB80002FDEE2E5E9E4E0496D0E1B2DE1E3E3E3E2007A2D3815C7E6E3E5E5E6E750010000E3E2E3E4E5E4E2E0E3ACE5E4E6E6E5E0E2E3E3E319E4E6E4E3E5E3E5E5E5E5E4E6E6E5E4E3E2E6E5E5E7E6E4E6E6E7E5E6E4E5E5E6E5E6E6E1E7E8E8E7E7E9E6E7E9E5E5E6E5E6E6E6E5E4E5E6E5E7E5E2E5E5E5E6E6E7E7E4E5E5E6E7E7E6E0E5E5E6E7E7E7E7E6E7E8E7E7E7E7E7E7E6E7E4E7E7E4E7E7E6E7E8E8E8E8E8E9E8EAE2DB280A1243DC8EE2E2E2E3E2E14C3C01B3A4E3E5D6E37831DF6F1B28E1E2E2E3504C1531E20015E1E4E3DF8745A82F45338EDEDFE4E383D2492F50A4A1BAE4E5E894E00000000C3175BAE2E4E4E5E5E4240000004949E2E4E4E5D207A1D6E5E0E4DDE4C92222000EE2E5E5E4E58B5F005210E4E4E5E4E4E7AA9F19000003E1E5E5E5E6D0E3E2E3E4CDE4E4E5E5E5E566E215E6E5E4E4E5E6E6E6E5E7E7E7E6E7E7E7E6E6E7E5E6E6E4E3E7E8E6E5E5E7E7E7E7E6E6E5E7E6E6E5E6E6E5E5E6E8E8E7E7E5E7E5E6E5E6E6E5E4DDE4E4E4E6E5E6E6E5E6E6E5E6E5E7E7E6E6E7E6E6E5E6E6E7E6E6E7E7E7E5E7E6E64C000000
+                                                                        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008D0000000001000001E3E6E6E5E8E9E5E8E7E7E6E7E8E8E9E8E5E5C70A1DE1E2E4E3E55BE4E1DE80124322E0ACE2E2AA8B9B2B3C1920DFE4E4E2C0BC000C0033001BE5E1E5E2E173BE244E3378DEE5E4E3BE17243300E0AFE1E3E5E0D8BE712020542F41E7E2DCE3E3E46D6A00640A85E4E4E619000000E1E5E3E4E5E3E00C78E364C2E3E5E471014E00E5E3E5E4E4E5E4E4360700E3001DE5E6E4E8E1ACC7E08EE6E7E4E4E5E4E4641DE0B3E5E4E5E5E4E4E5E6E6E7E6E6E7E6E4E5E6E6E6E5E6E4E3E5E6E6E6E4E5E6E6E7E6E7E0E5E5E6E5E6E7E6E3E5E6E5E5E5E4E8E5E6E4E5E6E6E6E5E3E4E4E3E5E5E6E6E5E5E5E6E6E5E6E6E4E5E5E7E7E7E7E4E5E6E6E8E7E8E7E2E6CBE7E4E5E6E6E7E4C7E7E9E9E9E8E8E9E8E9E6E415940000A8DFE2E26D78E2E27E0131289FDDA6E5E4E3000000000136AAE2DEE4E34E07389BAA45E3E3DDE1DEE1B312002F7EBEE4E5E4544C26001B43DD64E5E4E3851DAA5F547CE031A6C0E3E4E3E6E37E173A1728E0E6E40000000028E3E4E7E2E2E003E5E743A6E3E3E45D451D00E3E4E4E5E5E4E4E5E3C205000083E4E6E6E5E6E1D8E1DCE2E6E5E6E6E4E6DD3CE5E5E5E3E5E4E2E6E4E6E5E3E4E3E4E6E7E5E6E7E6E7E6E6E7E9E8E2E3E4E5E6E7E6E8E5E6E6E6E7E6E6E6E6E4E6E6E7E7E6E6E8E7E5E7E7E6E5E7E4E3E5E5E7E6E6E8E5E3E4E5E8E8E8E9E7E6E7E5E6E6E4E6E4E6E6E8D8E7E6E6E6E5E5E6000000
+                                                                         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008F0000000001000001E5E7E7E6E6E3E6E7E8E8E8E3B5E4E2E6E4E3249FB70019DF6FE2E5BAE2E2DD9B92001D3C3650E2E10C19004E0000529FE5E0E2CB785D05CDE0E1E4E4CD9BC9000000310078E4E5E1CBBEBA0000033EAFE3E3E6E49643734E3AE3E4E4E0E6E6E0E7E4D40700006AE3E6E60019E3006DD4E5E6E3E0157A7CE200B3E1E3E2C9222B0185E5E5E6E4E3E5E6E7E631004CE3E5E8E5E8E6E3E3E3E1E6E7ACE8E6E4E5E5AAE6E5E6E6E5E6E5E5E4E6E5E5E5E5E6E6E6E5E6E8E7E7E7E8E7E6E7E5E5E5E5E7E7E6E7E4E3E4E5E7E7E7E6E6E7E6E7E6E7E6E5E6E7E4E6E5E7E5E6E3E4E5E6E6E5E6E6E6E5E7E7E7E6E5E7E6E5E7E6E2E5E6E7E4E4E6E8E5E6E6E7E8E7E7E8E5E6E7E6E7E7E8E7E8E8E8E8E9E8E8E6E4E3E200001D26E18BE2E5E3DBE4E1B700E300945FDEE0D2AA57000000001547C2DCE0E52D0C1BAFAFE185E5E1CBD69D7A246F49E1E2E4E3E0E217000031906D89E3DDE3E3D2E27131CDA1C9E3E3E4E3D4E20707000E00E1E6E6000000009DE2E4E7DCE39F4538284CE6E6E6E5C57C94E4DEE4E4E7E6E6E5E5E1E3DDE7E6E7E7E6E4E6E6E4E4E36AE4E3E4E4E4E4E4E4E4E5E6E8E6E5E4E6E7E6E7E6E5E4E5E5E7E6E6E5E6E2E4AFE6E6E7E6E7E3E6E7E7E7E7E8E4E6ACE5E7E5E6E6E6E6E6E6E6E5E7E7E7E5E6E6E6E8E7E6E4E4E4E3E6E6E6E4E5E3E4E5E6E6E7E5E7E6E6E8E6E5E5E5E5E4E6E5E5E6E6E7E6E4E5E5000000
+                                                                          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000910000000001000001E5E6E6E6E7E8E7E7E7E5E6E6E5E4E4E4E2E3E07A430EC7E1E1E2E4E3E0B5E1C9002854386A87E1DBE349000000000028E0E2E4E0101B9B6D2FAAE3E2DCE0D62B47640AC2E3D4E2DFE7E57500000AC983E3E4E4DEE4E4E0004C9DB380E4E4E6E5DE380C00000007E2E4E6E10000107AE3E1E5DFE0E3E5AF22DBE4E5E59BE11522E4E6E7E6E6E6E5E5E5E6B7E1E4E4E6E6E4E6E5E5E2E3B17AE3E5E5E1E4E4E3E2E5E5E6E7E5E6E5E5E5E5E5E6E4E4E5E6E4E5E5E4E5E8E5E6E4E7E5E3E5C2E4E6E6E5E4E6E3E4E4E6E7E6E7E7E3E6E6E4E5E4E5E5E4E6E2E4E5E5E6E6E6E6E7E7E6E6E5E4E6E6E4E6E7E5E7E5E6CBE5E6E8E6E6B1E5E7E5E7E6E5E7E6E7E6E5E6E5E6E5E7E7E7E7E6E9E8E8E9E5E6E4E4E3E3E3E23C2087E3DEE0E2E2E2E3E4DF052D053C33A8E3E57E7E00001700000A45E0E2575F012D330CE1E5E4E3E0E1943E99242DBCE3E4E3E3D8E2A8E375B1DCDFE1E5E4E3E1E3D26492E1E0DEE2DEE4E2E31901360E5B57E6E5E5527E1B0773E4E5E5E4E1E3E51994E5E6E4E5E59236E5E5E5E6E7E7E5E5E4E4D290684CE6E6E6E6E6E5E4E4E3E5E2E3E6E5E7E5E5E6E6E6E3E8E8E7E6E8E6E5E6E5E7E6E7E9E6E5E6E5E4E5E7E7E6E6E5E5E6E5E4E6E6E7E5E4E5E3E5E6E6E6E7E7E6E6E2E7E6E5E5E7E6E6E5E5E4E4E4E4E6E5E5E6E5E5E6E6E5E4E4E6E6E5E6E6E5E5E6E7E5E5E5E5EAE6E7E8E7E7E9E7E5E5E3E4000000
+                                                                           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000930000000001000001E4E6E6E6E6E6E6E7E6E7E7E7E3E3E3E2E2E0E2E0800000808E80E0E1DCE1E2E0AC477A54263C87E39FC5470000001B2B4EAAE3E1DFE2474E19DDE2E4E0E2E14C153E3E0000648BE3E3DCE3DB7580DEE2DEE4E4E4E6E5E44719100794BAD2DBE4E4E0D047074719E3E3E5E2E02B244322BCE3E4E2E3E0000012C5E3E4E4E443DBD0E587CBE7E6E5E4E6E5DBB75750C2E5E6E6E7E6E4E3E4E2E5E5E3E4E2E3E2E3E2E4E2E2E5E5E6E6E5E4E3E2E3E3E5E6E5E5E3C9E5E6E5E6E7E7E7E6E6E5E5E6E6E5E6E7E4E4E5E4E4E2E2E3E5E3E5E6E2E5E4E3E5E6E6E8E4E4E5E3E4E4E4E4E6E5E6E6E5E5E5E5E7E8E5E8E4E3E4E4E5E4E2E4E6E4E6E7A6E5E696E5E6E7E7E7E7E7E8E7E7E8E7E8E9E7E8E7E6E2E6E2E2E1DC20A8005BE0C9E3E1E39FE4E3E352D46D2641C59DB5E36A173C125B4C5DE0E4E5BEE1BE1041158EC0D8E3E0E19B2B0E000000ACE2E4E2BCDBAC83D4E2E3E3BEE3E4E1437AE4E400E0E1E4E3E4E5E5E2BC00415BDFE2E3E4E10024CBE5E4E4E4E2E4E40500006FE4E5E2E2E4E3E5E468E5E5C7E6E6E6E5C0B5E0E5E5E6E5E5E5E5E4E5E5E3E5E6E6E7E4E4E4E4E6E5E6E4E5E5E4E7E6E6E6E5E8E6E8E8E5E6E5E3E5E5E5E6E7E4E4E5E6E5E5E6E7E7E6E7E6E3E5E6E4E5E5E6E3E3E6E5E5E5E4E4E5E5E6E5E3E5E6E5E3E4E4E4E6E7E7E9E6E6E5E6E6E5E6E6E7E6E3E7E7E7E5E5BEE8E0E7E3E7E7E8E8E6E6E6000000
+                                                                            USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000950000000001000001E5E7E7E2E7E8E4E7E8E8E7E8E7E7E8E7E3E2E3E26DDE246FE2DEE4E4AC2FE3E3E2E2C0C05F2DC971BEBEE4B58E4E2F991599E5E7E2E5804500057AB3E1E3E3E29BB1071B1B1568BAE6E3E3E2E12F33B5D0D2E4E5E3E02F10523C05E4E3E09DDEE8E5453619005BE4E2E5E4E1000019DEE4E3E5E5E4B500E500BCE5E6E4E4E5E4E3451049E4E4E6E4E4E5E6E6C9E5E5E6E6E6E6E7E6E7E7E6E3E6E6E5E6E6E5E5E4E5E5E5E5E4E6E7E7E6E5E6E6E5E5E5E6E7E6E6E5E6E5E5E6E6E6E6E3E4E5E5E5E6E6E6E4E5E5E5E6E5E5E5E7E2E7E8E6E5E8E6E6E7E6CDE6E7E5E6E2E4E3E3E7E6E6E7E3E4E4E4E6E6E0E7E6E7E7E8E7E5E6E5E6E4E8E77CE7E6E6E7E6E7E5E5E7E7E7E7E6E7E6E7E7E8E7E6E4E6E5E2DBE2E2E58B3301E0E0E5DC311290E3E6E5E3E38EB3999FDDE3E4E3434C473310A1E1E1E6D6E2B5009B4789DCE5E4E0E2C53A00000122CBE3E0E3E2BCA80C50B1B1D8E5E5E3D4DF57361DE3E3E496E3E5BC47E4010000E4E6E6E6DC00000000A4E4E4E5E4E4100000E1E5E5E5E5E5E4E33C0090E6E3E6E3E5E6E6E5C0E4E6E6E8E8E6E8E6E7E6E7E4E5E4E5E4E4E4E4B7E5E6E7E5E6E7E7E6E6E6E3E5E5E7E6E5E3E4E5E6E6E7E5E9E6E6E8E5E6E4E7E5E6E6E5E4E6E4E5E5E4E5E4E6E6E8E7E4E6E6E5E6E5E6E6E6E5E6E7E1E5E4E6E7E5E5E6E5E4E7E6E7E7E8E7E6E6E6E7E4CD6FE4E8C9E8E7E5E6E8E7E7E5E7E5000000
+                                                                             USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000970000000001000001E4E6E6E6E6E6E7E6E8E9EAE8E3E6E6E7E3C7E2E3E3D8BE1703BAE1E238174EDEE3E5E4E3E04EE3E2E4E4E3E55BAA5F3E014968B7E2E1BA5F7C8022DC92E3E3E3E5E03C68000022AFE4E3E1E4E38E83B352E1D0E2E6E3E2C97CE2E4E4E27E8796E0E387E0003C0073E4E5E5E400004700E4E4E4E4E26803000052E4E3E5E5E5E4003C0003E6E8E9E7E3E5E4E2C752E4E5E6E5E5E4E5E5E5E4E6E5E6E7E3E5E4E4E6E5E3E4E3E4E5E6E7E7E5E6E6E5E5E4E6E6E6E5E6E7E5E5E6E4E4E4E2E6E5E5E6E5E4E4E4E5E5E5E4E6E5E6E4E0E4E4E7E6E6E7E5E4E3E5E5E4E6E4E4E4E3E6E6E3E6E5E7E6E6E6E5E4E2E4E6E5E7E6E4E4E4E6E5E3E6E7E8E6E7E7E6E550E3E7E8E2E8E7E8E7E8E1E7E8E6E7E6E8E4E1E0E2E1E2E178195094E3E5523AE1CBE0E3E2DF417343DCE2E3E1E3E273995D224EBCE0E4E5E6D0385B286AC794E0E2E290DCE13A0C78E1E4E5E5E3E462265D3AD6E2E1E3E4DF22A4E6E5E6E36D9FDFE5E6E4E2000000E3E6CDE4E4000C0524E6E3E4E6E4E4752B00DCE4E7E4E4E5E35207053AE4E7E5E6E8E6E7E6E4E5E5E6E4E5E6E5E5E5E7E7E6E5E5E5E6E5E3E5E6E5E4E7E5E4E7E6E9E8E8E8E6E3E5E6E7E7E7E5E7E6E6E6E5E4E4E4E5E5E6E6E5E3E5E5E5E5E6E7E7E5E4E5E5E6E6E5E6E8E6E7E4E7E5E6E8E7E5E6E4E1E1E3E7E8E7E6E6E5E6E6E6E2E6E6E8E7E6E7E5E6E7E7E7E8E6E8E7E8E8E8E6E5E7E6000000
+                                                                              USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000990000000001000001E3E6E6E7E7E7E7E7E9E7E9E9E5E7E5E7E4E4E4E5E2BCE02200DCE3E4C0BEBA8ED6E3E3E1D89D73BAE1E4E0E3E5E1B73859526AA4ACE4E5E02D6A62B7DCE196E2E4A49BE1662F3EDCD8E5E4E1E468A8E0E0D85F90E3E4E4E092DFE2E3E1DF505BE5E5E590000000BEE5E6E5E3A4150024E3E5E6E6E6E443129BE4E6E5E6E5E4E5E4755B5422E4E6E7E6E5E6E5E4E4E4E4E7E7E8E7E7E6E6E5E4E4E6E6E4E6E5E4E2E3E5E4E6E6E6E8E6E5E4E5E6E5E6E6E4E4E3E1E5E4E4E4E8E5E6E6E6E4E3E4E8E7E5E5E4E6E6E7E3E5E4E5E6E5E6E6E6E7DBE4E6E7E6E7E6E1E5E5DCE0E3E4E5E4E5E6E5E5E6E6E7E6E6E4E5E6E6E6E4AAE5E3E6E5E5E5E6E6E5E5E7E5E4E6E7E7E8E7E7E6E6E6E8E7E7E7E5E6E6E8E3E4E3E2E600A1E10AE0E6E4B5D68389E4B5E5E4A1E0C75BE1E5E2E3DCE196963820192B50DFE5E3E06F2FC5E2DCE5E4E2E4DFE2310700DDE2E3E6BEE5E4ACBAE1D492C7E4D2E3E5DFE4E2E4DCE2C5C9E2E5E5E6E199E1E7E7E5E5E5E43600C2E4E5E5E4E2E31500E4E7E5E6E5E5E5E5E38EDD261DE5E7E7E6E4E5E6E4E3E4E5E8E7E7E7E8E8E6A8E5E6E6E7E5E3E6E2E8E7E8E4E3E6E6E7E7E5E6E6E7E3E7E7E2E5E5E3E9E6E7E6E5E4E5E5E7E7E8E7E7E6E7E7E5E5E6E5E8E7E8E6C9E6E6E6E7E6E6E6E8E8E8E8E6E6E6E6E7E5E6E7E3E4E5E5E7E8E5E4E7E7E6E6E8E7E7E7E5E6E7E792E6E6DDE8E7E9E7E6E4E6E5000000
+                                                                               USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009B0000000001000001E8E7E7E7E6E7E6E7E8E8E8B5E8E5E5E8E4E4E4E3E3E152C7DBA8E5E3C08EAAA6BEE4E4E4E138A6316DDBE3E3DFE7CB33072F33A1E5E6E6E79985A1E03E73E3E2E6E4E4E51B380103D6E1E5E6E5E4BEAFC9DCB1D6D0E3E4D2E5E5E5E5E4E5C5D2E2E4E5E3E522432BC7E5E4E5E5E04547E6E5E6E6E6D60000E6E7E7E7E6E6E5E5E633280028DCE5E5E7E7E6E6E5E7E3E6E7E6E8E7E5E6E6E6E6E5E4E5E5E4E4E4E6E7E6E6C5E6E6E6E8E7E7E7E7E5E7E6E5E6A4E6E5E6E6E6E7E6E4E5E7E8E7E7E5E5E5E6E7E8E7E7E4E2E4E5E6E5E6E5E6E7E7E6E8E7E5E7E6E7E7E5E5E5E3E3E6E4E3E6E6E6E7E6E7E7E6E6E9E8E8E7E7E7E7E4E9E8E7E7E7E7E7E6E6E5E7E7E7E6E6E7E7E6E6E6E8E8E8E8EAE8EAE8E5E6E5E3E4E5E4E4E0E3E1E5E28E8B0078E3E1E0E5AABE9DB3E3BEE4E2E0997ABE0543C5E2E5E5E5D83E59502407D8E1E4E4E4DEA4000510E0E5E4E5E4E5E0B7549F6FE5E1E6E5E3E4E4E4E5E3E4C987E3E3E6E59B1B413EBEE6E5E8E5E3E0E4E6E7E8E6E5E30050C7E5E6E8E7E6E6E4E7E65DE50CE3E5E6E4E6E6E7E7E7E7E8E7E6E6E7E6E5E5E6E6E7E5E5E4E5E5E6E5E5E6E5E8E1E6E8E8E7E9C0E7E5E7E7E6E6E5E6E5E7E7E7E6E5E6E7E5E5E5E7E6E6E5E7E8E6E7E7E4E7E7E7E7E5E5E6E7E5E6E7E6E5E6E6E6E7E6E8E4E5E5E5E7E6E5E6E7E7E8E7E6E6E7E6E9E8E8E8E8E8E5A6E6E7E7E6E8E7E8E8E6E4E6E5000000
+                                                                                USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009D0000000001000001E4E5E2E5E7E8E7E8E6E6E6E7E6E5E6E4E5E4E4E0E5E2E5E3DFE2E2E2C7D099544C7AE3DFE3D6AF454CC9E4E4E6E0D085506A925FE2E2E4E3E3471DE062ACDBE3E3E3E6E4E0994E59E0E4E0E4E3E3E29D80D296D6E2E5E5E5E6E6E6E6E3E231B1E5E5E4E2BA269B00E0E5E4E5E6E4E3E6E6E7E4E7E6E6E6E200E3E5E1E3E5E5E3E4E600E49BE1E6E6E8E7E8E7E5E5E5E5E6E6E7E8E6E5E4E6E3E5E5E4E7E7E6E6E6E7E7E7E6E5E5E3E3E3E4E4E5E6E5E6E6E5E3E3E6E7E6E7E7E6E7E7E6E5E6E6E5E3E5E4E5E6E6E7E3E2E4E6E3E6E5E3E3E1E4E3E7E5E7E6E5E3E4E5E6E6E6D0E4E6E4E7E6E5E5E6E4E2E4E6E7E7E6E6E77CE6E9E8E7E6E7BEE5E6E6E6E6E5E6E7E8E7E7E8E7E7E7E7E7E2E6E5E5E4E3E4E4E2E3E2E2E2E20000E2E3E2E4E2473EA4DEE4E5E4281D9DE2E3E2E4E3BC5F547A5492E4DFE2E3E3AC9289A4BEB5E3E2E5E4E3E2B35757DEE3E5E6E4E4E4E1E4B3E2E4E5E6E7E7E5E3E4E5E0B1B1BEE3E5E6E47C47201596E6E4E5E6E5C0E5E6E7E6E7E6E5E5E00EE2E3E5E5E5E5E6E7E6C52F01E4E6E6E6E6E6E5E5E6E6E6E5E5E4E5E6E4E4E4E5E3E5E5E4E5E6E6E5E6E7E7E7E6E7E7E5E4E6E6E5E5E6E7E5E4E6E5E5E4E6E4E5E5E5E6E6E6E6E6E6E7E9E8E6E4E6E6E5E6E6E7E6E7E6E5E6E7E5E6E8E8E7E7E5E6E6E6E7E6E7E5E4E4E5E4E6E7E7E7E6E6E8E8E8E7E8E7E6E7E7E7E6E7E6E6E6E8E7E8E5E6E6E5000000
+                                                                                 USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009F0000000001000001E6E5E6E6E7E7E7E8E7E7E7E6E6E6E6E5E1E2E2E2E2E1E312000057E3E3E0C99D5F00E4E3E2E575000075E1E3E1E06A4C179DBA4520E2E5E4E4D0E3E13EA4E4E1E2E2E4B5E1E3E2C9BAE4E3E0E7E2E5E4E215DB8EE4E4E5E5E5E4E4E6E32F0C71E7E4E6E5A119200043E6E7E5E3E292E3E3E3E5E4E4E4E5E4E4E5E1E5E3E1E2E5E7E6E3E5E5E4E5B7E8E7E7E7E7E5E5E7E4E7E6E7E5E7E6E4D0E5E4E4E5E5E4E6E5E4E6E5E8E6E2E6E5E5E5E4E7E6E7E7E2E5E4E5E6E5E6E6E7E7E6E6E5E5E5E5E6E4E5E5E6E4E5E6E6E4E5E6E8E6E6DFE8E5E5E8E6E8E6E7E5E3E6E4E7E5E5E5E3E5E6E4E6E7E9E8E8E7E8E7E6E7E7E2E6E6E6E7E5E7E7E5E6E6E7E5E9E8E7E7E6E6E7E7E8E6E8E8E7E7E7E6E2E4E2E3E6E4E4E4E2E3E4E00000BCE4E4E4E4E16FE2E2E3E3E2E3100043C7CBE6E5C98EB7E3BC0C28DBE2E3E4D4E250C741E1E2E5E5E6E7E6E5E6E5E4E0E2E3E6E5E2E3897E7800E2E6E5E5E6E7E6E5E410E433B7E4E5E6E2D400E000E6E6E6E5E4E4E2E6E6E7E7E5E5E3E4DFE4E2E3E507E5E3E5E5E5E6E7E2E6E7E7E7E7EAE6E6E4E4E7E7E5E5E7E6E6DFE6E5E8E7E7E6E6E5E5B1E5E5E6E7E6E2E4E4E4E4E7E6E6E8E4E5E5E5E5E7E6E6E6E6E7E7E6E4E3E6E5E5E5E4E7E6E5E6E7E6E8E7E8E7E6E8E5E2E3E5E7E6E6E5E7E6E6E6E4E5E3E4E6E6E4E6E3E7E6E6E7E7E6E6E6E6E7E5E6E7E7E7E9E7E7E7E7E7E7E7E8E7E7E7000000
+                                                                                  USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A10000000001000001E7E7E8E8E8E8E8E8E87EE8E8E6E4E5E4E4E3E2E1E5E4E4E3DF47E0E4E1E4E4E2E5E3E1E3E3E2E2C0128BE1E0E4E36DE3D0E07154806FE4E2E2E5CB45C01D94E0E2E2E2E1E5E4BE5903E3E4E4E5E3E3E4E0100EAAE3E3E5E4E5E5E2E5E4E0AAE1E8E7E7E7E4E3660000C9E2E4E4E1E4E3E6E5E6E7E8E6E6E3E3E6E5E4E66F41E3E5E3E5E2E5E5E7E5E6E5E5E4E8E6E6E6E9E7E7E7E5E4E4E4E4E4E5E6E5E6E4E4E4E5E6E5E5E7E7E8E6E6E5E4E6E7E6E6E4E5E5E5E7E9E6E6E5E6E7E7E4E5E4E4E7E6E8E7E6E6E5E4E4E6E5E5E7E6E5E4E2E4E7E8E9E1E6E6E8E7E6E6E6E6E7E5E7E6E6E7E6E6E8E6E6E6E7E6E5E5E6E6E8E6E7E6E6E5E6E7E7E8E7E9E6E3E6E3E7E6E7E6E8E8E7E7E7E7E6E6E6E5E6E8E2E3E4E3E4E5E4E2E4E5E5E5DEE3E1E3E2E159E3E4E3CB0C17788E75E2E2E5E4E38E01B71D90E4E1E0E3E2E0BCCD47E3E4E5E7E5E6E6B112664EE5E4D8E5E4E4E55D0AB3E0E4E2E3E5E4E4E4E35D0010E4E6E4E4E5E4000000E2E2E3D4E4E3E3E4E6E7E7E5E6E3E5E6E4E6E4E4E226E3E6E5E1E3E3E3E2E1E6E5E5E4E5E6E7E4E6E7E7E5E6E6E6E7E2E5E5E5E4E5E4E3E6E6E5E6E9E7E7E5E4E5E4E4E5E4E5E6E5E4E5E5E5E5E5E5E8E7E8E8E5E5E4E5E7E7E7E7E6E5E5E6E5E6E6E6E8E7E8E8E6E6E6E6E8E7E7E6E6E6E6E8E5E5E5E4E7E6E8E7E4E7E4E6E8E7E6E7E7E8E7E8E8E8E8E5E7E8E6E6E7E7E6E6E7E6E6E7000000
+                                                                                   USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A30000000001000001E6E6E6E6D2E6E7E7E9E8E9E9E7E7E7E4E3E3E2DBE3E3E4E5E1E3E3E3E4E0E2E3E4E2A8E5E3E2E5E09D4C3AE3E4E6E7E7E7E4D21928E000E6E3E5E5E587D4E2E3E5E3E4E3E6E62B1D0500C2E3E7E6E6E7E5E0E3E3E6E5E6E5E5E4E4DCE4B754009FE5E7E7E4E500A8E2E5E6E5E4E5E6E5E4E4E4E2E6E5E7E6E4E5E5D2E6E7E5E6E6E7E7E7E4E4E4E3E5E4E3E6E4E7E5E6E8E6E7E7E7E4E6E3E4E6E4E6E7E7E6E6E8E3E7E7E6E7E5E5E6E5E5E4E8E5E5E5E7E7E6E6E9E6E7E3E8E7E8E7E4E3E5E4E7E6E8E8E5E3E4E5E8E7E6E7E8E6E5E7E7E6E7E9E6E5E0E5E5E5E6E6E6E6E5DDE8E7E7E7E6E6E6C9E3E0E6E6E6E5E5E6E4E5E5E5E7E7E7E6E8E7E8E8E7E6E6E6E7E5E7E6E7E8E8E8E8E8E8E8E8E7E6E5E4E0E4E2E3E1A8E4E3E4DBE2E3E2E4E0E6E4E5E4E3E1E5E0E24C45E5E4E3E6E4E5E4E05000C7E1E4E5E4E6C0E1D8E2CDE2E7E5E626E5A6A60005E1E4E5E6E4E5E7E5E5E6E6E5E3E7E4E5E4E5E3B3E3AA59E3E6E3E6E50AB7E5E5E6E8E4E6E8E6E6E6E5E6E6E7E5E5E5E5E4E5E5E6E6E5E8E6BAE5E9E6E6E7E3E2E4E5E7E8E8E6E6E6E8E7E9E7E8E6E6E7E6E6E7E5E5E5E6E7E8E6E6E5E3E4E6E7E5E7E6E6E8E6E8E6E7E7E7E6E5E6E5E4E5E4E6E4E6E7E8E7E8E7E6E5E4E6E7E7E8E7E7E7E6E7E8E7E7E7E5E5E6E7E7E8E5E7E5E6E4E6E8E7E8E8E7E5A6E6E7E7E7E8E3E5E5E7E6E7E7E6E8E7E9E7E8E8E8E8E6E6E6E5000000
+                                                                                    USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A50000000001000001E7E7E7E7E7E7E9E7E9E7E8E8E2E7E7E3E3E4A4E3E5E0E3D4A4E2E3E4E4E3E5E5E7E7E6E6E69FE0E7E420017CE1E1E5E3E4E4E13315A4A4E4E6E7E4E5E4E5E6E2E5E5E4E2E5E6E3CB158375E4E7E6E6E5E5E5E0E5E6E7E6E5E6E6E4E5E6E457332FE6E6E6E2E696E380E3E4E4E3E6E4E5E6E6E6E7E6E6E8E7E7E5E5E5E4E5E5E2E8E7E7E7E5E6E5E6E6E7E5E5E7E7E7E8E6E3E6E7E3E6E6E6E4E7E7E6E4E5E6E5E5E5E6E6E5E5E5E4E6E7E5E5E7E6E6E5E6E7E5E7E5E6E6E5E7E5E6E3E5E6E5E7E7E6E5E6E6E7E6E7E7E7E8E6E7E6E8E7E3E7E8E7E6E5E5E7E8E6E5E7E8E6E5E6E8E7E8E6E6E7E6E6E6E7E6E7E6E6E5E6E7E6E7E5E8E8E8E9E8E7E8E7E6E6E6E6E8E7E8E8E7E7E6E6EAE9E9EAE6E7E8E8E1ACE2E2E3E4E2E3E564E2E4E4CDE5B1E1BCE6E7E5E5E7E5E5E27AE4E5E4E5E6E2E5E473E2DCE4E5E2C9E5E4E2E2E4B7E3E5E4E4E2E5E4E2549675E5E5E5E3E6E4E5E3E5E4E5E4E2E6E3E3E3E5E5A800C2E5E5E5E6E5E4D4E5E6E6E5E5E5E4E5E4E5E4E4E4E4E4E6E6E4E4E6E6E7E5E4E4E5E6E5E7E8E6E6E6E6E5E6E6E4E6E5E7E9E7E5E7E6E5E7E7E7E6E6E5E5E4E4E4E5E6E5E6E5E5E6E6E5E5E4E6E5E6E6E5E8E6E7E4E4E4E5E6E9E8E8E4E5E5E8E8E7E6E5E6E7E7E8E6E6E6E7E7E8E5E6E6E7E8E7E8E9E8E7E6E6E6E6E6E6E7E7ACE7E7E6E5E6E6E7E8E7E5E7E3E7E8E8E7E7E8E6E7E9E8E8E8E7E6E7E6E7E6E7000000
+                                                                                     USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A70000000001000001E7E7E7E7E7E9E9E9E8E8E8E8E7E8E9E8E3E4E5E4E0DFB7E4E7E6E7E6E04131E5E6E5E5E5E4E4E5E39D80E6E5E5E675E6E7E7E7C0C0E2E5E4E6E4E5E4E2E4E3E3E6E7E6E7E6E5E5E6E4E2E5E4E1E2E6E7E4E6E5E5E4E5E5E7E6E6C5E5E6E4E12BE2E7E6D8E5E6E2E2E4E4E5E5E4E4E6E7E8E6E6E7E6E6E6E6E6E5E7E7E5E5E2E6E4E4E5E4E8E7E6E7E1E5E5E6E7E8E8C5E6E6E7E5E5E6E6E3E6E5E7E7E6E6E6E6E7E8E7E7E4E6E5E6E5E6E6E5E5E5E6E5E6E7E5E5E6E5E3E8E8E8E6E8E5E7E5E7E7E7E8E8E6E7E5E8E7E8E6E7E5E6E6E6E7E2E7E7E8E7E5E8E8E7E6E7E6E5E3E5E4E0E6E7E7E8E9E7E9E7E7E7E8E7E8E7E8E8E8E8E6E6E5E5E9E8E9E8E7E6E7E7E8E7E7E7E7E5E7E7E7E7E7E7E7E8E8E9E3E2E3E2E6E6E4E6E4E4E4E5E3E5E5E4E7E580C9E4DDE5E5E3E5E7A8E6E5E6E6E3E5E5E3E5E5E3E5E6E5E4E4E4E5E4E6E5E5E4E4E5E492E3E6E6E6E6E4E4E4E5E6E7E7E7E5E6E6E6E6E4E5E4E5E4E3E3E5E5E5E7E8E7E6E8E8E9E8E9E6E4E5E7E6E7E6E6E480E5E5E6E7E8E7E4E6E4E4E7E5E6E6E8E9E8E6E6E8E8E6E6E5E6E7E8E7E8E7E4E6CDE6E6E7E6E6E5E4E4E5E6E6E7E6E6E4E5E6E5E5E4E4E6E6E7D2E7E8E8E9E8E7E8E8E9E7E5E6E4E6E5E5E8E5E7E6E4E5E7E7E6E8E7E6E9E8E7E8E8E6E8E7E7E7DEE7E6E6E6E7E8E7E7E3E7E8E7E8E6E6E6E7E7E8E7E7E6E6E7E7E6E7E7E7E8E7E7E8E7E8E7E8E7E5E6E6000000
+                                                                                      USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A90000000001000001E8E8E8E9E5E6E6E6E7E6E6E7E2E2E3E1E3E3E2E3E6E5E5E4E4E5E3E4E5E3E2E6283AE4E5E4E119E57CE2E6E7E6E7E7E4E6E5E5E692E1E5E5E3E4E3E4E4E5E5E4E5E6E4E7E6A1E7E6E6E6E6E7E6E6E5E3E5E4E5E3E6E6E5E6E6E6E6E5E4E5E5E6E5E6E6E6E7E5E5E5E4E6E5E3E4E3E3E4E4E5E5E5E5BEE5E5E4E4E6E4E6E7E4E6E8E5E7E6E7E4E6E5E6E4C5E6E7E7E7E7E8E7E8E7E6E6E7E7E5E4E5E4E4E4E4E3E6E3E4E3E6E6E8E7E7E6E4E5E7E6E6E8E5E5E7E7E4E5E6E7E6E5E7E7E3E4E6E5E8E1E7E5E7E3E6E6E5E5E4E6E8E6E7E8E5E5E4E4E85DE7E8E5E6E8E7E8E7E6E7E6E6E6E6E5E3E7E7E8E8E7E7E9E8E8E9E9E9E8EAE2E8E7E7E6E6E6E7E6E7E6E7E8E8E8E8E8E8E6E3E9EAE7EAE1E3E4E3E5E4E4E4E373E2E2E5E4E4E4E5E3E4E6B3E0E5E5E6E5E4E5E5C0E5E7E2E6E5689B9FE5E4E3E0E4E7E4E5E4E3E3E3E4E4E3E4E3E3E4E5E5E5E4E1E3E5E7E6E5E6E5E6E6E6E5E5E6E6E5E6E6E5E5E5E2E4E3E0E4E5E4E5E4E5E5E6E4E4E2E5E0E5E3E5E6E6E4E5E3E5E5E5E6E5E2E3E3E2E6E6E7E7E6E6E5E4E5E5C0E5E5E5E5E6E6E6E7E6E6E7E6E5E6E6E6E7E5E5E3E4E4E5E5E1E5E2E6E6E8E7E6E5E6E6E5E7E5E5E5E6E3E6E5E7E8E6E7E7E7E7E7E8E5E1E5E5E7E5E7E7E6E7E4E5E0E7E7E6E5E6E3E5E7E9E7E8E8E7E7E8E8E7E7E7E6E6E8E6E6E6E7E6E6E7E7E6E8E8E6E8E8E8E7E6E7E7E7E7E7E7E8E7E7E6E6E7000000
+                                                                                       USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AB0000000001000001E6E6E6E6E9E8E8E8E8E8E7E6E4E4E3E5E2E3E4E1E6E6E5E0E5E6E5E4E8D0E7E8E4A1DE96AAE2E5E6E5E2E5E2E6E6E02B2F414CE4DFE1E4E5E5E5E6E4E4E3E4E5E5E5E5E4C7E7E5E5E4E4E2E4E6E7E7E6C7E5E5E596E1CDE5E4E4E5E4E6E5E1E4E6E6E8E8E6E4E4E5E7E7E4E5E4E5E4CBE5E6E7A8E7E5E6E5E6E7E7E7E5E5E7E5E6A1E3E6E7E5E6E3E4E6BEE7E7E5E5E5E6E3E6E5E6E6E6E5E6E6E1E8CDE1E4E5E6E4E3E3E5E7E7E6E5E5E6E4E4E3E4E5E5E8E7E7E6E6E7E6E8E5E7E7E6E6E6E6E7E7E7E5E6E7E7E9E7E6E8E6E4E5E7E8E6DDE5E6E6E8E7E7E8E8E8E8E6E7E5E4E9E8E8E8E7E7E8E5E7E7E7E7E6E7E8E6E7E7E6E9E8E6E6E4E7E7E7E6E6E6E6E5E9E7E7E8E7E8E7E7E8E8E8E9E1E3E3E3E3E5E3E5E5E5E4E4E7E7E7E7E5E5E5E6E5E5E4E4E7E7E6E72F43E4E2E8B533E771262831BEE5E6E3E5E44EE5E2E3DFDDE5E5E6E6E6E6E5E6E6E7E5E7E6E4E5E6E4E1E5E6E6E5E6E5E6E3E4E6E6D6E6E6E7E6E6E7E6E5E4E3E4E7E3E5E5E0E4E46FE6E2E7E7E6E51DE7E5E6E5E6E5E4E4E5E6E6E5E7E7E7E6E6E6E8E6E6E7E7E7E6E8E7E7E4E4E2C2E6E6E2E5E3E5E5E7E6E5E5E6E7E7E8E7E7E7E5E5E5E6E7E6E6E5E5E5E6E7E9E1E7E6E7E7E7E6E5E7E7E7E7E8E6E5E5E7E6E6E5E7E8E9E7E8E7E7E7E6E8E7E6E8E6E6E8E6E7E6E7E6E7E7E6E7E8E8E7E6E8E8E9E9E8E8E6E7E8E7E7E7E8E7E4E7E8E8E9E9E6E5E6E7000000
+                                                                                        USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AD0000000001000001E6E5E6E6E9E7E7E8E8EAE9EAE8E6E5E6E3E2E3E4E2E3E5E3E2E5E6E4E5E300E6E6E6E0E6E7E2E6E3E1E4E0BCE8E5DEE7DDE6D44EE1E0E596A4E649E6E6DDE3A1E6E6E6E738E296B324E4E3A65D7AC2E5E7E7E5E6E5E2E4E3E5E5E4E4E5C0E5E6E5E5E673E4E5E4E5A1E6E6E8E5E4E6E4E6D2C7E2E4E5E5E6E4E8E3CDE1E6E5E1E3E3E2E4E5E5E6E1E5E56FE6E6E6E6E5E7E4E7E8E6E8E6E6E5E5E6E4E6E5E6E7E8E5E5E7E6E8E7E7E7E6E5E7E7E6E6E7E8E4E6E6E5E5E7E5E8E8E8E7E7E5E7E6E6E6E8E7E7E6E7E6E8E5E0E8E9E7E8E7E6E6E5E6E7E7E6E6E6E7E8E6E7E7E7E8E387E8E8E7E8E7E7E6E5E5E5E7E7E76DE6E6E6E7E7E8E7E7E7E4E7E7E6E6E5E5E8E7E8E8E7E7E6E6E8E8E7ACE4E4E2E3E3E4E3E4E7E6E6E5E7E6E5E6E6E4E5E5E7E6E6E8E7E5E6E6E5E6E6E7E5E5E6E6E7E7E7E6E7E1E7E5E6E7E6E7E7E7E468CDE5E3E4E7E2A6E0E3E6E3E6E0CDE7E7E5E5E6E475CDE5E5E7E7E6E7E5E1E5E4E6E5E6E5E8E7E5E2E6DBE4E7E8E7E6E5E5E4E5E4E7E6E7E8E5E5E6E2E6E6E6E7E6E6E8E6AFE7E6E7E7E8E9E5E6E5E5E6E9E8E8E8E6E5E7E7E9E8E7E7E6E8E8E2E6E6E7E7E6E6E7E8E8E9E9E8E6E6E6E6E9E8E8E8E7E9E8E9E7E8E8E8E6E7EBE8E8E8E6E7E7E7E6E7E7E6E6E7E9E5E7E8E7E8E7E7E8E7E6E7E7E8E7E8E7E8E7E7E8E7E8E7E9E9E9E8E6E6E6E6E8E7E7E7E7E8E9E7E8E6E6E7E8E8E6E7E6E5E6E6000000
+                                                                                         USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AF0000000001000001E7E7E6E7E9E8E9E9E0E8E7E8E6E9E9E8E5E4E5E6E4E6E6E6E7E6E6E7E6E4E5E5E6E7E5E5E6E6E5E7E6E6E7E7E8E7E7E7E7E6E6E7E6E6E6E5E5E6E6E6E6E6E6E6E7E8E6E6E8E6E8E8E7E7E7E8E6E6E7E6E6E7E6A6E4E5E5E6E7E7E8E8E6E5E4E4E6E7E6E7E7E7E7E6EAE7E7E7E6E7E6E7E6E8E9E8EAE8E8E8E6E7E9E7E8E6E7E7E6E5E7E7E7E8E4E7E9E8E8E8E7E4E1E8E6E8E7E7E7E7E8E7E8E5E6E6E8E7E8E8E8E8E9E9E9E9E8E9E8E8E7E8E7E6E7E7E8E7E6E8E7E7E6E8E9E9E7E9E8E8E3E6E8E8E7E8E8E8E9E7E8E8E8E8E9E9E9E7E7E6E7E8E8E8E8E8E7E7E8E7E7E7E8E6E8E8E9E8E7E7E6E6E8E8E7E8E8E8E6E8EAEAE9EAE7E7E9E8E6E7E8E8E6E6E6E6E8E8E8E7E7E8E8E7EAE7E9E8E8E6E6E7E5E6E5E5E6E5E6E5E5E6E5E5E6E7E6E7E6E6E6E5E8E5E6E8E4E5E4E5E7E6E7E7E7E7E8E7E6E6E4E6E7E4E6E7E7E5E5E5E6E5E7E6E8E7E8E8E7E6E6E6E7E7E6E8E5E5E6E7E7E585E7E8E7E8E9E6E6E7E6E7E7E6E6E8E6E6A6E7E6E6E6E8E8E8E7E7E8E8E7E7E7E5E6E2E7E8E7E6E5E6E4E7E9E7E8E7E7E7E7E8E8E7E8E785E8E8E8E0E8E9E8E8E7E8E6E7E6E7E8E8E8E7E8E8E9E8E7E7E8E8E8E7E9E6E6E6E7E7E9E8E8E9E8E6E7E7E6E5E6E6E8E6E7E8E7E7E6E7E9E8E8E9E6E6E6E7E6E6E6E6E8E8E8E8E8E8E7E8E7E7E8E8E6E6E8E7E6E6E7E6E8E8E8E6E6E7E7E8E9E7E7E7E9E8E7E8D4E6E8E6EAE8E8E8E6E6E6E6000000
+                                                                                          USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000B10000000001000001E6E6E6E6E8E7E8E9E9E8E7E8E5E8E8E8E6E4E5E5E6E5E6E5E7E7E8E8E1E5E4E5E7E6E7E7E5E6E5E6E6E741E5E7E6E8E8E6E5E6E5E8E6E7E8E5E6E5E6E93CE5E7E6E5E4E6E6E7E6E5E7E5E7E5E5E5E6E6E6E6E7E6E5E6E7E7E6E7E6E6E6E6E5E5E6E7E6E7E6E5E6E6E6E8E7E7E7E7E7E8E8E8E7E8E8E6E7E7E6E6E6E6E6E5E6E6E8E6E7E8E8E8E7E8E9E9E9E7E8E6E8E8E6E4E7E7E8E7E7E7E7E5E6E6E7E7E7E7E7E6E8E8E6E7E6B5E7E7E7E7E7E6E7E7E8E7E7E7E9E8E8E8E7E7E7E7E7E7E7E9E6E8E7E7E7E6E6E6E7E8E8E8E8E7E7E7E8E8EAE8E7E8E8E8E8E8E7E8E8E6E6E6E6E6E5E6E8E8E7E7E6E7E5E6E8E6E7E7E7E7E7E7E6E5E6E6E7E7E6E7E6E6E6E6E8E8E7E8E7E7E8E8EAE9E8E6E8E7E9E7E3E3E6E6E6E6E7E6E7E7E6E7E6E6E6E4E6E5E6E6E6E5E5E5E7E7E8E7E8E8E8E8E5E6E6E6E8E7E7E7E6E5E4E5E6E6E8E7E1E8E8E7E9E8E9E8E8E7E8E7E7E7E7E6E6E7E7E7E6E7E8E8E6E7E7E8E7E7E8E6E8E8E7E8E7E7E7E7C9E6E9E7E7E7E7E7E8E9E1EAE8E8E6E8E8E7E8E7E6E6E7E7E7E2E7E7EAE9E8E8E6E9E3E8E7E8E8E7E6E6E6E6E7E7E8E6E6E6E6E7E7E6E8E6E7E6E7E7E8E8E7E7E8E5E8E7E6E8E7E8E7E7E7E6E7E9E8EAE7E8E9E8E7E6E8E8E7E8E9E8E7E7E7E6EAE8E8E7E7E7E8E7E6E7E9E9E8E8E6E7E6E7E7E8E7E7E8E7E8E7E7E7E8E8E8E6E7E6E7E7E8E8E7E9E6E6E7E7E8E2E8E7E6E8E8E8E6E6E6E7000000
+                                                                                           USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000000000000B30000000001000001E6E4E5E5E7E7E8E7E9E9E9E8E6E8E8E8E4E6E5B3E4E4E5E6E5E5E5E7E5E5E5E6E6E6E6E5E9E7E8E7E5E5E5E6E8E8E7E7E7E9E9E8E8E6E8E7E6E6E7E8E6E5E5E5E7E7E7E4E6E6E6E7E7E6E6E6E6E6E7E8E6E6E664E8E7E6E6E6E7E8D6E7E5E6E6E9E7E7E6E6E7E6E6E6DCE8E8E8E7E8E8E7E8E6E8E9E7E5E6E6E4E6E6E6E7E7E7E8E8E7E7E8E7E8E7EAE6E7E8E7E7E7E8E9EAE9E9E6E6E6E7E7E7EAE9E8E7E7E7E8E6E6E7E8E6E8E8E7E7E6E6E6E7E7E8E8E7E8E4E8E6E7E7E7E9E6E9E6E7E6E7E8E8E9E7E7E7E6E8E9E8E9E8E9E7E7E7E7E5E7E2E8E7E7E8E7E6E7E6E6E6E7E7E6E7E8E5E8E6E8E7E8E9E9E8E6E5E7E7E9E8E9E9E7E5E7E6E7E7E6E7E6E6E6E5E8E8E8E7E7E7E8E8EAEAEAEAE6E6E8E6E5E5E6E6E4E3E4E4E6E4E5E7E6E6E5E5E6E6E6E7E8E6E8E8E8E7E9E7E7E6E7E7E9E7E7E8E8E4E7E8E7E7E7E6E7E7E7E6E5E4E5E6E7E3E4E5E6E6E6E4E9E8E7E8E7E8E7E9E6E6E6E6E7E7E6E4E5E4E5E4E5E6E6E6E8E7E6E7E7E7E8E6E5E7E7E6E3E7E6E6E8E5E6E6E8E7E8E8E7E6E7E7E8E8E7E7E6E6E7E7E6E8E5E8E5E5E5E6E8E9EAE9E9E8E9E9E9E9E8E7E6E7E7E99BE5E6E6E8E8E0E7E9E9E8E8EAE7E9E9E9E8E8E8E7E7E5E8E9E7E6E8E6E7E7E8EAE9E7E8E9E9E9E8E7E7E6E7E8E8E6E7E7E7E7E7E6E7E7E7EAE6E6E8E6E6E6E5E8E8E8E8E7E8E7E7E5E6E7E6E8E8E6E7E5E6E6E5E8E8E7E9E8E8E8E8E6E6E5E6000000

tests/test-device-fake.c

@@ -279,4 +279,6 @@ fpi_device_fake_class_init (FpiDeviceFakeClass *klass)
   dev_class->list = fpi_device_fake_list;
   dev_class->delete = fpi_device_fake_delete;
   dev_class->cancel = fpi_device_fake_cancel;
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

tests/test-fpi-device.c

@@ -506,6 +506,175 @@ test_driver_get_driver_data (void)
   g_assert_cmpuint (fpi_device_get_driver_data (device), ==, driver_data);
 }
 
+static void
+test_driver_initial_features (void)
+{
+  g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
+  FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_none (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->list = NULL;
+  dev_class->capture = NULL;
+  dev_class->verify = NULL;
+  dev_class->identify = NULL;
+  dev_class->delete = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, ==, FPI_DEVICE_FEATURE_NONE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_capture (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->capture = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_verify (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->verify = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_identify (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->identify = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_storage (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->list = NULL;
+  dev_class->delete = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_list (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->list = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
+static void
+test_driver_initial_features_no_delete (void)
+{
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+
+  dev_class->list = NULL;
+  dev_class->features = FPI_DEVICE_FEATURE_NONE;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+
+  g_assert_cmpuint (dev_class->features, !=, FPI_DEVICE_FEATURE_NONE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_CAPTURE);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_IDENTIFY);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_VERIFY);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_DUPLICATES_CHECK);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_LIST);
+  g_assert_true (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_DELETE);
+  g_assert_false (dev_class->features & FPI_DEVICE_FEATURE_STORAGE_CLEAR);
+}
+
 static void
 on_driver_probe_async (GObject *initable, GAsyncResult *res, gpointer user_data)
 {
@@ -992,6 +1161,39 @@ test_driver_verify (void)
   g_assert_true (match);
 }
 
+static void
+test_driver_verify_not_supported (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpPrint) enrolled_print = NULL;
+  g_autoptr(FpPrint) out_print = NULL;
+  g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  FpiDeviceFake *fake_dev;
+  gboolean match;
+
+  dev_class->features &= ~FPI_DEVICE_FEATURE_VERIFY;
+
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+  fake_dev->last_called_function = NULL;
+
+  enrolled_print = make_fake_print_reffed (device, g_variant_new_uint64 (3));
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL,
+                                         test_driver_match_cb, match_data,
+                                         &match, &out_print, &error));
+
+  g_assert_null (fake_dev->last_called_function);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_NOT_SUPPORTED);
+
+  g_assert_false (match_data->called);
+  g_assert_no_error (match_data->error);
+
+  g_assert_null (out_print);
+  g_assert_false (match);
+}
+
 static void
 test_driver_verify_fail (void)
 {
@@ -1311,7 +1513,7 @@ test_driver_do_not_support_identify (void)
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpDevice) device = NULL;
 
-  dev_class->identify = NULL;
+  dev_class->features &= ~FPI_DEVICE_FEATURE_IDENTIFY;
 
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   g_assert_false (fp_device_supports_identify (device));
@@ -1639,6 +1841,7 @@ test_driver_supports_capture (void)
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpDevice) device = NULL;
 
+  dev_class->features |= FPI_DEVICE_FEATURE_CAPTURE;
   dev_class->capture = fake_device_stub_capture;
 
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
@@ -1651,6 +1854,7 @@ test_driver_do_not_support_capture (void)
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpDevice) device = NULL;
 
+  dev_class->features &= ~FPI_DEVICE_FEATURE_CAPTURE;
   dev_class->capture = NULL;
 
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
@@ -1676,6 +1880,29 @@ test_driver_capture (void)
   g_assert (image == fake_dev->ret_image);
 }
 
+static void
+test_driver_capture_not_supported (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpImage) image = NULL;
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  gboolean wait_for_finger = TRUE;
+  FpiDeviceFake *fake_dev;
+
+  dev_class->features &= ~FPI_DEVICE_FEATURE_CAPTURE;
+
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+  fake_dev->last_called_function = NULL;
+
+  image = fp_device_capture_sync (device, wait_for_finger, NULL, &error);
+  g_assert_null (fake_dev->last_called_function);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_NOT_SUPPORTED);
+
+  g_assert_null (image);
+}
+
 static void
 test_driver_capture_error (void)
 {
@@ -1695,18 +1922,13 @@ test_driver_capture_error (void)
   g_assert_null (image);
 }
 
-static void
-fake_device_stub_list (FpDevice *device)
-{
-}
-
 static void
 test_driver_has_storage (void)
 {
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpDevice) device = NULL;
 
-  dev_class->list = fake_device_stub_list;
+  dev_class->features |= FPI_DEVICE_FEATURE_STORAGE;
 
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   g_assert_true (fp_device_has_storage (device));
@@ -1718,7 +1940,7 @@ test_driver_has_not_storage (void)
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpDevice) device = NULL;
 
-  dev_class->list = NULL;
+  dev_class->features &= ~FPI_DEVICE_FEATURE_STORAGE;
 
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   g_assert_false (fp_device_has_storage (device));
@@ -1770,7 +1992,7 @@ test_driver_list_no_storage (void)
   g_autoptr(GPtrArray) prints = NULL;
   g_autoptr(GError) error = NULL;
 
-  dev_class->list = NULL;
+  dev_class->features &= ~FPI_DEVICE_FEATURE_STORAGE;
 
   device = auto_close_fake_device_new ();
   g_assert_false (fp_device_has_storage (device));
@@ -2439,6 +2661,14 @@ main (int argc, char *argv[])
   g_test_add_func ("/driver/get_usb_device", test_driver_get_usb_device);
   g_test_add_func ("/driver/get_virtual_env", test_driver_get_virtual_env);
   g_test_add_func ("/driver/get_driver_data", test_driver_get_driver_data);
+  g_test_add_func ("/driver/initial_features", test_driver_initial_features);
+  g_test_add_func ("/driver/initial_features/none", test_driver_initial_features_none);
+  g_test_add_func ("/driver/initial_features/no_capture", test_driver_initial_features_no_capture);
+  g_test_add_func ("/driver/initial_features/no_verify", test_driver_initial_features_no_verify);
+  g_test_add_func ("/driver/initial_features/no_identify", test_driver_initial_features_no_identify);
+  g_test_add_func ("/driver/initial_features/no_storage", test_driver_initial_features_no_storage);
+  g_test_add_func ("/driver/initial_features/no_list", test_driver_initial_features_no_list);
+  g_test_add_func ("/driver/initial_features/no_delete", test_driver_initial_features_no_delete);
 
   g_test_add_func ("/driver/probe", test_driver_probe);
   g_test_add_func ("/driver/probe/error", test_driver_probe_error);
@@ -2455,6 +2685,7 @@ main (int argc, char *argv[])
   g_test_add_func ("/driver/verify/fail", test_driver_verify_fail);
   g_test_add_func ("/driver/verify/retry", test_driver_verify_retry);
   g_test_add_func ("/driver/verify/error", test_driver_verify_error);
+  g_test_add_func ("/driver/verify/not_supported", test_driver_verify_not_supported);
   g_test_add_func ("/driver/verify/report_no_cb", test_driver_verify_report_no_callback);
   g_test_add_func ("/driver/verify/not_reported", test_driver_verify_not_reported);
   g_test_add_func ("/driver/verify/complete_retry", test_driver_verify_complete_retry);
@@ -2466,6 +2697,7 @@ main (int argc, char *argv[])
   g_test_add_func ("/driver/identify/complete_retry", test_driver_identify_complete_retry);
   g_test_add_func ("/driver/identify/report_no_cb", test_driver_identify_report_no_callback);
   g_test_add_func ("/driver/capture", test_driver_capture);
+  g_test_add_func ("/driver/capture/not_supported", test_driver_capture_not_supported);
   g_test_add_func ("/driver/capture/error", test_driver_capture_error);
   g_test_add_func ("/driver/list", test_driver_list);
   g_test_add_func ("/driver/list/error", test_driver_list_error);

tests/vfs7552/device

@@ -0,0 +1,222 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-7
+N: bus/usb/001/003=12010002FF10FF088A13910064010000010109023500010100A0320904000005FF000000070501024000000705810240000007058202400000070583030800040705840310000A
+E: DEVNAME=/dev/bus/usb/001/003
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=138a/91/164
+E: TYPE=255/16/255
+E: BUSNUM=001
+E: DEVNUM=003
+E: MAJOR=189
+E: MINOR=2
+E: SUBSYSTEM=usb
+E: ID_VENDOR=138a
+E: ID_VENDOR_ENC=138a
+E: ID_VENDOR_ID=138a
+E: ID_MODEL=0091
+E: ID_MODEL_ENC=0091
+E: ID_MODEL_ID=0091
+E: ID_REVISION=0164
+E: ID_SERIAL=138a_0091_ba1ea8009583
+E: ID_SERIAL_SHORT=ba1ea8009583
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_VENDOR_FROM_DATABASE=Validity Sensors, Inc.
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=VFS7552 Touch Fingerprint Sensor
+E: ID_PATH=pci-0000:00:14.0-usb-0:7
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_7
+A: authorized=1\n
+A: avoid_reset_quirk=0\n
+A: bConfigurationValue=1\n
+A: bDeviceClass=ff\n
+A: bDeviceProtocol=ff\n
+A: bDeviceSubClass=10\n
+A: bMaxPacketSize0=8\n
+A: bMaxPower=100mA\n
+A: bNumConfigurations=1\n
+A: bNumInterfaces= 1\n
+A: bcdDevice=0164\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002FF10FF088A13910064010000010109023500010100A0320904000005FF000000070501024000000705810240000007058202400000070583030800040705840310000A
+A: dev=189:2\n
+A: devnum=3\n
+A: devpath=7\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4c/device:4d/device:54
+A: idProduct=0091\n
+A: idVendor=138a\n
+A: ltm_capable=no\n
+A: maxchild=0\n
+L: port=../1-0:1.0/usb1-port7
+A: power/active_duration=385364\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=34389164\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/persist=1\n
+A: power/runtime_active_time=392057\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=33996840\n
+A: power/wakeup=disabled\n
+A: power/wakeup_abort_count=\n
+A: power/wakeup_active=\n
+A: power/wakeup_active_count=\n
+A: power/wakeup_count=\n
+A: power/wakeup_expire_count=\n
+A: power/wakeup_last_time_ms=\n
+A: power/wakeup_max_time_ms=\n
+A: power/wakeup_total_time_ms=\n
+A: quirks=0x0\n
+A: removable=fixed\n
+A: rx_lanes=1\n
+A: serial=ba1ea8009583\n
+A: speed=12\n
+A: tx_lanes=1\n
+A: urbnum=356510\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020011050302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/001/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/511
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=0
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_5.11.2-arch1-1_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x205.11.2-arch1-1\x20xhci-hcd
+E: ID_VENDOR_ID=1d6b
+E: ID_MODEL=xHCI_Host_Controller
+E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
+E: ID_MODEL_ID=0002
+E: ID_REVISION=0511
+E: ID_SERIAL=Linux_5.11.2-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=2.0 root hub
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_FOR_SEAT=usb-pci-0000_00_14_0
+E: TAGS=:seat:
+E: CURRENT_TAGS=:seat:
+A: authorized=1\n
+A: authorized_default=1\n
+A: avoid_reset_quirk=0\n
+A: bConfigurationValue=1\n
+A: bDeviceClass=09\n
+A: bDeviceProtocol=01\n
+A: bDeviceSubClass=00\n
+A: bMaxPacketSize0=64\n
+A: bMaxPower=0mA\n
+A: bNumConfigurations=1\n
+A: bNumInterfaces= 1\n
+A: bcdDevice=0511\n
+A: bmAttributes=e0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002090001406B1D020011050302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0\n
+A: devnum=1\n
+A: devpath=0\n
+L: driver=../../../../bus/usb/drivers/usb
+L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4c/device:4d
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 5.11.2-arch1-1 xhci-hcd\n
+A: maxchild=16\n
+A: power/active_duration=3289930\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=34389654\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_time=3289845\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=31099805\n
+A: power/wakeup=disabled\n
+A: power/wakeup_abort_count=\n
+A: power/wakeup_active=\n
+A: power/wakeup_active_count=\n
+A: power/wakeup_count=\n
+A: power/wakeup_expire_count=\n
+A: power/wakeup_last_time_ms=\n
+A: power/wakeup_max_time_ms=\n
+A: power/wakeup_total_time_ms=\n
+A: product=xHCI Host Controller\n
+A: quirks=0x0\n
+A: removable=unknown\n
+A: rx_lanes=1\n
+A: serial=0000:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=2355\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:A12F
+E: PCI_SUBSYS_ID=1028:07BE
+E: PCI_SLOT_NAME=0000:00:14.0
+E: MODALIAS=pci:v00008086d0000A12Fsv00001028sd000007BEbc0Csc03i30
+E: SUBSYSTEM=pci
+E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
+E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
+E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
+E: ID_VENDOR_FROM_DATABASE=Intel Corporation
+E: ID_MODEL_FROM_DATABASE=100 Series/C230 Series Chipset Family USB 3.0 xHCI Controller
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=86802FA1060490023130030C000080000400D1ED0000000000000000000000000000000000000000000000002810BE07000000007000000000000000FF010000
+A: consistent_dma_mask_bits=64\n
+A: d3cold_allowed=1\n
+A: device=0xa12f\n
+A: dma_mask_bits=64\n
+L: driver=../../../bus/pci/drivers/xhci_hcd
+A: driver_override=(null)\n
+A: enable=1\n
+L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4c
+L: iommu=../../virtual/iommu/dmar1
+L: iommu_group=../../../kernel/iommu_groups/4
+A: irq=143\n
+A: local_cpulist=0-7\n
+A: local_cpus=ff\n
+A: modalias=pci:v00008086d0000A12Fsv00001028sd000007BEbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/143=msi\n
+A: numa_node=-1\n
+A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts    7   10 2112 10\nxHCI ring segments   30   38 4096 38\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\n
+A: power/control=on\n
+A: power/runtime_active_time=34390988\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=0\n
+A: power/wakeup=enabled\n
+A: power/wakeup_abort_count=0\n
+A: power/wakeup_active=0\n
+A: power/wakeup_active_count=0\n
+A: power/wakeup_count=0\n
+A: power/wakeup_expire_count=0\n
+A: power/wakeup_last_time_ms=0\n
+A: power/wakeup_max_time_ms=0\n
+A: power/wakeup_total_time_ms=0\n
+A: power_state=D0\n
+A: resource=0x00000000edd10000 0x00000000edd1ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
+A: revision=0x31\n
+A: subsystem_device=0x07be\n
+A: subsystem_vendor=0x1028\n
+A: vendor=0x8086\n
+

tests/virtual-device.py

@@ -424,6 +424,30 @@ class VirtualDevice(VirtualDeviceBase):
         while not opened:
             ctx.iteration(True)
 
+    def test_close_while_opening(self):
+        self.set_keep_alive(True)
+        self.dev.close_sync()
+
+        opened = False
+        def on_opened(dev, res):
+            nonlocal opened
+            dev.open_finish(res)
+            opened = True
+
+        self.send_sleep(500)
+        self.dev.open(callback=on_opened)
+
+        self.wait_timeout(10)
+        self.assertFalse(self.dev.is_open())
+
+        with self.assertRaises(GLib.Error) as error:
+            self.dev.close_sync()
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.NOT_OPEN))
+
+        while not opened:
+            ctx.iteration(True)
+
     def test_enroll(self):
         matching = self.enroll_print('testprint', FPrint.Finger.LEFT_LITTLE)
         self.assertEqual(matching.get_username(), 'testuser')
@@ -825,6 +849,21 @@ class VirtualDevice(VirtualDeviceBase):
 
         self.assertEqual(close_res.code, int(FPrint.DeviceError.BUSY))
 
+    def test_identify_unsupported(self):
+        if self.dev.supports_identify():
+            self.skipTest('Device supports identification')
+
+        with self.assertRaises(GLib.Error) as error:
+            self.dev.identify_sync([FPrint.Print.new(self.dev)])
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.NOT_SUPPORTED))
+
+    def test_capture_unsupported(self):
+        with self.assertRaises(GLib.Error) as error:
+            self.dev.capture_sync(wait_for_finger=False)
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.NOT_SUPPORTED))
+
 
 class VirtualDeviceClosed(VirtualDeviceBase):
 

tests/virtual-sdcp.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-try:
-    import gi
-    import os
-
-    from gi.repository import GLib, Gio
-
-    import unittest
-    import subprocess
-    import shutil
-    import tempfile
-except Exception as e:
-    print("Missing dependencies: %s" % str(e))
-    sys.exit(77)
-
-FPrint = None
-
-# Re-run the test with the passed wrapper if set
-wrapper = os.getenv('LIBFPRINT_TEST_WRAPPER')
-if wrapper:
-    wrap_cmd = wrapper.split(' ') + [sys.executable, os.path.abspath(__file__)] + \
-        sys.argv[1:]
-    os.unsetenv('LIBFPRINT_TEST_WRAPPER')
-    sys.exit(subprocess.check_call(wrap_cmd))
-
-# Only permit loading virtual_sdcp driver for tests in this file
-os.environ['FP_DRIVERS_WHITELIST'] = 'virtual_sdcp'
-
-if hasattr(os.environ, 'MESON_SOURCE_ROOT'):
-    root = os.environ['MESON_SOURCE_ROOT']
-else:
-    root = os.path.join(os.path.dirname(__file__), '..')
-
-ctx = GLib.main_context_default()
-
-class VirtualSDCP(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        os.environ['FP_VIRTUAL_SDCP'] = os.environ['SDCP_VIRT_BINARY']
-
-        cls.ctx = FPrint.Context()
-
-        cls.dev = None
-        for dev in cls.ctx.get_devices():
-            cls.dev = dev
-            break
-
-        assert cls.dev is not None, "You need to compile with virtual_sdcp for testing"
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.dev
-        del cls.ctx
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-    def enroll(self, progress_cb=None):
-        # Enroll another print
-        template = FPrint.Print.new(self.dev)
-        template.props.finger = FPrint.Finger.LEFT_THUMB
-        template.props.username = "testuser"
-        template.props.description = "test print"
-        datetime = GLib.DateTime.new_now_local()
-        date = GLib.Date()
-        date.set_dmy(*datetime.get_ymd()[::-1])
-        template.props.enroll_date = date
-        return self.dev.enroll_sync(template, None, progress_cb, None)
-
-    def test_connect(self):
-        self.dev.open_sync()
-        self.dev.close_sync()
-
-    def test_reconnect(self):
-        # Ensure device was opened once before, this may be a reconnect if
-        # it is the same process as another test.
-        self.dev.open_sync()
-        self.dev.close_sync()
-
-        # Check that a reconnect happens on next open. To know about this, we
-        # need to parse check log messages for that.
-        success = [False]
-        def log_func(domain, level, msg):
-            print("log: '%s', '%s', '%s'" % (str(domain), str(level), msg))
-            if msg == 'Reconnect succeeded':
-                success[0] = True
-
-            # Call default handler
-            GLib.log_default_handler(domain, level, msg)
-
-        handler_id = GLib.log_set_handler('libfprint-sdcp_device', GLib.LogLevelFlags.LEVEL_DEBUG, log_func)
-        self.dev.open_sync()
-        self.dev.close_sync()
-        GLib.log_remove_handler('libfprint-sdcp_device', handler_id)
-        assert success[0]
-
-    def test_enroll(self):
-        self.dev.open_sync()
-
-        # Must return a print
-        assert isinstance(self.enroll(), FPrint.Print)
-
-        self.dev.close_sync()
-
-
-    def test_verify(self):
-        self.dev.open_sync()
-
-        # Enroll a new print (will be the last), check that it verifies
-        p = self.enroll()
-        match, dev_print = self.dev.verify_sync(p)
-        assert match
-
-        # The returned "device" print is identical
-        assert p.equal(dev_print)
-
-        # We can do the same with it
-        match, dev_print2 = self.dev.verify_sync(dev_print)
-        assert match
-
-        # Now, enroll a new print, causing the old one to not match anymore
-        # (the device always claims to see the last enrolled print).
-        self.enroll()
-        match, dev_print = self.dev.verify_sync(p)
-        assert match is False
-
-        self.dev.close_sync()
-
-if __name__ == '__main__':
-    try:
-        gi.require_version('FPrint', '2.0')
-        from gi.repository import FPrint
-    except Exception as e:
-        print("Missing dependencies: %s" % str(e))
-        sys.exit(77)
-
-    # avoid writing to stderr
-    unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout, verbosity=2))