← Back to branch summary

~ubuntu-branches/debian/jessie/sane-backends/jessie

« back to all changes in this revision

Viewing changes to backend/genesys_gl843.c

  • Committer: Package Import Robot
  • Author(s): Mark Buda
  • Date: 2013-11-24 10:05:18 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20131124100518-3k4yw6t30auxr5zu
Tags: 1.0.24-1
http://bugs.debian.org/688531
* New upstream version.
* New maintainer (Closes: 688531)
* Disable USB testing since it (probably) doesn't work on autobuilders.
* Fixed a bunch of lintian warnings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/genesys_gl843.c
1
1
/* sane - Scanner Access Now Easy.
2
2
 
3
 
   Copyright (C) 2010-2012 St�phane Voltz <stef.dev@free.fr>
 
3
   Copyright (C) 2010-2013 St�phane Voltz <stef.dev@free.fr>
4
4
   
5
5
    
6
6
   This file is part of the SANE package.
55
55
/*                  Read and write RAM, registers and AFE                   */
56
56
/* ------------------------------------------------------------------------ */
57
57
 
58
 
/**
59
 
 *
60
 
 */
61
 
static SANE_Status
62
 
write_end_access (Genesys_Device * dev, uint8_t index, uint8_t val)
63
 
{
64
 
  SANE_Status status;
65
 
 
66
 
  DBG (DBG_io, "write_end_access: 0x%02x,0x%02x\n", index, val);
67
 
 
68
 
  status =
69
 
    sanei_usb_control_msg (dev->dn, REQUEST_TYPE_OUT, REQUEST_REGISTER,
70
 
                           VALUE_BUF_ENDACCESS, index, 1, &val);
71
 
  if (status != SANE_STATUS_GOOD)
72
 
    {
73
 
      DBG (DBG_error,
74
 
           "write_end_access: failed %s\n", sane_strstatus (status));
75
 
    }
76
 
  return status;
77
 
}
78
58
 
79
59
/**
80
60
 * Write bulk data (e.g. gamma or shading data) */
228
208
  return status;
229
209
}
230
210
 
231
 
/**
232
 
 * Write to many GL843 registers at once
233
 
 */
234
 
#ifndef UNIT_TESTING
235
 
static
236
 
#endif
237
 
  SANE_Status
238
 
gl843_bulk_write_register (Genesys_Device * dev, Genesys_Register_Set * reg,
239
 
                           size_t elems)
240
 
{
241
 
  SANE_Status status = SANE_STATUS_GOOD;
242
 
  size_t i;
243
 
 
244
 
  for (i = 0; i < elems && status == SANE_STATUS_GOOD; i++)
245
 
    {
246
 
      if (reg[i].address != 0)
247
 
        {
248
 
          status =
249
 
            sanei_genesys_write_register (dev, reg[i].address, reg[i].value);
250
 
        }
251
 
    }
252
 
 
253
 
  DBG (DBG_io, "gl843_bulk_write_register: wrote %lu registers\n",
254
 
       (u_long) elems);
255
 
  return status;
256
 
}
257
211
 
258
212
static SANE_Status
259
213
gl843_bulk_read_data (Genesys_Device * dev, uint8_t addr,
407
361
  Genesys_Register_Set *r = NULL;
408
362
  int value = 1;
409
363
 
410
 
  r = sanei_genesys_get_address (regs, 0x9d);
 
364
  r = sanei_genesys_get_address (regs, REG9D);
411
365
  if (r != NULL)
412
366
    {
413
367
      switch (r->value & 0x0c)
442
396
  return SANE_FALSE;
443
397
}
444
398
 
445
 
/** @get sensor profile
 
399
/** @brief sensor profile
446
400
 * search for the database of motor profiles and get the best one. Each
447
401
 * profile is at a specific dpihw. Use first entry of table by default.
448
402
 * @param sensor_type sensor id
551
505
  r = sanei_genesys_get_address (regs, 0x7d);
552
506
  if (r)
553
507
    {
554
 
      r->value = 0x90;
 
508
      if (!(dev->model->flags & GENESYS_FLAG_FULL_HWDPI_MODE))
 
509
        {
 
510
          r->value = 0x90;
 
511
        }
555
512
    }
556
513
  r = sanei_genesys_get_address (regs, 0x9e);
557
514
  if (r)
593
550
{
594
551
  DBGSTART;
595
552
 
596
 
  memset (dev->reg, 0,
597
 
          GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
 
553
  memset (dev->reg, 0, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
598
554
 
599
555
  /* default to KV-SS080 */
600
556
  SETREG (0xa2, 0x0f);
608
564
  SETREG (0x09, 0x00);
609
565
  SETREG (0x0a, 0x00);
610
566
  SETREG (0x0b, 0x6a);
611
 
  SETREG (0x0c, 0x00);
612
567
  SETREG (0x10, 0x00);
613
568
  SETREG (0x11, 0x00);
614
569
  SETREG (0x12, 0x00);
691
646
  SETREG (0x7d, 0x00);
692
647
  SETREG (0x7f, 0x00);
693
648
  SETREG (0x80, 0x00);
694
 
  SETREG (0x81, 0x00);
695
 
  SETREG (0x82, 0x00);
696
 
  SETREG (0x83, 0x00);
697
 
  SETREG (0x84, 0x00);
698
 
  SETREG (0x85, 0x00);
699
 
  SETREG (0x86, 0x00);
 
649
  if (strcmp (dev->model->name, "canon-canoscan-4400f") != 0)
 
650
    {
 
651
      SETREG (0x81, 0x00);
 
652
      SETREG (0x82, 0x00);
 
653
      SETREG (0x83, 0x00);
 
654
      SETREG (0x84, 0x00);
 
655
      SETREG (0x85, 0x00);
 
656
      SETREG (0x86, 0x00);
 
657
    }
700
658
  SETREG (0x87, 0x00);
701
659
  SETREG (0x9d, 0x04);
702
 
  SETREG (0x94, 0xff);
703
660
  SETREG (0x9e, 0x00);
704
 
  SETREG (0xab, 0x50);
 
661
  if (strcmp (dev->model->name, "canon-canoscan-8400f") != 0)
 
662
    {
 
663
      SETREG (0x0c, 0x00);
 
664
      SETREG (0x94, 0xff);
 
665
      SETREG (0xab, 0x50);
 
666
    }
705
667
     
706
668
  /* so many time burnt for this register ....*/
707
 
  SETREG (0xaa, 0x00);
 
669
  if (strcmp (dev->model->name, "canon-canoscan-4400f") != 0
 
670
    &&strcmp (dev->model->name, "canon-canoscan-8400f") != 0)
 
671
    {
 
672
      SETREG (0xaa, 0x00);
 
673
    }
708
674
 
709
675
  /* G4050 values */
710
676
  if ((strcmp (dev->model->name, "hewlett-packard-scanjet-g4050") == 0)
744
710
      SETREG (0x9b, 0x80);
745
711
      SETREG (0xac, 0x00);
746
712
    }
 
713
  
 
714
  if (strcmp (dev->model->name, "canon-canoscan-4400f") == 0)
 
715
    {
 
716
      SETREG (0x06, 0xf0); /* SCANMOD=111, PWRBIT and no GAIN4 */
 
717
      SETREG (0x0b, 0x69); /* 16M only */
 
718
      SETREG (0x1e, 0x20);
 
719
      SETREG (0x22, 0xc8);
 
720
      SETREG (0x23, 0xc8);
 
721
      SETREG (0x5e, 0x3f);
 
722
      SETREG (0x5f, 0xf0);
 
723
      SETREG (0x6b, 0x72);
 
724
      SETREG (0x72, 0x01);
 
725
      SETREG (0x73, 0x03);
 
726
      SETREG (0x80, 0x0c);
 
727
      SETREG (0x87, 0x02);      /* MCLOCK -> CK4MAP */
 
728
      SETREG (0x9d, 0x08);      /* STEPTIM=2        */
 
729
      SETREG (0xa2, 0x1f);
 
730
      SETREG (0xab, 0x00);
 
731
      sanei_genesys_set_double(dev->reg,REG_EXPR,0x9c40);
 
732
      sanei_genesys_set_double(dev->reg,REG_EXPG,0x9c40);
 
733
      sanei_genesys_set_double(dev->reg,REG_EXPB,0x9c40);
 
734
    }
 
735
  
 
736
  if (strcmp (dev->model->name, "canon-canoscan-8400f") == 0)
 
737
    {
 
738
      SETREG (0x03, 0x1c);
 
739
      SETREG (0x06, 0xd0); /* SCANMOD=110, PWRBIT and no GAIN4 */
 
740
      SETREG (0x0a, 0x10);
 
741
      SETREG (0x22, 0x50);
 
742
      SETREG (0x23, 0x50);
 
743
      SETREG (0x5e, 0x85);
 
744
      SETREG (0x6b, 0xb1);
 
745
      SETREG (0x1e, 0xa0);
 
746
      SETREG (0x72, 0x03);
 
747
      SETREG (0x73, 0x04);
 
748
      SETREG (0x7d, 0x20);
 
749
      SETREG (0x80, 0x28);
 
750
      SETREG (0x87, 0x02);      /* MCLOCK -> CK4MAP */
 
751
      SETREG (0x9d, 0x08);      /* STEPTIM=2        */
 
752
    }
747
753
 
748
754
  /* fine tune upon device description */
749
755
  dev->reg[reg_0x05].value &= ~REG05_DPIHW;
764
770
    }
