genesys: Route sleep calls through low level scanner interface

backend/genesys/genesys.cpp

@@ -1532,11 +1532,11 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
 
     if (is_dark) {
         // wait some time to let lamp to get dark
-        sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
     } else if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION) {
         // make sure lamp is bright again
         // FIXME: what about scanners that take a long time to warm the lamp?
-        sanei_genesys_sleep_ms(500);
+        dev->interface->sleep_ms(500);
     }
 
     bool start_motor = !is_dark;
@@ -2986,7 +2986,7 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
 
         dev->cmd_set->end_scan(dev, &dev->reg, true);
 
-      sanei_genesys_sleep_ms(1000);
+        dev->interface->sleep_ms(1000);
       seconds++;
 
         dev->cmd_set->begin_scan(dev, sensor, &dev->reg, false);
@@ -3043,10 +3043,9 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
 	}
 
       /* sleep another second before next loop */
-      sanei_genesys_sleep_ms(1000);
+        dev->interface->sleep_ms(1000);
-      seconds++;
+        seconds++;
-    }
+    } while (seconds < WARMUP_TIME);
-  while (seconds < WARMUP_TIME);
 
   if (seconds >= WARMUP_TIME)
     {
@@ -3188,8 +3187,8 @@ static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
            + dev->reg.get8(0x3f);
   do
     {
-      // wait some time between each test to avoid overloading USB and CPU
+        // wait some time between each test to avoid overloading USB and CPU
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
         sanei_genesys_read_feed_steps (dev, &steps);
     }
   while (steps < expected);
@@ -3199,11 +3198,10 @@ static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
     // we wait for at least one word of valid scan data
     // this is also done in sanei_genesys_read_data_from_scanner -- pierre
     if (!dev->model->is_sheetfed) {
-      do
+        do {
-	{
+            dev->interface->sleep_ms(100);
-          sanei_genesys_sleep_ms(100);
             sanei_genesys_read_valid_words(dev, &steps);
-	}
+        }
       while (steps < 1);
     }
 }

backend/genesys/gl124.cpp

@@ -1062,7 +1062,7 @@ static void gl124_stop_action(Genesys_Device* dev)
     dev->reg.set8(REG_0x01, val);
     dev->interface->write_register(REG_0x01, val);
 
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
   loop = 10;
   while (loop > 0)
@@ -1079,7 +1079,7 @@ static void gl124_stop_action(Genesys_Device* dev)
       return;
 	}
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       loop--;
     }
 
@@ -1199,7 +1199,7 @@ void CommandSetGl124::rewind(Genesys_Device* dev) const
     begin_scan(dev, sensor, &dev->reg, true);
   do
     {
-        sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
         byte = dev->interface->read_register(REG_0x100);
     } while (byte & REG_0x100_MOTMFLG);
     end_scan(dev, &dev->reg, true);
@@ -1235,7 +1235,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
     {
       sanei_genesys_print_status (val);
     }
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
     // second is reliable
     val = sanei_genesys_get_status(dev);
@@ -1321,7 +1321,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
               dev->scanhead_position_in_steps = 0;
             return;
 	    }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
 	  ++loop;
 	}
 
@@ -1605,11 +1605,11 @@ void CommandSetGl124::wait_for_motor_stop(Genesys_Device* dev) const
         return;
 
     do {
-        sanei_genesys_sleep_ms(10);
+        dev->interface->sleep_ms(10);
         val = sanei_genesys_get_status(dev);
         val40 = dev->interface->read_register(REG_0x100);
     } while ((val & MOTORENB) ||(val40 & REG_0x100_MOTMFLG));
