genesys: Return errors as exceptions from *read_register()

backend/genesys_gl124.cc

@@ -152,13 +152,14 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int half_ccd
 static SANE_Status
 gl124_homsnr_gpio(Genesys_Device *dev)
 {
+    DBG_HELPER(dbg);
 uint8_t val;
 SANE_Status status=SANE_STATUS_GOOD;
 
-  RIE (sanei_genesys_read_register (dev, REG32, &val));
+    sanei_genesys_read_register(dev, REG32, &val);
   val &= ~REG32_GPIO10;
   RIE (sanei_genesys_write_register (dev, REG32, val));
-  return status;
+    return SANE_STATUS_GOOD;
 }
 
 /**@brief compute half ccd mode
@@ -627,8 +628,9 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
 
 /* Set values of analog frontend */
 static SANE_Status
-gl124_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
+gl124_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint8_t set)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
@@ -642,7 +644,7 @@ gl124_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
       dev->frontend = dev->frontend_initial;
     }
 
-  RIE (sanei_genesys_read_register (dev, REG0A, &val));
+    sanei_genesys_read_register(dev, REG0A, &val);
 
   /* route to correct analog FE */
   switch ((val & REG0A_SIFSEL)>>REG0AS_SIFSEL)
@@ -659,7 +661,6 @@ gl124_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
       break;
     }
 
-  DBGCOMPLETED;
   return status;
 }
 
@@ -1644,12 +1645,11 @@ gl124_start_action (Genesys_Device * dev)
 static SANE_Status
 gl124_stop_action (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val40, val;
   unsigned int loop;
 
-  DBGSTART;
-
   /* post scan gpio : without that HOMSNR is unreliable */
   gl124_homsnr_gpio(dev);
 
@@ -1659,19 +1659,12 @@ gl124_stop_action (Genesys_Device * dev)
       sanei_genesys_print_status (val);
     }
 
-  status = sanei_genesys_read_register (dev, REG100, &val40);
+    sanei_genesys_read_register(dev, REG100, &val40);
-  if (status != SANE_STATUS_GOOD)
-    {
-      DBG(DBG_error, "%s: failed to read reg100: %s\n", __func__, sane_strstatus(status));
-      DBGCOMPLETED;
-      return status;
-    }
 
   /* only stop action if needed */
   if (!(val40 & REG100_DATAENB) && !(val40 & REG100_MOTMFLG))
     {
       DBG (DBG_info, "%s: already stopped\n", __func__);
-      DBGCOMPLETED;
       return SANE_STATUS_GOOD;
     }
 
@@ -1697,21 +1690,12 @@ gl124_stop_action (Genesys_Device * dev)
 	{
 	  sanei_genesys_print_status (val);
 	}
-      status = sanei_genesys_read_register (dev, REG100, &val40);
+    sanei_genesys_read_register(dev, REG100, &val40);
-      if (status != SANE_STATUS_GOOD)
-	{
-	  DBG (DBG_error,
-	       "%s: failed to read home sensor: %s\n", __func__,
-	       sane_strstatus (status));
-	  DBGCOMPLETED;
-	  return status;
-	}
 
       /* if scanner is in command mode, we are done */
       if (!(val40 & REG100_DATAENB) && !(val40 & REG100_MOTMFLG)
 	  && !(val & MOTORENB))
 	{
-	  DBGCOMPLETED;
 	  return SANE_STATUS_GOOD;
 	}
 
@@ -1719,7 +1703,6 @@ gl124_stop_action (Genesys_Device * dev)
       loop--;
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_IO_ERROR;
 }
 
@@ -1736,9 +1719,9 @@ gl124_setup_scan_gpio(Genesys_Device *dev, int resolution)
 {
 SANE_Status status = SANE_STATUS_GOOD;
 uint8_t val;
+    DBG_HELPER(dbg);
 
-  DBGSTART;
+    sanei_genesys_read_register(dev, REG32, &val);
-  RIE (sanei_genesys_read_register (dev, REG32, &val));
 
   /* LiDE 110, 210 and 220 cases */
   if(dev->model->gpo_type != GPO_CANONLIDE120)
@@ -1779,7 +1762,6 @@ uint8_t val;
     }
   val |= 0x02;
   RIE (sanei_genesys_write_register (dev, REG32, val));
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -1789,12 +1771,12 @@ static SANE_Status
 gl124_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
 		  SANE_Bool start_motor)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
 
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
-  DBGSTART;
   if (reg == NULL)
     return SANE_STATUS_INVAL;
 
@@ -1804,8 +1786,8 @@ gl124_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
   /* clear scan and feed count */
   RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
 
-  /* enable scan and motor */
+    // enable scan and motor
-  RIE (sanei_genesys_read_register (dev, REG01, &val));
+    sanei_genesys_read_register(dev, REG01, &val);
   val |= REG01_SCAN;
   RIE (sanei_genesys_write_register (dev, REG01, val));
 
@@ -1818,8 +1800,7 @@ gl124_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
       RIE (sanei_genesys_write_register (dev, REG0F, 0));
     }
 
-  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
-  return status;
 }
 
 
@@ -1863,11 +1844,10 @@ SANE_Status gl124_rewind(Genesys_Device * dev)
 {
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t byte;
+    DBG_HELPER(dbg);
 
-  DBGSTART;
+    // set motor reverse
-
+    sanei_genesys_read_register(dev, 0x02, &byte);
-  /* set motor reverse */
-  RIE (sanei_genesys_read_register (dev, 0x02, &byte));
   byte |= 0x04;
   RIE (sanei_genesys_write_register(dev, 0x02, byte));
 
@@ -1878,16 +1858,15 @@ SANE_Status gl124_rewind(Genesys_Device * dev)
   do
     {
         sanei_genesys_sleep_ms(100);
-      RIE (sanei_genesys_read_register (dev, REG100, &byte));
+        sanei_genesys_read_register(dev, REG100, &byte);
     }
   while(byte & REG100_MOTMFLG);
   RIE (gl124_end_scan (dev, &dev->reg, SANE_TRUE));
 
-  /* restore direction */
+    // restore direction
-  RIE (sanei_genesys_read_register (dev, 0x02, &byte));
+    sanei_genesys_read_register(dev, 0x02, &byte);
   byte &= 0xfb;
   RIE (sanei_genesys_write_register(dev, 0x02, byte));
-  DBGCOMPLETED;
     return SANE_STATUS_GOOD;
 }
 
@@ -2421,7 +2400,7 @@ static void gl124_wait_for_motor_stop(Genesys_Device* dev)
     uint8_t val40, val;
 
     TIE(sanei_genesys_get_status(dev, &val));
-    TIE(sanei_genesys_read_register(dev, REG100, &val40));
+    sanei_genesys_read_register(dev, REG100, &val40);
 
     if ((val & MOTORENB) == 0 && (val40 & REG100_MOTMFLG) == 0)
         return;
@@ -2429,7 +2408,7 @@ static void gl124_wait_for_motor_stop(Genesys_Device* dev)
     do {
         sanei_genesys_sleep_ms(10);
         TIE(sanei_genesys_get_status(dev, &val));
-        TIE(sanei_genesys_read_register(dev, REG100, &val40));
+        sanei_genesys_read_register(dev, REG100, &val40);
     } while ((val & MOTORENB) ||(val40 & REG100_MOTMFLG));
     sanei_genesys_sleep_ms(50);
 }
@@ -2530,13 +2509,13 @@ static SANE_Status
 gl124_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
                          uint8_t * data, int size)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint32_t addr, length, strpixel ,endpixel, x, factor, segcnt, pixels, i;
   uint32_t lines, channels;
   uint16_t dpiset,dpihw;
   uint8_t val,*ptr,*src;
 
-  DBGSTART;
   DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__func__,size);
 
   /* logical size of a color as seen by generic code of the frontend */
@@ -2632,7 +2611,7 @@ gl124_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
           /* next shading coefficient */
           ptr+=4;
         }
-      RIE (sanei_genesys_read_register (dev, 0xd0+i, &val));
+        sanei_genesys_read_register(dev, 0xd0+i, &val);
       addr = val * 8192 + 0x10000000;
       status = sanei_genesys_write_ahb(dev, addr, pixels*dev->segnb, buffer.data());
       if (status != SANE_STATUS_GOOD)
@@ -2642,8 +2621,6 @@ gl124_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
         }
     }
 
-  DBGCOMPLETED;
-
   return status;
 }
 
@@ -2920,6 +2897,7 @@ static SANE_Status
 gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                          Genesys_Register_Set& regs)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t reg0a;
   unsigned int channels, bpp;
@@ -2927,13 +2905,10 @@ gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
   int topavg, bottomavg, resolution, lines;
   int top, bottom, black_pixels, pixels;
 
