1 /* HP Scanjet 3900 series - Debugging functions for standalone
2
3 Copyright (C) 2005-2008 Jonathan Bravo Lopez <jkdsoft@gmail.com>
4
5 This file is part of the SANE package.
6
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License
9 as published by the Free Software Foundation; either version 2
10 of the License, or (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <https://www.gnu.org/licenses/>.
19
20 As a special exception, the authors of SANE give permission for
21 additional uses of the libraries contained in this release of SANE.
22
23 The exception is that, if you link a SANE library with other files
24 to produce an executable, this does not by itself cause the
25 resulting executable to be covered by the GNU General Public
26 License. Your use of that executable is in no way restricted on
27 account of linking the SANE library code into it.
28
29 This exception does not, however, invalidate any other reasons why
30 the executable file might be covered by the GNU General Public
31 License.
32
33 If you submit changes to SANE to the maintainers to be included in
34 a subsequent release, you agree by submitting the changes that
35 those changes may be distributed with this exception intact.
36
37 If you write modifications of your own for SANE, it is your choice
38 whether to permit this exception to apply to your modifications.
39 If you do not wish that, delete this exception notice.
40 */
41
42 /* debugging level messages */
43 #define DBG_ERR 0x00 /* Only important errors */
44 #define DBG_VRB 0x01 /* verbose messages */
45 #define DBG_FNC 0x02 /* Function names and parameters */
46 #define DBG_CTL 0x03 /* USB Ctl data */
47 #define DBG_BLK 0x04 /* USB Bulk data */
48
49 #include <stdarg.h>
50 #ifdef HAVE_TIFFIO_H
51 #include <tiffio.h> /* dbg_tiff_save */
52 #endif
53
54 /* headers */
55
56 static void dump_shading (struct st_calibration *myCalib);
57 static char *dbg_scantype (SANE_Int type);
58 static void dbg_scanmodes (struct st_device *dev);
59 static void dbg_motorcurves (struct st_device *dev);
60 static void dbg_motormoves (struct st_device *dev);
61 static void dbg_hwdcfg (struct st_hwdconfig *params);
62 static void dbg_ScanParams (struct st_scanparams *params);
63 static void dbg_calibtable (struct st_gain_offset *params);
64 static char *dbg_colour (SANE_Int colour);
65 static void dbg_motorcfg (struct st_motorcfg *motorcfg);
66 static void dbg_buttons (struct st_buttons *buttons);
67 static void dbg_sensor (struct st_sensorcfg *sensor);
68 static void dbg_timing (struct st_timing *mt);
69 static void dbg_sensorclock (struct st_cph *cph);
70 static void dbg_tiff_save (char *sFile, SANE_Int width, SANE_Int height,
71 SANE_Int depth, SANE_Int colortype, SANE_Int res_x,
72 SANE_Int res_y, SANE_Byte * buffer, SANE_Int size);
73 static void dbg_autoref (struct st_scanparams *scancfg, SANE_Byte * pattern,
74 SANE_Int ser1, SANE_Int ser2, SANE_Int ler);
75
76 #ifdef developing
77 static void dbg_buffer (SANE_Int level, char *title, SANE_Byte * buffer,
78 SANE_Int size, SANE_Int start);
79 static void dbg_registers (SANE_Byte * buffer);
80 #endif
81
82 #ifdef STANDALONE
83
84 /* implementation */
85
86 int DBG_LEVEL = 0;
87
88 static void
DBG(int level,const char * msg,...)89 DBG (int level, const char *msg, ...)
90 {
91 va_list ap;
92 va_start (ap, msg);
93
94 if (level <= DBG_LEVEL)
95 vfprintf (stderr, msg, ap);
96
97 va_end (ap);
98 }
99
100 #endif
101
102 /* debugging functions */
103
104 static void
dump_shading(struct st_calibration * myCalib)105 dump_shading (struct st_calibration *myCalib)
106 {
107 if (myCalib != NULL)
108 {
109 SANE_Int colour, a;
110 FILE *shadingfile[3];
111
112 shadingfile[0] = fopen ("RShading.txt", "w");
113 shadingfile[1] = fopen ("GShading.txt", "w");
114 shadingfile[2] = fopen ("BShading.txt", "w");
115
116 for (colour = 0; colour < 3; colour++)
117 {
118 if (shadingfile[colour] != NULL)
119 {
120 for (a = 0; a < myCalib->shadinglength; a++)
121 fprintf (shadingfile[colour], "%04i: %04x %04x\n", a,
122 (unsigned int) myCalib->white_shading[colour][a],
123 (unsigned int) myCalib->black_shading[colour][a]);
124 fclose (shadingfile[colour]);
125 }
126 }
127 }
128 }
129
130 static char *
dbg_scantype(SANE_Int type)131 dbg_scantype (SANE_Int type)
132 {
133 switch (type)
134 {
135 case ST_NORMAL:
136 return "ST_NORMAL";
137 break;
138 case ST_TA:
139 return "ST_TA";
140 break;
141 case ST_NEG:
142 return "ST_NEG";
143 break;
144 default:
145 return "Unknown";
146 break;
147 }
148 }
149
150 static void
dbg_sensorclock(struct st_cph * cph)151 dbg_sensorclock (struct st_cph *cph)
152 {
153 if (cph != NULL)
154 {
155 DBG (DBG_FNC, " -> cph->p1 = %f\n", cph->p1);
156 DBG (DBG_FNC, " -> cph->p2 = %f\n", cph->p2);
157 DBG (DBG_FNC, " -> cph->ps = %i\n", cph->ps);
158 DBG (DBG_FNC, " -> cph->ge = %i\n", cph->ge);
159 DBG (DBG_FNC, " -> cph->go = %i\n", cph->go);
160 }
161 else
162 DBG (DBG_FNC, " -> cph is NULL\n");
163 }
164
165 static void
dbg_timing(struct st_timing * mt)166 dbg_timing (struct st_timing *mt)
167 {
168 if (mt != NULL)
169 {
170 DBG (DBG_FNC, " -> mt->cdss[0] = %i\n", _B0 (mt->cdss[0]));
171 DBG (DBG_FNC, " -> mt->cdsc[0] = %i\n", _B0 (mt->cdsc[0]));
172 DBG (DBG_FNC, " -> mt->cdss[1] = %i\n", _B0 (mt->cdss[1]));
173 DBG (DBG_FNC, " -> mt->cdsc[1] = %i\n", _B0 (mt->cdsc[1]));
174 DBG (DBG_FNC, " -> mt->cnpp = %i\n", _B0 (mt->cnpp));
175 DBG (DBG_FNC, " -> mt->cvtrp0 = %i\n", _B0 (mt->cvtrp[0]));
176 DBG (DBG_FNC, " -> mt->cvtrp1 = %i\n", _B0 (mt->cvtrp[1]));
177 DBG (DBG_FNC, " -> mt->cvtrp2 = %i\n", _B0 (mt->cvtrp[2]));
178 DBG (DBG_FNC, " -> mt->cvtrfpw = %i\n", _B0 (mt->cvtrfpw));
179 DBG (DBG_FNC, " -> mt->cvtrbpw = %i\n", _B0 (mt->cvtrbpw));
180 DBG (DBG_FNC, " -> mt->cvtrw = %i\n", _B0 (mt->cvtrw));
181 DBG (DBG_FNC, " -> mt->clamps = 0x%08x\n", mt->clamps);
182 DBG (DBG_FNC, " -> mt->clampe = 0x%08x\n", mt->clampe);
183 DBG (DBG_FNC, " -> mt->adcclkp0 = %f\n", mt->adcclkp[0]);
184 DBG (DBG_FNC, " -> mt->adcclkp1 = %f\n", mt->adcclkp[1]);
185 DBG (DBG_FNC, " -> mt->adcclkp2e = %i\n", mt->adcclkp2e);
186 DBG (DBG_FNC, " -> mt->cphbp2s = %i\n", mt->cphbp2s);
187 DBG (DBG_FNC, " -> mt->cphbp2e = %i\n", mt->cphbp2e);
188 }
189 else
190 DBG (DBG_FNC, " -> mt is NULL\n");
191 }
192
193 static void
dbg_sensor(struct st_sensorcfg * sensor)194 dbg_sensor (struct st_sensorcfg *sensor)
195 {
196 if (sensor != NULL)
197 {
198 DBG (DBG_FNC,
199 " -> type, name, res , {chn_color }, {chn_gray}, {rgb_order }, line_dist, evnodd_dist\n");
200 DBG (DBG_FNC,
201 " -> ----, ----, --- , {--, --, --}, {--, -- }, {--, --, --}, ---------, -----------\n");
202 DBG (DBG_FNC,
203 " -> %4i, %4i, %4i, {%2i, %2i, %2i}, {%2i, %2i }, {%2i, %2i, %2i}, %9i, %11i\n",
204 sensor->type, sensor->name, sensor->resolution,
205 sensor->channel_color[0], sensor->channel_color[1],
206 sensor->channel_color[2], sensor->channel_gray[0],
207 sensor->channel_gray[1], sensor->rgb_order[0],
208 sensor->rgb_order[1], sensor->rgb_order[2], sensor->line_distance,
209 sensor->evenodd_distance);
210 }
211 else
212 DBG (DBG_FNC, " -> sensor is NULL\n");
213 }
214
215 static void
dbg_buttons(struct st_buttons * buttons)216 dbg_buttons (struct st_buttons *buttons)
217 {
218 if (buttons != NULL)
219 {
220 DBG (DBG_FNC, " -> count, btn1, btn2, btn3, btn4, btn5, btn6\n");
221 DBG (DBG_FNC, " -> -----, ----, ----, ----, ----, ----, ----\n");
222 DBG (DBG_FNC, " -> %5i, %4i, %4i, %4i, %4i, %4i, %4i\n",
223 buttons->count, buttons->mask[0], buttons->mask[1],
224 buttons->mask[2], buttons->mask[3], buttons->mask[4],
225 buttons->mask[5]);
226 }
227 else
228 DBG (DBG_FNC, " -> buttons is NULL\n");
229 }
230
231 static void
dbg_scanmodes(struct st_device * dev)232 dbg_scanmodes (struct st_device *dev)
233 {
234 if (dev->scanmodes_count > 0)
235 {
236 SANE_Int a;
237 struct st_scanmode *reg;
238
239 DBG (DBG_FNC,
240 " -> ##, 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");
241 DBG (DBG_FNC,
242 " -> --, ---------, ----------, --- , --, --, --, ---, ------, ----, ---, ---, {------ ------ ------}, {------ ------ ------}, ---, ------, -----, ----, ---, ---, -----, ------, --\n");
243 for (a = 0; a < dev->scanmodes_count; a++)
244 {
245 reg = dev->scanmodes[a];
246 if (reg != NULL)
247 {
248 DBG (DBG_FNC,
249 " -> %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",
250 a, dbg_scantype (reg->scantype),
251 dbg_colour (reg->colormode), reg->resolution, reg->timing,
252 reg->motorcurve, reg->samplerate, reg->systemclock,
253 reg->ctpc, reg->motorbackstep, reg->scanmotorsteptype,
254 reg->dummyline, reg->expt[0], reg->expt[1], reg->expt[2],
255 reg->mexpt[0], reg->mexpt[1], reg->mexpt[2],
256 reg->motorplus, reg->multiexposurefor16bitmode,
257 reg->multiexposureforfullspeed, reg->multiexposure,
258 reg->mri, reg->msi, reg->mmtir, reg->mmtirh,
259 reg->skiplinecount);
260 }
261 }
262 }
263 }
264
265 static void
dbg_motorcurves(struct st_device * dev)266 dbg_motorcurves (struct st_device *dev)
267 {
268 if (dev->mtrsetting != NULL)
269 {
270 struct st_motorcurve *mtc;
271 SANE_Int a = 0;
272
273 while (a < dev->mtrsetting_count)
274 {
275 DBG (DBG_FNC, " -> Motorcurve %2i: ", a);
276 mtc = dev->mtrsetting[a];
277 if (mtc != NULL)
278 {
279 DBG (DBG_FNC, "mri=%i msi=%i skip=%i bckstp=%i\n", mtc->mri,
280 mtc->msi, mtc->skiplinecount, mtc->motorbackstep);
281 if (mtc->curve_count > 0)
282 {
283 char *sdata = (char *) malloc (256);
284 if (sdata != NULL)
285 {
286 char *sline = (char *) malloc (256);
287 if (sline != NULL)
288 {
289 SANE_Int count;
290 struct st_curve *crv;
291
292 DBG (DBG_FNC,
293 " -> ##, dir, type , count, from, to , steps\n");
294 DBG (DBG_FNC,
295 " -> --, ---, ----------, -----, ----, ----, -----\n");
296
297 count = 0;
298 while (count < mtc->curve_count)
299 {
300 memset (sline, 0, 256);
301
302 snprintf (sdata, 256, " -> %02i, ", count);
303 strcat (sline, sdata);
304
305 crv = mtc->curve[count];
306 if (crv != NULL)
307 {
308 if (crv->crv_speed == ACC_CURVE)
309 strcat (sline, "ACC, ");
310 else
311 strcat (sline, "DEC, ");
312
313 switch (crv->crv_type)
314 {
315 case CRV_NORMALSCAN:
316 strcat (sline, "NORMALSCAN, ");
317 break;
318 case CRV_PARKHOME:
319 strcat (sline, "PARKHOME , ");
320 break;
321 case CRV_SMEARING:
322 strcat (sline, "SMEARING , ");
323 break;
324 case CRV_BUFFERFULL:
325 strcat (sline, "BUFFERFULL, ");
326 break;
327 default:
328 snprintf (sdata, 256, "unknown %2i, ",
329 crv->crv_type);
330 strcat (sline, sdata);
331 break;
332 }
333
334 snprintf (sdata, 256, "%5i, ",
335 crv->step_count);
336 strcat (sline, sdata);
337 if (crv->step_count > 0)
338 {
339 SANE_Int stpcount = 0;
340
341 snprintf (sdata, 256, "%4i, %4i| ",
342 crv->step[0],
343 crv->step[crv->step_count -
344 1]);
345 strcat (sline, sdata);
346
347 while (stpcount < crv->step_count)
348 {
349 if (stpcount == 10)
350 {
351 strcat (sline, "...");
352 break;
353 }
354 if (stpcount > 0)
355 strcat (sline, ", ");
356
357 snprintf (sdata, 256, "%4i",
358 crv->step[stpcount]);
359 strcat (sline, sdata);
360
361 stpcount++;
362 }
363 strcat (sline, "\n");
364 }
365 else
366 strcat (sline, "NONE\n");
367 }
368 else
369 strcat (sline, "NULL ...\n");
370
371 DBG (DBG_FNC, "%s", sline);
372
373 count++;
374 }
375
376 free (sline);
377 }
378 free (sdata);
379 }
380 }
381 }
382 else
383 DBG (DBG_FNC, "NULL\n");
384 a++;
385 }
386 }
387 }
388
389 static void
dbg_motormoves(struct st_device * dev)390 dbg_motormoves (struct st_device *dev)
391 {
392 if (dev->motormove_count > 0)
393 {
394 SANE_Int a;
395 struct st_motormove *reg;
396
397 DBG (DBG_FNC, " -> ##, CLK, CTPC, STT, CV\n");
398 DBG (DBG_FNC, " -> --, ---, ----, ---, --\n");
399 for (a = 0; a < dev->motormove_count; a++)
400 {
401 reg = dev->motormove[a];
402 if (reg != NULL)
403 {
404 DBG (DBG_FNC, " -> %2i, %3i, %4i, %3i, %2i\n",
405 a, reg->systemclock, reg->ctpc,
406 reg->scanmotorsteptype, reg->motorcurve);
407 }
408 }
409 }
410 }
411
412 static void
dbg_hwdcfg(struct st_hwdconfig * params)413 dbg_hwdcfg (struct st_hwdconfig *params)
414 {
415 if (params != NULL)
416 {
417 DBG (DBG_FNC, " -> Low level config:\n");
418 DBG (DBG_FNC, " -> startpos = %i\n", params->startpos);
419 DBG (DBG_FNC, " -> arrangeline = %s\n",
420 (params->arrangeline ==
421 FIX_BY_SOFT) ? "FIX_BY_SOFT" : (params->arrangeline ==
422 FIX_BY_HARD) ? "FIX_BY_HARD" :
423 "FIX_BY_NONE");
424 DBG (DBG_FNC, " -> scantype = %s\n",
425 dbg_scantype (params->scantype));
426 DBG (DBG_FNC, " -> compression = %i\n", params->compression);
427 DBG (DBG_FNC, " -> use_gamma_tables = %i\n",
428 params->use_gamma_tables);
429 DBG (DBG_FNC, " -> gamma_tablesize = %i\n",
430 params->gamma_tablesize);
431 DBG (DBG_FNC, " -> white_shading = %i\n",
432 params->white_shading);
433 DBG (DBG_FNC, " -> black_shading = %i\n",
434 params->black_shading);
435 DBG (DBG_FNC, " -> unk3 = %i\n", params->unk3);
436 DBG (DBG_FNC, " -> motorplus = %i\n", params->motorplus);
437 DBG (DBG_FNC, " -> static_head = %i\n", params->static_head);
438 DBG (DBG_FNC, " -> motor_direction = %s\n",
439 (params->motor_direction == MTR_FORWARD) ? "FORWARD" : "BACKWARD");
440 DBG (DBG_FNC, " -> dummy_scan = %i\n", params->dummy_scan);
441 DBG (DBG_FNC, " -> highresolution = %i\n",
442 params->highresolution);
443 DBG (DBG_FNC, " -> sensorevenodddistance = %i\n",
444 params->sensorevenodddistance);
445 DBG (DBG_FNC, " -> calibrate = %i\n", params->calibrate);
446 }
447 }
448
449 static void
dbg_ScanParams(struct st_scanparams * params)450 dbg_ScanParams (struct st_scanparams *params)
451 {
452 if (params != NULL)
453 {
454 DBG (DBG_FNC, " -> Scan params:\n");
455 DBG (DBG_FNC, " -> colormode = %s\n",
456 dbg_colour (params->colormode));
457 DBG (DBG_FNC, " -> depth = %i\n", params->depth);
458 DBG (DBG_FNC, " -> samplerate = %i\n", params->samplerate);
459 DBG (DBG_FNC, " -> timing = %i\n", params->timing);
460 DBG (DBG_FNC, " -> channel = %i\n", params->channel);
461 DBG (DBG_FNC, " -> sensorresolution = %i\n", params->sensorresolution);
462 DBG (DBG_FNC, " -> resolution_x = %i\n", params->resolution_x);
463 DBG (DBG_FNC, " -> resolution_y = %i\n", params->resolution_y);
464 DBG (DBG_FNC, " -> left = %i\n", params->coord.left);
465 DBG (DBG_FNC, " -> width = %i\n", params->coord.width);
466 DBG (DBG_FNC, " -> top = %i\n", params->coord.top);
467 DBG (DBG_FNC, " -> height = %i\n", params->coord.height);
468 DBG (DBG_FNC, " -> shadinglength = %i\n", params->shadinglength);
469 DBG (DBG_FNC, " -> v157c = %i\n", params->v157c);
470 DBG (DBG_FNC, " -> bytesperline = %i\n", params->bytesperline);
471 DBG (DBG_FNC, " -> expt = %i\n", params->expt);
472 DBG (DBG_FNC, " *> startpos = %i\n", params->startpos);
473 DBG (DBG_FNC, " *> leftleading = %i\n", params->leftleading);
474 DBG (DBG_FNC, " *> ser = %i\n", params->ser);
475 DBG (DBG_FNC, " *> ler = %i\n", params->ler);
476 DBG (DBG_FNC, " *> scantype = %s\n",
477 dbg_scantype (params->scantype));
478 }
479 }
480
481 static void
dbg_calibtable(struct st_gain_offset * params)482 dbg_calibtable (struct st_gain_offset *params)
483 {
484 if (params != NULL)
485 {
486 DBG (DBG_FNC, " -> Calib table:\n");
487 DBG (DBG_FNC, " -> type R G B\n");
488 DBG (DBG_FNC, " -> ----- --- --- ---B\n");
489 DBG (DBG_FNC, " -> edcg1 = %3i , %3i , %3i\n", params->edcg1[0],
490 params->edcg1[1], params->edcg1[2]);
491 DBG (DBG_FNC, " -> edcg2 = %3i , %3i , %3i\n", params->edcg2[0],
492 params->edcg2[1], params->edcg2[2]);
493 DBG (DBG_FNC, " -> odcg1 = %3i , %3i , %3i\n", params->odcg1[0],
494 params->odcg1[1], params->odcg1[2]);
495 DBG (DBG_FNC, " -> odcg2 = %3i , %3i , %3i\n", params->odcg2[0],
496 params->odcg2[1], params->odcg2[2]);
497 DBG (DBG_FNC, " -> pag = %3i , %3i , %3i\n", params->pag[0],
498 params->pag[1], params->pag[2]);
499 DBG (DBG_FNC, " -> vgag1 = %3i , %3i , %3i\n", params->vgag1[0],
500 params->vgag1[1], params->vgag1[2]);
501 DBG (DBG_FNC, " -> vgag2 = %3i , %3i , %3i\n", params->vgag2[0],
502 params->vgag2[1], params->vgag2[2]);
503 }
504 }
505
506 static char *
dbg_colour(SANE_Int colour)507 dbg_colour (SANE_Int colour)
508 {
509 switch (colour)
510 {
511 case CM_COLOR:
512 return "CM_COLOR";
513 break;
514 case CM_GRAY:
515 return "CM_GRAY";
516 break;
517 case CM_LINEART:
518 return "CM_LINEART";
519 break;
520 default:
521 return "Unknown";
522 break;
523 }
524 }
525
526 static void
dbg_motorcfg(struct st_motorcfg * motorcfg)527 dbg_motorcfg (struct st_motorcfg *motorcfg)
528 {
529 if (motorcfg != NULL)
530 {
531 DBG (DBG_FNC,
532 " -> type, res , freq, speed, base, high, park, change\n");
533 DBG (DBG_FNC,
534 " -> ----, --- , ----, -----, ----, ----, ----, ------\n");
535 DBG (DBG_FNC, " -> %4i, %4i, %4i, %5i, %4i, %4i, %4i, %6i\n",
536 motorcfg->type, motorcfg->resolution, motorcfg->pwmfrequency,
537 motorcfg->basespeedpps, motorcfg->basespeedmotormove,
538 motorcfg->highspeedmotormove, motorcfg->parkhomemotormove,
539 motorcfg->changemotorcurrent);
540 }
541 }
542
543 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)544 dbg_tiff_save (char *sFile, SANE_Int width, SANE_Int height, SANE_Int depth,
545 SANE_Int colortype, SANE_Int res_x, SANE_Int res_y,
546 SANE_Byte * buffer, SANE_Int size)
547 {
548 #ifdef HAVE_TIFFIO_H
549 if (buffer != NULL)
550 {
551 char *path = getenv ("HOME");
552
553 if (path != NULL)
554 {
555 char filename[512];
556 TIFF *image;
557
558 if (snprintf (filename, 512, "%s/%s", path, sFile) > 0)
559 {
560 /* Open the TIFF file */
561 if ((image = TIFFOpen (filename, "w")) != NULL)
562 {
563 char desc[256];
564
565 SANE_Int spp = (colortype == CM_GRAY) ? 1 : 3;
566 SANE_Int ct =
567 (colortype ==
568 CM_GRAY) ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB;
569
570 snprintf (desc, 256, "Created with hp3900 %s",
571 BACKEND_VRSN);
572
573 /* We need to set some values for basic tags before we can add any data */
574 TIFFSetField (image, TIFFTAG_IMAGEWIDTH, width);
575 TIFFSetField (image, TIFFTAG_IMAGELENGTH, height);
576 TIFFSetField (image, TIFFTAG_BITSPERSAMPLE, depth);
577 TIFFSetField (image, TIFFTAG_SAMPLESPERPIXEL, spp);
578
579 TIFFSetField (image, TIFFTAG_PHOTOMETRIC, ct);
580 TIFFSetField (image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
581 TIFFSetField (image, TIFFTAG_PLANARCONFIG,
582 PLANARCONFIG_CONTIG);
583
584 TIFFSetField (image, TIFFTAG_XRESOLUTION, (double) res_x);
585 TIFFSetField (image, TIFFTAG_YRESOLUTION, (double) res_y);
586 TIFFSetField (image, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
587 TIFFSetField (image, TIFFTAG_IMAGEDESCRIPTION, desc);
588
589 /* Write the information to the file */
590 TIFFWriteRawStrip (image, 0, buffer, size);
591 TIFFClose (image);
592 }
593 }
594 else
595 DBG (DBG_ERR, "- dbg_tiff_save: Error generating filename\n");
596 }
597 else
598 DBG (DBG_ERR,
599 "- dbg_tiff_save: Environment HOME variable does not exist\n");
600 }
601 #else
602 /* silent gcc */
603 sFile = sFile;
604 width = width;
605 height = height;
606 depth = depth;
607 colortype = colortype;
608 res_x = res_x;
609 res_y = res_y;
610 buffer = buffer;
611 size = size;
612
613 DBG (DBG_ERR, "- dbg_tiff_save: tiffio not supported\n");
614 #endif
615 }
616
617 static void
dbg_autoref(struct st_scanparams * scancfg,SANE_Byte * pattern,SANE_Int ser1,SANE_Int ser2,SANE_Int ler)618 dbg_autoref (struct st_scanparams *scancfg, SANE_Byte * pattern,
619 SANE_Int ser1, SANE_Int ser2, SANE_Int ler)
620 {
621 /* this function generates post-autoref.tiff */
622 SANE_Byte *img =
623 malloc (sizeof (SANE_Byte) *
624 (scancfg->coord.width * scancfg->coord.height * 3));
625
626 if (img != NULL)
627 {
628 SANE_Int c, value;
629
630 /* generate image from 1 gray channel to 3 color channels */
631 for (c = 0; c < (scancfg->coord.width * scancfg->coord.height); c++)
632 {
633 value = *(pattern + c);
634 *(img + (3 * c)) = value;
635 *(img + (3 * c) + 1) = value;
636 *(img + (3 * c) + 2) = value;
637 }
638
639 for (c = 0; c < scancfg->coord.height; c++)
640 {
641 /* line for first SER */
642 if (c < (ler + 5))
643 {
644 *(img + (scancfg->coord.width * c * 3) + (3 * ser1)) = 0;
645 *(img + (scancfg->coord.width * c * 3) + (3 * ser1) + 1) = 255;
646 *(img + (scancfg->coord.width * c * 3) + (3 * ser1) + 2) = 0;
647 }
648
649 /* line for second SER */
650 if (c > (ler - 5))
651 {
652 *(img + (scancfg->coord.width * c * 3) + (3 * ser2)) = 90;
653 *(img + (scancfg->coord.width * c * 3) + (3 * ser2) + 1) = 90;
654 *(img + (scancfg->coord.width * c * 3) + (3 * ser2) + 2) = 255;
655 }
656
657 /* vertical lines of the pointer */
658 if ((c > (ler - 5)) && (c < (ler + 5)))
659 {
660 if ((ser2 - 5) >= 0)
661 {
662 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5))) =
663 255;
664 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5)) +
665 1) = 255;
666 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 - 5)) +
667 2) = 0;
668 }
669
670 if ((ser2 + 5) < scancfg->coord.width)
671 {
672 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5))) =
673 255;
674 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5)) +
675 1) = 255;
676 *(img + (scancfg->coord.width * c * 3) + (3 * (ser2 + 5)) +
677 2) = 0;
678 }
679 }
680 }
681
682 /* line for first LER */
683 for (c = 0; c < scancfg->coord.width; c++)
684 {
685 if ((c > (ser1 - 5)) && (c < (ser2 + 5)))
686 {
687 if (c != (ser2 - 5))
688 {
689 *(img + (scancfg->coord.width * ler * 3) + (3 * c)) = 255;
690 *(img + (scancfg->coord.width * ler * 3) + (3 * c) + 1) =
691 90;
692 *(img + (scancfg->coord.width * ler * 3) + (3 * c) + 2) =
693 90;
694 }
695
696 /* horizontal lines of the pointer */
697 if ((c > (ser2 - 5)) && (c < (ser2 + 5)))
698 {
699 if ((ler - 5) >= 0)
700 {
701 *(img + (scancfg->coord.width * (ler - 5) * 3) +
702 (3 * c)) = 255;
703 *(img + (scancfg->coord.width * (ler - 5) * 3) +
704 (3 * c) + 1) = 255;
705 *(img + (scancfg->coord.width * (ler - 5) * 3) +
706 (3 * c) + 2) = 0;
707 }
708
709 if ((ler + 5) < scancfg->coord.height)
710 {
711 *(img + (scancfg->coord.width * (ler + 5) * 3) +
712 (3 * c)) = 255;
713 *(img + (scancfg->coord.width * (ler + 5) * 3) +
714 (3 * c) + 1) = 255;
715 *(img + (scancfg->coord.width * (ler + 5) * 3) +
716 (3 * c) + 2) = 0;
717 }
718 }
719 }
720 }
721
722 dbg_tiff_save ("post-autoref.tiff", scancfg->coord.width,
723 scancfg->coord.height, 8, CM_COLOR,
724 scancfg->resolution_x, scancfg->resolution_y, img,
725 scancfg->coord.height * scancfg->coord.width * 3);
726
727 /* free generated image */
728 free (img);
729 }
730 }
731
732 #ifdef developing
733
734 static void
dbg_buffer(SANE_Int level,char * title,SANE_Byte * buffer,SANE_Int size,SANE_Int start)735 dbg_buffer (SANE_Int level, char *title, SANE_Byte * buffer, SANE_Int size,
736 SANE_Int start)
737 {
738 if (level <= DBG_LEVEL)
739 {
740 DBG (level, "%s ", title);
741 if ((size > 0) && (buffer != NULL))
742 {
743 SANE_Int cont, data, offset = 0;
744 SANE_Int col = 0;
745 char text[9];
746 char *sline = NULL;
747 char *sdata = NULL;
748
749 sline = (char *) malloc (81);
750 if (sline != NULL)
751 {
752 sdata = (char *) malloc (81);
753 if (sdata != NULL)
754 {
755 for (cont = 0; cont < size; cont++)
756 {
757 if (col == 0)
758 {
759 if (cont == 0)
760 snprintf (sline, 80, " BF: ");
761 else
762 snprintf (sline, 80, " ");
763 memset (&text, 0, sizeof (text));
764 }
765 data = _B0 (buffer[cont]);
766 text[col] = (data > 31) ? data : '·';
767 snprintf (sdata, 80, "%02x ", data);
768 sline = strcat (sline, sdata);
769 col++;
770 offset++;
771 if (col == 8)
772 {
773 col = 0;
774 snprintf (sdata, 80, " : %s : 0x%04x\n", text,
775 start + offset - 8);
776 sline = strcat (sline, sdata);
777 DBG (level, "%s", sline);
778 memset (sline, 0, 81);
779 }
780 }
781 if (col > 0)
782 {
783 for (cont = col; cont < 8; cont++)
784 {
785 snprintf (sdata, 80, "-- ");
786 sline = strcat (sline, sdata);
787 offset++;
788 }
789 snprintf (sdata, 80, " : %s : 0x%04x\n", text,
790 start + offset - 8);
791 sline = strcat (sline, sdata);
792 DBG (level, "%s", sline);
793 memset (sline, 0, 81);
794 }
795 free (sdata);
796 }
797 free (sline);
798 }
799 }
800 else
801 DBG (level, " BF: Empty buffer\n");
802 }
803 }
804
805 static void
dbg_registers(SANE_Byte * buffer)806 dbg_registers (SANE_Byte * buffer)
807 {
808 /* buffer size must be RT_BUFFER_LEN bytes */
809 /*SANE_Int iValue, iValue2;
810 double dValue;
811
812 DBG(DBG_FNC, "\n----------------------------------------------------\n");
813 DBG(DBG_FNC, """RTS8822 Control Registers Info""\nAddress Info\n------- ----\n");
814 iValue = data_lsb_get(&buffer[0x000], 1);
815 DBG(DBG_FNC, "\n0x0000");
816 DBG(DBG_FNC, " bit[0..3] = systemclock: 0x%02x\n", iValue & 0x0f);
817 DBG(DBG_FNC, " bit[4] = 0x%02x : MLOCK\n", (iValue >> 4) & 1);
818 DBG(DBG_FNC, " bit[5] = 0x%02x : Bit to reset scanner\n", (iValue >> 5) & 1);
819 DBG(DBG_FNC, " bit[6] = 0x%02x : ?\n", (iValue >> 6) & 1);
820 DBG(DBG_FNC, " bit[7] = 0x%02x : RTS_IsExecuting\n", (iValue >> 7) & 1);
821
822 iValue = data_lsb_get(&buffer[0x001], 1);
823 DBG(DBG_FNC, "0x0001 bit[0] = 0x%02x : ?\n", iValue & 1);
824 DBG(DBG_FNC, " bit[1] = 0x%02x : (is 1 if has motorcurves)\n", (iValue >> 1) & 1);
825 DBG(DBG_FNC, " bit[2] = 0x%02x : ?\n", (iValue >> 2) & 1);
826 DBG(DBG_FNC, " bit[3] = 0x%02x : ?\n", (iValue >> 3) & 1);
827 DBG(DBG_FNC, " bit[4] = 0x%02x : dummy scan\n", (iValue >> 4) & 1);
828 DBG(DBG_FNC, " bit[5..7] = 0x%02x : ?\n", (iValue >> 5) & 7);
829
830 dbg_buffer(DBG_FNC, "\n0x0002", &buffer[0x002], 0x0e, 0x02);
831
832 iValue = data_lsb_get(&buffer[0x010], 1);
833 DBG(DBG_FNC, "\n0x0010 bit[0..4] = 0x%02x : cvrs\n", iValue & 0x1f);
834 DBG(DBG_FNC, " bit[5] = 0x%02x : Enable CCD\n", ((iValue >> 5) & 1));
835 DBG(DBG_FNC, " bit[6] = 0x%02x : Enable CCD channel 1\n", ((iValue >> 6) & 1));
836 DBG(DBG_FNC, " bit[7] = 0x%02x : Enable CCD channel 2\n", ((iValue >> 7) & 1));
837
838 iValue = data_lsb_get(&buffer[0x011], 1);
839 DBG(DBG_FNC, "\n0x0011 bit[0..6] = ?: 0x%02x\n", iValue & 0x3f);
840 DBG(DBG_FNC, " bit[7] = 0x%02x : sensor type (CCD=0|CIS=1)\n", (iValue >> 7) & 1);
841
842 iValue = data_lsb_get(&buffer[0x012], 1);
843 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);
844 DBG(DBG_FNC, " bit[6..7] = channels_per_dot : 0x%02x\n", (iValue >> 6) & 3);
845
846 iValue = data_lsb_get(&buffer[0x013], 1);
847 DBG(DBG_FNC, "\n0x0013");
848 DBG(DBG_FNC, " bit[0..1] = Pre-Amplifier Gain[RED] : 0x%02x\n", iValue & 3);
849 DBG(DBG_FNC, " bit[2..3] = Pre-Amplifier Gain[GREEN] : 0x%02x\n", (iValue >> 2) & 3);
850 DBG(DBG_FNC, " bit[4..5] = Pre-Amplifier Gain[BLUE] : 0x%02x\n", (iValue >> 4) & 3);
851 DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
852 DBG(DBG_FNC, " bit[7] = Enable CCD channel 3: : 0x%02x\n", (iValue >> 7) & 1);
853
854 iValue = data_lsb_get(&buffer[0x014], 1);
855 DBG(DBG_FNC, "\n0x0014");
856 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [RED] : 0x%02x\n", iValue & 0x1f);
857 DBG(DBG_FNC, " bit[5..7] = Top Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
858
859 iValue = data_lsb_get(&buffer[0x015], 1);
860 DBG(DBG_FNC, "0x0015");
861 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [GREEN] : 0x%02x\n", iValue & 0x1f);
862 DBG(DBG_FNC, " bit[5..7] = Middle Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
863
864 iValue = data_lsb_get(&buffer[0x016], 1);
865 DBG(DBG_FNC, "0x0016");
866 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 1 [BLUE] : 0x%02x\n", iValue & 0x1f);
867 DBG(DBG_FNC, " bit[5..7] = Bottom Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
868
869 iValue = data_lsb_get(&buffer[0x017], 1);
870 DBG(DBG_FNC, "0x0017");
871 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [RED] : 0x%02x\n", iValue & 0x1f);
872 DBG(DBG_FNC, " bit[5..7] = Top Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
873
874 iValue = data_lsb_get(&buffer[0x018], 1);
875 DBG(DBG_FNC, "0x0018");
876 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [GREEN] : 0x%02x\n", iValue & 0x1f);
877 DBG(DBG_FNC, " bit[5..7] = Middle Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
878
879 iValue = data_lsb_get(&buffer[0x019], 1);
880 DBG(DBG_FNC, "0x0019");
881 DBG(DBG_FNC, " bit[0..4] = Variable Gain Amplifier 2 [BLUE] : 0x%02x\n", iValue & 0x1f);
882 DBG(DBG_FNC, " bit[5..7] = Bottom Reference Voltage: 0x%02x\n", (iValue >> 5) & 3);
883
884 iValue = data_lsb_get(&buffer[0x01a], 1);
885 iValue2 = data_lsb_get(&buffer[0x01b], 1);
886 DBG(DBG_FNC, "\n0x001a-0x001b\n");
887 DBG(DBG_FNC, " Red Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
888 DBG(DBG_FNC, " Red Even offset 2: 0x%02x\n", iValue2 & 0x3f);
889
890 iValue = data_lsb_get(&buffer[0x01c], 1);
891 iValue2 = data_lsb_get(&buffer[0x01d], 1);
892 DBG(DBG_FNC, "0x001c-0x001d\n");
893 DBG(DBG_FNC, " Red Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
894 DBG(DBG_FNC, " Red Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
895
896 iValue = data_lsb_get(&buffer[0x01e], 1);
897 iValue2 = data_lsb_get(&buffer[0x01f], 1);
898 DBG(DBG_FNC, "0x001e-0x001f\n");
899 DBG(DBG_FNC, " Green Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
900 DBG(DBG_FNC, " Green Even offset 2: 0x%02x\n", iValue2 & 0x3f);
901
902 iValue = data_lsb_get(&buffer[0x020], 1);
903 iValue2 = data_lsb_get(&buffer[0x021], 1);
904 DBG(DBG_FNC, "0x0020-0x0021\n");
905 DBG(DBG_FNC, " Green Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
906 DBG(DBG_FNC, " Green Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
907
908 iValue = data_lsb_get(&buffer[0x022], 1);
909 iValue2 = data_lsb_get(&buffer[0x023], 1);
910 DBG(DBG_FNC, "0x0022-0x0023\n");
911 DBG(DBG_FNC, " Blue Even offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
912 DBG(DBG_FNC, " Blue Even offset 2: 0x%02x\n", iValue2 & 0x3f);
913
914 iValue = data_lsb_get(&buffer[0x024], 1);
915 iValue2 = data_lsb_get(&buffer[0x025], 1);
916 DBG(DBG_FNC, "0x0024-0x0025\n");
917 DBG(DBG_FNC, " Blue Odd offset 1: 0x%02x\n", ((iValue2 & 0x80) << 1) | iValue);
918 DBG(DBG_FNC, " Blue Odd offset 2: 0x%02x\n", iValue2 & 0x3f);
919
920 dbg_buffer(DBG_FNC, "\n0x0026", &buffer[0x026], 0x03, 0x26);
921
922 iValue = data_lsb_get(&buffer[0x029], 1);
923 DBG(DBG_FNC, "\n0x0029");
924 DBG(DBG_FNC, " First connection to scanner? : 0x%02x\n", iValue);
925
926 dbg_buffer(DBG_FNC, "\n0x002a", &buffer[0x02a], 0x06, 0x2a);
927
928 DBG(DBG_FNC, "\nExposure times:\n");
929 iValue = data_lsb_get(&buffer[0x030], 3);
930 DBG(DBG_FNC, "0x0030 Line exposure time : %i us\n", iValue);
931
932 iValue = data_lsb_get(&buffer[0x033], 3);
933 DBG(DBG_FNC, "\n0x0033 mexpts[RED] : %i us\n", iValue);
934
935 iValue = data_lsb_get(&buffer[0x036], 3);
936 DBG(DBG_FNC, "0x0036 expts[RED] : %i us\n", iValue);
937
938 iValue = data_lsb_get(&buffer[0x039], 3);
939 DBG(DBG_FNC, "0x0039 mexpts[GREEN]: %i us\n", iValue);
940
941 iValue = data_lsb_get(&buffer[0x03c], 3);
942 DBG(DBG_FNC, "0x003c expts[GREEN]: %i us\n", iValue);
943
944 iValue = data_lsb_get(&buffer[0x03f], 3);
945 DBG(DBG_FNC, "0x003f mexpts[BLUE] : %i us\n", iValue);
946
947 iValue = data_lsb_get(&buffer[0x042], 3);
948 DBG(DBG_FNC, "0x0042 expts[BLUE] : %i us\n", iValue);
949
950 iValue = data_lsb_get(&buffer[0x045], 1);
951 DBG(DBG_FNC, "\n0x0045 bit[0..4] = timing.cvtrfpw: 0x%02x\n", iValue & 0x1f);
952 DBG(DBG_FNC, " bit[5] = timing.cvtrp[2]: 0x%02x\n", (iValue >> 5) & 1);
953 DBG(DBG_FNC, " bit[6] = timing.cvtrp[1]: 0x%02x\n", (iValue >> 6) & 1);
954 DBG(DBG_FNC, " bit[7] = timing.cvtrp[0]: 0x%02x\n", (iValue >> 7) & 1);
955
956 iValue = data_lsb_get(&buffer[0x046], 1);
957 DBG(DBG_FNC, "0x0046");
958 DBG(DBG_FNC, " bit[0..4] = timing.cvtrbpw: 0x%02x\n", iValue & 0x1f);
959 DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 3);
960
961 iValue = data_lsb_get(&buffer[0x047], 1);
962 DBG(DBG_FNC, "0x0047");
963 DBG(DBG_FNC, " timing.cvtrw: 0x%02x\n", iValue);
964
965 iValue = data_lsb_get(&buffer[0x04c], 0x01) & 0x0f;
966 dValue = iValue * pow(2, 32);
967 iValue = data_lsb_get(&buffer[0x04a], 0x02);
968 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x048], 0x02);
969 DBG(DBG_FNC, "\n0x0048 Linear image sensor clock 1\n");
970 DBG(DBG_FNC, " bit[0..35] = timing.cph0p1: %.0f.\n", dValue);
971 iValue = data_lsb_get(&buffer[0x04c], 0x01);
972 DBG(DBG_FNC, " bit[36] = timing.cph0go: 0x%02x\n", (iValue >> 4) & 1);
973 DBG(DBG_FNC, " bit[37] = timing.cph0ge: 0x%02x\n", (iValue >> 5) & 1);
974 DBG(DBG_FNC, " bit[38] = timing.cph0ps: 0x%02x\n", (iValue >> 6) & 1);
975 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 7) & 1);
976
977 iValue = data_lsb_get(&buffer[0x051], 0x01) & 0x0f;
978 dValue = iValue * pow(2, 32);
979 iValue = data_lsb_get(&buffer[0x04f], 0x02);
980 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x04d], 0x02);
981 DBG(DBG_FNC, "0x004d");
982 DBG(DBG_FNC, " bit[0..35] = timing.cph0p2: %.0f.\n", dValue);
983
984 iValue = data_lsb_get(&buffer[0x056], 1) & 0x0f;
985 dValue = iValue * pow(2, 32);
986 iValue = data_lsb_get(&buffer[0x054], 2);
987 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x052], 2);
988 DBG(DBG_FNC, "\n0x0052 Linear image sensor clock 2\n");
989 DBG(DBG_FNC, " bit[0..35] = timing.cph1p1: %.0f.\n", dValue);
990 iValue = data_lsb_get(&buffer[0x056], 1);
991 DBG(DBG_FNC, " bit[36] = timing.cph1go: 0x%02x\n", (iValue >> 4) & 1);
992 DBG(DBG_FNC, " bit[37] = timing.cph1ge: 0x%02x\n", (iValue >> 5) & 1);
993 DBG(DBG_FNC, " bit[38] = timing.cph1ps: 0x%02x\n", (iValue >> 6) & 1);
994 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 7) & 1);
995
996
997 iValue = data_lsb_get(&buffer[0x05b], 0x01) & 0x0f;
998 dValue = iValue * pow(2, 32);
999 iValue = data_lsb_get(&buffer[0x059], 0x02);
1000 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x057], 0x02);
1001 DBG(DBG_FNC, "0x0057");
1002 DBG(DBG_FNC, " bit[0..35] = timing.cph1p2: %.0f.\n", dValue);
1003 iValue = data_lsb_get(&buffer[0x05b], 0x01);
1004 DBG(DBG_FNC, " bits[36..39] = %02x\n", (iValue >> 0x04) & 0x0f);
1005 DBG(DBG_FNC, " bit[36] = ?: %02x\n", (iValue >> 0x04) & 0x01);
1006 DBG(DBG_FNC, " bit[37] = ?: %02x\n", (iValue >> 0x05) & 0x01);
1007 DBG(DBG_FNC, " bit[38] = ?: %02x\n", (iValue >> 0x06) & 0x01);
1008 DBG(DBG_FNC, " bit[39] = ?: %02x\n", (iValue >> 0x07) & 0x01);
1009
1010 iValue = data_lsb_get(&buffer[0x060], 0x01) & 0x0f;
1011 dValue = iValue * pow(2, 32);
1012 iValue = data_lsb_get(&buffer[0x05e], 0x02);
1013 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x05c], 0x02);
1014 DBG(DBG_FNC, "\n0x005c Linear Image Sensor Clock 3\n");
1015 DBG(DBG_FNC, " bit[0..35] = timing.cph2p1: %.0f.\n", dValue);
1016 iValue = data_lsb_get(&buffer[0x060], 0x01);
1017 DBG(DBG_FNC, " bit[36] = timing.cph2go: 0x%02x\n", (iValue >> 0x04) & 0x01);
1018 DBG(DBG_FNC, " bit[37] = timing.cph2ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
1019 DBG(DBG_FNC, " bit[38] = timing.cph2ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
1020 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1021
1022 iValue = data_lsb_get(&buffer[0x065], 0x01) & 0x0f;
1023 dValue = iValue * pow(2, 32);
1024 iValue = data_lsb_get(&buffer[0x063], 0x02);
1025 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x061], 0x02);
1026 DBG(DBG_FNC, "0x0061");
1027 DBG(DBG_FNC, " bit[0..35] = timing.cph2p2: %.0f.\n", dValue);
1028 iValue = data_lsb_get(&buffer[0x065], 0x01);
1029 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1030 DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
1031 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1032 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1033 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1034
1035 iValue = data_lsb_get(&buffer[0x06a], 0x01) & 0x0f;
1036 dValue = iValue * pow(2, 32);
1037 iValue = data_lsb_get(&buffer[0x068], 0x02);
1038 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x066], 0x02);
1039 DBG(DBG_FNC, "\n0x0066 Linear Image Sensor Clock 4\n");
1040 DBG(DBG_FNC, " bit[0..35] = timing.cph3p1: %.0f.\n", dValue);
1041 iValue = data_lsb_get(&buffer[0x06a], 0x01);
1042 DBG(DBG_FNC, " bit[36] = timing.cph3go: 0x%02x\n", (iValue >> 0x04) & 0x01);
1043 DBG(DBG_FNC, " bit[37] = timing.cph3ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
1044 DBG(DBG_FNC, " bit[38] = timing.cph3ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
1045 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1046
1047 iValue = data_lsb_get(&buffer[0x06f], 0x01) & 0x0f;
1048 dValue = iValue * pow(2, 32);
1049 iValue = data_lsb_get(&buffer[0x06d], 0x02);
1050 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x06b], 0x02);
1051 DBG(DBG_FNC, "0x006b");
1052 DBG(DBG_FNC, " bit[0..35] = timing.cph3p2: %.0f.\n", dValue);
1053 iValue = data_lsb_get(&buffer[0x06f], 0x01);
1054 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1055 DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
1056 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1057 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1058 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1059
1060 iValue = data_lsb_get(&buffer[0x074], 0x01) & 0x0f;
1061 dValue = iValue * pow(2, 32);
1062 iValue = data_lsb_get(&buffer[0x072], 0x02);
1063 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x070], 0x02);
1064 DBG(DBG_FNC, "\n0x0070 Linear Image Sensor Clock 5\n");
1065 DBG(DBG_FNC, " bit[0..35] = timing.cph4p1: %.0f.\n", dValue);
1066 iValue = data_lsb_get(&buffer[0x074], 0x01);
1067 DBG(DBG_FNC, " bit[36] = timing.cph4go: 0x%02x\n", (iValue >> 0x04) & 0x01);
1068 DBG(DBG_FNC, " bit[37] = timing.cph4ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
1069 DBG(DBG_FNC, " bit[38] = timing.cph4ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
1070 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1071
1072 iValue = data_lsb_get(&buffer[0x079], 0x01) & 0x0f;
1073 dValue = iValue * pow(2, 32);
1074 iValue = data_lsb_get(&buffer[0x077], 0x02);
1075 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x075], 0x02);
1076 DBG(DBG_FNC, "0x0075");
1077 DBG(DBG_FNC, " bit[0..35] = timing.cph4p2: %.0f.\n", dValue);
1078 iValue = data_lsb_get(&buffer[0x079], 0x01);
1079 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1080 DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
1081 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1082 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1083 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1084
1085 iValue = data_lsb_get(&buffer[0x07e], 0x01) & 0x0f;
1086 dValue = iValue * pow(2, 32);
1087 iValue = data_lsb_get(&buffer[0x07c], 0x02);
1088 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x07a], 0x02);
1089 DBG(DBG_FNC, "\n0x007a Linear Image Sensor Clock 6\n");
1090 DBG(DBG_FNC, " bit[0..35] = timing.cph5p1: %.0f.\n", dValue);
1091 iValue = data_lsb_get(&buffer[0x07e], 0x01);
1092 DBG(DBG_FNC, " bit[36] = timing.cph5go: 0x%02x\n", (iValue >> 0x04) & 0x01);
1093 DBG(DBG_FNC, " bit[37] = timing.cph5ge: 0x%02x\n", (iValue >> 0x05) & 0x01);
1094 DBG(DBG_FNC, " bit[38] = timing.cph5ps: 0x%02x\n", (iValue >> 0x06) & 0x01);
1095 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1096
1097 iValue = data_lsb_get(&buffer[0x083], 0x01) & 0x0f;
1098 dValue = iValue * pow(2, 32);
1099 iValue = data_lsb_get(&buffer[0x081], 0x02);
1100 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x07f], 0x02);
1101 DBG(DBG_FNC, "0x007f");
1102 DBG(DBG_FNC, " bit[0..35] = timing.cph5p2: %.0f.\n", dValue);
1103 iValue = data_lsb_get(&buffer[0x083], 0x01);
1104 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1105 DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
1106 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1107 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1108 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1109
1110 iValue = data_lsb_get(&buffer[0x084], 3);
1111 DBG(DBG_FNC, "\n0x0084");
1112 DBG(DBG_FNC, " timing.cphbp2s : 0x%06x\n", iValue);
1113
1114 iValue = data_lsb_get(&buffer[0x087], 3);
1115 DBG(DBG_FNC, "0x0087");
1116 DBG(DBG_FNC, " timing.cphbp2e : 0x%06x\n", iValue);
1117
1118 iValue = data_lsb_get(&buffer[0x08a], 3);
1119 DBG(DBG_FNC, "0x008a");
1120 DBG(DBG_FNC, " timing.clamps : 0x%08x\n", iValue);
1121
1122 iValue = data_lsb_get(&buffer[0x08d], 3);
1123 DBG(DBG_FNC, "0x008d");
1124 DBG(DBG_FNC, " timing.clampe or cphbp2e : 0x%08x\n", iValue);
1125
1126 iValue = data_lsb_get(&buffer[0x092], 0x01);
1127 DBG(DBG_FNC, "\n0x0092 Correlated-Double-Sample 1\n");
1128 DBG(DBG_FNC, " bit[0..5] = timing.cdss[0]: 0x%02x\n", iValue & 0x3f);
1129 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1130
1131 iValue = data_lsb_get(&buffer[0x093], 0x01);
1132 DBG(DBG_FNC, "0x0093");
1133 DBG(DBG_FNC, " bit[0..5] = timing.cdsc[0]: 0x%02x\n", iValue & 0x3f);
1134 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1135
1136 iValue = data_lsb_get(&buffer[0x094], 0x01);
1137 DBG(DBG_FNC, "\n0x0094 Correlated-Double-Sample 2\n");
1138 DBG(DBG_FNC, " bit[0..5] = timing.cdss[1]: 0x%02x\n", iValue & 0x3f);
1139 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1140
1141 iValue = data_lsb_get(&buffer[0x095], 0x01);
1142 DBG(DBG_FNC, "0x0095");
1143 DBG(DBG_FNC, " bit[0..5] = timing.cdsc[1]: 0x%02x\n", iValue & 0x3f);
1144 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1145
1146 iValue = data_lsb_get(&buffer[0x096], 0x01);
1147 DBG(DBG_FNC, "0x0096");
1148 DBG(DBG_FNC, " bit[0..5] = timing.cnpp: 0x%02x\n", iValue & 0x3f);
1149 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1150
1151 iValue = data_lsb_get(&buffer[0x09b], 0x01) & 0x0f;
1152 dValue = iValue * pow(2, 32);
1153 iValue = data_lsb_get(&buffer[0x099], 0x02);
1154 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x097], 0x02);
1155 DBG(DBG_FNC, "\n0x0097 Analog to Digital Converter clock 1\n");
1156 DBG(DBG_FNC, " bit[0..35] = timing.adcclkp[0]: %.0f.\n", dValue);
1157 iValue = data_lsb_get(&buffer[0x09b], 0x01);
1158 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1159 DBG(DBG_FNC, " bit[36] = ?: 0x%02x\n", (iValue >> 0x04) & 0x01);
1160 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1161 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1162 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1163
1164 dbg_buffer(DBG_FNC, "\n0x009c CIS sensor 1", &buffer[0x09c], 0x06, 0x9c);
1165 dbg_buffer(DBG_FNC, "0x00a2 CIS sensor 2", &buffer[0x0a2], 0x06, 0xa2);
1166 dbg_buffer(DBG_FNC, "0x00a8 CIS sensor 3", &buffer[0x0a8], 0x06, 0xa8);
1167
1168 iValue = data_lsb_get(&buffer[0x0ae], 0x01);
1169 DBG(DBG_FNC, "\n0x00ae");
1170 DBG(DBG_FNC, " bit[0..5] = ?: 0x%02x\n", iValue & 0x3f);
1171 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1172
1173 iValue = data_lsb_get(&buffer[0x0af], 0x01);
1174 DBG(DBG_FNC, "0x00af");
1175 DBG(DBG_FNC, " bit[0..2] = ?: 0x%02x\n", iValue & 7);
1176 DBG(DBG_FNC, " bit[3..7] = ?: 0x%02x\n", (iValue >> 3) & 0x1f);
1177
1178 iValue = data_lsb_get(&buffer[0x0b0], 2);
1179 DBG(DBG_FNC, "\n0x00b0");
1180 DBG(DBG_FNC, " Left : 0x%04x\n", iValue);
1181
1182 iValue = data_lsb_get(&buffer[0x0b2], 2);
1183 DBG(DBG_FNC, "0x00b2");
1184 DBG(DBG_FNC, " Right: 0x%04x\n", iValue);
1185
1186 dbg_buffer(DBG_FNC, "\n0x00b4", &buffer[0x0b4], 12, 0xb4);
1187
1188 iValue = data_lsb_get(&buffer[0x0c0], 0x01);
1189 DBG(DBG_FNC, "\n0x00c0");
1190 DBG(DBG_FNC, " bit[0..4] = resolution ratio: 0x%02x\n", iValue & 0x1f);
1191 DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
1192
1193 iValue = data_lsb_get(&buffer[0x0c5], 0x01) & 0x0f;
1194 dValue = iValue * pow(2, 32);
1195 iValue = data_lsb_get(&buffer[0x0c3], 0x02);
1196 dValue = dValue + (iValue * pow(2, 16)) + data_lsb_get(&buffer[0x0c1], 2);
1197 DBG(DBG_FNC, "\n0x00c1 Analog to Digital Converter clock 2\n");
1198 DBG(DBG_FNC, " bit[0..35] = timing.adcclkp[1]: %.0f.\n", dValue);
1199 iValue = data_lsb_get(&buffer[0x0c5], 0x01);
1200 DBG(DBG_FNC, " bits[36..39] = 0x%02x\n", (iValue >> 0x04) & 0x0f);
1201 DBG(DBG_FNC, " bit[36] = ?: 0x%02x (equal to bit[32])\n", (iValue >> 0x04) & 0x01);
1202 DBG(DBG_FNC, " bit[37] = ?: 0x%02x\n", (iValue >> 0x05) & 0x01);
1203 DBG(DBG_FNC, " bit[38] = ?: 0x%02x\n", (iValue >> 0x06) & 0x01);
1204 DBG(DBG_FNC, " bit[39] = ?: 0x%02x\n", (iValue >> 0x07) & 0x01);
1205
1206 dbg_buffer(DBG_FNC, "\n0x00c6", &buffer[0x0c6], 0x0a, 0xc6);
1207
1208 iValue = ((buffer[0x0d4] & 0x0f) << 0x10) + data_lsb_get(&buffer[0x0d0], 0x02);
1209 DBG(DBG_FNC, "\n0x00d0");
1210 DBG(DBG_FNC, " Top : 0x%04x\n", iValue);
1211
1212 iValue = ((buffer[0x0d4] & 0xf0) << 0x06)+ data_lsb_get(&buffer[0x0d2], 0x02);
1213 DBG(DBG_FNC, "x00d2");
1214 DBG(DBG_FNC, " Down: 0x%04x\n", iValue);
1215
1216 iValue = _B0(buffer[0x0d5]);
1217 DBG(DBG_FNC, "0x00d5");
1218 DBG(DBG_FNC, " ?: 0x%04x\n", iValue);
1219
1220 iValue = data_lsb_get(&buffer[0x0d6], 1);
1221 DBG(DBG_FNC, "\n0x00d6");
1222 DBG(DBG_FNC, " bit[0..3] = ? : 0x%02x\n", iValue & 0xf);
1223 DBG(DBG_FNC, " bit[4..7] = dummyline: 0x%02x\n", (iValue >> 4) & 0xf);
1224
1225 iValue = data_lsb_get(&buffer[0x0d7], 0x01);
1226 DBG(DBG_FNC, "\n0x00d7");
1227 DBG(DBG_FNC, " bit[0..5] = motor pwm frequency: 0x%02x\n", iValue & 0x3f);
1228 DBG(DBG_FNC, " bit[6] = ?: 0x%02x\n", (iValue >> 6) & 1);
1229 DBG(DBG_FNC, " bit[7] = motor type: 0x%02x ", (iValue >> 7) & 1);
1230 if (((iValue >> 7) & 1) == MT_OUTPUTSTATE)
1231 DBG(DBG_FNC, ": Output state machine\n");
1232 else DBG(DBG_FNC, "On-Chip PWM\n");
1233
1234 iValue = data_lsb_get(&buffer[0x0d8], 0x01);
1235 DBG(DBG_FNC, "\n0x00d8");
1236 DBG(DBG_FNC, " bit[0..5] = ?: 0x%02x\n", iValue & 0x3f);
1237 DBG(DBG_FNC, " bit[6] = scantype (0=Normal|1=TMA) : 0x%02x\n", (iValue >> 6) & 1);
1238 DBG(DBG_FNC, " bit[7] = enable head movement : 0x%02x :", (iValue >> 7) & 1);
1239
1240 iValue = data_lsb_get(&buffer[0x0d9], 0x01);
1241 DBG(DBG_FNC, "\n0x00d9");
1242 DBG(DBG_FNC, " bit[0..2] = ?: 0x%02x\n", iValue & 7);
1243 DBG(DBG_FNC, " bit[3] = ?: 0x%02x\n", (iValue >> 3) & 1);
1244 DBG(DBG_FNC, " bit[4..6] = motor step type: 0x%02x: ", (iValue >> 4) & 7);
1245 switch((iValue >> 4) & 7)
1246 {
1247 case 0: DBG(DBG_FNC, "full (1)\n"); break;
1248 case 1: DBG(DBG_FNC, "half (1/2)\n"); break;
1249 case 2: DBG(DBG_FNC, "quart (1/4)\n"); break;
1250 case 3: DBG(DBG_FNC, "(1/8)\n"); break;
1251 default: DBG(DBG_FNC, "unknown\n"); break;
1252 }
1253 DBG(DBG_FNC, " bit[7] = Motor direction: 0x%02x = ", (iValue >> 7) & 1);
1254 if (((iValue >> 7) & 1) == 0)
1255 DBG(DBG_FNC, "Backward\n");
1256 else DBG(DBG_FNC, "Forward\n");
1257
1258 iValue = data_lsb_get(&buffer[0x0dd], 0x01);
1259 DBG(DBG_FNC, "\n0x00da");
1260 DBG(DBG_FNC, " msi = 0x%03x\n", ((iValue & 3) << 8) + data_lsb_get(&buffer[0x0da], 1));
1261
1262 DBG(DBG_FNC, "0x00db");
1263 DBG(DBG_FNC, " motorbackstep1 = 0x%03x\n", ((iValue & 0x0c) << 6) + data_lsb_get(&buffer[0x0db], 1));
1264
1265 DBG(DBG_FNC, "0x00dc");
1266 DBG(DBG_FNC, " motorbackstep2 = 0x%03x\n", ((iValue & 0x30) << 4) + data_lsb_get(&buffer[0x0dc], 1));
1267
1268 iValue = data_lsb_get(&buffer[0x0dd], 0x01);
1269 DBG(DBG_FNC, "0x00dd");
1270 DBG(DBG_FNC, " bit[7] = Motor enabled?: 0x%02x = ", (iValue >> 7) & 1);
1271 if (((iValue >> 7) & 1) == 0)
1272 DBG(DBG_FNC, "Yes\n");
1273 else DBG(DBG_FNC, "No\n");
1274
1275 iValue = data_lsb_get(&buffer[0x0de], 0x02);
1276 DBG(DBG_FNC, "\n0x00de");
1277 DBG(DBG_FNC, " bit[00..11] = ?: 0x%02x\n", iValue & 0xfff);
1278 DBG(DBG_FNC, " bit[12..15] = ?: 0x%02x\n", (iValue >> 12) & 0x0f);
1279
1280 iValue = data_lsb_get(&buffer[0x0df], 0x01);
1281 DBG(DBG_FNC, "\n0x00df");
1282 DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0x0f);
1283 DBG(DBG_FNC, " bit[4] = has_motorcurves?: 0x%02x\n", (iValue >> 4) & 0x01);
1284 DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
1285
1286 iValue = data_lsb_get(&buffer[0x0e0], 1);
1287 DBG(DBG_FNC, "\n0x00e0 step size - 1 : 0x%02x\n", iValue);
1288
1289 iValue = data_lsb_get(&buffer[0x0e1], 3);
1290 DBG(DBG_FNC, "\n0x00e1 0x%06x : last step of accurve.normalscan table\n", iValue);
1291
1292 iValue = data_lsb_get(&buffer[0x0e4], 3);
1293 DBG(DBG_FNC, "0x00e4 0x%06x : last step of accurve.smearing table\n", iValue);
1294
1295 iValue = data_lsb_get(&buffer[0x0e7], 3);
1296 DBG(DBG_FNC, "0x00e7 0x%06x : last step of accurve.parkhome table\n", iValue);
1297
1298 iValue = data_lsb_get(&buffer[0x0ea], 3);
1299 DBG(DBG_FNC, "0x00ea 0x%06x : last step of deccurve.scanbufferfull table\n", iValue);
1300
1301 iValue = data_lsb_get(&buffer[0x0ed], 3);
1302 DBG(DBG_FNC, "0x00ed 0x%06x : last step of deccurve.normalscan table\n", iValue);
1303
1304 iValue = data_lsb_get(&buffer[0x0f0], 3);
1305 DBG(DBG_FNC, "0x00f0 0x%06x : last step of deccurve.smearing table\n", iValue);
1306
1307 iValue = data_lsb_get(&buffer[0x0f3], 3);
1308 DBG(DBG_FNC, "0x00f3 0x%06x : last step of deccurve.parkhome table\n", iValue);
1309
1310 iValue = data_lsb_get(&buffer[0x0f6], 2);
1311 DBG(DBG_FNC, "\n0x00f6 bit[00..13] = 0x%04x : ptr to accurve.normalscan step table\n", iValue & 0x3fff);
1312 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1313
1314 iValue = data_lsb_get(&buffer[0x0f8], 2);
1315 DBG(DBG_FNC, "0x00f8");
1316 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.scanbufferfull step table\n", iValue & 0x3fff);
1317 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1318
1319 iValue = data_lsb_get(&buffer[0x0fa], 2);
1320 DBG(DBG_FNC, "0x00fa");
1321 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to accurve.smearing step table\n", iValue & 0x3fff);
1322 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1323
1324 iValue = data_lsb_get(&buffer[0x0fc], 2);
1325 DBG(DBG_FNC, "0x00fc");
1326 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.smearing step table\n", iValue & 0x3fff);
1327 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1328
1329 iValue = data_lsb_get(&buffer[0x0fe], 2);
1330 DBG(DBG_FNC, "0x00fe");
1331 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.normalscan step table\n", iValue & 0x3fff);
1332 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1333
1334 iValue = data_lsb_get(&buffer[0x100], 2);
1335 DBG(DBG_FNC, "0x0100");
1336 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to accurve.parkhome step table\n", iValue & 0x3fff);
1337 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1338
1339 iValue = data_lsb_get(&buffer[0x102], 2);
1340 DBG(DBG_FNC, "0x0102");
1341 DBG(DBG_FNC, " bit[00..13] = 0x%04x : ptr to deccurve.parkhome step table\n", iValue & 0x3fff);
1342 DBG(DBG_FNC, " bit[14..15] = 0x%04x : ?\n",(iValue >> 14) & 3);
1343
1344 dbg_buffer(DBG_FNC, "\n0x0104 Motor resource", &buffer[0x104], 0x20, 0x104);
1345
1346 dbg_buffer(DBG_FNC, "\n0x0124", &buffer[0x124], 0x22, 0x124);
1347
1348 iValue = data_lsb_get(&buffer[0x146], 1);
1349 DBG(DBG_FNC, "\n0x0146");
1350 DBG(DBG_FNC, " bit[0..3] = Lamp pulse-width modulation frequency : 0x%02x\n", iValue & 0xf);
1351 DBG(DBG_FNC, " bit[4] = timer enabled? : 0x%02x\n", (iValue >> 4) & 1);
1352 DBG(DBG_FNC, " bit[5] = ? : 0x%02x\n", (iValue >> 5) & 1);
1353 DBG(DBG_FNC, " bit[6] = lamp turned on? : 0x%02x\n", (iValue >> 6) & 1);
1354 DBG(DBG_FNC, " bit[7] = sensor type : 0x%02x ", (iValue >> 7) & 1);
1355 if (((iValue >> 7) & 1) != 0)
1356 DBG(DBG_FNC, "CCD\n");
1357 else DBG(DBG_FNC, "CIS\n");
1358
1359 iValue = data_lsb_get(&buffer[0x147], 1);
1360 DBG(DBG_FNC, "\n0x0147");
1361 DBG(DBG_FNC, " time to turn off lamp = 0x%02x (minutes * 2.682163611980331)\n", iValue);
1362
1363 iValue = data_lsb_get(&buffer[0x148], 1);
1364 DBG(DBG_FNC, "\n0x0148");
1365 DBG(DBG_FNC, " bit[0..5] = Lamp pulse-width modulation duty cycle : 0x%02x\n", iValue & 0x3f);
1366 DBG(DBG_FNC, " bit[6..7] = ? : 0x%02x\n",(iValue >> 6) & 3);
1367
1368 iValue = data_lsb_get(&buffer[0x149], 1);
1369 DBG(DBG_FNC, "\n0x0149");
1370 DBG(DBG_FNC, " bit[0..5] = even_odd_distance : 0x%02x\n", iValue & 0x3f);
1371 DBG(DBG_FNC, " bit[6..7] = ? : 0x%02x\n",(iValue >> 6) & 3);
1372
1373 iValue = data_lsb_get(&buffer[0x14a], 1);
1374 DBG(DBG_FNC, "0x014a");
1375 DBG(DBG_FNC, " bit[0..5] = sensor line distance : 0x%02x\n", iValue & 0x3f);
1376 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n",(iValue >> 6) & 3);
1377
1378 iValue = data_lsb_get(&buffer[0x14b], 1);
1379 DBG(DBG_FNC, "0x014b");
1380 DBG(DBG_FNC, " bit[0..5] = sensor line distance + even_odd_distance: 0x%02x\n", iValue & 0x3f);
1381 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n",(iValue >> 6) & 3);
1382
1383 iValue = data_lsb_get(&buffer[0x14c], 1);
1384 DBG(DBG_FNC, "0x014c");
1385 DBG(DBG_FNC, " bit[0..5] = sensor line distance * 2: 0x%02x\n", iValue & 0x3f);
1386 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1387
1388 iValue = data_lsb_get(&buffer[0x14d], 1);
1389 DBG(DBG_FNC, "0x014d");
1390 DBG(DBG_FNC, " bit[0..5] = (sensor line distance * 2) + even_odd_distance: 0x%02x\n", iValue & 0x3f);
1391 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 3);
1392
1393 iValue = data_lsb_get(&buffer[0x14e], 1);
1394 DBG(DBG_FNC, "\n0x014e");
1395 DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0xf);
1396 DBG(DBG_FNC, " bit[4] = ?: 0x%02x\n", (iValue >> 4) & 1);
1397 DBG(DBG_FNC, " bit[5..7] = ?: 0x%02x\n", (iValue >> 5) & 7);
1398
1399 dbg_buffer(DBG_FNC, "\n0x014f", &buffer[0x14f], 0x05, 0x14f);
1400
1401 iValue = data_lsb_get(&buffer[0x154], 1);
1402 DBG(DBG_FNC, "\n0x0154");
1403 DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0xf);
1404 DBG(DBG_FNC, " bit[4..5] = ?: 0x%02x\n", (iValue >> 4) & 3);
1405 DBG(DBG_FNC, " bit[6..7] = ?: 0x%02x\n", (iValue >> 6) & 7);
1406
1407 iValue = data_lsb_get(&buffer[0x155], 1);
1408 DBG(DBG_FNC, "\n0x0155");
1409 DBG(DBG_FNC, " bit[0..3] = ?: 0x%02x\n", iValue & 0x0f);
1410 DBG(DBG_FNC, " bit[4] = 0x%02x : ", (iValue >> 4) & 1);
1411 if (((iValue >> 4) & 1) == 0)
1412 DBG(DBG_FNC, "flb lamp\n");
1413 else DBG(DBG_FNC, "tma lamp\n");
1414 DBG(DBG_FNC, " bit[5..7] = ? : 0x%02x\n", (iValue >> 5) & 7);
1415
1416 dbg_buffer(DBG_FNC, "\n0x0156", &buffer[0x156], 0x02, 0x156);
1417
1418 iValue = data_lsb_get(&buffer[0x158], 1);
1419 DBG(DBG_FNC, "\n0x0158");
1420 DBG(DBG_FNC, " bit[0..3] = %02x : Scanner buttons ", iValue & 0x0f);
1421 if ((iValue & 0x0f) == 0x0f)
1422 DBG(DBG_FNC, "enabled\n");
1423 else DBG(DBG_FNC, "disabled\n");
1424 DBG(DBG_FNC, " bit[4..7] = ? : 0x%02x\n", (iValue >> 4) & 0x0f);
1425
1426 dbg_buffer(DBG_FNC, "\n0x0159", &buffer[0x159], 11, 0x159);
1427
1428 iValue = data_lsb_get(&buffer[0x164], 1);
1429 DBG(DBG_FNC, "\n0x0164");
1430 DBG(DBG_FNC, " bit[0..6] = ?: 0x%02x\n", iValue & 0x3f);
1431 DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
1432
1433 dbg_buffer(DBG_FNC, "\n0x0165", &buffer[0x165], 3, 0x165);
1434
1435 iValue = data_lsb_get(&buffer[0x168], 1);
1436 DBG(DBG_FNC, "\n0x0168 Buttons status : 0x%02x\n", iValue);
1437 DBG(DBG_FNC, " bit[0] = button 1 : 0x%02x\n", iValue & 1);
1438 DBG(DBG_FNC, " bit[1] = button 2 : 0x%02x\n", (iValue >> 1) & 1);
1439 DBG(DBG_FNC, " bit[2] = button 4 : 0x%02x\n", (iValue >> 2) & 1);
1440 DBG(DBG_FNC, " bit[3] = button 3 : 0x%02x\n", (iValue >> 3) & 1);
1441 DBG(DBG_FNC, " bit[4] = button ? : 0x%02x\n", (iValue >> 4) & 1);
1442 DBG(DBG_FNC, " bit[5] = button ? : 0x%02x\n", (iValue >> 5) & 1);
1443 DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
1444 DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
1445
1446 iValue = data_lsb_get(&buffer[0x169], 1);
1447 DBG(DBG_FNC, "\n0x0169", iValue);
1448 DBG(DBG_FNC, " bit[0] = ? : 0x%02x\n", iValue & 1);
1449 DBG(DBG_FNC, " bit[1] = tma attached? : 0x%02x\n", (iValue >> 1) & 1);
1450 DBG(DBG_FNC, " bit[2..7] = ? : 0x%02x\n", (iValue >> 2) & 0x3f);
1451
1452 iValue = data_lsb_get(&buffer[0x16a], 1);
1453 DBG(DBG_FNC, "\n0x016a Buttons status 2: 0x%02x\n", iValue);
1454 DBG(DBG_FNC, " bit[0] = button 1 : 0x%02x\n", iValue & 1);
1455 DBG(DBG_FNC, " bit[1] = button 2 : 0x%02x\n", (iValue >> 1) & 1);
1456 DBG(DBG_FNC, " bit[2] = button 4 : 0x%02x\n", (iValue >> 2) & 1);
1457 DBG(DBG_FNC, " bit[3] = button 3 : 0x%02x\n", (iValue >> 3) & 1);
1458 DBG(DBG_FNC, " bit[4] = button ? : 0x%02x\n", (iValue >> 4) & 1);
1459 DBG(DBG_FNC, " bit[5] = button ? : 0x%02x\n", (iValue >> 5) & 1);
1460 DBG(DBG_FNC, " bit[6] = ? : 0x%02x\n", (iValue >> 6) & 1);
1461 DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
1462
1463 dbg_buffer(DBG_FNC, "\n0x016b", &buffer[0x16b], 4, 0x16b);
1464
1465 iValue = data_lsb_get(&buffer[0x16f], 1);
1466 DBG(DBG_FNC, "\n0x016f");
1467 DBG(DBG_FNC, " bit[0..5] = ? : 0x%02x\n", iValue & 0x3f);
1468 DBG(DBG_FNC, " bit[6] = is lamp at home? : 0x%02x\n", (iValue >> 6) & 1);
1469 DBG(DBG_FNC, " bit[7] = ?: %02x\n", (iValue >> 7) & 1);
1470
1471 dbg_buffer(DBG_FNC, "\n0x0170", &buffer[0x170], 0x17, 0x170);
1472
1473 iValue = data_lsb_get(&buffer[0x187], 1);
1474 DBG(DBG_FNC, "\n0x0187");
1475 DBG(DBG_FNC, " bit[0..3] = ? : 0x%02x\n", iValue & 0xf);
1476 DBG(DBG_FNC, " bit[4..7] = mclkioc : 0x%02x\n", (iValue >> 4) & 0xf);
1477
1478 dbg_buffer(DBG_FNC, "\n0x0188", &buffer[0x188], 0x16, 0x188);
1479
1480 iValue = data_lsb_get(&buffer[0x19e], 2);
1481 DBG(DBG_FNC, "\n0x019e");
1482 DBG(DBG_FNC, " binary threshold low : 0x%04x\n", (iValue >> 8) + ((iValue << 8) & 0xff00));
1483
1484 iValue = data_lsb_get(&buffer[0x1a0], 2);
1485 DBG(DBG_FNC, "\n0x01a0");
1486 DBG(DBG_FNC, " binary threshold high : 0x%04x\n", (iValue >> 8) + ((iValue << 8) & 0xff00));
1487
1488 dbg_buffer(DBG_FNC, "\n0x01a2", &buffer[0x1a2], 0x12, 0x1a2);
1489
1490 iValue = data_lsb_get(&buffer[0x1b4], 2);
1491 DBG(DBG_FNC, "\n0x01b4");
1492 DBG(DBG_FNC, " bit[00..13] = Ptr to red gamma table (table_size * 0) : 0x%04x\n", (iValue & 0x3fff));
1493 DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
1494
1495 iValue = data_lsb_get(&buffer[0x1b6], 2);
1496 DBG(DBG_FNC, "0x01b6");
1497 DBG(DBG_FNC, " bit[00..13] = Ptr to green gamma table (table_size * 1) : 0x%04x\n", (iValue & 0x3fff));
1498 DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
1499
1500 iValue = data_lsb_get(&buffer[0x1b8], 2);
1501 DBG(DBG_FNC, "0x01b8");
1502 DBG(DBG_FNC, " bit[00..13] = Ptr to blue gamma table (table_size * 2) : 0x%04x\n", (iValue & 0x3fff));
1503 DBG(DBG_FNC, " bit[14..15] = ? : 0x%02x\n", (iValue >> 14) & 3);
1504
1505 iValue = data_lsb_get(&buffer[0x1ba], 1);
1506 DBG(DBG_FNC, "\n0x01ba");
1507 DBG(DBG_FNC, " ? : 0x%02x\n", iValue);
1508
1509 iValue = data_lsb_get(&buffer[0x1bb], 2);
1510 DBG(DBG_FNC, "0x01bb");
1511 DBG(DBG_FNC, " ? : 0x%04x\n", iValue + ((data_lsb_get(&buffer[0x1bf], 1) & 1) << 16));
1512
1513 iValue = data_lsb_get(&buffer[0x1bd], 2);
1514 DBG(DBG_FNC, "0x01bd");
1515 DBG(DBG_FNC, " ? : 0x%04x\n", iValue + (((data_lsb_get(&buffer[0x1bf], 1) >> 1) & 3) << 16));
1516
1517 iValue = data_lsb_get(&buffer[0x1c0], 3);
1518 DBG(DBG_FNC, "0x01c0");
1519 DBG(DBG_FNC, " bit[0..19] = ? : 0x%06x\n", iValue & 0xfffff);
1520
1521 iValue = data_lsb_get(&buffer[0x1bf], 2);
1522 DBG(DBG_FNC, "\n0x01bf");
1523 DBG(DBG_FNC, " bit[3..4] = ? : 0x%02x\n", (iValue >> 3) & 3);
1524 DBG(DBG_FNC, " bit[5..7] = ? : 0x%02x\n", (iValue >> 5) & 7);
1525
1526 iValue = data_lsb_get(&buffer[0x1c2], 3);
1527 DBG(DBG_FNC, "\n0x01c2");
1528 DBG(DBG_FNC, " bit[4..23] = ? : 0x%06x\n", ((iValue >> 8) & 0xffff) + (((iValue >> 4) & 0xf) << 16));
1529
1530 iValue = data_lsb_get(&buffer[0x1c5], 3);
1531 DBG(DBG_FNC, "0x01c5");
1532 DBG(DBG_FNC, " bit[00..19] = ? : 0x%06x\n", iValue & 0xfffff);
1533 DBG(DBG_FNC, " bit[20..23] = ? : 0x%02x\n", (iValue >> 20) & 0xf);
1534
1535 dbg_buffer(DBG_FNC, "\n0x01c8", &buffer[0x1c8], 7, 0x1c8);
1536
1537 iValue = data_lsb_get(&buffer[0x1cf], 3);
1538 DBG(DBG_FNC, "\n0x01cf");
1539 DBG(DBG_FNC, " bit[0] = ? : 0x%02x\n", iValue & 1);
1540 DBG(DBG_FNC, " bit[1] = shading base (0 = 0x4000|1= 0x2000) : 0x%02x\n", (iValue >> 1) & 1);
1541 DBG(DBG_FNC, " bit[2] = white shading correction : 0x%02x\n", (iValue >> 2) & 1);
1542 DBG(DBG_FNC, " bit[3] = black shading correction : 0x%02x\n", (iValue >> 3) & 1);
1543 DBG(DBG_FNC, " bit[4..5] = 0x%02x : ", (iValue >> 4) & 3);
1544 switch ((iValue >> 4) & 3)
1545 {
1546 case 0: DBG(DBG_FNC, "8 bits per channel"); break;
1547 case 1: DBG(DBG_FNC, "12 bits per channel"); break;
1548 case 2: DBG(DBG_FNC, "16 bits per channel"); break;
1549 case 3: DBG(DBG_FNC, "lineart mode"); break;
1550 }
1551 DBG(DBG_FNC, "\n");
1552 DBG(DBG_FNC, " bit[6] = samplerate: 0x%02x ", (iValue >> 6) & 1);
1553 if (((iValue >> 6) & 1) == PIXEL_RATE)
1554 DBG(DBG_FNC, "PIXEL_RATE\n");
1555 else DBG(DBG_FNC, "LINE_RATE\n");
1556 DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
1557
1558 iValue = data_lsb_get(&buffer[0x1d0], 1);
1559 DBG(DBG_FNC, "\n0x01d0");
1560 DBG(DBG_FNC, " bit[0] = 0x%02x\n", iValue & 1);
1561 DBG(DBG_FNC, " bit[1] = 0x%02x\n", (iValue >> 1) & 1);
1562 DBG(DBG_FNC, " bit[2..3] = gamma table size : 0x%02x ", (iValue >> 2) & 3);
1563 switch ((iValue >> 2) & 3)
1564 {
1565 case 0: DBG(DBG_FNC, "bit[0] + 0x100") ;break;
1566 case 1: DBG(DBG_FNC, "bit[0] + 0x400") ;break;
1567 case 2: DBG(DBG_FNC, "bit[0] + 0x1000") ;break;
1568 }
1569 DBG(DBG_FNC, "\n");
1570 DBG(DBG_FNC, " bit[4..5] = ? : 0x%02x\n", (iValue >> 4) & 3);
1571 DBG(DBG_FNC, " bit[6] = use gamma tables? : 0x%02x\n", (iValue >> 6) & 1);
1572 DBG(DBG_FNC, " bit[7] = ? : 0x%02x\n", (iValue >> 7) & 1);
1573
1574 dbg_buffer(DBG_FNC, "\n0x01d1", &buffer[0x1d1], 0x430, 0x1d1);
1575
1576 DBG(DBG_FNC, "----------------------------------------------------\n\n");
1577 */
1578 /*exit(0); */
1579 }
1580 #endif
1581