-    sanei_genesys_sleep_ms(50);
+    dev->interface->sleep_ms(50);
 }
 
 /** @brief set up registers for the actual scan

backend/genesys/gl646.cpp

@@ -887,7 +887,7 @@ static void gl646_wm_hp3670(Genesys_Device* dev, const Genesys_Sensor& sensor, u
     {
     case AFE_INIT:
         dev->interface->write_fe_register(0x04, 0x80);
-      sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
     dev->interface->write_register(0x50, 0x00);
       dev->frontend = dev->frontend_initial;
         dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
@@ -1156,9 +1156,9 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
 	    {
               DBG(DBG_warn, "%s: no paper detected\n", __func__);
 	    }
-          sanei_genesys_sleep_ms(200);
+            dev->interface->sleep_ms(200);
-	  count++;
+            count++;
-	}
+        }
       while (((val & 0x04) != 0x04) && (count < 300));	/* 1 min time out */
       if (count == 300)
 	{
@@ -1210,7 +1210,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
   do
     {
         val = sanei_genesys_get_status(dev);
-      sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
       count++;
     } while ((val & REG_0x41_MOTMFLG) && (count < 300));
 
@@ -1332,7 +1332,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
   /* wait for motor to stop */
   do
     {
-      sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
         state = sanei_genesys_get_status(dev);
     }
     while (state & REG_0x41_MOTMFLG);
@@ -1384,7 +1384,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
         state = sanei_genesys_get_status(dev);
 
       print_status (state);
-      sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
       count++;
     } while (((state & REG_0x41_HOMESNR) == 0) && (count < 150));
 
@@ -1469,9 +1469,9 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool c
 		  break;	/* leave for loop */
 		}
 
-              sanei_genesys_sleep_ms(100);
+                dev->interface->sleep_ms(100);
-	    }
+            }
-	}
+        }
     }
   else				/* flat bed scanners */
     {
@@ -1500,9 +1500,9 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool c
 		  break;	/* leave while loop */
 		}
 
-              sanei_genesys_sleep_ms(100);
+                dev->interface->sleep_ms(100);
-	    }
+            }
-	}
+        }
     }
 
   DBG(DBG_proc, "%s: end (i=%u)\n", __func__, i);
@@ -1545,7 +1545,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
   /* stop motor if needed */
     if (val & REG_0x41_MOTMFLG) {
         gl646_stop_motor(dev);
-      sanei_genesys_sleep_ms(200);
+        dev->interface->sleep_ms(200);
     }
 
   /* when scanhead is moving then wait until scanhead stops or timeout */
@@ -1561,7 +1561,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
             DBG(DBG_info, "%s: already at home and not moving\n", __func__);
             return;
         }
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
     }
 
   if (!i)			/* the loop counted down to 0, scanner still is busy */
@@ -1625,12 +1625,12 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
 	    {
 	      DBG(DBG_info, "%s: reached home position\n", __func__);
 	      DBG(DBG_proc, "%s: end\n", __func__);
-              sanei_genesys_sleep_ms(500);
+                dev->interface->sleep_ms(500);
-            return;
+                return;
-	    }
+            }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
-          ++loop;
+            ++loop;
-	}
+        }
 
         // when we come here then the scanner needed too much time for this, so we better
         // stop the motor
@@ -2750,7 +2750,7 @@ static void gl646_repark_head(Genesys_Device* dev)
     expected = dev->reg.get24(REG_FEEDL);
   do
     {
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
         sanei_genesys_read_feed_steps (dev, &steps);
     }
   while (steps < expected);
@@ -2817,7 +2817,7 @@ void CommandSetGl646::init(Genesys_Device* dev) const
 
         // ASIC reset
         dev->interface->write_register(0x0e, 0x00);
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
 
         // Write initial registers
         dev->interface->write_registers(dev->reg);

backend/genesys/gl841.cpp

@@ -1702,7 +1702,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
             uint8_t val = dev->interface->read_register(REG_0x6D);
             dev->interface->write_register(REG_0x6D, val | 0x80);
 
-            sanei_genesys_sleep_ms(1);
+            dev->interface->sleep_ms(1);
 
 	    /*enable GPIO9*/
             val = dev->interface->read_register(REG_0x6C);
@@ -1716,7 +1716,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
             val = dev->interface->read_register(REG_0x6B);
             dev->interface->write_register(REG_0x6B, val & ~REG_0x6B_GPO18);
 
-            sanei_genesys_sleep_ms(1);
+            dev->interface->sleep_ms(1);
 
             val = dev->interface->read_register(REG_0x6D);
             dev->interface->write_register(REG_0x6D, val & ~0x80);
@@ -1745,7 +1745,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
             uint8_t val = dev->interface->read_register(REG_0x6D);
             dev->interface->write_register(REG_0x6D, val | 0x80);
 