-  DBGSTART;
+    // no gain nor offset for TI AFE
-
+    sanei_genesys_read_register(dev, REG0A, &reg0a);
-  /* no gain nor offset for TI AFE */
-  RIE (sanei_genesys_read_register (dev, REG0A, &reg0a));
   if(((reg0a & REG0A_SIFSEL)>>REG0AS_SIFSEL)==3)
     {
-      DBGCOMPLETED;
       return status;
     }
 
@@ -3063,7 +3038,6 @@ gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
       dev->frontend.get_offset(1),
       dev->frontend.get_offset(2));
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -3081,6 +3055,7 @@ static SANE_Status
 gl124_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                               Genesys_Register_Set& regs, int dpi)
 {
+    DBG_HELPER(dbg);
   int pixels;
   int total_size;
   uint8_t reg0a;
@@ -3094,8 +3069,8 @@ gl124_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   DBG(DBG_proc, "%s: dpi = %d\n", __func__, dpi);
 
-  /* no gain nor offset for TI AFE */
+    // no gain nor offset for TI AFE
-  RIE (sanei_genesys_read_register (dev, REG0A, &reg0a));
+    sanei_genesys_read_register(dev, REG0A, &reg0a);
   if(((reg0a & REG0A_SIFSEL)>>REG0AS_SIFSEL)==3)
     {
       DBGCOMPLETED;
@@ -3232,7 +3207,6 @@ gl124_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   status = gl124_slow_back_home (dev, SANE_TRUE);
 
-  DBGCOMPLETED;
   return status;
 }
 
@@ -3432,8 +3406,6 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
-  DBGSTART;
-
   /* reset ASIC in case of cold boot */
   if(cold)
     {
@@ -3444,16 +3416,15 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
   /* enable GPOE 17 */
   RIE (sanei_genesys_write_register (dev, 0x36, 0x01));
 
-  /* set GPIO 17 */
+    // set GPIO 17
-  RIE (sanei_genesys_read_register (dev, 0x33, &val));
+    sanei_genesys_read_register(dev, 0x33, &val);
   val |= 0x01;
   RIE (sanei_genesys_write_register (dev, 0x33, val));
 
-  /* test CHKVER */
+    // test CHKVER
-  RIE (sanei_genesys_read_register (dev, REG100, &val));
+    sanei_genesys_read_register(dev, REG100, &val);
-  if (val & REG100_CHKVER)
+    if (val & REG100_CHKVER) {
-    {
+        sanei_genesys_read_register(dev, 0x00, &val);
-      RIE (sanei_genesys_read_register (dev, 0x00, &val));
         DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
     }
 
@@ -3482,7 +3453,6 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
   /* setup internal memory layout */
   RIE (gl124_init_memory_layout (dev));
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -3493,10 +3463,10 @@ gl124_update_hardware_sensors (Genesys_Scanner * s)
   /* do what is needed to get a new set of events, but try to not loose
      any of them.
    */
-  SANE_Status status = SANE_STATUS_GOOD;
+    DBG_HELPER(dbg);
-  uint8_t val=0;
+    uint8_t val = 0;
 
-  RIE (sanei_genesys_read_register (s->dev, REG31, &val));
+    sanei_genesys_read_register(s->dev, REG31, &val);
 
   /* TODO : for the next scanner special case,
    * add another per scanner button profile struct to avoid growing
@@ -3518,7 +3488,7 @@ gl124_update_hardware_sensors (Genesys_Scanner * s)
         s->buttons[BUTTON_EMAIL_SW].write((val & 0x08) == 0);
         s->buttons[BUTTON_FILE_SW].write((val & 0x10) == 0);
     }
-  return status;
+  return SANE_STATUS_GOOD;
 }
 
 

backend/genesys_gl646.cc

@@ -1055,24 +1055,16 @@ gl646_asic_test (Genesys_Device * dev)
       return status;
     }
 
-  status = sanei_genesys_read_register (dev, 0x4e, &val);
+  sanei_genesys_read_register(dev, 0x4e, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read register: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
   if (val != 0xde)		/* value of register 0x38 */
     {
       DBG(DBG_error, "%s: register contains invalid value\n", __func__);
       return SANE_STATUS_IO_ERROR;
     }
 
-  status = sanei_genesys_read_register (dev, 0x4f, &val);
+    sanei_genesys_read_register(dev, 0x4f, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read register: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
   if (val != 0xad)		/* value of register 0x39 */
     {
       DBG(DBG_error, "%s: register contains invalid value\n", __func__);

backend/genesys_gl841.cc

@@ -332,24 +332,16 @@ sanei_gl841_asic_test (Genesys_Device * dev)
       return status;
     }
 
-  status = sanei_genesys_read_register (dev, 0x38, &val);
+    sanei_genesys_read_register(dev, 0x38, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read register: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
   if (val != 0xde)		/* value of register 0x38 */
     {
       DBG(DBG_error, "%s: register contains invalid value\n", __func__);
       return SANE_STATUS_IO_ERROR;
     }
 
-  status = sanei_genesys_read_register (dev, 0x39, &val);
+    sanei_genesys_read_register(dev, 0x39, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read register: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
   if (val != 0xad)		/* value of register 0x39 */
     {
       DBG(DBG_error, "%s: register contains invalid value\n", __func__);
@@ -2844,32 +2836,24 @@ gl841_start_action (Genesys_Device * dev)
 static SANE_Status
 gl841_stop_action (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   Genesys_Register_Set local_reg;
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val40, val;
   unsigned int loop;
 
-  DBG(DBG_proc, "%s\n", __func__);
-
   status = sanei_genesys_get_status (dev, &val);
   if (DBG_LEVEL >= DBG_io)
     {
       sanei_genesys_print_status (val);
     }
 
-  status = sanei_genesys_read_register(dev, 0x40, &val40);
+    sanei_genesys_read_register(dev, 0x40, &val40);
-  if (status != SANE_STATUS_GOOD)
-    {
-      DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-      DBGCOMPLETED;
-      return status;
-    }
 
   /* only stop action if needed */
   if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
     {
       DBG(DBG_info, "%s: already stopped\n", __func__);
-      DBGCOMPLETED;
       return SANE_STATUS_GOOD;
     }
 
@@ -2890,24 +2874,15 @@ gl841_stop_action (Genesys_Device * dev)
      register 0x0f) seems to be unnecessary */
 
   loop = 10;
-  while (loop > 0)
+    while (loop > 0) {
-    {
+        sanei_genesys_read_register(dev, 0x40, &val40);
-      status = sanei_genesys_read_register(dev, 0x40, &val40);
+        if (DBG_LEVEL >= DBG_io) {
-      if (DBG_LEVEL >= DBG_io)
+            sanei_genesys_print_status(val);
-	{
-	  sanei_genesys_print_status (val);
-        }
-      if (status != SANE_STATUS_GOOD)
-	{
-	  DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-	  DBGCOMPLETED;
-	  return status;
         }
 
       /* if scanner is in command mode, we are done */
       if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
 	{
-	  DBGCOMPLETED;
 	  return SANE_STATUS_GOOD;
 	}
 
@@ -2915,22 +2890,17 @@ gl841_stop_action (Genesys_Device * dev)
       loop--;
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_IO_ERROR;
 }
 
 static SANE_Status
 gl841_get_paper_sensor(Genesys_Device * dev, SANE_Bool * paper_loaded)
 {
-  SANE_Status status = SANE_STATUS_GOOD;
+    DBG_HELPER(dbg);
     uint8_t val;
 
-  status = sanei_genesys_read_register(dev, REG6D, &val);
+    sanei_genesys_read_register(dev, REG6D, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read gpio: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
     *paper_loaded = (val & 0x1) == 0;
     return SANE_STATUS_GOOD;
 }
@@ -3141,14 +3111,13 @@ gl841_load_document (Genesys_Device * dev)
 static SANE_Status
 gl841_detect_document_end (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   SANE_Bool paper_loaded;
   unsigned int scancnt = 0, lincnt, postcnt;
   uint8_t val;
   size_t total_bytes_to_read;
 
-  DBG(DBG_proc, "%s: begin\n", __func__);
-
   RIE (gl841_get_paper_sensor (dev, &paper_loaded));
 
   /* sheetfed scanner uses home sensor as paper present */
@@ -3182,14 +3151,14 @@ gl841_detect_document_end (Genesys_Device * dev)
         }
       DBG(DBG_io, "%s: scancnt=%u lines\n", __func__, scancnt);
 
-      RIE(sanei_genesys_read_register(dev, 0x25, &val));
+        sanei_genesys_read_register(dev, 0x25, &val);
-      lincnt=65536*val;
+        lincnt = 65536 * val;
-      RIE(sanei_genesys_read_register(dev, 0x26, &val));
+        sanei_genesys_read_register(dev, 0x26, &val);
-      lincnt+=256*val;
+        lincnt += 256 * val;
-      RIE(sanei_genesys_read_register(dev, 0x27, &val));
+        sanei_genesys_read_register(dev, 0x27, &val);
-      lincnt+=val;
+        lincnt += val;
         DBG(DBG_io, "%s: lincnt=%u lines\n", __func__, lincnt);
-      postcnt=(SANE_UNFIX(dev->model->post_scan)/MM_PER_INCH)*dev->settings.yres;
+        postcnt = (SANE_UNFIX(dev->model->post_scan)/MM_PER_INCH) * dev->settings.yres;
         DBG(DBG_io, "%s: postcnt=%u lines\n", __func__, postcnt);
 
       /* the current scancnt is also the final one, so we use it to
@@ -3208,7 +3177,6 @@ gl841_detect_document_end (Genesys_Device * dev)
         }
     }
 
-  DBG(DBG_proc, "%s: finished\n", __func__);
   return SANE_STATUS_GOOD;
 }
 
@@ -3218,19 +3186,17 @@ static SANE_Status
 gl841_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
 			SANE_Bool start_motor)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
   SANE_Status status = SANE_STATUS_GOOD;
   // FIXME: SEQUENTIAL not really needed in this case
   Genesys_Register_Set local_reg(Genesys_Register_Set::SEQUENTIAL);
   uint8_t val;
 
-  DBG(DBG_proc, "%s\n", __func__);
+    if (dev->model->gpo_type == GPO_CANONLIDE80) {
-
+        sanei_genesys_read_register(dev, REG6B, &val);
-  if (dev->model->gpo_type == GPO_CANONLIDE80)
-    {
-      RIE (sanei_genesys_read_register (dev, REG6B, &val));
         val = REG6B_GPO18;
-      RIE (sanei_genesys_write_register (dev, REG6B, val));
+        RIE(sanei_genesys_write_register(dev, REG6B, val));
     }
 
     if (dev->model->ccd_type != CCD_PLUSTEK_3600) {
@@ -3257,8 +3223,6 @@ gl841_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
       return status;
     }
 
-  DBG(DBG_proc, "%s: completed\n", __func__);
-
   return status;
 }
 
@@ -3379,6 +3343,7 @@ gl841_feed (Genesys_Device * dev, int steps)
 static SANE_Status
 gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
 {
+    DBG_HELPER(dbg);
   Genesys_Register_Set local_reg;
   SANE_Status status = SANE_STATUS_GOOD;
   GenesysRegister *r;
@@ -3394,18 +3359,16 @@ gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
       return SANE_STATUS_GOOD;
     }
 
-  /* reset gpio pin */
+    // reset gpio pin
-  if (dev->model->gpo_type == GPO_CANONLIDE35)
+    if (dev->model->gpo_type == GPO_CANONLIDE35) {
-    {
+        sanei_genesys_read_register(dev, REG6C, &val);
-      RIE (sanei_genesys_read_register (dev, REG6C, &val));
         val = dev->gpo.value[0];
-      RIE (sanei_genesys_write_register (dev, REG6C, val));
+        RIE(sanei_genesys_write_register(dev, REG6C, val));
     }
-  if (dev->model->gpo_type == GPO_CANONLIDE80)
+    if (dev->model->gpo_type == GPO_CANONLIDE80) {
-    {
+        sanei_genesys_read_register(dev, REG6B, &val);
-      RIE (sanei_genesys_read_register (dev, REG6B, &val));
         val = REG6B_GPO18 | REG6B_GPO17;
-      RIE (sanei_genesys_write_register (dev, REG6B, val));
+        RIE(sanei_genesys_write_register(dev, REG6B, val));
     }
   gl841_save_power(dev, SANE_FALSE);
 
@@ -3524,7 +3487,6 @@ gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
     }
 
   DBG(DBG_info, "%s: scanhead is still moving\n", __func__);
-  DBG(DBG_proc, "%s: finished\n", __func__);
   return SANE_STATUS_GOOD;
 }
 
@@ -5118,16 +5080,17 @@ gl841_init (Genesys_Device * dev)
 static SANE_Status
 gl841_update_hardware_sensors (Genesys_Scanner * s)
 {
+    DBG_HELPER(dbg);
+    SANE_Status status = SANE_STATUS_GOOD;
   /* do what is needed to get a new set of events, but try to not lose
      any of them.
    */
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
     if (s->dev->model->gpo_type == GPO_CANONLIDE35
         || s->dev->model->gpo_type == GPO_CANONLIDE80)
     {
-        RIE(sanei_genesys_read_register(s->dev, REG6D, &val));
+        sanei_genesys_read_register(s->dev, REG6D, &val);
         s->buttons[BUTTON_SCAN_SW].write((val & 0x01) == 0);
         s->buttons[BUTTON_FILE_SW].write((val & 0x02) == 0);
         s->buttons[BUTTON_EMAIL_SW].write((val & 0x04) == 0);
@@ -5138,7 +5101,7 @@ gl841_update_hardware_sensors (Genesys_Scanner * s)
         s->dev->model->gpo_type == GPO_DP665 ||
         s->dev->model->gpo_type == GPO_DP685)
     {
-        RIE(sanei_genesys_read_register(s->dev, REG6D, &val));
+        sanei_genesys_read_register(s->dev, REG6D, &val);
 
         s->buttons[BUTTON_PAGE_LOADED_SW].write((val & 0x01) == 0);
         s->buttons[BUTTON_SCAN_SW].write((val & 0x02) == 0);

backend/genesys_gl843.cc

@@ -815,6 +815,7 @@ gl843_send_slope_table (Genesys_Device * dev, int table_nr,
 static SANE_Status
 gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
@@ -829,9 +830,9 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
       dev->frontend = dev->frontend_initial;
     }
 
-  /* check analog frontend type */
+    // check analog frontend type
     // FIXME: looks like we write to that register with initial data
-  RIE (sanei_genesys_read_register (dev, REG04, &val));
+    sanei_genesys_read_register(dev, REG04, &val);
   if ((val & REG04_FESET) != 0x00)
     {
       /* for now there is no support for AD fe */
@@ -916,7 +917,6 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
 	}
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -1811,17 +1811,18 @@ gl843_calculate_current_setup(Genesys_Device * dev, const Genesys_Sensor& sensor
 static SANE_Status
 gl843_save_power (Genesys_Device * dev, SANE_Bool enable)
 {
+    DBG_HELPER(dbg);
   uint8_t val;
   SANE_Status status = SANE_STATUS_GOOD;
 
   DBG(DBG_proc, "%s: enable = %d\n", __func__, enable);
-  if (dev == NULL)
+    if (dev == NULL) {
         return SANE_STATUS_INVAL;
+    }
 
-  /* switch KV-SS080 lamp off */
+    // switch KV-SS080 lamp off
-  if (dev->model->gpo_type == GPO_KVSS080)
+    if (dev->model->gpo_type == GPO_KVSS080) {
-    {
+        sanei_genesys_read_register(dev, REG6C, &val);
-      RIE(sanei_genesys_read_register (dev, REG6C, &val));
       if(enable)
         val &= 0xef;
       else
@@ -1829,7 +1830,6 @@ gl843_save_power (Genesys_Device * dev, SANE_Bool enable)
       RIE(sanei_genesys_write_register(dev,REG6C,val));
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -1866,12 +1866,11 @@ gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set* reg)
 static SANE_Status
 gl843_stop_action (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val40, val;
   unsigned int loop;
 
-  DBG(DBG_proc, "%s\n", __func__);
-
   status = sanei_genesys_get_status (dev, &val);
   if (DBG_LEVEL >= DBG_io)
     {
@@ -1879,19 +1878,12 @@ gl843_stop_action (Genesys_Device * dev)
     }
 
     val40 = 0;
-  status = sanei_genesys_read_register (dev, REG40, &val40);
+    sanei_genesys_read_register(dev, REG40, &val40);
-  if (status != SANE_STATUS_GOOD)
-    {
-      DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-      DBG(DBG_proc, "%s: completed\n", __func__);
-      return status;
-    }
 
   /* only stop action if needed */
   if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
     {
       DBG(DBG_info, "%s: already stopped\n", __func__);
-      DBG(DBG_proc, "%s: completed\n", __func__);
       return SANE_STATUS_GOOD;
     }
 
@@ -1916,19 +1908,12 @@ gl843_stop_action (Genesys_Device * dev)
 	  sanei_genesys_print_status (val);
 	}
       val40 = 0;
-      status = sanei_genesys_read_register (dev, 0x40, &val40);
+        sanei_genesys_read_register(dev, 0x40, &val40);
-      if (status != SANE_STATUS_GOOD)
-	{
-	  DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-	  DBGCOMPLETED;
-	  return status;
-	}
 
       /* if scanner is in command mode, we are done */
       if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
 	  && !(val & REG41_MOTORENB))
 	{
-	  DBGCOMPLETED;
 	  return SANE_STATUS_GOOD;
 	}
 
@@ -1936,26 +1921,19 @@ gl843_stop_action (Genesys_Device * dev)
       loop--;
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_IO_ERROR;
 }
 
 static SANE_Status
 gl843_get_paper_sensor (Genesys_Device * dev, SANE_Bool * paper_loaded)
 {
-  SANE_Status status = SANE_STATUS_GOOD;
+    DBG_HELPER(dbg);
     uint8_t val;
 
-  status = sanei_genesys_read_register (dev, REG6D, &val);
+    sanei_genesys_read_register(dev, REG6D, &val);
-  if (status != SANE_STATUS_GOOD)
+
-    {
-      DBG(DBG_error, "%s: failed to read gpio: %s\n", __func__, sane_strstatus(status));
-      return status;
-    }
     *paper_loaded = (val & 0x1) == 0;
     return SANE_STATUS_GOOD;
-
-  return SANE_STATUS_INVAL;
 }
 
 static SANE_Status
@@ -2112,98 +2090,94 @@ gl843_detect_document_end (Genesys_Device * dev)
 // enables or disables XPA slider motor
 static SANE_Status gl843_set_xpa_motor_power(Genesys_Device *dev, bool set)
 {
+    DBG_HELPER(dbg);
     uint8_t val;
-    SANE_Status status=SANE_STATUS_GOOD;
+    SANE_Status status = SANE_STATUS_GOOD;
-
-    DBGSTART;
 
     if (dev->model->model_id == MODEL_CANON_CANOSCAN_8400F) {
 
         if (set) {
-            RIE(sanei_genesys_read_register(dev, 0x6c, &val));
+            sanei_genesys_read_register(dev, 0x6c, &val);
             val &= ~(REG6C_GPIO16 | REG6C_GPIO13);
             RIE(sanei_genesys_write_register(dev, 0x6c, val));
 
-            RIE(sanei_genesys_read_register(dev, 0xa9, &val));
+            sanei_genesys_read_register(dev, 0xa9, &val);
             val |= REGA9_GPO30;
             val &= ~REGA9_GPO29;
             RIE(sanei_genesys_write_register(dev, 0xa9,val));
         } else {
-            RIE(sanei_genesys_read_register(dev, 0x6c, &val));
+            sanei_genesys_read_register(dev, 0x6c, &val);
             val |= REG6C_GPIO16 | REG6C_GPIO13;
             RIE(sanei_genesys_write_register(dev, 0x6c, val));
 
-            RIE(sanei_genesys_read_register(dev, 0xa9, &val));
+            sanei_genesys_read_register(dev, 0xa9, &val);
             val &= ~REGA9_GPO30;
             val |= REGA9_GPO29;
             RIE(sanei_genesys_write_register(dev, 0xa9, val));
         }
     } else if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F) {
-
         if (set) {
-            RIE(sanei_genesys_read_register(dev, REG6C, &val));
+            sanei_genesys_read_register(dev, REG6C, &val);
             val &= ~REG6C_GPIO14;
             if (dev->current_setup.xres >= 2400) {
                 val |= REG6C_GPIO10;
             }
             RIE(sanei_genesys_write_register(dev, REG6C, val));
 
-            RIE(sanei_genesys_read_register(dev, REGA6, &val));
+            sanei_genesys_read_register(dev, REGA6, &val);
             val |= REGA6_GPIO17;
             val &= ~REGA6_GPIO23;
             RIE(sanei_genesys_write_register(dev, REGA6,val));
         } else {
-            RIE(sanei_genesys_read_register(dev, REG6C, &val));
+            sanei_genesys_read_register(dev, REG6C, &val);
             val |= REG6C_GPIO14;
             val &= ~REG6C_GPIO10;
             RIE(sanei_genesys_write_register(dev, REG6C, val));
 
-            RIE(sanei_genesys_read_register(dev, REGA6, &val));
+            sanei_genesys_read_register(dev, REGA6, &val);
             val &= ~REGA6_GPIO17;
             val &= ~REGA6_GPIO23;
             RIE(sanei_genesys_write_register(dev, REGA6,val));
         }
     } else if (dev->model->model_id == MODEL_HP_SCANJET_G4050) {
-
         if (set) {
-            /* set MULTFILM et GPOADF */
+            // set MULTFILM et GPOADF
-            RIE (sanei_genesys_read_register (dev, REG6B, &val));
+            sanei_genesys_read_register(dev, REG6B, &val);
             val |=REG6B_MULTFILM|REG6B_GPOADF;
             RIE (sanei_genesys_write_register (dev, REG6B, val));
 
-            RIE (sanei_genesys_read_register (dev, REG6C, &val));
+            sanei_genesys_read_register(dev, REG6C, &val);
             val &= ~REG6C_GPIO15;
             RIE (sanei_genesys_write_register (dev, REG6C, val));
 
             /* Motor power ? No move at all without this one */
-            RIE (sanei_genesys_read_register (dev, REGA6, &val));
+            sanei_genesys_read_register(dev, REGA6, &val);
             val |= REGA6_GPIO20;
             RIE (sanei_genesys_write_register(dev,REGA6,val));
 
-            RIE (sanei_genesys_read_register (dev, REGA8, &val));
+            sanei_genesys_read_register(dev, REGA8, &val);
             val &= ~REGA8_GPO27;
             RIE (sanei_genesys_write_register (dev, REGA8, val));
 
-            RIE (sanei_genesys_read_register (dev, REGA9, &val));
+            sanei_genesys_read_register(dev, REGA9, &val);
             val |= REGA9_GPO32|REGA9_GPO31;
             RIE (sanei_genesys_write_register (dev, REGA9, val));
         } else {
-            /* unset GPOADF */
+            // unset GPOADF
-            RIE (sanei_genesys_read_register (dev, REG6B, &val));
+            sanei_genesys_read_register(dev, REG6B, &val);
             val &= ~REG6B_GPOADF;
             RIE (sanei_genesys_write_register (dev, REG6B, val));
 
-            RIE (sanei_genesys_read_register (dev, REGA8, &val));
+            sanei_genesys_read_register(dev, REGA8, &val);
             val |= REGA8_GPO27;
             RIE (sanei_genesys_write_register (dev, REGA8, val));
 
-            RIE (sanei_genesys_read_register (dev, REGA9, &val));
+            sanei_genesys_read_register(dev, REGA9, &val);
             val &= ~REGA9_GPO31;
             RIE (sanei_genesys_write_register (dev, REGA9, val));
         }
     }
 
-    DBGCOMPLETED;
     return SANE_STATUS_GOOD;
 }
 
@@ -2215,12 +2189,12 @@ static SANE_Status gl843_set_xpa_motor_power(Genesys_Device *dev, bool set)
  */
 static SANE_Status gl843_set_xpa_lamp_power(Genesys_Device *dev, bool set)
 {
+    DBG_HELPER(dbg);
     SANE_Status status = SANE_STATUS_GOOD;
     uint8_t val = 0;
-    DBGSTART;
 
     if (set) {
-        RIE(sanei_genesys_read_register(dev, REGA6, &val));
+        sanei_genesys_read_register(dev, REGA6, &val);
 
         // cut regular lamp power
         val &= ~(REGA6_GPIO24 | REGA6_GPIO23);
@@ -2232,13 +2206,13 @@ static SANE_Status gl843_set_xpa_lamp_power(Genesys_Device *dev, bool set)
 
         RIE(sanei_genesys_write_register(dev, REGA6, val));
 
-        RIE(sanei_genesys_read_register(dev, REGA7, &val));
+        sanei_genesys_read_register(dev, REGA7, &val);
         val|=REGA7_GPOE24; /* lamp 1 off GPOE 24 */
         val|=REGA7_GPOE23; /* lamp 2 off GPOE 23 */
         val|=REGA7_GPOE22; /* full XPA lamp power */
         RIE(sanei_genesys_write_register(dev, REGA7, val));
     } else {
-        RIE(sanei_genesys_read_register(dev, REGA6, &val));
+        sanei_genesys_read_register(dev, REGA6, &val);
 
         // switch on regular lamp
         val |= REGA6_GPIO23;
@@ -2253,17 +2227,16 @@ static SANE_Status gl843_set_xpa_lamp_power(Genesys_Device *dev, bool set)
         dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
     {
         if (set) {
-            RIE(sanei_genesys_read_register(dev, REG6C, &val));
+            sanei_genesys_read_register(dev, REG6C, &val);
             val |= REG6C_GPIO16;
             RIE(sanei_genesys_write_register(dev, REG6C, val));
         } else {
-            RIE(sanei_genesys_read_register(dev, REG6C, &val));
+            sanei_genesys_read_register(dev, REG6C, &val);
             val &= ~REG6C_GPIO16;
             RIE(sanei_genesys_write_register(dev, REG6C, val));
         }
     }
 
-    DBGCOMPLETED;
     return status;
 }
 
@@ -2272,12 +2245,11 @@ static SANE_Status
 gl843_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
 		  SANE_Bool start_motor)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
   uint16_t dpiset, dpihw;
 
-  DBGSTART;
-
   /* get back the target dpihw */
   sanei_genesys_get_double (reg, REG_DPISET, &dpiset);
   dpihw = sanei_genesys_compute_dpihw(dev, sensor, dpiset);
@@ -2340,8 +2312,8 @@ gl843_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
   RIE (sanei_genesys_write_register
        (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
 
-  /* enable scan and motor */
+    // enable scan and motor
-  RIE (sanei_genesys_read_register (dev, REG01, &val));
+    sanei_genesys_read_register(dev, REG01, &val);
   val |= REG01_SCAN;
   RIE (sanei_genesys_write_register (dev, REG01, val));
 
@@ -2354,7 +2326,6 @@ gl843_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
       RIE (sanei_genesys_write_register (dev, REG0F, 0));
     }
 
-  DBGCOMPLETED;
   return status;
 }
 
@@ -3957,8 +3928,6 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
-  DBGSTART;
-
   if(cold)
     {
       RIE (sanei_genesys_write_register (dev, 0x0e, 0x01));
@@ -3975,11 +3944,10 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
     }
     sanei_genesys_write_0x8c(dev, 0x0f, val);
 
-  /* test CHKVER */
+    // test CHKVER
-  RIE (sanei_genesys_read_register (dev, REG40, &val));
+    sanei_genesys_read_register(dev, REG40, &val);
-  if (val & REG40_CHKVER)
+    if (val & REG40_CHKVER) {
-    {
+        sanei_genesys_read_register(dev, 0x00, &val);
-      RIE (sanei_genesys_read_register (dev, 0x00, &val));
         DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
     }
 
@@ -4048,7 +4016,6 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
   gl843_feed (dev, 300);
   sanei_genesys_sleep_ms(100);
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -4073,13 +4040,13 @@ gl843_init (Genesys_Device * dev)
 static SANE_Status
 gl843_update_hardware_sensors (Genesys_Scanner * s)
 {
+    DBG_HELPER(dbg);
   /* do what is needed to get a new set of events, but try to not lose
      any of them.
    */
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
-  RIE (sanei_genesys_read_register (s->dev, REG6D, &val));
+    sanei_genesys_read_register(s->dev, REG6D, &val);
 
   switch (s->dev->model->gpo_type)
     {
@@ -4098,7 +4065,7 @@ gl843_update_hardware_sensors (Genesys_Scanner * s)
             break;
     }
 
-  return status;
+  return SANE_STATUS_GOOD;
 }
 
 /** @brief move sensor to transparency adaptor

backend/genesys_gl846.cc

@@ -545,10 +545,11 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
 static SANE_Status
 gl846_homsnr_gpio(Genesys_Device *dev)
 {
+    DBG_HELPER(dbg);
 uint8_t val;
 SANE_Status status=SANE_STATUS_GOOD;
 
-  RIE (sanei_genesys_read_register (dev, REG6C, &val));
+    sanei_genesys_read_register(dev, REG6C, &val);
   val |= 0x41;
   RIE (sanei_genesys_write_register (dev, REG6C, val));
 
@@ -597,6 +598,7 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
                             int scan_power_mode,
                             unsigned int flags)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   int use_fast_fed;
   unsigned int fast_dpi;
@@ -611,7 +613,6 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
   int fast_step_type;
   unsigned int ccdlmt,tgtime;
 
-  DBGSTART;
   DBG(DBG_proc, "%s : scan_exposure_time=%d, scan_yres=%g, scan_step_type=%d, scan_lines=%d, "
       "scan_dummy=%d, feed_steps=%d, scan_power_mode=%d, flags=%x\n", __func__, scan_exposure_time,
       scan_yres, scan_step_type, scan_lines, scan_dummy, feed_steps, scan_power_mode, flags);
@@ -728,7 +729,7 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
 
   /* hi res motor speed GPIO */
   /*
-  RIE (sanei_genesys_read_register (dev, REG6C, &effective));
+  sanei_genesys_read_register(dev, REG6C, &effective);
   */
 
   /* if quarter step, bipolar Vref2 */
@@ -753,7 +754,7 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
 
   /* effective scan */
   /*
-  RIE (sanei_genesys_read_register (dev, REG6C, &effective));
+  sanei_genesys_read_register(dev, REG6C, &effective);
   val = effective | REG6C_GPIO10;
   RIE (sanei_genesys_write_register (dev, REG6C, val));
   */
@@ -819,7 +820,6 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
   r = sanei_genesys_get_address (reg, REG_FMOVDEC);
   r->value = fast_steps;
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -1482,12 +1482,11 @@ gl846_start_action (Genesys_Device * dev)
 static SANE_Status
 gl846_stop_action (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val40, val;
   unsigned int loop;
 
-  DBGSTART;
-
   /* post scan gpio : without that HOMSNR is unreliable */
   gl846_homsnr_gpio(dev);
   status = sanei_genesys_get_status (dev, &val);
@@ -1496,11 +1495,10 @@ gl846_stop_action (Genesys_Device * dev)
       sanei_genesys_print_status (val);
     }
 
-  status = sanei_genesys_read_register (dev, REG40, &val40);
+    sanei_genesys_read_register(dev, REG40, &val40);
   if (status != SANE_STATUS_GOOD)
     {
       DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-      DBGCOMPLETED;
       return status;
     }
 
@@ -1508,7 +1506,6 @@ gl846_stop_action (Genesys_Device * dev)
   if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
     {
       DBG(DBG_info, "%s: already stopped\n", __func__);
-      DBGCOMPLETED;
       return SANE_STATUS_GOOD;
     }
 
@@ -1532,19 +1529,12 @@ gl846_stop_action (Genesys_Device * dev)
         {
           sanei_genesys_print_status (val);
         }
-      status = sanei_genesys_read_register (dev, REG40, &val40);
+        sanei_genesys_read_register(dev, REG40, &val40);
-      if (status != SANE_STATUS_GOOD)
-        {
-          DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-          DBGCOMPLETED;
-          return status;
-        }
 
       /* if scanner is in command mode, we are done */
       if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
           && !(val & REG41_MOTORENB))
         {
-          DBGCOMPLETED;
           return SANE_STATUS_GOOD;
         }
 
@@ -1552,7 +1542,6 @@ gl846_stop_action (Genesys_Device * dev)
       loop--;
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_IO_ERROR;
 }
 
@@ -1561,16 +1550,15 @@ static SANE_Status
 gl846_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
                   SANE_Bool start_motor)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
   GenesysRegister *r;
 
-  DBGSTART;
-
   /* XXX STEF XXX SCAN GPIO */
   /*
-  RIE (sanei_genesys_read_register (dev, REG6C, &val));
+  sanei_genesys_read_register(dev, REG6C, &val);
   RIE (sanei_genesys_write_register (dev, REG6C, val));
   */
 
@@ -1579,7 +1567,7 @@ gl846_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
   val = REG0D_CLRMCNT;
   RIE (sanei_genesys_write_register (dev, REG0D, val));
 
-  RIE (sanei_genesys_read_register (dev, REG01, &val));
+    sanei_genesys_read_register(dev, REG01, &val);
   val |= REG01_SCAN;
   RIE (sanei_genesys_write_register (dev, REG01, val));
   r = sanei_genesys_get_address (reg, REG01);
@@ -1594,8 +1582,6 @@ gl846_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
       RIE (sanei_genesys_write_register (dev, REG0F, 0));
     }
 
-  DBGCOMPLETED;
-
   return status;
 }
 
@@ -2251,6 +2237,7 @@ static SANE_Status
 gl846_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
                          uint8_t * data, int size)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint32_t addr, length, i, x, factor, pixels;
   uint32_t dpiset, dpihw, strpixel, endpixel;
@@ -2258,7 +2245,6 @@ gl846_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
   uint32_t lines, channels;
   uint8_t val,*ptr,*src;
 
-  DBGSTART;
   DBG(DBG_io2, "%s: writing %d bytes of shading data\n", __func__, size);
 
   /* shading data is plit in 3 (up to 5 with IR) areas
@@ -2332,7 +2318,7 @@ gl846_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
           ptr+=4;
         }
 
-      RIE(sanei_genesys_read_register(dev, 0xd0+i, &val));
+        sanei_genesys_read_register(dev, 0xd0+i, &val);
       addr = val * 8192 + 0x10000000;
       status = sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
       if (status != SANE_STATUS_GOOD)
@@ -2342,8 +2328,6 @@ gl846_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
         }
     }
 
-  DBGCOMPLETED;
-
   return status;
 }
 
@@ -2630,11 +2614,10 @@ gl846_boot (Genesys_Device * dev, SANE_Bool cold)
     }
     sanei_genesys_write_0x8c(dev, 0x0f, val);
 
-  /* test CHKVER */
+    // test CHKVER
-  RIE (sanei_genesys_read_register (dev, REG40, &val));
+    sanei_genesys_read_register(dev, REG40, &val);
-  if (val & REG40_CHKVER)
+    if (val & REG40_CHKVER) {
-    {
+        sanei_genesys_read_register(dev, 0x00, &val);
-      RIE (sanei_genesys_read_register (dev, 0x00, &val));
         DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
     }
 
@@ -2693,6 +2676,7 @@ static SANE_Status gl846_init(Genesys_Device * dev)
 static SANE_Status
 gl846_update_hardware_sensors (Genesys_Scanner * s)
 {
+    DBG_HELPER(dbg);
   /* do what is needed to get a new set of events, but try to not lose
      any of them.
    */
@@ -2707,7 +2691,7 @@ gl846_update_hardware_sensors (Genesys_Scanner * s)
         email=0x04;
         copy=0x08;
     }
-  RIE (sanei_genesys_read_register (s->dev, REG6D, &val));
+    sanei_genesys_read_register(s->dev, REG6D, &val);
 
     s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
     s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@@ -3029,6 +3013,7 @@ static SANE_Status
 gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                          Genesys_Register_Set& regs)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t reg04;
   unsigned int channels, bpp;
@@ -3036,13 +3021,10 @@ gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
   int topavg, bottomavg, resolution, lines;
   int top, bottom, black_pixels, pixels;
 
-  DBGSTART;
+    // no gain nor offset for AKM AFE
-
+    sanei_genesys_read_register(dev, REG04, &reg04);
-  /* no gain nor offset for AKM AFE */
-  RIE (sanei_genesys_read_register (dev, REG04, &reg04));
   if ((reg04 & REG04_FESET) == 0x02)
     {
-      DBGCOMPLETED;
       return status;
     }
 
@@ -3172,7 +3154,6 @@ gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
       dev->frontend.get_offset(1),
       dev->frontend.get_offset(2));
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -3180,6 +3161,7 @@ static SANE_Status
 gl846_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                               Genesys_Register_Set& regs, int dpi)
 {
+    DBG_HELPER(dbg);
   int pixels;
   int total_size;
   uint8_t reg04;
@@ -3193,11 +3175,10 @@ gl846_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   DBG(DBG_proc, "%s: dpi = %d\n", __func__, dpi);
 
-  /* no gain nor offset for AKM AFE */
+    // no gain nor offset for AKM AFE
-  RIE (sanei_genesys_read_register (dev, REG04, &reg04));
+    sanei_genesys_read_register(dev, REG04, &reg04);
   if ((reg04 & REG04_FESET) == 0x02)
     {
-      DBGCOMPLETED;
       return status;
     }
 
@@ -3311,7 +3292,6 @@ gl846_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   status=gl846_slow_back_home (dev, SANE_TRUE);
 
-  DBGCOMPLETED;
   return status;
 }
 

backend/genesys_gl847.cc

@@ -569,18 +569,16 @@ gl847_set_ad_fe (Genesys_Device * dev, uint8_t set)
 static SANE_Status
 gl847_homsnr_gpio(Genesys_Device *dev)
 {
+    DBG_HELPER(dbg);
 uint8_t val;
 SANE_Status status=SANE_STATUS_GOOD;
 
-  if (dev->model->gpo_type == GPO_CANONLIDE700)
+    if (dev->model->gpo_type == GPO_CANONLIDE700) {
-    {
+        sanei_genesys_read_register(dev, REG6C, &val);
-      RIE (sanei_genesys_read_register (dev, REG6C, &val));
       val &= ~REG6C_GPIO10;
       RIE (sanei_genesys_write_register (dev, REG6C, val));
-    }
+    } else {
-  else
+        sanei_genesys_read_register(dev, REG6C, &val);
-    {
-      RIE (sanei_genesys_read_register (dev, REG6C, &val));
       val |= REG6C_GPIO10;
       RIE (sanei_genesys_write_register (dev, REG6C, val));
     }
@@ -591,15 +589,15 @@ SANE_Status status=SANE_STATUS_GOOD;
 static SANE_Status
 gl847_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
 
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
   DBG(DBG_proc, "%s (%s)\n", __func__, set == AFE_INIT ? "init" : set == AFE_SET ? "set" : set ==
       AFE_POWER_SAVE ? "powersave" : "huh?");
 
-  RIE (sanei_genesys_read_register (dev, REG04, &val));
+    sanei_genesys_read_register(dev, REG04, &val);
 
   /* route to AD devices */
   if ((val & REG04_FESET) == 0x02)
@@ -611,7 +609,6 @@ gl847_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
   DBG(DBG_proc, "%s(): unsupported frontend type %d\n", __func__,
       dev->reg.find_reg(0x04).value & REG04_FESET);
 
-  DBGCOMPLETED;
   return SANE_STATUS_UNSUPPORTED;
 }
 
@@ -631,6 +628,7 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
 			    int scan_power_mode,
                             unsigned int flags)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   int use_fast_fed;
   unsigned int fast_dpi;
@@ -645,7 +643,6 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
   int fast_step_type;
   unsigned int ccdlmt,tgtime;
 
-  DBGSTART;
   DBG(DBG_proc, "%s : scan_exposure_time=%d, can_yres=%g, scan_step_type=%d, scan_lines=%d, "
       "scan_dummy=%d, feed_steps=%d, scan_power_mode=%d, flags=%x\n", __func__, scan_exposure_time,
       scan_yres, scan_step_type, scan_lines, scan_dummy, feed_steps, scan_power_mode, flags);
@@ -760,8 +757,8 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
   r = sanei_genesys_get_address (reg, REG1C);
   tgtime=1<<(r->value & REG1C_TGTIME);
 
-  /* hi res motor speed GPIO */
+    // hi res motor speed GPIO
-  RIE (sanei_genesys_read_register (dev, REG6C, &effective));
+    sanei_genesys_read_register(dev, REG6C, &effective);
 
   /* if quarter step, bipolar Vref2 */
   if (scan_step_type > 1)
@@ -781,8 +778,8 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
     }
   RIE (sanei_genesys_write_register (dev, REG6C, val));
 
-  /* effective scan */
+    // effective scan
-  RIE (sanei_genesys_read_register (dev, REG6C, &effective));
+    sanei_genesys_read_register(dev, REG6C, &effective);
   val = effective | REG6C_GPIO10;
   RIE (sanei_genesys_write_register (dev, REG6C, val));
 
@@ -834,7 +831,6 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
   r = sanei_genesys_get_address (reg, REG_FMOVDEC);
   r->value = fast_steps;
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -1500,12 +1496,11 @@ gl847_start_action (Genesys_Device * dev)
 static SANE_Status
 gl847_stop_action (Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val40, val;
   unsigned int loop;
 
-  DBGSTART;
-
   /* post scan gpio : without that HOMSNR is unreliable */
   gl847_homsnr_gpio(dev);
   status = sanei_genesys_get_status (dev, &val);
@@ -1514,19 +1509,12 @@ gl847_stop_action (Genesys_Device * dev)
       sanei_genesys_print_status (val);
     }
 
-  status = sanei_genesys_read_register (dev, REG40, &val40);
+    sanei_genesys_read_register(dev, REG40, &val40);
-  if (status != SANE_STATUS_GOOD)
-    {
-      DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-      DBGCOMPLETED;
-      return status;
-    }
 
   /* only stop action if needed */
   if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
     {
       DBG(DBG_info, "%s: already stopped\n", __func__);
-      DBGCOMPLETED;
       return SANE_STATUS_GOOD;
     }
 
@@ -1550,19 +1538,12 @@ gl847_stop_action (Genesys_Device * dev)
 	{
 	  sanei_genesys_print_status (val);
 	}
-      status = sanei_genesys_read_register (dev, REG40, &val40);
+            sanei_genesys_read_register(dev, REG40, &val40);
-      if (status != SANE_STATUS_GOOD)
-	{
-	  DBG(DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus(status));
-          DBGCOMPLETED;
-	  return status;
-	}
 
       /* if scanner is in command mode, we are done */
       if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
 	  && !(val & REG41_MOTORENB))
 	{
-          DBGCOMPLETED;
 	  return SANE_STATUS_GOOD;
 	}
 
@@ -1570,7 +1551,6 @@ gl847_stop_action (Genesys_Device * dev)
       loop--;
     }
 
-  DBGCOMPLETED;
   return SANE_STATUS_IO_ERROR;
 }
 
@@ -1579,17 +1559,15 @@ static SANE_Status
 gl847_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
 		  SANE_Bool start_motor)
 {
+    DBG_HELPER(dbg);
     (void) sensor;
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
   GenesysRegister *r;
 
-  DBGSTART;
+    // clear GPIO 10
-
+    if (dev->model->gpo_type != GPO_CANONLIDE700) {
-  /* clear GPIO 10 */
+        sanei_genesys_read_register(dev, REG6C, &val);
-  if (dev->model->gpo_type != GPO_CANONLIDE700)
-    {
-      RIE (sanei_genesys_read_register (dev, REG6C, &val));
       val &= ~REG6C_GPIO10;
       RIE (sanei_genesys_write_register (dev, REG6C, val));
     }
@@ -1599,7 +1577,7 @@ gl847_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
   val = REG0D_CLRMCNT;
   RIE (sanei_genesys_write_register (dev, REG0D, val));
 
-  RIE (sanei_genesys_read_register (dev, REG01, &val));
+    sanei_genesys_read_register(dev, REG01, &val);
   val |= REG01_SCAN;
   RIE (sanei_genesys_write_register (dev, REG01, val));
   r = sanei_genesys_get_address (reg, REG01);
@@ -1614,8 +1592,6 @@ gl847_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
       RIE (sanei_genesys_write_register (dev, REG0F, 0));
     }
 
-  DBGCOMPLETED;
-
   return status;
 }
 
