1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2002, 2004 Frank Zago (sane at zago dot net)
4 Copyright (C) 2002 Other SANE contributors
5
6 This file is part of the SANE package.
7
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2 of the
11 License, or (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>.
20
21 As a special exception, the authors of SANE give permission for
22 additional uses of the libraries contained in this release of SANE.
23
24 The exception is that, if you link a SANE library with other files
25 to produce an executable, this does not by itself cause the
26 resulting executable to be covered by the GNU General Public
27 License. Your use of that executable is in no way restricted on
28 account of linking the SANE library code into it.
29
30 This exception does not, however, invalidate any other reasons why
31 the executable file might be covered by the GNU General Public
32 License.
33
34 If you submit changes to SANE to the maintainers to be included in
35 a subsequent release, you agree by submitting the changes that
36 those changes may be distributed with this exception intact.
37
38 If you write modifications of your own for SANE, it is your choice
39 whether to permit this exception to apply to your modifications.
40 If you do not wish that, delete this exception notice.
41 */
42
43 /*
44 Matsushita/Panasonic KV-SS25, KV-SS50, KV-SS55, KV-SS50EX,
45 KV-SS55EX, KV-SS850, KV-SS855 SCSI scanners.
46
47 This backend may support more Panasonic scanners.
48 */
49
50 /*--------------------------------------------------------------------------*/
51
52 #define BUILD 7 /* 2004-02-11 */
53 #define BACKEND_NAME matsushita
54 #define MATSUSHITA_CONFIG_FILE "matsushita.conf"
55
56 /*--------------------------------------------------------------------------*/
57
58 #include "../include/sane/config.h"
59
60 #include <errno.h>
61 #include <fcntl.h>
62 #include <limits.h>
63 #include <signal.h>
64 #include <stdio.h>
65 #include <stdlib.h>
66 #include <string.h>
67 #include <sys/types.h>
68 #include <sys/wait.h>
69 #include <unistd.h>
70
71 #include "../include/sane/sane.h"
72 #include "../include/sane/sanei.h"
73 #include "../include/sane/saneopts.h"
74 #include "../include/sane/sanei_scsi.h"
75 #include "../include/sane/sanei_debug.h"
76 #include "../include/sane/sanei_backend.h"
77 #include "../include/sane/sanei_config.h"
78 #include "../include/lassert.h"
79
80 #include "matsushita.h"
81
82 /*--------------------------------------------------------------------------*/
83
84 /* Lists of possible scan modes. */
85 static SANE_String_Const scan_mode_list_1[] = {
86 BLACK_WHITE_STR,
87 NULL
88 };
89
90 static SANE_String_Const scan_mode_list_3[] = {
91 BLACK_WHITE_STR,
92 GRAY4_STR,
93 GRAY8_STR,
94 NULL
95 };
96
97 /*--------------------------------------------------------------------------*/
98
99 /* Lists of supported resolutions (in DPI).
100 * 200 DPI scanners are using resolutions_list_200
101 * 300 DPI scanners are using resolutions_list_300
102 * 400 DPI scanners are using resolutions_list_400
103 *
104 * The resolutions_rounds_* lists provide the value with which round
105 * up the X value given by the interface.
106 */
107 #ifdef unused_yet
108 static const SANE_Word resolutions_list_200[4] = {
109 3, 100, 150, 200
110 };
111 static const SANE_Word resolutions_rounds_200[4] = {
112 3, 0x100, 0x40, 0x20
113 };
114 #endif
115
116 static const SANE_Word resolutions_list_300[5] = {
117 4, 150, 200, 240, 300
118 };
119 static const SANE_Word resolutions_rounds_300[5] = {
120 4, 0x100, 0x40, 0x20, 0x80
121 };
122
123 static const SANE_Word resolutions_list_400[8] = {
124 7, 100, 150, 200, 240, 300, 360, 400
125 };
126 static const SANE_Word resolutions_rounds_400[8] = {
127 7, 0x100, 0x100, 0x40, 0x20, 0x80, 0x100, 0x100 /* TO FIX */
128 };
129
130 /*--------------------------------------------------------------------------*/
131
132 /* Lists of supported halftone. They are only valid with
133 * for the Black&White mode. */
134 static SANE_String_Const halftone_pattern_list[] = {
135 SANE_I18N ("None"),
136 SANE_I18N ("Bayer Dither 16"),
137 SANE_I18N ("Bayer Dither 64"),
138 SANE_I18N ("Halftone Dot 32"),
139 SANE_I18N ("Halftone Dot 64"),
140 SANE_I18N ("Error Diffusion"),
141 NULL
142 };
143 static const int halftone_pattern_val[] = {
144 -1,
145 0x01,
146 0x00,
147 0x02,
148 0x03,
149 0x04
150 };
151
152 /*--------------------------------------------------------------------------*/
153
154 /* List of automatic threshold options */
155 static SANE_String_Const automatic_threshold_list[] = {
156 SANE_I18N ("None"),
157 SANE_I18N ("Mode 1"),
158 SANE_I18N ("Mode 2"),
159 SANE_I18N ("Mode 3"),
160 NULL
161 };
162 static const int automatic_threshold_val[] = {
163 0,
164 0x80,
165 0x81,
166 0x82
167 };
168
169 /*--------------------------------------------------------------------------*/
170
171 /* List of white level base. */
172 static SANE_String_Const white_level_list[] = {
173 SANE_I18N ("From white stick"),
174 SANE_I18N ("From paper"),
175 SANE_I18N ("Automatic"),
176 NULL
177 };
178 static const int white_level_val[] = {
179 0x00,
180 0x80,
181 0x81
182 };
183
184 /*--------------------------------------------------------------------------*/
185
186 /* List of noise reduction options. */
187 static SANE_String_Const noise_reduction_list[] = {
188 SANE_I18N ("None"),
189 "1x1",
190 "2x2",
191 "3x3",
192 "4x4",
193 "5x5",
194 NULL
195 };
196 static const int noise_reduction_val[] = {
197 0x00,
198 0x01,
199 0x02,
200 0x03,
201 0x04,
202 0x05
203 };
204
205 /*--------------------------------------------------------------------------*/
206
207 /* List of image emphasis options, 5 steps */
208 static SANE_String_Const image_emphasis_list_5[] = {
209 SANE_I18N ("Smooth"),
210 SANE_I18N ("None"),
211 SANE_I18N ("Low"),
212 SANE_I18N ("Medium"), /* default */
213 SANE_I18N ("High"),
214 NULL
215 };
216 static const int image_emphasis_val_5[] = {
217 0x80,
218 0x00,
219 0x01,
220 0x30,
221 0x50
222 };
223
224 /* List of image emphasis options, 3 steps */
225 static SANE_String_Const image_emphasis_list_3[] = {
226 SANE_I18N ("Low"),
227 SANE_I18N ("Medium"), /* default ? */
228 SANE_I18N ("High"),
229 NULL
230 };
231 static const int image_emphasis_val_3[] = {
232 0x01,
233 0x30,
234 0x50
235 };
236
237 /*--------------------------------------------------------------------------*/
238
239 /* List of gamma */
240 static SANE_String_Const gamma_list[] = {
241 SANE_I18N ("Normal"),
242 SANE_I18N ("CRT"),
243 NULL
244 };
245 static const int gamma_val[] = {
246 0x00,
247 0x01
248 };
249
250 /*--------------------------------------------------------------------------*/
251
252 /* Page feeder options */
253 static SANE_String_Const feeder_mode_list[] = {
254 SANE_I18N ("One page"),
255 SANE_I18N ("All pages"),
256 NULL
257 };
258 static const int feeder_mode_val[] = {
259 0x00,
260 0xff
261 };
262
263 /*--------------------------------------------------------------------------*/
264
265 /* Paper size in millimeters.
266 * Values from http://www.twics.com/~eds/paper/. */
267 static const struct paper_sizes paper_sizes[] = {
268 {"2A0", 1189, 1682},
269 {"4A0", 1682, 2378},
270 {"A0", 841, 1189},
271 {"A1", 594, 841},
272 {"A2", 420, 594},
273 {"A3", 297, 420},
274 {"A4", 210, 297},
275 {"A5", 148, 210},
276 {"A6", 105, 148},
277 {"A7", 74, 105},
278 {"A8", 52, 74},
279 {"A9", 37, 52},
280 {"A10", 26, 37},
281 {"B0", 1000, 1414},
282 {"B1", 707, 1000},
283 {"B2", 500, 707},
284 {"B3", 353, 500},
285 {"B4", 250, 353},
286 {"B5", 176, 250},
287 {"B6", 125, 176},
288 {"B7", 88, 125},
289 {"B8", 62, 88},
290 {"B9", 44, 62},
291 {"B10", 31, 44},
292 {"C0", 917, 1297},
293 {"C1", 648, 917},
294 {"C2", 458, 648},
295 {"C3", 324, 458},
296 {"C4", 229, 324},
297 {"C5", 162, 229},
298 {"C6", 114, 162},
299 {"C7", 81, 114},
300 {"C8", 57, 81},
301 {"C9", 40, 57},
302 {"C10", 28, 40},
303 {"Legal", 8.5 * MM_PER_INCH, 14 * MM_PER_INCH},
304 {"Letter", 8.5 * MM_PER_INCH, 11 * MM_PER_INCH}
305 };
306
307 /*--------------------------------------------------------------------------*/
308
309 /* Define the supported scanners and their characteristics. */
310 static const struct scanners_supported scanners[] = {
311
312 /* Panasonic KV-SS25 */
313 {
314 0x06, "K.M.E. ", "KV-SS25A ",
315 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
316 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
317 {1, 255, 1}, /* brightness range */
318 {1, 255, 1}, /* contrast range */
319 scan_mode_list_3,
320 resolutions_list_300, resolutions_rounds_300,
321 image_emphasis_list_5, image_emphasis_val_5,
322 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
323 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
324 MAT_CAP_NOISE_REDUCTION},
325
326 /* Panasonic KV-SS25D */
327 {
328 0x06, "K.M.E. ", "KV-SS25D ", /* TO FIX */
329 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
330 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
331 {1, 255, 1}, /* brightness range */
332 {1, 255, 1}, /* contrast range */
333 scan_mode_list_3,
334 resolutions_list_300, resolutions_rounds_300,
335 image_emphasis_list_5, image_emphasis_val_5,
336 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
337 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
338 MAT_CAP_NOISE_REDUCTION},
339
340 /* Panasonic KV-SS50 */
341 {
342 0x06, "K.M.E. ", "KV-SS50 ", /* TO FIX */
343 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
344 {SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */
345 {1, 5, 1}, /* brightness range, TO FIX */
346 {0, 0, 0}, /* contrast range */
347 scan_mode_list_1,
348 resolutions_list_300, resolutions_rounds_300, /* TO FIX */
349 image_emphasis_list_3, image_emphasis_val_3,
350 MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE},
351
352 /* Panasonic KV-SS55 */
353 {
354 0x06, "K.M.E. ", "KV-SS55 ", /* TO FIX */
355 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
356 {SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */
357 {1, 5, 1}, /* brightness range, TO FIX */
358 {1, 255, 1}, /* contrast range, TO FIX */
359 scan_mode_list_1,
360 resolutions_list_300, resolutions_rounds_300, /* TO FIX */
361 image_emphasis_list_3, image_emphasis_val_3,
362 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_PAPER_DETECT |
363 MAT_CAP_MIRROR_IMAGE},
364
365 /* Panasonic KV-SS50EX */
366 {
367 0x06, "K.M.E. ", "KV-SS50EX ", /* TO FIX */
368 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
369 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */
370 {1, 255, 1}, /* brightness range */
371 {0, 0, 0}, /* contrast range */
372 scan_mode_list_3,
373 resolutions_list_300, resolutions_rounds_300, /* TO FIX */
374 image_emphasis_list_5, image_emphasis_val_5,
375 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
376 MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE},
377
378 /* Panasonic KV-SS55EX */
379 {
380 0x06, "K.M.E. ", "KV-SS55EX ",
381 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
382 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
383 {1, 255, 1}, /* brightness range */
384 {1, 255, 1}, /* contrast range */
385 scan_mode_list_3,
386 resolutions_list_300, resolutions_rounds_300,
387 image_emphasis_list_5, image_emphasis_val_5,
388 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
389 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
390 MAT_CAP_NOISE_REDUCTION},
391
392 /* Panasonic KV-SS850 */
393 {
394 0x06, "K.M.E. ", "KV-SS850 ", /* TO FIX */
395 {SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
396 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */
397 {1, 255, 1}, /* brightness range */
398 {0, 0, 0}, /* contrast range */
399 scan_mode_list_3,
400 resolutions_list_300, resolutions_rounds_300, /* TO FIX */
401 image_emphasis_list_5, image_emphasis_val_5,
402 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL |
403 MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT |
404 MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED},
405
406 /* Panasonic KV-SS855 */
407 {
408 0x06, "K.M.E. ", "KV-SS855 ", /* TO FIX */
409 {SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
410 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */
411 {1, 255, 1}, /* brightness range */
412 {1, 255, 1}, /* contrast range, TO FIX */
413 scan_mode_list_3,
414 resolutions_list_400, resolutions_rounds_400, /* TO FIX */
415 image_emphasis_list_5, image_emphasis_val_5,
416 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_AUTOMATIC_THRESHOLD |
417 MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION |
418 MAT_CAP_PAPER_DETECT | MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED},
419
420 /* Panasonic KV-S2065L */
421 {
422 0x06, "K.M.E. ", "KV-S2065L ",
423 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
424 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
425 {1, 255, 1}, /* brightness range */
426 {1, 255, 1}, /* contrast range */
427 scan_mode_list_3,
428 resolutions_list_300, resolutions_rounds_300,
429 image_emphasis_list_5, image_emphasis_val_5,
430 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
431 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
432 MAT_CAP_NOISE_REDUCTION},
433
434 /* Panasonic KV-S2025C */
435 {
436 0x06, "K.M.E. ", "KV-S2025C ",
437 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
438 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
439 {1, 255, 1}, /* brightness range */
440 {1, 255, 1}, /* contrast range */
441 scan_mode_list_3,
442 resolutions_list_300, resolutions_rounds_300,
443 image_emphasis_list_5, image_emphasis_val_5,
444 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
445 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
446 MAT_CAP_NOISE_REDUCTION},
447
448 /* Panasonic KV-S2045C */
449 {
450 0x06, "K.M.E. ", "KV-S2045C ",
451 {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */
452 {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */
453 {1, 255, 1}, /* brightness range */
454 {1, 255, 1}, /* contrast range */
455 scan_mode_list_3,
456 resolutions_list_300, resolutions_rounds_300,
457 image_emphasis_list_5, image_emphasis_val_5,
458 MAT_CAP_DUPLEX | MAT_CAP_CONTRAST |
459 MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA |
460 MAT_CAP_NOISE_REDUCTION}
461 };
462
463
464 /*--------------------------------------------------------------------------*/
465
466 /* List of scanner attached. */
467 static Matsushita_Scanner *first_dev = NULL;
468 static int num_devices = 0;
469 static const SANE_Device **devlist = NULL;
470
471
472 /* Local functions. */
473
474 /* Display a buffer in the log. */
475 static void
hexdump(int level, const char *comment, unsigned char *p, int l)476 hexdump (int level, const char *comment, unsigned char *p, int l)
477 {
478 int i;
479 char line[128];
480 char *ptr;
481
482 DBG (level, "%s\n", comment);
483 ptr = line;
484 for (i = 0; i < l; i++, p++)
485 {
486 if ((i % 16) == 0)
487 {
488 if (ptr != line)
489 {
490 *ptr = '\0';
491 DBG (level, "%s\n", line);
492 ptr = line;
493 }
494 sprintf (ptr, "%3.3d:", i);
495 ptr += 4;
496 }
497 sprintf (ptr, " %2.2x", *p);
498 ptr += 3;
499 }
500 *ptr = '\0';
501 DBG (level, "%s\n", line);
502 }
503
504 /* Returns the length of the longest string, including the terminating
505 * character. */
506 static size_t
max_string_size(SANE_String_Const strings[])507 max_string_size (SANE_String_Const strings[])
508 {
509 size_t size, max_size = 0;
510 int i;
511
512 for (i = 0; strings[i]; ++i)
513 {
514 size = strlen (strings[i]) + 1;
515 if (size > max_size)
516 {
517 max_size = size;
518 }
519 }
520
521 return max_size;
522 }
523
524 /* After the windows has been set, issue that command to get the
525 * document size. */
526 static SANE_Status
matsushita_read_document_size(Matsushita_Scanner * dev)527 matsushita_read_document_size (Matsushita_Scanner * dev)
528 {
529 CDB cdb;
530 SANE_Status status;
531 size_t size;
532
533 DBG (DBG_proc, "matsushita_read_document_size: enter\n");
534
535 size = 0x10;
536 MKSCSI_READ_10 (cdb, 0x80, 0, size);
537
538 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
539 NULL, 0, dev->buffer, &size);
540
541 if (status != SANE_STATUS_GOOD || size != 0x10)
542 {
543 DBG (DBG_error,
544 "matsushita_read_document_size: cannot read document size\n");
545 return (SANE_STATUS_IO_ERROR);
546 }
547
548 hexdump (DBG_info2, "document size", dev->buffer, 16);
549
550 /* Check that X and Y are the same values the backend computed. */
551
552 assert (dev->params.lines == B32TOI (&dev->buffer[4]));
553 assert (dev->params.pixels_per_line == B32TOI (&dev->buffer[0]));
554
555 DBG (DBG_proc, "matsushita_read_document_size: exit, %ld bytes read\n",
556 (long)size);
557
558 return (SANE_STATUS_GOOD);
559 }
560
561 /* Initialize a scanner entry. Return an allocated scanner with some
562 * preset values. */
563 static Matsushita_Scanner *
matsushita_init(void)564 matsushita_init (void)
565 {
566 Matsushita_Scanner *dev;
567
568 DBG (DBG_proc, "matsushita_init: enter\n");
569
570 /* Allocate a new scanner entry. */
571 dev = malloc (sizeof (Matsushita_Scanner));
572 if (dev == NULL)
573 {
574 return NULL;
575 }
576
577 memset (dev, 0, sizeof (Matsushita_Scanner));
578
579 /* Allocate the buffer used to transfer the SCSI data. */
580 dev->buffer_size = 64 * 1024;
581 dev->buffer = malloc (dev->buffer_size);
582 if (dev->buffer == NULL)
583 {
584 free (dev);
585 return NULL;
586 }
587
588 /* Allocate a buffer to store the temporary image. */
589 dev->image_size = 64 * 1024; /* enough for 1 line at max res */
590 dev->image = malloc (dev->image_size);
591 if (dev->image == NULL)
592 {
593 free (dev->buffer);
594 free (dev);
595 return NULL;
596 }
597
598 dev->sfd = -1;
599
600 DBG (DBG_proc, "matsushita_init: exit\n");
601
602 return (dev);
603 }
604
605 /* Closes an open scanner. */
606 static void
matsushita_close(Matsushita_Scanner * dev)607 matsushita_close (Matsushita_Scanner * dev)
608 {
609 DBG (DBG_proc, "matsushita_close: enter\n");
610
611 if (dev->sfd != -1)
612 {
613 sanei_scsi_close (dev->sfd);
614 dev->sfd = -1;
615 }
616
617 DBG (DBG_proc, "matsushita_close: exit\n");
618 }
619
620 /* Frees the memory used by a scanner. */
621 static void
matsushita_free(Matsushita_Scanner * dev)622 matsushita_free (Matsushita_Scanner * dev)
623 {
624 int i;
625
626 DBG (DBG_proc, "matsushita_free: enter\n");
627
628 if (dev == NULL)
629 return;
630
631 matsushita_close (dev);
632 if (dev->devicename)
633 {
634 free (dev->devicename);
635 }
636 if (dev->buffer)
637 {
638 free (dev->buffer);
639 }
640 if (dev->image)
641 {
642 free (dev->image);
643 }
644 for (i = 1; i < OPT_NUM_OPTIONS; i++)
645 {
646 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
647 {
648 free (dev->val[i].s);
649 }
650 }
651 free (dev->paper_sizes_list);
652 free (dev->paper_sizes_val);
653
654 free (dev);
655
656 DBG (DBG_proc, "matsushita_free: exit\n");
657 }
658
659 /* Inquiry a device and returns TRUE if is supported. */
660 static int
matsushita_identify_scanner(Matsushita_Scanner * dev)661 matsushita_identify_scanner (Matsushita_Scanner * dev)
662 {
663 CDB cdb;
664 SANE_Status status;
665 size_t size;
666 int i;
667
668 DBG (DBG_proc, "matsushita_identify_scanner: enter\n");
669
670 size = 5;
671 MKSCSI_INQUIRY (cdb, size);
672 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
673 NULL, 0, dev->buffer, &size);
674
675 if (status)
676 {
677 DBG (DBG_error,
678 "matsushita_identify_scanner: inquiry failed with status %s\n",
679 sane_strstatus (status));
680 return (SANE_FALSE);
681 }
682
683 size = dev->buffer[4] + 5; /* total length of the inquiry data */
684
685 if (size < 36)
686 {
687 DBG (DBG_error,
688 "matsushita_identify_scanner: not enough data to identify device\n");
689 return (SANE_FALSE);
690 }
691
692 MKSCSI_INQUIRY (cdb, size);
693 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
694 NULL, 0, dev->buffer, &size);
695
696 if (status)
697 {
698 DBG (DBG_error,
699 "matsushita_identify_scanner: inquiry failed with status %s\n",
700 sane_strstatus (status));
701 return (SANE_FALSE);
702 }
703
704 hexdump (DBG_info2, "inquiry", dev->buffer, size);
705
706 dev->scsi_type = dev->buffer[0] & 0x1f;
707 memcpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
708 dev->scsi_vendor[0x08] = 0;
709 memcpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
710 dev->scsi_product[0x10] = 0;
711 memcpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
712 dev->scsi_version[0x04] = 0;
713
714 DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n",
715 dev->scsi_vendor, dev->scsi_product, dev->scsi_version);
716
717 /* Lookup through the supported scanners table to find if this
718 * backend supports that one. */
719 for (i = 0; i < NELEMS (scanners); i++)
720 {
721 if (dev->scsi_type == scanners[i].scsi_type &&
722 strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 &&
723 strcmp (dev->scsi_product, scanners[i].scsi_product) == 0)
724 {
725
726 DBG (DBG_error, "matsushita_identify_scanner: scanner supported\n");
727
728 dev->scnum = i;
729
730 return (SANE_TRUE);
731 }
732 }
733
734 DBG (DBG_proc, "matsushita_identify_scanner: exit, device not supported\n");
735
736 return (SANE_FALSE);
737 }
738
739 /* The interface can show different paper sizes. Show only the sizes
740 * available for that scanner. */
741 static int
matsushita_build_paper_sizes(Matsushita_Scanner * dev)742 matsushita_build_paper_sizes (Matsushita_Scanner * dev)
743 {
744 SANE_String_Const *psl; /* string list */
745 int *psv; /* value list */
746 int num;
747 int i;
748
749 DBG (DBG_proc, "matsushita_build_paper_sizes: enter\n");
750
751 psl = malloc ((sizeof (SANE_String_Const) + 1) * NELEMS (paper_sizes));
752 if (psl == NULL)
753 {
754 DBG (DBG_error, "ERROR: not enough memory\n");
755 return SANE_STATUS_NO_MEM;
756 }
757
758 psv = malloc ((sizeof (int) + 1) * NELEMS (paper_sizes));
759 if (psv == NULL)
760 {
761 DBG (DBG_error, "ERROR: not enough memory\n");
762 free (psl);
763 return SANE_STATUS_NO_MEM;
764 }
765
766 for (i = 0, num = 0; i < NELEMS (paper_sizes); i++)
767 {
768 if (SANE_UNFIX (scanners[dev->scnum].x_range.max) >=
769 paper_sizes[i].width
770 && SANE_UNFIX (scanners[dev->scnum].y_range.max) >=
771 paper_sizes[i].length)
772 {
773
774 /* This paper size fits into the scanner. */
775 psl[num] = paper_sizes[i].name;
776 psv[num] = i;
777 num++;
778 }
779 }
780 psl[num] = NULL; /* terminate the list */
781
782 dev->paper_sizes_list = psl;
783 dev->paper_sizes_val = psv;
784
785 DBG (DBG_proc, "matsushita_build_paper_sizes: exit (%d)\n", num);
786
787 return SANE_STATUS_GOOD;
788 }
789
790 /* Lookup a string list from one array and return its index. */
791 static int
get_string_list_index(SANE_String_Const list[], SANE_String_Const name)792 get_string_list_index (SANE_String_Const list[], SANE_String_Const name)
793 {
794 int index;
795
796 index = 0;
797 while (list[index] != NULL)
798 {
799 if (strcmp (list[index], name) == 0)
800 {
801 return (index);
802 }
803 index++;
804 }
805
806 DBG (DBG_error, "name %s not found in list\n", name);
807
808 assert (0 == 1); /* bug in backend, core dump */
809
810 return (-1);
811 }
812
813 /* Lookup an int list from one array and return its index. */
814 static int
get_int_list_index(const SANE_Word list[], const SANE_Word value)815 get_int_list_index (const SANE_Word list[], const SANE_Word value)
816 {
817 int index;
818 int size; /* number of elements */
819
820 index = 1;
821 size = list[0];
822 while (index <= size)
823 {
824 if (list[index] == value)
825 {
826 return (index);
827 }
828 index++;
829 }
830
831 DBG (DBG_error, "word %d not found in list\n", value);
832
833 assert (0 == 1); /* bug in backend, core dump */
834
835 return (-1);
836 }
837
838 /* SCSI sense handler. Callback for SANE. */
839 static SANE_Status
matsushita_sense_handler(int scsi_fd, unsigned char *result, void __sane_unused__ *arg)840 matsushita_sense_handler (int scsi_fd, unsigned char *result, void __sane_unused__ *arg)
841 {
842 int asc, ascq, sensekey;
843 int len;
844
845 DBG (DBG_proc, "matsushita_sense_handler (scsi_fd = %d)\n", scsi_fd);
846
847 sensekey = get_RS_sense_key (result);
848 len = 7 + get_RS_additional_length (result);
849
850 hexdump (DBG_info2, "sense", result, len);
851
852 if (get_RS_error_code (result) != 0x70)
853 {
854 DBG (DBG_error,
855 "matsushita_sense_handler: invalid sense key error code (%d)\n",
856 get_RS_error_code (result));
857
858 return SANE_STATUS_IO_ERROR;
859 }
860
861 if (get_RS_ILI (result) != 0)
862 {
863 DBG (DBG_sense, "matsushita_sense_handler: short read\n");
864 }
865
866 if (len < 14)
867 {
868 DBG (DBG_error,
869 "matsushita_sense_handler: sense too short, no ASC/ASCQ\n");
870
871 return SANE_STATUS_IO_ERROR;
872 }
873
874 asc = get_RS_ASC (result);
875 ascq = get_RS_ASCQ (result);
876
877 DBG (DBG_sense, "matsushita_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n",
878 sensekey, asc, ascq);
879
880 switch (sensekey)
881 {
882 case 0x00: /* no sense */
883 if (get_RS_EOM (result) && asc == 0x00 && ascq == 0x00)
884 {
885 DBG (DBG_sense, "matsushita_sense_handler: EOF\n");
886 return SANE_STATUS_EOF;
887 }
888
889 return SANE_STATUS_GOOD;
890 break;
891
892 case 0x02: /* not ready */
893 if (asc == 0x04 && ascq == 0x81)
894 {
895 /* Jam door open. */
896 return SANE_STATUS_COVER_OPEN;
897 }
898 break;
899
900 case 0x03: /* medium error */
901 if (asc == 0x3a)
902 {
903 /* No paper in the feeder. */
904 return SANE_STATUS_NO_DOCS;
905 }
906 if (asc == 0x80)
907 {
908 /* Probably a paper jam. ascq might give more info. */
909 return SANE_STATUS_JAMMED;
910 }
911 break;
912
913 case 0x05:
914 if (asc == 0x20 || asc == 0x24 || asc == 0x26)
915 {
916 /* Invalid command, invalid field in CDB or invalid field in data.
917 * The backend has prepared some wrong combination of options.
918 * Shot the backend maintainer. */
919 return SANE_STATUS_IO_ERROR;
920 }
921 else if (asc == 0x2c && ascq == 0x80)
922 {
923 /* The scanner does have enough memory to scan the whole
924 * area. For instance the KV-SS25 has only 4MB of memory,
925 * which is not enough to scan a A4 page at 300dpi in gray
926 * 8 bits. */
927 return SANE_STATUS_NO_MEM;
928 }
929 break;
930
931 case 0x06:
932 if (asc == 0x29)
933 {
934 /* Reset occurred. May be the backend should retry the
935 * command. */
936 return SANE_STATUS_GOOD;
937 }
938 break;
939 }
940
941 DBG (DBG_sense,
942 "matsushita_sense_handler: unknown error condition. Please report it to the backend maintainer\n");
943
944 return SANE_STATUS_IO_ERROR;
945 }
946
947 /* Check that a new page is available by issuing an empty read. The
948 * sense handler might return SANE_STATUS_NO_DOCS which indicates that
949 * the feeder is now empty. */
950 static SANE_Status
matsushita_check_next_page(Matsushita_Scanner * dev)951 matsushita_check_next_page (Matsushita_Scanner * dev)
952 {
953 CDB cdb;
954 SANE_Status status;
955
956 DBG (DBG_proc, "matsushita_check_next_page: enter\n");
957
958 MKSCSI_READ_10 (cdb, 0, 0, 0);
959 cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */
960 cdb.data[5] = dev->page_side;
961
962 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
963
964 DBG (DBG_proc, "matsushita_check_next_page: exit with status %d\n", status);
965
966 return (status);
967 }
968
969 /* Attach a scanner to this backend. */
970 static SANE_Status
attach_scanner(const char *devicename, Matsushita_Scanner ** devp)971 attach_scanner (const char *devicename, Matsushita_Scanner ** devp)
972 {
973 Matsushita_Scanner *dev;
974 int sfd;
975
976 DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename);
977
978 if (devp)
979 *devp = NULL;
980
981 /* Check if we know this device name. */
982 for (dev = first_dev; dev; dev = dev->next)
983 {
984 if (strcmp (dev->sane.name, devicename) == 0)
985 {
986 if (devp)
987 {
988 *devp = dev;
989 }
990 DBG (DBG_info, "device is already known\n");
991 return SANE_STATUS_GOOD;
992 }
993 }
994
995 /* Allocate a new scanner entry. */
996 dev = matsushita_init ();
997 if (dev == NULL)
998 {
999 DBG (DBG_error, "ERROR: not enough memory\n");
1000 return SANE_STATUS_NO_MEM;
1001 }
1002
1003 DBG (DBG_info, "attach_scanner: opening %s\n", devicename);
1004
1005 if (sanei_scsi_open (devicename, &sfd, matsushita_sense_handler, dev) != 0)
1006 {
1007 DBG (DBG_error, "ERROR: attach_scanner: open failed\n");
1008 matsushita_free (dev);
1009 return SANE_STATUS_INVAL;
1010 }
1011
1012 /* Fill some scanner specific values. */
1013 dev->devicename = strdup (devicename);
1014 dev->sfd = sfd;
1015
1016 /* Now, check that it is a scanner we support. */
1017 if (matsushita_identify_scanner (dev) == SANE_FALSE)
1018 {
1019 DBG (DBG_error,
1020 "ERROR: attach_scanner: scanner-identification failed\n");
1021 matsushita_free (dev);
1022 return SANE_STATUS_INVAL;
1023 }
1024
1025 matsushita_close (dev);
1026
1027 /* Set the default options for that scanner. */
1028 dev->sane.name = dev->devicename;
1029 dev->sane.vendor = "Panasonic";
1030 dev->sane.model = dev->scsi_product;
1031 dev->sane.type = SANE_I18N ("sheetfed scanner");
1032
1033 /* Link the scanner with the others. */
1034 dev->next = first_dev;
1035 first_dev = dev;
1036
1037 if (devp)
1038 {
1039 *devp = dev;
1040 }
1041
1042 num_devices++;
1043
1044 DBG (DBG_proc, "attach_scanner: exit\n");
1045
1046 return SANE_STATUS_GOOD;
1047 }
1048
1049 static SANE_Status
attach_one(const char *dev)1050 attach_one (const char *dev)
1051 {
1052 attach_scanner (dev, NULL);
1053 return SANE_STATUS_GOOD;
1054 }
1055
1056 /* Reset the options for that scanner. */
1057 static void
matsushita_init_options(Matsushita_Scanner * dev)1058 matsushita_init_options (Matsushita_Scanner * dev)
1059 {
1060 int i;
1061
1062 /* Pre-initialize the options. */
1063 memset (dev->opt, 0, sizeof (dev->opt));
1064 memset (dev->val, 0, sizeof (dev->val));
1065
1066 for (i = 0; i < OPT_NUM_OPTIONS; ++i)
1067 {
1068 dev->opt[i].size = sizeof (SANE_Word);
1069 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1070 }
1071
1072 /* Number of options. */
1073 dev->opt[OPT_NUM_OPTS].name = "";
1074 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
1075 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
1076 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
1077 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
1078 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
1079
1080 /* Mode group */
1081 dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
1082 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
1083 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
1084 dev->opt[OPT_MODE_GROUP].cap = 0;
1085 dev->opt[OPT_MODE_GROUP].size = 0;
1086 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1087
1088 /* Scanner supported modes */
1089 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
1090 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
1091 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
1092 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
1093 dev->opt[OPT_MODE].size =
1094 max_string_size (scanners[dev->scnum].scan_mode_list);
1095 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1096 dev->opt[OPT_MODE].constraint.string_list =
1097 scanners[dev->scnum].scan_mode_list;
1098 dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
1099
1100 /* X and Y resolution */
1101 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
1102 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
1103 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1104 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
1105 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
1106 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
1107 dev->opt[OPT_RESOLUTION].constraint.word_list =
1108 scanners[dev->scnum].resolutions_list;
1109 dev->val[OPT_RESOLUTION].w = resolutions_list_300[1];
1110
1111 /* Duplex */
1112 dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX;
1113 dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX;
1114 dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX;
1115 dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL;
1116 dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE;
1117 dev->val[OPT_DUPLEX].w = SANE_FALSE;
1118 if ((scanners[dev->scnum].cap & MAT_CAP_DUPLEX) == 0)
1119 dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE;
1120
1121 /* Feeder mode */
1122 dev->opt[OPT_FEEDER_MODE].name = "feeder-mode";
1123 dev->opt[OPT_FEEDER_MODE].title = SANE_I18N ("Feeder mode");
1124 dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N ("Sets the feeding mode");
1125 dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING;
1126 dev->opt[OPT_FEEDER_MODE].size = max_string_size (feeder_mode_list);
1127 dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1128 dev->opt[OPT_FEEDER_MODE].constraint.string_list = feeder_mode_list;
1129 dev->val[OPT_FEEDER_MODE].s = strdup (feeder_mode_list[0]);
1130
1131 /* Geometry group */
1132 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
1133 dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
1134 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
1135 dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
1136 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
1137 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1138
1139 /* Paper sizes list. */
1140 dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE;
1141 dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE;
1142 dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE;
1143 dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING;
1144 dev->opt[OPT_PAPER_SIZE].size = max_string_size (dev->paper_sizes_list);
1145 dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1146 dev->opt[OPT_PAPER_SIZE].constraint.string_list = dev->paper_sizes_list;
1147 dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will do it later */
1148
1149 /* Upper left X */
1150 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
1151 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
1152 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
1153 dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
1154 dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
1155 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
1156 dev->opt[OPT_TL_X].constraint.range = &(scanners[dev->scnum].x_range);
1157
1158 /* Upper left Y */
1159 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
1160 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
1161 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
1162 dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
1163 dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
1164 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1165 dev->opt[OPT_TL_Y].constraint.range = &(scanners[dev->scnum].y_range);
1166
1167 /* Bottom-right x */
1168 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
1169 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
1170 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
1171 dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
1172 dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
1173 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
1174 dev->opt[OPT_BR_X].constraint.range = &(scanners[dev->scnum].x_range);
1175
1176 /* Bottom-right y */
1177 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
1178 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
1179 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
1180 dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
1181 dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
1182 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1183 dev->opt[OPT_BR_Y].constraint.range = &(scanners[dev->scnum].y_range);
1184
1185 /* Enhancement group */
1186 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
1187 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
1188 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
1189 dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
1190 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
1191 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1192
1193 /* Brightness */
1194 dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
1195 dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
1196 dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
1197 dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
1198 dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
1199 dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int);
1200 dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
1201 dev->opt[OPT_BRIGHTNESS].constraint.range =
1202 &(scanners[dev->scnum].brightness_range);
1203 dev->val[OPT_BRIGHTNESS].w = 128;
1204
1205 /* Contrast */
1206 dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
1207 dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
1208 dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
1209 dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
1210 dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
1211 dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int);
1212 dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
1213 dev->opt[OPT_CONTRAST].constraint.range =
1214 &(scanners[dev->scnum].contrast_range);
1215 dev->val[OPT_CONTRAST].w = 128;
1216 if ((scanners[dev->scnum].cap & MAT_CAP_CONTRAST) == 0)
1217 dev->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
1218
1219 /* Automatic threshold */
1220 dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold";
1221 dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N ("Automatic threshold");
1222 dev->opt[OPT_AUTOMATIC_THRESHOLD].desc =
1223 SANE_I18N
1224 ("Automatically sets brightness, contrast, white level, gamma, noise reduction and image emphasis");
1225 dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING;
1226 dev->opt[OPT_AUTOMATIC_THRESHOLD].size =
1227 max_string_size (automatic_threshold_list);
1228 dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type =
1229 SANE_CONSTRAINT_STRING_LIST;
1230 dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list =
1231 automatic_threshold_list;
1232 dev->val[OPT_AUTOMATIC_THRESHOLD].s = strdup (automatic_threshold_list[0]);
1233 if ((scanners[dev->scnum].cap & MAT_CAP_AUTOMATIC_THRESHOLD) == 0)
1234 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE;
1235
1236 /* Halftone pattern */
1237 dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
1238 dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
1239 dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
1240 dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
1241 dev->opt[OPT_HALFTONE_PATTERN].size =
1242 max_string_size (halftone_pattern_list);
1243 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
1244 dev->opt[OPT_HALFTONE_PATTERN].constraint_type =
1245 SANE_CONSTRAINT_STRING_LIST;
1246 dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
1247 halftone_pattern_list;
1248 dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
1249
1250 /* Automatic separation */
1251 dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP;
1252 dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP;
1253 dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP;
1254 dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL;
1255 dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE;
1256 dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE;
1257
1258 /* White level base */
1259 dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL;
1260 dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL;
1261 dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL;
1262 dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING;
1263 dev->opt[OPT_WHITE_LEVEL].size = max_string_size (white_level_list);
1264 dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1265 dev->opt[OPT_WHITE_LEVEL].constraint.string_list = white_level_list;
1266 dev->val[OPT_WHITE_LEVEL].s = strdup (white_level_list[0]);
1267 if ((scanners[dev->scnum].cap & MAT_CAP_WHITE_LEVEL) == 0)
1268 dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE;
1269
1270 /* Noise reduction */
1271 dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction";
1272 dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N ("Noise reduction");
1273 dev->opt[OPT_NOISE_REDUCTION].desc =
1274 SANE_I18N ("Reduce the isolated dot noise");
1275 dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING;
1276 dev->opt[OPT_NOISE_REDUCTION].size = max_string_size (noise_reduction_list);
1277 dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1278 dev->opt[OPT_NOISE_REDUCTION].constraint.string_list = noise_reduction_list;
1279 dev->val[OPT_NOISE_REDUCTION].s = strdup (noise_reduction_list[0]);
1280 if ((scanners[dev->scnum].cap & MAT_CAP_NOISE_REDUCTION) == 0)
1281 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
1282
1283 /* Image emphasis */
1284 dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis";
1285 dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N ("Image emphasis");
1286 dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N ("Sets the image emphasis");
1287 dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING;
1288 dev->opt[OPT_IMAGE_EMPHASIS].size =
1289 max_string_size (scanners[dev->scnum].image_emphasis_list);
1290 dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1291 dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list =
1292 scanners[dev->scnum].image_emphasis_list;
1293 dev->val[OPT_IMAGE_EMPHASIS].s = strdup (SANE_I18N ("Medium"));
1294
1295 /* Gamma */
1296 dev->opt[OPT_GAMMA].name = "gamma";
1297 dev->opt[OPT_GAMMA].title = SANE_I18N ("Gamma");
1298 dev->opt[OPT_GAMMA].desc = SANE_I18N ("Gamma");
1299 dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
1300 dev->opt[OPT_GAMMA].size = max_string_size (gamma_list);
1301 dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1302 dev->opt[OPT_GAMMA].constraint.string_list = gamma_list;
1303 dev->val[OPT_GAMMA].s = strdup (gamma_list[0]);
1304
1305 /* Lastly, set the default scan mode. This might change some
1306 * values previously set here. */
1307 sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE,
1308 (SANE_String_Const *) dev->paper_sizes_list[0], NULL);
1309 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
1310 (SANE_String_Const *) scanners[dev->scnum].
1311 scan_mode_list[0], NULL);
1312 }
1313
1314 /* Wait until the scanner is ready.
1315 *
1316 * The only reason I know the scanner is not ready is because it is
1317 * moving the CCD.
1318 */
1319 static SANE_Status
matsushita_wait_scanner(Matsushita_Scanner * dev)1320 matsushita_wait_scanner (Matsushita_Scanner * dev)
1321 {
1322 SANE_Status status;
1323 int timeout;
1324 CDB cdb;
1325
1326 DBG (DBG_proc, "matsushita_wait_scanner: enter\n");
1327
1328 MKSCSI_TEST_UNIT_READY (cdb);
1329
1330 /* Set the timeout to 60 seconds. */
1331 timeout = 60;
1332
1333 while (timeout > 0)
1334 {
1335
1336 /* test unit ready */
1337 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1338 NULL, 0, NULL, NULL);
1339
1340 if (status == SANE_STATUS_GOOD)
1341 {
1342 return SANE_STATUS_GOOD;
1343 }
1344
1345 sleep (1);
1346 };
1347
1348 DBG (DBG_proc, "matsushita_wait_scanner: scanner not ready\n");
1349 return (SANE_STATUS_IO_ERROR);
1350 }
1351
1352 /* Reset a window. This is used to re-initialize the scanner. */
1353 static SANE_Status
matsushita_reset_window(Matsushita_Scanner * dev)1354 matsushita_reset_window (Matsushita_Scanner * dev)
1355 {
1356 CDB cdb;
1357 SANE_Status status;
1358
1359 DBG (DBG_proc, "matsushita_reset_window: enter\n");
1360
1361 MKSCSI_SET_WINDOW (cdb, 0);
1362
1363 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
1364
1365 DBG (DBG_proc, "matsushita_reset_window: exit, status=%d\n", status);
1366
1367 return status;
1368 }
1369
1370 /* Set a window. */
1371 static SANE_Status
matsushita_set_window(Matsushita_Scanner * dev, int side)1372 matsushita_set_window (Matsushita_Scanner * dev, int side)
1373 {
1374 size_t size;
1375 CDB cdb;
1376 unsigned char window[72];
1377 SANE_Status status;
1378 int i;
1379
1380 DBG (DBG_proc, "matsushita_set_window: enter\n");
1381
1382 size = sizeof (window);
1383 MKSCSI_SET_WINDOW (cdb, size);
1384
1385 memset (window, 0, size);
1386
1387 /* size of the windows descriptor block */
1388 window[7] = sizeof (window) - 8;
1389
1390 /* Page side */
1391 window[8] = side;
1392
1393 /* X and Y resolution */
1394 Ito16 (dev->resolution, &window[10]);
1395 Ito16 (dev->resolution, &window[12]);
1396
1397 /* Upper Left (X,Y) */
1398 Ito32 (dev->x_tl, &window[14]);
1399 Ito32 (dev->y_tl, &window[18]);
1400
1401 /* Width and length */
1402 Ito32 (dev->width, &window[22]);
1403 Ito32 (dev->length, &window[26]);
1404 Ito32 (dev->width, &window[56]); /* again, verso? */
1405 Ito32 (dev->length, &window[60]); /* again, verso? */
1406
1407 /* Brightness */
1408 window[30] = 255 - dev->val[OPT_BRIGHTNESS].w;
1409 window[31] = window[30]; /* same as brightness. */
1410
1411 /* Contrast */
1412 window[32] = dev->val[OPT_CONTRAST].w;
1413
1414 /* Image Composition */
1415 switch (dev->scan_mode)
1416 {
1417 case MATSUSHITA_BW:
1418 window[33] = 0x00;
1419 break;
1420 case MATSUSHITA_HALFTONE:
1421 window[33] = 0x01;
1422 break;
1423 case MATSUSHITA_GRAYSCALE:
1424 window[33] = 0x02;
1425 break;
1426 }
1427
1428 /* Depth */
1429 window[34] = dev->depth;
1430
1431 /* Halftone pattern. */
1432 if (dev->scan_mode == MATSUSHITA_HALFTONE)
1433 {
1434 i = get_string_list_index (halftone_pattern_list,
1435 dev->val[OPT_HALFTONE_PATTERN].s);
1436 window[36] = halftone_pattern_val[i];
1437 }
1438
1439 /* Gamma */
1440 if (dev->scan_mode == MATSUSHITA_GRAYSCALE)
1441 {
1442 i = get_string_list_index (gamma_list, dev->val[OPT_GAMMA].s);
1443 window[52] = gamma_val[i];
1444 }
1445
1446 /* Feeder mode */
1447 i = get_string_list_index (feeder_mode_list, dev->val[OPT_FEEDER_MODE].s);
1448 window[65] = feeder_mode_val[i];
1449
1450 /* Image emphasis */
1451 i = get_string_list_index (scanners[dev->scnum].image_emphasis_list,
1452 dev->val[OPT_IMAGE_EMPHASIS].s);
1453 window[51] = scanners[dev->scnum].image_emphasis_val[i];
1454
1455 /* White level */
1456 i = get_string_list_index (white_level_list, dev->val[OPT_WHITE_LEVEL].s);
1457 window[68] = white_level_val[i];
1458
1459 if (dev->scan_mode == MATSUSHITA_BW ||
1460 dev->scan_mode == MATSUSHITA_HALFTONE)
1461 {
1462
1463 /* Noise reduction */
1464 i = get_string_list_index (noise_reduction_list,
1465 dev->val[OPT_NOISE_REDUCTION].s);
1466 window[69] = noise_reduction_val[i];
1467
1468 /* Automatic separation */
1469 if (dev->val[OPT_AUTOMATIC_SEPARATION].w)
1470 {
1471 window[67] = 0x80;
1472 }
1473
1474 /* Automatic threshold. Must be last because it may override
1475 * some previous options. */
1476 i = get_string_list_index (automatic_threshold_list,
1477 dev->val[OPT_AUTOMATIC_THRESHOLD].s);
1478 window[66] = automatic_threshold_val[i];
1479
1480 if (automatic_threshold_val[i] != 0)
1481 {
1482 /* Automatic threshold is enabled. */
1483 window[30] = 0; /* brightness. */
1484 window[31] = 0; /* same as brightness. */
1485 window[32] = 0; /* contrast */
1486 window[33] = 0; /* B&W mode */
1487 window[36] = 0; /* Halftone pattern. */
1488 window[51] = 0; /* Image emphasis */
1489 window[67] = 0; /* Automatic separation */
1490 window[68] = 0; /* White level */
1491 window[69] = 0; /* Noise reduction */
1492 }
1493 }
1494
1495 hexdump (DBG_info2, "windows", window, 72);
1496
1497 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1498 window, sizeof (window), NULL, NULL);
1499
1500 DBG (DBG_proc, "matsushita_set_window: exit, status=%d\n", status);
1501
1502 return status;
1503 }
1504
1505 /* Read the image from the scanner and fill the temporary buffer with it. */
1506 static SANE_Status
matsushita_fill_image(Matsushita_Scanner * dev)1507 matsushita_fill_image (Matsushita_Scanner * dev)
1508 {
1509 SANE_Status status;
1510 size_t size;
1511 CDB cdb;
1512
1513 DBG (DBG_proc, "matsushita_fill_image: enter\n");
1514
1515 assert (dev->image_begin == dev->image_end);
1516 assert (dev->real_bytes_left > 0);
1517
1518 dev->image_begin = 0;
1519 dev->image_end = 0;
1520
1521 while (dev->real_bytes_left)
1522 {
1523
1524 /*
1525 * Try to read the maximum number of bytes.
1526 *
1527 * The windows driver reads no more than 0x8000 byte.
1528 *
1529 * This backend operates differently than the windows
1530 * driver. The windows TWAIN driver always read 2 more bytes
1531 * at the end, so it gets a CHECK CONDITION with a short read
1532 * sense. Since the linux scsi layer seem to be buggy
1533 * regarding the resid, always read exactly the number of
1534 * remaining bytes.
1535 */
1536
1537 size = dev->real_bytes_left;
1538 if (size > dev->image_size - dev->image_end)
1539 size = dev->image_size - dev->image_end;
1540 if (size > 0x8000)
1541 size = 0x8000;
1542
1543 if (size == 0)
1544 {
1545 /* Probably reached the end of the buffer.
1546 * Check, just in case. */
1547 assert (dev->image_end != 0);
1548 return (SANE_STATUS_GOOD);
1549 }
1550
1551 DBG (DBG_info, "sane_read: to read = %ld bytes (bpl=%d)\n",
1552 (long) size, dev->params.bytes_per_line);
1553
1554 MKSCSI_READ_10 (cdb, 0, 0, size);
1555 cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */
1556 cdb.data[5] = dev->page_side;
1557
1558 hexdump (DBG_info2, "sane_read: READ_10 CDB", cdb.data, 10);
1559
1560 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1561 NULL, 0, dev->buffer, &size);
1562
1563 if (status == SANE_STATUS_EOF)
1564 {
1565 DBG (DBG_proc, "sane_read: exit, end of page scan\n");
1566 return (SANE_STATUS_EOF);
1567 }
1568
1569 if (status != SANE_STATUS_GOOD)
1570 {
1571 DBG (DBG_error, "sane_read: cannot read from the scanner\n");
1572 return status;
1573 }
1574
1575 dev->real_bytes_left -= size;
1576
1577 switch (dev->depth)
1578 {
1579 case 1:
1580 {
1581 /* For Black & White, the bits in every bytes are mirrored.
1582 * for instance 11010001 is coded as 10001011 */
1583
1584 unsigned char *src = dev->buffer;
1585 unsigned char *dest = dev->image + dev->image_end;
1586 unsigned char s;
1587 unsigned char d;
1588
1589 size_t i;
1590
1591 for (i = 0; i < size; i++)
1592 {
1593 s = *src;
1594 d = 0;
1595 if (s & 0x01)
1596 d |= 0x80;
1597 if (s & 0x02)
1598 d |= 0x40;
1599 if (s & 0x04)
1600 d |= 0x20;
1601 if (s & 0x08)
1602 d |= 0x10;
1603 if (s & 0x10)
1604 d |= 0x08;
1605 if (s & 0x20)
1606 d |= 0x04;
1607 if (s & 0x40)
1608 d |= 0x02;
1609 if (s & 0x80)
1610 d |= 0x01;
1611 *dest = d;
1612 src++;
1613 dest++;
1614 }
1615 }
1616 break;
1617
1618 case 4:
1619 {
1620 /* Adjust from a depth of 4 bits ([0..15]) to
1621 * a depth of 8 bits ([0..255]) */
1622
1623 unsigned char *src = dev->buffer;
1624 unsigned char *dest = dev->image + dev->image_end;
1625 size_t i;
1626
1627 /* n bytes from image --> 2*n bytes in buf. */
1628
1629 for (i = 0; i < size; i++)
1630 {
1631 *dest = ((*src & 0x0f) >> 0) * 17;
1632 dest++;
1633 *dest = ((*src & 0xf0) >> 4) * 17;
1634 dest++;
1635 src++;
1636 }
1637
1638 size *= 2;
1639 }
1640 break;
1641
1642 default:
1643 memcpy (dev->image + dev->image_end, dev->buffer, size);
1644 break;
1645 }
1646
1647 dev->image_end += size;
1648
1649 }
1650
1651 return (SANE_STATUS_GOOD); /* unreachable */
1652 }
1653
1654 /* Copy from the raw buffer to the buffer given by the backend.
1655 *
1656 * len in input is the maximum length available in buf, and, in
1657 * output, is the length written into buf.
1658 */
1659 static void
matsushita_copy_raw_to_frontend(Matsushita_Scanner * dev, SANE_Byte * buf, size_t * len)1660 matsushita_copy_raw_to_frontend (Matsushita_Scanner * dev, SANE_Byte * buf,
1661 size_t * len)
1662 {
1663 size_t size;
1664
1665 size = dev->image_end - dev->image_begin;
1666 if (size > *len)
1667 {
1668 size = *len;
1669 }
1670 *len = size;
1671
1672 memcpy (buf, dev->image + dev->image_begin, size);
1673 dev->image_begin += size;
1674 }
1675
1676 /* Stop a scan. */
1677 static SANE_Status
do_cancel(Matsushita_Scanner * dev)1678 do_cancel (Matsushita_Scanner * dev)
1679 {
1680 DBG (DBG_sane_proc, "do_cancel enter\n");
1681
1682 if (dev->scanning == SANE_TRUE)
1683 {
1684
1685 /* Reset the scanner */
1686 matsushita_reset_window (dev);
1687
1688 matsushita_close (dev);
1689 }
1690
1691 dev->scanning = SANE_FALSE;
1692
1693 DBG (DBG_sane_proc, "do_cancel exit\n");
1694
1695 return SANE_STATUS_CANCELLED;
1696 }
1697
1698 /*--------------------------------------------------------------------------*/
1699
1700 /* Entry points */
1701
1702 SANE_Status
sane_init(SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize)1703 sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize)
1704 {
1705 FILE *fp;
1706 char dev_name[PATH_MAX];
1707 size_t len;
1708
1709 DBG_INIT ();
1710
1711 DBG (DBG_sane_init, "sane_init\n");
1712
1713 DBG (DBG_error, "This is sane-matsushita version %d.%d-%d\n", SANE_CURRENT_MAJOR,
1714 SANE_CURRENT_MINOR, BUILD);
1715 DBG (DBG_error, "(C) 2002 by Frank Zago\n");
1716
1717 if (version_code)
1718 {
1719 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD);
1720 }
1721
1722 fp = sanei_config_open (MATSUSHITA_CONFIG_FILE);
1723 if (!fp)
1724 {
1725 /* default to /dev/scanner instead of insisting on config file */
1726 attach_scanner ("/dev/scanner", 0);
1727 return SANE_STATUS_GOOD;
1728 }
1729
1730 while (sanei_config_read (dev_name, sizeof (dev_name), fp))
1731 {
1732 if (dev_name[0] == '#') /* ignore line comments */
1733 continue;
1734 len = strlen (dev_name);
1735
1736 if (!len)
1737 continue; /* ignore empty lines */
1738
1739 sanei_config_attach_matching_devices (dev_name, attach_one);
1740 }
1741
1742 fclose (fp);
1743
1744 DBG (DBG_proc, "sane_init: leave\n");
1745
1746 return SANE_STATUS_GOOD;
1747 }
1748
1749 SANE_Status
sane_get_devices(const SANE_Device *** device_list, SANE_Bool __sane_unused__ local_only)1750 sane_get_devices (const SANE_Device *** device_list, SANE_Bool __sane_unused__ local_only)
1751 {
1752 Matsushita_Scanner *dev;
1753 int i;
1754
1755 DBG (DBG_proc, "sane_get_devices: enter\n");
1756
1757 if (devlist)
1758 free (devlist);
1759
1760 devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
1761 if (!devlist)
1762 return SANE_STATUS_NO_MEM;
1763
1764 i = 0;
1765 for (dev = first_dev; i < num_devices; dev = dev->next)
1766 devlist[i++] = &dev->sane;
1767 devlist[i++] = 0;
1768
1769 *device_list = devlist;
1770
1771 DBG (DBG_proc, "sane_get_devices: exit\n");
1772
1773 return SANE_STATUS_GOOD;
1774 }
1775
1776 SANE_Status
sane_open(SANE_String_Const devicename, SANE_Handle * handle)1777 sane_open (SANE_String_Const devicename, SANE_Handle * handle)
1778 {
1779 Matsushita_Scanner *dev;
1780 SANE_Status status;
1781
1782 DBG (DBG_proc, "sane_open: enter\n");
1783
1784 /* search for devicename */
1785 if (devicename[0])
1786 {
1787 DBG (DBG_info, "sane_open: devicename=%s\n", devicename);
1788
1789 for (dev = first_dev; dev; dev = dev->next)
1790 {
1791 if (strcmp (dev->sane.name, devicename) == 0)
1792 {
1793 break;
1794 }
1795 }
1796
1797 if (!dev)
1798 {
1799 status = attach_scanner (devicename, &dev);
1800 if (status != SANE_STATUS_GOOD)
1801 {
1802 return status;
1803 }
1804 }
1805 }
1806 else
1807 {
1808 DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n");
1809 dev = first_dev; /* empty devicename -> use first device */
1810 }
1811
1812 if (!dev)
1813 {
1814 DBG (DBG_error, "No scanner found\n");
1815
1816 return SANE_STATUS_INVAL;
1817 }
1818
1819 /* Build a list a paper size that fit into this scanner. */
1820 matsushita_build_paper_sizes (dev);
1821
1822 matsushita_init_options (dev);
1823
1824 *handle = dev;
1825
1826 DBG (DBG_proc, "sane_open: exit\n");
1827
1828 return SANE_STATUS_GOOD;
1829 }
1830
1831 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)1832 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
1833 {
1834 Matsushita_Scanner *dev = handle;
1835
1836 DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option);
1837
1838 if ((unsigned) option >= OPT_NUM_OPTIONS)
1839 {
1840 return NULL;
1841 }
1842
1843 DBG (DBG_proc, "sane_get_option_descriptor: exit\n");
1844
1845 return dev->opt + option;
1846 }
1847
1848 SANE_Status
sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action, void *val, SANE_Int * info)1849 sane_control_option (SANE_Handle handle, SANE_Int option,
1850 SANE_Action action, void *val, SANE_Int * info)
1851 {
1852 Matsushita_Scanner *dev = handle;
1853 SANE_Status status;
1854 SANE_Word cap;
1855 SANE_String_Const name;
1856 int i;
1857 SANE_Word value;
1858 int rc;
1859
1860 DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n",
1861 option, action);
1862
1863 if (info)
1864 {
1865 *info = 0;
1866 }
1867
1868 if (dev->scanning)
1869 {
1870 return SANE_STATUS_DEVICE_BUSY;
1871 }
1872
1873 if (option < 0 || option >= OPT_NUM_OPTIONS)
1874 {
1875 return SANE_STATUS_INVAL;
1876 }
1877
1878 cap = dev->opt[option].cap;
1879 if (!SANE_OPTION_IS_ACTIVE (cap))
1880 {
1881 return SANE_STATUS_INVAL;
1882 }
1883
1884 name = dev->opt[option].name;
1885 if (!name)
1886 {
1887 name = "(no name)";
1888 }
1889 if (action == SANE_ACTION_GET_VALUE)
1890 {
1891
1892 switch (option)
1893 {
1894 /* word options */
1895 case OPT_NUM_OPTS:
1896 case OPT_RESOLUTION:
1897 case OPT_TL_Y:
1898 case OPT_BR_Y:
1899 case OPT_TL_X:
1900 case OPT_BR_X:
1901 case OPT_BRIGHTNESS:
1902 case OPT_CONTRAST:
1903 case OPT_DUPLEX:
1904 case OPT_AUTOMATIC_SEPARATION:
1905 *(SANE_Word *) val = dev->val[option].w;
1906 return SANE_STATUS_GOOD;
1907
1908 /* string options */
1909 case OPT_MODE:
1910 case OPT_FEEDER_MODE:
1911 case OPT_HALFTONE_PATTERN:
1912 case OPT_PAPER_SIZE:
1913 case OPT_AUTOMATIC_THRESHOLD:
1914 case OPT_WHITE_LEVEL:
1915 case OPT_NOISE_REDUCTION:
1916 case OPT_IMAGE_EMPHASIS:
1917 case OPT_GAMMA:
1918 strcpy (val, dev->val[option].s);
1919 return SANE_STATUS_GOOD;
1920
1921 default:
1922 return SANE_STATUS_INVAL;
1923 }
1924 }
1925 else if (action == SANE_ACTION_SET_VALUE)
1926 {
1927
1928 if (!SANE_OPTION_IS_SETTABLE (cap))
1929 {
1930 DBG (DBG_error, "could not set option, not settable\n");
1931 return SANE_STATUS_INVAL;
1932 }
1933
1934 status = sanei_constrain_value (dev->opt + option, val, info);
1935 if (status != SANE_STATUS_GOOD)
1936 {
1937 DBG (DBG_error, "could not set option, invalid value\n");
1938 return status;
1939 }
1940
1941 switch (option)
1942 {
1943
1944 /* Side-effect options */
1945 case OPT_TL_Y:
1946 case OPT_BR_Y:
1947 case OPT_RESOLUTION:
1948 if (info)
1949 {
1950 *info |= SANE_INFO_RELOAD_PARAMS;
1951 }
1952 dev->val[option].w = *(SANE_Word *) val;
1953 return SANE_STATUS_GOOD;
1954
1955 /* The length of X must be rounded (up). */
1956 case OPT_TL_X:
1957 case OPT_BR_X:
1958
1959 value = mmToIlu (SANE_UNFIX (*(SANE_Word *) val));
1960
1961 i = get_int_list_index (scanners[dev->scnum].resolutions_list,
1962 dev->val[OPT_RESOLUTION].w);
1963
1964 if (value & (scanners[dev->scnum].resolutions_round[i] - 1))
1965 {
1966 value =
1967 (value | (scanners[dev->scnum].resolutions_round[i] - 1)) + 1;
1968 if (info)
1969 {
1970 *info |= SANE_INFO_INEXACT;
1971 }
1972 }
1973
1974 *(SANE_Word *) val = SANE_FIX (iluToMm (value));
1975
1976 dev->val[option].w = *(SANE_Word *) val;
1977
1978 if (info)
1979 {
1980 *info |= SANE_INFO_RELOAD_PARAMS;
1981 }
1982
1983 return SANE_STATUS_GOOD;
1984
1985 /* Side-effect free options */
1986 case OPT_CONTRAST:
1987 case OPT_BRIGHTNESS:
1988 case OPT_DUPLEX:
1989 case OPT_AUTOMATIC_SEPARATION:
1990 dev->val[option].w = *(SANE_Word *) val;
1991 return SANE_STATUS_GOOD;
1992
1993 /* String mode */
1994 case OPT_WHITE_LEVEL:
1995 case OPT_NOISE_REDUCTION:
1996 case OPT_IMAGE_EMPHASIS:
1997 case OPT_GAMMA:
1998 case OPT_FEEDER_MODE:
1999 free (dev->val[option].s);
2000 dev->val[option].s = (SANE_String) strdup (val);
2001 return SANE_STATUS_GOOD;
2002
2003 case OPT_MODE:
2004 if (strcmp (dev->val[option].s, val) == 0)
2005 return SANE_STATUS_GOOD;
2006
2007 free (dev->val[OPT_MODE].s);
2008 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
2009
2010 /* Set default options for the scan modes. */
2011 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
2012 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE;
2013 dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE;
2014 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
2015 dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
2016
2017 if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0)
2018 {
2019 dev->depth = 1;
2020
2021 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
2022 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
2023 dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE;
2024 dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE;
2025
2026 i = get_string_list_index (halftone_pattern_list,
2027 dev->val[OPT_HALFTONE_PATTERN].s);
2028 if (halftone_pattern_val[i] == -1)
2029 {
2030 dev->scan_mode = MATSUSHITA_BW;
2031 }
2032 else
2033 {
2034 dev->scan_mode = MATSUSHITA_HALFTONE;
2035 }
2036 }
2037 else if (strcmp (dev->val[OPT_MODE].s, GRAY4_STR) == 0)
2038 {
2039 dev->scan_mode = MATSUSHITA_GRAYSCALE;
2040 dev->depth = 4;
2041
2042 dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
2043 }
2044 else if (strcmp (dev->val[OPT_MODE].s, GRAY8_STR) == 0)
2045 {
2046 dev->scan_mode = MATSUSHITA_GRAYSCALE;
2047 dev->depth = 8;
2048
2049 dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
2050 }
2051 else
2052 {
2053 assert (0 == 1);
2054 }
2055
2056 /* Some options might not be supported by the scanner. */
2057 if ((scanners[dev->scnum].cap & MAT_CAP_GAMMA) == 0)
2058 dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
2059
2060 if (info)
2061 {
2062 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2063 }
2064 return SANE_STATUS_GOOD;
2065
2066 case OPT_HALFTONE_PATTERN:
2067 free (dev->val[option].s);
2068 dev->val[option].s = (SANE_String) strdup (val);
2069 i = get_string_list_index (halftone_pattern_list,
2070 dev->val[OPT_HALFTONE_PATTERN].s);
2071 if (halftone_pattern_val[i] == -1)
2072 {
2073 dev->scan_mode = MATSUSHITA_BW;
2074 }
2075 else
2076 {
2077 dev->scan_mode = MATSUSHITA_HALFTONE;
2078 }
2079
2080 return SANE_STATUS_GOOD;
2081
2082 case OPT_PAPER_SIZE:
2083 if (strcmp (dev->val[option].s, val) == 0)
2084 return SANE_STATUS_GOOD;
2085
2086 free (dev->val[OPT_PAPER_SIZE].s);
2087 dev->val[OPT_PAPER_SIZE].s = (SANE_Char *) strdup (val);
2088
2089 i = get_string_list_index (dev->paper_sizes_list,
2090 dev->val[OPT_PAPER_SIZE].s);
2091 i = dev->paper_sizes_val[i];
2092
2093 /* Set the 4 corners values. */
2094 value = 0;
2095 rc = sane_control_option (handle, OPT_TL_X, SANE_ACTION_SET_VALUE,
2096 &value, info);
2097 assert (rc == SANE_STATUS_GOOD);
2098
2099 value = 0;
2100 rc = sane_control_option (handle, OPT_TL_Y, SANE_ACTION_SET_VALUE,
2101 &value, info);
2102 assert (rc == SANE_STATUS_GOOD);
2103
2104 value = SANE_FIX (paper_sizes[i].width);
2105 rc = sane_control_option (handle, OPT_BR_X, SANE_ACTION_SET_VALUE,
2106 &value, info);
2107 assert (rc == SANE_STATUS_GOOD);
2108
2109 value = SANE_FIX (paper_sizes[i].length);
2110 rc = sane_control_option (handle, OPT_BR_Y, SANE_ACTION_SET_VALUE,
2111 &value, info);
2112 assert (rc == SANE_STATUS_GOOD);
2113
2114 if (info)
2115 *info |= SANE_INFO_RELOAD_OPTIONS;
2116
2117 return SANE_STATUS_GOOD;
2118
2119 case OPT_AUTOMATIC_THRESHOLD:
2120 if (strcmp (dev->val[option].s, val) == 0)
2121 return SANE_STATUS_GOOD;
2122
2123 free (dev->val[option].s);
2124 dev->val[option].s = (SANE_Char *) strdup (val);
2125
2126 /* If the threshold is not set to none, some option must
2127 * disappear. */
2128 dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE;
2129 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
2130 dev->opt[OPT_IMAGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
2131 dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE;
2132 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
2133
2134 if (strcmp (dev->val[option].s, automatic_threshold_list[0]) == 0)
2135 {
2136 dev->opt[OPT_WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE;
2137 dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE;
2138 dev->opt[OPT_IMAGE_EMPHASIS].cap &= ~SANE_CAP_INACTIVE;
2139 dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE;
2140 if (dev->scan_mode == MATSUSHITA_BW
2141 || dev->scan_mode == MATSUSHITA_HALFTONE)
2142 {
2143 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
2144 }
2145 }
2146
2147 if (info)
2148 {
2149 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
2150 }
2151 return SANE_STATUS_GOOD;
2152
2153 default:
2154 return SANE_STATUS_INVAL;
2155 }
2156 }
2157
2158 DBG (DBG_proc, "sane_control_option: exit, bad\n");
2159
2160 return SANE_STATUS_UNSUPPORTED;
2161 }
2162
2163 SANE_Status
sane_get_parameters(SANE_Handle handle, SANE_Parameters * params)2164 sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
2165 {
2166 Matsushita_Scanner *dev = handle;
2167
2168 DBG (DBG_proc, "sane_get_parameters: enter\n");
2169
2170 if (!(dev->scanning))
2171 {
2172
2173 /* Setup the parameters for the scan. These values will be re-used
2174 * in the SET WINDOWS command. */
2175 dev->resolution = dev->val[OPT_RESOLUTION].w;
2176
2177 dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
2178 dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
2179 dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
2180 dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
2181
2182 /* Check the corners are OK. */
2183 if (dev->x_tl > dev->x_br)
2184 {
2185 int s;
2186 s = dev->x_tl;
2187 dev->x_tl = dev->x_br;
2188 dev->x_br = s;
2189 }
2190 if (dev->y_tl > dev->y_br)
2191 {
2192 int s;
2193 s = dev->y_tl;
2194 dev->y_tl = dev->y_br;
2195 dev->y_br = s;
2196 }
2197
2198 dev->width = dev->x_br - dev->x_tl;
2199 dev->length = dev->y_br - dev->y_tl;
2200
2201 /* Prepare the parameters for the caller. */
2202 memset (&dev->params, 0, sizeof (SANE_Parameters));
2203
2204 dev->params.format = SANE_FRAME_GRAY;
2205 dev->params.last_frame = SANE_TRUE;
2206 dev->params.pixels_per_line =
2207 (((dev->width * dev->resolution) / 1200) + 7) & ~0x7;
2208
2209 if (dev->depth == 4)
2210 {
2211 dev->params.depth = 8;
2212 }
2213 else
2214 {
2215 dev->params.depth = dev->depth;
2216 }
2217 dev->params.bytes_per_line =
2218 (dev->params.pixels_per_line / 8) * dev->params.depth;
2219 dev->params.lines = (dev->length * dev->resolution) / 1200;
2220 }
2221
2222 /* Return the current values. */
2223 if (params)
2224 {
2225 *params = (dev->params);
2226 }
2227
2228 DBG (DBG_proc, "sane_get_parameters: exit\n");
2229
2230 return SANE_STATUS_GOOD;
2231 }
2232
2233 SANE_Status
sane_start(SANE_Handle handle)2234 sane_start (SANE_Handle handle)
2235 {
2236 Matsushita_Scanner *dev = handle;
2237 SANE_Status status;
2238
2239 DBG (DBG_proc, "sane_start: enter\n");
2240
2241 if (!(dev->scanning))
2242 {
2243
2244 sane_get_parameters (dev, NULL);
2245
2246 if (dev->image == NULL)
2247 {
2248 dev->image_size = 3 * dev->buffer_size;
2249 dev->image = malloc (dev->image_size);
2250 if (dev->image == NULL)
2251 {
2252 return SANE_STATUS_NO_MEM;
2253 }
2254 }
2255
2256 /* Open again the scanner. */
2257 if (sanei_scsi_open
2258 (dev->devicename, &(dev->sfd), matsushita_sense_handler, dev) != 0)
2259 {
2260 DBG (DBG_error, "ERROR: sane_start: open failed\n");
2261 return SANE_STATUS_INVAL;
2262 }
2263
2264 dev->page_side = 0; /* page front */
2265 dev->page_num = 0; /* first page */
2266
2267 /* The scanner must be ready. */
2268 status = matsushita_wait_scanner (dev);
2269 if (status)
2270 {
2271 matsushita_close (dev);
2272 return status;
2273 }
2274
2275 status = matsushita_reset_window (dev);
2276 if (status)
2277 {
2278 matsushita_close (dev);
2279 return status;
2280 }
2281
2282 status = matsushita_set_window (dev, PAGE_FRONT);
2283 if (status)
2284 {
2285 matsushita_close (dev);
2286 return status;
2287 }
2288
2289 if (dev->val[OPT_DUPLEX].w == SANE_TRUE)
2290 {
2291 status = matsushita_set_window (dev, PAGE_BACK);
2292 if (status)
2293 {
2294 matsushita_close (dev);
2295 return status;
2296 }
2297 }
2298
2299 status = matsushita_read_document_size (dev);
2300 if (status)
2301 {
2302 matsushita_close (dev);
2303 return status;
2304 }
2305
2306 }
2307 else
2308 {
2309 if (dev->val[OPT_DUPLEX].w == SANE_TRUE && dev->page_side == PAGE_FRONT)
2310 {
2311 dev->page_side = PAGE_BACK;
2312 }
2313 else
2314 {
2315 /* new sheet. */
2316 dev->page_side = PAGE_FRONT;
2317 dev->page_num++;
2318 }
2319
2320 status = matsushita_check_next_page (dev);
2321 if (status)
2322 {
2323 return status;
2324 }
2325 }
2326
2327 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
2328 dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines;
2329 if (dev->depth == 4)
2330 {
2331 /* Every byte read will be expanded into 2 bytes. */
2332 dev->real_bytes_left /= 2;
2333 }
2334
2335 dev->image_end = 0;
2336 dev->image_begin = 0;
2337
2338 dev->scanning = SANE_TRUE;
2339
2340 DBG (DBG_proc, "sane_start: exit\n");
2341
2342 return SANE_STATUS_GOOD;
2343 }
2344
2345 SANE_Status
sane_read(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len)2346 sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
2347 SANE_Int * len)
2348 {
2349 SANE_Status status;
2350 Matsushita_Scanner *dev = handle;
2351 size_t size;
2352 int buf_offset; /* offset into buf */
2353
2354 DBG (DBG_proc, "sane_read: enter\n");
2355
2356 *len = 0;
2357
2358 if (!(dev->scanning))
2359 {
2360 /* OOPS, not scanning */
2361 return do_cancel (dev);
2362 }
2363
2364 if (dev->bytes_left <= 0)
2365 {
2366 return (SANE_STATUS_EOF);
2367 }
2368
2369 buf_offset = 0;
2370
2371 do
2372 {
2373 if (dev->image_begin == dev->image_end)
2374 {
2375 /* Fill image */
2376 status = matsushita_fill_image (dev);
2377 if (status != SANE_STATUS_GOOD)
2378 {
2379 return (status);
2380 }
2381 }
2382
2383 /* Something must have been read */
2384 if (dev->image_begin == dev->image_end)
2385 {
2386 DBG (DBG_info, "sane_read: nothing read\n");
2387 return SANE_STATUS_IO_ERROR;
2388 }
2389
2390 /* Copy the data to the frontend buffer. */
2391 size = max_len - buf_offset;
2392 if (size > dev->bytes_left)
2393 {
2394 size = dev->bytes_left;
2395 }
2396 matsushita_copy_raw_to_frontend (dev, buf + buf_offset, &size);
2397
2398 buf_offset += size;
2399
2400 dev->bytes_left -= size;
2401 *len += size;
2402
2403 }
2404 while ((buf_offset != max_len) && dev->bytes_left);
2405
2406 DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n", (long)dev->bytes_left);
2407
2408 return SANE_STATUS_GOOD;
2409 }
2410
2411 SANE_Status
sane_set_io_mode(SANE_Handle __sane_unused__ handle, SANE_Bool __sane_unused__ non_blocking)2412 sane_set_io_mode (SANE_Handle __sane_unused__ handle, SANE_Bool __sane_unused__ non_blocking)
2413 {
2414 SANE_Status status;
2415 Matsushita_Scanner *dev = handle;
2416
2417 DBG (DBG_proc, "sane_set_io_mode: enter\n");
2418
2419 if (dev->scanning == SANE_FALSE)
2420 {
2421 return (SANE_STATUS_INVAL);
2422 }
2423
2424 if (non_blocking == SANE_FALSE) {
2425 status = SANE_STATUS_GOOD;
2426 } else {
2427 status = SANE_STATUS_UNSUPPORTED;
2428 }
2429
2430 DBG (DBG_proc, "sane_set_io_mode: exit\n");
2431
2432 return status;
2433 }
2434
2435 SANE_Status
sane_get_select_fd(SANE_Handle __sane_unused__ handle, SANE_Int __sane_unused__ * fd)2436 sane_get_select_fd (SANE_Handle __sane_unused__ handle, SANE_Int __sane_unused__ * fd)
2437 {
2438 DBG (DBG_proc, "sane_get_select_fd: enter\n");
2439
2440 DBG (DBG_proc, "sane_get_select_fd: exit\n");
2441
2442 return SANE_STATUS_UNSUPPORTED;
2443 }
2444
2445 void
sane_cancel(SANE_Handle handle)2446 sane_cancel (SANE_Handle handle)
2447 {
2448 Matsushita_Scanner *dev = handle;
2449
2450 DBG (DBG_proc, "sane_cancel: enter\n");
2451
2452 do_cancel (dev);
2453
2454 DBG (DBG_proc, "sane_cancel: exit\n");
2455 }
2456
2457 void
sane_close(SANE_Handle handle)2458 sane_close (SANE_Handle handle)
2459 {
2460 Matsushita_Scanner *dev = handle;
2461 Matsushita_Scanner *dev_tmp;
2462
2463 DBG (DBG_proc, "sane_close: enter\n");
2464
2465 do_cancel (dev);
2466 matsushita_close (dev);
2467
2468 /* Unlink dev. */
2469 if (first_dev == dev)
2470 {
2471 first_dev = dev->next;
2472 }
2473 else
2474 {
2475 dev_tmp = first_dev;
2476 while (dev_tmp->next && dev_tmp->next != dev)
2477 {
2478 dev_tmp = dev_tmp->next;
2479 }
2480 if (dev_tmp->next != NULL)
2481 {
2482 dev_tmp->next = dev_tmp->next->next;
2483 }
2484 }
2485
2486 matsushita_free (dev);
2487 num_devices--;
2488
2489 DBG (DBG_proc, "sane_close: exit\n");
2490 }
2491
2492 void
sane_exit(void)2493 sane_exit (void)
2494 {
2495 DBG (DBG_proc, "sane_exit: enter\n");
2496
2497 while (first_dev)
2498 {
2499 sane_close (first_dev);
2500 }
2501
2502 if (devlist)
2503 {
2504 free (devlist);
2505 devlist = NULL;
2506 }
2507
2508 DBG (DBG_proc, "sane_exit: exit\n");
2509 }
2510