Initial import of sane-backends version 1.0.24-1.2

1 files changed, 3215 insertions, 0 deletions

diff --git a/backend/plustek-usbshading.c b/backend/plustek-usbshading.c
new file mode 100644
index 0000000..6d08dc7
--- /dev/null
+++ b/backend/plustek-usbshading.c
@@ -0,0 +1,3215 @@
+/*.............................................................................
+ * Project : SANE library for Plustek flatbed scanners.
+ *.............................................................................
+ */
+
+/** @file plustek-usbshading.c
+ *  @brief Calibration routines.
+ *
+ * Based on sources acquired from Plustek Inc.<br>
+ * Copyright (C) 2001-2013 Gerhard Jaeger <gerhard@gjaeger.de>
+ *
+ * History:
+ * - 0.40 - starting version of the USB support
+ * - 0.41 - minor fixes
+ *        - added workaround stuff for EPSON1250
+ * - 0.42 - added workaround stuff for UMAX 3400
+ * - 0.43 - added call to usb_switchLamp before reading dark data
+ * - 0.44 - added more debug output and bypass calibration
+ *        - added dump of shading data
+ * - 0.45 - added coarse calibration for CIS devices
+ *        - added _WAF_SKIP_FINE to skip the results of fine calibration
+ *        - CanoScan fixes and fine-tuning
+ * - 0.46 - CanoScan will now be calibrated by code in plustek-usbcal.c
+ *        - added functions to save and restore calibration data from a file
+ *        - fixed some TPA issues
+ * - 0.47 - made calibration work on big-endian machines
+ * - 0.48 - added more debug output
+ *        - added usb_AutoWarmup()
+ * - 0.49 - a_bRegs is now part of the device structure
+ *        - using now PhyDpi.y as selector for the motor MCLK range
+ * - 0.50 - readded kCIS670 to add 5% extra to LiDE20 fine calibration
+ *        - fixed line statistics and added data output
+ * - 0.51 - added fine calibration cache
+ * - 0.52 - added get_ptrs to let various sensororders work
+ *          correctly
+ *        - fixed warning condition
+ * .
+ * <hr>
+ * This file is part of the SANE package.
+ *
+ * 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.
+ * <hr>
+ */
+
+/************** global stuff - I hate it, but we need it... ******************/
+
+#define _MAX_AUTO_WARMUP 60  /**< number of loops                            */
+#define _AUTO_SLEEP       1  /**< time to sleep, when lamp is not stable     */
+#define _AUTO_THRESH     60  /**< threshold for stop waiting (normal lamp)   */
+#define _AUTO_TPA_THRESH 40  /**< threshold for stop waiting (TPA lamp)      */
+
+#define _MAX_GAIN_LOOPS  10  /**< max number of loops for coarse calibration */
+#define _TLOOPS           3  /**< test loops for transfer rate measurement   */
+
+#define SWAP_COARSE
+#define SWAP_FINE
+
+/************************** static variables *********************************/
+
+static RGBUShortDef Gain_Hilight;
+static RGBUShortDef Gain_NegHilight;
+static RGBByteDef   Gain_Reg;
+
+static u_long     m_dwPixels;
+static ScanParam  m_ScanParam;
+static u_long     m_dwIdealGain;
+
+static double dMCLK, dExpect, dMax;
+static double dMCLK_ADF;
+
+/** do some statistics...
+ */
+static void usb_line_statistics( char *cmt, u_short* buf,
+                                 u_long dim_x, SANE_Bool color )
+{
+	char         fn[50];
+	int          i, channel;
+	u_long       dw, imad, imid, alld, cld, cud;
+	u_short      mid, mad, aved, lbd, ubd, tmp;
+	MonoWordDef *pvd, *pvd2;
+	FILE        *fp;
+	SANE_Bool    swap = usb_HostSwap();
+
+	pvd = pvd2 = (MonoWordDef*)buf;
+
+	if( color )
+		channel = 3;
+	else
+		channel = 1;
+
+	for( i = 0; i < channel; i++ ) {
+
+		mid  = 0xFFFF;
+		mad  = 0;
+		imid = 0;
+		imad = 0;
+		alld = 0;
+
+		fp = NULL;
+		if( DBG_LEVEL >= _DBG_DCALDATA ) {
+			sprintf( fn, "%scal%u.dat", cmt, i );
+			fp = fopen( fn, "w+b" );
+			if( fp == NULL )
+				DBG( _DBG_ERROR, "Could not open %s\n", fn );
+		}
+
+		/* do the standard min/max stuff */
+		for( dw = 0; dw < dim_x; pvd++, dw++ ) {
+
+			if( swap )
+				tmp = _LOBYTE(pvd->Mono) * 256 + _HIBYTE(pvd->Mono);
+			else
+				tmp = pvd->Mono;
+
+			if( tmp > mad ) {
+				mad  = tmp;
+				imad = dw;
+			}
+
+			if( tmp < mid ) {
+				mid  = tmp;
+				imid = dw;
+			}
+
+			if( fp )
+				fprintf(fp, "%u\n", tmp );
+
+			alld += tmp;
+		}
+
+		if( fp )
+			fclose(fp);
+
+		/* calculate average and 5% limit */
+		aved = (u_short)(alld/dim_x);
+		lbd  = aved - 0.05*aved;
+		ubd  = aved + 0.05*aved;
+		cld  = 0;
+		cud  = 0;
+
+		/* find the number of values beyond the 5% limits */
+		for( dw = 0; dw < dim_x; pvd2++, dw++ ) {
+
+			if( swap )
+				tmp = _LOBYTE(pvd2->Mono) * 256 + _HIBYTE(pvd2->Mono);
+			else
+				tmp = pvd2->Mono;
+
+			if( tmp > ubd ) cud++;
+			if( tmp < lbd ) cld++;
+		}
+
+		DBG( _DBG_INFO2, "Color[%u] (%s): %lu all "
+		                 "min=%u(%lu) max=%u(%lu) ave=%u\n",
+		                 i, cmt, dim_x, mid, imid, mad, imad, aved);
+		DBG( _DBG_INFO2, "5%%: low@%u (count=%lu), upper@%u (count=%lu)\n",
+		                 lbd, cld, ubd, cud);
+	}
+}
+
+/**
+ */
+static void
+usb_PrepareFineCal( Plustek_Device *dev, ScanParam *tmp_sp, u_short cal_dpi )
+{
+	ScanParam *sp    = &dev->scanning.sParam;
+	DCapsDef  *scaps = &dev->usbDev.Caps;
+
+	*tmp_sp = *sp;
+
+	if( dev->adj.cacheCalData ) {
+
+		DBG( _DBG_INFO2, "* Cal-cache active, tweaking scanparams"
+		                 " - DPI=%u!\n", cal_dpi );
+
+		tmp_sp->UserDpi.x = usb_SetAsicDpiX(dev, sp->UserDpi.x );
+		if( cal_dpi != 0 )
+			tmp_sp->UserDpi.x = cal_dpi;
+
+		tmp_sp->PhyDpi        = scaps->OpticDpi;
+		tmp_sp->Origin.x      = 0;
+		tmp_sp->Size.dwPixels = scaps->Normal.Size.x *
+		                        usb_SetAsicDpiX(dev, tmp_sp->UserDpi.x)/ 300UL;
+	}
+
+#if 0
+	if( tmp_sp->PhyDpi.x > 75)
+		tmp_sp->Size.dwLines = 64;
+	else
+#endif
+		tmp_sp->Size.dwLines = 32;
+
+	tmp_sp->Origin.y  = 0;
+	tmp_sp->bBitDepth = 16;
+
+	tmp_sp->UserDpi.y    = scaps->OpticDpi.y;
+	tmp_sp->Size.dwBytes = tmp_sp->Size.dwPixels * 2 * tmp_sp->bChannels;
+
+	if( usb_IsCISDevice(dev) && (tmp_sp->bDataType == SCANDATATYPE_Color)) {
+		tmp_sp->Size.dwBytes *= 3;
+	}
+
+	tmp_sp->dMCLK = dMCLK;
+}
+
+/**
+ */
+static double usb_GetMCLK( Plustek_Device *dev, ScanParam *param )
+{
+	int          idx, i;
+	double       mclk;
+	ClkMotorDef *clk;
+	HWDef       *hw = &dev->usbDev.HwSetting;
+
+	clk = usb_GetMotorSet( hw->motorModel );
+	idx = 0;
+	for( i = 0; i < _MAX_CLK; i++ ) {
+		if( param->PhyDpi.y <= dpi_ranges[i] )
+			break;
+		idx++;
+	}
+	if( idx >= _MAX_CLK )
+		idx = _MAX_CLK - 1;
+
+	if( param->bDataType != SCANDATATYPE_Color ) {
+
+		if( param->bBitDepth > 8 )
+			mclk = clk->gray_mclk_16[idx];
+		else
+			mclk = clk->gray_mclk_8[idx];
+	} else {
+		if( param->bBitDepth > 8 )
+			mclk = clk->color_mclk_16[idx];
+		else
+			mclk = clk->color_mclk_8[idx];
+	}
+
+	DBG( _DBG_INFO, "GETMCLK[%u/%u], using entry %u: %.3f, %u\n",
+	     hw->motorModel, param->bDataType, idx, mclk, param->PhyDpi.x );
+	return mclk;
+}
+
+/** usb_SetMCLK
+ * get the MCLK out of our table
+ */
+static void usb_SetMCLK( Plustek_Device *dev, ScanParam *param )
+{
+	HWDef *hw = &dev->usbDev.HwSetting;
+
+	dMCLK = usb_GetMCLK( dev, param );
+	param->dMCLK = dMCLK; 
+
+	DBG( _DBG_INFO, "SETMCLK[%u/%u]: %.3f\n", 
+	     hw->motorModel, param->bDataType, dMCLK );
+}
+
+/** usb_SetDarkShading
+ * download the dark shading data to Merlins' DRAM
+ */
+static SANE_Bool usb_SetDarkShading( Plustek_Device *dev, u_char channel,
+                                     void *coeff_buffer, u_short wCount )
+{
+	int     res;
+	u_char *regs = dev->usbDev.a_bRegs;
+
+	regs[0x03] = 0;
+	if( channel == CHANNEL_green )
+		regs[0x03] |= 4;
+	else
+		if( channel == CHANNEL_blue )
+			regs[0x03] |= 8;
+
+	if( usbio_WriteReg( dev->fd, 0x03, regs[0x03] )) {
+
+		/* Dataport address is always 0 for setting offset coefficient */
+		regs[0x04] = 0;
+		regs[0x05] = 0;
+
+		res = sanei_lm983x_write( dev->fd, 0x04, &regs[0x04], 2, SANE_TRUE );
+
+		/* Download offset coefficients */
+		if( SANE_STATUS_GOOD == res ) {
+			
+			res = sanei_lm983x_write( dev->fd, 0x06,
+			                          (u_char*)coeff_buffer, wCount, SANE_FALSE );
+			if( SANE_STATUS_GOOD == res )
+				return SANE_TRUE;
+		}
+	}
+	
+	DBG( _DBG_ERROR, "usb_SetDarkShading() failed\n" );
+	return SANE_FALSE;
+}
+
+/** usb_SetWhiteShading
+ * download the white shading data to Merlins' DRAM
+ */
+static SANE_Bool usb_SetWhiteShading( Plustek_Device *dev, u_char channel,
+                                      void *data_buffer, u_short wCount )
+{
+	int     res;
+	u_char *regs = dev->usbDev.a_bRegs;
+
+	regs[0x03] = 1;
+	if (channel == CHANNEL_green)
+		regs [0x03] |= 4;
+	else
+		if (channel == CHANNEL_blue)
+			regs[0x03] |= 8;
+
+	if( usbio_WriteReg( dev->fd, 0x03, regs[0x03] )) {
+
+		/* Dataport address is always 0 for setting offset coefficient */
+		regs[0x04] = 0;
+		regs[0x05] = 0;
+
+		res = sanei_lm983x_write( dev->fd, 0x04, &regs[0x04], 2, SANE_TRUE );
+
+		/* Download offset coefficients */
+		if( SANE_STATUS_GOOD == res ) {
+			res = sanei_lm983x_write(dev->fd, 0x06,
+			                        (u_char*)data_buffer, wCount, SANE_FALSE );
+			if( SANE_STATUS_GOOD == res )
+				return SANE_TRUE;
+		}
+	}
+	
+	DBG( _DBG_ERROR, "usb_SetWhiteShading() failed\n" );
+	return SANE_FALSE;
+}
+
+/** usb_GetSWOffsetGain4TPA
+ *  preset the offset and gain parameter for fine calibration for
+ *  TPA/ADF scanning
+ */
+static void usb_GetSWOffsetGain4TPA( Plustek_Device *dev )
+{
+	ScanParam *param = &dev->scanning.sParam;
+	DCapsDef  *sCaps = &dev->usbDev.Caps;
+
+	switch( sCaps->bCCD ) {
+		case kEPSON:
+			DBG( _DBG_INFO2, "kEPSON TPA adjustments\n" );
+			param->swGain[0] = 1000;
+			param->swGain[1] = 1000;
+			param->swGain[2] = 1000;
+		break;
+	}
+}
+
+/** usb_GetSWOffsetGain
+ * preset the offset and gain parameter for fine calibration for normal
+ * scanning
+ */
+static void usb_GetSWOffsetGain( Plustek_Device *dev )
+{
+	ScanParam *param = &dev->scanning.sParam;
+	DCapsDef  *sCaps  = &dev->usbDev.Caps;
+	HWDef     *hw     = &dev->usbDev.HwSetting;
+
+	param->swOffset[0] = 0;
+	param->swOffset[1] = 0;
+	param->swOffset[2] = 0;
+
+	param->swGain[0] = 1000;
+	param->swGain[1] = 1000;
+	param->swGain[2] = 1000;
+
+	if( param->bSource != SOURCE_Reflection ) {
+		usb_GetSWOffsetGain4TPA( dev );
+		return;
+	}
+
+	/* only valid for normal scanning... */
+	switch( sCaps->bCCD ) {
+
+	case kEPSON:
+		DBG( _DBG_INFO2, "kEPSON adjustments\n" );
+#if 0
+		param->swGain[0] = 800;
+		param->swGain[1] = 800;
+		param->swGain[2] = 800;
+#endif
+		break;
+	
+	case kNECSLIM:
+		DBG( _DBG_INFO2, "kNECSLIM adjustments\n" );
+		if( param->PhyDpi.x <= 150 ) {
+			param->swOffset[0] = 600;
+			param->swOffset[1] = 500;
+			param->swOffset[2] = 300;
+			param->swGain[0] = 960;
+			param->swGain[1] = 970;
+			param->swGain[2] = 1000;
+		} else if (param->PhyDpi.x <= 300) {
+			param->swOffset[0] = 700;
+			param->swOffset[1] = 600;
+			param->swOffset[2] = 400;
+			param->swGain[0] = 967;
+			param->swGain[1] = 980;
+			param->swGain[2] = 1000;
+		} else {
+			param->swOffset[0] = 900;
+			param->swOffset[1] = 850;
+			param->swOffset[2] = 620;
+			param->swGain[0] = 965;
+			param->swGain[1] = 980;
+			param->swGain[2] = 1000;
+		}
+		break;
+
+	case kNEC8861:
+		DBG( _DBG_INFO2, "kNEC8861 adjustments\n" );
+		break;
+
+	case kCIS670:
+		DBG( _DBG_INFO2, "kCIS670 adjustments\n" );
+		if(param->bDataType == SCANDATATYPE_Color) {
+
+			param->swGain[0] =
+			param->swGain[1] =
+			param->swGain[2] = 952;
+
+			param->swOffset[0] =
+			param->swOffset[1] =
+			param->swOffset[2] = 1000;
+		}
+		break;
+#if 0
+	case kCIS650:
+	case kCIS1220:
+
+		DBG( _DBG_INFO2, "kCIS adjustments\n" );
+		if(param->bDataType == SCANDATATYPE_Color) {
+
+			param->swGain[0] =
+			param->swGain[1] =
+			param->swGain[2] = 952;
+
+			param->swOffset[0] =
+			param->swOffset[1] =
+			param->swOffset[2] = 1000;
+		}
+		break;
+	case kCIS1240:
+		DBG( _DBG_INFO2, "kCIS1240 adjustments\n" );
+		if(param->bDataType == SCANDATATYPE_Color) {
+
+			param->swGain[0] = 950;
+			param->swGain[1] = 950;
+			param->swGain[2] = 900;
+
+			param->swOffset[0] =
+			param->swOffset[1] =
+			param->swOffset[2] = 0; /*1000;*/
+		}
+		break;
+#endif
+
+	case kNEC3799:
+		DBG( _DBG_INFO2, "kNEC3799 adjustments\n" );
+		if( sCaps->bPCB == 2 ) {
+			if( param->PhyDpi.x <= 150 ) {
+				param->swOffset[0] = 600;
+				param->swOffset[1] = 500;
+				param->swOffset[2] = 300;
+				param->swGain[0] = 960;
+				param->swGain[1] = 970;
+				param->swGain[2] = 1000;
+			} else if (param->PhyDpi.x <= 300) {
+				param->swOffset[0] = 700;
+				param->swOffset[1] = 600;
+				param->swOffset[2] = 400;
+				param->swGain[0] = 967;
+				param->swGain[1] = 980;
+				param->swGain[2] = 1000;
+			} else {
+				param->swOffset[0] = 900;
+				param->swOffset[1] = 850;
+				param->swOffset[2] = 620;
+				param->swGain[0] = 965;
+				param->swGain[1] = 980;
+				param->swGain[2] = 1000;
+			}
+		} else if( hw->motorModel == MODEL_KaoHsiung ) {
+			param->swOffset[0] = 1950;
+			param->swOffset[1] = 1700;
+			param->swOffset[2] = 1250;
+			param->swGain[0] = 955;
+			param->swGain[1] = 950;
+			param->swGain[2] = 1000;
+		} else { /* MODEL_Hualien */
+			if( param->PhyDpi.x <= 300 ) {
+				if( param->bBitDepth > 8 ) {
+					param->swOffset[0] = 0;
+					param->swOffset[1] = 0;
+					param->swOffset[2] = -300;
+					param->swGain[0] = 970;
+					param->swGain[1] = 985;
+					param->swGain[2] = 1050;
+				} else {
+					param->swOffset[0] = -485;
+					param->swOffset[1] = -375;
+					param->swOffset[2] = -628;
+					param->swGain[0] = 970;
+					param->swGain[1] = 980;
+					param->swGain[2] = 1050;
+				}
+			} else {
+				if( param->bBitDepth > 8 ) {
+					param->swOffset[0] = 1150;
+					param->swOffset[1] = 1000;
+					param->swOffset[2] = 700;
+					param->swGain[0] = 990;
+					param->swGain[1] = 1000;
+					param->swGain[2] = 1050;
+				} else {
+					param->swOffset[0] = -30;
+					param->swOffset[1] = 0;
+					param->swOffset[2] = -250;
+					param->swGain[0] = 985;
+					param->swGain[1] = 995;
+					param->swGain[2] = 1050;
+				}
+			}
+		}
+		break;
+
+	case kSONY548:
+		DBG( _DBG_INFO2, "kSONY548 adjustments\n" );
+		if(param->bDataType == SCANDATATYPE_Color)
+		{
+			if(param->PhyDpi.x <= 75)
+			{
+				param->swOffset[0] = 650;
+				param->swOffset[1] = 850;
+				param->swOffset[2] = 500;
+				param->swGain[0] = 980;
+				param->swGain[1] = 1004;
+				param->swGain[2] = 1036;
+			}
+			else if(param->PhyDpi.x <= 300)
+			{
+				param->swOffset[0] = 700;
+				param->swOffset[1] = 900;
+				param->swOffset[2] = 550;
+				param->swGain[0] = 970;
+				param->swGain[1] = 995;
+				param->swGain[2] = 1020;
+			}
+			else if(param->PhyDpi.x <= 400)
+			{
+				param->swOffset[0] = 770;
+				param->swOffset[1] = 1010;
+				param->swOffset[2] = 600;
+				param->swGain[0] = 970;
+				param->swGain[1] = 993;
+				param->swGain[2] = 1023;
+			}
+			else
+			{
+				param->swOffset[0] = 380;
+				param->swOffset[1] = 920;
+				param->swOffset[2] = 450;
+				param->swGain[0] = 957;
+				param->swGain[1] = 980;
+				param->swGain[2] = 1008;
+			}
+		}
+		else
+		{
+			if(param->PhyDpi.x <= 75)
+			{
+				param->swOffset[1] = 1250;
+				param->swGain[1] = 950;
+			}
+			else if(param->PhyDpi.x <= 300)
+			{
+				param->swOffset[1] = 1250;
+				param->swGain[1] = 950;
+			}
+			else if(param->PhyDpi.x <= 400)
+			{
+				param->swOffset[1] = 1250;
+				param->swGain[1] = 950;
+			}
+			else
+			{
+				param->swOffset[1] = 1250;
+				param->swGain[1] = 950;
+			}
+		}
+		break;
+
+	case kNEC3778:
+		DBG( _DBG_INFO2, "kNEC3778 adjustments\n" );
+		if((_LM9831 == hw->chip) && (param->PhyDpi.x <= 300))
+		{
+			param->swOffset[0] = 0;
+			param->swOffset[1] = 0;
+			param->swOffset[2] = 0;
+			param->swGain[0] = 900;
+			param->swGain[1] = 920;
+			param->swGain[2] = 980;
+		}
+		else if( hw->motorModel == MODEL_HuaLien && param->PhyDpi.x > 800)
+		{
+			param->swOffset[0] = 0;
+			param->swOffset[1] = 0;
+			param->swOffset[2] = -200;
+			param->swGain[0] = 980;
+			param->swGain[1] = 930;
+			param->swGain[2] = 1080;
+		}
+		else
+		{
+			param->swOffset[0] = -304;
+			param->swOffset[1] = -304;
+			param->swOffset[2] = -304;
+			param->swGain[0] = 910;	
+			param->swGain[1] = 920;	
+			param->swGain[2] = 975;
+		}
+		
+		if(param->bDataType == SCANDATATYPE_BW && param->PhyDpi.x <= 300)
+		{
+			param->swOffset[1] = 1000;
+			param->swGain[1] = 1000;
+		}
+		break;
+	}
+}
+
+/** according to the pixel values,
+ */
+static u_char usb_GetNewGain( Plustek_Device *dev, u_short wMax, int channel )
+{
+	double dRatio, dAmp;
+	u_long dwInc, dwDec;
+	u_char bGain;
+
+	if( !wMax )
+		wMax = 1;
+
+	dAmp = 0.93 + 0.067 * dev->usbDev.a_bRegs[0x3b+channel];
+
+	if((m_dwIdealGain / (wMax / dAmp)) < 3) {
+
+		dRatio = ((double) m_dwIdealGain * dAmp / wMax - 0.93) / 0.067;
+		if(ceil(dRatio) > 0x3f)
+			return 0x3f;
+
+		dwInc = (u_long)((0.93 + ceil (dRatio) * 0.067) * wMax / dAmp);
+		dwDec = (u_long)((0.93 + floor (dRatio) * 0.067) * wMax / dAmp);
+		if((dwInc >= 0xff00) ||
+		   (labs (dwInc - m_dwIdealGain) > labs(dwDec - m_dwIdealGain))) {
+			bGain = (u_char)floor(dRatio);
+		} else {
+			bGain = (u_char)ceil(dRatio);
+		}
+
+	} else {
+
+		dRatio = m_dwIdealGain / (wMax / dAmp);
+		dAmp   = floor((dRatio / 3 - 0.93)/0.067);
+
+		if( dAmp > 31 )
+			dAmp = 31;
+
+		bGain = (u_char)dAmp + 32;
+	}
+	
+	if( bGain > 0x3f ) {
+		DBG( _DBG_INFO, "* GAIN Overflow!!!\n" );
+		bGain = 0x3f;
+	}
+	return bGain;
+}
+
+/** limit and set register given by address
+ * @param gain -
+ * @param reg  -
+ */
+static void setAdjGain( int gain, u_char *reg )
+{
+	if( gain >= 0 ) {
+
+		if( gain > 0x3f )
+			*reg = 0x3f;
+		else
+			*reg = gain;
+	}
+}
+
+/**
+ * @param channel - 0 = red, 1 = green, 2 = blue
+ * @param max     -
+ * @param ideal   -
+ * @param l_on    -
+ * @param l_off   -
+ * @return
+ */
+static SANE_Bool adjLampSetting( Plustek_Device *dev, int channel, u_long max,  
+                                 u_long ideal, u_short l_on, u_short *l_off )
+{
+	SANE_Bool adj = SANE_FALSE;
+	u_long    lamp_on;
+
+	/* so if the image was too bright, we dim the lamps by 3% */
+	if( max > ideal ) {
+
+		lamp_on = (*l_off) - l_on;
+	    lamp_on = (lamp_on * 97)/100;
+		*l_off  = l_on + lamp_on;
+        DBG( _DBG_INFO2,
+	                "lamp(%u) adjust (-3%%): %i %i\n", channel, l_on, *l_off );
+		adj = SANE_TRUE;
+	}
+
+    /* if the image was too dull, increase lamp by 1% */
+	if( dev->usbDev.a_bRegs[0x3b + channel] == 63 ) {
+
+		lamp_on  = (*l_off) - l_on;
+	    lamp_on += (lamp_on/100);
+		*l_off   = l_on + lamp_on;
+        DBG( _DBG_INFO2,
+	                "lamp(%u) adjust (+1%%): %i %i\n", channel, l_on, *l_off );
+		adj = SANE_TRUE;
+    }
+
+    return adj;
+}
+
+/** usb_AdjustGain
+ * function to perform the "coarse calibration step" part 1.
+ * We scan reference image pixels to determine the optimum coarse gain settings
+ * for R, G, B. (Analog gain and offset prior to ADC). These coefficients are
+ * applied at the line rate during normal scanning.
+ * The scanned line should contain a white strip with some black at the
+ * beginning. The function searches for the maximum value which corresponds to
+ * the maximum white value.
+ * Affects register 0x3b, 0x3c and 0x3d
+ *
+ */
+static SANE_Bool usb_AdjustGain( Plustek_Device *dev, int fNegative )
+{
+	char      tmp[40];
+	int       i;
+	double    min_mclk;
+	ScanDef  *scanning = &dev->scanning;
+	DCapsDef *scaps    = &dev->usbDev.Caps;
+	HWDef    *hw       = &dev->usbDev.HwSetting;
+	u_long   *scanbuf  = scanning->pScanBuffer;
+	u_char   *regs     = dev->usbDev.a_bRegs;
+	u_long    dw, start, end, len;
+	SANE_Bool fRepeatITA = SANE_TRUE;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	bMaxITA = 0xff;
+
+	DBG( _DBG_INFO, "#########################\n" );
+	DBG( _DBG_INFO, "usb_AdjustGain()\n" );
+	if((dev->adj.rgain != -1) && 
+	   (dev->adj.ggain != -1) && (dev->adj.bgain != -1)) {
+		setAdjGain( dev->adj.rgain, &regs[0x3b] );
+		setAdjGain( dev->adj.ggain, &regs[0x3c] );
+		setAdjGain( dev->adj.bgain, &regs[0x3d] );
+		DBG( _DBG_INFO, "- function skipped, using frontend values!\n" );
+		return SANE_TRUE;
+	}
+
+	min_mclk = usb_GetMCLK( dev, &scanning->sParam );
+
+	/* define the strip to scan for coarse calibration */
+	m_ScanParam.Size.dwLines  = 1;
+	m_ScanParam.Size.dwPixels = scaps->Normal.Size.x *
+	                            scaps->OpticDpi.x / 300UL;
+	m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels *
+	                            2 * m_ScanParam.bChannels;
+
+	if( usb_IsCISDevice(dev) && m_ScanParam.bDataType == SCANDATATYPE_Color)
+		m_ScanParam.Size.dwBytes *= 3;
+
+	m_ScanParam.Origin.x = (u_short)((u_long) hw->wActivePixelsStart *
+                                                    300UL / scaps->OpticDpi.x);
+	m_ScanParam.bCalibration = PARAM_Gain;
+
+	start = 0;
+	len   = m_ScanParam.Size.dwPixels;
+
+	if( scanning->sParam.bSource == SOURCE_Transparency ) {
+		start = scaps->Positive.DataOrigin.x * scaps->OpticDpi.x / 300UL;
+		len   = scaps->Positive.Size.x * scaps->OpticDpi.x / 300UL;
+	}
+	else if( scanning->sParam.bSource == SOURCE_Negative ) {
+		start = scaps->Negative.DataOrigin.x * scaps->OpticDpi.x / 300UL;
+		len   = scaps->Negative.Size.x * scaps->OpticDpi.x / 300UL;
+	}
+	end = start + len;
+
+	start = ((u_long)dev->usbDev.pSource->DataOrigin.x*scaps->OpticDpi.x/300UL);
+	len   = ((u_long)dev->usbDev.pSource->Size.x * scaps->OpticDpi.x / 300UL);
+
+	DBG( _DBG_INFO2, "Coarse Calibration Strip:\n" );
+	DBG( _DBG_INFO2, "Lines    = %lu\n", m_ScanParam.Size.dwLines  );
+	DBG( _DBG_INFO2, "Pixels   = %lu\n", m_ScanParam.Size.dwPixels );
+	DBG( _DBG_INFO2, "Bytes    = %lu\n", m_ScanParam.Size.dwBytes  );
+	DBG( _DBG_INFO2, "Origin.X = %u\n",  m_ScanParam.Origin.x );
+	DBG( _DBG_INFO2, "Start    = %lu\n", start );
+	DBG( _DBG_INFO2, "Len      = %lu\n", len   );
+	DBG( _DBG_INFO2, "End      = %lu\n", end   );
+	DBG( _DBG_INFO,  "MIN MCLK = %.2f\n", min_mclk );
+
+	i = 0;
+TOGAIN:
+	m_ScanParam.dMCLK = dMCLK;
+
+	if( !usb_SetScanParameters( dev, &m_ScanParam ))
+		return SANE_FALSE;
+
+	if( !usb_ScanBegin( dev, SANE_FALSE) ||
+		!usb_ScanReadImage( dev, scanbuf, m_ScanParam.Size.dwPhyBytes ) ||
+		!usb_ScanEnd( dev )) {
+		DBG( _DBG_ERROR, "usb_AdjustGain() failed\n" );
+		return SANE_FALSE;
+	}
+
+	DBG( _DBG_INFO2, "PhyBytes  = %lu\n",  m_ScanParam.Size.dwPhyBytes  );
+	DBG( _DBG_INFO2, "PhyPixels = %lu\n",  m_ScanParam.Size.dwPhyPixels );
+
+	if( end > m_ScanParam.Size.dwPhyPixels )
+		end = m_ScanParam.Size.dwPhyPixels;
+
+	sprintf( tmp, "coarse-gain-%u.raw", i++ );
+
+	dumpPicInit(&m_ScanParam, tmp);
+	dumpPic(tmp, (u_char*)scanbuf, m_ScanParam.Size.dwPhyBytes, 0);
+		
+#ifdef SWAP_COARSE
+	if(usb_HostSwap())
+#endif
+		usb_Swap((u_short *)scanbuf, m_ScanParam.Size.dwPhyBytes );
+
+	if( fNegative ) {
+
+		if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+
+			RGBULongDef rgb, rgbSum;
+			u_long      dwLoop = len / 20 * 20;
+			u_long      dw10, dwGray, dwGrayMax;
+
+			rgb.Red = rgb.Green = rgb.Blue = dwGrayMax = 0;
+
+			for( dw = start; dwLoop; dwLoop-- ) {
+
+				rgbSum.Red = rgbSum.Green = rgbSum.Blue = 0;
+				for( dw10 = 20; dw10--; dw++ ) {
+					rgbSum.Red   += (u_long)(((RGBULongDef*)scanbuf)[dw].Red);
+					rgbSum.Green += (u_long)(((RGBULongDef*)scanbuf)[dw].Green);
+					rgbSum.Blue  += (u_long)(((RGBULongDef*)scanbuf)[dw].Blue);
+				}
+
+				/* do some weighting of the color planes for negatives */
+				dwGray = (rgbSum.Red * 30UL + rgbSum.Green * 59UL + rgbSum.Blue * 11UL) / 100UL;
+
+				if( fNegative == 1 || rgbSum.Red > rgbSum.Green) {
+					if( dwGray > dwGrayMax ) {
+						dwGrayMax = dwGray;
+						rgb.Red   = rgbSum.Red;
+						rgb.Green = rgbSum.Green;
+						rgb.Blue  = rgbSum.Blue;
+					}
+				}
+			}
+
+			Gain_Hilight.Red   = (u_short)(rgb.Red / 20UL);
+			Gain_Hilight.Green = (u_short)(rgb.Green / 20UL);
+			Gain_Hilight.Blue  = (u_short)(rgb.Blue / 20UL);
+			DBG(_DBG_INFO2, "MAX(R,G,B)= 0x%04x(%u), 0x%04x(%u), 0x%04x(%u)\n",
+			    Gain_Hilight.Red, Gain_Hilight.Red, Gain_Hilight.Green, 
+			    Gain_Hilight.Green, Gain_Hilight.Blue, Gain_Hilight.Blue );
+
+			regs[0x3b] = usb_GetNewGain(dev,Gain_Hilight.Red,   0 );
+			regs[0x3c] = usb_GetNewGain(dev,Gain_Hilight.Green, 1 );
+			regs[0x3d] = usb_GetNewGain(dev,Gain_Hilight.Blue,  2 );
+
+		} else {
+
+			u_long dwMax  = 0, dwSum;
+			u_long dwLoop = len / 20 * 20;
+			u_long dw10;
+
+			for( dw = start; dwLoop; dwLoop-- ) {
+
+				dwSum = 0;
+				for( dw10 = 20; dw10--; dw++ )
+					dwSum += (u_long)((u_short*)scanbuf)[dw];
+
+				if((fNegative == 1) || (dwSum < 0x6000 * 20)) {
+					if( dwMax < dwSum )
+						dwMax = dwSum;
+				}
+			}
+			Gain_Hilight.Red  = Gain_Hilight.Green =
+			Gain_Hilight.Blue = (u_short)(dwMax / 20UL);
+
+			Gain_Reg.Red  = Gain_Reg.Green =
+			Gain_Reg.Blue = regs[0x3b] =
+			regs[0x3c] = regs[0x3d] = usb_GetNewGain(dev,Gain_Hilight.Green,1);
+		}
+	} else {
+	
+		if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+
+			RGBUShortDef max_rgb, min_rgb, tmp_rgb;
+			u_long       dwR, dwG, dwB;
+			u_long       dwDiv   = 10;
+			u_long       dwLoop1 = len / dwDiv, dwLoop2;
+
+			max_rgb.Red = max_rgb.Green = max_rgb.Blue = 0;
+			min_rgb.Red = min_rgb.Green = min_rgb.Blue = 0xffff;
+
+			/* find out the max pixel value for R, G, B */
+			for( dw = start; dwLoop1; dwLoop1-- ) {
+
+				/* do some averaging... */
+				for (dwLoop2 = dwDiv, dwR = dwG = dwB = 0;
+				                                    dwLoop2; dwLoop2--, dw++) {
+					if( usb_IsCISDevice(dev)) {
+						dwR += ((u_short*)scanbuf)[dw];
+						dwG += ((u_short*)scanbuf)[dw+m_ScanParam.Size.dwPhyPixels+1];
+						dwB += ((u_short*)scanbuf)[dw+(m_ScanParam.Size.dwPhyPixels+1)*2];
+            		} else {
+						dwR += ((RGBUShortDef*)scanbuf)[dw].Red;
+						dwG += ((RGBUShortDef*)scanbuf)[dw].Green;
+						dwB += ((RGBUShortDef*)scanbuf)[dw].Blue;
+					}
+				}
+				dwR = dwR / dwDiv;
+				dwG = dwG / dwDiv;
+				dwB = dwB / dwDiv;
+
+				if(max_rgb.Red < dwR)
+					max_rgb.Red = dwR;
+				if(max_rgb.Green < dwG)
+					max_rgb.Green = dwG;
+				if(max_rgb.Blue < dwB)
+					max_rgb.Blue = dwB;
+
+				if(min_rgb.Red > dwR)
+					min_rgb.Red = dwR;
+				if(min_rgb.Green > dwG)
+					min_rgb.Green = dwG;
+				if(min_rgb.Blue > dwB)
+					min_rgb.Blue = dwB;
+			}
+
+			DBG(_DBG_INFO2, "MAX(R,G,B)= 0x%04x(%u), 0x%04x(%u), 0x%04x(%u)\n",
+				  	max_rgb.Red, max_rgb.Red, max_rgb.Green,
+					max_rgb.Green, max_rgb.Blue, max_rgb.Blue );
+			DBG(_DBG_INFO2, "MIN(R,G,B)= 0x%04x(%u), 0x%04x(%u), 0x%04x(%u)\n",
+				  	min_rgb.Red, min_rgb.Red, min_rgb.Green,
+					min_rgb.Green, min_rgb.Blue, min_rgb.Blue );
+
+			/* on CIS scanner, we use the min value, on CCD the max value
+			 * for adjusting the gain
+			 */
+			tmp_rgb = max_rgb;
+			if( usb_IsCISDevice(dev))
+				tmp_rgb = min_rgb;
+
+			DBG(_DBG_INFO2, "CUR(R,G,B)= 0x%04x(%u), 0x%04x(%u), 0x%04x(%u)\n",
+				  	tmp_rgb.Red, tmp_rgb.Red, tmp_rgb.Green,
+				    tmp_rgb.Green, tmp_rgb.Blue, tmp_rgb.Blue);
+
+/*			m_dwIdealGain = IDEAL_GainNormal;
+*/						 /* min(min(rgb.wRed, rgb.wGreen), rgb.wBlue) */
+
+			regs[0x3b] = usb_GetNewGain( dev, tmp_rgb.Red,   0 );
+			regs[0x3c] = usb_GetNewGain( dev, tmp_rgb.Green, 1 );
+			regs[0x3d] = usb_GetNewGain( dev, tmp_rgb.Blue,  2 );
+
+			if( !_IS_PLUSTEKMOTOR(hw->motorModel)) {
+
+				SANE_Bool adj = SANE_FALSE;
+
+				/* on CIS devices, we can control the lamp off settings */
+				if( usb_IsCISDevice(dev)) {
+
+/*					m_dwIdealGain = IDEAL_GainNormal;
+ */
+					if( adjLampSetting( dev, CHANNEL_red, tmp_rgb.Red, m_dwIdealGain,
+					                    hw->red_lamp_on, &hw->red_lamp_off )) {
+						adj = SANE_TRUE;
+					}
+
+					if( adjLampSetting( dev, CHANNEL_green, tmp_rgb.Green, m_dwIdealGain,
+								    hw->green_lamp_on, &hw->green_lamp_off )) {
+						adj = SANE_TRUE;
+					}
+
+					if( adjLampSetting( dev, CHANNEL_blue, tmp_rgb.Blue, m_dwIdealGain,
+									    hw->blue_lamp_on, &hw->blue_lamp_off)){
+						adj = SANE_TRUE;
+					}
+
+					/* on any adjustment, set the registers... */
+					if( adj ) {
+						usb_AdjustLamps( dev, SANE_TRUE );
+
+						if( i < _MAX_GAIN_LOOPS )
+							goto TOGAIN;
+					}
+
+				} else {
+
+					if((!regs[0x3b] ||
+					    !regs[0x3c] || !regs[0x3d]) && dMCLK > min_mclk) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK - 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+						
+						adj = SANE_TRUE;
+
+					} else if(((regs[0x3b] == 63) || (regs[0x3c] == 63) ||
+									  (regs[0x3d] == 63)) && (dMCLK < 10)) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK + 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+						adj = SANE_TRUE;
+					}
+
+					if( adj ) {
+						if( i < _MAX_GAIN_LOOPS )
+							goto TOGAIN;
+					}
+				}
+				
+			} else {
+
+				/* for MODEL KaoHsiung 1200 scanner multi-straight-line bug at
+				 * 1200 dpi color mode
+				 */
+				if( hw->motorModel == MODEL_KaoHsiung &&
+				    scaps->bCCD == kNEC3778 && dMCLK>= 5.5 && !regs[0x3c]){
+
+					regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+					scanning->sParam.dMCLK = dMCLK = dMCLK - 1.5;
+					goto TOGAIN;
+
+				} else if( hw->motorModel == MODEL_HuaLien &&
+					       scaps->bCCD == kNEC3799 && fRepeatITA ) {
+
+					if((!regs[0x3b] ||
+					    !regs[0x3c] || !regs[0x3d]) && dMCLK > 3.0) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK - 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+						goto TOGAIN;
+
+					} else if(((regs[0x3b] == 63) || (regs[0x3c] == 63) ||
+										  (regs[0x3d] == 63)) && (dMCLK < 10)) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK + 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+						goto TOGAIN;
+					}
+					bMaxITA = (u_char)floor((dMCLK + 1) / 2);
+					fRepeatITA = SANE_FALSE;
+				}
+			}
+
+		} else {
+
+			u_short	w_max = 0, w_min = 0xffff, w_tmp;
+
+			for( dw = start; dw < end; dw++ ) {
+				if( w_max < ((u_short*)scanbuf)[dw])
+					w_max = ((u_short*)scanbuf)[dw];
+				if( w_min > ((u_short*)scanbuf)[dw])
+					w_min = ((u_short*)scanbuf)[dw];
+			}
+
+			w_tmp = w_max;
+			if( usb_IsCISDevice(dev))
+				w_tmp = w_min;
+
+			regs[0x3b] =
+			regs[0x3c] =
+			regs[0x3d] = usb_GetNewGain(dev, w_tmp, 0);
+
+			DBG(_DBG_INFO2, "MAX(G)= 0x%04x(%u)\n", w_max, w_max );
+			DBG(_DBG_INFO2, "MIN(G)= 0x%04x(%u)\n", w_min, w_min );
+			DBG(_DBG_INFO2, "CUR(G)= 0x%04x(%u)\n", w_tmp, w_tmp );
+
+/*			m_dwIdealGain = IDEAL_GainNormal;
+ */
+			if( !_IS_PLUSTEKMOTOR(hw->motorModel)) {
+
+				SANE_Bool adj = SANE_FALSE;
+
+				/* on CIS devices, we can control the lamp off settings */
+				if( usb_IsCISDevice(dev)) {
+
+					if( adjLampSetting( dev, CHANNEL_green, w_tmp, m_dwIdealGain,
+					                    hw->green_lamp_on, &hw->green_lamp_off )) {
+						adj = SANE_TRUE;
+					}
+
+					/* on any adjustment, set the registers... */
+					if( adj ) {
+						usb_AdjustLamps( dev, SANE_TRUE );
+
+						if( i < _MAX_GAIN_LOOPS )
+							goto TOGAIN;
+					}
+
+				} else {
+
+					if( !regs[0x3b] && (dMCLK > min_mclk)) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK - 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+						adj = SANE_TRUE;
+
+					} else if((regs[0x3b] == 63) && (dMCLK < 20)) {
+
+						scanning->sParam.dMCLK = dMCLK = dMCLK + 0.5;
+						regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+						adj = SANE_TRUE;
+					}
+
+					if( adj ) {
+						if( i < _MAX_GAIN_LOOPS )
+							goto TOGAIN;
+					}
+				}
+			}
+		}
+	}
+
+	DBG( _DBG_INFO2, "REG[0x3b] = %u\n", regs[0x3b] );
+	DBG( _DBG_INFO2, "REG[0x3c] = %u\n", regs[0x3c] );
+	DBG( _DBG_INFO2, "REG[0x3d] = %u\n", regs[0x3d] );
+
+	DBG( _DBG_INFO2, "red_lamp_on    = %u\n", hw->red_lamp_on  );
+	DBG( _DBG_INFO2, "red_lamp_off   = %u\n", hw->red_lamp_off );
+	DBG( _DBG_INFO2, "green_lamp_on  = %u\n", hw->green_lamp_on  );
+	DBG( _DBG_INFO2, "green_lamp_off = %u\n", hw->green_lamp_off );
+	DBG( _DBG_INFO2, "blue_lamp_on   = %u\n", hw->blue_lamp_on   );
+	DBG( _DBG_INFO2, "blue_lamp_off  = %u\n", hw->blue_lamp_off  );
+
+	DBG( _DBG_INFO, "usb_AdjustGain() done.\n" );
+	return SANE_TRUE;
+}
+
+/** usb_GetNewOffset
+ * @param pdwSum   -
+ * @param pdwDiff  -
+ * @param pcOffset -
+ * @param pIdeal   -
+ * @param channel  -
+ * @param cAdjust  -
+ */
+static void usb_GetNewOffset( Plustek_Device *dev, u_long *pdwSum, u_long *pdwDiff,
+                              signed char *pcOffset, u_char *pIdeal,
+                              u_long channel, signed char cAdjust )
+{
+	/* IDEAL_Offset is currently set to 0x1000 = 4096 */
+	u_long dwIdealOffset = IDEAL_Offset;
+
+	if( pdwSum[channel] > dwIdealOffset ) {
+
+		/* Over ideal value */
+		pdwSum[channel] -= dwIdealOffset;
+		if( pdwSum[channel] < pdwDiff[channel] ) {
+			/* New offset is better than old one */
+			pdwDiff[channel] = pdwSum[channel];
+			pIdeal[channel]  = dev->usbDev.a_bRegs[0x38 + channel];
+		}
+		pcOffset[channel] -= cAdjust;
+
+	} else 	{
+
+		/* Below than ideal value */
+		pdwSum[channel] = dwIdealOffset - pdwSum [channel];
+		if( pdwSum[channel] < pdwDiff[channel] ) {
+			/* New offset is better than old one */
+			pdwDiff[channel] = pdwSum[channel];
+			pIdeal[channel]  = dev->usbDev.a_bRegs[0x38 + channel];
+		}
+		pcOffset[channel] += cAdjust;
+	}
+
+	if( pcOffset[channel] >= 0 )
+		dev->usbDev.a_bRegs[0x38 + channel] = pcOffset[channel];
+	else
+		dev->usbDev.a_bRegs[0x38 + channel] = (u_char)(32 - pcOffset[channel]);
+}
+
+/** usb_AdjustOffset
+ * function to perform the "coarse calibration step" part 2.
+ * We scan reference image pixels to determine the optimum coarse offset settings
+ * for R, G, B. (Analog gain and offset prior to ADC). These coefficients are
+ * applied at the line rate during normal scanning.
+ * On CIS based devices, we switch the light off, on CCD devices, we use the optical
+ * black pixels.
+ * Affects register 0x38, 0x39 and 0x3a
+ */
+static SANE_Bool usb_AdjustOffset( Plustek_Device *dev )
+{
+	char          tmp[40];
+	signed char   cAdjust = 16;
+	signed char   cOffset[3];
+	u_char        bExpect[3];
+	int           i;
+	u_long        dw, dwPixels;
+    u_long        dwDiff[3], dwSum[3];
+
+	HWDef  *hw      = &dev->usbDev.HwSetting;
+	u_char *regs    = dev->usbDev.a_bRegs;
+	u_long *scanbuf = dev->scanning.pScanBuffer;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	DBG( _DBG_INFO, "#########################\n" );
+	DBG( _DBG_INFO, "usb_AdjustOffset()\n" );
+	if((dev->adj.rofs != -1) && 
+	   (dev->adj.gofs != -1) && (dev->adj.bofs != -1)) {
+		regs[0x38] = (dev->adj.rofs & 0x3f);
+		regs[0x39] = (dev->adj.gofs & 0x3f);
+		regs[0x3a] = (dev->adj.bofs & 0x3f);
+		DBG( _DBG_INFO, "- function skipped, using frontend values!\n" );
+		return SANE_TRUE;
+	}
+
+	m_ScanParam.Size.dwLines  = 1;
+	m_ScanParam.Size.dwPixels = 2550;
+
+	if( usb_IsCISDevice(dev))
+		dwPixels = m_ScanParam.Size.dwPixels;
+	else
+		dwPixels = (u_long)(hw->bOpticBlackEnd - hw->bOpticBlackStart );
+
+	m_ScanParam.Size.dwPixels = 2550;
+	m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels * 2 *
+	                                                     m_ScanParam.bChannels;
+	if( usb_IsCISDevice(dev) && m_ScanParam.bDataType == SCANDATATYPE_Color )
+		m_ScanParam.Size.dwBytes *= 3;
+
+	m_ScanParam.Origin.x = (u_short)((u_long)hw->bOpticBlackStart * 300UL /
+												  dev->usbDev.Caps.OpticDpi.x);
+	m_ScanParam.bCalibration = PARAM_Offset;
+ 	m_ScanParam.dMCLK        = dMCLK;
+
+	dwDiff[0]  = dwDiff[1]  = dwDiff[2]  = 0xffff;
+	cOffset[0] = cOffset[1] = cOffset[2] = 0;
+	bExpect[0] = bExpect[1] = bExpect[2] = 0;
+
+	regs[0x38] = regs[0x39] = regs[0x3a] = 0;
+
+	if( usb_IsCISDevice(dev)) {
+	    /*
+		 * if we have dark shading strip, there's no need to switch
+	     * the lamp off
+		 */
+		if( dev->usbDev.pSource->DarkShadOrgY >= 0 ) {
+
+			usb_ModuleToHome( dev, SANE_TRUE );
+			usb_ModuleMove  ( dev, MOVE_Forward,
+								(u_long)dev->usbDev.pSource->DarkShadOrgY );
+
+			regs[0x45] &= ~0x10;
+
+		} else {
+
+		 	/* switch lamp off to read dark data... */
+			regs[0x29] = 0;
+			usb_switchLamp( dev, SANE_FALSE );
+		}
+	}
+
+	if( 0 == dwPixels ) {
+		DBG( _DBG_ERROR, "OpticBlackEnd = OpticBlackStart!!!\n" );
+		return SANE_FALSE;
+	}
+
+	if( !usb_SetScanParameters( dev, &m_ScanParam )) {
+		DBG( _DBG_ERROR, "usb_AdjustOffset() failed\n" );
+		return SANE_FALSE;
+	}
+		
+	i = 0;
+
+	DBG( _DBG_INFO2, "S.dwPixels  = %lu\n", m_ScanParam.Size.dwPixels );		
+	DBG( _DBG_INFO2, "dwPixels    = %lu\n", dwPixels );
+	DBG( _DBG_INFO2, "dwPhyBytes  = %lu\n", m_ScanParam.Size.dwPhyBytes );
+	DBG( _DBG_INFO2, "dwPhyPixels = %lu\n", m_ScanParam.Size.dwPhyPixels );
+
+	while( cAdjust ) {
+
+		/*
+		 * read data (a white calibration strip - hopefully ;-)
+		 */
+		if((!usb_ScanBegin(dev, SANE_FALSE)) ||
+		   (!usb_ScanReadImage(dev,scanbuf,m_ScanParam.Size.dwPhyBytes)) ||
+			!usb_ScanEnd( dev )) {
+			DBG( _DBG_ERROR, "usb_AdjustOffset() failed\n" );
+			return SANE_FALSE;
+		}
+
+		sprintf( tmp, "coarse-off-%u.raw", i++ );
+		
+#ifdef SWAP_COARSE
+		if(usb_HostSwap())
+			usb_Swap((u_short *)scanbuf, m_ScanParam.Size.dwPhyBytes );
+#endif
+		dumpPicInit(&m_ScanParam, tmp);
+		dumpPic(tmp, (u_char*)scanbuf, m_ScanParam.Size.dwPhyBytes, 0);
+
+		if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+
+			dwSum[0] = dwSum[1] = dwSum[2] = 0;
+
+			for (dw = 0; dw < dwPixels; dw++) {
+#ifndef SWAP_COARSE
+				dwSum[0] += (u_long)_HILO2WORD(((ColorWordDef*)scanbuf)[dw].HiLo[0]);
+				dwSum[1] += (u_long)_HILO2WORD(((ColorWordDef*)scanbuf)[dw].HiLo[1]);
+				dwSum[2] += (u_long)_HILO2WORD(((ColorWordDef*)scanbuf)[dw].HiLo[2]);
+#else
+				dwSum[0] += ((RGBUShortDef*)scanbuf)[dw].Red;
+				dwSum[1] += ((RGBUShortDef*)scanbuf)[dw].Green;
+				dwSum[2] += ((RGBUShortDef*)scanbuf)[dw].Blue;
+#endif
+			}
+
+            DBG( _DBG_INFO2, "RedSum   = %lu, ave = %lu\n",
+												dwSum[0], dwSum[0] /dwPixels );
+            DBG( _DBG_INFO2, "GreenSum = %lu, ave = %lu\n",
+												dwSum[1], dwSum[1] /dwPixels );
+            DBG( _DBG_INFO2, "BlueSum  = %lu, ave = %lu\n",
+												dwSum[2], dwSum[2] /dwPixels );
+			
+			/* do averaging for each channel */
+			dwSum[0] /= dwPixels;
+			dwSum[1] /= dwPixels;
+			dwSum[2] /= dwPixels;
+
+			usb_GetNewOffset( dev, dwSum, dwDiff, cOffset, bExpect, 0, cAdjust );
+			usb_GetNewOffset( dev, dwSum, dwDiff, cOffset, bExpect, 1, cAdjust );
+			usb_GetNewOffset( dev, dwSum, dwDiff, cOffset, bExpect, 2, cAdjust );
+
+            DBG( _DBG_INFO2, "RedExpect   = %u\n", bExpect[0] );
+            DBG( _DBG_INFO2, "GreenExpect = %u\n", bExpect[1] );
+            DBG( _DBG_INFO2, "BlueExpect  = %u\n", bExpect[2] );
+
+		} else {
+			dwSum[0] = 0;
+
+			for( dw = 0; dw < dwPixels; dw++ ) {
+#ifndef SWAP_COARSE
+				dwSum[0] += (u_long)_HILO2WORD(((HiLoDef*)scanbuf)[dw]);
+#else
+				dwSum[0] += ((u_short*)scanbuf)[dw];
+#endif
+			}
+			dwSum [0] /= dwPixels;
+			usb_GetNewOffset( dev, dwSum, dwDiff, cOffset, bExpect, 0, cAdjust );
+			regs[0x3a] = regs[0x39] = regs[0x38];
+
+			DBG(_DBG_INFO2,"Sum = %lu, ave = %lu\n",dwSum[0],dwSum[0]/dwPixels);
+			DBG(_DBG_INFO2,"Expect = %u\n", bExpect[0]);
+		}
+
+		_UIO(sanei_lm983x_write(dev->fd, 0x38, &regs[0x38], 3, SANE_TRUE));
+		cAdjust >>= 1;
+	}
+
+	if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+		regs[0x38] = bExpect[0];
+		regs[0x39] = bExpect[1];
+		regs[0x3a] = bExpect[2];
+	} else {
+
+		regs[0x38] = regs[0x39] = regs[0x3a] = bExpect[0];	
+	}
+
+	DBG( _DBG_INFO2, "REG[0x38] = %u\n", regs[0x38] );
+	DBG( _DBG_INFO2, "REG[0x39] = %u\n", regs[0x39] );
+	DBG( _DBG_INFO2, "REG[0x3a] = %u\n", regs[0x3a] );
+	DBG( _DBG_INFO, "usb_AdjustOffset() done.\n" );
+
+	/* switch it on again on CIS based scanners */
+	if( usb_IsCISDevice(dev)) {
+
+		if( dev->usbDev.pSource->DarkShadOrgY < 0 ) {
+			regs[0x29] = hw->bReg_0x29;
+			usb_switchLamp( dev, SANE_TRUE );
+			usbio_WriteReg( dev->fd, 0x29, regs[0x29]);
+		}
+	}
+
+	return SANE_TRUE;
+}
+
+/** this function tries to find out some suitable values for the dark
+ *  fine calibration. If the device owns a black calibration strip
+ *  the data is simply copied. If not, then the white strip is read 
+ *  with the lamp switched off...
+ */
+static void usb_GetDarkShading( Plustek_Device *dev, u_short *pwDest,
+                                HiLoDef *pSrce, u_long dwPixels,
+                                u_long dwAdd, int iOffset )
+{
+	u_long    dw;
+	u_long    dwSum[2];
+	DCapsDef *scaps = &dev->usbDev.Caps;
+	HWDef    *hw    = &dev->usbDev.HwSetting;
+
+	if( dev->usbDev.pSource->DarkShadOrgY >= 0 ) {
+
+		u_short w;
+		int     wtmp;
+
+		/* here we use the source  buffer + a static offset */
+		for (dw = 0; dw < dwPixels; dw++, pSrce += dwAdd)
+		{
+#ifndef SWAP_FINE
+			wtmp = ((int)_PHILO2WORD(pSrce) + iOffset);
+#else
+			wtmp = ((int)_PLOHI2WORD(pSrce) + iOffset);
+#endif
+			if( wtmp < 0 )
+				wtmp = 0;
+
+			if( wtmp > 0xffff )
+				wtmp = 0xffff;
+
+			w = (u_short)wtmp;
+
+#ifndef SWAP_FINE
+			pwDest[dw] = _LOBYTE(w) * 256 + _HIBYTE(w);
+#else
+			pwDest[dw] = w;
+#endif
+		}
+	}
+	else
+	{
+		dwSum[0] = dwSum[1] = 0;
+		if( hw->bSensorConfiguration & 0x04 ) {
+
+			/* Even/Odd CCD */
+			for( dw = 0; dw < dwPixels; dw++, pSrce += dwAdd ) {
+#ifndef SWAP_FINE
+				dwSum[dw & 1] += (u_long)_PHILO2WORD(pSrce);
+#else
+				dwSum[dw & 1] += (u_long)_PLOHI2WORD(pSrce);
+#endif
+			}
+			dwSum[0] /= ((dwPixels + 1UL) >> 1);
+			dwSum[1] /= (dwPixels >> 1);
+
+			if( /*Registry.GetEvenOdd() == 1 ||*/ scaps->bPCB == 2)
+			{
+				dwSum[0] = dwSum[1] = (dwSum[0] + dwSum[1]) / 2;
+			}
+
+			dwSum[0] = (int)dwSum[0] + iOffset;
+			dwSum[1] = (int)dwSum[1] + iOffset;
+
+			if((int)dwSum[0] < 0)
+				dwSum[0] = 0;
+
+			if((int)dwSum[1] < 0)
+				dwSum[1] = 0;
+#ifndef SWAP_FINE
+			dwSum[0] = (u_long)_LOBYTE(_LOWORD(dwSum[0])) * 256UL +
+			                             _HIBYTE(_LOWORD(dwSum[0]));
+			dwSum[1] = (u_long)_LOBYTE(_LOWORD(dwSum[1])) * 256UL +
+			                             _HIBYTE(_LOWORD(dwSum[1]));
+#else
+			dwSum[0] = (u_long)_LOWORD(dwSum[0]);
+			dwSum[1] = (u_long)_LOWORD(dwSum[1]);
+#endif
+
+			for( dw = 0; dw < dwPixels; dw++ )
+				pwDest[dw] = (u_short)dwSum[dw & 1];
+		} else {
+			
+			/* Standard CCD */
+
+			/* do some averaging on the line */
+			for( dw = 0; dw < dwPixels; dw++, pSrce += dwAdd ) {
+#ifndef SWAP_FINE
+				dwSum[0] += (u_long)_PHILO2WORD(pSrce);
+#else
+				dwSum[0] += (u_long)_PLOHI2WORD(pSrce);
+#endif
+			}
+
+			dwSum[0] /= dwPixels;
+
+			/* add our offset... */
+			dwSum[0] = (int)dwSum[0] + iOffset;
+			if((int)dwSum[0] < 0)
+				dwSum[0] = 0;
+#ifndef SWAP_FINE
+			dwSum[0] = (u_long)_LOBYTE(_LOWORD(dwSum[0])) * 256UL +
+			                             _HIBYTE(_LOWORD(dwSum[0]));
+#else
+			dwSum[0] = (u_long)_LOWORD(dwSum[0]);
+#endif
+
+			/* fill the shading data */
+			for( dw = 0; dw < dwPixels; dw++ )
+				pwDest[dw] = (u_short)dwSum[0];
+		}
+	}
+#ifdef SWAP_FINE
+	if(usb_HostSwap())
+		usb_Swap( pwDest, dwPixels *2 );
+#endif
+}
+
+/** usb_AdjustDarkShading
+ * fine calibration part 1 - read the black calibration area and write
+ * the black line data to the offset coefficient data in Merlins' DRAM
+ * If there's no black line available, we can use the min pixel value
+ * from coarse calibration...
+ */
+static SANE_Bool usb_AdjustDarkShading( Plustek_Device *dev )
+{
+	char      tmp[40];
+	ScanDef  *scanning = &dev->scanning;
+	DCapsDef *scaps    = &dev->usbDev.Caps;
+	HWDef    *hw       = &dev->usbDev.HwSetting;
+	u_long   *scanbuf  = scanning->pScanBuffer;
+	u_char   *regs     = dev->usbDev.a_bRegs;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	if( scaps->workaroundFlag & _WAF_SKIP_FINE )
+		return SANE_TRUE;
+
+	DBG( _DBG_INFO, "#########################\n" );
+	DBG( _DBG_INFO, "usb_AdjustDarkShading()\n" );
+	DBG( _DBG_INFO2, "* MCLK = %f (scanparam-MCLK=%f)\n",
+	                    dMCLK, scanning->sParam.dMCLK );
+
+	usb_PrepareFineCal( dev, &m_ScanParam, 0 );
+
+	m_ScanParam.Size.dwLines = 1;				/* for gain */
+	m_ScanParam.bCalibration = PARAM_DarkShading;
+
+	if( _LM9831 == hw->chip ) {
+
+		m_ScanParam.UserDpi.x = usb_SetAsicDpiX( dev, m_ScanParam.UserDpi.x);
+		if( m_ScanParam.UserDpi.x < 100)
+			m_ScanParam.UserDpi.x = 150;
+
+		/* Now DPI X is physical */
+		m_ScanParam.Origin.x      = m_ScanParam.Origin.x %
+		                            (u_short)m_dHDPIDivider;
+		m_ScanParam.Size.dwPixels = (u_long)scaps->Normal.Size.x *
+		                                    m_ScanParam.UserDpi.x / 300UL;
+		m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels *
+		                            2UL * m_ScanParam.bChannels;
+		m_dwPixels = scanning->sParam.Size.dwPixels *
+		             m_ScanParam.UserDpi.x / scanning->sParam.UserDpi.x;
+
+		if( usb_IsCISDevice(dev) && m_ScanParam.bDataType == SCANDATATYPE_Color )
+			m_ScanParam.Size.dwBytes *= 3;
+    }
+
+	/* if we have dark shading strip, there's no need to switch
+	 * the lamp off
+	 */
+	if( dev->usbDev.pSource->DarkShadOrgY >= 0 ) {
+
+		usb_ModuleToHome( dev, SANE_TRUE );
+		usb_ModuleMove  ( dev, MOVE_Forward,
+		                  (u_long)dev->usbDev.pSource->DarkShadOrgY );
+	} else {
+
+	 	/* switch lamp off to read dark data... */
+		regs[0x29] = 0;
+		usb_switchLamp( dev, SANE_FALSE );
+	}
+
+	usb_SetScanParameters( dev, &m_ScanParam );
+
+	if((!usb_ScanBegin(dev, SANE_FALSE)) ||
+	   (!usb_ScanReadImage(dev,scanbuf, m_ScanParam.Size.dwPhyBytes)) ||
+	   (!usb_ScanEnd( dev ))) {
+
+		/* on error, reset the lamp settings*/
+		regs[0x29] = hw->bReg_0x29;
+ 		usb_switchLamp( dev, SANE_TRUE );
+		usbio_WriteReg( dev->fd, 0x29, regs[0x29] );
+
+		DBG( _DBG_ERROR, "usb_AdjustDarkShading() failed\n" );
+		return SANE_FALSE;
+	}
+	
+	/* set illumination mode and switch lamp on again
+	 */
+	regs[0x29] = hw->bReg_0x29;
+	usb_switchLamp( dev, SANE_TRUE );
+
+	if( !usbio_WriteReg( dev->fd, 0x29, regs[0x29])) {
+		DBG( _DBG_ERROR, "usb_AdjustDarkShading() failed\n" );
+		return SANE_FALSE;
+	}
+
+#ifdef SWAP_FINE
+	if(usb_HostSwap())
+		usb_Swap((u_short *)scanbuf, m_ScanParam.Size.dwPhyBytes );
+#endif
+
+	sprintf( tmp, "fine-black.raw" );
+
+	dumpPicInit(&m_ScanParam, tmp);
+	dumpPic(tmp, (u_char*)scanbuf, m_ScanParam.Size.dwPhyBytes, 0);
+
+	usleep(500 * 1000);    /* Warm up lamp again */
+
+	if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+
+		if( usb_IsCISDevice(dev)) {
+
+			usb_GetDarkShading( dev, a_wDarkShading, (HiLoDef*)scanbuf,
+			                    m_ScanParam.Size.dwPhyPixels, 1,
+			                    scanning->sParam.swOffset[0]);
+
+			usb_GetDarkShading( dev, a_wDarkShading + m_ScanParam.Size.dwPhyPixels,
+			                    (HiLoDef*)scanbuf + m_ScanParam.Size.dwPhyPixels,
+			                     m_ScanParam.Size.dwPhyPixels, 1, scanning->sParam.swOffset[1]);
+
+			usb_GetDarkShading( dev, a_wDarkShading + m_ScanParam.Size.dwPhyPixels * 2,
+			               (HiLoDef*)scanbuf + m_ScanParam.Size.dwPhyPixels * 2,
+			               m_ScanParam.Size.dwPhyPixels, 1, scanning->sParam.swOffset[2]);
+
+		} else {
+
+			usb_GetDarkShading( dev, a_wDarkShading, (HiLoDef*)scanbuf,
+			                    m_ScanParam.Size.dwPhyPixels, 3,
+			                    scanning->sParam.swOffset[0]);
+			usb_GetDarkShading( dev, a_wDarkShading + m_ScanParam.Size.dwPhyPixels,
+			                (HiLoDef*)scanbuf + 1, m_ScanParam.Size.dwPhyPixels,
+			                3, scanning->sParam.swOffset[1]);
+			usb_GetDarkShading( dev, a_wDarkShading + m_ScanParam.Size.dwPhyPixels * 2,
+			               (HiLoDef*)scanbuf + 2, m_ScanParam.Size.dwPhyPixels,
+			               3, scanning->sParam.swOffset[2]);
+		}
+	} else {
+
+		usb_GetDarkShading( dev, a_wDarkShading, (HiLoDef*)scanbuf,
+		                    m_ScanParam.Size.dwPhyPixels, 1,
+		                    scanning->sParam.swOffset[1]);
+
+		memcpy( a_wDarkShading + m_ScanParam.Size.dwPhyPixels,
+		        a_wDarkShading, m_ScanParam.Size.dwPhyPixels * 2 );
+		memcpy( a_wDarkShading + m_ScanParam.Size.dwPhyPixels * 2,
+		        a_wDarkShading, m_ScanParam.Size.dwPhyPixels * 2 );
+	}
+
+	regs[0x45] |= 0x10;
+
+	usb_line_statistics( "Dark", a_wDarkShading, m_ScanParam.Size.dwPhyPixels,
+                          scanning->sParam.bDataType == SCANDATATYPE_Color?1:0);
+	return SANE_TRUE;
+}
+
+/** function to remove the brightest values out of each row
+ * @param dev           - the almighty device structure.
+ * @param sp            - is a pointer to the scanparam structure used for
+ *                        scanning the shading lines.
+ * @param hilight       - defines the number of values to skip.
+ * @param shading_lines - defines the overall number of shading lines.
+ */
+static void usb_CalSortHighlight( Plustek_Device *dev, ScanParam *sp, 
+                                  u_long hilight, u_long shading_lines )
+{
+    ScanDef      *scan = &dev->scanning;
+	u_short       r, g, b;
+	u_long        lines, w, x;
+	RGBUShortDef *pw, *rgb;
+
+	if( hilight == 0 )
+		return;
+
+	rgb = (RGBUShortDef*)scan->pScanBuffer;
+
+	/* do it for all relevant lines */
+	for( lines = hilight,  rgb = rgb + sp->Size.dwPhyPixels * lines;
+	     lines < shading_lines; lines++, rgb += sp->Size.dwPhyPixels ) {
+
+		/* scan the complete line */
+		for( x = 0; x < sp->Size.dwPhyPixels; x++ ) {
+
+			/* reference is the first scanline */
+			pw = (RGBUShortDef*)scan->pScanBuffer;
+			r = rgb[x].Red;
+			g = rgb[x].Green;
+			b = rgb[x].Blue;
+
+			for( w = 0; w < hilight; w++, pw += sp->Size.dwPhyPixels ) {
+
+				if( r > pw[x].Red )
+					_SWAP( r, pw[x].Red );
+
+				if( g > pw[x].Green )
+					_SWAP( g, pw[x].Green );
+
+				if( b > pw[x].Blue )
+					_SWAP( b, pw[x].Blue );
+			}
+			rgb[x].Red   = r;
+			rgb[x].Green = g;
+			rgb[x].Blue  = b;
+		}
+	}
+}
+
+/** function to remove the brightest values out of each row
+ * @param dev           - the almighty device structure.
+ * @param sp            - is a pointer to the scanparam structure used for 
+ *                        scanning the shading lines.
+ * @param hilight       - defines the number of values to skip.
+ * @param shading_lines - defines the overall number of shading lines.
+ */
+static void usb_CalSortShadow( Plustek_Device *dev, ScanParam *sp,
+                               u_long hilight, u_long shadow, u_long shading_lines )
+{
+	ScanDef      *scan = &dev->scanning;
+	u_short       r, g, b;
+	u_long        lines, w, x;
+	RGBUShortDef *pw, *rgb;
+
+	if( shadow == 0 )
+		return;
+
+	rgb = (RGBUShortDef*)scan->pScanBuffer;
+
+	for( lines = hilight,  rgb = rgb + sp->Size.dwPhyPixels * lines;
+	     lines < shading_lines-shadow; lines++, rgb += sp->Size.dwPhyPixels ) {
+
+		for (x = 0; x < sp->Size.dwPhyPixels; x++) {
+
+			pw = ((RGBUShortDef*)scan->pScanBuffer) + (shading_lines - shadow) *
+			                                           sp->Size.dwPhyPixels;
+			r = rgb[x].Red;
+			g = rgb[x].Green;
+			b = rgb[x].Blue;
+
+			for( w = 0; w < shadow; w++, pw += sp->Size.dwPhyPixels ) {
+				if( r < pw[x].Red )
+					_SWAP( r, pw[x].Red );
+				if( g < pw[x].Green )
+					_SWAP( g, pw [x].Green );
+				if( b > pw[x].Blue )
+					_SWAP( b, pw[x].Blue );
+			}
+			rgb[x].Red   = r;
+			rgb[x].Green = g;
+			rgb[x].Blue  = b;
+		}
+	}
+}
+
+static void usb_procHighlightAndShadow( Plustek_Device *dev, ScanParam *sp,
+                                        u_long hilight, u_long shadow, u_long shading_lines )
+{
+	ScanDef      *scan = &dev->scanning;
+	u_long        lines, x;
+	u_long       *pr, *pg, *pb;
+	RGBUShortDef *rgb;
+
+	pr = (u_long*)((u_char*)scan->pScanBuffer + sp->Size.dwPhyBytes * shading_lines);
+	pg = pr + sp->Size.dwPhyPixels;
+	pb = pg + sp->Size.dwPhyPixels;
+
+	memset(pr, 0, sp->Size.dwPhyPixels * 4UL * 3UL);
+
+	/* Sort hilight */
+	usb_CalSortHighlight(dev, sp, hilight, shading_lines);
+
+	/* Sort shadow */
+	usb_CalSortShadow(dev, sp, hilight, shadow, shading_lines);
+
+	rgb  = (RGBUShortDef*)scan->pScanBuffer;
+	rgb += sp->Size.dwPhyPixels * hilight;
+
+	/* Sum */
+	for( lines = hilight; lines < (shading_lines-shadow); lines++ ) {
+
+		for( x = 0; x < sp->Size.dwPhyPixels; x++ ) {
+			pr[x] += rgb[x].Red;
+			pg[x] += rgb[x].Green;
+			pb[x] += rgb[x].Blue;
+		}
+
+		rgb += sp->Size.dwPhyPixels;
+	}
+}
+
+/** usb_AdjustWhiteShading
+ * fine calibration part 2 - read the white calibration area and calculate
+ * the gain coefficient for each pixel
+ */
+static SANE_Bool usb_AdjustWhiteShading( Plustek_Device *dev )
+{
+	char          tmp[40];
+	ScanDef      *scan  = &dev->scanning;
+	DCapsDef     *scaps = &dev->usbDev.Caps;
+	HWDef        *hw    = &dev->usbDev.HwSetting;
+	u_long       *pBuf  = scan->pScanBuffer;
+	u_long        dw, dwLines, dwRead;
+	u_long        shading_lines;
+	MonoWordDef  *pValue;
+	u_short      *m_pAvMono;
+	u_long       *pdw, *m_pSum;
+	u_short       hilight, shadow;
+	int           i;
+	SANE_Bool     swap = usb_HostSwap();
+	
+	if( scaps->workaroundFlag & _WAF_SKIP_FINE )
+		return SANE_TRUE;
+
+	DBG( _DBG_INFO, "#########################\n" );
+	DBG( _DBG_INFO, "usb_AdjustWhiteShading()\n" );
+	
+	m_pAvMono = (u_short*)scan->pScanBuffer;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	usb_PrepareFineCal( dev, &m_ScanParam, 0 );
+
+	if( m_ScanParam.PhyDpi.x > 75)
+		shading_lines = 64;
+	else
+		shading_lines = 32;
+
+	/* NOTE: hilight + shadow < shading_lines */
+	hilight = 4;
+	shadow  = 4;
+
+	m_ScanParam.bCalibration = PARAM_WhiteShading;
+	m_ScanParam.Size.dwLines = shading_lines;
+
+	if( _LM9831 == hw->chip ) {
+
+		m_ScanParam.UserDpi.x = usb_SetAsicDpiX( dev, m_ScanParam.UserDpi.x);
+		if( m_ScanParam.UserDpi.x < 100 )
+			m_ScanParam.UserDpi.x = 150;
+
+		/* Now DPI X is physical */
+		m_ScanParam.Origin.x      = m_ScanParam.Origin.x % (u_short)m_dHDPIDivider;
+		m_ScanParam.Size.dwPixels = (u_long)scaps->Normal.Size.x * m_ScanParam.UserDpi.x / 300UL;
+		m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels * 2UL * m_ScanParam.bChannels;
+		if( usb_IsCISDevice(dev) && m_ScanParam.bDataType == SCANDATATYPE_Color )
+			m_ScanParam.Size.dwBytes *= 3;
+
+		m_dwPixels = scan->sParam.Size.dwPixels * m_ScanParam.UserDpi.x / 
+		             scan->sParam.UserDpi.x;
+
+		dw = (u_long)(hw->wDRAMSize - 196 /*192 KiB*/) * 1024UL;
+		for( dwLines = dw / m_ScanParam.Size.dwBytes;
+			 dwLines < m_ScanParam.Size.dwLines; m_ScanParam.Size.dwLines>>=1);
+	}
+
+	/* goto the correct position again... */
+	if( dev->usbDev.pSource->DarkShadOrgY >= 0 ) {
+
+		usb_ModuleToHome( dev, SANE_TRUE );
+		usb_ModuleMove  ( dev, MOVE_Forward,
+		                  (u_long)dev->usbDev.pSource->ShadingOriginY );
+	}
+
+	sprintf( tmp, "fine-white.raw" );
+	DBG( _DBG_INFO2, "FINE WHITE Calibration Strip: %s\n", tmp );
+	DBG( _DBG_INFO2, "Shad.-Lines = %lu\n", shading_lines );
+	DBG( _DBG_INFO2, "Lines       = %lu\n", m_ScanParam.Size.dwLines  );
+	DBG( _DBG_INFO2, "Pixels      = %lu\n", m_ScanParam.Size.dwPixels );
+	DBG( _DBG_INFO2, "Bytes       = %lu\n", m_ScanParam.Size.dwBytes  );
+	DBG( _DBG_INFO2, "Origin.X    = %u\n",  m_ScanParam.Origin.x );
+
+	for( dw = shading_lines, dwRead = 0; dw; dw -= m_ScanParam.Size.dwLines ) {
+
+		if( usb_SetScanParameters( dev, &m_ScanParam ) &&
+		    usb_ScanBegin( dev, SANE_FALSE )) {
+
+			DBG(_DBG_INFO2,"TotalBytes = %lu\n",m_ScanParam.Size.dwTotalBytes);
+			if( _LM9831 == hw->chip ) {
+				/* Delay for white shading hold for 9831-1200 scanner */
+				usleep(900000);
+			}
+
+			if( usb_ScanReadImage( dev, (u_char*)pBuf + dwRead,
+			                       m_ScanParam.Size.dwTotalBytes)) {
+
+				if( _LM9831 == hw->chip ) {
+					/* Delay for white shading hold for 9831-1200 scanner */
+					usleep(10000);
+				}
+
+				if( 0 == dwRead ) {
+					dumpPicInit(&m_ScanParam, tmp);
+				}
+				
+				dumpPic(tmp, (u_char*)pBuf + dwRead, m_ScanParam.Size.dwTotalBytes, 0);
+
+				if( usb_ScanEnd( dev )) {
+					dwRead += m_ScanParam.Size.dwTotalBytes;
+					continue;
+				}
+			}
+		}
+
+		DBG( _DBG_ERROR, "usb_AdjustWhiteShading() failed\n" );
+		return SANE_FALSE;
+	}
+
+	m_pSum = (u_long*)((u_char*)pBuf + m_ScanParam.Size.dwPhyBytes * shading_lines);
+	
+	/*
+	 * do some reordering on CIS based devices:
+	 * from RRRRRRR.... GGGGGGGG.... BBBBBBBBB, create RGB RGB RGB ...
+	 * to use the following code, originally written for CCD devices...
+	 */
+	if( usb_IsCISDevice(dev)) {
+
+		u_short *dest, *src;
+		u_long   dww;
+
+		src = (u_short*)pBuf;
+
+		DBG( _DBG_INFO2, "PhyBytes  = %lu\n", m_ScanParam.Size.dwPhyBytes );
+		DBG( _DBG_INFO2, "PhyPixels = %lu\n", m_ScanParam.Size.dwPhyPixels );
+		DBG( _DBG_INFO2, "Pixels    = %lu\n", m_ScanParam.Size.dwPixels );
+		DBG( _DBG_INFO2, "Bytes     = %lu\n", m_ScanParam.Size.dwBytes  );
+		DBG( _DBG_INFO2, "Channels  = %u\n",  m_ScanParam.bChannels );
+
+		for( dwLines = shading_lines; dwLines; dwLines-- ) {
+
+			dest = a_wWhiteShading;
+
+			for( dw=dww=0; dw < m_ScanParam.Size.dwPhyPixels; dw++, dww+=3 ) {
+
+				dest[dww]     = src[dw];
+				dest[dww + 1] = src[m_ScanParam.Size.dwPhyPixels + dw];
+				dest[dww + 2] = src[m_ScanParam.Size.dwPhyPixels * 2 + dw];
+			}
+
+			/* copy line back ... */
+			memcpy( src, dest, m_ScanParam.Size.dwPhyPixels * 3 * 2 );
+			src = &src[m_ScanParam.Size.dwPhyPixels * 3];
+		}
+
+		m_ScanParam.bChannels = 3;
+	}
+
+	if( _LM9831 == hw->chip ) {
+
+		u_short *pwDest = (u_short*)pBuf;
+		HiLoDef *pwSrce = (HiLoDef*)pBuf;
+
+		pwSrce  += ((u_long)(scan->sParam.Origin.x-m_ScanParam.Origin.x) /
+		           (u_short)m_dHDPIDivider) *
+		                   (scaps->OpticDpi.x / 300UL) * m_ScanParam.bChannels;
+
+		for( dwLines = shading_lines; dwLines; dwLines--) {
+
+#ifdef SWAP_FINE
+			if(usb_HostSwap()) {
+#endif
+				for( dw = 0; dw < m_dwPixels * m_ScanParam.bChannels; dw++ ) 
+					pwDest[dw] = _HILO2WORD(pwSrce[dw]);
+#ifdef SWAP_FINE
+			} else {
+				for( dw = 0; dw < m_dwPixels * m_ScanParam.bChannels; dw++ )
+					pwDest[dw] = _LOHI2WORD(pwSrce[dw]);
+			}
+#endif
+			pwDest += (u_long)m_dwPixels * m_ScanParam.bChannels;
+			pwSrce  = (HiLoDef*)((u_char*)pwSrce + m_ScanParam.Size.dwPhyBytes);
+		}
+
+		_SWAP(m_ScanParam.Size.dwPhyPixels, m_dwPixels);
+	} else {
+		/* Discard the status word and conv. the hi-lo order to intel format */
+		u_short *pwDest = (u_short*)pBuf;
+		HiLoDef *pwSrce = (HiLoDef*)pBuf;
+
+		for( dwLines = shading_lines; dwLines; dwLines-- ) {
+
+#ifdef SWAP_FINE
+			if(usb_HostSwap()) {
+#endif
+				for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels *
+				                                 m_ScanParam.bChannels; dw++) {
+					pwDest[dw] = _HILO2WORD(pwSrce[dw]);
+				}
+#ifdef SWAP_FINE
+			} else {
+				for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels *
+				                                 m_ScanParam.bChannels; dw++) {
+					pwDest[dw] = _LOHI2WORD(pwSrce[dw]);
+				}
+			}
+#endif
+			pwDest += m_ScanParam.Size.dwPhyPixels * m_ScanParam.bChannels;
+			pwSrce = (HiLoDef*)((u_char*)pwSrce + m_ScanParam.Size.dwPhyBytes);
+		}
+	}
+
+	if( scan->sParam.bDataType == SCANDATATYPE_Color ) {
+
+		usb_procHighlightAndShadow(dev, &m_ScanParam, hilight, shadow, shading_lines);
+
+		pValue = (MonoWordDef*)a_wWhiteShading;
+		pdw    = (u_long*)m_pSum;
+
+		/* Software gain */
+		if( scan->sParam.bSource != SOURCE_Negative ) {
+
+			for( i = 0; i < 3; i++ ) {
+
+				for(dw=m_ScanParam.Size.dwPhyPixels; dw; dw--,pValue++,pdw++) {
+
+					*pdw = *pdw * 1000 / ((shading_lines - hilight - shadow) *
+					                               scan->sParam.swGain[i]);
+					if(*pdw > 65535U)
+						pValue->Mono = 65535U;
+					else
+						pValue->Mono = (u_short)*pdw;
+					
+					if (pValue->Mono > 16384U)
+						pValue->Mono = (u_short)(GAIN_Target * 16384U / pValue->Mono);
+					else
+						pValue->Mono = GAIN_Target;
+
+#ifdef SWAP_FINE
+					if( swap )
+#endif
+						_SWAP(pValue->HiLo.bHi, pValue->HiLo.bLo);
+				}
+			}
+		} else {
+			for( dw = m_ScanParam.Size.dwPhyPixels*3; dw; dw--,pValue++,pdw++)
+				pValue->Mono=(u_short)(*pdw/(shading_lines-hilight-shadow));
+
+				/* swapping will be done later in usb_ResizeWhiteShading() */
+		}
+	} else {
+
+		/* gray mode */
+		u_short *pwAv, *pw;
+		u_short  w, wV;
+
+		memset( m_pSum, 0, m_ScanParam.Size.dwPhyPixels << 2 );
+		if( hilight ) {
+			for( dwLines = hilight,
+				 pwAv = m_pAvMono + m_ScanParam.Size.dwPhyPixels * dwLines;
+				 dwLines < shading_lines;
+              				 dwLines++, pwAv += m_ScanParam.Size.dwPhyPixels) {
+
+				for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++ ) {
+
+					pw = m_pAvMono;
+					wV = pwAv [dw];
+					for( w = 0; w < hilight; w++,
+						 pw += m_ScanParam.Size.dwPhyPixels ) {
+						if( wV > pw[dw] )
+							_SWAP( wV, pw[dw] );
+					}
+					pwAv[dw] = wV;
+				}
+			}
+		}
+
+		/* Sort shadow */
+		if (shadow) {
+			for (dwLines = hilight, pwAv = m_pAvMono + m_ScanParam.Size.dwPhyPixels * dwLines;
+			 	 dwLines < (shading_lines - shadow); dwLines++, pwAv += m_ScanParam.Size.dwPhyPixels)
+				for (dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++)
+				{
+					pw = m_pAvMono + (shading_lines - shadow) * m_ScanParam.Size.dwPhyPixels;
+					wV = pwAv [dw];
+					for (w = 0; w < shadow; w++, pw += m_ScanParam.Size.dwPhyPixels)
+						if (wV < pw [dw])
+							_SWAP (wV, pw[dw]);
+					pwAv [dw] = wV;
+				}
+		}
+
+		/* Sum */
+		pdw = (u_long*)m_pSum;
+
+		for (dwLines = hilight,
+			 pwAv = m_pAvMono + m_ScanParam.Size.dwPhyPixels * dwLines;
+			 dwLines < (shading_lines - shadow);
+			 dwLines++, pwAv += m_ScanParam.Size.dwPhyPixels) {
+			for (dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++)
+				pdw[dw] += pwAv[dw];
+		}
+
+		/* Software gain */
+		pValue = (MonoWordDef*)a_wWhiteShading;
+		if( scan->sParam.bSource != SOURCE_Negative ) {
+
+			for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++) {
+				
+				pdw[dw] = pdw[dw] * 1000 /((shading_lines-hilight-shadow) *
+				                                 scan->sParam.swGain[1]);
+				if( pdw[dw] > 65535U )
+					pValue[dw].Mono = 65535;
+				else
+					pValue[dw].Mono = (u_short)pdw[dw];
+
+				if( pValue[dw].Mono > 16384U ) {
+					pValue[dw].Mono = (u_short)(GAIN_Target * 16384U / pValue[dw].Mono);
+				} else {
+					pValue[dw].Mono = GAIN_Target;
+				}
+
+#ifdef SWAP_FINE
+				if( swap )
+#endif
+					_SWAP(pValue[dw].HiLo.bHi, pValue[dw].HiLo.bLo);
+			}
+			
+		} else{
+
+			for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++ ) {
+				pValue[dw].Mono = (u_short)(pdw[dw] /
+				                  (shading_lines - hilight - shadow));
+
+				/* swapping will be done later in usb_ResizeWhiteShading() */
+			}
+		}
+	}
+
+	usb_SaveCalSetShading( dev, &m_ScanParam );
+
+	if( scan->sParam.bSource != SOURCE_Negative ) {
+		usb_line_statistics( "White", a_wWhiteShading, m_ScanParam.Size.dwPhyPixels,
+	                         scan->sParam.bDataType == SCANDATATYPE_Color?1:0);
+	}
+	return SANE_TRUE;
+}
+
+/** for negative film only
+ * we need to resize the gain to obtain bright white...
+ */
+static void usb_ResizeWhiteShading( double dAmp, u_short *pwShading, int iGain )
+{
+	u_long  dw, dwAmp;
+	u_short w;
+	
+	DBG( _DBG_INFO2, "ResizeWhiteShading: dAmp=%.3f, iGain=%i\n", dAmp, iGain );
+
+	for( dw = 0; dw < m_ScanParam.Size.dwPhyPixels; dw++ ) {
+		
+		dwAmp = (u_long)(GAIN_Target * 0x4000 /
+		                            (pwShading[dw] + 1) * dAmp) * iGain / 1000;
+
+		if( dwAmp <= GAIN_Target)
+			w = (u_short)dwAmp;
+		else 
+			w = GAIN_Target;
+
+#ifndef SWAP_FINE
+		pwShading[dw] = (u_short)_LOBYTE(w) * 256 + _HIBYTE(w);
+#else
+		pwShading[dw] = w;
+#endif
+	}
+
+#ifdef SWAP_FINE
+	if( usb_HostSwap())
+		usb_Swap( pwShading, m_ScanParam.Size.dwPhyPixels );
+#endif
+}
+
+/** do the base settings for calibration scans
+ */
+static void
+usb_PrepareCalibration( Plustek_Device *dev )
+{
+	ScanDef  *scan  = &dev->scanning;
+	DCapsDef *scaps = &dev->usbDev.Caps;
+	u_char   *regs  = dev->usbDev.a_bRegs;
+
+	usb_GetSWOffsetGain( dev );
+
+	memset( &m_ScanParam, 0, sizeof(ScanParam));
+
+	m_ScanParam.UserDpi   = scaps->OpticDpi;
+	m_ScanParam.PhyDpi    = scaps->OpticDpi;
+	m_ScanParam.bChannels = scan->sParam.bChannels;
+	m_ScanParam.bBitDepth = 16;
+	m_ScanParam.bSource   = scan->sParam.bSource;
+	m_ScanParam.Origin.y  = 0;
+
+	if( scan->sParam.bDataType == SCANDATATYPE_Color )
+		m_ScanParam.bDataType = SCANDATATYPE_Color;
+	else
+		m_ScanParam.bDataType = SCANDATATYPE_Gray;
+
+	usb_SetMCLK( dev, &m_ScanParam );
+ 
+	/* preset these registers offset/gain */
+	regs[0x38] = regs[0x39] = regs[0x3a] = 0;
+	regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+	regs[0x45] &= ~0x10;
+
+	memset( a_wWhiteShading, 0, _SHADING_BUF );
+	memset( a_wDarkShading,  0, _SHADING_BUF );
+
+	scan->skipCoarseCalib = SANE_FALSE;
+
+	if( dev->adj.cacheCalData )
+		if( usb_ReadAndSetCalData( dev ))
+			scan->skipCoarseCalib = SANE_TRUE;
+
+	/* as sheet-fed device we use the cached values, or
+	 * perform the calibration upon request
+	 */
+	if( usb_IsSheetFedDevice(dev)) {
+		if( !scan->skipCoarseCalib && !usb_InCalibrationMode(dev)) {
+
+			DBG(_DBG_INFO2,"SHEET-FED device, skip coarse calibration!\n");
+			scan->skipCoarseCalib = SANE_TRUE;
+
+			regs[0x3b] = 0x0a;
+			regs[0x3c] = 0x0a;
+			regs[0x3d] = 0x0a;
+
+			/* use frontend values... */
+			if((dev->adj.rofs != -1) &&
+			   (dev->adj.gofs != -1) && (dev->adj.bofs != -1)) {
+				regs[0x38] = (dev->adj.rofs & 0x3f);
+				regs[0x39] = (dev->adj.gofs & 0x3f);
+				regs[0x3a] = (dev->adj.bofs & 0x3f);
+			}
+
+			if((dev->adj.rgain != -1) &&
+			   (dev->adj.ggain != -1) && (dev->adj.bgain != -1)) {
+				setAdjGain( dev->adj.rgain, &regs[0x3b] );
+				setAdjGain( dev->adj.ggain, &regs[0x3c] );
+				setAdjGain( dev->adj.bgain, &regs[0x3d] );
+			}
+		}
+	}
+}
+
+/**
+ */
+static SANE_Bool
+usb_SpeedTest( Plustek_Device *dev )
+{
+	int       i;
+	double    s, e, r, tr;
+	struct timeval start, end;
+	DCapsDef *scaps   = &dev->usbDev.Caps;
+	HWDef    *hw      = &dev->usbDev.HwSetting;
+	u_char   *regs    = dev->usbDev.a_bRegs;
+	u_long   *scanbuf = dev->scanning.pScanBuffer;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	bMaxITA = 0xff;
+
+	DBG( 1, "#########################\n" );
+	DBG( 1, "usb_SpeedTest(%d,%lu)\n", dev->initialized, dev->transferRate );
+	if( dev->transferRate != DEFAULT_RATE ) {
+		DBG( 1, "* skipped, using already detected speed: %lu Bytes/s\n", 
+                dev->transferRate );
+		return SANE_TRUE;
+	}
+
+	usb_PrepareCalibration( dev );
+	regs[0x38] = regs[0x39] = regs[0x3a] = 0;
+	regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+	/* define the strip to scan for warming up the lamp, in the end
+	 * we always scan the full line, even for TPA
+	 */
+	m_ScanParam.bDataType     = SCANDATATYPE_Color;
+	m_ScanParam.bCalibration  = PARAM_Gain;
+	m_ScanParam.dMCLK         = dMCLK;
+	m_ScanParam.bBitDepth     = 8;
+	m_ScanParam.Size.dwLines  = 1;
+	m_ScanParam.Size.dwPixels = scaps->Normal.Size.x *
+	                            scaps->OpticDpi.x / 300UL;
+	m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels *
+	                            2 * m_ScanParam.bChannels;
+
+	if( usb_IsCISDevice(dev))
+		m_ScanParam.Size.dwBytes *= 3;
+
+	m_ScanParam.Origin.x = (u_short)((u_long) hw->wActivePixelsStart *
+	                                                300UL / scaps->OpticDpi.x);
+	r = 0.0;
+	dev->transferRate = 2000000;
+
+	for( i = 0; i < _TLOOPS ; i++ ) {
+
+		if( !usb_SetScanParameters( dev, &m_ScanParam ))
+			return SANE_FALSE;
+
+		if( !usb_ScanBegin( dev, SANE_FALSE )) {
+			DBG( _DBG_ERROR, "usb_SpeedTest() failed\n" );
+			return SANE_FALSE;
+		}
+		if (!usb_IsDataAvailableInDRAM( dev )) 
+			return SANE_FALSE;
+
+		m_fFirst = SANE_FALSE;
+		gettimeofday( &start, NULL );
+		usb_ScanReadImage( dev, scanbuf, m_ScanParam.Size.dwPhyBytes );
+		gettimeofday( &end, NULL );
+		usb_ScanEnd( dev );
+		s = (double)start.tv_sec * 1000000.0 + (double)start.tv_usec;
+		e = (double)end.tv_sec   * 1000000.0 + (double)end.tv_usec;
+
+		if( e > s )
+			r += (e - s);
+		else
+			r += (s - e);
+	}
+
+	tr = ((double)m_ScanParam.Size.dwPhyBytes * _TLOOPS * 1000000.0)/r;
+	dev->transferRate = (u_long)tr;
+	DBG( 1, "usb_SpeedTest() done - %u loops, %.4fus --> %.4f B/s, %lu\n", 
+	        _TLOOPS, r, tr, dev->transferRate );
+	return SANE_TRUE;
+}
+
+/** read the white calibration strip until the lamp seems to be stable
+ * the timed warmup will be used, when the warmup time is set to -1
+ */
+static SANE_Bool
+usb_AutoWarmup( Plustek_Device *dev )
+{
+	int       i, stable_count;
+	ScanDef  *scanning = &dev->scanning;
+	DCapsDef *scaps    = &dev->usbDev.Caps;
+	HWDef    *hw       = &dev->usbDev.HwSetting;
+	u_long   *scanbuf  = scanning->pScanBuffer;
+	u_char   *regs     = dev->usbDev.a_bRegs;
+	u_long    dw, start, end, len;
+	u_long    curR,   curG,  curB;
+	u_long    lastR, lastG, lastB;
+	long      diffR, diffG, diffB;
+	long      thresh = _AUTO_THRESH;
+
+	if( usb_IsEscPressed())
+		return SANE_FALSE;
+
+	bMaxITA = 0xff;
+
+	DBG( _DBG_INFO, "#########################\n" );
+	DBG( _DBG_INFO, "usb_AutoWarmup()\n" );
+
+	if( usb_IsCISDevice(dev)) {
+		DBG( _DBG_INFO, "- function skipped, CIS device!\n" );
+		return SANE_TRUE;
+	}
+
+	if( dev->adj.warmup >= 0 ) {
+		DBG( _DBG_INFO, "- using timed warmup: %ds\n", dev->adj.warmup );
+		if( !usb_Wait4Warmup( dev )) {
+			DBG( _DBG_ERROR, "- CANCEL detected\n" );
+			return SANE_FALSE;
+		}
+		return SANE_TRUE;
+	}
+
+	usb_PrepareCalibration( dev );
+	regs[0x38] = regs[0x39] = regs[0x3a] = 0;
+	regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+	/* define the strip to scan for warming up the lamp, in the end
+	 * we always scan the full line, even for TPA
+	 */
+	m_ScanParam.bDataType     = SCANDATATYPE_Color;
+	m_ScanParam.bCalibration  = PARAM_Gain;
+	m_ScanParam.dMCLK         = dMCLK;
+	m_ScanParam.Size.dwLines  = 1;
+	m_ScanParam.Size.dwPixels = scaps->Normal.Size.x *
+	                            scaps->OpticDpi.x / 300UL;
+	m_ScanParam.Size.dwBytes  = m_ScanParam.Size.dwPixels *
+	                            2 * m_ScanParam.bChannels;
+
+	if( usb_IsCISDevice(dev))
+		m_ScanParam.Size.dwBytes *= 3;
+
+	m_ScanParam.Origin.x = (u_short)((u_long) hw->wActivePixelsStart *
+	                                                300UL / scaps->OpticDpi.x);
+
+	stable_count = 0;
+	start = 500;
+	len   = m_ScanParam.Size.dwPixels;
+
+	if( scanning->sParam.bSource == SOURCE_Transparency ) {
+		start  = scaps->Positive.DataOrigin.x * scaps->OpticDpi.x / 300UL;
+		len    = scaps->Positive.Size.x * scaps->OpticDpi.x / 300UL;
+		thresh = _AUTO_TPA_THRESH;
+	}
+	else if( scanning->sParam.bSource == SOURCE_Negative ) {
+		start  = scaps->Negative.DataOrigin.x * scaps->OpticDpi.x / 300UL;
+		len    = scaps->Negative.Size.x * scaps->OpticDpi.x / 300UL;
+		thresh = _AUTO_TPA_THRESH;
+	}
+	end = start + len;
+	DBG( _DBG_INFO2, "Start=%lu, End=%lu, Len=%lu, Thresh=%li\n", 
+	                 start, end, len, thresh );
+
+	lastR = lastG = lastB = 0;
+	for( i = 0; i < _MAX_AUTO_WARMUP + 1 ; i++ ) {
+
+		if( !usb_SetScanParameters( dev, &m_ScanParam ))
+			return SANE_FALSE;
+
+		if( !usb_ScanBegin( dev, SANE_FALSE ) ||
+		    !usb_ScanReadImage( dev, scanbuf, m_ScanParam.Size.dwPhyBytes ) ||
+		    !usb_ScanEnd( dev )) {
+			DBG( _DBG_ERROR, "usb_AutoWarmup() failed\n" );
+			return SANE_FALSE;
+		}
+
+#ifdef SWAP_COARSE
+		if(usb_HostSwap())
+#endif
+			usb_Swap((u_short *)scanbuf, m_ScanParam.Size.dwPhyBytes );
+
+		if( end > m_ScanParam.Size.dwPhyPixels )
+			end = m_ScanParam.Size.dwPhyPixels;
+
+		curR = curG = curB = 0;
+		for( dw = start; dw < end; dw++ ) {
+			
+			if( usb_IsCISDevice(dev)) {
+				curR += ((u_short*)scanbuf)[dw];
+				curG += ((u_short*)scanbuf)[dw+m_ScanParam.Size.dwPhyPixels+1];
+				curB += ((u_short*)scanbuf)[dw+(m_ScanParam.Size.dwPhyPixels+1)*2];
+			} else {
+				curR += ((RGBUShortDef*)scanbuf)[dw].Red;
+				curG += ((RGBUShortDef*)scanbuf)[dw].Green;
+				curB += ((RGBUShortDef*)scanbuf)[dw].Blue;
+			}
+		}
+		curR /= len;
+		curG /= len;
+		curB /= len;
+
+		diffR = curR - lastR; lastR = curR;
+		diffG = curG - lastG; lastG = curG;
+		diffB = curB - lastB; lastB = curB;
+		DBG( _DBG_INFO2, "%i/%i-AVE(R,G,B)= %lu(%ld), %lu(%ld), %lu(%ld)\n", 
+		              i, stable_count, curR, diffR, curG, diffG, curB, diffB );
+
+		/* we consider the lamp to be stable,
+		 * when the diffs are less than thresh for at least 3 loops
+		 */
+		if((diffR < thresh) && (diffG < thresh) && (diffB < thresh)) {
+			if( stable_count > 3 )
+				break;
+			stable_count++;
+		} else {
+			stable_count = 0;
+		}
+
+		/* no need to sleep in the first loop */
+		if((i != 0) && (stable_count == 0))
+			sleep( _AUTO_SLEEP );
+	}
+
+	DBG( _DBG_INFO, "usb_AutoWarmup() done - %u loops\n", i+1 );
+	DBG( _DBG_INFO, "* AVE(R,G,B)= %lu(%ld), %lu(%ld), %lu(%ld)\n", 
+	                       curR, diffR, curG, diffG, curB, diffB );
+	return SANE_TRUE;
+}
+
+/**
+ */
+static int
+usb_DoIt( Plustek_Device *dev )
+{
+	SANE_Bool skip_fine;
+	ScanDef  *scan = &dev->scanning;
+
+	DBG( _DBG_INFO, "Settings done, so start...\n" );
+	if( !scan->skipCoarseCalib ) {
+		DBG( _DBG_INFO2, "###### ADJUST GAIN (COARSE)#######\n" );
+		if( !usb_AdjustGain(dev, 0)) {
+			DBG( _DBG_ERROR, "Coarse Calibration failed!!!\n" );
+			return _E_INTERNAL;
+		}
+		DBG( _DBG_INFO2, "###### ADJUST OFFSET (COARSE) ####\n" );
+		if( !usb_AdjustOffset(dev)) {
+			DBG( _DBG_ERROR, "Coarse Calibration failed!!!\n" );
+			return _E_INTERNAL;
+		}
+	} else {
+		DBG( _DBG_INFO2, "Coarse Calibration skipped, using saved data\n" );
+	}
+
+	skip_fine = SANE_FALSE;
+	if( dev->adj.cacheCalData ) {
+		skip_fine = usb_FineShadingFromFile(dev);
+	}
+
+	if( !skip_fine ) {
+		DBG( _DBG_INFO2, "###### ADJUST DARK (FINE) ########\n" );
+		if( !usb_AdjustDarkShading(dev)) {
+			DBG( _DBG_ERROR, "Fine Calibration failed!!!\n" );
+			return _E_INTERNAL;
+		}
+		DBG( _DBG_INFO2, "###### ADJUST WHITE (FINE) #######\n" );
+		if( !usb_AdjustWhiteShading(dev)) {
+			DBG( _DBG_ERROR, "Fine Calibration failed!!!\n" );
+			return _E_INTERNAL;
+		}
+	} else {
+		DBG( _DBG_INFO2, "###### FINE calibration skipped #######\n" );
+
+		m_ScanParam = scan->sParam;
+		usb_GetPhyPixels( dev, &m_ScanParam );
+
+		usb_line_statistics( "Dark", a_wDarkShading, m_ScanParam.Size.dwPhyPixels,
+		                      m_ScanParam.bDataType == SCANDATATYPE_Color?1:0);
+		usb_line_statistics( "White", a_wWhiteShading, m_ScanParam.Size.dwPhyPixels,
+		                      m_ScanParam.bDataType == SCANDATATYPE_Color?1:0);
+
+/*		dev->usbDev.a_bRegs[0x45] &= ~0x10;*/
+	}
+	return 0;
+}
+
+/** usb_DoCalibration
+ */
+static int
+usb_DoCalibration( Plustek_Device *dev )
+{
+	int       result;
+	ScanDef  *scanning = &dev->scanning;
+	DCapsDef *scaps    = &dev->usbDev.Caps;
+	HWDef    *hw       = &dev->usbDev.HwSetting;
+	u_char   *regs     = dev->usbDev.a_bRegs;
+	double    dRed, dGreen, dBlue;
+
+	DBG( _DBG_INFO, "usb_DoCalibration()\n" );
+
+	if( SANE_TRUE == scanning->fCalibrated )
+		return SANE_TRUE;
+
+	/* Go to shading position
+     */
+	DBG( _DBG_INFO, "...goto shading position\n" );
+
+	/* HEINER: Currently not clear why Plustek didn't use the ShadingOriginY
+	 *         for all modes
+	 * It should be okay to remove this and reference to the ShadingOriginY
+	 */	
+#if 0	
+	if( scanning->sParam.bSource == SOURCE_Negative ) {
+
+		DBG( _DBG_INFO, "DataOrigin.x=%u, DataOrigin.y=%u\n",
+		 dev->usbDev.pSource->DataOrigin.x, dev->usbDev.pSource->DataOrigin.y);
+		if(!usb_ModuleMove( dev, MOVE_Forward,
+		                                  (dev->usbDev.pSource->DataOrigin.y +
+  			                               dev->usbDev.pSource->Size.y / 2))) {
+			return _E_LAMP_NOT_IN_POS;
+		}
+
+	} else {
+#endif
+		DBG( _DBG_INFO, "ShadingOriginY=%lu\n",
+				(u_long)dev->usbDev.pSource->ShadingOriginY );
+
+		if((hw->motorModel == MODEL_HuaLien) && (scaps->OpticDpi.x==600)) {
+			if (!usb_ModuleMove(dev, MOVE_ToShading,
+			                    (u_long)dev->usbDev.pSource->ShadingOriginY)) {
+				return _E_LAMP_NOT_IN_POS;
+			}
+		} else {
+			if( !usb_ModuleMove(dev, MOVE_Forward,
+			                    (u_long)dev->usbDev.pSource->ShadingOriginY)) {
+				return _E_LAMP_NOT_IN_POS;
+			}
+		}
+/*	}*/
+
+	DBG( _DBG_INFO, "shading position reached\n" );
+
+	usb_SpeedTest( dev );
+
+	if( !usb_AutoWarmup( dev ))
+		return SANE_FALSE;
+
+	usb_PrepareCalibration( dev );
+
+	/** this won't work for Plustek devices!!!
+	 */
+#if 0
+	if( scaps->workaroundFlag & _WAF_BYPASS_CALIBRATION ||
+		!(SCANDEF_QualityScan & dev->scanning.dwFlag)) {
+#else
+	if( scaps->workaroundFlag & _WAF_BYPASS_CALIBRATION ) {
+#endif
+
+		DBG( _DBG_INFO, "--> BYPASS\n" );
+		regs[0x38] = regs[0x39] = regs[0x3a] = 0;
+		regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+		setAdjGain( dev->adj.rgain, &regs[0x3b] );
+		setAdjGain( dev->adj.ggain, &regs[0x3c] );
+		setAdjGain( dev->adj.bgain, &regs[0x3d] );
+
+		regs[0x45] |= 0x10;
+		usb_SetMCLK( dev, &scanning->sParam );
+
+	    dumpregs( dev->fd, regs );
+		DBG( _DBG_INFO, "<-- BYPASS\n" );
+
+	} else {
+
+		switch( scanning->sParam.bSource ) {
+
+			case SOURCE_Negative:
+				DBG( _DBG_INFO, "NEGATIVE Shading\n" );
+				m_dwIdealGain = IDEAL_GainNormal;
+
+				if( !_IS_PLUSTEKMOTOR(hw->motorModel)) {
+					DBG( _DBG_INFO, "No Plustek model: %udpi\n",
+						            scanning->sParam.PhyDpi.x );
+					usb_SetMCLK( dev, &scanning->sParam );
+				} else {
+
+					if( dev->usbDev.Caps.OpticDpi.x == 600 )
+						dMCLK = 7;
+					else
+						dMCLK = 8;
+				}
+
+				for(;;) {
+					if( usb_AdjustGain( dev, 2)) {
+						if( regs[0x3b] && regs[0x3c] && regs[0x3d]) {
+							break;
+						} else {
+							regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+							dMCLK--;
+						}
+					} else {
+						return _E_LAMP_NOT_STABLE;
+					}
+				}
+				scanning->sParam.dMCLK = dMCLK;
+				Gain_Reg.Red    = regs[0x3b];
+				Gain_Reg.Green  = regs[0x3c];
+				Gain_Reg.Blue   = regs[0x3d];
+				Gain_NegHilight = Gain_Hilight;
+			
+				DBG( _DBG_INFO, "MCLK      = %.3f\n", dMCLK );
+				DBG( _DBG_INFO, "GainRed   = %u\n", regs[0x3b] );
+				DBG( _DBG_INFO, "GainGreen = %u\n", regs[0x3c] );
+				DBG( _DBG_INFO, "GainBlue  = %u\n", regs[0x3d] );
+
+#if 0
+    			if( !usb_ModuleMove( dev, MOVE_Backward,
+    								 dev->usbDev.pSource->DataOrigin.y +
+    								 dev->usbDev.pSource->Size.y / 2 -
+    								 dev->usbDev.pSource->ShadingOriginY)) {
+    				return _E_LAMP_NOT_IN_POS;
+    			}
+#endif
+				regs[0x45] &= ~0x10;
+
+				regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+				if(!usb_AdjustGain( dev, 1 ))
+					return _E_INTERNAL;
+				
+				regs[0x3b] = regs[0x3c] = regs[0x3d] = 1;
+
+				DBG( _DBG_INFO, "Settings done, so start...\n" );
+				if( !usb_AdjustOffset(dev) || !usb_AdjustDarkShading(dev) ||
+				                              !usb_AdjustWhiteShading(dev)) {
+					return _E_INTERNAL;
+				}
+
+				dRed    = 0.93 + 0.067 * Gain_Reg.Red;
+				dGreen  = 0.93 + 0.067 * Gain_Reg.Green;
+				dBlue   = 0.93 + 0.067 * Gain_Reg.Blue;
+				dExpect = 2.85;
+				if( dBlue >= dGreen && dBlue >= dRed )
+					dMax = dBlue;
+				else
+					if( dGreen >= dRed && dGreen >= dBlue )
+						dMax = dGreen;
+					else
+						dMax = dRed;
+
+				dMax = dExpect / dMax;
+				dRed   *= dMax;
+				dGreen *= dMax;
+				dBlue  *= dMax;
+
+				if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+					usb_ResizeWhiteShading( dRed,  a_wWhiteShading,
+					                                scanning->sParam.swGain[0]);
+					usb_ResizeWhiteShading( dGreen, a_wWhiteShading +
+					                                m_ScanParam.Size.dwPhyPixels,
+					                                scanning->sParam.swGain[1]);
+					usb_ResizeWhiteShading( dBlue,  a_wWhiteShading +
+					                                m_ScanParam.Size.dwPhyPixels*2,
+					                                scanning->sParam.swGain[2]);
+				}
+				usb_line_statistics( "White", a_wWhiteShading, 
+				                     m_ScanParam.Size.dwPhyPixels, SANE_TRUE);
+				break;
+
+			case SOURCE_ADF:
+				DBG( _DBG_INFO, "ADF Shading\n" );
+				m_dwIdealGain = IDEAL_GainPositive;
+				if( scanning->sParam.bDataType == SCANDATATYPE_BW ) {
+					if( scanning->sParam.PhyDpi.x <= 200 ) {
+						scanning->sParam.dMCLK = 4.5;
+						dMCLK = 4.0;
+					} else if ( scanning->sParam.PhyDpi.x <= 300 ) {
+						scanning->sParam.dMCLK = 4.0;
+						dMCLK = 3.5;
+					} else if( scanning->sParam.PhyDpi.x <= 400 ) {
+						scanning->sParam.dMCLK = 5.0;
+						dMCLK = 4.0;
+					} else {
+						scanning->sParam.dMCLK = 6.0;
+						dMCLK = 4.0;
+					}
+				} else { /* Gray */
+
+					if( scanning->sParam.PhyDpi.x <= 400 ) {
+						scanning->sParam.dMCLK = 6.0;
+						dMCLK = 4.5;
+					} else {
+						scanning->sParam.dMCLK = 9.0;
+						dMCLK = 7.0;
+					}
+				}
+				dMCLK_ADF = dMCLK;
+
+				result = usb_DoIt( dev );
+				if( result != 0 )
+					return result;
+				break;
+
+			case SOURCE_Transparency:
+				DBG( _DBG_INFO, "TRANSPARENCY Shading\n" );
+				m_dwIdealGain = IDEAL_GainPositive;
+
+				if( !_IS_PLUSTEKMOTOR(hw->motorModel)) {
+					DBG( _DBG_INFO, "No Plustek model: %udpi\n",
+						            scanning->sParam.PhyDpi.x );
+					usb_SetMCLK( dev, &scanning->sParam );
+
+				} else {
+					if( dev->usbDev.Caps.OpticDpi.x == 600 ) {
+						scanning->sParam.dMCLK = 8;
+						dMCLK = 4;
+					} else {
+						scanning->sParam.dMCLK = 8;
+						dMCLK = 6;
+					}
+				}
+				result = usb_DoIt( dev );
+				if( result != 0 )
+					return result;
+				break;
+
+			default:
+				if( !_IS_PLUSTEKMOTOR(hw->motorModel)) {
+    				DBG( _DBG_INFO, "No Plustek model: %udpi\n",
+    												scanning->sParam.PhyDpi.x );
+    				usb_SetMCLK( dev, &scanning->sParam );
+
+    			} else 	if( dev->usbDev.Caps.OpticDpi.x == 600 ) {
+
+    				DBG( _DBG_INFO, "Default Shading (600dpi)\n" );
+
+    				if( dev->usbDev.Caps.bCCD == kSONY548 )	{
+
+    					DBG( _DBG_INFO, "CCD - SONY548\n" );
+    					if( scanning->sParam.PhyDpi.x <= 75 ) {
+    						if( scanning->sParam.bDataType  == SCANDATATYPE_Color )
+    							scanning->sParam.dMCLK = dMCLK = 2.5;
+    						else if(scanning->sParam.bDataType == SCANDATATYPE_Gray)
+    							scanning->sParam.dMCLK = dMCLK = 7.0;
+    						else
+    							scanning->sParam.dMCLK = dMCLK = 7.0;
+
+    					} else if( scanning->sParam.PhyDpi.x <= 300 ) {
+    						if( scanning->sParam.bDataType  == SCANDATATYPE_Color )
+    							scanning->sParam.dMCLK = dMCLK = 3.0;
+    						else if(scanning->sParam.bDataType == SCANDATATYPE_Gray)
+    							scanning->sParam.dMCLK = dMCLK = 6.0;
+    						else  {
+    							if( scanning->sParam.PhyDpi.x <= 100 )
+    								scanning->sParam.dMCLK = dMCLK = 6.0;
+    							else if( scanning->sParam.PhyDpi.x <= 200 )
+    								scanning->sParam.dMCLK = dMCLK = 5.0;
+    							else
+    								scanning->sParam.dMCLK = dMCLK = 4.5;
+    						}
+    					} else if( scanning->sParam.PhyDpi.x <= 400 ) {
+    						if( scanning->sParam.bDataType  == SCANDATATYPE_Color )
+    							scanning->sParam.dMCLK = dMCLK = 4.0;
+    						else if( scanning->sParam.bDataType == SCANDATATYPE_Gray )
+    							scanning->sParam.dMCLK = dMCLK = 6.0;
+    						else
+    							scanning->sParam.dMCLK = dMCLK = 4.0;
+    					} else {
+    						if(scanning->sParam.bDataType  == SCANDATATYPE_Color)
+    							scanning->sParam.dMCLK = dMCLK = 6.0;
+    						else if(scanning->sParam.bDataType == SCANDATATYPE_Gray)
+    							scanning->sParam.dMCLK = dMCLK = 7.0;
+    						else
+    							scanning->sParam.dMCLK = dMCLK = 6.0;
+    					}
+
+    				} else if( dev->usbDev.Caps.bPCB == 0x02 ) {
+    					DBG( _DBG_INFO, "PCB - 0x02\n" );
+    					if( scanning->sParam.PhyDpi.x > 300 )
+    						scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 6: 16);
+    					else if( scanning->sParam.PhyDpi.x > 150 )
+    						scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?4.5: 13.5);
+    					else
+    						scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?3: 8);
+
+    				}  else if( dev->usbDev.Caps.bButtons ) { /* with lens Shading piece (with gobo) */
+
+    					DBG( _DBG_INFO, "CAPS - Buttons\n" );
+    					scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?3: 6);
+    					if( dev->usbDev.HwSetting.motorModel == MODEL_KaoHsiung )	{
+    						if( dev->usbDev.Caps.bCCD == kNEC3799 ) {
+    							if( scanning->sParam.PhyDpi.x > 300 )
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 6: 13);
+    							else if(scanning->sParam.PhyDpi.x > 150)
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?4.5:13.5);
+    							else
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?3: 6);
+    						} else {
+    							scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?3: 6);
+    						}
+    					} else { /* motorModel == MODEL_Hualien */
+    						/*  IMPORTANT !!!!
+    						 * for Hualien 600 dpi scanner big noise
+                             */
+    						hw->wLineEnd = 5384;
+    						if(scanning->sParam.bDataType  == SCANDATATYPE_Color &&
+    							((scanning->sParam.bBitDepth == 8 && 
+								 (scanning->sParam.PhyDpi.x == 200 ||scanning->sParam.PhyDpi.x == 300))))
+    							hw->wLineEnd = 7000;
+    						regs[0x20] = _HIBYTE(hw->wLineEnd);
+    						regs[0x21] = _LOBYTE(hw->wLineEnd);
+
+    						if( scanning->sParam.PhyDpi.x > 300 ) {
+    							if (scanning->sParam.bBitDepth > 8)
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType  == SCANDATATYPE_Color)? 5: 13);
+    							else
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 6: 13);
+    						} else {
+    							if( scanning->sParam.bBitDepth > 8 )
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 5: 13);
+    							else
+    								scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)?3: 6);
+    						}
+    					}
+    				} else  { /* without lens Shading piece (without gobo) - Model U12 only */
+    					DBG( _DBG_INFO, "Default trunc (U12)\n" );
+    					if( scanning->sParam.PhyDpi.x > 300 )
+    						scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 3: 9);
+    					else
+    						scanning->sParam.dMCLK = dMCLK = ((scanning->sParam.bDataType == SCANDATATYPE_Color)? 2: 6);
+    				}
+    			} else {	/* Device.Caps.OpticDpi.x == 1200 */
+
+    				DBG( _DBG_INFO, "Default Shading (1200dpi)\n" );
+    				if( scanning->sParam.bDataType != SCANDATATYPE_Color ) {
+    					if( scanning->sParam.PhyDpi.x > 300 )
+    						scanning->sParam.dMCLK = dMCLK = 6.0;
+    					else {
+    						scanning->sParam.dMCLK = dMCLK = 5.0;
+    						regs[0x0a] = 1;
+    					}
+    				} else {
+    					if( scanning->sParam.PhyDpi.x <= 300)
+    						scanning->sParam.dMCLK = dMCLK = 2.0;
+    					else if( scanning->sParam.PhyDpi.x <= 800 )
+    						scanning->sParam.dMCLK = dMCLK = 4.0;
+    					else
+    						scanning->sParam.dMCLK = dMCLK = 5.5;
+    				}
+    			}
+
+				if (m_ScanParam.bSource == SOURCE_ADF)
+					m_dwIdealGain = IDEAL_GainPositive;
+				else
+					m_dwIdealGain = IDEAL_GainNormal;
+
+				result = usb_DoIt( dev );
+				if( result != 0 )
+					return result;
+				break;
+		}
+	}
+
+	/* home the sensor after calibration */
+	if( _IS_PLUSTEKMOTOR(hw->motorModel)) {
+		if( hw->motorModel != MODEL_Tokyo600 ) {
+			usb_ModuleMove  ( dev, MOVE_Forward, hw->wMotorDpi / 5 );
+			usb_ModuleToHome( dev, SANE_TRUE );
+		}
+	} else {
+		usb_ModuleMove( dev, MOVE_Forward, 10 );
+		usleep( 1500 );
+		usb_ModuleToHome( dev, SANE_TRUE );
+	}
+
+	if( scanning->sParam.bSource == SOURCE_ADF ) {
+
+		if( scaps->bCCD == kNEC3778 )
+			usb_ModuleMove( dev, MOVE_Forward, 1000 );
+
+		else /* if( scaps->bCCD == kNEC3799) */
+			usb_ModuleMove( dev, MOVE_Forward, 3 * 300 + 38 );
+
+		usb_MotorOn( dev, SANE_FALSE );
+	}
+
+	scanning->fCalibrated = SANE_TRUE;
+	DBG( _DBG_INFO, "Calibration done\n" );
+	DBG( _DBG_INFO, "-----------------------\n" );
+	DBG( _DBG_INFO, "Static Gain:\n" );
+	DBG( _DBG_INFO, "REG[0x3b] = %u\n", regs[0x3b] );
+	DBG( _DBG_INFO, "REG[0x3c] = %u\n", regs[0x3c] );
+	DBG( _DBG_INFO, "REG[0x3d] = %u\n", regs[0x3d] );
+	DBG( _DBG_INFO, "Static Offset:\n" );
+	DBG( _DBG_INFO, "REG[0x38] = %i\n", regs[0x38] );
+	DBG( _DBG_INFO, "REG[0x39] = %i\n", regs[0x39] );
+	DBG( _DBG_INFO, "REG[0x3a] = %i\n", regs[0x3a] );
+	DBG( _DBG_INFO, "MCLK      = %.2f\n", scanning->sParam.dMCLK );
+	DBG( _DBG_INFO, "-----------------------\n" );
+	return SANE_TRUE;
+}
+
+/* on different sensor orders, we need to adjust the shading buffer
+ * pointer, otherwise we correct the wrong channels
+ */
+static void
+get_ptrs(Plustek_Device *dev, u_short *buf, u_long offs,
+         u_short **r, u_short **g, u_short **b)
+{
+	ScanDef  *scan  = &dev->scanning;
+	DCapsDef *scaps = &dev->usbDev.Caps;
+	u_char so = scaps->bSensorOrder;
+
+	if (_WAF_RESET_SO_TO_RGB & scaps->workaroundFlag) {
+		if (scaps->bPCB != 0) {
+			if (scan->sParam.PhyDpi.x > scaps->bPCB)
+				so = SENSORORDER_rgb;
+		}
+	}
+
+	switch( so ) {
+		case SENSORORDER_gbr:
+			*g = buf;
+			*b = buf + offs;
+			*r = buf + offs * 2;
+			break;
+
+		case SENSORORDER_bgr:
+			*b = buf;
+			*g = buf + offs;
+			*r = buf + offs * 2;
+			break;
+
+		case SENSORORDER_rgb:
+		default:
+			*r = buf;
+			*g = buf + offs;
+			*b = buf + offs * 2;
+			break;
+	}
+}
+
+/** usb_DownloadShadingData
+ * according to the job id, different registers or DRAM areas are set
+ * in preparation for calibration or scanning
+ */
+static SANE_Bool
+usb_DownloadShadingData( Plustek_Device *dev, u_char what )
+{
+	u_char    channel;
+	u_short   *r, *g, *b;
+	DCapsDef  *scaps = &dev->usbDev.Caps;
+	ScanDef   *scan  = &dev->scanning;
+	HWDef     *hw    = &dev->usbDev.HwSetting;
+	ScanParam *param = &dev->scanning.sParam;
+	u_char    *regs  = dev->usbDev.a_bRegs;
+
+	DBG( _DBG_INFO, "usb_DownloadShadingData(%u)\n", what );
+
+	channel = CHANNEL_green;
+	if( usb_IsCISDevice(dev))
+		channel = CHANNEL_blue;
+
+	switch( what ) {
+
+		case PARAM_WhiteShading:
+			if( m_ScanParam.bDataType == SCANDATATYPE_Color ) {
+
+				usb_SetDarkShading( dev, CHANNEL_red, a_wDarkShading,
+				                    (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				usb_SetDarkShading( dev, CHANNEL_green, a_wDarkShading +
+				                    m_ScanParam.Size.dwPhyPixels,
+				                    (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				usb_SetDarkShading( dev, CHANNEL_blue, a_wDarkShading +
+				                    m_ScanParam.Size.dwPhyPixels * 2,
+				                    (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+			} else {
+				usb_SetDarkShading( dev, channel, a_wDarkShading +
+				                    m_ScanParam.Size.dwPhyPixels,
+				                    (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+			}
+			regs[0x40] = 0x40;
+			regs[0x41] = 0x00;
+
+			/* set RAM configuration AND
+			 * Gain = Multiplier Coefficient/16384
+			 * CFG Register 0x40/0x41 for Multiplier Coefficient Source
+			 * External DRAM for Offset Coefficient Source
+			 */
+			regs[0x42] = (u_char)(( hw->wDRAMSize > 512)? 0x64: 0x24);
+			_UIO(sanei_lm983x_write( dev->fd, 0x40,
+			                        &regs[0x40], 0x42-0x40+1, SANE_TRUE ));
+			break;
+
+		case PARAM_Scan:
+			{
+#if 0
+				if( scaps->workaroundFlag & _WAF_BYPASS_CALIBRATION ||
+					!(SCANDEF_QualityScan & dev->scanning.dwFlag)) {
+#else
+				if( scaps->workaroundFlag & _WAF_BYPASS_CALIBRATION ) {
+#endif
+					DBG( _DBG_INFO, "--> BYPASS\n" );
+					/* set RAM configuration AND
+					 * Bypass Multiplier
+					 * CFG Register 0x40/0x41 for Multiplier Coefficient Source
+					 * CFG Register 0x3e/0x3f for Offset Coefficient Source
+					 */
+					regs[0x03] = 0;
+					regs[0x40] = 0x40;
+					regs[0x41] = 0x00;
+					regs[0x42] = (u_char)((hw->wDRAMSize > 512)? 0x61:0x21);
+					if( !usbio_WriteReg( dev->fd, 0x03, regs[0x03]))
+						return SANE_FALSE;
+
+					_UIO(sanei_lm983x_write( dev->fd, 0x40,
+					                        &regs[0x40], 3, SANE_TRUE));
+					break;
+				}
+
+				if( _LM9831 != hw->chip )
+					m_dwPixels = m_ScanParam.Size.dwPhyPixels;
+
+				if( scaps->workaroundFlag & _WAF_SKIP_FINE ) {
+					DBG( _DBG_INFO, "Skipping fine calibration\n" );
+					regs[0x42] = (u_char)(( hw->wDRAMSize > 512)? 0x60: 0x20);
+					if (scan->skipCoarseCalib) {
+
+						DBG( _DBG_INFO, "...cleaning shading buffer\n" );
+						memset( a_wWhiteShading, 0, _SHADING_BUF );
+						memset( a_wDarkShading,  0, _SHADING_BUF );
+
+						regs[0x40] = 0x3f;
+						regs[0x41] = 0xff;
+
+						_UIO(sanei_lm983x_write( dev->fd, 0x40,
+						                        &regs[0x40], 3, SANE_TRUE));
+					} else {
+						if( !usbio_WriteReg( dev->fd, 0x42, regs[0x42]))
+							return SANE_FALSE;
+					}
+					break;
+				}
+
+				DBG( _DBG_INFO, "Downloading %lu pixels\n", m_dwPixels );
+				/* Download the dark & white shadings to LM983x */
+				if( param->bDataType == SCANDATATYPE_Color ) {
+
+					get_ptrs(dev, a_wDarkShading, m_dwPixels, &r, &g, &b);
+
+					usb_SetDarkShading( dev, CHANNEL_red, r,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+					usb_SetDarkShading( dev, CHANNEL_green, g,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+					usb_SetDarkShading( dev, CHANNEL_blue, b,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				} else {
+					usb_SetDarkShading( dev, channel,
+					                    a_wDarkShading + m_dwPixels,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				}
+				if( param->bDataType == SCANDATATYPE_Color ) {
+
+					get_ptrs(dev, a_wWhiteShading, 
+					         m_ScanParam.Size.dwPhyPixels, &r, &g, &b);
+
+					usb_SetWhiteShading( dev, CHANNEL_red, r,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+					usb_SetWhiteShading( dev, CHANNEL_green, g,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+					usb_SetWhiteShading( dev, CHANNEL_blue, b,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				} else {
+					usb_SetWhiteShading( dev, channel, a_wWhiteShading,
+					                (u_short)m_ScanParam.Size.dwPhyPixels * 2);
+				}
+
+				/* set RAM configuration AND
+				 * Gain = Multiplier Coefficient/16384
+				 * External DRAM for Multiplier Coefficient Source
+				 * External DRAM for Offset Coefficient Source
+				 */
+				regs[0x42] = (u_char)((hw->wDRAMSize > 512)? 0x66: 0x26);
+
+				if( scaps->workaroundFlag & _WAF_SKIP_WHITEFINE ) {
+					DBG( _DBG_INFO,"Skipping fine white calibration result\n");
+					regs[0x42] = (u_char)(( hw->wDRAMSize > 512)? 0x64: 0x24);
+				}
+
+				if( !usbio_WriteReg( dev->fd, 0x42, regs[0x42]))
+					return SANE_FALSE;
+			}
+			break;
+
+		default:
+			/* for coarse calibration and "black fine" */
+			regs[0x3e] = 0;
+			regs[0x3f] = 0;
+			regs[0x40] = 0x40;
+			regs[0x41] = 0x00;
+
+			/* set RAM configuration AND
+			 * GAIN = Multiplier Coefficient/16384
+			 * CFG Register 0x40/0x41 for Multiplier Coefficient Source
+			 * CFG Register 0x3e/0x3f for Offset Coefficient Source
+			 */
+			regs[0x42] = (u_char)((hw->wDRAMSize > 512)? 0x60: 0x20);
+			_UIO(sanei_lm983x_write( dev->fd, 0x3e, &regs[0x3e],
+			                         0x42 - 0x3e + 1, SANE_TRUE ));
+			break;
+	}
+	return SANE_TRUE;
+}
+
+/* END PLUSTEK-USBSHADING.C .................................................*/