@@ -1658,13 +1634,13 @@ gl847_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
 static
 SANE_Status gl847_rewind(Genesys_Device * dev)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t byte;
 
-  DBGSTART;
 
-  /* set motor reverse */
+    // set motor reverse
-  RIE (sanei_genesys_read_register (dev, 0x02, &byte));
+    sanei_genesys_read_register(dev, 0x02, &byte);
   byte |= 0x04;
   RIE (sanei_genesys_write_register(dev, 0x02, byte));
 
@@ -1673,13 +1649,13 @@ SANE_Status gl847_rewind(Genesys_Device * dev)
   do
     {
       sanei_genesys_sleep_ms(100);
-      RIE (sanei_genesys_read_register (dev, REG40, &byte));
+        sanei_genesys_read_register(dev, REG40, &byte);
     }
   while(byte & REG40_MOTMFLG);
   RIE (gl847_end_scan (dev, dev->reg, SANE_TRUE));
 
-  /* restore direction */
+    // restore direction
-  RIE (sanei_genesys_read_register (dev, 0x02, &byte));
+    sanei_genesys_read_register(dev, 0x02, &byte);
   byte &= 0xfb;
   RIE (sanei_genesys_write_register(dev, 0x02, byte));
 
@@ -2317,6 +2293,7 @@ static SANE_Status
 gl847_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
                          uint8_t * data, int size)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint32_t addr, length, i, x, factor, pixels;
   uint32_t dpiset, dpihw, strpixel, endpixel;