765
771
 
766
772
  /* initalize calibration reg */
767
 
  memcpy (dev->calib_reg, dev->reg,
768
 
          GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
 
773
  memcpy (dev->calib_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
769
774
 
770
775
  DBGCOMPLETED;
771
776
}
783
788
  SANE_Status status;
784
789
  uint8_t *table;
785
790
  int i;
786
 
  char msg[2048 * 4];
 
791
  char msg[10000];
787
792
 
788
793
  DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __FUNCTION__,
789
794
       table_nr, steps);
800
805
      sprintf (msg, "write slope %d (%d)=", table_nr, steps);
801
806
      for (i = 0; i < steps; i++)
802
807
        {
803
 
          sprintf (msg, "%s,%d", msg, slope_table[i]);
 
808
          sprintf (msg+strlen(msg), "%d", slope_table[i]);
804
809
        }
805
810
      DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
806
811
    }
807
812
 
 
813
 
808
814
  /* slope table addresses are fixed : 0x4000,  0x4800,  0x5000,  0x5800,  0x6000 */
809
 
  /* XXX STEF XXX USB 1.1 ? write_end_access (dev, 0x0f, 0x14); */
 
815
  /* XXX STEF XXX USB 1.1 ? sanei_genesys_write_0x8c (dev, 0x0f, 0x14); */
810
816
  status = write_data (dev, 0x4000 + 0x800 * table_nr, steps * 2, table);
811
817
  if (status != SANE_STATUS_GOOD)
812
818
    {
816
822
    }
817
823
 
818
824
  free (table);
819
 
  DBG (DBG_proc, "%s: completed\n", __FUNCTION__);
 
825
  DBGCOMPLETED;
820
826
  return status;
821
827
}
822
828
 
926
932
{
927
933
  SANE_Status status;
928
934
  int use_fast_fed, coeff;
929
 
  unsigned int fast_time;
930
 
  unsigned int slow_time;
931
935
  unsigned int lincnt;
932
936
  uint16_t scan_table[1024];
933
937
  uint16_t fast_table[1024];
976
980
    r->value |= REG02_ACDCDIS;
977
981
 
978
982
  /* scan and backtracking slope table */
979
 
  slow_time=sanei_genesys_slope_table(scan_table,
980
 
                                      &scan_steps,
981
 
                                      scan_yres,
982
 
                                      exposure,
983
 
                                      dev->motor.base_ydpi,
984
 
                                      scan_step_type,
985
 
                                      factor,
986
 
                                      dev->model->motor_type,
987
 
                                      gl843_motors);
 
983
  sanei_genesys_slope_table(scan_table,
 
984
                            &scan_steps,
 
985
                            scan_yres,
 
986
                            exposure,
 
987
                            dev->motor.base_ydpi,
 
988
                            scan_step_type,
 
989
                            factor,
 
990
                            dev->model->motor_type,
 
991
                            gl843_motors);
988
992
  RIE(gl843_send_slope_table (dev, SCAN_TABLE, scan_table, scan_steps*factor));
989
993
  RIE(gl843_send_slope_table (dev, BACKTRACK_TABLE, scan_table, scan_steps*factor));
990
994
 
1002
1006
    {
1003
1007
      fast_step_type=scan_step_type;
1004
1008
    }
1005
 
  fast_time=sanei_genesys_slope_table(fast_table,
1006
 
                                      &fast_steps,
1007
 
                                      sanei_genesys_get_lowest_ydpi(dev),
1008
 
                                      exposure,
1009
 
                                      dev->motor.base_ydpi,
1010
 
                                      fast_step_type,
1011
 
                                      factor,
1012
 
                                      dev->model->motor_type,
1013
 
                                      gl843_motors);
 
1009
  sanei_genesys_slope_table(fast_table,
 
1010
                            &fast_steps,
 
1011
                            sanei_genesys_get_lowest_ydpi(dev),
 
1012
                            exposure,
 
1013
                            dev->motor.base_ydpi,
 
1014
                            fast_step_type,
 
1015
                            factor,
 
1016
                            dev->model->motor_type,
 
1017
                            gl843_motors);
1014
1018
  RIE(gl843_send_slope_table (dev, STOP_TABLE, fast_table, fast_steps*factor));
1015
1019
  RIE(gl843_send_slope_table (dev, FAST_TABLE, fast_table, fast_steps*factor));
1016
1020
  RIE(gl843_send_slope_table (dev, HOME_TABLE, fast_table, fast_steps*factor));
1081
1085
 
1082
1086
  /* Vref XXX STEF XXX : optical divider or step type ? */
1083
1087
  r = sanei_genesys_get_address (reg, 0x80);
1084
 
  r->value = 0x50;
1085
 
  coeff=dev->sensor.optical_res/sanei_genesys_compute_dpihw(dev, scan_yres);
1086
 
  if (dev->model->motor_type == MOTOR_KVSS080) 
 
1088
  if (!(dev->model->flags & GENESYS_FLAG_FULL_HWDPI_MODE))
1087
1089
    {
1088
 
      if(coeff>=1)
 
1090
      r->value = 0x50;
 
1091
      coeff=dev->sensor.optical_res/sanei_genesys_compute_dpihw(dev, scan_yres);
 
1092
      if (dev->model->motor_type == MOTOR_KVSS080) 
1089
1093
        {
1090
 
          r->value |= 0x05;
 
1094
          if(coeff>=1)
 
1095
            {
 
1096
              r->value |= 0x05;
 
1097
            }
 
1098
        }
 
1099
      else {
 
1100
        switch(coeff)
 
1101
          {
 
1102
          case 4:
 
1103
              r->value |= 0x0a;
 
1104
              break;
 
1105
          case 2:
 
1106
              r->value |= 0x0f;
 
1107
              break;
 
1108
          case 1:
 
1109
              r->value |= 0x0f;
 
1110
              break;
 
1111
          }
1091
1112
        }
1092
1113
    }
1093
 
  else {
1094
 
    switch(coeff)
1095
 
      {
1096
 
      case 4:
1097
 
          r->value |= 0x0a;
1098
 
          break;
1099
 
      case 2:
1100
 
          r->value |= 0x0f;
1101
 
          break;
1102
 
      case 1:
1103
 
          r->value |= 0x0f;
1104
 
          break;
1105
 
      }
1106
 
  }
1107
 
 
1108
1114
 
1109
1115
  DBGCOMPLETED;
1110
1116
  return SANE_STATUS_GOOD;
1125
1131
/** @brief setup optical related registers
1126
1132
 * start and pixels are expressed in optical sensor resolution coordinate
1127
1133
 * space. 
 
1134
 * @param dev device to use
 
1135
 * @param reg registers to set up
1128
1136
 * @param exposure exposure time to use
1129
1137
 * @param used_res scanning resolution used, may differ from
1130
1138
 *        scan's one
1131
1139
 * @param start logical start pixel coordinate
1132
1140
 * @param pixels logical number of pixels to use
 
1141
 * @param channels number of color channles used (1 or 3)
 
1142
 * @param depth bit depth of the scan (1, 8 or 16 bits)
 
1143
 * @param half_ccd SANE_TRUE if timings are such that x coordiantes must be halved
 
1144
 * @param color_filter to choose the color channel used in gray scans
1133
1145
 * @param flags to drive specific settings such no calibration, XPA use ...
1134
1146
 * @return SANE_STATUS_GOOD if OK
1135
1147
 */
1314
1326
  else
1315
1327
    r->value |= REG05_GMMENB;
1316
1328
 
1317
 
  sanei_genesys_set_double(reg,REG_DPISET,dpiset);
1318
 
  DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
 
1329
  if(half_ccd)
 
1330
    {
 
1331
      sanei_genesys_set_double(reg,REG_DPISET,dpiset*4);
 
1332
      DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset*4);
 
1333
    }
 
