summaryrefslogtreecommitdiff
path: root/backend/sm3840_scan.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/sm3840_scan.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/sm3840_scan.c')
-rwxr-xr-xbackend/sm3840_scan.c946
1 files changed, 946 insertions, 0 deletions
diff --git a/backend/sm3840_scan.c b/backend/sm3840_scan.c
new file mode 100755
index 0000000..e9442a7
--- /dev/null
+++ b/backend/sm3840_scan.c
@@ -0,0 +1,946 @@
+/* sane - Scanner Access Now Easy.
+
+ ScanMaker 3840 Backend
+ Copyright (C) 2005 Earle F. Philhower, III
+ earle@ziplabel.com - http://www.ziplabel.com
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ As a special exception, the authors of SANE give permission for
+ additional uses of the libraries contained in this release of SANE.
+
+ The exception is that, if you link a SANE library with other files
+ to produce an executable, this does not by itself cause the
+ resulting executable to be covered by the GNU General Public
+ License. Your use of that executable is in no way restricted on
+ account of linking the SANE library code into it.
+
+ This exception does not, however, invalidate any other reasons why
+ the executable file might be covered by the GNU General Public
+ License.
+
+ If you submit changes to SANE to the maintainers to be included in
+ a subsequent release, you agree by submitting the changes that
+ those changes may be distributed with this exception intact.
+
+ If you write modifications of your own for SANE, it is your choice
+ whether to permit this exception to apply to your modifications.
+ If you do not wish that, delete this exception notice.
+
+*/
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "sm3840_lib.h"
+
+#ifndef BACKENDNAME
+static void setup_scan (p_usb_dev_handle udev, SM3840_Params * p,
+ char *stname, int raw, int nohead);
+#else
+static void setup_scan (p_usb_dev_handle udev, SM3840_Params * p);
+#endif
+
+
+#ifndef BACKENDNAME
+
+#include "sm3840_lib.c"
+
+int
+main (int argc, char *argv[])
+{
+ int i;
+
+ int gray = 0;
+ int dpi = 1200;
+ int bpp16 = 0;
+ int raw = 0;
+ int nohead = 0;
+ double gain = 3.5;
+ int offset = 1800;
+ usb_dev_handle *udev;
+
+ char *stname;
+ double topin, botin, leftin, rightin;
+ int topline, scanlines, leftpix, scanpix;
+
+ stname = NULL;
+ topin = 0.0;
+ botin = 11.7;
+ leftin = 0.0;
+ rightin = 8.5;
+ for (i = 1; i < argc; i++)
+ {
+ if (!strcmp (argv[i], "-300"))
+ dpi = 300;
+ else if (!strcmp (argv[i], "-600"))
+ dpi = 600;
+ else if (!strcmp (argv[i], "-1200"))
+ dpi = 1200;
+ else if (!strcmp (argv[i], "-150"))
+ dpi = 150;
+ else if (!strcmp (argv[i], "-top"))
+ topin = atof (argv[++i]);
+ else if (!strcmp (argv[i], "-bot"))
+ botin = atof (argv[++i]);
+ else if (!strcmp (argv[i], "-left"))
+ leftin = atof (argv[++i]);
+ else if (!strcmp (argv[i], "-right"))
+ rightin = atof (argv[++i]);
+ else if (!strcmp (argv[i], "-gain"))
+ gain = atof (argv[++i]);
+ else if (!strcmp (argv[i], "-offset"))
+ offset = atoi (argv[++i]);
+ else if (!strcmp (argv[i], "-gray"))
+ gray = 1;
+ else if (!strcmp (argv[i], "-16bpp"))
+ bpp16 = 1;
+ else if (!strcmp (argv[i], "-raw"))
+ raw = 1;
+ else if (!strcmp (argv[i], "-nohead"))
+ nohead = 1;
+ else
+ stname = argv[i];
+ }
+
+ SM3840_Params params;
+ params.gray = gray;
+ params.dpi = dpi;
+ params.bpp = bpp16 ? 16 : 8;
+ params.gain = gain;
+ params.offset = offset;
+ params.lamp = 15;
+ params.top = topin;
+ params.left = leftin;
+ params.height = botin - topin;
+ params.width = rightin - leftin;
+
+ prepare_params (&params);
+ udev = find_device (0x05da, 0x30d4); /* 3840 */
+ if (!udev)
+ udev = find_device (0x05da, 0x30cf); /* 4800 */
+ if (!udev)
+ fprintf (stderr, "Unable to open scanner.\n");
+ else
+ setup_scan (udev, &params, stname, raw, nohead);
+
+ return 0;
+}
+#endif
+
+#ifndef BACKENDNAME
+static void
+setup_scan (p_usb_dev_handle udev, SM3840_Params * p,
+ char *stname, int raw, int nohead)
+#else
+static void
+setup_scan (p_usb_dev_handle udev, SM3840_Params * p)
+#endif
+{
+ int gray = p->gray ? 1 : 0;
+ int dpi = p->dpi;
+ int bpp16 = (p->bpp == 16) ? 1 : 0;
+ double gain = p->gain;
+ int offset = p->offset;
+ int topline = p->topline;
+ int scanlines = p->scanlines;
+ int leftpix = p->leftpix;
+ int scanpix = p->scanpix;
+ int len;
+ unsigned char hello[2] = { 0x55, 0xaa };
+ unsigned char howdy[3];
+ unsigned short *whitebalance;
+ int whitebalancesize = (dpi == 1200) ? 12672 : 6528;
+ unsigned short *whitemap;
+ int whitemapsize = (dpi == 1200) ? 29282 : 14642;
+ unsigned short *whitescan;
+ unsigned short *lightmap;
+ unsigned int topreg, botreg;
+ int redreg, greenreg, bluereg, donered, donegreen, doneblue;
+ int rgreg = 0x00;
+ int ggreg = 0x00;
+ int bgreg = 0x00;
+ int i, j;
+ int red, green, blue;
+ unsigned char rd_byte;
+ unsigned short GRAYMASK = 0xc000;
+
+
+#ifndef BACKENDNAME
+ char fname[64];
+ char head[128];
+
+ len = usb_set_configuration (udev, 1);
+ len = usb_claim_interface (udev, 0);
+ len = usb_clear_halt (udev, 1);
+ len = usb_clear_halt (udev, 2);
+ len = usb_clear_halt (udev, 3);
+#endif
+ DBG (2, "params.gray = %d;\n", p->gray);
+ DBG (2, "params.dpi = %d\n", p->dpi);
+ DBG (2, "params.bpp = %d\n", p->bpp);
+ DBG (2, "params.gain = %f\n", p->gain);
+ DBG (2, "params.offset = %d\n", p->offset);
+ DBG (2, "params.lamp = %d\n", p->lamp);
+ DBG (2, "params.top = %f\n", p->top);
+ DBG (2, "params.left = %f\n", p->left);
+ DBG (2, "params.height = %f\n", p->height);
+ DBG (2, "params.width = %f\n", p->width);
+
+ DBG (2, "params.topline = %d\n", p->topline);
+ DBG (2, "params.scanlines = %d\n", p->scanlines);
+ DBG (2, "params.leftpix = %d\n", p->leftpix);
+ DBG (2, "params.scanpix = %d\n", p->scanpix);
+
+ DBG (2, "params.linelen = %d\n", p->linelen);
+
+ reset_scanner (udev);
+
+ idle_ab (udev);
+ write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0b);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0f);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x05);
+ write_vctl (udev, 0x0b, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 7, 0xa8, 0x80, 0x83, 0xa2, 0x85, 0x01, 0x83, 0x82, 0x85,
+ 0x00, 0x83, 0x00, 0x93, 0x00);
+ write_regs (udev, 1, 0xa8, 0x80);
+ write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0b);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0f);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x05);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xfe, 0x83, 0x00, 0x8d, 0xff);
+ write_regs (udev, 1, 0x97, 0x00);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 8, 0x80, 0x00, 0x84, 0x00, 0xbe, 0x00, 0xc0, 0x00, 0x86,
+ 0x00, 0x89, 0x00, 0x94, 0x00, 0x01, 0x02);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ write_regs (udev, 1, 0x94, 0x51);
+ write_regs (udev, 1, 0xb0, 0x00);
+ write_regs (udev, 1, 0xb1, 0x00);
+ write_regs (udev, 1, 0xb2, 0x00);
+ write_regs (udev, 1, 0xb3, 0x00);
+ write_regs (udev, 1, 0xb4, 0x10);
+ write_regs (udev, 1, 0xb5, 0x1f);
+ write_regs (udev, 1, 0xb0, 0x00);
+ write_regs (udev, 1, 0xb1, 0x00);
+ write_regs (udev, 1, 0xb2, 0x00);
+ write_vctl (udev, 0x0c, 0x0002, 0x0002, 0x00);
+ len = usb_bulk_write (udev, 2, hello, 2, wr_timeout);
+ write_regs (udev, 1, 0xb0, 0x00);
+ write_regs (udev, 1, 0xb1, 0x00);
+ write_regs (udev, 1, 0xb2, 0x00);
+ write_vctl (udev, 0x0c, 0x0003, 0x0003, 0x00);
+ len = usb_bulk_read (udev, 1, howdy, 3, rd_timeout);
+ write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0b);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0f);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x05);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xfe, 0x83, 0x00, 0x8d, 0xff);
+ write_regs (udev, 1, 0x97, 0x00);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 8, 0x80, 0x00, 0x84, 0x00, 0xbe, 0x00, 0xc0, 0x00, 0x86,
+ 0x00, 0x89, 0x00, 0x94, 0x00, 0x01, 0x02);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xff, 0x83, 0x00, 0x8d, 0xff);
+ write_regs (udev, 5, 0x83, 0x00, 0xa3, 0xff, 0xa4, 0xff, 0xa1, 0xff, 0xa2,
+ 0xf7);
+ write_regs (udev, 4, 0x83, 0x22, 0x87, 0x01, 0x83, 0x02, 0x87, 0x16);
+ write_regs (udev, 11, 0xa0, 0x00, 0x9c, 0x00, 0x9f, 0x00, 0x9d, 0x00, 0x9e,
+ 0x00, 0xa0, 0x00, 0xce, 0x0c, 0x83, 0x20, 0xa5, 0x00, 0xa6,
+ 0x00, 0xa7, 0x00);
+
+ set_gain_black (udev, 0x01, 0x01, 0x01, 0xaa, 0xaa, 0xaa);
+
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b, 0x02, 0x98,
+ 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b, 0x03, 0x98, 0x00, 0x99,
+ 0x00, 0x9a, 0x00);
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x98, 0x83, 0x82, 0x85, 0x3a);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+
+ if (dpi == 1200)
+ write_regs (udev, 1, 0x94, 0x51);
+ else
+ write_regs (udev, 1, 0x94, 0x61);
+
+ whitemap = (unsigned short *) malloc (whitemapsize);
+
+ set_lightmap_white (whitemap, dpi, 0);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x06, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x06);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x40, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0x7f, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) whitemap, whitemapsize,
+ wr_timeout);
+
+ set_lightmap_white (whitemap, dpi, 1);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0x7f, 0xb5, 0x07);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xbf, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) whitemap, whitemapsize,
+ wr_timeout);
+
+ set_lightmap_white (whitemap, dpi, 2);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x07);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0xc0, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) whitemap, whitemapsize,
+ wr_timeout);
+
+ free (whitemap);
+
+ /* Move to head... */
+ idle_ab (udev);
+ write_regs (udev, 1, 0x97, 0x00);
+ idle_ab (udev);
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ idle_ab (udev);
+ write_regs (udev, 16, 0x84, 0x94, 0x80, 0xd1, 0x80, 0xc1, 0x82, 0x7f, 0xcf,
+ 0x04, 0xc1, 0x02, 0xc2, 0x00, 0xc3, 0x06, 0xc4, 0xff, 0xc5,
+ 0x40, 0xc6, 0x8c, 0xc7, 0xdc, 0xc8, 0x20, 0xc0, 0x72, 0x89,
+ 0xff, 0x86, 0xff);
+ poll1 (udev);
+
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x01, 0x83, 0x82, 0x85, 0x00);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8, 0x77,
+ 0xb9, 0x1e);
+ else
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8, 0x3b,
+ 0xb9, 0x1f);
+ write_regs (udev, 5, 0xc0, 0x00, 0x84, 0x00, 0x80, 0xa1, 0xcf, 0x04, 0x82,
+ 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x02, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x01, 0xbd, 0x01, 0x88, 0xa4, 0xc1, 0x02, 0xc2, 0x00,
+ 0xc3, 0x02, 0xc4, 0x01, 0xc5, 0x01, 0xc6, 0xa3, 0xc7, 0xa4,
+ 0xc8, 0x04, 0xc0, 0xd2, 0x89, 0x05, 0x86, 0x00);
+ else
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x01, 0xbd, 0x01, 0x88, 0xd0, 0xc1, 0x01, 0xc2, 0x00,
+ 0xc3, 0x04, 0xc4, 0x01, 0xc5, 0x01, 0xc6, 0xcf, 0xc7, 0xd0,
+ 0xc8, 0x14, 0xc0, 0xd1, 0x89, 0x0a, 0x86, 0x00);
+ write_regs (udev, 8, 0xbb, 0x01, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80, 0xbf,
+ 0x00, 0x90, 0x40, 0x91, 0x00, 0x83, 0x82);
+ write_regs (udev, 1, 0xbe, 0x0d);
+ write_vctl (udev, 0x0c, 0x0003, 0x0001, 0x00);
+ whitebalance = (unsigned short *) malloc (whitebalancesize);
+ len = usb_bulk_read (udev, 1, &rd_byte, 1, rd_timeout);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+ len =
+ usb_bulk_read (udev, 1, (unsigned char *) whitebalance, whitebalancesize,
+ rd_timeout);
+ write_regs (udev, 2, 0xbe, 0x00, 0x84, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ redreg = greenreg = bluereg = 0x80;
+ red = green = blue = 0;
+ donered = donegreen = doneblue = 0;
+ DBG (2, "setting blackpoint\n");
+ for (j = 0; (j < 16) && !(donered && donegreen && doneblue); j++)
+ {
+ set_gain_black (udev, 0x01, 0x01, 0x01, redreg, greenreg, bluereg);
+
+ if (dpi == 1200)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x77, 0xb9, 0x1e);
+ else
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x3b, 0xb9, 0x1f);
+ write_regs (udev, 8, 0xbb, 0x01, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x40, 0x91, 0x00, 0x83, 0x82);
+ write_regs (udev, 1, 0xbe, 0x0d);
+ write_vctl (udev, 0x0c, 0x0003, 0x0001, 0x00);
+ len = usb_bulk_read (udev, 1, &rd_byte, 1, rd_timeout);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+ len =
+ usb_bulk_read (udev, 1, (unsigned char *) whitebalance,
+ whitebalancesize, rd_timeout);
+ fix_endian_short (whitebalance, whitebalancesize/2);
+ if (!donered)
+ {
+ red = (whitebalance[0] + whitebalance[3] + whitebalance[6]) / 3;
+ if (red > 0x1000)
+ redreg += 0x10;
+ else if (red > 0x500)
+ redreg += 0x08;
+ else if (red > 0x0010)
+ redreg++;
+ else
+ donered = 1;
+ }
+ if (!donegreen)
+ {
+ green = (whitebalance[1] + whitebalance[4] + whitebalance[7]) / 3;
+ if (green > 0x1000)
+ greenreg += 0x10;
+ else if (green > 0x0500)
+ greenreg += 0x08;
+ else if (green > 0x0010)
+ greenreg++;
+ else
+ donegreen = 1;
+ }
+ if (!doneblue)
+ {
+ blue = (whitebalance[2] + whitebalance[5] + whitebalance[8]) / 3;
+ if (blue > 0x1000)
+ bluereg += 0x10;
+ else if (blue > 0x0500)
+ bluereg += 0x08;
+ else if (blue > 0x0010)
+ bluereg++;
+ else
+ doneblue = 1;
+ }
+ DBG (2, "red=%d(%d)%02x, green=%d(%d)%02x, blue=%d(%d)%02x\n",
+ red, donered, redreg, green, donegreen, greenreg,
+ blue, doneblue, bluereg);
+ write_regs (udev, 2, 0xbe, 0x00, 0x84, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ }
+ DBG (2, "setting whitepoint\n");
+ donegreen = donered = doneblue = 0;
+ for (j = 0; (j < 16) && !(donered && donegreen && doneblue); j++)
+ {
+ set_gain_black (udev, rgreg, ggreg, bgreg, redreg, greenreg, bluereg);
+
+ if (dpi == 1200)
+ idle_ab (udev);
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8, 0x3b,
+ 0xb9, 0x1f);
+ if (dpi == 1200)
+ idle_ab (udev);
+ write_regs (udev, 8, 0xbb, 0x01, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x40, 0x91, 0x00, 0x83, 0x82);
+ write_regs (udev, 1, 0xbe, 0x0d);
+ write_vctl (udev, 0x0c, 0x0003, 0x0001, 0x00);
+ len = usb_bulk_read (udev, 1, &rd_byte, 1, rd_timeout);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+ len =
+ usb_bulk_read (udev, 1, (unsigned char *) whitebalance,
+ whitebalancesize, rd_timeout);
+ fix_endian_short (whitebalance, whitebalancesize/2);
+ if (!donered)
+ {
+ red =
+ (whitebalance[180 * 3 + 0] + whitebalance[180 * 3 + 3] +
+ whitebalance[180 * 3 + 6]) / 3;
+ if (red < 0x5000)
+ rgreg += 0x02;
+ else if (red < 0x8000)
+ rgreg += 0x01;
+ else
+ donered = 1;
+ }
+ if (!donegreen)
+ {
+ green =
+ (whitebalance[180 * 3 + 1] + whitebalance[180 * 3 + 4] +
+ whitebalance[180 * 3 + 7]) / 3;
+ if (green < 0x5000)
+ ggreg += 0x02;
+ else if (green < 0x8000)
+ ggreg += 0x01;
+ else
+ donegreen = 1;
+ }
+ if (!doneblue)
+ {
+ blue =
+ (whitebalance[180 * 3 + 2] + whitebalance[180 * 3 + 5] +
+ whitebalance[180 * 3 + 8]) / 3;
+ if (blue < 0x5000)
+ bgreg += 0x02;
+ else if (blue < 0x8000)
+ bgreg += 0x01;
+ else
+ doneblue = 1;
+ }
+ DBG (2, "red=%d(%d)%02x, green=%d(%d)%02x, blue=%d(%d)%02x\n",
+ red, donered, rgreg, green, donegreen, ggreg, blue, doneblue,
+ bgreg);
+ write_regs (udev, 2, 0xbe, 0x00, 0x84, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ }
+ free (whitebalance);
+
+ /* One step down for optimal contrast... */
+ if (rgreg)
+ rgreg--;
+ if (bgreg)
+ bgreg--;
+ if (ggreg)
+ ggreg--;
+
+
+ write_regs (udev, 8, 0x80, 0x00, 0x84, 0x00, 0xbe, 0x00, 0xc0, 0x00, 0x86,
+ 0x00, 0x89, 0x00, 0x94, 0x00, 0x01, 0x02);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xff, 0x83, 0x00, 0x8d, 0xff);
+ write_regs (udev, 5, 0x83, 0x00, 0xa3, 0xff, 0xa4, 0xff, 0xa1, 0xff, 0xa2,
+ 0xf7);
+ write_regs (udev, 4, 0x83, 0x22, 0x87, 0x01, 0x83, 0x02, 0x87, 0x16);
+ write_regs (udev, 11, 0xa0, 0x00, 0x9c, 0x00, 0x9f, 0x00, 0x9d, 0x00, 0x9e,
+ 0x00, 0xa0, 0x00, 0xce, 0x0c, 0x83, 0x20, 0xa5, 0x00, 0xa6,
+ 0x00, 0xa7, 0x00);
+ set_gain_black (udev, rgreg, ggreg, bgreg, redreg, greenreg, bluereg);
+
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b, 0x02, 0x98,
+ 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b, 0x03, 0x98, 0x00, 0x99,
+ 0x00, 0x9a, 0x00);
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x98, 0x83, 0x82, 0x85, 0x3a);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 1, 0x94, 0x71);
+ else
+ write_regs (udev, 1, 0x94, 0x61);
+
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x01, 0x83, 0x82, 0x85, 0x00);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8, 0xbf,
+ 0xb9, 0x17);
+ else
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8, 0xdf,
+ 0xb9, 0x1b);
+ write_regs (udev, 6, 0xc0, 0x00, 0x84, 0x00, 0x84, 0xb4, 0x80, 0xe1, 0xcf,
+ 0x04, 0x82, 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x02, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x08, 0x88, 0xa4, 0xc1, 0x02, 0xc2, 0x00,
+ 0xc3, 0x02, 0xc4, 0x20, 0xc5, 0x08, 0xc6, 0x96, 0xc7, 0xa4,
+ 0xc8, 0x06, 0xc0, 0xd2, 0x89, 0x24, 0x86, 0x01);
+ else
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x10, 0x88, 0xd0, 0xc1, 0x01, 0xc2, 0x00,
+ 0xc3, 0x04, 0xc4, 0x20, 0xc5, 0x10, 0xc6, 0xc3, 0xc7, 0xd0,
+ 0xc8, 0x1c, 0xc0, 0xd1, 0x89, 0x24, 0x86, 0x01);
+ write_regs (udev, 8, 0xbb, 0x05, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80, 0xbf,
+ 0x00, 0x90, 0x40, 0x91, 0x00, 0x83, 0x82);
+ write_regs (udev, 1, 0xbe, 0x1d);
+ write_vctl (udev, 0x0c, 0x0003, 0x0001, 0x00);
+ len = usb_bulk_read (udev, 1, &rd_byte, 1, rd_timeout);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+ record_mem (udev, (unsigned char **) (void *)&whitescan,
+ (5632 * 2 * 3 * (dpi == 1200 ? 2 : 1)) * 4);
+ fix_endian_short (whitescan, (5632 * 2 * 3 * (dpi == 1200 ? 2 : 1)) * 2);
+ write_regs (udev, 5, 0x83, 0x00, 0xa3, 0xff, 0xa4, 0xff, 0xa1, 0xff, 0xa2,
+ 0xff);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+ write_regs (udev, 2, 0xbe, 0x00, 0x84, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ write_regs (udev, 4, 0x83, 0x00, 0xa3, 0x00, 0xa4, 0x00, 0x97, 0x0a);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0b);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x0f);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x05);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xff, 0x83, 0x00, 0x8d, 0xff);
+ write_regs (udev, 1, 0x97, 0x00);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 1, 0x97, 0x00);
+ write_vctl (udev, 0x0c, 0x0004, 0x008b, 0x00);
+ read_vctl (udev, 0x0c, 0x0007, 0x0000, &rd_byte);
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ write_regs (udev, 16, 0x84, 0x94, 0x80, 0xd1, 0x80, 0xc1, 0x82, 0x7f, 0xcf,
+ 0x04, 0xc1, 0x02, 0xc2, 0x00, 0xc3, 0x06, 0xc4, 0xff, 0xc5,
+ 0x40, 0xc6, 0x8c, 0xc7, 0xdc, 0xc8, 0x20, 0xc0, 0x72, 0x89,
+ 0xff, 0x86, 0xff);
+ poll1 (udev);
+
+ /* ready scan position */
+ /* 1/3" of unscannable area at top... */
+ if (dpi == 300)
+ topreg = 120 * 4;
+ else if (dpi == 600)
+ topreg = 139 * 4;
+ else if (dpi == 1200)
+ topreg = 152 * 4;
+ else /*if (dpi == 150) */
+ topreg = 120 * 4;
+ topreg += topline * (1200 / dpi);
+
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ write_regs (udev, 14, 0x84, 0xb4, 0x80, 0xe1, 0xcf, 0x04, 0xc1, 0x02, 0xc2,
+ 0x00, 0xc3, 0x07, 0xc4, 0xff, 0xc5, 0x40, 0xc6, 0x8c, 0xc7,
+ 0xdc, 0xc8, 0x20, 0xc0, 0x72, 0x89, topreg & 255, 0x86,
+ 255 & (topreg >> 8));
+ write_regs (udev, 1, 0x97, 0x00);
+ poll2 (udev);
+
+ write_regs (udev, 8, 0x80, 0x00, 0x84, 0x00, 0xbe, 0x00, 0xc0, 0x00, 0x86,
+ 0x00, 0x89, 0x00, 0x94, 0x00, 0x01, 0x02);
+ write_vctl (udev, 0x0c, 0x00c0, 0x8406, 0x00);
+ write_vctl (udev, 0x0c, 0x00c0, 0x0406, 0x00);
+ write_regs (udev, 16, 0xbe, 0x18, 0x80, 0x00, 0x84, 0x00, 0x89, 0x00, 0x88,
+ 0x00, 0x86, 0x00, 0x90, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3,
+ 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8,
+ 0x00, 0xc0, 0x00);
+ if (dpi == 1200)
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0x24, 0x83, 0x00, 0x8d, 0xff);
+ else
+ write_regs (udev, 4, 0x83, 0x20, 0x8d, 0xff, 0x83, 0x00, 0x8d, 0xff);
+ if (dpi != 1200)
+ write_regs (udev, 5, 0x83, 0x00, 0xa3, 0xff, 0xa4, 0xff, 0xa1, 0xff, 0xa2,
+ 0xf7);
+ if (dpi == 1200)
+ write_regs (udev, 4, 0x83, 0x22, 0x87, 0x01, 0x83, 0x02, 0x87, 0x2c);
+ else
+ write_regs (udev, 4, 0x83, 0x22, 0x87, 0x01, 0x83, 0x02, 0x87, 0x16);
+ if (dpi == 1200)
+ write_regs (udev, 11, 0xa0, 0x00, 0x9c, 0x00, 0x9f, 0x40, 0x9d, 0x00,
+ 0x9e, 0x00, 0xa0, 0x00, 0xce, 0x0c, 0x83, 0x20, 0xa5, 0x00,
+ 0xa6, 0x00, 0xa7, 0x00);
+ else
+ write_regs (udev, 11, 0xa0, 0x00, 0x9c, 0x00, 0x9f, 0x00, 0x9d, 0x00,
+ 0x9e, 0x00, 0xa0, 0x00, 0xce, 0x0c, 0x83, 0x20, 0xa5, 0x00,
+ 0xa6, 0x00, 0xa7, 0x00);
+
+ set_gain_black (udev, rgreg, ggreg, bgreg, redreg, greenreg, bluereg);
+ if (!bpp16)
+ {
+ if (dpi == 1200)
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0xc7, 0x99, 0x99, 0x9a, 0xd5,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0xc8, 0x99, 0x99, 0x9a, 0xd3, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ else if (dpi == 150)
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0x94, 0x99, 0x67, 0x9a, 0x83,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0x7e, 0x99, 0x5d, 0x9a, 0x7d, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ else
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0xb3, 0x99, 0x72, 0x9a, 0x9d,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0xa3, 0x99, 0x6f, 0x9a, 0x94, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ }
+ else
+ {
+ if (dpi == 1200)
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0xb9, 0x99, 0x7a, 0x9a, 0xd6,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0xbc, 0x99, 0x7c, 0x9a, 0xd3, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ else if (dpi == 150)
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0x9c, 0x99, 0x5f, 0x9a, 0x87,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0x97, 0x99, 0x58, 0x9a, 0x81, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ else
+ write_regs (udev, 16, 0x9b, 0x00, 0x98, 0x9d, 0x99, 0x79, 0x9a, 0x8e,
+ 0x9b, 0x01, 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00, 0x9b,
+ 0x02, 0x98, 0x89, 0x99, 0x71, 0x9a, 0x80, 0x9b, 0x03,
+ 0x98, 0x00, 0x99, 0x00, 0x9a, 0x00);
+ }
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x98, 0x83, 0x82, 0x85, 0x3a);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+ if (!bpp16)
+ {
+ if (dpi == 1200)
+ write_regs (udev, 1, 0x94, 0x51);
+ else
+ write_regs (udev, 1, 0x94, 0x41);
+ }
+ else
+ {
+ if (dpi == 1200)
+ write_regs (udev, 1, 0x94, 0x71);
+ else
+ write_regs (udev, 1, 0x94, 0x61);
+ }
+ lightmap = (unsigned short *) malloc (whitemapsize);
+ calc_lightmap (whitescan, lightmap, 0, dpi, gain, offset);
+ select_pixels (lightmap, dpi, leftpix, scanpix);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x06, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x06);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x40, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0x7f, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) lightmap, whitemapsize,
+ wr_timeout);
+
+ calc_lightmap (whitescan, lightmap, 1, dpi, gain, offset);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0x7f, 0xb5, 0x07);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xbf, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ fix_endian_short (&GRAYMASK, 1);
+ if (gray)
+ for (i = 0; i < whitemapsize / 2; i++)
+ lightmap[i] |= GRAYMASK;
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) lightmap, whitemapsize,
+ wr_timeout);
+
+ calc_lightmap (whitescan, lightmap, 2, dpi, gain, offset);
+ if (dpi == 1200)
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0x80, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x07);
+ else
+ write_regs (udev, 6, 0xb0, 0x00, 0xb1, 0xc0, 0xb2, 0x07, 0xb3, 0xff, 0xb4,
+ 0xff, 0xb5, 0x07);
+ write_vctl (udev, 0x0c, 0x0002, whitemapsize, 0x00);
+ len =
+ usb_bulk_write (udev, 2, (unsigned char *) lightmap, whitemapsize,
+ wr_timeout);
+
+ free (whitescan);
+ free (lightmap);
+
+ if (!bpp16)
+ download_lut8 (udev, dpi, gray ? 0 : 1);
+
+ write_regs (udev, 4, 0x83, 0xa2, 0x85, 0x01, 0x83, 0x82, 0x85, 0x00);
+ write_regs (udev, 1, 0x9d, 0x80);
+ write_regs (udev, 1, 0x9d, 0x00);
+
+ if (!bpp16)
+ {
+ if (dpi == 1200)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0x1f, 0xb5, 0x06, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x43, 0xb9, 0x2d);
+ else if (dpi == 150)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0x0f, 0xb5, 0x07, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0xe0, 0xb9, 0x37);
+ else
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0x0f, 0xb5, 0x07, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x90, 0xb9, 0x37);
+ }
+ else
+ {
+ if (dpi == 1200)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x87, 0xb9, 0x18);
+ else if (dpi == 150)
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0xc1, 0xb9, 0x1e);
+ else
+ write_regs (udev, 10, 0xb0, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, 0xff,
+ 0xb4, 0xff, 0xb5, 0x03, 0xb6, 0x01, 0xb7, 0x00, 0xb8,
+ 0x21, 0xb9, 0x1e);
+ }
+
+ /* [86,89] controls number of 300dpi steps to scan */
+ botreg = scanlines * (1200 / dpi) + 400;
+ write_regs (udev, 6, 0xc0, 0x00, 0x84, 0x00, 0x84, 0xb4, 0x80, 0xe1, 0xcf,
+ 0x04, 0x82, 0x00);
+
+ if (!bpp16)
+ {
+ if (dpi == 300)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x10, 0x88, 0xd0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x04, 0xc4, 0x20, 0xc5, 0x10, 0xc6, 0xc3,
+ 0xc7, 0xd0, 0xc8, 0x12, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 600)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x10, 0x88, 0xd0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x04, 0xc4, 0x20, 0xc5, 0x10, 0xc6, 0xc3,
+ 0xc7, 0xd0, 0xc8, 0x16, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 1200)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x02, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x08, 0x88, 0xa4, 0xc1, 0x02, 0xc2,
+ 0x00, 0xc3, 0x02, 0xc4, 0x20, 0xc5, 0x08, 0xc6, 0x96,
+ 0xc7, 0xa4, 0xc8, 0x06, 0xc0, 0xd2, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 150)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x06, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x1c, 0xbd, 0x08, 0x88, 0xe0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x03, 0xc4, 0x1c, 0xc5, 0x08, 0xc6, 0xd7,
+ 0xc7, 0xe0, 0xc8, 0x11, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+
+ if (dpi == 300)
+ write_regs (udev, 8, 0xbb, 0x01, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x20, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 600)
+ write_regs (udev, 8, 0xbb, 0x02, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x20, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 1200)
+ write_regs (udev, 8, 0xbb, 0x02, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x20, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 150)
+ write_regs (udev, 8, 0xbb, 0x00, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x20, 0x91, 0x00, 0x83, 0x82);
+ }
+ else
+ {
+ if (dpi == 300)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x10, 0x88, 0xd0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x04, 0xc4, 0x20, 0xc5, 0x10, 0xc6, 0xc3,
+ 0xc7, 0xd0, 0xc8, 0x13, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 150)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x06, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x1c, 0xbd, 0x08, 0x88, 0xe0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x03, 0xc4, 0x1c, 0xc5, 0x08, 0xc6, 0xd7,
+ 0xc7, 0xe0, 0xc8, 0x12, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 1200)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x02, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x08, 0x88, 0xa4, 0xc1, 0x02, 0xc2,
+ 0x00, 0xc3, 0x02, 0xc4, 0x20, 0xc5, 0x08, 0xc6, 0x96,
+ 0xc7, 0xa4, 0xc8, 0x0c, 0xc0, 0xd2, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+ else if (dpi == 600)
+ write_regs (udev, 18, 0x83, 0xa2, 0x85, 0x04, 0x83, 0x82, 0x85, 0x00,
+ 0xbc, 0x20, 0xbd, 0x10, 0x88, 0xd0, 0xc1, 0x01, 0xc2,
+ 0x00, 0xc3, 0x04, 0xc4, 0x20, 0xc5, 0x10, 0xc6, 0xc3,
+ 0xc7, 0xd0, 0xc8, 0x1a, 0xc0, 0xd1, 0x89, botreg & 255,
+ 0x86, 255 & (botreg >> 8));
+
+ if (dpi == 300)
+ write_regs (udev, 8, 0xbb, 0x02, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x70, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 150)
+ write_regs (udev, 8, 0xbb, 0x01, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x70, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 1200)
+ write_regs (udev, 8, 0xbb, 0x05, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x70, 0x91, 0x00, 0x83, 0x82);
+ else if (dpi == 600)
+ write_regs (udev, 8, 0xbb, 0x04, 0x9b, 0x24, 0x8b, 0x00, 0x8e, 0x80,
+ 0xbf, 0x00, 0x90, 0x70, 0x91, 0x00, 0x83, 0x82);
+
+
+ }
+
+ if (gray)
+ write_regs (udev, 1, 0xbe, 0x05);
+ else
+ write_regs (udev, 1, 0xbe, 0x0d);
+ write_vctl (udev, 0x0c, 0x0003, 0x0001, 0x00);
+ len = usb_bulk_read (udev, 1, &rd_byte, 1, rd_timeout);
+ write_vctl (udev, 0x0c, 0x0001, 0x0000, 0x00);
+
+#ifndef BACKENDNAME
+ sprintf (fname, "%d.%s", dpi, gray ? "pgm" : "ppm");
+ if (stname)
+ strcpy (fname, stname);
+ sprintf (head, "P%d\n%d %d\n%d\n", gray ? 5 : 6, scanpix, scanlines,
+ bpp16 ? 65535 : 255);
+ if (nohead)
+ head[0] = 0;
+ if (!raw)
+ record_image (udev, fname, dpi, scanpix, scanlines, gray, head, bpp16);
+ else
+ record_head (udev, fname,
+ scanpix * (gray ? 1 : 3) * (bpp16 ? 2 : 1) * scanlines, "");
+
+ reset_scanner (udev);
+ idle_ab (udev);
+ set_lamp_timer (udev, 5);
+#endif
+}