kopia lustrzana https://gitlab.com/sane-project/backends
1582 wiersze
62 KiB
C
1582 wiersze
62 KiB
C
/* HP Scanjet 3900 series - Debugging functions for standalone
|
||
|
||
Copyright (C) 2005-2008 Jonathan Bravo Lopez <jkdsoft@gmail.com>
|
||
|
||
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.
|
||
*/
|
||
|
||
/* debugging level messages */
|
||
#define DBG_ERR 0x00 /* Only important errors */
|
||
#define DBG_VRB 0x01 /* verbose messages */
|
||
#define DBG_FNC 0x02 /* Function names and parameters */
|
||
#define DBG_CTL 0x03 /* USB Ctl data */
|
||
#define DBG_BLK 0x04 /* USB Bulk data */
|
||
|
||
#include <stdarg.h>
|
||
#ifdef HAVE_TIFFIO_H
|
||
#include <tiffio.h> /* dbg_tiff_save */
|
||
#endif
|
||
|
||
/* headers */
|
||
|
||
static void dump_shading (struct st_calibration *myCalib);
|
||
static char *dbg_scantype (SANE_Int type);
|
||
static void dbg_scanmodes (struct st_device *dev);
|
||
static void dbg_motorcurves (struct st_device *dev);
|
||
static void dbg_motormoves (struct st_device *dev);
|
||
static void dbg_hwdcfg (struct st_hwdconfig *params);
|
||
static void dbg_ScanParams (struct st_scanparams *params);
|
||
static void dbg_calibtable (struct st_gain_offset *params);
|
||
static char *dbg_colour (SANE_Int colour);
|
||
static void dbg_motorcfg (struct st_motorcfg *motorcfg);
|
||
static void dbg_buttons (struct st_buttons *buttons);
|
||
static void dbg_sensor (struct st_sensorcfg *sensor);
|
||
static void dbg_timing (struct st_timing *mt);
|
||
static void dbg_sensorclock (struct st_cph *cph);
|
||
static void dbg_tiff_save (char *sFile, SANE_Int width, SANE_Int height,
|
||
SANE_Int depth, SANE_Int colortype, SANE_Int res_x,
|
||
SANE_Int res_y, SANE_Byte * buffer, SANE_Int size);
|
||
static void dbg_autoref (struct st_scanparams *scancfg, SANE_Byte * pattern,
|
||
SANE_Int ser1, SANE_Int ser2, SANE_Int ler);
|
||
|
||
#ifdef developing
|
||
static void dbg_buffer (SANE_Int level, char *title, SANE_Byte * buffer,
|
||
SANE_Int size, SANE_Int start);
|
||
static void dbg_registers (SANE_Byte * buffer);
|
||
#endif
|
||
|
||
#ifdef STANDALONE
|
||
|
||
/* implementation */
|
||
|
||
int DBG_LEVEL = 0;
|
||
|
||
static void
|
||
DBG (int level, const char *msg, ...)
|
||
{
|
||
va_list ap;
|
||
va_start (ap, msg);
|
||
|
||
if (level <= DBG_LEVEL)
|
||
vfprintf (stderr, msg, ap);
|
||
|
||
va_end (ap);
|
||
}
|
||
|
||
#endif
|
||
|
||
/* debugging functions */
|
||
|
||
static void
|
||
dump_shading (struct st_calibration *myCalib)
|
||
{
|
||
if (myCalib != NULL)
|
||
{
|
||
SANE_Int colour, a;
|
||
FILE *shadingfile[3];
|
||
|
||
shadingfile[0] = fopen ("RShading.txt", "w");
|
||
shadingfile[1] = fopen ("GShading.txt", "w");
|
||
shadingfile[2] = fopen ("BShading.txt", "w");
|
||
|
||
for (colour = 0; colour < 3; colour++)
|
||
{
|
||
if (shadingfile[colour] != NULL)
|
||
{
|
||
for (a = 0; a < myCalib->shadinglength; a++)
|
||
fprintf (shadingfile[colour], "%04i: %04x %04x\n", a,
|
||
(unsigned int) myCalib->white_shading[colour][a],
|
||
(unsigned int) myCalib->black_shading[colour][a]);
|
||
fclose (shadingfile[colour]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static char *
|
||
dbg_scantype (SANE_Int type)
|
||
{
|
||
switch (type)
|
||
{
|
||
case ST_NORMAL:
|
||
return "ST_NORMAL";
|
||
break;
|
||
case ST_TA:
|
||
return "ST_TA";
|
||
break;
|
||
case ST_NEG:
|
||
return "ST_NEG";
|
||
break;
|
||
default:
|
||
return "Unknown";
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_sensorclock (struct st_cph *cph)
|
||
{
|
||
if (cph != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> cph->p1 = %f\n", cph->p1);
|
||
DBG (DBG_FNC, " -> cph->p2 = %f\n", cph->p2);
|
||
DBG (DBG_FNC, " -> cph->ps = %i\n", cph->ps);
|
||
DBG (DBG_FNC, " -> cph->ge = %i\n", cph->ge);
|
||
DBG (DBG_FNC, " -> cph->go = %i\n", cph->go);
|
||
}
|
||
else
|
||
DBG (DBG_FNC, " -> cph is NULL\n");
|
||
}
|
||
|
||
static void
|
||
dbg_timing (struct st_timing *mt)
|
||
{
|
||
if (mt != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> mt->cdss[0] = %i\n", _B0 (mt->cdss[0]));
|
||
DBG (DBG_FNC, " -> mt->cdsc[0] = %i\n", _B0 (mt->cdsc[0]));
|
||
DBG (DBG_FNC, " -> mt->cdss[1] = %i\n", _B0 (mt->cdss[1]));
|
||
DBG (DBG_FNC, " -> mt->cdsc[1] = %i\n", _B0 (mt->cdsc[1]));
|
||
DBG (DBG_FNC, " -> mt->cnpp = %i\n", _B0 (mt->cnpp));
|
||
DBG (DBG_FNC, " -> mt->cvtrp0 = %i\n", _B0 (mt->cvtrp[0]));
|
||
DBG (DBG_FNC, " -> mt->cvtrp1 = %i\n", _B0 (mt->cvtrp[1]));
|
||
DBG (DBG_FNC, " -> mt->cvtrp2 = %i\n", _B0 (mt->cvtrp[2]));
|
||
DBG (DBG_FNC, " -> mt->cvtrfpw = %i\n", _B0 (mt->cvtrfpw));
|
||
DBG (DBG_FNC, " -> mt->cvtrbpw = %i\n", _B0 (mt->cvtrbpw));
|
||
DBG (DBG_FNC, " -> mt->cvtrw = %i\n", _B0 (mt->cvtrw));
|
||
DBG (DBG_FNC, " -> mt->clamps = 0x%08x\n", mt->clamps);
|
||
DBG (DBG_FNC, " -> mt->clampe = 0x%08x\n", mt->clampe);
|
||
DBG (DBG_FNC, " -> mt->adcclkp0 = %f\n", mt->adcclkp[0]);
|
||
DBG (DBG_FNC, " -> mt->adcclkp1 = %f\n", mt->adcclkp[1]);
|
||
DBG (DBG_FNC, " -> mt->adcclkp2e = %i\n", mt->adcclkp2e);
|
||
DBG (DBG_FNC, " -> mt->cphbp2s = %i\n", mt->cphbp2s);
|
||
DBG (DBG_FNC, " -> mt->cphbp2e = %i\n", mt->cphbp2e);
|
||
}
|
||
else
|
||
DBG (DBG_FNC, " -> mt is NULL\n");
|
||
}
|
||
|
||
static void
|
||
dbg_sensor (struct st_sensorcfg *sensor)
|
||
{
|
||
if (sensor != NULL)
|
||
{
|
||
DBG (DBG_FNC,
|
||
" -> type, name, res , {chn_color }, {chn_gray}, {rgb_order }, line_dist, evnodd_dist\n");
|
||
DBG (DBG_FNC,
|
||
" -> ----, ----, --- , {--, --, --}, {--, -- }, {--, --, --}, ---------, -----------\n");
|
||
DBG (DBG_FNC,
|
||
" -> %4i, %4i, %4i, {%2i, %2i, %2i}, {%2i, %2i }, {%2i, %2i, %2i}, %9i, %11i\n",
|
||
sensor->type, sensor->name, sensor->resolution,
|
||
sensor->channel_color[0], sensor->channel_color[1],
|
||
sensor->channel_color[2], sensor->channel_gray[0],
|
||
sensor->channel_gray[1], sensor->rgb_order[0],
|
||
sensor->rgb_order[1], sensor->rgb_order[2], sensor->line_distance,
|
||
sensor->evenodd_distance);
|
||
}
|
||
else
|
||
DBG (DBG_FNC, " -> sensor is NULL\n");
|
||
}
|
||
|
||
static void
|
||
dbg_buttons (struct st_buttons *buttons)
|
||
{
|
||
if (buttons != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> count, btn1, btn2, btn3, btn4, btn5, btn6\n");
|
||
DBG (DBG_FNC, " -> -----, ----, ----, ----, ----, ----, ----\n");
|
||
DBG (DBG_FNC, " -> %5i, %4i, %4i, %4i, %4i, %4i, %4i\n",
|
||
buttons->count, buttons->mask[0], buttons->mask[1],
|
||
buttons->mask[2], buttons->mask[3], buttons->mask[4],
|
||
buttons->mask[5]);
|
||
}
|
||
else
|
||
DBG (DBG_FNC, " -> buttons is NULL\n");
|
||
}
|
||
|
||
static void
|
||
dbg_scanmodes (struct st_device *dev)
|
||
{
|
||
if (dev->scanmodes_count > 0)
|
||
{
|
||
SANE_Int a;
|
||
struct st_scanmode *reg;
|
||
|
||
DBG (DBG_FNC,
|
||
" -> ##, ST , CM , RES , TM, CV, SR, CLK, CTPC , BKS , STT, DML, { Exposure times }, { Max exposure times }, MP , MExp16, MExpF, MExp, MRI, MSI, MMTIR, MMTIRH, SK\n");
|
||
DBG (DBG_FNC,
|
||
" -> --, ---------, ----------, --- , --, --, --, ---, ------, ----, ---, ---, {------ ------ ------}, {------ ------ ------}, ---, ------, -----, ----, ---, ---, -----, ------, --\n");
|
||
for (a = 0; a < dev->scanmodes_count; a++)
|
||
{
|
||
reg = dev->scanmodes[a];
|
||
if (reg != NULL)
|
||
{
|
||
DBG (DBG_FNC,
|
||
" -> %2i, %9s, %10s, %4i, %2i, %2i, %2i, %3i, %6i, %4i, %3i, %3i, {%6i, %6i, %6i}, {%6i, %6i, %6i}, %3i, %6i, %5i, %4i, %3i, %3i, %5i, %6i, %2i\n",
|
||
a, dbg_scantype (reg->scantype),
|
||
dbg_colour (reg->colormode), reg->resolution, reg->timing,
|
||
reg->motorcurve, reg->samplerate, reg->systemclock,
|
||
reg->ctpc, reg->motorbackstep, reg->scanmotorsteptype,
|
||
reg->dummyline, reg->expt[0], reg->expt[1], reg->expt[2],
|
||
reg->mexpt[0], reg->mexpt[1], reg->mexpt[2],
|
||
reg->motorplus, reg->multiexposurefor16bitmode,
|
||
reg->multiexposureforfullspeed, reg->multiexposure,
|
||
reg->mri, reg->msi, reg->mmtir, reg->mmtirh,
|
||
reg->skiplinecount);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_motorcurves (struct st_device *dev)
|
||
{
|
||
if (dev->mtrsetting != NULL)
|
||
{
|
||
struct st_motorcurve *mtc;
|
||
SANE_Int a = 0;
|
||
|
||
while (a < dev->mtrsetting_count)
|
||
{
|
||
DBG (DBG_FNC, " -> Motorcurve %2i: ", a);
|
||
mtc = dev->mtrsetting[a];
|
||
if (mtc != NULL)
|
||
{
|
||
DBG (DBG_FNC, "mri=%i msi=%i skip=%i bckstp=%i\n", mtc->mri,
|
||
mtc->msi, mtc->skiplinecount, mtc->motorbackstep);
|
||
if (mtc->curve_count > 0)
|
||
{
|
||
char *sdata = (char *) malloc (256);
|
||
if (sdata != NULL)
|
||
{
|
||
char *sline = (char *) malloc (256);
|
||
if (sline != NULL)
|
||
{
|
||
SANE_Int count;
|
||
struct st_curve *crv;
|
||
|
||
DBG (DBG_FNC,
|
||
" -> ##, dir, type , count, from, to , steps\n");
|
||
DBG (DBG_FNC,
|
||
" -> --, ---, ----------, -----, ----, ----, -----\n");
|
||
|
||
count = 0;
|
||
while (count < mtc->curve_count)
|
||
{
|
||
memset (sline, 0, 256);
|
||
|
||
snprintf (sdata, 256, " -> %02i, ", count);
|
||
strcat (sline, sdata);
|
||
|
||
crv = mtc->curve[count];
|
||
if (crv != NULL)
|
||
{
|
||
if (crv->crv_speed == ACC_CURVE)
|
||
strcat (sline, "ACC, ");
|
||
else
|
||
strcat (sline, "DEC, ");
|
||
|
||
switch (crv->crv_type)
|
||
{
|
||
case CRV_NORMALSCAN:
|
||
strcat (sline, "NORMALSCAN, ");
|
||
break;
|
||
case CRV_PARKHOME:
|
||
strcat (sline, "PARKHOME , ");
|
||
break;
|
||
case CRV_SMEARING:
|
||
strcat (sline, "SMEARING , ");
|
||
break;
|
||
case CRV_BUFFERFULL:
|
||
strcat (sline, "BUFFERFULL, ");
|
||
break;
|
||
default:
|
||
snprintf (sdata, 256, "unknown %2i, ",
|
||
crv->crv_type);
|
||
strcat (sline, sdata);
|
||
break;
|
||
}
|
||
|
||
snprintf (sdata, 256, "%5i, ",
|
||
crv->step_count);
|
||
strcat (sline, sdata);
|
||
if (crv->step_count > 0)
|
||
{
|
||
SANE_Int stpcount = 0;
|
||
|
||
snprintf (sdata, 256, "%4i, %4i| ",
|
||
crv->step[0],
|
||
crv->step[crv->step_count -
|
||
1]);
|
||
strcat (sline, sdata);
|
||
|
||
while (stpcount < crv->step_count)
|
||
{
|
||
if (stpcount == 10)
|
||
{
|
||
strcat (sline, "...");
|
||
break;
|
||
}
|
||
if (stpcount > 0)
|
||
strcat (sline, ", ");
|
||
|
||
snprintf (sdata, 256, "%4i",
|
||
crv->step[stpcount]);
|
||
strcat (sline, sdata);
|
||
|
||
stpcount++;
|
||
}
|
||
strcat (sline, "\n");
|
||
}
|
||
else
|
||
strcat (sline, "NONE\n");
|
||
}
|
||
else
|
||
strcat (sline, "NULL ...\n");
|
||
|
||
DBG (DBG_FNC, "%s", sline);
|
||
|
||
count++;
|
||
}
|
||
|
||
free (sline);
|
||
}
|
||
free (sdata);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
DBG (DBG_FNC, "NULL\n");
|
||
a++;
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_motormoves (struct st_device *dev)
|
||
{
|
||
if (dev->motormove_count > 0)
|
||
{
|
||
SANE_Int a;
|
||
struct st_motormove *reg;
|
||
|
||
DBG (DBG_FNC, " -> ##, CLK, CTPC, STT, CV\n");
|
||
DBG (DBG_FNC, " -> --, ---, ----, ---, --\n");
|
||
for (a = 0; a < dev->motormove_count; a++)
|
||
{
|
||
reg = dev->motormove[a];
|
||
if (reg != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> %2i, %3i, %4i, %3i, %2i\n",
|
||
a, reg->systemclock, reg->ctpc,
|
||
reg->scanmotorsteptype, reg->motorcurve);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_hwdcfg (struct st_hwdconfig *params)
|
||
{
|
||
if (params != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> Low level config:\n");
|
||
DBG (DBG_FNC, " -> startpos = %i\n", params->startpos);
|
||
DBG (DBG_FNC, " -> arrangeline = %s\n",
|
||
(params->arrangeline ==
|
||
FIX_BY_SOFT) ? "FIX_BY_SOFT" : (params->arrangeline ==
|
||
FIX_BY_HARD) ? "FIX_BY_HARD" :
|
||
"FIX_BY_NONE");
|
||
DBG (DBG_FNC, " -> scantype = %s\n",
|
||
dbg_scantype (params->scantype));
|
||
DBG (DBG_FNC, " -> compression = %i\n", params->compression);
|
||
DBG (DBG_FNC, " -> use_gamma_tables = %i\n",
|
||
params->use_gamma_tables);
|
||
DBG (DBG_FNC, " -> gamma_tablesize = %i\n",
|
||
params->gamma_tablesize);
|
||
DBG (DBG_FNC, " -> white_shading = %i\n",
|
||
params->white_shading);
|
||
DBG (DBG_FNC, " -> black_shading = %i\n",
|
||
params->black_shading);
|
||
DBG (DBG_FNC, " -> unk3 = %i\n", params->unk3);
|
||
DBG (DBG_FNC, " -> motorplus = %i\n", params->motorplus);
|
||
DBG (DBG_FNC, " -> static_head = %i\n", params->static_head);
|
||
DBG (DBG_FNC, " -> motor_direction = %s\n",
|
||
(params->motor_direction == MTR_FORWARD) ? "FORWARD" : "BACKWARD");
|
||
DBG (DBG_FNC, " -> dummy_scan = %i\n", params->dummy_scan);
|
||
DBG (DBG_FNC, " -> highresolution = %i\n",
|
||
params->highresolution);
|
||
DBG (DBG_FNC, " -> sensorevenodddistance = %i\n",
|
||
params->sensorevenodddistance);
|
||
DBG (DBG_FNC, " -> calibrate = %i\n", params->calibrate);
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_ScanParams (struct st_scanparams *params)
|
||
{
|
||
if (params != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> Scan params:\n");
|
||
DBG (DBG_FNC, " -> colormode = %s\n",
|
||
dbg_colour (params->colormode));
|
||
DBG (DBG_FNC, " -> depth = %i\n", params->depth);
|
||
DBG (DBG_FNC, " -> samplerate = %i\n", params->samplerate);
|
||
DBG (DBG_FNC, " -> timing = %i\n", params->timing);
|
||
DBG (DBG_FNC, " -> channel = %i\n", params->channel);
|
||
DBG (DBG_FNC, " -> sensorresolution = %i\n", params->sensorresolution);
|
||
DBG (DBG_FNC, " -> resolution_x = %i\n", params->resolution_x);
|
||
DBG (DBG_FNC, " -> resolution_y = %i\n", params->resolution_y);
|
||
DBG (DBG_FNC, " -> left = %i\n", params->coord.left);
|
||
DBG (DBG_FNC, " -> width = %i\n", params->coord.width);
|
||
DBG (DBG_FNC, " -> top = %i\n", params->coord.top);
|
||
DBG (DBG_FNC, " -> height = %i\n", params->coord.height);
|
||
DBG (DBG_FNC, " -> shadinglength = %i\n", params->shadinglength);
|
||
DBG (DBG_FNC, " -> v157c = %i\n", params->v157c);
|
||
DBG (DBG_FNC, " -> bytesperline = %i\n", params->bytesperline);
|
||
DBG (DBG_FNC, " -> expt = %i\n", params->expt);
|
||
DBG (DBG_FNC, " *> startpos = %i\n", params->startpos);
|
||
DBG (DBG_FNC, " *> leftleading = %i\n", params->leftleading);
|
||
DBG (DBG_FNC, " *> ser = %i\n", params->ser);
|
||
DBG (DBG_FNC, " *> ler = %i\n", params->ler);
|
||
DBG (DBG_FNC, " *> scantype = %s\n",
|
||
dbg_scantype (params->scantype));
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_calibtable (struct st_gain_offset *params)
|
||
{
|
||
if (params != NULL)
|
||
{
|
||
DBG (DBG_FNC, " -> Calib table:\n");
|
||
DBG (DBG_FNC, " -> type R G B\n");
|
||
DBG (DBG_FNC, " -> ----- --- --- ---B\n");
|
||
DBG (DBG_FNC, " -> edcg1 = %3i , %3i , %3i\n", params->edcg1[0],
|
||
params->edcg1[1], params->edcg1[2]);
|
||
DBG (DBG_FNC, " -> edcg2 = %3i , %3i , %3i\n", params->edcg2[0],
|
||
params->edcg2[1], params->edcg2[2]);
|
||
DBG (DBG_FNC, " -> odcg1 = %3i , %3i , %3i\n", params->odcg1[0],
|
||
params->odcg1[1], params->odcg1[2]);
|
||
DBG (DBG_FNC, " -> odcg2 = %3i , %3i , %3i\n", params->odcg2[0],
|
||
params->odcg2[1], params->odcg2[2]);
|
||
DBG (DBG_FNC, " -> pag = %3i , %3i , %3i\n", params->pag[0],
|
||
params->pag[1], params->pag[2]);
|
||
DBG (DBG_FNC, " -> vgag1 = %3i , %3i , %3i\n", params->vgag1[0],
|
||
params->vgag1[1], params->vgag1[2]);
|
||
DBG (DBG_FNC, " -> vgag2 = %3i , %3i , %3i\n", params->vgag2[0],
|
||
params->vgag2[1], params->vgag2[2]);
|
||
}
|
||
}
|
||
|
||
static char *
|
||
dbg_colour (SANE_Int colour)
|
||
{
|
||
switch (colour)
|
||
{
|
||
case CM_COLOR:
|
||
return "CM_COLOR";
|
||
break;
|
||
case CM_GRAY:
|
||
return "CM_GRAY";
|
||
break;
|
||
case CM_LINEART:
|
||
return "CM_LINEART";
|
||
break;
|
||
default:
|
||
return "Unknown";
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_motorcfg (struct st_motorcfg *motorcfg)
|
||
{
|
||
if (motorcfg != NULL)
|
||
{
|
||
DBG (DBG_FNC,
|
||
" -> type, res , freq, speed, base, high, park, change\n");
|
||
DBG (DBG_FNC,
|
||
" -> ----, --- , ----, -----, ----, ----, ----, ------\n");
|
||
DBG (DBG_FNC, " -> %4i, %4i, %4i, %5i, %4i, %4i, %4i, %6i\n",
|
||
motorcfg->type, motorcfg->resolution, motorcfg->pwmfrequency,
|
||
motorcfg->basespeedpps, motorcfg->basespeedmotormove,
|
||
motorcfg->highspeedmotormove, motorcfg->parkhomemotormove,
|
||
motorcfg->changemotorcurrent);
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_tiff_save (char *sFile, SANE_Int width, SANE_Int height, SANE_Int depth,
|
||
SANE_Int colortype, SANE_Int res_x, SANE_Int res_y,
|
||
SANE_Byte * buffer, SANE_Int size)
|
||
{
|
||
#ifdef HAVE_TIFFIO_H
|
||
if (buffer != NULL)
|
||
{
|
||
char *path = getenv ("HOME");
|
||
|
||
if (path != NULL)
|
||
{
|
||
char filename[512];
|
||
TIFF *image;
|
||
|
||
if (snprintf (filename, 512, "%s/%s", path, sFile) > 0)
|
||
{
|
||
/* Open the TIFF file */
|
||
if ((image = TIFFOpen (filename, "w")) != NULL)
|
||
{
|
||
char desc[256];
|
||
|
||
SANE_Int spp = (colortype == CM_GRAY) ? 1 : 3;
|
||
SANE_Int ct =
|
||
(colortype ==
|
||
CM_GRAY) ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB;
|
||
|
||
snprintf (desc, 256, "Created with hp3900 %s",
|
||
BACKEND_VRSN);
|
||
|
||
/* We need to set some values for basic tags before we can add any data */
|
||
TIFFSetField (image, TIFFTAG_IMAGEWIDTH, width);
|
||
TIFFSetField (image, TIFFTAG_IMAGELENGTH, height);
|
||
TIFFSetField (image, TIFFTAG_BITSPERSAMPLE, depth);
|
||
TIFFSetField (image, TIFFTAG_SAMPLESPERPIXEL, spp);
|
||
|
||
TIFFSetField (image, TIFFTAG_PHOTOMETRIC, ct);
|
||
TIFFSetField (image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
|
||
TIFFSetField (image, TIFFTAG_PLANARCONFIG,
|
||
PLANARCONFIG_CONTIG);
|
||
|
||
TIFFSetField (image, TIFFTAG_XRESOLUTION, (double) res_x);
|
||
TIFFSetField (image, TIFFTAG_YRESOLUTION, (double) res_y);
|
||
TIFFSetField (image, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
|
||
TIFFSetField (image, TIFFTAG_IMAGEDESCRIPTION, desc);
|
||
|
||
/* Write the information to the file */
|
||
TIFFWriteRawStrip (image, 0, buffer, size);
|
||
TIFFClose (image);
|
||
}
|
||
}
|
||
else
|
||
DBG (DBG_ERR, "- dbg_tiff_save: Error generating filename\n");
|
||
}
|
||
else
|
||
DBG (DBG_ERR,
|
||
"- dbg_tiff_save: Enviroment HOME variable does not exist\n");
|
||
}
|
||
#else
|
||
/* silent gcc */
|
||
sFile = sFile;
|
||
width = width;
|
||
height = height;
|
||
depth = depth;
|
||
colortype = colortype;
|
||
res_x = res_x;
|
||
res_y = res_y;
|
||
buffer = buffer;
|
||
size = size;
|
||
|
||
DBG (DBG_ERR, "- dbg_tiff_save: tiffio not supported\n");
|
||
#endif
|
||
}
|
||
|
||
static void
|
||
dbg_autoref (struct st_scanparams *scancfg, SANE_Byte * pattern,
|
||
SANE_Int ser1, SANE_Int ser2, SANE_Int ler)
|
||
{
|
||
/* this function generates post-autoref.tiff */
|
||
SANE_Byte *img =
|
||
malloc (sizeof (SANE_Byte) *
|
||
(scancfg->coord.width * scancfg->coord.height * 3));
|
||
|
||
if (img != NULL)
|
||
{
|
||
SANE_Int c, value;
|
||
|
||
/* generate image from 1 gray channel to 3 color channels */
|
||
for (c = 0; c < (scancfg->coord.width * scancfg->coord.height); c++)
|
||
{
|
||
value = *(pattern + c);
|
||
*(img + (3 * c)) = value;
|
||
*(img + (3 * c) + 1) = value;
|
||
*(img + (3 * c) + 2) = value;
|
||
}
|
||
|
||
for (c = 0; c < scancfg->coord.height; c++)
|
||
{
|
||
/* line for first SER */
|
||
if (c < (ler + 5))
|
||
{
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser1)) = 0;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser1) + 1) = 255;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser1) + 2) = 0;
|
||
}
|
||
|
||
/* line for second SER */
|
||
if (c > (ler - 5))
|
||
{
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser2)) = 90;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser2) + 1) = 90;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * ser2) + 2) = 255;
|
||
}
|
||
|
||
/* vertical lines of the pointer */
|
||
if ((c > (ler - 5)) && (c < (ler + 5)))
|
||
{
|
||
if ((ser2 - 5) >= 0)
|
||
{
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5))) =
|
||
255;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5)) +
|
||
1) = 255;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5)) +
|
||
2) = 0;
|
||
}
|
||
|
||
if ((ser2 + 5) < scancfg->coord.width)
|
||
{
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5))) =
|
||
255;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5)) +
|
||
1) = 255;
|
||
*(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5)) +
|
||
2) = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* line for first LER */
|
||
for (c = 0; c < scancfg->coord.width; c++)
|
||
{
|
||
if ((c > (ser1 - 5)) && (c < (ser2 + 5)))
|
||
{
|
||
if (c != (ser2 - 5))
|
||
{
|
||
*(img + (scancfg->coord.width * ler * 3) + (3 * c)) = 255;
|
||
*(img + (scancfg->coord.width * ler * 3) + (3 * c) + 1) =
|
||
90;
|
||
*(img + (scancfg->coord.width * ler * 3) + (3 * c) + 2) =
|
||
90;
|
||
}
|
||
|
||
/* horizontal lines of the pointer */
|
||
if ((c > (ser2 - 5)) && (c < (ser2 + 5)))
|
||
{
|
||
if ((ler - 5) >= 0)
|
||
{
|
||
*(img + (scancfg->coord.width * (ler - 5) * 3) +
|
||
(3 * c)) = 255;
|
||
*(img + (scancfg->coord.width * (ler - 5) * 3) +
|
||
(3 * c) + 1) = 255;
|
||
*(img + (scancfg->coord.width * (ler - 5) * 3) +
|
||
(3 * c) + 2) = 0;
|
||
}
|
||
|
||
if ((ler + 5) < scancfg->coord.height)
|
||
{
|
||
*(img + (scancfg->coord.width * (ler + 5) * 3) +
|
||
(3 * c)) = 255;
|
||
*(img + (scancfg->coord.width * (ler + 5) * 3) +
|
||
(3 * c) + 1) = 255;
|
||
*(img + (scancfg->coord.width * (ler + 5) * 3) +
|
||
(3 * c) + 2) = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
dbg_tiff_save ("post-autoref.tiff", scancfg->coord.width,
|
||
scancfg->coord.height, 8, CM_COLOR,
|
||
scancfg->resolution_x, scancfg->resolution_y, img,
|
||
scancfg->coord.height * scancfg->coord.width * 3);
|
||
|
||
/* free generated image */
|
||
free (img);
|
||
}
|
||
}
|
||
|
||
#ifdef developing
|
||
|
||
static void
|
||
dbg_buffer (SANE_Int level, char *title, SANE_Byte * buffer, SANE_Int size,
|
||
SANE_Int start)
|
||
{
|
||
if (level <= DBG_LEVEL)
|
||
{
|
||
DBG (level, "%s ", title);
|
||
if ((size > 0) && (buffer != NULL))
|
||
{
|
||
SANE_Int cont, data, offset = 0;
|
||
SANE_Int col = 0;
|
||
char text[9];
|
||
char *sline = NULL;
|
||
char *sdata = NULL;
|
||
|
||
sline = (char *) malloc (81);
|
||
if (sline != NULL)
|
||
{
|
||
sdata = (char *) malloc (81);
|
||
if (sdata != NULL)
|
||
{
|
||
for (cont = 0; cont < size; cont++)
|
||
{
|
||
if (col == 0)
|
||
{
|
||
if (cont == 0)
|
||
snprintf (sline, 80, " BF: ");
|
||
else
|
||
snprintf (sline, 80, " ");
|
||
bzero (&text, sizeof (text));
|
||
}
|
||
data = _B0 (buffer[cont]);
|
||
text[col] = (data > 31) ? data : '<EFBFBD>';
|
||
snprintf (sdata, 80, "%02x ", data);
|
||
sline = strcat (sline, sdata);
|
||
col++;
|
||
offset++;
|
||
if (col == 8)
|
||
{
|
||
col = 0;
|
||
snprintf (sdata, 80, " : %s : 0x%04x\n", text,
|
||
start + offset - 8);
|
||
sline = strcat (sline, sdata);
|
||
DBG (level, "%s", sline);
|
||
bzero (sline, 81);
|
||
}
|
||
}
|
||
if (col > 0)
|
||
{
|
||
for (cont = col; cont < 8; cont++)
|
||
{
|
||
snprintf (sdata, 80, "-- ");
|
||
sline = strcat (sline, sdata);
|
||
offset++;
|
||
}
|
||
snprintf (sdata, 80, " : %s : 0x%04x\n", text,
|
||
start + offset - 8);
|
||
sline = strcat (sline, sdata);
|
||
DBG (level, "%s", sline);
|
||
bzero (sline, 81);
|
||
}
|
||
free (sdata);
|
||
}
|
||
free (sline);
|
||
}
|
||
}
|
||
else
|
||
DBG (level, " BF: Empty buffer\n");
|
||
}
|
||
}
|
||
|
||
static void
|
||
dbg_registers (SANE_Byte * buffer)
|
||
{
|
||
/* buffer size must be RT_BUFFER_LEN bytes */
|
||
/*SANE_Int iValue, iValue2;
|
||
double dValue;
|
||
|
||
DBG(DBG_FNC, "\n----------------------------------------------------\n");
|
||
DBG(DBG_FNC, """RTS8822 Control Registers Info""\nAddress Info\n------- ----\n");
|
||
iValue = data_lsb_get(&buffer[0x000], 1);
|
||
DBG(DBG_FNC, "\n0x0000");
|
||
DBG(DBG_FNC, " bit[0..3] = systemclock: 0x%02x\n", iValue & 0x0f);
|
||
DBG(DBG_FNC, " bit[4] = 0x%02x : MLOCK\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5] = 0x%02x : Bit to reset scanner\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[6] = 0x%02x : ?\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = 0x%02x : RTS_IsExecuting\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x001], 1);
|
||
DBG(DBG_FNC, "0x0001 bit[0] = 0x%02x : ?\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = 0x%02x : (is 1 if has motorcurves)\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2] = 0x%02x : ?\n", (iValue >> 2) & 1);
|
||
DBG(DBG_FNC, " bit[3] = 0x%02x : ?\n", (iValue >> 3) & 1);
|
||
DBG(DBG_FNC, " bit[4] = 0x%02x : dummy scan\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5..7] = 0x%02x : ?\n", (iValue >> 5) & 7);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0002", &buffer[0x002], 0x0e, 0x02);
|
||
|
||
iValue = data_lsb_get(&buffer[0x010], 1);
|
||
DBG(DBG_FNC, "\n0x0010 bit[0..4] = 0x%02x : cvrs\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5] = 0x%02x : Enable CCD\n", ((iValue >> 5) & 1));
|
||
DBG(DBG_FNC, " bit[6] = 0x%02x : Enable CCD channel 1\n", ((iValue >> 6) & 1));
|
||
DBG(DBG_FNC, " bit[7] = 0x%02x : Enable CCD channel 2\n", ((iValue >> 7) & 1));
|
||
|
||
iValue = data_lsb_get(&buffer[0x011], 1);
|
||
DBG(DBG_FNC, "\n0x0011 bit[0..6] = ?: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[7] = 0x%02x : sensor type (CCD=0|CIS=1)\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x012], 1);
|
||
DBG(DBG_FNC, "0x0012 bit[0..5] = 0x%02x [0x%02x,0x%02x,0x%02x] rgb channel order\n", (iValue & 0x3f), (iValue >> 4) & 3, (iValue >> 2) & 3, iValue & 3);
|
||
DBG(DBG_FNC, " bit[6..7] = channels_per_dot : 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x013], 1);
|
||
DBG(DBG_FNC, "\n0x0013");
|
||
DBG(DBG_FNC, " bit[0..1] = Pre-Amplifier Gain[RED] : 0x%02x\n", iValue & 3);
|
||
DBG(DBG_FNC, " bit[2..3] = Pre-Amplifier Gain[GREEN] : 0x%02x\n", (iValue >> 2) & 3);
|
||
DBG(DBG_FNC, " bit[4..5] = Pre-Amplifier Gain[BLUE] : 0x%02x\n", (iValue >> 4) & 3);
|
||
DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = Enable CCD channel 3: : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x014], 1);
|
||
DBG(DBG_FNC, "\n0x0014");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [RED] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Top Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x015], 1);
|
||
DBG(DBG_FNC, "0x0015");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [GREEN] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Middle Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x016], 1);
|
||
DBG(DBG_FNC, "0x0016");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [BLUE] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Bottom Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x017], 1);
|
||
DBG(DBG_FNC, "0x0017");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [RED] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Top Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x018], 1);
|
||
DBG(DBG_FNC, "0x0018");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [GREEN] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Middle Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x019], 1);
|
||
DBG(DBG_FNC, "0x0019");
|
||
DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [BLUE] : 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = Bottom Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x01a], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x01b], 1);
|
||
DBG(DBG_FNC, "\n0x001a-0x001b\n");
|
||
DBG(DBG_FNC, " Red Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Red Even offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x01c], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x01d], 1);
|
||
DBG(DBG_FNC, "0x001c-0x001d\n");
|
||
DBG(DBG_FNC, " Red Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Red Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x01e], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x01f], 1);
|
||
DBG(DBG_FNC, "0x001e-0x001f\n");
|
||
DBG(DBG_FNC, " Green Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Green Even offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x020], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x021], 1);
|
||
DBG(DBG_FNC, "0x0020-0x0021\n");
|
||
DBG(DBG_FNC, " Green Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Green Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x022], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x023], 1);
|
||
DBG(DBG_FNC, "0x0022-0x0023\n");
|
||
DBG(DBG_FNC, " Blue Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Blue Even offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x024], 1);
|
||
iValue2 = data_lsb_get(&buffer[0x025], 1);
|
||
DBG(DBG_FNC, "0x0024-0x0025\n");
|
||
DBG(DBG_FNC, " Blue Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
|
||
DBG(DBG_FNC, " Blue Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0026", &buffer[0x026], 0x03, 0x26);
|
||
|
||
iValue = data_lsb_get(&buffer[0x029], 1);
|
||
DBG(DBG_FNC, "\n0x0029");
|
||
DBG(DBG_FNC, " First connection to scanner? : 0x%02x\n", iValue);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x002a", &buffer[0x02a], 0x06, 0x2a);
|
||
|
||
DBG(DBG_FNC, "\nExposure times:\n");
|
||
iValue = data_lsb_get(&buffer[0x030], 3);
|
||
DBG(DBG_FNC, "0x0030 Line exposure time : %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x033], 3);
|
||
DBG(DBG_FNC, "\n0x0033 mexpts[RED] : %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x036], 3);
|
||
DBG(DBG_FNC, "0x0036 expts[RED] : %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x039], 3);
|
||
DBG(DBG_FNC, "0x0039 mexpts[GREEN]: %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x03c], 3);
|
||
DBG(DBG_FNC, "0x003c expts[GREEN]: %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x03f], 3);
|
||
DBG(DBG_FNC, "0x003f mexpts[BLUE] : %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x042], 3);
|
||
DBG(DBG_FNC, "0x0042 expts[BLUE] : %i us\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x045], 1);
|
||
DBG(DBG_FNC, "\n0x0045 bit[0..4] = timing.cvtrfpw: 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5] = timing.cvtrp[2]: 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[6] = timing.cvtrp[1]: 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = timing.cvtrp[0]: 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x046], 1);
|
||
DBG(DBG_FNC, "0x0046");
|
||
DBG(DBG_FNC, " bit[0..4] = timing.cvtrbpw: 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x047], 1);
|
||
DBG(DBG_FNC, "0x0047");
|
||
DBG(DBG_FNC, " timing.cvtrw: 0x%02x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x04c], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x04a], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x048], 0x02);
|
||
DBG(DBG_FNC, "\n0x0048 Linear image sensor clock 1\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph0p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x04c], 0x01);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph0go: 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph0ge: 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph0ps: 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x051], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x04f], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x04d], 0x02);
|
||
DBG(DBG_FNC, "0x004d");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph0p2: %.0f.\n", dValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x056], 1) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x054], 2);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x052], 2);
|
||
DBG(DBG_FNC, "\n0x0052 Linear image sensor clock 2\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph1p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x056], 1);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph1go: 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph1ge: 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph1ps: 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
|
||
iValue = data_lsb_get(&buffer[0x05b], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x059], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x057], 0x02);
|
||
DBG(DBG_FNC, "0x0057");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph1p2: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x05b], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = %02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: %02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: %02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: %02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: %02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x060], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x05e], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x05c], 0x02);
|
||
DBG(DBG_FNC, "\n0x005c Linear Image Sensor Clock 3\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph2p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x060], 0x01);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph2go: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph2ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph2ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x065], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x063], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x061], 0x02);
|
||
DBG(DBG_FNC, "0x0061");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph2p2: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x065], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x06a], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x068], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x066], 0x02);
|
||
DBG(DBG_FNC, "\n0x0066 Linear Image Sensor Clock 4\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph3p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x06a], 0x01);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph3go: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph3ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph3ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x06f], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x06d], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x06b], 0x02);
|
||
DBG(DBG_FNC, "0x006b");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph3p2: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x06f], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x074], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x072], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x070], 0x02);
|
||
DBG(DBG_FNC, "\n0x0070 Linear Image Sensor Clock 5\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph4p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x074], 0x01);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph4go: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph4ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph4ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x079], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x077], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x075], 0x02);
|
||
DBG(DBG_FNC, "0x0075");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph4p2: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x079], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x07e], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x07c], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x07a], 0x02);
|
||
DBG(DBG_FNC, "\n0x007a Linear Image Sensor Clock 6\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph5p1: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x07e], 0x01);
|
||
DBG(DBG_FNC, " bit[36] = timing.cph5go: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = timing.cph5ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = timing.cph5ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x083], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x081], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x07f], 0x02);
|
||
DBG(DBG_FNC, "0x007f");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.cph5p2: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x083], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
iValue = data_lsb_get(&buffer[0x084], 3);
|
||
DBG(DBG_FNC, "\n0x0084");
|
||
DBG(DBG_FNC, " timing.cphbp2s : 0x%06x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x087], 3);
|
||
DBG(DBG_FNC, "0x0087");
|
||
DBG(DBG_FNC, " timing.cphbp2e : 0x%06x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x08a], 3);
|
||
DBG(DBG_FNC, "0x008a");
|
||
DBG(DBG_FNC, " timing.clamps : 0x%08x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x08d], 3);
|
||
DBG(DBG_FNC, "0x008d");
|
||
DBG(DBG_FNC, " timing.clampe or cphbp2e : 0x%08x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x092], 0x01);
|
||
DBG(DBG_FNC, "\n0x0092 Correlated-Double-Sample 1\n");
|
||
DBG(DBG_FNC, " bit[0..5] = timing.cdss[0]: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x093], 0x01);
|
||
DBG(DBG_FNC, "0x0093");
|
||
DBG(DBG_FNC, " bit[0..5] = timing.cdsc[0]: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x094], 0x01);
|
||
DBG(DBG_FNC, "\n0x0094 Correlated-Double-Sample 2\n");
|
||
DBG(DBG_FNC, " bit[0..5] = timing.cdss[1]: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x095], 0x01);
|
||
DBG(DBG_FNC, "0x0095");
|
||
DBG(DBG_FNC, " bit[0..5] = timing.cdsc[1]: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x096], 0x01);
|
||
DBG(DBG_FNC, "0x0096");
|
||
DBG(DBG_FNC, " bit[0..5] = timing.cnpp: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x09b], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x099], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x097], 0x02);
|
||
DBG(DBG_FNC, "\n0x0097 Analog to Digital Converter clock 1\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.adcclkp[0]: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x09b], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x009c CIS sensor 1", &buffer[0x09c], 0x06, 0x9c);
|
||
dbg_buffer(DBG_FNC, "0x00a2 CIS sensor 2", &buffer[0x0a2], 0x06, 0xa2);
|
||
dbg_buffer(DBG_FNC, "0x00a8 CIS sensor 3", &buffer[0x0a8], 0x06, 0xa8);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0ae], 0x01);
|
||
DBG(DBG_FNC, "\n0x00ae");
|
||
DBG(DBG_FNC, " bit[0..5] = ?: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0af], 0x01);
|
||
DBG(DBG_FNC, "0x00af");
|
||
DBG(DBG_FNC, " bit[0..2] = ?: 0x%02x\n", iValue & 7);
|
||
DBG(DBG_FNC, " bit[3..7] = ?: 0x%02x\n", (iValue >> 3) & 0x1f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0b0], 2);
|
||
DBG(DBG_FNC, "\n0x00b0");
|
||
DBG(DBG_FNC, " Left : 0x%04x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0b2], 2);
|
||
DBG(DBG_FNC, "0x00b2");
|
||
DBG(DBG_FNC, " Right: 0x%04x\n", iValue);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x00b4", &buffer[0x0b4], 12, 0xb4);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0c0], 0x01);
|
||
DBG(DBG_FNC, "\n0x00c0");
|
||
DBG(DBG_FNC, " bit[0..4] = resolution ratio: 0x%02x\n", iValue & 0x1f);
|
||
DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0c5], 0x01) & 0x0f;
|
||
dValue = iValue * pow(2, 32);
|
||
iValue = data_lsb_get(&buffer[0x0c3], 0x02);
|
||
dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x0c1], 2);
|
||
DBG(DBG_FNC, "\n0x00c1 Analog to Digital Converter clock 2\n");
|
||
DBG(DBG_FNC, " bit[0..35] = timing.adcclkp[1]: %.0f.\n", dValue);
|
||
iValue = data_lsb_get(&buffer[0x0c5], 0x01);
|
||
DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
|
||
DBG(DBG_FNC, " bit[36] = ?: 0x%02x (equal to bit[32])\n", (iValue >> 0x04) & 0x01);
|
||
DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
|
||
DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
|
||
DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x00c6", &buffer[0x0c6], 0x0a, 0xc6);
|
||
|
||
iValue = ((buffer[0x0d4] & 0x0f) << 0x10) + data_lsb_get(&buffer[0x0d0], 0x02);
|
||
DBG(DBG_FNC, "\n0x00d0");
|
||
DBG(DBG_FNC, " Top : 0x%04x\n", iValue);
|
||
|
||
iValue = ((buffer[0x0d4] & 0xf0) << 0x06)+ data_lsb_get(&buffer[0x0d2], 0x02);
|
||
DBG(DBG_FNC, "x00d2");
|
||
DBG(DBG_FNC, " Down: 0x%04x\n", iValue);
|
||
|
||
iValue = _B0(buffer[0x0d5]);
|
||
DBG(DBG_FNC, "0x00d5");
|
||
DBG(DBG_FNC, " ?: 0x%04x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0d6], 1);
|
||
DBG(DBG_FNC, "\n0x00d6");
|
||
DBG(DBG_FNC, " bit[0..3] = ? : 0x%02x\n", iValue & 0xf);
|
||
DBG(DBG_FNC, " bit[4..7] = dummyline: 0x%02x\n", (iValue >> 4) & 0xf);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0d7], 0x01);
|
||
DBG(DBG_FNC, "\n0x00d7");
|
||
DBG(DBG_FNC, " bit[0..5] = motor pwm frequency: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6] = ?: 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = motor type: 0x%02x ", (iValue >> 7) & 1);
|
||
if (((iValue >> 7) & 1) == MT_OUTPUTSTATE)
|
||
DBG(DBG_FNC, ": Output state machine\n");
|
||
else DBG(DBG_FNC, "On-Chip PWM\n");
|
||
|
||
iValue = data_lsb_get(&buffer[0x0d8], 0x01);
|
||
DBG(DBG_FNC, "\n0x00d8");
|
||
DBG(DBG_FNC, " bit[0..5] = ?: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6] = scantype (0=Normal|1=TMA) : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = enable head movement : 0x%02x :", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0d9], 0x01);
|
||
DBG(DBG_FNC, "\n0x00d9");
|
||
DBG(DBG_FNC, " bit[0..2] = ?: 0x%02x\n", iValue & 7);
|
||
DBG(DBG_FNC, " bit[3] = ?: 0x%02x\n", (iValue >> 3) & 1);
|
||
DBG(DBG_FNC, " bit[4..6] = motor step type: 0x%02x: ", (iValue >> 4) & 7);
|
||
switch((iValue >> 4) & 7)
|
||
{
|
||
case 0: DBG(DBG_FNC, "full (1)\n"); break;
|
||
case 1: DBG(DBG_FNC, "half (1/2)\n"); break;
|
||
case 2: DBG(DBG_FNC, "quart (1/4)\n"); break;
|
||
case 3: DBG(DBG_FNC, "(1/8)\n"); break;
|
||
default: DBG(DBG_FNC, "unknown\n"); break;
|
||
}
|
||
DBG(DBG_FNC, " bit[7] = Motor direction: 0x%02x = ", (iValue >> 7) & 1);
|
||
if (((iValue >> 7) & 1) == 0)
|
||
DBG(DBG_FNC, "Backward\n");
|
||
else DBG(DBG_FNC, "Forward\n");
|
||
|
||
iValue = data_lsb_get(&buffer[0x0dd], 0x01);
|
||
DBG(DBG_FNC, "\n0x00da");
|
||
DBG(DBG_FNC, " msi = 0x%03x\n", ((iValue & 3) << 8) + data_lsb_get(&buffer[0x0da], 1));
|
||
|
||
DBG(DBG_FNC, "0x00db");
|
||
DBG(DBG_FNC, " motorbackstep1 = 0x%03x\n", ((iValue & 0x0c) << 6) + data_lsb_get(&buffer[0x0db], 1));
|
||
|
||
DBG(DBG_FNC, "0x00dc");
|
||
DBG(DBG_FNC, " motorbackstep2 = 0x%03x\n", ((iValue & 0x30) << 4) + data_lsb_get(&buffer[0x0dc], 1));
|
||
|
||
iValue = data_lsb_get(&buffer[0x0dd], 0x01);
|
||
DBG(DBG_FNC, "0x00dd");
|
||
DBG(DBG_FNC, " bit[7] = Motor enabled?: 0x%02x = ", (iValue >> 7) & 1);
|
||
if (((iValue >> 7) & 1) == 0)
|
||
DBG(DBG_FNC, "Yes\n");
|
||
else DBG(DBG_FNC, "No\n");
|
||
|
||
iValue = data_lsb_get(&buffer[0x0de], 0x02);
|
||
DBG(DBG_FNC, "\n0x00de");
|
||
DBG(DBG_FNC, " bit[00..11] = ?: 0x%02x\n", iValue & 0xfff);
|
||
DBG(DBG_FNC, " bit[12..15] = ?: 0x%02x\n", (iValue >> 12) & 0x0f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0df], 0x01);
|
||
DBG(DBG_FNC, "\n0x00df");
|
||
DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0x0f);
|
||
DBG(DBG_FNC, " bit[4] = has_motorcurves?: 0x%02x\n", (iValue >> 4) & 0x01);
|
||
DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0e0], 1);
|
||
DBG(DBG_FNC, "\n0x00e0 step size - 1 : 0x%02x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0e1], 3);
|
||
DBG(DBG_FNC, "\n0x00e1 0x%06x : last step of accurve.normalscan table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0e4], 3);
|
||
DBG(DBG_FNC, "0x00e4 0x%06x : last step of accurve.smearing table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0e7], 3);
|
||
DBG(DBG_FNC, "0x00e7 0x%06x : last step of accurve.parkhome table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0ea], 3);
|
||
DBG(DBG_FNC, "0x00ea 0x%06x : last step of deccurve.scanbufferfull table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0ed], 3);
|
||
DBG(DBG_FNC, "0x00ed 0x%06x : last step of deccurve.normalscan table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0f0], 3);
|
||
DBG(DBG_FNC, "0x00f0 0x%06x : last step of deccurve.smearing table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0f3], 3);
|
||
DBG(DBG_FNC, "0x00f3 0x%06x : last step of deccurve.parkhome table\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0f6], 2);
|
||
DBG(DBG_FNC, "\n0x00f6 bit[00..13] = 0x%04x : ptr to accurve.normalscan step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0f8], 2);
|
||
DBG(DBG_FNC, "0x00f8");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.scanbufferfull step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0fa], 2);
|
||
DBG(DBG_FNC, "0x00fa");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to accurve.smearing step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0fc], 2);
|
||
DBG(DBG_FNC, "0x00fc");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.smearing step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x0fe], 2);
|
||
DBG(DBG_FNC, "0x00fe");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.normalscan step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x100], 2);
|
||
DBG(DBG_FNC, "0x0100");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to accurve.parkhome step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x102], 2);
|
||
DBG(DBG_FNC, "0x0102");
|
||
DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.parkhome step table\n", iValue & 0x3fff);
|
||
DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0104 Motor resource", &buffer[0x104], 0x20, 0x104);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0124", &buffer[0x124], 0x22, 0x124);
|
||
|
||
iValue = data_lsb_get(&buffer[0x146], 1);
|
||
DBG(DBG_FNC, "\n0x0146");
|
||
DBG(DBG_FNC, " bit[0..3] = Lamp pulse-width modulation frequency : 0x%02x\n", iValue & 0xf);
|
||
DBG(DBG_FNC, " bit[4] = timer enabled? : 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5] = ? : 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[6] = lamp turned on? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = sensor type : 0x%02x ", (iValue >> 7) & 1);
|
||
if (((iValue >> 7) & 1) != 0)
|
||
DBG(DBG_FNC, "CCD\n");
|
||
else DBG(DBG_FNC, "CIS\n");
|
||
|
||
iValue = data_lsb_get(&buffer[0x147], 1);
|
||
DBG(DBG_FNC, "\n0x0147");
|
||
DBG(DBG_FNC, " time to turn off lamp = 0x%02x (minutes * 2.682163611980331)\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x148], 1);
|
||
DBG(DBG_FNC, "\n0x0148");
|
||
DBG(DBG_FNC, " bit[0..5] = Lamp pulse-width modulation duty cycle : 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ? : 0x%02x\n",(iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x149], 1);
|
||
DBG(DBG_FNC, "\n0x0149");
|
||
DBG(DBG_FNC, " bit[0..5] = even_odd_distance : 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ? : 0x%02x\n",(iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x14a], 1);
|
||
DBG(DBG_FNC, "0x014a");
|
||
DBG(DBG_FNC, " bit[0..5] = sensor line distance : 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n",(iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x14b], 1);
|
||
DBG(DBG_FNC, "0x014b");
|
||
DBG(DBG_FNC, " bit[0..5] = sensor line distance + even_odd_distance: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n",(iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x14c], 1);
|
||
DBG(DBG_FNC, "0x014c");
|
||
DBG(DBG_FNC, " bit[0..5] = sensor line distance * 2: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x14d], 1);
|
||
DBG(DBG_FNC, "0x014d");
|
||
DBG(DBG_FNC, " bit[0..5] = (sensor line distance * 2) + even_odd_distance: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x14e], 1);
|
||
DBG(DBG_FNC, "\n0x014e");
|
||
DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0xf);
|
||
DBG(DBG_FNC, " bit[4] = ?: 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x014f", &buffer[0x14f], 0x05, 0x14f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x154], 1);
|
||
DBG(DBG_FNC, "\n0x0154");
|
||
DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0xf);
|
||
DBG(DBG_FNC, " bit[4..5] = ?: 0x%02x\n", (iValue >> 4) & 3);
|
||
DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 7);
|
||
|
||
iValue = data_lsb_get(&buffer[0x155], 1);
|
||
DBG(DBG_FNC, "\n0x0155");
|
||
DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0x0f);
|
||
DBG(DBG_FNC, " bit[4] = 0x%02x : ", (iValue >> 4) & 1);
|
||
if (((iValue >> 4) & 1) == 0)
|
||
DBG(DBG_FNC, "flb lamp\n");
|
||
else DBG(DBG_FNC, "tma lamp\n");
|
||
DBG(DBG_FNC, " bit[5..7] = ? : 0x%02x\n", (iValue >> 5) & 7);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0156", &buffer[0x156], 0x02, 0x156);
|
||
|
||
iValue = data_lsb_get(&buffer[0x158], 1);
|
||
DBG(DBG_FNC, "\n0x0158");
|
||
DBG(DBG_FNC, " bit[0..3] = %02x : Scanner buttons ", iValue & 0x0f);
|
||
if ((iValue & 0x0f) == 0x0f)
|
||
DBG(DBG_FNC, "enabled\n");
|
||
else DBG(DBG_FNC, "dissabled\n");
|
||
DBG(DBG_FNC, " bit[4..7] = ? : 0x%02x\n", (iValue >> 4) & 0x0f);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0159", &buffer[0x159], 11, 0x159);
|
||
|
||
iValue = data_lsb_get(&buffer[0x164], 1);
|
||
DBG(DBG_FNC, "\n0x0164");
|
||
DBG(DBG_FNC, " bit[0..6] = ?: 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0165", &buffer[0x165], 3, 0x165);
|
||
|
||
iValue = data_lsb_get(&buffer[0x168], 1);
|
||
DBG(DBG_FNC, "\n0x0168 Buttons status : 0x%02x\n", iValue);
|
||
DBG(DBG_FNC, " bit[0] = button 1 : 0x%02x\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = button 2 : 0x%02x\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2] = button 4 : 0x%02x\n", (iValue >> 2) & 1);
|
||
DBG(DBG_FNC, " bit[3] = button 3 : 0x%02x\n", (iValue >> 3) & 1);
|
||
DBG(DBG_FNC, " bit[4] = button ? : 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5] = button ? : 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x169], 1);
|
||
DBG(DBG_FNC, "\n0x0169", iValue);
|
||
DBG(DBG_FNC, " bit[0] = ? : 0x%02x\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = tma attached? : 0x%02x\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2..7] = ? : 0x%02x\n", (iValue >> 2) & 0x3f);
|
||
|
||
iValue = data_lsb_get(&buffer[0x16a], 1);
|
||
DBG(DBG_FNC, "\n0x016a Buttons status 2: 0x%02x\n", iValue);
|
||
DBG(DBG_FNC, " bit[0] = button 1 : 0x%02x\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = button 2 : 0x%02x\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2] = button 4 : 0x%02x\n", (iValue >> 2) & 1);
|
||
DBG(DBG_FNC, " bit[3] = button 3 : 0x%02x\n", (iValue >> 3) & 1);
|
||
DBG(DBG_FNC, " bit[4] = button ? : 0x%02x\n", (iValue >> 4) & 1);
|
||
DBG(DBG_FNC, " bit[5] = button ? : 0x%02x\n", (iValue >> 5) & 1);
|
||
DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x016b", &buffer[0x16b], 4, 0x16b);
|
||
|
||
iValue = data_lsb_get(&buffer[0x16f], 1);
|
||
DBG(DBG_FNC, "\n0x016f");
|
||
DBG(DBG_FNC, " bit[0..5] = ? : 0x%02x\n", iValue & 0x3f);
|
||
DBG(DBG_FNC, " bit[6] = is lamp at home? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = ?: %02x\n", (iValue >> 7) & 1);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0170", &buffer[0x170], 0x17, 0x170);
|
||
|
||
iValue = data_lsb_get(&buffer[0x187], 1);
|
||
DBG(DBG_FNC, "\n0x0187");
|
||
DBG(DBG_FNC, " bit[0..3] = ? : 0x%02x\n", iValue & 0xf);
|
||
DBG(DBG_FNC, " bit[4..7] = mclkioc : 0x%02x\n", (iValue >> 4) & 0xf);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x0188", &buffer[0x188], 0x16, 0x188);
|
||
|
||
iValue = data_lsb_get(&buffer[0x19e], 2);
|
||
DBG(DBG_FNC, "\n0x019e");
|
||
DBG(DBG_FNC, " binary threshold low : 0x%04x\n", (iValue >> 8) + ((iValue << 8) & 0xff00));
|
||
|
||
iValue = data_lsb_get(&buffer[0x1a0], 2);
|
||
DBG(DBG_FNC, "\n0x01a0");
|
||
DBG(DBG_FNC, " binary threshold high : 0x%04x\n", (iValue >> 8) + ((iValue << 8) & 0xff00));
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x01a2", &buffer[0x1a2], 0x12, 0x1a2);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1b4], 2);
|
||
DBG(DBG_FNC, "\n0x01b4");
|
||
DBG(DBG_FNC, " bit[00..13] = Ptr to red gamma table (table_size * 0) : 0x%04x\n", (iValue & 0x3fff));
|
||
DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1b6], 2);
|
||
DBG(DBG_FNC, "0x01b6");
|
||
DBG(DBG_FNC, " bit[00..13] = Ptr to green gamma table (table_size * 1) : 0x%04x\n", (iValue & 0x3fff));
|
||
DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1b8], 2);
|
||
DBG(DBG_FNC, "0x01b8");
|
||
DBG(DBG_FNC, " bit[00..13] = Ptr to blue gamma table (table_size * 2) : 0x%04x\n", (iValue & 0x3fff));
|
||
DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1ba], 1);
|
||
DBG(DBG_FNC, "\n0x01ba");
|
||
DBG(DBG_FNC, " ? : 0x%02x\n", iValue);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1bb], 2);
|
||
DBG(DBG_FNC, "0x01bb");
|
||
DBG(DBG_FNC, " ? : 0x%04x\n", iValue + ((data_lsb_get(&buffer[0x1bf], 1) & 1) << 16));
|
||
|
||
iValue = data_lsb_get(&buffer[0x1bd], 2);
|
||
DBG(DBG_FNC, "0x01bd");
|
||
DBG(DBG_FNC, " ? : 0x%04x\n", iValue + (((data_lsb_get(&buffer[0x1bf], 1) >> 1) & 3) << 16));
|
||
|
||
iValue = data_lsb_get(&buffer[0x1c0], 3);
|
||
DBG(DBG_FNC, "0x01c0");
|
||
DBG(DBG_FNC, " bit[0..19] = ? : 0x%06x\n", iValue & 0xfffff);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1bf], 2);
|
||
DBG(DBG_FNC, "\n0x01bf");
|
||
DBG(DBG_FNC, " bit[3..4] = ? : 0x%02x\n", (iValue >> 3) & 3);
|
||
DBG(DBG_FNC, " bit[5..7] = ? : 0x%02x\n", (iValue >> 5) & 7);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1c2], 3);
|
||
DBG(DBG_FNC, "\n0x01c2");
|
||
DBG(DBG_FNC, " bit[4..23] = ? : 0x%06x\n", ((iValue >> 8) & 0xffff) + (((iValue >> 4) & 0xf) << 16));
|
||
|
||
iValue = data_lsb_get(&buffer[0x1c5], 3);
|
||
DBG(DBG_FNC, "0x01c5");
|
||
DBG(DBG_FNC, " bit[00..19] = ? : 0x%06x\n", iValue & 0xfffff);
|
||
DBG(DBG_FNC, " bit[20..23] = ? : 0x%02x\n", (iValue >> 20) & 0xf);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x01c8", &buffer[0x1c8], 7, 0x1c8);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1cf], 3);
|
||
DBG(DBG_FNC, "\n0x01cf");
|
||
DBG(DBG_FNC, " bit[0] = ? : 0x%02x\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = shading base (0 = 0x4000|1= 0x2000) : 0x%02x\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2] = white shading correction : 0x%02x\n", (iValue >> 2) & 1);
|
||
DBG(DBG_FNC, " bit[3] = black shading correction : 0x%02x\n", (iValue >> 3) & 1);
|
||
DBG(DBG_FNC, " bit[4..5] = 0x%02x : ", (iValue >> 4) & 3);
|
||
switch ((iValue >> 4) & 3)
|
||
{
|
||
case 0: DBG(DBG_FNC, "8 bits per channel"); break;
|
||
case 1: DBG(DBG_FNC, "12 bits per channel"); break;
|
||
case 2: DBG(DBG_FNC, "16 bits per channel"); break;
|
||
case 3: DBG(DBG_FNC, "lineart mode"); break;
|
||
}
|
||
DBG(DBG_FNC, "\n");
|
||
DBG(DBG_FNC, " bit[6] = samplerate: 0x%02x ", (iValue >> 6) & 1);
|
||
if (((iValue >> 6) & 1) == PIXEL_RATE)
|
||
DBG(DBG_FNC, "PIXEL_RATE\n");
|
||
else DBG(DBG_FNC, "LINE_RATE\n");
|
||
DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
iValue = data_lsb_get(&buffer[0x1d0], 1);
|
||
DBG(DBG_FNC, "\n0x01d0");
|
||
DBG(DBG_FNC, " bit[0] = 0x%02x\n", iValue & 1);
|
||
DBG(DBG_FNC, " bit[1] = 0x%02x\n", (iValue >> 1) & 1);
|
||
DBG(DBG_FNC, " bit[2..3] = gamma table size : 0x%02x ", (iValue >> 2) & 3);
|
||
switch ((iValue >> 2) & 3)
|
||
{
|
||
case 0: DBG(DBG_FNC, "bit[0] + 0x100") ;break;
|
||
case 1: DBG(DBG_FNC, "bit[0] + 0x400") ;break;
|
||
case 2: DBG(DBG_FNC, "bit[0] + 0x1000") ;break;
|
||
}
|
||
DBG(DBG_FNC, "\n");
|
||
DBG(DBG_FNC, " bit[4..5] = ? : 0x%02x\n", (iValue >> 4) & 3);
|
||
DBG(DBG_FNC, " bit[6] = use gamma tables? : 0x%02x\n", (iValue >> 6) & 1);
|
||
DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
|
||
|
||
dbg_buffer(DBG_FNC, "\n0x01d1", &buffer[0x1d1], 0x430, 0x1d1);
|
||
|
||
DBG(DBG_FNC, "----------------------------------------------------\n\n");
|
||
*/
|
||
/*exit(0); */
|
||
}
|
||
#endif
|