@@ -2324,7 +2301,6 @@ gl847_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
   uint32_t lines, channels;
   uint8_t val,*ptr,*src;
 
-  DBGSTART;
   DBG(DBG_io2, "%s: writing %d bytes of shading data\n", __func__, size);
 
   /* shading data is plit in 3 (up to 5 with IR) areas
@@ -2398,7 +2374,7 @@ gl847_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
           ptr+=4;
         }
 
-      RIE (sanei_genesys_read_register (dev, 0xd0+i, &val));
+            sanei_genesys_read_register(dev, 0xd0+i, &val);
       addr = val * 8192 + 0x10000000;
       status = sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
       if (status != SANE_STATUS_GOOD)
@@ -2408,8 +2384,6 @@ gl847_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
         }
     }
 
-  DBGCOMPLETED;
-
   return status;
 }
 
@@ -2724,7 +2698,7 @@ gl847_init_memory_layout (Genesys_Device * dev)
 static SANE_Status
 gl847_boot (Genesys_Device * dev, SANE_Bool cold)
 {
-    DBG_HELPER(dgb);
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t val;
 
@@ -2735,11 +2709,10 @@ gl847_boot (Genesys_Device * dev, SANE_Bool cold)
       RIE (sanei_genesys_write_register (dev, 0x0e, 0x00));
     }
 
-  /* test CHKVER */
+    // test CHKVER
-  RIE (sanei_genesys_read_register (dev, REG40, &val));
+    sanei_genesys_read_register(dev, REG40, &val);
-  if (val & REG40_CHKVER)
+    if (val & REG40_CHKVER) {
-    {
+        sanei_genesys_read_register(dev, 0x00, &val);
-      RIE (sanei_genesys_read_register (dev, 0x00, &val));
         DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
     }
 
@@ -2795,6 +2768,7 @@ static SANE_Status gl847_init (Genesys_Device * dev)
 static SANE_Status
 gl847_update_hardware_sensors (Genesys_Scanner * s)
 {
+    DBG_HELPER(dbg);
   /* do what is needed to get a new set of events, but try to not lose
      any of them.
    */
@@ -2815,7 +2789,7 @@ gl847_update_hardware_sensors (Genesys_Scanner * s)
         email=0x04;
         copy=0x08;
     }
-  RIE (sanei_genesys_read_register (s->dev, REG6D, &val));
+    sanei_genesys_read_register(s->dev, REG6D, &val);
 
     s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
     s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@@ -3132,6 +3106,7 @@ static SANE_Status
 gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                          Genesys_Register_Set& regs)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t reg04;
   unsigned int channels, bpp;