1334
  else
 
1335
    {
 
1336
      sanei_genesys_set_double(reg,REG_DPISET,dpiset);
 
1337
      DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
 
1338
    }
1319
1339
 
1320
1340
  sanei_genesys_set_double(reg,REG_STRPIXEL,startx/tgtime);
1321
1341
  sanei_genesys_set_double(reg,REG_ENDPIXEL,endx/tgtime);
1413
1433
 
1414
1434
 
1415
1435
  /* we have 2 domains for ccd: xres below or above half ccd max dpi */
1416
 
  if (dev->sensor.optical_res < 2 * xres ||
 
1436
  if (dev->sensor.optical_res < 4 * xres ||
1417
1437
      !(dev->model->flags & GENESYS_FLAG_HALF_CCD_MODE))
1418
1438
    {
1419
1439
      half_ccd = SANE_FALSE;
1426
1446
  /* optical_res */
1427
1447
  optical_res = dev->sensor.optical_res;
1428
1448
  if (half_ccd)
1429
 
    optical_res /= 2;
 
1449
    optical_res /= 4;
1430
1450
 
1431
1451
  /* stagger starting at 2400, and not applied for calibration */
1432
1452
  stagger = 0;
1672
1692
  float startx;                 /*optical_res, from dummy_pixel+1 */
1673
1693
  float pixels;
1674
1694
  float lines;
1675
 
  int color_filter;
1676
1695
 
1677
1696
  int used_res;
1678
1697
  int used_pixels;
1680
1699
  int exposure;
1681
1700
  int stagger;
1682
1701
 
1683
 
  int slope_dpi = 0;
1684
 
  int dummy = 0;
1685
 
  int scan_step_type = 1;
1686
1702
  int max_shift;
1687
1703
 
1688
1704
  SANE_Bool half_ccd;           /* false: full CCD res is used, true, half max CCD res is used */
1728
1744
  startx = start;
1729
1745
  pixels = dev->settings.pixels;
1730
1746
  lines = dev->settings.lines;
1731
 
  color_filter = dev->settings.color_filter;
1732
 
 
1733
1747
 
1734
1748
  DBG (DBG_info,
1735
1749
       "gl843_calculate_current_setup settings:\n"
1742
1756
 
1743
1757
/* half_ccd */
1744
1758
  /* we have 2 domains for ccd: xres below or above half ccd max dpi */
1745
 
  if ((dev->sensor.optical_res < 2 * xres) ||
 
1759
  if ((dev->sensor.optical_res < 4 * xres) ||
1746
1760
      !(dev->model->flags & GENESYS_FLAG_HALF_CCD_MODE))
1747
1761
    {
1748
1762
      half_ccd = SANE_FALSE;
1756
1770
  /* optical_res */
1757
1771
  optical_res = dev->sensor.optical_res;
1758
1772
  if (half_ccd)
1759
 
    optical_res /= 2;
 
1773
    optical_res /= 4;
1760
1774
 
1761
1775
  /* stagger */
1762
1776
  if ((!half_ccd) && (dev->model->flags & GENESYS_FLAG_STAGGERED_LINE))
1777
1791
  /* compute correct pixels number */
1778
1792
  used_pixels = (pixels * optical_res) / xres;
1779
1793
  DBG (DBG_info, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
1780
 
  dummy = 0;
1781
 
 
1782
 
  /* slope_dpi */
1783
 
  /* cis color scan is effectively a gray scan with 3 gray lines per color
1784
 
   line and a FILTER of 0 */
1785
 
  if (dev->model->is_cis)
1786
 
    slope_dpi = yres * channels;
1787
 
  else
1788
 
    slope_dpi = yres;
1789
1794
 
1790
1795
  /* exposure */
1791
1796
  exposure = gl843_compute_exposure (dev, used_res, oflags);
1792
 
 
1793
 
  /* scan_step_type */
1794
 
  scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure);
1795
1797
  DBG (DBG_info, "%s : exposure=%d pixels\n", __FUNCTION__, exposure);
1796
1798
 
1797
1799
  /* it seems base_dpi of the G4050 motor is changed above 600 dpi*/
1885
1887
 
1886
1888
/**
1887
1889
 * for fast power saving methods only, like disabling certain amplifiers
1888
 
 * @param device device to use
 
1890
 * @param dev device to use
1889
1891
 * @param enable true to set inot powersaving
1890
1892
 * */
1891
1893
static SANE_Status
2323
2325
  dpihw = sanei_genesys_compute_dpihw (dev, dpiset);
2324
2326
 
2325
2327
  /* set up GPIO for scan */
2326
 
  /* KV case */
2327
 
  if (dev->model->gpo_type == GPO_KVSS080)
2328
 
    {
2329
 
      RIE (sanei_genesys_write_register (dev, REGA9, 0x00));
2330
 
      RIE (sanei_genesys_write_register (dev, REGA6, 0xf6));
2331
 
      /* blinking led */
2332
 
      RIE (sanei_genesys_write_register (dev, 0x7e, 0x04));
2333
 
    }
2334
 
  if (dev->model->gpo_type == GPO_G4050)
2335
 
    {
2336
 
      RIE (sanei_genesys_write_register (dev, REGA7, 0xfe));
2337
 
      RIE (sanei_genesys_write_register (dev, REGA8, 0x3e));
2338
 
      RIE (sanei_genesys_write_register (dev, REGA9, 0x06));
2339
 
      switch (dpihw)
2340
 
        {
2341
 
        case 1200:
2342
 
        case 2400:
2343
 
        case 4800:
2344
 
          RIE (sanei_genesys_write_register (dev, REG6C, 0x60));
2345
 
          RIE (sanei_genesys_write_register (dev, REGA6, 0x46));
2346
 
          break;
2347
 
        default:                /* 600 dpi  case */
2348
 
          RIE (sanei_genesys_write_register (dev, REG6C, 0x20));
2349
 
          RIE (sanei_genesys_write_register (dev, REGA6, 0x44));
2350
 
        }
2351
 
 
2352
 
      /* turn on XPA lamp if XPA is selected and lamp power on*/
2353
 
      r03 = sanei_genesys_read_reg_from_set (reg, REG03);
2354
 
      if ((r03 & REG03_XPASEL) && (r03 & REG03_LAMPPWR))
2355
 
        {
2356
 
          RIE(gl843_xpa_lamp_on(dev));
2357
 
        }
2358
 
 
2359
 
      /* enable XPA lamp motor */
2360
 
      if (r03 & REG03_XPASEL)
2361
 
        {
2362
 
          RIE(gl843_xpa_motor_on(dev));
2363
 
        }
2364
 
 
2365
 
      /* blinking led */
2366
 
      RIE (sanei_genesys_write_register (dev, REG7E, 0x01));
 
2328
  switch(dev->model->gpo_type)
 
2329
    {
 
2330
      /* KV case */
 
2331
      case GPO_KVSS080:
 
2332
        RIE (sanei_genesys_write_register (dev, REGA9, 0x00));
 
2333
        RIE (sanei_genesys_write_register (dev, REGA6, 0xf6));
 
2334
        /* blinking led */
 
2335
        RIE (sanei_genesys_write_register (dev, 0x7e, 0x04));
 
2336
        break;
 
2337
      case GPO_G4050:
 
2338
        RIE (sanei_genesys_write_register (dev, REGA7, 0xfe));
 
2339
        RIE (sanei_genesys_write_register (dev, REGA8, 0x3e));
 
2340
        RIE (sanei_genesys_write_register (dev, REGA9, 0x06));
 
2341
        switch (dpihw)
 
2342
          {
 
2343
           case 1200:
 
2344
           case 2400:
 
2345
           case 4800:
 
2346
             RIE (sanei_genesys_write_register (dev, REG6C, 0x60));
 
2347
             RIE (sanei_genesys_write_register (dev, REGA6, 0x46));
 
2348
             break;
 
2349
           default:             /* 600 dpi  case */
 
2350
             RIE (sanei_genesys_write_register (dev, REG6C, 0x20));
 
2351
             RIE (sanei_genesys_write_register (dev, REGA6, 0x44));
 
2352
          }
 
2353
 
 
2354
        /* turn on XPA lamp if XPA is selected and lamp power on*/
 
2355
        r03 = sanei_genesys_read_reg_from_set (reg, REG03);
 
2356
        if ((r03 & REG03_XPASEL) && (r03 & REG03_LAMPPWR))
 
2357
          {
 
2358
            RIE(gl843_xpa_lamp_on(dev));
 
2359
          }
 
2360
 
 
2361
        /* enable XPA lamp motor */
 
2362
        if (r03 & REG03_XPASEL)
 
2363
          {
 
2364
            RIE(gl843_xpa_motor_on(dev));
 
2365
          }
 
2366
 
 
2367
        /* blinking led */
 
2368
        RIE (sanei_genesys_write_register (dev, REG7E, 0x01));
 
2369
        break;
 
2370
      case GPO_CS4400F:
 
2371
      case GPO_CS8400F:
 
2372
      default:
 
2373
        break;
2367
2374
    }
2368
2375
 
2369
2376
  /* clear scan and feed count */
2456
2463
  DBGSTART;
2457
2464
 
2458
2465
  /* copy scan settings */
2459
 
  memset (local_reg, 0, sizeof (local_reg));
2460
2466
  memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
2461
2467
 
2462
2468
  /* set a huge feedl and reverse direction */
2472
2478
  r->value &= ~REG01_SCAN;
2473
2479
 
2474
2480
  /* write to scanner and start action */
2475
 
  RIE (gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
 
2481
  RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
2476
2482
  RIE (gl843_xpa_motor_on(dev));
2477
2483
  status = gl843_start_action (dev);
2478
2484
  if (status != SANE_STATUS_GOOD)
2480
2486
      DBG (DBG_error, "%s: failed to start motor: %s\n",__FUNCTION__, sane_strstatus (status));
2481
2487
      gl843_stop_action (dev);
2482
2488
      /* restore original registers */
2483
 
      gl843_bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
 
2489
      dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
2484
2490
      return status;
2485
2491
    }
2486
2492
 
2582
2588
      return SANE_STATUS_GOOD;
2583
2589
    }
2584
2590
 
2585
 
  memset (local_reg, 0, sizeof (local_reg));
2586
2591
  memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
2587
2592
  resolution=sanei_genesys_get_lowest_ydpi(dev);
2588
2593
 
2612
2617
  r = sanei_genesys_get_address (local_reg, REG01);
2613
2618
  r->value &= ~REG01_SCAN;
2614
2619
 
2615
 
  RIE (gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
 
2620
  RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
2616
2621
 
2617
2622
  status = gl843_start_action (dev);
2618
2623
  if (status != SANE_STATUS_GOOD)
2622
2627
           sane_strstatus (status));
2623
2628
      gl843_stop_action (dev);
2624
2629
      /* restore original registers */
2625
 
      gl843_bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
 
2630
      dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
2626
2631
      return status;
2627
2632
    }
2628
2633
 
2682
2687
 
2683
2688
  DBG (DBG_proc, "gl843_search_start_position\n");
2684
2689
 
2685
 
  memset (local_reg, 0, sizeof (local_reg));
2686
 
  memcpy (local_reg, dev->reg,
2687
 
          GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
 
2690
  memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
2688
2691
 
2689
2692
  /* sets for a 200 lines * 600 pixels */
2690
2693
  /* normal scan with no shading */
2705
2708
                                 SCAN_FLAG_DISABLE_GAMMA |
2706
2709
                                 SCAN_FLAG_IGNORE_LINE_DISTANCE |
2707
2710
                                 SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE);
 
2711
  if (status != SANE_STATUS_GOOD)
 
2712
    {
 
2713
      DBG (DBG_error,
 
2714
           "gl843_search_start_position: failed to bulk setup registers: %s\n",
 
2715
           sane_strstatus (status));
 
2716
      return status;
 
2717
    }
2708
2718
 
2709
2719
  /* send to scanner */
2710
 
  status = gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
 
2720
  status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
2711
2721
  if (status != SANE_STATUS_GOOD)
2712
2722
    {
2713
2723
      DBG (DBG_error,
2767
2777
    }
2768
2778
 
2769
2779
  /* update regs to copy ASIC internal state */
2770
 
  memcpy (dev->reg, local_reg,
2771
 
          GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
 
2780
  memcpy (dev->reg, local_reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
2772
2781
 
2773
2782
  status =
2774
2783
    sanei_genesys_search_reference_point (dev, data, 0, dpi, pixels,
2835
2844
       "gl843_init_register_for_coarse_calibration: optical sensor res: %d dpi, actual res: %d\n",
2836
2845
       dev->sensor.optical_res / cksel, dev->settings.xres);
2837
2846
 
2838
 
  status = gl843_bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
 
2847
  status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
2839
2848
  if (status != SANE_STATUS_GOOD)
2840
2849
    {
2841
2850
      DBG (DBG_error,
2867
2876
  DBGSTART;
2868
2877
 
2869
2878
  /* prepare local registers */
2870
 
  memset (local_reg, 0, sizeof (local_reg));
2871
2879
  memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
2872
2880
 
2873
2881
  resolution=sanei_genesys_get_lowest_ydpi(dev);
2897
2905
  r->value &= ~REG01_SCAN;
2898
2906
  
2899
2907
  /* send registers */
2900
 
  RIE (gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
 
2908
  RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
2901
2909
 
2902
2910
  status = gl843_start_action (dev);
2903
2911
  if (status != SANE_STATUS_GOOD)
2906
2914
      gl843_stop_action (dev);
2907
2915
 
2908
2916
      /* restore original registers */
2909
 
      gl843_bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
 
2917
      dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
2910
2918
      return status;
2911
2919
    }
2912
2920
 
2978
2986
  sanei_genesys_get_double(dev->calib_reg,REG_STRPIXEL,&strpixel);
2979
2987
  DBG (DBG_info, "%s: STRPIXEL=%d\n", __FUNCTION__, strpixel);
2980
2988
 
2981
 
  status = gl843_bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
 
2989
  status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
2982
2990
  if (status != SANE_STATUS_GOOD)
2983
2991
    {
2984
2992
      DBG (DBG_error,
3072
3080
  return SANE_STATUS_GOOD;
3073
3081
}
3074
3082
 
3075
 
/*
3076
 
 * this function sends generic gamma table (ie linear ones)
3077
 
 * or the Sensor specific one if provided
 
3083
/** 
 
3084
 * This function sends gamma tables to ASIC
3078
3085
 */
3079
3086
static SANE_Status
3080
 
gl843_send_gamma_table (Genesys_Device * dev, SANE_Bool generic)
 
3087
gl843_send_gamma_table (Genesys_Device * dev)
3081
3088
{
3082
3089
  int size;
3083
3090
  int status;
3084
3091
  uint8_t *gamma;
3085
 
  int i, gmmval;
3086
 
 
3087
 
  DBG (DBG_proc, "gl843_send_gamma_table\n");
3088
 
 
3089
 
  /* don't send anything if no specific gamma table defined */
3090
 
  if (!generic
3091
 
      && (dev->sensor.red_gamma_table == NULL
3092
 
          || dev->sensor.green_gamma_table == NULL
3093
 
          || dev->sensor.blue_gamma_table == NULL))
3094
 
    {
3095
 
      DBG (DBG_proc, "gl843_send_gamma_table: nothing to send, skipping\n");
3096
 
      return SANE_STATUS_GOOD;
3097
 
    }
 
3092
  int i;
 
3093
 
 
3094
  DBGSTART;
3098
3095
 
3099
3096
  size = 256;
3100
3097
 
3103
3100
  if (!gamma)
3104
3101
    return SANE_STATUS_NO_MEM;
3105
3102
 
3106
 
  /* take care off generic/specific data */
3107
 
  if (generic)
3108
 
    {
3109
 
      /* fill with default values */
3110
 
      for (i = 0; i < size; i++)
3111
 
        {
3112
 
          gmmval = i * 256;
3113
 
          gamma[i * 2 + size * 0 + 0] = gmmval & 0xff;
3114
 
          gamma[i * 2 + size * 0 + 1] = (gmmval >> 8) & 0xff;
3115
 
          gamma[i * 2 + size * 2 + 0] = gmmval & 0xff;
3116
 
          gamma[i * 2 + size * 2 + 1] = (gmmval >> 8) & 0xff;
3117
 
          gamma[i * 2 + size * 4 + 0] = gmmval & 0xff;
3118
 
          gamma[i * 2 + size * 4 + 1] = (gmmval >> 8) & 0xff;
3119
 
        }
3120
 
    }
3121
 
  else
3122
 
    {
3123
 
      /* copy sensor specific's gamma tables */
3124
 
      for (i = 0; i < size; i++)
3125
 
        {
3126
 
          gamma[i * 2 + size * 0 + 0] = dev->sensor.red_gamma_table[i] & 0xff;
3127
 
          gamma[i * 2 + size * 0 + 1] =
3128
 
            (dev->sensor.red_gamma_table[i] >> 8) & 0xff;
3129
 
          gamma[i * 2 + size * 2 + 0] =
3130
 
            dev->sensor.green_gamma_table[i] & 0xff;
3131
 
          gamma[i * 2 + size * 2 + 1] =
3132
 
            (dev->sensor.green_gamma_table[i] >> 8) & 0xff;
3133
 
          gamma[i * 2 + size * 4 + 0] =
3134
 
            dev->sensor.blue_gamma_table[i] & 0xff;
3135
 
          gamma[i * 2 + size * 4 + 1] =
3136
 
            (dev->sensor.blue_gamma_table[i] >> 8) & 0xff;
3137
 
        }
 
3103
  /* copy sensor specific's gamma tables */
 
3104
  for (i = 0; i < size; i++)
 
3105
    {
 
3106
      gamma[i * 2 + size * 0 + 0] = dev->sensor.gamma_table[GENESYS_RED][i] & 0xff;
 
3107
      gamma[i * 2 + size * 0 + 1] = (dev->sensor.gamma_table[GENESYS_RED][i] >> 8) & 0xff;
 
3108
      gamma[i * 2 + size * 2 + 0] = dev->sensor.gamma_table[GENESYS_GREEN][i] & 0xff;
 
3109
      gamma[i * 2 + size * 2 + 1] = (dev->sensor.gamma_table[GENESYS_GREEN][i] >> 8) & 0xff;
 
3110
      gamma[i * 2 + size * 4 + 0] = dev->sensor.gamma_table[GENESYS_BLUE][i] & 0xff;
 
3111
      gamma[i * 2 + size * 4 + 1] = (dev->sensor.gamma_table[GENESYS_BLUE][i] >> 8) & 0xff;
3138
3112
    }
3139
3113
 
3140
3114
  /* send address */
3226
3200
      return status;
3227
3201
    }
3228
3202
 
3229
 
  RIE (gl843_bulk_write_register
 
3203
  RIE (dev->model->cmd_set->bulk_write_register
3230
3204
       (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
3231
3205
 
3232
3206
 
3266
3240
          r->value = dev->sensor.regs_0x10_0x1d[i];
3267
3241
        }
3268
3242
 
3269
 
      RIE (gl843_bulk_write_register
 
3243
      RIE (dev->model->cmd_set->bulk_write_register
3270
3244
           (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
3271
3245
 
3272
3246
      DBG (DBG_info, "gl843_led_calibration: starting first line reading\n");
3476
3450
      dev->frontend.offset[i] = bottom[i];
3477
3451
      dev->frontend.gain[i] = 0;
3478
3452
    }
3479
 
  RIE (gl843_set_fe (dev, AFE_SET));
 
3453
  RIEF2 (gl843_set_fe (dev, AFE_SET), first_line, second_line);
3480
3454
 
3481
3455
  /* scan with obttom AFE settings */
3482
 
  RIE (gl843_bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
 
3456
  RIEF2 (dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS), first_line, second_line);
3483
3457
  DBG (DBG_info, "gl843_offset_calibration: starting first line reading\n");
3484
 
  RIE (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
3485
 
  RIE (sanei_genesys_read_data_from_scanner (dev, first_line, total_size));
 
3458
  RIEF2 (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE), first_line, second_line);
 
3459
  RIEF2 (sanei_genesys_read_data_from_scanner (dev, first_line, total_size), first_line, second_line);
3486
3460
  if (DBG_LEVEL >= DBG_data)
3487
3461
    {
3488
3462
      for (i = 0; i < 3; i++)
3504
3478
      top[i] = 255;
3505
3479
      dev->frontend.offset[i] = top[i];
3506
3480
    }
3507
 
  RIE (gl843_set_fe (dev, AFE_SET));
 
3481
  RIEF2 (gl843_set_fe (dev, AFE_SET), first_line, second_line);
3508
3482
 
3509
3483
  /* scan with top AFE values */
3510
 
  RIE (gl843_bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
 
3484
  RIEF2 (dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS), first_line, second_line);
3511
3485
  DBG (DBG_info, "gl843_offset_calibration: starting second line reading\n");
3512
 
  RIE (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
3513
 
  RIE (sanei_genesys_read_data_from_scanner (dev, second_line, total_size));
 
3486
  RIEF2 (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE), first_line, second_line);
 
3487
  RIEF2 (sanei_genesys_read_data_from_scanner (dev, second_line, total_size), first_line, second_line);
3514
3488
 
3515
3489
  for (i = 0; i < 3; i++)
3516
3490
    {
3535
3509
              dev->frontend.offset[i] = (top[i] + bottom[i]) / 2;
3536
3510
            }
3537
3511
        }
3538
 
      RIE (gl843_set_fe (dev, AFE_SET));
 
3512
      RIEF2 (gl843_set_fe (dev, AFE_SET), first_line, second_line);
3539
3513
 
3540
3514
      /* scan with no move */
3541
 
      RIE (gl843_bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
 
3515
      RIEF2 (dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS), first_line, second_line);
3542
3516
      DBG (DBG_info, "gl843_offset_calibration: starting second line reading\n");
3543
 
      RIE (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
3544
 
      RIE (sanei_genesys_read_data_from_scanner (dev, second_line, total_size));
 
3517
      RIEF2 (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE), first_line, second_line);
 
3518
      RIEF2 (sanei_genesys_read_data_from_scanner (dev, second_line, total_size), first_line, second_line);
3545
3519
 
3546
3520
      if (DBG_LEVEL >= DBG_data)
3547
3521
        {
3664
3638
      return status;
3665
3639
    }
3666
3640
 
3667
 
  RIE (gl843_bulk_write_register
 
3641
  RIE (dev->model->cmd_set->bulk_write_register
3668
3642
       (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
3669
3643
 
3670
3644
  total_size = pixels * channels * (16/bpp) * lines;
3673
3647
  if (!line)
3674
3648
    return SANE_STATUS_NO_MEM;
3675
3649
 
3676
 
  RIE (gl843_set_fe(dev, AFE_SET));
3677
 
  RIE (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
3678
 
  RIE (sanei_genesys_read_data_from_scanner (dev, line, total_size));
 
3650
  RIEF (gl843_set_fe(dev, AFE_SET), line);
 
3651
  RIEF (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE), line);
 
3652
  RIEF (sanei_genesys_read_data_from_scanner (dev, line, total_size), line);
3679
3653
 
3680
3654
  if (DBG_LEVEL >= DBG_data)
3681
3655
    sanei_genesys_write_pnm_file ("coarse.pnm", line, bpp, channels, pixels, lines);
3743
3717
 
3744
3718
  RIE (gl843_stop_action (dev));
3745
3719
 
3746
 
  gl843_slow_back_home (dev, SANE_TRUE);
 
3720
  status=gl843_slow_back_home (dev, SANE_TRUE);
3747
3721
 
3748
3722
  DBGCOMPLETED;
3749
 
  return SANE_STATUS_GOOD;
 
3723
  return status;
3750
3724
}
3751
3725
 
3752
3726
/*
3801
3775
    }
3802
3776
 
3803
3777
  gl843_set_motor_power (reg, SANE_FALSE);
3804
 
  RIE (gl843_bulk_write_register (dev, reg, GENESYS_GL843_MAX_REGS));
 
3778
  RIE (dev->model->cmd_set->bulk_write_register (dev, reg, GENESYS_GL843_MAX_REGS));
3805
3779
 
3806
3780
  DBGCOMPLETED;
3807
3781
  return SANE_STATUS_GOOD;
3818
3792
gl843_init_gpio (Genesys_Device * dev)
3819
3793
{
3820
3794
  SANE_Status status = SANE_STATUS_GOOD;
3821
 
  int i;
 
3795
  int idx;
3822
3796
 
3823
3797
  DBGSTART;
3824
3798
 
3826
3800
  RIE (sanei_genesys_write_register (dev, REG6F, dev->gpo.enable[1]));
3827
3801
  RIE (sanei_genesys_write_register (dev, REG6C, dev->gpo.value[0]));
3828
3802
  RIE (sanei_genesys_write_register (dev, REG6D, dev->gpo.value[1]));
3829
 
  if ((strcmp (dev->model->name, "hewlett-packard-scanjet-g4010") == 0)
3830
 
   || (strcmp (dev->model->name, "hewlett-packard-scanjet-4850c") == 0)
3831
 
   || (strcmp (dev->model->name, "hewlett-packard-scanjet-g4050") == 0))
3832
 
    {
3833
 
      i = 0;
 
3803
 
 
3804
  idx=0;
 
3805
  while(dev->model->gpo_type != gpios[idx].gpo_type && gpios[idx].gpo_type!=0)
 
3806
    {
 
3807
      idx++;
 
3808
    }
 
3809
  if (gpios[idx].gpo_type!=0)
 
3810
    {
 
3811
      RIE (sanei_genesys_write_register (dev, REGA6, gpios[idx].ra6));
 
3812
      RIE (sanei_genesys_write_register (dev, REGA7, gpios[idx].ra7));
 
3813
      RIE (sanei_genesys_write_register (dev, REGA8, gpios[idx].ra8));
 
3814
      RIE (sanei_genesys_write_register (dev, REGA9, gpios[idx].ra9));
3834
3815
    }
3835
3816
  else
3836
3817
    {
3837
 
      i = 1;
 
3818
      status=SANE_STATUS_INVAL;
3838
3819
    }
3839
 
  RIE (sanei_genesys_write_register (dev, REGA6, gpios[i].ra6));
3840
 
  RIE (sanei_genesys_write_register (dev, REGA7, gpios[i].ra7));
3841
 
  RIE (sanei_genesys_write_register (dev, REGA8, gpios[i].ra8));
3842
 
  RIE (sanei_genesys_write_register (dev, REGA9, gpios[i].ra9));
3843
3820
 
3844
3821
  DBGCOMPLETED;
3845
3822
  return status;
3849
3826
/* *
3850
3827
 * initialize ASIC from power on condition
3851
3828
 */
3852
 
static SANE_Status
3853
 
gl843_cold_boot (Genesys_Device * dev)
 
3829
#ifndef UNIT_TESTING
 
3830
static
 
3831
#endif
 
3832
SANE_Status
 
3833
gl843_boot (Genesys_Device * dev, SANE_Bool cold)
3854
3834
{
3855
3835
  SANE_Status status;
3856
3836
  uint8_t val;
3857
3837
 
3858
3838
  DBGSTART;
3859
3839
 
3860
 
  RIE (sanei_genesys_write_register (dev, 0x0e, 0x01));
3861
 
  RIE (sanei_genesys_write_register (dev, 0x0e, 0x00));
 
3840
  if(cold)
 
3841
    {
 
3842
      RIE (sanei_genesys_write_register (dev, 0x0e, 0x01));
 
3843
      RIE (sanei_genesys_write_register (dev, 0x0e, 0x00));
 
3844
    }
 
3845
  
 
3846
  if(dev->usb_mode == 1)
 
3847
    {
 
3848
      val = 0x14;
 
3849
    }
 
3850
  else
 
3851
    {
 
3852
      val = 0x11;
 
3853
    }
 
3854
  RIE (sanei_genesys_write_0x8c (dev, 0x0f, val));
3862
3855
 
3863
3856
  /* test CHKVER */
3864
3857
  RIE (sanei_genesys_read_register (dev, REG40, &val));
3866
3859
    {
3867
3860
      RIE (sanei_genesys_read_register (dev, 0x00, &val));
3868
3861
      DBG (DBG_info,
3869
 
           "gl843_cold_boot: reported version for genesys chip is 0x%02x\n",
 
3862
           "%s: reported version for genesys chip is 0x%02x\n", __FUNCTION__,
3870
3863
           val);
3871
3864
    }
3872
3865
 
3876
3869
  RIE (sanei_genesys_write_register (dev, REG6B, 0x02));
3877
3870
 
3878
3871
  /* Write initial registers */
3879
 
  RIE (gl843_bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS));
 
3872
  RIE (dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS));
3880
3873
 
3881
3874
  /* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
3882
3875
  val = dev->reg[reg_0x0b].value & REG0B_DRAMSEL;
3884
3877
  RIE (sanei_genesys_write_register (dev, REG0B, val));
3885
3878
  dev->reg[reg_0x0b].value = val;
3886
3879
  /* URB    14  control  0x40 0x0c 0x8c 0x10 len     1 wrote 0xb4 */
3887
 
  RIE (write_end_access (dev, 0x10, 0xb4));
 
3880
  RIE (sanei_genesys_write_0x8c (dev, 0x10, 0xb4));
3888
3881
 
3889
3882
  /* CLKSET */
3890
3883
  val = (dev->reg[reg_0x0b].value & ~REG0B_CLKSET) | REG0B_48MHZ;
3905
3898
 
3906
3899
  /* setup gpio */
3907
3900
  RIE (gl843_init_gpio (dev));
 
3901
  
 
3902
  gl843_feed (dev, 300);
 
3903
  usleep (100000);
3908
3904
 
3909
3905
  DBGCOMPLETED;
3910
3906
  return SANE_STATUS_GOOD;
3921
3917
gl843_init (Genesys_Device * dev)
3922
3918
{
3923
3919
  SANE_Status status;
3924
 
  uint8_t val;
3925
 
  SANE_Bool cold = SANE_TRUE;
3926
 
  int size;
3927
3920
 
3928
3921
  DBG_INIT ();
3929
3922
  DBGSTART;
3930
3923
 
3931
 
  /* URB    16  control  0xc0 0x0c 0x8e 0x0b len     1 read  0x00 */
3932
 
  status =
3933
 
    sanei_usb_control_msg (dev->dn, REQUEST_TYPE_IN, REQUEST_REGISTER,
3934
 
                           VALUE_GET_REGISTER, 0x0b, 1, &val);
3935
 
  if (status != SANE_STATUS_GOOD)
3936
 
    {
3937
 
      DBG (DBG_error,
3938
 
           "gl843_init: request register failed %s\n",
3939
 
           sane_strstatus (status));
3940
 
      return status;
3941
 
    }
3942
 
  DBG (DBG_io2, "gl843_init: value=0x%02x\n", val);
3943
 
  DBG (DBG_info, "%s: device is %s\n", __FUNCTION__,
3944
 
       (val & 0x08) ? "USB 1.0" : "USB2.0");
3945
 
  if (val & 0x08)
3946
 
    {
3947
 
      /* URB    17  control  0x40 0x0c 0x8c 0x0f len     1 wrote 0x14  */
3948
 
      dev->usb_mode = 1;
3949
 
      val = 0x14;
3950
 
    }
3951
 
  else
3952
 
    {
3953
 
      /* URB    17  control  0x40 0x0c 0x8c 0x0f len     1 wrote 0x11  */
3954
 
      dev->usb_mode = 2;
3955
 
      val = 0x11;
3956
 
    }
3957
 
  RIE (write_end_access (dev, 0x0f, val));
3958
 
 
3959
 
  /* check if the device has already been initialized and powered up 
3960
 
   * we read register 6 and check PWRBIT, if reset scanner has been
3961
 
   * freshly powered up. This bit will be set to later so that following
3962
 
   * reads can detect power down/up cycle*/
3963
 
  RIE (sanei_genesys_read_register (dev, 0x06, &val));
3964
 
  if (val & REG06_PWRBIT)
3965
 
    {
3966
 
      cold = SANE_FALSE;
3967
 
    }
3968
 
  DBG (DBG_info, "%s: device is %s\n", __FUNCTION__, cold ? "cold" : "warm");
3969
 
 
3970
 
  /* don't do anything if backend is initialized and hardware hasn't been
3971
 
   * replug */
3972
 
  if (dev->already_initialized && !cold)
3973
 
    {
3974
 
      DBG (DBG_info, "gl843_init: already initialized, nothing to do\n");
3975
 
      return SANE_STATUS_GOOD;
3976
 
    }
3977
 
 
3978
 
  /* set up hardware and registers */
3979
 
  RIE (gl843_cold_boot (dev));
3980
 
 
3981
 
  /* move head away from park position */
3982
 
  gl843_feed (dev, 300);
3983
 
  usleep (100000);
3984
 
 
3985
 
  /* now hardware part is OK, set up device struct */
3986
 
  FREE_IFNOT_NULL (dev->white_average_data);
3987
 
  FREE_IFNOT_NULL (dev->dark_average_data);
3988
 
  FREE_IFNOT_NULL (dev->sensor.red_gamma_table);
3989
 
  FREE_IFNOT_NULL (dev->sensor.green_gamma_table);
3990
 
  FREE_IFNOT_NULL (dev->sensor.blue_gamma_table);
3991
 
 
3992
 
  dev->settings.color_filter = 0;
3993
 
 
3994
 
  memcpy (dev->calib_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
3995
 
 
3996
 
  /* Set analog frontend */
3997
 
  RIE (gl843_set_fe (dev, AFE_INIT));
3998
 
 
3999
 
  /* init gamma tables */
4000
 
  size = 256;
4001
 
  if (dev->sensor.red_gamma_table == NULL)
4002
 
    {
4003
 
      dev->sensor.red_gamma_table = (uint16_t *) malloc (2 * size);
4004
 
      if (dev->sensor.red_gamma_table == NULL)
4005
 
        {
4006
 
          DBG (DBG_error,
4007
 
               "gl843_init: could not allocate memory for gamma table\n");
4008
 
          return SANE_STATUS_NO_MEM;
4009
 
        }
4010
 
      sanei_genesys_create_gamma_table (dev->sensor.red_gamma_table, size, 65535, 65535, dev->sensor.red_gamma);
4011
 
    }
4012
 
  if (dev->sensor.green_gamma_table == NULL)
4013
 
    {
4014
 
      dev->sensor.green_gamma_table = (uint16_t *) malloc (2 * size);
4015
 
      if (dev->sensor.red_gamma_table == NULL)
4016
 
        {
4017
 
          DBG (DBG_error,
4018
 
               "gl843_init: could not allocate memory for gamma table\n");
4019
 
          return SANE_STATUS_NO_MEM;
4020
 
        }
4021
 
      sanei_genesys_create_gamma_table (dev->sensor.green_gamma_table, size, 65535, 65535, dev->sensor.green_gamma);
4022
 
    }
4023
 
  if (dev->sensor.blue_gamma_table == NULL)
4024
 
    {
4025
 
      dev->sensor.blue_gamma_table = (uint16_t *) malloc (2 * size);
4026
 
      if (dev->sensor.red_gamma_table == NULL)
4027
 
        {
4028
 
          DBG (DBG_error,
4029
 
               "gl843_init: could not allocate memory for gamma table\n");
4030
 
          return SANE_STATUS_NO_MEM;
4031
 
        }
4032
 
      sanei_genesys_create_gamma_table (dev->sensor.blue_gamma_table, size, 65535, 65535, dev->sensor.blue_gamma);
4033
 
    }
4034
 
 
4035
 
  dev->oe_buffer.buffer = NULL;
4036
 
  dev->already_initialized = SANE_TRUE;
4037
 
 
4038
 
  /* Move home if needed */
4039
 
  RIE (gl843_slow_back_home (dev, SANE_TRUE));
4040
 
  dev->scanhead_position_in_steps = 0;
4041
 
 
4042
 
  /* Set powersaving (default = 15 minutes) */
4043
 
  RIE (gl843_set_powersaving (dev, 15));
 
3924
  status=sanei_genesys_asic_init(dev, GENESYS_GL843_MAX_REGS);
4044
3925
 
4045
3926
  DBGCOMPLETED;
4046
3927
  return status;
4057
3938
 
4058
3939
  RIE (sanei_genesys_read_register (s->dev, REG6D, &val));
4059
3940
 
4060
 
  if (s->dev->model->gpo_type == GPO_KVSS080) 
4061
 
    {
4062
 
      if (s->val[OPT_SCAN_SW].b == s->last_val[OPT_SCAN_SW].b)
4063
 
        s->val[OPT_SCAN_SW].b = (val & 0x04) == 0;
4064
 
    }
4065
 
  else
4066
 
    {
4067
 
      if (s->val[OPT_SCAN_SW].b == s->last_val[OPT_SCAN_SW].b)
4068
 
        s->val[OPT_SCAN_SW].b = (val & 0x01) == 0;
4069
 
      if (s->val[OPT_FILE_SW].b == s->last_val[OPT_FILE_SW].b)
4070
 
        s->val[OPT_FILE_SW].b = (val & 0x02) == 0;
4071
 
      if (s->val[OPT_EMAIL_SW].b == s->last_val[OPT_EMAIL_SW].b)
4072
 
        s->val[OPT_EMAIL_SW].b = (val & 0x04) == 0;
4073
 
      if (s->val[OPT_COPY_SW].b == s->last_val[OPT_COPY_SW].b)
4074
 
        s->val[OPT_COPY_SW].b = (val & 0x08) == 0;
 
3941
  switch (s->dev->model->gpo_type)
 
3942
    {
 
3943
      case GPO_KVSS080:
 
3944
        if (s->val[OPT_SCAN_SW].b == s->last_val[OPT_SCAN_SW].b)
 
3945
          s->val[OPT_SCAN_SW].b = (val & 0x04) == 0;
 
3946
        break;
 
3947
      case GPO_G4050:
 
3948
        if (s->val[OPT_SCAN_SW].b == s->last_val[OPT_SCAN_SW].b)
 
3949
          s->val[OPT_SCAN_SW].b = (val & 0x01) == 0;
 
3950
        if (s->val[OPT_FILE_SW].b == s->last_val[OPT_FILE_SW].b)
 
3951
          s->val[OPT_FILE_SW].b = (val & 0x02) == 0;
 
3952
        if (s->val[OPT_EMAIL_SW].b == s->last_val[OPT_EMAIL_SW].b)
 
3953
          s->val[OPT_EMAIL_SW].b = (val & 0x04) == 0;
 
3954
        if (s->val[OPT_COPY_SW].b == s->last_val[OPT_COPY_SW].b)
 
3955
          s->val[OPT_COPY_SW].b = (val & 0x08) == 0;
 
3956
        break;
 
3957
      case GPO_CS4400F:
 
3958
      case GPO_CS8400F:
 
3959
      default:
 
3960
        break;
4075
3961
    }
4076
3962
 
4077
3963
  return status;
4145
4031
  channels = 1;
4146
4032
 
4147
4033
  /* 10 MM */
4148
 
  lines = (10 * dpi) / MM_PER_INCH;
 
4034
  /* lines = (10 * dpi) / MM_PER_INCH; */
4149
4035
  /* shading calibation is done with dev->motor.base_ydpi */
4150
4036
  lines = (dev->model->shading_lines * dpi) / dev->motor.base_ydpi;
4151
4037
  depth = 8;
4178
4064
                                 SCAN_FLAG_DISABLE_GAMMA);
4179
4065
  if (status != SANE_STATUS_GOOD)
4180
4066
    {
 
4067
      free(data);
4181
4068
      DBG (DBG_error,
4182
4069
           "gl843_search_strip: failed to setup for scan: %s\n",
4183
4070
           sane_strstatus (status));
4192
4079
    r->value |= REG02_MTRREV;
4193
4080
 
4194
4081
 
4195
 
  status = gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
 
4082
  status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
4196
4083
  if (status != SANE_STATUS_GOOD)
4197
4084
    {
 
4085
      free(data);
4198
4086
      DBG (DBG_error,
4199
4087
           "gl843_search_strip: failed to bulk write registers: %s\n",
4200
4088
           sane_strstatus (status));
4239
4127
  if (DBG_LEVEL >= DBG_data)
4240
4128
    {
4241
4129
      sprintf (title, "search_strip_%s_%s%02d.pnm",
4242
 
               black ? "black" : "white", forward ? "fwd" : "bwd", pass);
 
4130
               black ? "black" : "white", forward ? "fwd" : "bwd", (int)pass);
4243
4131
      sanei_genesys_write_pnm_file (title, data, depth, channels, pixels,
4244
4132
                                    lines);
4245
4133
    }
4249
4137
  while (pass < 20 && !found)
4250
4138
    {
4251
4139
      status =
4252
 
        gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
 
4140
        dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
4253
4141
      if (status != SANE_STATUS_GOOD)
4254
4142
        {
4255
4143
          DBG (DBG_error,
4296
4184
      if (DBG_LEVEL >= DBG_data)
4297
4185
        {
4298
4186
          sprintf (title, "search_strip_%s_%s%02d.pnm",
4299
 
                   black ? "black" : "white", forward ? "fwd" : "bwd", pass);
 
4187
                   black ? "black" : "white", forward ? "fwd" : "bwd", (int)pass);
4300
4188
          sanei_genesys_write_pnm_file (title, data, depth, channels,
4301
4189
                                        pixels, lines);
4302
4190
        }
4543
4431
 
4544
4432
  gl843_slow_back_home,
4545
4433
 
4546
 
  gl843_bulk_write_register,
 
4434
  sanei_genesys_bulk_write_register,
4547
4435
  gl843_bulk_write_data,
4548
4436
  gl843_bulk_read_data,
4549
4437
 
4557
4445
  sanei_genesys_is_compatible_calibration,
4558
4446
  gl843_move_to_ta,
4559
4447
  gl843_send_shading_data,
4560
 
  gl843_calculate_current_setup
 
4448
  gl843_calculate_current_setup,
 
4449
  gl843_boot
4561
4450
};
4562
4451
 
4563
4452
SANE_Status