-            sanei_genesys_sleep_ms(10);
+            dev->interface->sleep_ms(10);
 
 	    /*disable GPIO9*/
             val = dev->interface->read_register(REG_0x6C);
@@ -1894,8 +1894,8 @@ static void gl841_stop_action(Genesys_Device* dev)
       return;
 	}
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
-      loop--;
+        loop--;
     }
 
     throw SaneException(SANE_STATUS_IO_ERROR, "could not stop motor");
@@ -1968,7 +1968,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
 	      DBG(DBG_proc, "%s: finished\n", __func__);
 	      break;
 	    }
-          sanei_genesys_sleep_ms(100);
+          dev->interface->sleep_ms(100);
 	  --loop;
 	}
 
@@ -2005,7 +2005,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
 	  break;
 	}
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       ++loop;
     }
 
@@ -2028,10 +2028,10 @@ void CommandSetGl841::load_document(Genesys_Device* dev) const
         dev->document = true;
 
           // give user some time to place document correctly
-          sanei_genesys_sleep_ms(1000);
+          dev->interface->sleep_ms(1000);
 	  break;
 	}
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       --loop;
     }
 
@@ -2195,7 +2195,7 @@ static void gl841_feed(Genesys_Device* dev, int steps)
 	  dev->scanhead_position_in_steps += steps;
             return;
       }
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       ++loop;
   }
 
@@ -2240,7 +2240,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
     {
       sanei_genesys_print_status (val);
     }
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
     // second is reliable
     val = sanei_genesys_get_status(dev);
@@ -2307,7 +2307,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
 	      DBG(DBG_proc, "%s: finished\n", __func__);
           return;
 	    }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
 	  ++loop;
 	}
 

backend/genesys/gl843.cpp

@@ -1331,7 +1331,7 @@ static void gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set*
     val &= ~REG_0x01_SCAN;
     reg->set8(REG_0x01, val);
     dev->interface->write_register(REG_0x01, val);
-    sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 }
 
 static void gl843_stop_action(Genesys_Device* dev)
@@ -1361,7 +1361,7 @@ static void gl843_stop_action(Genesys_Device* dev)
     dev->reg.set8(REG_0x01, val);
     dev->interface->write_register(REG_0x01, val);
 
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
   loop = 10;
   while (loop > 0)
@@ -1380,7 +1380,7 @@ static void gl843_stop_action(Genesys_Device* dev)
       return;
 	}
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       loop--;
     }
 
@@ -1803,7 +1803,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
 
             return;
 	    }
-          sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
 	  ++loop;
 	}
 
@@ -1831,7 +1831,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
     // first read gives HOME_SENSOR true
     val = sanei_genesys_get_status(dev);
 
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
     // second is reliable
     val = sanei_genesys_get_status(dev);
@@ -1911,7 +1911,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
 	      DBG(DBG_proc, "%s: finished\n", __func__);
           return;
 	    }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
 	  ++loop;
 	}
 
@@ -2103,7 +2103,7 @@ static void gl843_feed(Genesys_Device* dev, unsigned int steps)
     } while (!(val & FEEDFSH));
 
   // looks like the scanner locks up if we scan immediately after feeding
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 }
 
 // init registers for shading calibration shading calibration is done at dpihw