@@ -3139,13 +3114,10 @@ gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
   int topavg, bottomavg, resolution, lines;
   int top, bottom, black_pixels, pixels;
 
-  DBGSTART;
+    // no gain nor offset for AKM AFE
-
+    sanei_genesys_read_register(dev, REG04, &reg04);
-  /* no gain nor offset for AKM AFE */
-  RIE (sanei_genesys_read_register (dev, REG04, &reg04));
   if ((reg04 & REG04_FESET) == 0x02)
     {
-      DBGCOMPLETED;
       return status;
     }
 
@@ -3275,7 +3247,6 @@ gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
       dev->frontend.get_offset(1),
       dev->frontend.get_offset(2));
 
-  DBGCOMPLETED;
   return SANE_STATUS_GOOD;
 }
 
@@ -3283,6 +3254,7 @@ static SANE_Status
 gl847_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
                               Genesys_Register_Set& regs, int dpi)
 {
+    DBG_HELPER(dbg);
   int pixels;
   int total_size;
   uint8_t reg04;
@@ -3296,11 +3268,10 @@ gl847_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   DBG(DBG_proc, "%s: dpi = %d\n", __func__, dpi);
 
-  /* no gain nor offset for AKM AFE */
+    // no gain nor offset for AKM AFE
-  RIE (sanei_genesys_read_register (dev, REG04, &reg04));
+    sanei_genesys_read_register(dev, REG04, &reg04);
   if ((reg04 & REG04_FESET) == 0x02)
     {
-      DBGCOMPLETED;
       return status;
     }
 
@@ -3435,7 +3406,6 @@ gl847_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
 
   status=gl847_slow_back_home (dev, SANE_TRUE);
 
-  DBGCOMPLETED;
   return status;
 }
 

