1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2002 Frank Zago (sane at zago dot net)
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 as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 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 /*
43 Some Relisys scanners AVEC and RELI series
44 */
45
46 /*--------------------------------------------------------------------------*/
47
48 #define BUILD 10 /* 2004/02/08 */
49 #define BACKEND_NAME teco1
50 #define TECO_CONFIG_FILE "teco1.conf"
51
52 /*--------------------------------------------------------------------------*/
53
54 #include "../include/sane/config.h"
55
56 #include <errno.h>
57 #include <fcntl.h>
58 #include <limits.h>
59 #include <signal.h>
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #include <sys/types.h>
64 #include <sys/wait.h>
65 #include <unistd.h>
66
67 #include "../include/sane/sane.h"
68 #include "../include/sane/sanei.h"
69 #include "../include/sane/saneopts.h"
70 #include "../include/sane/sanei_scsi.h"
71 #include "../include/sane/sanei_debug.h"
72 #include "../include/sane/sanei_backend.h"
73 #include "../include/sane/sanei_config.h"
74 #include "../include/lassert.h"
75
76 #include "teco1.h"
77
78 #undef sim
79 #ifdef sim
80 #define sanei_scsi_cmd2(a, b, c, d, e, f, g) SANE_STATUS_GOOD
81 #define sanei_scsi_open(a, b, c, d) 0
82 #define sanei_scsi_cmd(a, b, c, d, e) SANE_STATUS_GOOD
83 #define sanei_scsi_close(a) SANE_STATUS_GOOD
84 #endif
85
86 /*--------------------------------------------------------------------------*/
87
88 /* Lists of possible scan modes. */
89 static SANE_String_Const scan_mode_list[] = {
90 BLACK_WHITE_STR,
91 GRAY_STR,
92 COLOR_STR,
93 NULL
94 };
95
96 /*--------------------------------------------------------------------------*/
97
98 /* Minimum and maximum width and length supported. */
99 static SANE_Range x_range = { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 };
100 static SANE_Range y_range = { SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0 };
101
102 /*--------------------------------------------------------------------------*/
103
104 /* Gamma range */
105 static const SANE_Range gamma_range = {
106 0, /* minimum */
107 255, /* maximum */
108 0 /* quantization */
109 };
110
111 /*--------------------------------------------------------------------------*/
112
113 /* List of dithering options. */
114 static SANE_String_Const dither_list[] = {
115 "Line art",
116 "2x2",
117 "3x3",
118 "4x4 bayer",
119 "4x4 smooth",
120 "8x8 bayer",
121 "8x8 smooth",
122 "8x8 horizontal",
123 "8x8 vertical",
124 NULL
125 };
126 static const int dither_val[] = {
127 0x00,
128 0x01,
129 0x02,
130 0x03,
131 0x04,
132 0x05,
133 0x06,
134 0x07,
135 0x08
136 };
137
138 /*--------------------------------------------------------------------------*/
139
140 static const SANE_Range threshold_range = {
141 0, /* minimum */
142 255, /* maximum */
143 0 /* quantization */
144 };
145
146 /*--------------------------------------------------------------------------*/
147
148 /* Define the supported scanners and their characteristics. */
149 static const struct scanners_supported scanners[] = {
150 {6, "TECO VM3510", /* *fake id*, see teco_identify_scanner */
151 TECO_VM3510,
152 "Dextra", "DF-600P",
153 {1, 600, 1}, /* resolution */
154 300, 600, /* max x and Y res */
155 3, /* color 3 pass */
156 256, /* number of bytes per gamma color */
157 80 /* number of bytes in a window */
158 },
159
160 {6, "TECO VM353A",
161 TECO_VM353A,
162 "Relisys", "RELI 2412",
163 {1, 1200, 1}, /* resolution */
164 300, 1200, /* max x and Y resolution */
165 1, /* color 1 pass */
166 256, /* number of bytes per gamma color */
167 99 /* number of bytes in a window */
168 },
169
170 {6, "TECO VM3520",
171 TECO_VM3520,
172 "Relisys", "AVEC Colour Office 2400",
173 {1, 600, 1}, /* resolution */
174 300, 600, /* max x and Y resolution */
175 3, /* color 3 pass */
176 256, /* number of bytes per gamma color */
177 99 /* number of bytes in a window */
178 },
179
180 {6, "TECO VM352A",
181 TECO_VM3520, /* same as AVEC 2400 */
182 "Relisys", "AVEC Colour 2412",
183 {1, 600, 1},
184 300, 600,
185 3,
186 256,
187 99
188 },
189
190 {6, "TECO VM4540",
191 TECO_VM4540,
192 "Relisys", "RELI 4816",
193 {1, 1600, 1}, /* resolution */
194 400, 1600, /* max x and Y resolution */
195 1, /* color 1 pass */
196 256, /* number of bytes per gamma color */
197 99 /* number of bytes in a window */
198 },
199
200 {6, "TECO VM4542",
201 TECO_VM4542,
202 "Relisys", "RELI 4830",
203 {1, 400, 1}, /* resolution */
204 400, 400, /* max x and Y resolution */
205 1, /* color 1 pass */
206 1024, /* number of bytes per gamma color */
207 99 /* number of bytes in a window */
208 }
209 };
210
211 /*--------------------------------------------------------------------------*/
212
213 /* List of scanner attached. */
214 static Teco_Scanner *first_dev = NULL;
215 static int num_devices = 0;
216 static const SANE_Device **devlist = NULL;
217
218
219 /* Local functions. */
220
221 /* Display a buffer in the log. */
222 static void
hexdump(int level,const char * comment,unsigned char * p,int l)223 hexdump (int level, const char *comment, unsigned char *p, int l)
224 {
225 int i;
226 char line[128];
227 char *ptr;
228 char asc_buf[17];
229 char *asc_ptr;
230
231 DBG (level, "%s\n", comment);
232
233 ptr = line;
234 *ptr = '\0';
235 asc_ptr = asc_buf;
236 *asc_ptr = '\0';
237
238 for (i = 0; i < l; i++, p++)
239 {
240 if ((i % 16) == 0)
241 {
242 if (ptr != line)
243 {
244 DBG (level, "%s %s\n", line, asc_buf);
245 ptr = line;
246 *ptr = '\0';
247 asc_ptr = asc_buf;
248 *asc_ptr = '\0';
249 }
250 sprintf (ptr, "%3.3d:", i);
251 ptr += 4;
252 }
253 ptr += sprintf (ptr, " %2.2x", *p);
254 if (*p >= 32 && *p <= 127)
255 {
256 asc_ptr += sprintf (asc_ptr, "%c", *p);
257 }
258 else
259 {
260 asc_ptr += sprintf (asc_ptr, ".");
261 }
262 }
263 *ptr = '\0';
264 DBG (level, "%s %s\n", line, asc_buf);
265 }
266
267 /* Returns the length of the longest string, including the terminating
268 * character. */
269 static size_t
max_string_size(SANE_String_Const strings[])270 max_string_size (SANE_String_Const strings[])
271 {
272 size_t size, max_size = 0;
273 int i;
274
275 for (i = 0; strings[i]; ++i)
276 {
277 size = strlen (strings[i]) + 1;
278 if (size > max_size)
279 {
280 max_size = size;
281 }
282 }
283
284 return max_size;
285 }
286
287 /* Lookup a string list from one array and return its index. */
288 static int
get_string_list_index(SANE_String_Const list[],SANE_String_Const name)289 get_string_list_index (SANE_String_Const list[], SANE_String_Const name)
290 {
291 int index;
292
293 index = 0;
294 while (list[index] != NULL)
295 {
296 if (strcmp (list[index], name) == 0)
297 {
298 return (index);
299 }
300 index++;
301 }
302
303 DBG (DBG_error, "name %s not found in list\n", name);
304
305 assert (0 == 1); /* bug in backend, core dump */
306
307 return (-1);
308 }
309
310 /* Initialize a scanner entry. Return an allocated scanner with some
311 * preset values. */
312 static Teco_Scanner *
teco_init(void)313 teco_init (void)
314 {
315 Teco_Scanner *dev;
316
317 DBG (DBG_proc, "teco_init: enter\n");
318
319 /* Allocate a new scanner entry. */
320 dev = malloc (sizeof (Teco_Scanner));
321 if (dev == NULL)
322 {
323 return NULL;
324 }
325
326 memset (dev, 0, sizeof (Teco_Scanner));
327
328 /* Allocate the buffer used to transfer the SCSI data. */
329 dev->buffer_size = 64 * 1024;
330 dev->buffer = malloc (dev->buffer_size);
331 if (dev->buffer == NULL)
332 {
333 free (dev);
334 return NULL;
335 }
336
337 /* Allocate a buffer to store the temporary image. */
338 dev->image_size = 64 * 1024; /* enough for 1 line at max res */
339 dev->image = malloc (dev->image_size);
340 if (dev->image == NULL)
341 {
342 free (dev->buffer);
343 free (dev);
344 return NULL;
345 }
346
347 dev->sfd = -1;
348
349 DBG (DBG_proc, "teco_init: exit\n");
350
351 return (dev);
352 }
353
354 /* Closes an open scanner. */
355 static void
teco_close(Teco_Scanner * dev)356 teco_close (Teco_Scanner * dev)
357 {
358 DBG (DBG_proc, "teco_close: enter\n");
359
360 if (dev->sfd != -1)
361 {
362 sanei_scsi_close (dev->sfd);
363 dev->sfd = -1;
364 }
365
366 DBG (DBG_proc, "teco_close: exit\n");
367 }
368
369 /* Frees the memory used by a scanner. */
370 static void
teco_free(Teco_Scanner * dev)371 teco_free (Teco_Scanner * dev)
372 {
373 int i;
374
375 DBG (DBG_proc, "teco_free: enter\n");
376
377 if (dev == NULL)
378 return;
379
380 teco_close (dev);
381 if (dev->devicename)
382 {
383 free (dev->devicename);
384 }
385 if (dev->buffer)
386 {
387 free (dev->buffer);
388 }
389 if (dev->image)
390 {
391 free (dev->image);
392 }
393 for (i = 1; i < OPT_NUM_OPTIONS; i++)
394 {
395 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
396 {
397 free (dev->val[i].s);
398 }
399 }
400
401 free (dev);
402
403 DBG (DBG_proc, "teco_free: exit\n");
404 }
405
406 /* Inquiry a device and returns TRUE if is supported. */
407 static int
teco_identify_scanner(Teco_Scanner * dev)408 teco_identify_scanner (Teco_Scanner * dev)
409 {
410 CDB cdb;
411 SANE_Status status;
412 size_t size;
413 int i;
414
415 DBG (DBG_proc, "teco_identify_scanner: enter\n");
416
417 size = 5;
418 MKSCSI_INQUIRY (cdb, size);
419 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
420 NULL, 0, dev->buffer, &size);
421
422 if (status)
423 {
424 DBG (DBG_error,
425 "teco_identify_scanner: inquiry failed with status %s\n",
426 sane_strstatus (status));
427 return (SANE_FALSE);
428 }
429
430 #ifdef sim
431 {
432 #if 1
433 /* vm3510 / Dextra DF-600P */
434 unsigned char table[] = {
435 0x06, 0x00, 0x02, 0x02, 0x24, 0x00, 0x00, 0x10, 0x44, 0x46,
436 0x2D, 0x36, 0x30, 0x30, 0x4D, 0x20, 0x20, 0x20, 0x20, 0x20,
437 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
438 0x20, 0x20, 0x31, 0x2E, 0x31, 0x37, 0x31, 0x2E, 0x31, 0x37,
439 0x02
440 };
441 #endif
442
443 #if 0
444 /* vm4542 */
445 unsigned char table[] = {
446 0x06, 0x00, 0x02, 0x02, 0x30, 0x00, 0x00, 0x10, 0x52, 0x45, 0x4c, 0x49,
447 0x53, 0x59, 0x53, 0x20, 0x52, 0x45, 0x4c, 0x49, 0x20, 0x34, 0x38,
448 0x33, 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x31, 0x2e,
449 0x30, 0x33, 0x31, 0x2e, 0x30, 0x33, 0x02, 0x00, 0x54, 0x45, 0x43,
450 0x4f, 0x20, 0x56, 0x4d, 0x34, 0x35, 0x34, 0x32
451 };
452 #endif
453 memcpy (dev->buffer, table, sizeof (table));
454 }
455 #endif
456
457 size = dev->buffer[4] + 5; /* total length of the inquiry data */
458
459 MKSCSI_INQUIRY (cdb, size);
460 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
461 NULL, 0, dev->buffer, &size);
462
463 if (status)
464 {
465 DBG (DBG_error,
466 "teco_identify_scanner: inquiry failed with status %s\n",
467 sane_strstatus (status));
468 return (SANE_FALSE);
469 }
470
471 /* Hack to recognize the dextra as a TECO scanner. */
472 if (memcmp (dev->buffer + 0x08, "DF-600M ", 8) == 0)
473 {
474 memcpy (dev->buffer + 0x29, "\0TECO VM3510", 12);
475 dev->buffer[4] = 0x30; /* change length */
476 size = 0x35;
477 }
478
479 if (size < 53)
480 {
481 DBG (DBG_error,
482 "teco_identify_scanner: not enough data to identify device\n");
483 return (SANE_FALSE);
484 }
485
486 hexdump (DBG_info2, "inquiry", dev->buffer, size);
487
488 dev->scsi_type = dev->buffer[0] & 0x1f;
489 memcpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
490 dev->scsi_vendor[0x08] = 0;
491 memcpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
492 dev->scsi_product[0x10] = 0;
493 memcpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
494 dev->scsi_version[0x04] = 0;
495 memcpy (dev->scsi_teco_name, dev->buffer + 0x2A, 0x0B);
496 dev->scsi_teco_name[0x0B] = 0;
497
498 DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\" \"%s\"\n",
499 dev->scsi_vendor, dev->scsi_product, dev->scsi_version,
500 dev->scsi_teco_name);
501
502 /* Lookup through the supported scanners table to find if this
503 * backend supports that one. */
504 for (i = 0; i < NELEMS (scanners); i++)
505 {
506
507 if (dev->scsi_type == scanners[i].scsi_type &&
508 strcmp (dev->scsi_teco_name, scanners[i].scsi_teco_name) == 0)
509 {
510
511 DBG (DBG_error, "teco_identify_scanner: scanner supported\n");
512
513 dev->def = &(scanners[i]);
514
515 return (SANE_TRUE);
516 }
517 }
518
519 DBG (DBG_proc, "teco_identify_scanner: exit, device not supported\n");
520
521 return (SANE_FALSE);
522 }
523
524 /* Get the inquiry page 0x82. */
525 static int
teco_get_inquiry_82(Teco_Scanner * dev)526 teco_get_inquiry_82 (Teco_Scanner * dev)
527 {
528 CDB cdb;
529 SANE_Status status;
530 size_t size;
531
532 DBG (DBG_proc, "teco_get_inquiry_82: enter\n");
533
534 size = 0x4;
535 MKSCSI_INQUIRY (cdb, size);
536 cdb.data[1] = 1; /* evpd */
537 cdb.data[2] = 0x82; /* page code number */
538
539 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
540 NULL, 0, dev->buffer, &size);
541
542 if (status)
543 {
544 DBG (DBG_error,
545 "teco_get_inquiry_82: inquiry page 0x82 failed with status %s\n",
546 sane_strstatus (status));
547 return (SANE_FALSE);
548 }
549
550 size = dev->buffer[3] + 4;
551 MKSCSI_INQUIRY (cdb, size);
552 cdb.data[1] = 1; /* evpd */
553 cdb.data[2] = 0x82; /* page code number */
554
555 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
556 NULL, 0, dev->buffer, &size);
557
558 if (status)
559 {
560 DBG (DBG_error,
561 "teco_get_inquiry_82: inquiry page 0x82 failed with status %s\n",
562 sane_strstatus (status));
563 return (SANE_FALSE);
564 }
565
566 hexdump (DBG_info2, "inquiry page 0x82", dev->buffer, size);
567
568 DBG (DBG_proc, "teco_get_inquiry_82: leave\n");
569
570 return (status);
571 }
572
573 /* SCSI sense handler. Callback for SANE.
574 * These scanners never set asc or ascq. */
575 static SANE_Status
teco_sense_handler(int __sane_unused__ scsi_fd,unsigned char * result,void __sane_unused__ * arg)576 teco_sense_handler (int __sane_unused__ scsi_fd, unsigned char *result, void __sane_unused__ *arg)
577 {
578 int sensekey;
579 int len;
580
581 DBG (DBG_proc, "teco_sense_handler: enter\n");
582
583 sensekey = get_RS_sense_key (result);
584 len = 7 + get_RS_additional_length (result);
585
586 hexdump (DBG_info2, "sense", result, len);
587
588 if (get_RS_error_code (result) != 0x70)
589 {
590 DBG (DBG_error,
591 "teco_sense_handler: invalid sense key error code (%d)\n",
592 get_RS_error_code (result));
593
594 return SANE_STATUS_IO_ERROR;
595 }
596
597 if (len < 14)
598 {
599 DBG (DBG_error, "teco_sense_handler: sense too short, no ASC/ASCQ\n");
600
601 return SANE_STATUS_IO_ERROR;
602 }
603
604 DBG (DBG_sense, "teco_sense_handler: sense=%d\n", sensekey);
605
606 if (sensekey == 0x00)
607 {
608 return SANE_STATUS_GOOD;
609 }
610
611 return SANE_STATUS_IO_ERROR;
612 }
613
614 /* Send the mode select to the scanner. */
615 static int
teco_mode_select(Teco_Scanner * dev)616 teco_mode_select (Teco_Scanner * dev)
617 {
618 CDB cdb;
619 SANE_Status status;
620 size_t size;
621 unsigned char select[24] = {
622 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
623 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
624 0x03, 0x06, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00
625 };
626
627 DBG (DBG_proc, "teco_mode_select: enter\n");
628
629 size = 24;
630 MKSCSI_MODE_SELECT (cdb, 1, 0, size);
631
632 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
633 select, size, NULL, NULL);
634
635 DBG (DBG_proc, "teco_mode_select: exit\n");
636
637 return (status);
638 }
639
640 /* Set a window. */
641 static SANE_Status
teco_set_window(Teco_Scanner * dev)642 teco_set_window (Teco_Scanner * dev)
643 {
644 size_t size; /* significant size of window */
645 CDB cdb;
646 unsigned char window[99];
647 SANE_Status status;
648 int i;
649
650 DBG (DBG_proc, "teco_set_window: enter\n");
651
652 size = dev->def->window_size;
653
654 MKSCSI_SET_WINDOW (cdb, size);
655
656 memset (window, 0, size);
657
658 /* size of the windows descriptor block */
659 window[7] = size - 8;
660
661 /* X and Y resolution */
662 Ito16 (dev->x_resolution, &window[10]);
663 Ito16 (dev->y_resolution, &window[12]);
664
665 /* Upper Left (X,Y) */
666 Ito32 (dev->x_tl, &window[14]);
667 Ito32 (dev->y_tl, &window[18]);
668
669 /* Width and length */
670 Ito32 (dev->width, &window[22]);
671 Ito32 (dev->length, &window[26]);
672
673 /* Image Composition */
674 switch (dev->scan_mode)
675 {
676 case TECO_BW:
677 window[33] = 0x00;
678 i = get_string_list_index (dither_list, dev->val[OPT_DITHER].s);
679 window[36] = dither_val[i];
680 break;
681 case TECO_GRAYSCALE:
682 window[33] = 0x02;
683 break;
684 case TECO_COLOR:
685 window[33] = 0x05;
686 break;
687 }
688
689 /* Depth */
690 window[34] = dev->depth;
691
692 /* Unknown - invariants */
693 window[31] = 0x80;
694 window[37] = 0x80;
695 window[55] = 0x80;
696 window[57] = 0x80;
697 window[59] = 0x80;
698 window[61] = 0x80;
699 window[65] = 0x80;
700 window[67] = 0x80;
701 window[69] = 0x80;
702 window[71] = 0x80;
703 window[73] = 0x80;
704 window[75] = 0x80;
705 window[77] = 0x80;
706 window[79] = 0x80;
707 window[85] = 0xff;
708 window[89] = 0xff;
709 window[93] = 0xff;
710 window[97] = 0xff;
711
712 hexdump (DBG_info2, "windows", window, size);
713
714 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
715 window, size, NULL, NULL);
716
717 DBG (DBG_proc, "teco_set_window: exit, status=%d\n", status);
718
719 return status;
720 }
721
722 /* Return the number of byte that can be read. */
723 static SANE_Status
get_filled_data_length(Teco_Scanner * dev,size_t * to_read)724 get_filled_data_length (Teco_Scanner * dev, size_t * to_read)
725 {
726 size_t size;
727 CDB cdb;
728 SANE_Status status;
729
730 DBG (DBG_proc, "get_filled_data_length: enter\n");
731
732 *to_read = 0;
733
734 size = 0x12;
735 MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size);
736 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
737 NULL, 0, dev->buffer, &size);
738
739 if (size < 0x10)
740 {
741 DBG (DBG_error,
742 "get_filled_data_length: not enough data returned (%ld)\n",
743 (long) size);
744 }
745
746 hexdump (DBG_info2, "get_filled_data_length return", dev->buffer, size);
747
748 *to_read = B24TOI (&dev->buffer[9]);
749
750 DBG (DBG_info, "%d %d - %d %d\n",
751 dev->params.lines, B16TOI (&dev->buffer[12]),
752 dev->params.bytes_per_line, B16TOI (&dev->buffer[14]));
753
754 if (dev->real_bytes_left == 0)
755 {
756 /* Beginning of a scan. */
757 dev->params.lines = B16TOI (&dev->buffer[12]);
758
759 switch (dev->scan_mode)
760 {
761 case TECO_BW:
762 dev->params.bytes_per_line = B16TOI (&dev->buffer[14]);
763 dev->params.pixels_per_line = dev->params.bytes_per_line * 8;
764 break;
765
766 case TECO_GRAYSCALE:
767 dev->params.pixels_per_line = B16TOI (&dev->buffer[14]);
768 dev->params.bytes_per_line = dev->params.pixels_per_line;
769 break;
770
771 case TECO_COLOR:
772 dev->params.pixels_per_line = B16TOI (&dev->buffer[14]);
773 if (dev->def->pass == 3)
774 {
775 dev->params.bytes_per_line = dev->params.pixels_per_line;
776 }
777 else
778 {
779 dev->params.bytes_per_line = dev->params.pixels_per_line * 3;
780 }
781 break;
782 }
783 }
784
785 DBG (DBG_info, "get_filled_data_length: to read = %ld\n", (long) *to_read);
786
787 DBG (DBG_proc, "get_filled_data_length: exit, status=%d\n", status);
788
789 return (status);
790 }
791
792 /* Start a scan. */
793 static SANE_Status
teco_scan(Teco_Scanner * dev)794 teco_scan (Teco_Scanner * dev)
795 {
796 CDB cdb;
797 SANE_Status status;
798
799 DBG (DBG_proc, "teco_scan: enter\n");
800
801 MKSCSI_SCAN (cdb);
802
803 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
804
805 DBG (DBG_proc, "teco_scan: exit, status=%d\n", status);
806
807 return status;
808 }
809
810 #if 0
811 /* Do some vendor specific stuff. */
812 static SANE_Status
813 teco_vendor_spec (Teco_Scanner * dev)
814 {
815 CDB cdb;
816 SANE_Status status;
817 size_t size;
818
819 DBG (DBG_proc, "teco_vendor_spec: enter\n");
820
821 size = 0x7800;
822
823 cdb.data[0] = 0x09;
824 cdb.data[1] = 0;
825 cdb.data[2] = 0;
826 cdb.data[3] = (size >> 8) & 0xff;
827 cdb.data[4] = (size >> 0) & 0xff;
828 cdb.data[5] = 0;
829 cdb.len = 6;
830
831 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
832 NULL, 0, dev->buffer, &size);
833
834 /*hexdump (DBG_info2, "calibration:", dev->buffer, size); */
835
836 cdb.data[0] = 0x0E;
837 cdb.data[1] = 0;
838 cdb.data[2] = 0;
839 cdb.data[3] = 0;
840 cdb.data[4] = 0;
841 cdb.data[5] = 0;
842 cdb.len = 6;
843
844 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
845
846 return status;
847 }
848 #endif
849
850 /* Send the gamma
851 * The order is RGB. The last color is unused.
852 * G is also the gray gamma (if gray scan).
853 *
854 * Some scanner have 4 tables of 256 bytes, and some 4 tables of 1024 bytes.
855 */
856 static SANE_Status
teco_send_gamma(Teco_Scanner * dev)857 teco_send_gamma (Teco_Scanner * dev)
858 {
859 CDB cdb;
860 SANE_Status status;
861 struct
862 {
863 unsigned char gamma[4 * MAX_GAMMA_LENGTH];
864 }
865 param;
866 size_t i;
867 size_t size;
868
869 DBG (DBG_proc, "teco_send_gamma: enter\n");
870
871 size = 4 * GAMMA_LENGTH;
872 MKSCSI_SEND_10 (cdb, 0x03, 0x02, size);
873
874 if (dev->val[OPT_CUSTOM_GAMMA].w)
875 {
876 /* Use the custom gamma. */
877 if (dev->scan_mode == TECO_GRAYSCALE)
878 {
879 /* Gray */
880 for (i = 0; i < GAMMA_LENGTH; i++)
881 {
882 param.gamma[0 * GAMMA_LENGTH + i] = 0;
883 param.gamma[1 * GAMMA_LENGTH + i] = dev->gamma_GRAY[i];
884 param.gamma[2 * GAMMA_LENGTH + i] = 0;
885 param.gamma[3 * GAMMA_LENGTH + i] = 0;
886 }
887 }
888 else
889 {
890 /* Color */
891 for (i = 0; i < GAMMA_LENGTH; i++)
892 {
893 param.gamma[0 * GAMMA_LENGTH + i] = dev->gamma_R[i];
894 param.gamma[1 * GAMMA_LENGTH + i] = dev->gamma_G[i];
895 param.gamma[2 * GAMMA_LENGTH + i] = dev->gamma_B[i];
896 param.gamma[3 * GAMMA_LENGTH + i] = 0;
897 }
898 }
899 }
900 else
901 {
902 if (dev->scan_mode == TECO_BW)
903 {
904 /* Map threshold from a 0..255 scale to a
905 * 0..GAMMA_LENGTH scale. */
906 unsigned int threshold =
907 dev->val[OPT_THRESHOLD].w * (GAMMA_LENGTH / 256);
908
909 for (i = 0; i < GAMMA_LENGTH; i++)
910 {
911 param.gamma[0 * GAMMA_LENGTH + i] = 0;
912 if (i < threshold)
913 param.gamma[1 * GAMMA_LENGTH + i] = 0;
914 else
915 param.gamma[1 * GAMMA_LENGTH + i] = 255;
916 param.gamma[2 * GAMMA_LENGTH + i] = 0;
917 param.gamma[3 * GAMMA_LENGTH + i] = 0;
918 }
919 }
920 else
921 {
922
923 /*
924 * Shift is 1 for GAMMA_LENGTH == 256
925 * and 4 for GAMMA_LENGTH == 1024
926 */
927 int shift = GAMMA_LENGTH >> 8;
928
929 for (i = 0; i < GAMMA_LENGTH; i++)
930 {
931 param.gamma[0 * GAMMA_LENGTH + i] = i / shift;
932 param.gamma[1 * GAMMA_LENGTH + i] = i / shift;
933 param.gamma[2 * GAMMA_LENGTH + i] = i / shift;
934 param.gamma[3 * GAMMA_LENGTH + i] = 0;
935 }
936 }
937 }
938
939 hexdump (DBG_info2, "teco_send_gamma:", cdb.data, cdb.len);
940
941 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
942 ¶m, size, NULL, NULL);
943
944 DBG (DBG_proc, "teco_send_gamma: exit, status=%d\n", status);
945
946 return (status);
947 }
948
949 /* Attach a scanner to this backend. */
950 static SANE_Status
attach_scanner(const char * devicename,Teco_Scanner ** devp)951 attach_scanner (const char *devicename, Teco_Scanner ** devp)
952 {
953 Teco_Scanner *dev;
954 int sfd;
955
956 DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename);
957
958 if (devp)
959 *devp = NULL;
960
961 /* Check if we know this device name. */
962 for (dev = first_dev; dev; dev = dev->next)
963 {
964 if (strcmp (dev->sane.name, devicename) == 0)
965 {
966 if (devp)
967 {
968 *devp = dev;
969 }
970 DBG (DBG_info, "device is already known\n");
971 return SANE_STATUS_GOOD;
972 }
973 }
974
975 /* Allocate a new scanner entry. */
976 dev = teco_init ();
977 if (dev == NULL)
978 {
979 DBG (DBG_error, "ERROR: not enough memory\n");
980 return SANE_STATUS_NO_MEM;
981 }
982
983 DBG (DBG_info, "attach_scanner: opening %s\n", devicename);
984
985 if (sanei_scsi_open (devicename, &sfd, teco_sense_handler, dev) != 0)
986 {
987 DBG (DBG_error, "ERROR: attach_scanner: open failed\n");
988 teco_free (dev);
989 return SANE_STATUS_INVAL;
990 }
991
992 /* Fill some scanner specific values. */
993 dev->devicename = strdup (devicename);
994 dev->sfd = sfd;
995
996 /* Now, check that it is a scanner we support. */
997 if (teco_identify_scanner (dev) == SANE_FALSE)
998 {
999 DBG (DBG_error,
1000 "ERROR: attach_scanner: scanner-identification failed\n");
1001 teco_free (dev);
1002 return SANE_STATUS_INVAL;
1003 }
1004
1005 /* Get the page 0x82. It doesn't appear to be useful yet. */
1006 teco_get_inquiry_82 (dev);
1007
1008 teco_close (dev);
1009
1010 /* Set the default options for that scanner. */
1011 dev->sane.name = dev->devicename;
1012 dev->sane.vendor = dev->def->real_vendor;
1013 dev->sane.model = dev->def->real_product;
1014 dev->sane.type = "flatbed scanner";
1015
1016 /* Link the scanner with the others. */
1017 dev->next = first_dev;
1018 first_dev = dev;
1019
1020 if (devp)
1021 {
1022 *devp = dev;
1023 }
1024
1025 num_devices++;
1026
1027 DBG (DBG_proc, "attach_scanner: exit\n");
1028
1029 return SANE_STATUS_GOOD;
1030 }
1031
1032 static SANE_Status
attach_one(const char * dev)1033 attach_one (const char *dev)
1034 {
1035 attach_scanner (dev, NULL);
1036 return SANE_STATUS_GOOD;
1037 }
1038
1039 /* Reset the options for that scanner. */
1040 static void
teco_init_options(Teco_Scanner * dev)1041 teco_init_options (Teco_Scanner * dev)
1042 {
1043 int i;
1044
1045 /* Pre-initialize the options. */
1046 memset (dev->opt, 0, sizeof (dev->opt));
1047 memset (dev->val, 0, sizeof (dev->val));
1048
1049 for (i = 0; i < OPT_NUM_OPTIONS; ++i)
1050 {
1051 dev->opt[i].size = sizeof (SANE_Word);
1052 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1053 }
1054
1055 /* Number of options. */
1056 dev->opt[OPT_NUM_OPTS].name = "";
1057 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
1058 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
1059 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
1060 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
1061 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
1062
1063 /* Mode group */
1064 dev->opt[OPT_MODE_GROUP].title = SANE_TITLE_SCAN_MODE;
1065 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
1066 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
1067 dev->opt[OPT_MODE_GROUP].cap = 0;
1068 dev->opt[OPT_MODE_GROUP].size = 0;
1069 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1070
1071 /* Scanner supported modes */
1072 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
1073 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
1074 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
1075 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
1076 dev->opt[OPT_MODE].size = max_string_size (scan_mode_list);
1077 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1078 dev->opt[OPT_MODE].constraint.string_list = scan_mode_list;
1079 dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
1080
1081 /* X and Y resolution */
1082 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
1083 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
1084 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1085 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
1086 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
1087 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
1088 dev->opt[OPT_RESOLUTION].constraint.range = &dev->def->res_range;
1089 dev->val[OPT_RESOLUTION].w = 100;
1090
1091 /* Geometry group */
1092 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
1093 dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
1094 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
1095 dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
1096 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
1097 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1098
1099 /* Upper left X */
1100 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
1101 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
1102 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
1103 dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
1104 dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
1105 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
1106 dev->opt[OPT_TL_X].constraint.range = &x_range;
1107 dev->val[OPT_TL_X].w = x_range.min;
1108
1109 /* Upper left Y */
1110 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
1111 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
1112 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
1113 dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
1114 dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
1115 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1116 dev->opt[OPT_TL_Y].constraint.range = &y_range;
1117 dev->val[OPT_TL_Y].w = y_range.min;
1118
1119 /* Bottom-right x */
1120 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
1121 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
1122 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
1123 dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
1124 dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
1125 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
1126 dev->opt[OPT_BR_X].constraint.range = &x_range;
1127 dev->val[OPT_BR_X].w = x_range.max;
1128
1129 /* Bottom-right y */
1130 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
1131 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
1132 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
1133 dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
1134 dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
1135 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1136 dev->opt[OPT_BR_Y].constraint.range = &y_range;
1137 dev->val[OPT_BR_Y].w = y_range.max;
1138
1139 /* Enhancement group */
1140 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
1141 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
1142 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
1143 dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
1144 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
1145 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1146
1147 /* Halftone pattern */
1148 dev->opt[OPT_DITHER].name = "dither";
1149 dev->opt[OPT_DITHER].title = SANE_I18N ("Dither");
1150 dev->opt[OPT_DITHER].desc = SANE_I18N ("Dither");
1151 dev->opt[OPT_DITHER].type = SANE_TYPE_STRING;
1152 dev->opt[OPT_DITHER].size = max_string_size (dither_list);
1153 dev->opt[OPT_DITHER].cap |= SANE_CAP_INACTIVE;
1154 dev->opt[OPT_DITHER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1155 dev->opt[OPT_DITHER].constraint.string_list = dither_list;
1156 dev->val[OPT_DITHER].s = strdup (dither_list[0]);
1157
1158 /* custom-gamma table */
1159 dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
1160 dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
1161 dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
1162 dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
1163 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1164 dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
1165
1166 /* red gamma vector */
1167 dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
1168 dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
1169 dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
1170 dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
1171 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1172 dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
1173 dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word);
1174 dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
1175 dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range;
1176 dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R;
1177
1178 /* green and gamma vector */
1179 dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
1180 dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
1181 dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
1182 dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
1183 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1184 dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
1185 dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word);
1186 dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
1187 dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range;
1188 dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G;
1189
1190 /* blue gamma vector */
1191 dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
1192 dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
1193 dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
1194 dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
1195 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1196 dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
1197 dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word);
1198 dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
1199 dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range;
1200 dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B;
1201
1202 /* grayscale gamma vector */
1203 dev->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR;
1204 dev->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR;
1205 dev->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR;
1206 dev->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT;
1207 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
1208 dev->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE;
1209 dev->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word);
1210 dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE;
1211 dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &gamma_range;
1212 dev->val[OPT_GAMMA_VECTOR_GRAY].wa = dev->gamma_GRAY;
1213
1214 /* Threshold */
1215 dev->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
1216 dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
1217 dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
1218 dev->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
1219 dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
1220 dev->opt[OPT_THRESHOLD].size = sizeof (SANE_Int);
1221 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
1222 dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
1223 dev->opt[OPT_THRESHOLD].constraint.range = &threshold_range;
1224 dev->val[OPT_THRESHOLD].w = 128;
1225
1226 /* preview */
1227 dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
1228 dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
1229 dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
1230 dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
1231 dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
1232 dev->val[OPT_PREVIEW].w = SANE_FALSE;
1233
1234 /* Lastly, set the default scan mode. This might change some
1235 * values previously set here. */
1236 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
1237 (SANE_String_Const *) scan_mode_list[0], NULL);
1238 }
1239
1240 /*
1241 * Wait until the scanner is ready.
1242 */
1243 static SANE_Status
teco_wait_scanner(Teco_Scanner * dev)1244 teco_wait_scanner (Teco_Scanner * dev)
1245 {
1246 SANE_Status status;
1247 int timeout;
1248 CDB cdb;
1249
1250 DBG (DBG_proc, "teco_wait_scanner: enter\n");
1251
1252 MKSCSI_TEST_UNIT_READY (cdb);
1253
1254 /* Set the timeout to 60 seconds. */
1255 timeout = 60;
1256
1257 while (timeout > 0)
1258 {
1259
1260 /* test unit ready */
1261 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1262 NULL, 0, NULL, NULL);
1263
1264 if (status == SANE_STATUS_GOOD)
1265 {
1266 return SANE_STATUS_GOOD;
1267 }
1268
1269 sleep (1);
1270 };
1271
1272 DBG (DBG_proc, "teco_wait_scanner: scanner not ready\n");
1273 return (SANE_STATUS_IO_ERROR);
1274 }
1275
1276 /* Read the image from the scanner and fill the temporary buffer with it. */
1277 static SANE_Status
teco_fill_image(Teco_Scanner * dev)1278 teco_fill_image (Teco_Scanner * dev)
1279 {
1280 SANE_Status status;
1281 size_t size;
1282 CDB cdb;
1283 unsigned char *image;
1284
1285 DBG (DBG_proc, "teco_fill_image: enter\n");
1286
1287 assert (dev->image_begin == dev->image_end);
1288 assert (dev->real_bytes_left > 0);
1289
1290 dev->image_begin = 0;
1291 dev->image_end = 0;
1292
1293 while (dev->real_bytes_left)
1294 {
1295 /*
1296 * Try to read the maximum number of bytes.
1297 */
1298 size = 0;
1299 while (size == 0)
1300 {
1301 status = get_filled_data_length (dev, &size);
1302 if (status)
1303 return (status);
1304 if (size == 0)
1305 usleep (100000); /* sleep 1/10th of second */
1306 }
1307
1308 if (size > dev->real_bytes_left)
1309 size = dev->real_bytes_left;
1310 if (size > dev->image_size - dev->image_end)
1311 size = dev->image_size - dev->image_end;
1312
1313 /* Always read a multiple of a line. */
1314 size = size - (size % dev->params.bytes_per_line);
1315
1316 if (size == 0)
1317 {
1318 /* Probably reached the end of the buffer.
1319 * Check, just in case. */
1320 assert (dev->image_end != 0);
1321 return (SANE_STATUS_GOOD);
1322 }
1323
1324 DBG (DBG_info, "teco_fill_image: to read = %ld bytes (bpl=%d)\n",
1325 (long) size, dev->params.bytes_per_line);
1326
1327 MKSCSI_READ_10 (cdb, 0, 0, size);
1328
1329 hexdump (DBG_info2, "teco_fill_image: READ_10 CDB", cdb.data, 10);
1330
1331 image = dev->image + dev->image_end;
1332
1333 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1334 NULL, 0, image, &size);
1335
1336 if (status != SANE_STATUS_GOOD)
1337 {
1338 DBG (DBG_error, "teco_fill_image: cannot read from the scanner\n");
1339 return status;
1340 }
1341
1342 /* The size this scanner returns is always a multiple of lines. */
1343 assert ((size % dev->params.bytes_per_line) == 0);
1344
1345 DBG (DBG_info, "teco_fill_image: real bytes left = %ld\n",
1346 (long) dev->real_bytes_left);
1347
1348 if (dev->scan_mode == TECO_COLOR)
1349 {
1350 if (dev->def->pass == 1)
1351 {
1352
1353 /* Reorder the lines. The scanner gives color by color for
1354 * each line. */
1355 unsigned char *src = image;
1356 int nb_lines = size / dev->params.bytes_per_line;
1357 int i, j;
1358
1359 for (i = 0; i < nb_lines; i++)
1360 {
1361
1362 unsigned char *dest = dev->buffer;
1363
1364 for (j = 0; j < dev->params.pixels_per_line; j++)
1365 {
1366 *dest = src[j + 0 * dev->params.pixels_per_line];
1367 dest++;
1368 *dest = src[j + 1 * dev->params.pixels_per_line];
1369 dest++;
1370 *dest = src[j + 2 * dev->params.pixels_per_line];
1371 dest++;
1372 }
1373
1374 /* Copy the line back. */
1375 memcpy (src, dev->buffer, dev->params.bytes_per_line);
1376
1377 src += dev->params.bytes_per_line;
1378 }
1379 }
1380 }
1381
1382 dev->image_end += size;
1383 dev->real_bytes_left -= size;
1384 }
1385
1386 return (SANE_STATUS_GOOD); /* unreachable */
1387 }
1388
1389 /* Copy from the raw buffer to the buffer given by the backend.
1390 *
1391 * len in input is the maximum length available in buf, and, in
1392 * output, is the length written into buf.
1393 */
1394 static void
teco_copy_raw_to_frontend(Teco_Scanner * dev,SANE_Byte * buf,size_t * len)1395 teco_copy_raw_to_frontend (Teco_Scanner * dev, SANE_Byte * buf, size_t * len)
1396 {
1397 size_t size;
1398
1399 size = dev->image_end - dev->image_begin;
1400 if (size > *len)
1401 {
1402 size = *len;
1403 }
1404 *len = size;
1405
1406 switch (dev->scan_mode)
1407 {
1408 case TECO_BW:
1409 {
1410 /* Invert black and white. */
1411 unsigned char *src = dev->image + dev->image_begin;
1412 size_t i;
1413
1414 for (i = 0; i < size; i++)
1415 {
1416 *buf = *src ^ 0xff;
1417 src++;
1418 buf++;
1419 }
1420 }
1421 break;
1422
1423 case TECO_GRAYSCALE:
1424 case TECO_COLOR:
1425 memcpy (buf, dev->image + dev->image_begin, size);
1426 break;
1427 }
1428
1429 dev->image_begin += size;
1430 }
1431
1432 /* Stop a scan. */
1433 static SANE_Status
do_cancel(Teco_Scanner * dev)1434 do_cancel (Teco_Scanner * dev)
1435 {
1436 DBG (DBG_sane_proc, "do_cancel enter\n");
1437
1438 if (dev->scanning == SANE_TRUE)
1439 {
1440
1441 /* Reset the scanner */
1442 dev->x_resolution = 300;
1443 dev->y_resolution = 300;
1444 dev->x_tl = 0;
1445 dev->y_tl = 0;
1446 dev->width = 0;
1447 dev->length = 0;
1448
1449 teco_set_window (dev);
1450
1451 teco_scan (dev);
1452
1453 teco_close (dev);
1454 }
1455
1456 dev->scanning = SANE_FALSE;
1457
1458 DBG (DBG_sane_proc, "do_cancel exit\n");
1459
1460 return SANE_STATUS_CANCELLED;
1461 }
1462
1463 /*--------------------------------------------------------------------------*/
1464
1465 /* Sane entry points */
1466
1467 SANE_Status
sane_init(SANE_Int * version_code,SANE_Auth_Callback __sane_unused__ authorize)1468 sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize)
1469 {
1470 FILE *fp;
1471 char dev_name[PATH_MAX];
1472 size_t len;
1473
1474 DBG_INIT ();
1475
1476 DBG (DBG_sane_init, "sane_init\n");
1477
1478 DBG (DBG_error, "This is sane-teco1 version %d.%d-%d\n", SANE_CURRENT_MAJOR,
1479 SANE_CURRENT_MINOR, BUILD);
1480 DBG (DBG_error, "(C) 2002 by Frank Zago\n");
1481
1482 if (version_code)
1483 {
1484 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD);
1485 }
1486
1487 fp = sanei_config_open (TECO_CONFIG_FILE);
1488 if (!fp)
1489 {
1490 /* default to /dev/scanner instead of insisting on config file */
1491 attach_scanner ("/dev/scanner", 0);
1492 return SANE_STATUS_GOOD;
1493 }
1494
1495 while (sanei_config_read (dev_name, sizeof (dev_name), fp))
1496 {
1497 if (dev_name[0] == '#') /* ignore line comments */
1498 continue;
1499 len = strlen (dev_name);
1500
1501 if (!len)
1502 continue; /* ignore empty lines */
1503
1504 sanei_config_attach_matching_devices (dev_name, attach_one);
1505 }
1506
1507 fclose (fp);
1508
1509 DBG (DBG_proc, "sane_init: leave\n");
1510
1511 return SANE_STATUS_GOOD;
1512 }
1513
1514 SANE_Status
sane_get_devices(const SANE_Device *** device_list,SANE_Bool __sane_unused__ local_only)1515 sane_get_devices (const SANE_Device *** device_list, SANE_Bool __sane_unused__ local_only)
1516 {
1517 Teco_Scanner *dev;
1518 int i;
1519
1520 DBG (DBG_proc, "sane_get_devices: enter\n");
1521
1522 if (devlist)
1523 free (devlist);
1524
1525 devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
1526 if (!devlist)
1527 return SANE_STATUS_NO_MEM;
1528
1529 i = 0;
1530 for (dev = first_dev; i < num_devices; dev = dev->next)
1531 devlist[i++] = &dev->sane;
1532 devlist[i++] = 0;
1533
1534 *device_list = devlist;
1535
1536 DBG (DBG_proc, "sane_get_devices: exit\n");
1537
1538 return SANE_STATUS_GOOD;
1539 }
1540
1541 SANE_Status
sane_open(SANE_String_Const devicename,SANE_Handle * handle)1542 sane_open (SANE_String_Const devicename, SANE_Handle * handle)
1543 {
1544 Teco_Scanner *dev;
1545 SANE_Status status;
1546
1547 DBG (DBG_proc, "sane_open: enter\n");
1548
1549 /* search for devicename */
1550 if (devicename[0])
1551 {
1552 DBG (DBG_info, "sane_open: devicename=%s\n", devicename);
1553
1554 for (dev = first_dev; dev; dev = dev->next)
1555 {
1556 if (strcmp (dev->sane.name, devicename) == 0)
1557 {
1558 break;
1559 }
1560 }
1561
1562 if (!dev)
1563 {
1564 status = attach_scanner (devicename, &dev);
1565 if (status != SANE_STATUS_GOOD)
1566 {
1567 return status;
1568 }
1569 }
1570 }
1571 else
1572 {
1573 DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n");
1574 dev = first_dev; /* empty devicename -> use first device */
1575 }
1576
1577 if (!dev)
1578 {
1579 DBG (DBG_error, "No scanner found\n");
1580
1581 return SANE_STATUS_INVAL;
1582 }
1583
1584 teco_init_options (dev);
1585
1586 /* Initialize the gamma table. */
1587 {
1588 /*
1589 * Shift is 1 for GAMMA_LENGTH == 256
1590 * and 4 for GAMMA_LENGTH == 1024
1591 */
1592 int shift = GAMMA_LENGTH >> 8;
1593 size_t i;
1594
1595 for (i = 0; i < GAMMA_LENGTH; i++)
1596 {
1597 dev->gamma_R[i] = i / shift;
1598 dev->gamma_G[i] = i / shift;
1599 dev->gamma_B[i] = i / shift;
1600 dev->gamma_GRAY[i] = i / shift;
1601 }
1602 }
1603
1604 *handle = dev;
1605
1606 DBG (DBG_proc, "sane_open: exit\n");
1607
1608 return SANE_STATUS_GOOD;
1609 }
1610
1611 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle,SANE_Int option)1612 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
1613 {
1614 Teco_Scanner *dev = handle;
1615
1616 DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option);
1617
1618 if ((unsigned) option >= OPT_NUM_OPTIONS)
1619 {
1620 return NULL;
1621 }
1622
1623 DBG (DBG_proc, "sane_get_option_descriptor: exit\n");
1624
1625 return dev->opt + option;
1626 }
1627
1628 SANE_Status
sane_control_option(SANE_Handle handle,SANE_Int option,SANE_Action action,void * val,SANE_Int * info)1629 sane_control_option (SANE_Handle handle, SANE_Int option,
1630 SANE_Action action, void *val, SANE_Int * info)
1631 {
1632 Teco_Scanner *dev = handle;
1633 SANE_Status status;
1634 SANE_Word cap;
1635 SANE_String_Const name;
1636
1637 DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n",
1638 option, action);
1639
1640 if (info)
1641 {
1642 *info = 0;
1643 }
1644
1645 if (dev->scanning)
1646 {
1647 return SANE_STATUS_DEVICE_BUSY;
1648 }
1649
1650 if (option < 0 || option >= OPT_NUM_OPTIONS)
1651 {
1652 return SANE_STATUS_INVAL;
1653 }
1654
1655 cap = dev->opt[option].cap;
1656 if (!SANE_OPTION_IS_ACTIVE (cap))
1657 {
1658 return SANE_STATUS_INVAL;
1659 }
1660
1661 name = dev->opt[option].name;
1662 if (!name)
1663 {
1664 name = "(no name)";
1665 }
1666 if (action == SANE_ACTION_GET_VALUE)
1667 {
1668
1669 switch (option)
1670 {
1671 /* word options */
1672 case OPT_NUM_OPTS:
1673 case OPT_RESOLUTION:
1674 case OPT_TL_Y:
1675 case OPT_BR_Y:
1676 case OPT_TL_X:
1677 case OPT_BR_X:
1678 case OPT_CUSTOM_GAMMA:
1679 case OPT_THRESHOLD:
1680 case OPT_PREVIEW:
1681 *(SANE_Word *) val = dev->val[option].w;
1682 return SANE_STATUS_GOOD;
1683
1684 /* string options */
1685 case OPT_MODE:
1686 case OPT_DITHER:
1687 strcpy (val, dev->val[option].s);
1688 return SANE_STATUS_GOOD;
1689
1690 /* Gamma */
1691 case OPT_GAMMA_VECTOR_R:
1692 case OPT_GAMMA_VECTOR_G:
1693 case OPT_GAMMA_VECTOR_B:
1694 case OPT_GAMMA_VECTOR_GRAY:
1695 memcpy (val, dev->val[option].wa, dev->opt[option].size);
1696 return SANE_STATUS_GOOD;
1697
1698 default:
1699 return SANE_STATUS_INVAL;
1700 }
1701 }
1702 else if (action == SANE_ACTION_SET_VALUE)
1703 {
1704
1705 if (!SANE_OPTION_IS_SETTABLE (cap))
1706 {
1707 DBG (DBG_error, "could not set option, not settable\n");
1708 return SANE_STATUS_INVAL;
1709 }
1710
1711 status = sanei_constrain_value (dev->opt + option, val, info);
1712 if (status != SANE_STATUS_GOOD)
1713 {
1714 DBG (DBG_error, "could not set option, invalid value\n");
1715 return status;
1716 }
1717
1718 switch (option)
1719 {
1720
1721 /* Numeric side-effect options */
1722 case OPT_TL_Y:
1723 case OPT_BR_Y:
1724 case OPT_TL_X:
1725 case OPT_BR_X:
1726 case OPT_RESOLUTION:
1727 if (info)
1728 {
1729 *info |= SANE_INFO_RELOAD_PARAMS;
1730 }
1731 dev->val[option].w = *(SANE_Word *) val;
1732 return SANE_STATUS_GOOD;
1733
1734 /* Numeric side-effect free options */
1735 case OPT_THRESHOLD:
1736 case OPT_PREVIEW:
1737 dev->val[option].w = *(SANE_Word *) val;
1738 return SANE_STATUS_GOOD;
1739
1740 /* String side-effect free options */
1741 case OPT_DITHER:
1742 free (dev->val[option].s);
1743 dev->val[option].s = (SANE_String) strdup (val);
1744 return SANE_STATUS_GOOD;
1745
1746 /* String side-effect options */
1747 case OPT_MODE:
1748 if (strcmp (dev->val[option].s, val) == 0)
1749 return SANE_STATUS_GOOD;
1750
1751 free (dev->val[OPT_MODE].s);
1752 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
1753
1754 dev->opt[OPT_DITHER].cap |= SANE_CAP_INACTIVE;
1755 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1756 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1757 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1758 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1759 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
1760 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
1761
1762 if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0)
1763 {
1764 dev->depth = 8;
1765 dev->scan_mode = TECO_BW;
1766 dev->opt[OPT_DITHER].cap &= ~SANE_CAP_INACTIVE;
1767 dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
1768 }
1769 else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0)
1770 {
1771 dev->scan_mode = TECO_GRAYSCALE;
1772 dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1773 if (dev->val[OPT_CUSTOM_GAMMA].w)
1774 {
1775 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE;
1776 }
1777 dev->depth = 8;
1778 }
1779 else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0)
1780 {
1781 dev->scan_mode = TECO_COLOR;
1782 dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1783 if (dev->val[OPT_CUSTOM_GAMMA].w)
1784 {
1785 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1786 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1787 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1788 }
1789 dev->depth = 8;
1790 }
1791
1792 if (info)
1793 {
1794 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
1795 }
1796 return SANE_STATUS_GOOD;
1797
1798 case OPT_GAMMA_VECTOR_R:
1799 case OPT_GAMMA_VECTOR_G:
1800 case OPT_GAMMA_VECTOR_B:
1801 case OPT_GAMMA_VECTOR_GRAY:
1802 memcpy (dev->val[option].wa, val, dev->opt[option].size);
1803 return SANE_STATUS_GOOD;
1804
1805 case OPT_CUSTOM_GAMMA:
1806 dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val;
1807 if (dev->val[OPT_CUSTOM_GAMMA].w)
1808 {
1809 /* use custom_gamma_table */
1810 if (dev->scan_mode == TECO_GRAYSCALE)
1811 {
1812 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE;
1813 }
1814 else
1815 {
1816 /* color mode */
1817 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1818 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1819 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1820 }
1821 }
1822 else
1823 {
1824 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1825 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1826 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1827 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
1828 }
1829 if (info)
1830 {
1831 *info |= SANE_INFO_RELOAD_OPTIONS;
1832 }
1833 return SANE_STATUS_GOOD;
1834
1835 default:
1836 return SANE_STATUS_INVAL;
1837 }
1838 }
1839
1840 DBG (DBG_proc, "sane_control_option: exit, bad\n");
1841
1842 return SANE_STATUS_UNSUPPORTED;
1843 }
1844
1845 SANE_Status
sane_get_parameters(SANE_Handle handle,SANE_Parameters * params)1846 sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
1847 {
1848 Teco_Scanner *dev = handle;
1849
1850 DBG (DBG_proc, "sane_get_parameters: enter\n");
1851
1852 if (!(dev->scanning))
1853 {
1854
1855 /* Setup the parameters for the scan. These values will be re-used
1856 * in the SET WINDOWS command. */
1857 if (dev->val[OPT_PREVIEW].w == SANE_TRUE)
1858 {
1859 dev->x_resolution = 22;
1860 dev->y_resolution = 22;
1861 dev->x_tl = 0;
1862 dev->y_tl = 0;
1863 dev->x_br = mmToIlu (SANE_UNFIX (x_range.max));
1864 dev->y_br = mmToIlu (SANE_UNFIX (y_range.max));
1865 }
1866 else
1867 {
1868 dev->x_resolution = dev->val[OPT_RESOLUTION].w;
1869 dev->y_resolution = dev->val[OPT_RESOLUTION].w;
1870 if (dev->x_resolution > dev->def->x_resolution_max)
1871 {
1872 dev->x_resolution = dev->def->x_resolution_max;
1873 }
1874
1875 dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
1876 dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
1877 dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
1878 dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
1879 }
1880
1881 /* Check the corners are OK. */
1882 if (dev->x_tl > dev->x_br)
1883 {
1884 int s;
1885 s = dev->x_tl;
1886 dev->x_tl = dev->x_br;
1887 dev->x_br = s;
1888 }
1889 if (dev->y_tl > dev->y_br)
1890 {
1891 int s;
1892 s = dev->y_tl;
1893 dev->y_tl = dev->y_br;
1894 dev->y_br = s;
1895 }
1896
1897 dev->width = dev->x_br - dev->x_tl;
1898 dev->length = dev->y_br - dev->y_tl;
1899
1900 /* Prepare the parameters for the caller. */
1901 memset (&dev->params, 0, sizeof (SANE_Parameters));
1902
1903 dev->params.last_frame = SANE_TRUE;
1904
1905 switch (dev->scan_mode)
1906 {
1907 case TECO_BW:
1908 dev->params.format = SANE_FRAME_GRAY;
1909 dev->params.pixels_per_line =
1910 ((dev->width * dev->x_resolution) / 300) & ~0x7;
1911 dev->params.bytes_per_line = dev->params.pixels_per_line / 8;
1912 dev->params.depth = 1;
1913 dev->pass = 1;
1914 break;
1915 case TECO_GRAYSCALE:
1916 dev->params.format = SANE_FRAME_GRAY;
1917 dev->params.pixels_per_line =
1918 ((dev->width * dev->x_resolution) / 300);
1919 dev->params.bytes_per_line = dev->params.pixels_per_line;
1920 dev->params.depth = 8;
1921 dev->pass = 1;
1922 break;
1923 case TECO_COLOR:
1924 dev->params.format = SANE_FRAME_RGB;
1925 dev->params.pixels_per_line =
1926 ((dev->width * dev->x_resolution) / 300);
1927 dev->pass = dev->def->pass;
1928 dev->params.bytes_per_line = dev->params.pixels_per_line * 3;
1929 dev->params.depth = 8;
1930 break;
1931 }
1932
1933 dev->params.lines = (dev->length * dev->y_resolution) / 300;
1934 }
1935
1936 /* Return the current values. */
1937 if (params)
1938 {
1939 *params = (dev->params);
1940 }
1941
1942 DBG (DBG_proc, "sane_get_parameters: exit\n");
1943
1944 return SANE_STATUS_GOOD;
1945 }
1946
1947 SANE_Status
sane_start(SANE_Handle handle)1948 sane_start (SANE_Handle handle)
1949 {
1950 Teco_Scanner *dev = handle;
1951 SANE_Status status;
1952 size_t size;
1953
1954 DBG (DBG_proc, "sane_start: enter\n");
1955
1956 if (!(dev->scanning))
1957 {
1958
1959 /* Open again the scanner. */
1960 if (sanei_scsi_open
1961 (dev->devicename, &(dev->sfd), teco_sense_handler, dev) != 0)
1962 {
1963 DBG (DBG_error, "ERROR: sane_start: open failed\n");
1964 return SANE_STATUS_INVAL;
1965 }
1966
1967 /* Set the correct parameters. */
1968 sane_get_parameters (dev, NULL);
1969
1970 /* The scanner must be ready. */
1971 status = teco_wait_scanner (dev);
1972 if (status)
1973 {
1974 teco_close (dev);
1975 return status;
1976 }
1977
1978 status = teco_mode_select (dev);
1979 if (status)
1980 {
1981 teco_close (dev);
1982 return status;
1983 }
1984
1985 if (dev->scan_mode == TECO_COLOR)
1986 {
1987 dev->pass = dev->def->pass;
1988 }
1989 else
1990 {
1991 dev->pass = 1;
1992 }
1993
1994 if (dev->def->tecoref != TECO_VM3510)
1995 {
1996 status = teco_set_window (dev);
1997 if (status)
1998 {
1999 teco_close (dev);
2000 return status;
2001 }
2002
2003 dev->real_bytes_left = 0;
2004 status = get_filled_data_length (dev, &size);
2005 if (status)
2006 {
2007 teco_close (dev);
2008 return status;
2009 }
2010 }
2011
2012 #if 0
2013 /* The windows driver does that, but some scanners don't like it. */
2014 teco_vendor_spec (dev);
2015 if (status)
2016 {
2017 teco_close (dev);
2018 return status;
2019 }
2020 #endif
2021
2022 status = teco_send_gamma (dev);
2023 if (status)
2024 {
2025 teco_close (dev);
2026 return status;
2027 }
2028
2029 status = teco_set_window (dev);
2030 if (status)
2031 {
2032 teco_close (dev);
2033 return status;
2034 }
2035
2036 status = teco_scan (dev);
2037 if (status)
2038 {
2039 teco_close (dev);
2040 return status;
2041 }
2042
2043 if (dev->def->tecoref == TECO_VM3510)
2044 {
2045 dev->real_bytes_left = 0;
2046 status = get_filled_data_length (dev, &size);
2047 if (status)
2048 {
2049 teco_close (dev);
2050 return status;
2051 }
2052 }
2053 }
2054 else
2055 {
2056 /* Scan has already started. */
2057 dev->pass--;
2058 }
2059
2060 /* Set the frame parameter. */
2061 if (dev->scan_mode == TECO_COLOR && dev->def->pass > 1)
2062 {
2063 SANE_Frame frames[] = { 0, SANE_FRAME_BLUE,
2064 SANE_FRAME_GREEN, SANE_FRAME_RED
2065 };
2066 dev->params.format = frames[dev->pass];
2067 }
2068
2069 /* Is it the last frame? */
2070 if (dev->pass > 1)
2071 {
2072 dev->params.last_frame = SANE_FALSE;
2073 }
2074 else
2075 {
2076 dev->params.last_frame = SANE_TRUE;
2077 }
2078
2079 dev->image_end = 0;
2080 dev->image_begin = 0;
2081
2082 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
2083 dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines;
2084
2085 dev->scanning = SANE_TRUE;
2086
2087 DBG (DBG_proc, "sane_start: exit\n");
2088
2089 return SANE_STATUS_GOOD;
2090 }
2091
2092 SANE_Status
sane_read(SANE_Handle handle,SANE_Byte * buf,SANE_Int max_len,SANE_Int * len)2093 sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
2094 SANE_Int * len)
2095 {
2096 SANE_Status status;
2097 Teco_Scanner *dev = handle;
2098 size_t size;
2099 int buf_offset; /* offset into buf */
2100
2101 DBG (DBG_proc, "sane_read: enter\n");
2102
2103 *len = 0;
2104
2105 if (!(dev->scanning))
2106 {
2107 /* OOPS, not scanning */
2108 return do_cancel (dev);
2109 }
2110
2111 if (dev->bytes_left <= 0)
2112 {
2113 return (SANE_STATUS_EOF);
2114 }
2115
2116 buf_offset = 0;
2117
2118 do
2119 {
2120 if (dev->image_begin == dev->image_end)
2121 {
2122 /* Fill image */
2123 status = teco_fill_image (dev);
2124 if (status != SANE_STATUS_GOOD)
2125 {
2126 return (status);
2127 }
2128 }
2129
2130 /* Something must have been read */
2131 if (dev->image_begin == dev->image_end)
2132 {
2133 DBG (DBG_info, "sane_read: nothing read\n");
2134 return SANE_STATUS_IO_ERROR;
2135 }
2136
2137 /* Copy the data to the frontend buffer. */
2138 size = max_len - buf_offset;
2139 if (size > dev->bytes_left)
2140 {
2141 size = dev->bytes_left;
2142 }
2143 teco_copy_raw_to_frontend (dev, buf + buf_offset, &size);
2144
2145 buf_offset += size;
2146
2147 dev->bytes_left -= size;
2148 *len += size;
2149
2150 }
2151 while ((buf_offset != max_len) && dev->bytes_left);
2152
2153 DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n",
2154 (long) dev->bytes_left);
2155
2156 return SANE_STATUS_GOOD;
2157 }
2158
2159 SANE_Status
sane_set_io_mode(SANE_Handle __sane_unused__ handle,SANE_Bool __sane_unused__ non_blocking)2160 sane_set_io_mode (SANE_Handle __sane_unused__ handle, SANE_Bool __sane_unused__ non_blocking)
2161 {
2162 SANE_Status status;
2163 Teco_Scanner *dev = handle;
2164
2165 DBG (DBG_proc, "sane_set_io_mode: enter\n");
2166
2167 if (dev->scanning == SANE_FALSE)
2168 {
2169 return SANE_STATUS_INVAL;
2170 }
2171
2172 if (non_blocking == SANE_FALSE)
2173 {
2174 status = SANE_STATUS_GOOD;
2175 }
2176 else
2177 {
2178 status = SANE_STATUS_UNSUPPORTED;
2179 }
2180
2181 DBG (DBG_proc, "sane_set_io_mode: exit\n");
2182
2183 return status;
2184 }
2185
2186 SANE_Status
sane_get_select_fd(SANE_Handle __sane_unused__ handle,SANE_Int __sane_unused__ * fd)2187 sane_get_select_fd (SANE_Handle __sane_unused__ handle, SANE_Int __sane_unused__ *fd)
2188 {
2189 DBG (DBG_proc, "sane_get_select_fd: enter\n");
2190
2191 DBG (DBG_proc, "sane_get_select_fd: exit\n");
2192
2193 return SANE_STATUS_UNSUPPORTED;
2194 }
2195
2196 void
sane_cancel(SANE_Handle handle)2197 sane_cancel (SANE_Handle handle)
2198 {
2199 Teco_Scanner *dev = handle;
2200
2201 DBG (DBG_proc, "sane_cancel: enter\n");
2202
2203 do_cancel (dev);
2204
2205 DBG (DBG_proc, "sane_cancel: exit\n");
2206 }
2207
2208 void
sane_close(SANE_Handle handle)2209 sane_close (SANE_Handle handle)
2210 {
2211 Teco_Scanner *dev = handle;
2212 Teco_Scanner *dev_tmp;
2213
2214 DBG (DBG_proc, "sane_close: enter\n");
2215
2216 do_cancel (dev);
2217 teco_close (dev);
2218
2219 /* Unlink dev. */
2220 if (first_dev == dev)
2221 {
2222 first_dev = dev->next;
2223 }
2224 else
2225 {
2226 dev_tmp = first_dev;
2227 while (dev_tmp->next && dev_tmp->next != dev)
2228 {
2229 dev_tmp = dev_tmp->next;
2230 }
2231 if (dev_tmp->next != NULL)
2232 {
2233 dev_tmp->next = dev_tmp->next->next;
2234 }
2235 }
2236
2237 teco_free (dev);
2238 num_devices--;
2239
2240 DBG (DBG_proc, "sane_close: exit\n");
2241 }
2242
2243 void
sane_exit(void)2244 sane_exit (void)
2245 {
2246 DBG (DBG_proc, "sane_exit: enter\n");
2247
2248 while (first_dev)
2249 {
2250 sane_close (first_dev);
2251 }
2252
2253 if (devlist)
2254 {
2255 free (devlist);
2256 devlist = NULL;
2257 }
2258
2259 DBG (DBG_proc, "sane_exit: exit\n");
2260 }
2261