@@ -3024,7 +3024,7 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
     gl843_init_gpio(dev);
 
   gl843_feed (dev, 300);
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 }
 
 /* *

backend/genesys/gl846.cpp

@@ -308,9 +308,8 @@ static void gl846_set_adi_fe(Genesys_Device* dev, uint8_t set)
 
     // wait for FE to be ready
     std::uint8_t val8 = sanei_genesys_get_status(dev);
-    while (val8 & REG_0x41_FEBUSY)
+    while (val8 & REG_0x41_FEBUSY) {
-    {
+        dev->interface->sleep_ms(10);
-      sanei_genesys_sleep_ms(10);
         val8 = sanei_genesys_get_status(dev);
     };
 
@@ -898,7 +897,7 @@ static void gl846_stop_action(Genesys_Device* dev)
     val &= ~REG_0x01_SCAN;
     dev->reg.set8(REG_0x01, val);
     dev->interface->write_register(REG_0x01, val);
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
   loop = 10;
   while (loop > 0)
@@ -917,7 +916,7 @@ static void gl846_stop_action(Genesys_Device* dev)
           return;
         }
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       loop--;
     }
 
@@ -990,7 +989,7 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
     {
       sanei_genesys_print_status (val);
     }
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
     // second is reliable
     val = sanei_genesys_get_status(dev);
@@ -1078,7 +1077,7 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
               dev->scanhead_position_in_steps = 0;
               return;
             }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
           ++loop;
         }
 

backend/genesys/gl847.cpp

@@ -331,7 +331,7 @@ static void gl847_set_ad_fe(Genesys_Device* dev, uint8_t set)
     // wait for FE to be ready
     std::uint8_t val8 = sanei_genesys_get_status(dev);
     while (val8 & REG_0x41_FEBUSY) {
-      sanei_genesys_sleep_ms(10);
+        dev->interface->sleep_ms(10);
         val8 = sanei_genesys_get_status(dev);
     };
 
@@ -904,7 +904,7 @@ static void gl847_stop_action(Genesys_Device* dev)
     dev->reg.set8(REG_0x01, val);
     dev->interface->write_register(REG_0x01, val);
 
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
   loop = 10;
   while (loop > 0)
@@ -923,7 +923,7 @@ static void gl847_stop_action(Genesys_Device* dev)
       return;
 	}
 
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
       loop--;
     }
 
@@ -997,7 +997,7 @@ static void gl847_rewind(Genesys_Device* dev)
     gl847_begin_scan(dev, dev->reg, true);
   do
     {
-      sanei_genesys_sleep_ms(100);
+        dev->interface->sleep_ms(100);
         byte = dev->interface->read_register(REG_0x40);
     } while (byte & REG_0x40_MOTMFLG);
 
@@ -1035,7 +1035,7 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
     {
       sanei_genesys_print_status (val);
     }
-  sanei_genesys_sleep_ms(100);
+    dev->interface->sleep_ms(100);
 
     // second is reliable
     val = sanei_genesys_get_status(dev);
@@ -1121,7 +1121,7 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
               dev->scanhead_position_in_steps = 0;
             return;
 	    }
-          sanei_genesys_sleep_ms(100);
+            dev->interface->sleep_ms(100);
 	  ++loop;
 	}
 

backend/genesys/low.cpp

@@ -394,14 +394,14 @@ bool sanei_genesys_is_buffer_empty(Genesys_Device* dev)
     DBG_HELPER(dbg);
   uint8_t val = 0;
 
-  sanei_genesys_sleep_ms(1);
+    dev->interface->sleep_ms(1);
     val = sanei_genesys_get_status(dev);
 
     if (dev->cmd_set->test_buffer_empty_bit(val)) {
       /* fix timing issue on USB3 (or just may be too fast) hardware
        * spotted by John S. Weber <jweber53@gmail.com>
        */
-      sanei_genesys_sleep_ms(1);
+        dev->interface->sleep_ms(1);
       DBG(DBG_io2, "%s: buffer is empty\n", __func__);
         return true;
     }
@@ -423,7 +423,7 @@ void wait_until_buffer_non_empty(Genesys_Device* dev, bool check_status_twice)
         }
 
         bool empty = sanei_genesys_is_buffer_empty(dev);
-        sanei_genesys_sleep_ms(10);
+        dev->interface->sleep_ms(10);
         if (!empty)
             return;
     }
@@ -439,7 +439,7 @@ void wait_until_has_valid_words(Genesys_Device* dev)
         sanei_genesys_read_valid_words(dev, &words);
         if (words != 0)
             break;