backend/genesys_low.cc

@@ -524,9 +524,8 @@ static void sanei_genesys_read_gl847_register(Genesys_Device* dev, uint16_t reg,
     }
 }
 
-/* Read from one register */
+// Read from one register
-SANE_Status
+void sanei_genesys_read_register(Genesys_Device* dev, uint16_t reg, uint8_t* val)
-sanei_genesys_read_register (Genesys_Device * dev, uint16_t reg, uint8_t * val)
 {
     DBG_HELPER(dbg);
 
@@ -535,7 +534,7 @@ sanei_genesys_read_register (Genesys_Device * dev, uint16_t reg, uint8_t * val)
     // 16 bit register address space
     if (reg > 255) {
         sanei_genesys_read_hregister(dev, reg, val);
-        return SANE_STATUS_GOOD;
+        return;
     }
 
     // route to gl847 function if needed
@@ -545,7 +544,7 @@ sanei_genesys_read_register (Genesys_Device * dev, uint16_t reg, uint8_t * val)
         || dev->model->asic_type==GENESYS_GL124)
     {
         sanei_genesys_read_gl847_register(dev, reg, val);
-        return SANE_STATUS_GOOD;
+        return;
     }
 
   /* 8 bit register address space */
@@ -560,8 +559,6 @@ sanei_genesys_read_register (Genesys_Device * dev, uint16_t reg, uint8_t * val)
                              1, val);
 
   DBG(DBG_io, "%s (0x%02x, 0x%02x) completed\n", __func__, reg, *val);
