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