-        sanei_genesys_sleep_ms(sleep_time_ms);
+        dev->interface->sleep_ms(sleep_time_ms);
     }
 
     if (words == 0) {
@@ -1589,7 +1589,7 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
     // read initial status, if head isn't at home and motor is on we are parking, so we wait.
     // gl847/gl124 need 2 reads for reliable results
     val = sanei_genesys_get_status(dev);
-  sanei_genesys_sleep_ms(10);
+    dev->interface->sleep_ms(10);
     val = sanei_genesys_get_status(dev);
 
   /* if at home, return */
@@ -1604,7 +1604,7 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
     unsigned elapsed_ms = 0;
   do
     {
-      sanei_genesys_sleep_ms(100);
+      dev->interface->sleep_ms(100);
         elapsed_ms += 100;
 
         val = sanei_genesys_get_status(dev);
@@ -1995,19 +1995,6 @@ void sanei_genesys_load_lut(unsigned char* lut,
     }
 }
 
-void sanei_genesys_usleep(unsigned int useconds)
-{
-    if (sanei_usb_is_replay_mode_enabled()) {
-        return;
-    }
-  usleep(useconds);
-}
-
-void sanei_genesys_sleep_ms(unsigned int milliseconds)
-{
-  sanei_genesys_usleep(milliseconds * 1000);
-}
-
 static std::unique_ptr<std::vector<std::function<void()>>> s_functions_run_at_backend_exit;
 
 void add_function_to_run_at_backend_exit(std::function<void()> function)

backend/genesys/low.h

@@ -528,12 +528,6 @@ inline T clamp(const T& value, const T& lo, const T& hi)
 /*                ASIC specific functions declarations                       */
 /*---------------------------------------------------------------------------*/
 
-// same as usleep, except that it does nothing if testing mode is enabled
-extern void sanei_genesys_usleep(unsigned int useconds);
-
-// same as sanei_genesys_usleep just that the duration is in milliseconds
-extern void sanei_genesys_sleep_ms(unsigned int milliseconds);
-
 void add_function_to_run_at_backend_exit(std::function<void()> function);
 
 // calls functions added via add_function_to_run_at_backend_exit() in reverse order of being

backend/genesys/scanner_interface.h

@@ -88,6 +88,14 @@ public:
 
     virtual IUsbDevice& get_usb_device() = 0;
 
+    // sleeps the specified number of microseconds. Will not sleep if testing mode is enabled.
+    virtual void sleep_us(unsigned microseconds) = 0;
+
+    void sleep_ms(unsigned milliseconds)
+    {
+        sleep_us(milliseconds * 1000);
+    }
+
     virtual void record_test_message(const char* msg) = 0;
 };
 

backend/genesys/scanner_interface_usb.cpp

@@ -45,6 +45,7 @@
 
 #include "scanner_interface_usb.h"
 #include "low.h"
+#include <thread>
 
 namespace genesys {
 
@@ -480,6 +481,14 @@ IUsbDevice& ScannerInterfaceUsb::get_usb_device()
     return usb_dev_;
 }
 
+void ScannerInterfaceUsb::sleep_us(unsigned microseconds)
+{
+    if (sanei_usb_is_replay_mode_enabled()) {
+        return;
+    }
+    std::this_thread::sleep_for(std::chrono::microseconds{microseconds});
+}
+
 void ScannerInterfaceUsb::record_test_message(const char* msg)
 {
     sanei_usb_testing_record_message(msg);

backend/genesys/scanner_interface_usb.h

@@ -76,9 +76,12 @@ public:
     std::uint16_t read_fe_register(std::uint8_t address) override;
     void write_fe_register(std::uint8_t address, std::uint16_t value) override;
 
+    IUsbDevice& get_usb_device() override;
+
+    void sleep_us(unsigned microseconds) override;
+
     void record_test_message(const char* msg) override;
 
-    virtual IUsbDevice& get_usb_device() override;
 private:
     Genesys_Device* dev_;
     UsbDevice usb_dev_;

backend/genesys/test_scanner_interface.cpp

@@ -132,6 +132,11 @@ IUsbDevice& TestScannerInterface::get_usb_device()
     return usb_dev_;
 }
 
+void TestScannerInterface::sleep_us(unsigned microseconds)
+{
+    (void) microseconds;
+}
+
 void TestScannerInterface::record_test_message(const char* msg)
 {
     last_test_message_ = msg;

backend/genesys/test_scanner_interface.h

@@ -76,6 +76,8 @@ public:
 
     IUsbDevice& get_usb_device() override;
 
+    void sleep_us(unsigned microseconds) override;
+
     void record_test_message(const char* msg) override;
 
     const std::string& last_test_message() const;