-
-    return SANE_STATUS_GOOD;
 }
 
 /* Set address for writing data */
@@ -613,13 +610,11 @@ SANE_Status
 sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
 			     uint16_t *data)
 {
+    DBG_HELPER(dbg);
   SANE_Status status = SANE_STATUS_GOOD;
   uint8_t value;
   Genesys_Register_Set reg;
 
-
-  DBG(DBG_proc, "%s: start\n", __func__);
-
   reg.init_reg(0x50, addr);
 
   /* set up read address */
@@ -631,11 +626,11 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
       return status;
     }
 
-  /* read data */
+    // read data
-  RIE (sanei_genesys_read_register (dev, 0x46, &value));
+    sanei_genesys_read_register(dev, 0x46, &value);
-  *data=256*value;
+    *data = 256 * value;
-  RIE (sanei_genesys_read_register (dev, 0x47, &value));
+    sanei_genesys_read_register(dev, 0x47, &value);
-  *data+=value;
+    *data += value;
 
   DBG(DBG_io, "%s (0x%02x, 0x%04x)\n", __func__, addr, *data);
   DBG(DBG_proc, "%s: completed\n", __func__);
@@ -695,7 +690,8 @@ sanei_genesys_get_status (Genesys_Device * dev, uint8_t * status)
         sanei_genesys_read_hregister(dev, 0x101, status);
         return SANE_STATUS_GOOD;
     }
-  return sanei_genesys_read_register (dev, 0x41, status);
+    sanei_genesys_read_register(dev, 0x41, status);
+    return SANE_STATUS_GOOD;
 }
 
 /**
@@ -761,7 +757,6 @@ SANE_Status
 sanei_genesys_read_valid_words (Genesys_Device * dev, unsigned int *words)
 {
     DBG_HELPER(dbg);
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t value;
 
   switch (dev->model->asic_type)
@@ -779,33 +774,33 @@ sanei_genesys_read_valid_words (Genesys_Device * dev, unsigned int *words)
 
     case GENESYS_GL845:
     case GENESYS_GL846:
-      RIE (sanei_genesys_read_register (dev, 0x42, &value));
+        sanei_genesys_read_register(dev, 0x42, &value);
-      *words = (value & 0x02);
+        *words = value & 0x02;
-      RIE (sanei_genesys_read_register (dev, 0x43, &value));
+        sanei_genesys_read_register(dev, 0x43, &value);
         *words = *words * 256 + value;
-      RIE (sanei_genesys_read_register (dev, 0x44, &value));
+        sanei_genesys_read_register(dev, 0x44, &value);
         *words = *words * 256 + value;
-      RIE (sanei_genesys_read_register (dev, 0x45, &value));
+        sanei_genesys_read_register(dev, 0x45, &value);
         *words = *words * 256 + value;
         break;
 
     case GENESYS_GL847:
-      RIE (sanei_genesys_read_register (dev, 0x42, &value));
+        sanei_genesys_read_register(dev, 0x42, &value);
-      *words = (value & 0x03);
+        *words = value & 0x03;
-      RIE (sanei_genesys_read_register (dev, 0x43, &value));
+        sanei_genesys_read_register(dev, 0x43, &value);
         *words = *words * 256 + value;
-      RIE (sanei_genesys_read_register (dev, 0x44, &value));
+        sanei_genesys_read_register(dev, 0x44, &value);
         *words = *words * 256 + value;
-      RIE (sanei_genesys_read_register (dev, 0x45, &value));
+        sanei_genesys_read_register(dev, 0x45, &value);
         *words = *words * 256 + value;
         break;
 
     default:
-      RIE (sanei_genesys_read_register (dev, 0x44, &value));
+        sanei_genesys_read_register(dev, 0x44, &value);
         *words = value;
-      RIE (sanei_genesys_read_register (dev, 0x43, &value));
+        sanei_genesys_read_register(dev, 0x43, &value);
-      *words += (value * 256);
+        *words += value * 256;
-      RIE (sanei_genesys_read_register (dev, 0x42, &value));
+        sanei_genesys_read_register(dev, 0x42, &value);
       if (dev->model->asic_type == GENESYS_GL646)
 	*words += ((value & 0x03) * 256 * 256);
       else
@@ -823,7 +818,6 @@ SANE_Status
 sanei_genesys_read_scancnt (Genesys_Device * dev, unsigned int *words)
 {
     DBG_HELPER(dbg);
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t value;
 
   if (dev->model->asic_type == GENESYS_GL124)
@@ -837,11 +831,11 @@ sanei_genesys_read_scancnt (Genesys_Device * dev, unsigned int *words)
     }
   else
     {
-      RIE (sanei_genesys_read_register (dev, 0x4d, &value));
+            sanei_genesys_read_register(dev, 0x4d, &value);
             *words = value;
-      RIE (sanei_genesys_read_register (dev, 0x4c, &value));
+            sanei_genesys_read_register(dev, 0x4c, &value);
-      *words += (value * 256);
+            *words += value * 256;
-      RIE (sanei_genesys_read_register (dev, 0x4b, &value));
+            sanei_genesys_read_register(dev, 0x4b, &value);
       if (dev->model->asic_type == GENESYS_GL646)
         *words += ((value & 0x03) * 256 * 256);
       else
@@ -934,7 +928,6 @@ SANE_Status
 sanei_genesys_read_feed_steps (Genesys_Device * dev, unsigned int *steps)
 {
     DBG_HELPER(dbg);
-  SANE_Status status = SANE_STATUS_GOOD;
   uint8_t value;
 
   if (dev->model->asic_type == GENESYS_GL124)
@@ -948,11 +941,11 @@ sanei_genesys_read_feed_steps (Genesys_Device * dev, unsigned int *steps)
     }
   else
     {
-      RIE (sanei_genesys_read_register (dev, 0x4a, &value));
+        sanei_genesys_read_register(dev, 0x4a, &value);
         *steps = value;
-      RIE (sanei_genesys_read_register (dev, 0x49, &value));
+        sanei_genesys_read_register(dev, 0x49, &value);
-      *steps += (value * 256);
+        *steps += value * 256;
-      RIE (sanei_genesys_read_register (dev, 0x48, &value));
+        sanei_genesys_read_register(dev, 0x48, &value);
       if (dev->model->asic_type == GENESYS_GL646)
         *steps += ((value & 0x03) * 256 * 256);
       else if (dev->model->asic_type == GENESYS_GL841)
@@ -1250,13 +1243,12 @@ SANE_Status sanei_genesys_generate_gamma_buffer(Genesys_Device * dev,
 SANE_Status
 sanei_genesys_send_gamma_table(Genesys_Device * dev, const Genesys_Sensor& sensor)
 {
+    DBG_HELPER(dbg);
   int size;
   int i;
   uint8_t val;
   SANE_Status status = SANE_STATUS_GOOD;
 
-  DBGSTART;
-
   size = 256 + 1;
 
   /* allocate temporary gamma tables: 16 bits words, 3 channels */
@@ -1264,16 +1256,15 @@ sanei_genesys_send_gamma_table(Genesys_Device * dev, const Genesys_Sensor& senso
 
   RIE(sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data()));
 
-  /* loop sending gamma tables NOTE: 0x01000000 not 0x10000000 */
+    // loop sending gamma tables NOTE: 0x01000000 not 0x10000000
-  for (i = 0; i < 3; i++)
+    for (i = 0; i < 3; i++) {
-    {
+        // clear corresponding GMM_N bit
-      /* clear corresponding GMM_N bit */
+        sanei_genesys_read_register(dev, 0xbd, &val);
-      RIE(sanei_genesys_read_register(dev, 0xbd, &val));
       val &= ~(0x01 << i);
       RIE(sanei_genesys_write_register(dev, 0xbd, val));
 
-      /* clear corresponding GMM_F bit */
+        // clear corresponding GMM_F bit
-      RIE(sanei_genesys_read_register(dev, 0xbe, &val));
+        sanei_genesys_read_register(dev, 0xbe, &val);
       val &= ~(0x01 << i);
       RIE(sanei_genesys_write_register(dev, 0xbe, val));
 
@@ -1297,7 +1288,6 @@ sanei_genesys_send_gamma_table(Genesys_Device * dev, const Genesys_Sensor& senso
 	}
     }
 
-  DBGCOMPLETED;
   return status;
 }
 
@@ -1320,8 +1310,6 @@ sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
   uint8_t val;
   SANE_Bool cold = SANE_TRUE;
 
-  DBGSTART;
-
     // URB    16  control  0xc0 0x0c 0x8e 0x0b len     1 read  0x00 */
     dev->usb_dev.control_msg(REQUEST_TYPE_IN, REQUEST_REGISTER, VALUE_GET_REGISTER, 0x00, 1, &val);
 
@@ -1340,7 +1328,7 @@ sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
    * we read register 6 and check PWRBIT, if reset scanner has been
    * freshly powered up. This bit will be set to later so that following
    * reads can detect power down/up cycle*/
-  RIE (sanei_genesys_read_register (dev, 0x06, &val));
+    sanei_genesys_read_register(dev, 0x06, &val);
   /* test for POWER bit */
   if (val & 0x10)
     {

backend/genesys_low.h

@@ -1716,8 +1716,7 @@ inline void sanei_genesys_set_reg_from_set(Genesys_Register_Set* regs, uint16_t
 
 extern SANE_Status sanei_genesys_init_cmd_set (Genesys_Device * dev);
 
-extern SANE_Status
+extern void sanei_genesys_read_register(Genesys_Device* dev, uint16_t reg, uint8_t* val);
-sanei_genesys_read_register (Genesys_Device * dev, uint16_t reg, uint8_t * val);
 
 extern SANE_Status
 sanei_genesys_write_register (Genesys_Device * dev, uint16_t reg, uint8_t val);