1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2002-2003 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 Across FS-1130
44 */
45
46 /*--------------------------------------------------------------------------*/
47
48 #define BUILD 11 /* 2004/06/30 */
49 #define BACKEND_NAME leo
50 #define LEO_CONFIG_FILE "leo.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 "leo.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 =
93 { SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0 };
94
95 /*--------------------------------------------------------------------------*/
96
97 static const SANE_Range gamma_range = {
98 0, /* minimum */
99 255, /* maximum */
100 0 /* quantization */
101 };
102
103 /*--------------------------------------------------------------------------*/
104
105 static SANE_String_Const halftone_pattern_list[] = {
106 SANE_I18N ("None"),
107 SANE_I18N ("Diamond"),
108 SANE_I18N ("8x8 Coarse Fatting"),
109 SANE_I18N ("8x8 Fine Fatting"),
110 SANE_I18N ("8x8 Bayer"),
111 SANE_I18N ("8x8 Vertical Line"),
112 NULL
113 };
114
115 static const halftone_pattern_t *const halftone_pattern_val[] = {
116 NULL,
117 &haltfone_pattern_diamond,
118 &haltfone_pattern_8x8_Coarse_Fatting,
119 &haltfone_pattern_8x8_Fine_Fatting,
120 &haltfone_pattern_8x8_Bayer,
121 &haltfone_pattern_8x8_Vertical_Line
122 };
123
124 /*--------------------------------------------------------------------------*/
125
126 /* Define the supported scanners and their characteristics. */
127 static const struct scanners_supported scanners[] = {
128 {6, "ACROSS ", " ",
129 "Across", "FS-1130"},
130 {6, "LEO ", "LEOScan-S3 ",
131 "Leo", "S3"},
132 {6, "LEO", "LEOScan-S3",
133 "Leo", "S3"},
134 {6, "KYE CORP", "ColorPage-CS ",
135 "Genius", "FS1130"}
136 };
137
138 /*--------------------------------------------------------------------------*/
139
140 /* List of scanner attached. */
141 static Leo_Scanner *first_dev = NULL;
142 static int num_devices = 0;
143 static const SANE_Device **devlist = NULL;
144
145
146 /* Local functions. */
147
148 /* Display a buffer in the log. */
149 static void
hexdump(int level,const char * comment,unsigned char * p,int l)150 hexdump (int level, const char *comment, unsigned char *p, int l)
151 {
152 int i;
153 char line[128];
154 char *ptr;
155 char asc_buf[17];
156 char *asc_ptr;
157
158 DBG (level, "%s\n", comment);
159
160 ptr = line;
161 *ptr = '\0';
162 asc_ptr = asc_buf;
163 *asc_ptr = '\0';
164
165 for (i = 0; i < l; i++, p++)
166 {
167 if ((i % 16) == 0)
168 {
169 if (ptr != line)
170 {
171 DBG (level, "%s %s\n", line, asc_buf);
172 ptr = line;
173 *ptr = '\0';
174 asc_ptr = asc_buf;
175 *asc_ptr = '\0';
176 }
177 sprintf (ptr, "%3.3d:", i);
178 ptr += 4;
179 }
180 ptr += sprintf (ptr, " %2.2x", *p);
181 if (*p >= 32 && *p <= 127)
182 {
183 asc_ptr += sprintf (asc_ptr, "%c", *p);
184 }
185 else
186 {
187 asc_ptr += sprintf (asc_ptr, ".");
188 }
189 }
190 *ptr = '\0';
191 DBG (level, "%s %s\n", line, asc_buf);
192 }
193
194 /* Returns the length of the longest string, including the terminating
195 * character. */
196 static size_t
max_string_size(SANE_String_Const strings[])197 max_string_size (SANE_String_Const strings[])
198 {
199 size_t size, max_size = 0;
200 int i;
201
202 for (i = 0; strings[i]; ++i)
203 {
204 size = strlen (strings[i]) + 1;
205 if (size > max_size)
206 {
207 max_size = size;
208 }
209 }
210
211 return max_size;
212 }
213
214 /* Lookup a string list from one array and return its index. */
215 static int
get_string_list_index(SANE_String_Const list[],SANE_String_Const name)216 get_string_list_index (SANE_String_Const list[], SANE_String_Const name)
217 {
218 int index;
219
220 index = 0;
221 while (list[index] != NULL)
222 {
223 if (strcmp (list[index], name) == 0)
224 {
225 return (index);
226 }
227 index++;
228 }
229
230 DBG (DBG_error, "name %s not found in list\n", name);
231
232 assert (0 == 1); /* bug in backend, core dump */
233
234 return (-1);
235 }
236
237 /* Initialize a scanner entry. Return an allocated scanner with some
238 * preset values. */
239 static Leo_Scanner *
leo_init(void)240 leo_init (void)
241 {
242 Leo_Scanner *dev;
243
244 DBG (DBG_proc, "leo_init: enter\n");
245
246 /* Allocate a new scanner entry. */
247 dev = malloc (sizeof (Leo_Scanner));
248 if (dev == NULL)
249 {
250 return NULL;
251 }
252
253 memset (dev, 0, sizeof (Leo_Scanner));
254
255 /* Allocate the buffer used to transfer the SCSI data. */
256 dev->buffer_size = 64 * 1024;
257 dev->buffer = malloc (dev->buffer_size);
258 if (dev->buffer == NULL)
259 {
260 free (dev);
261 return NULL;
262 }
263
264 /* Allocate a buffer to store the temporary image. */
265 dev->image_size = 64 * 1024; /* enough for 1 line at max res */
266 dev->image = malloc (dev->image_size);
267 if (dev->image == NULL)
268 {
269 free (dev->buffer);
270 free (dev);
271 return NULL;
272 }
273
274 dev->sfd = -1;
275
276 DBG (DBG_proc, "leo_init: exit\n");
277
278 return (dev);
279 }
280
281 /* Closes an open scanner. */
282 static void
leo_close(Leo_Scanner * dev)283 leo_close (Leo_Scanner * dev)
284 {
285 DBG (DBG_proc, "leo_close: enter\n");
286
287 if (dev->sfd != -1)
288 {
289 sanei_scsi_close (dev->sfd);
290 dev->sfd = -1;
291 }
292
293 DBG (DBG_proc, "leo_close: exit\n");
294 }
295
296 /* Frees the memory used by a scanner. */
297 static void
leo_free(Leo_Scanner * dev)298 leo_free (Leo_Scanner * dev)
299 {
300 int i;
301
302 DBG (DBG_proc, "leo_free: enter\n");
303
304 if (dev == NULL)
305 return;
306
307 leo_close (dev);
308 if (dev->devicename)
309 {
310 free (dev->devicename);
311 }
312 if (dev->buffer)
313 {
314 free (dev->buffer);
315 }
316 if (dev->image)
317 {
318 free (dev->image);
319 }
320
321 for (i = 1; i < OPT_NUM_OPTIONS; i++)
322 {
323 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
324 {
325 free (dev->val[i].s);
326 }
327 }
328
329 free (dev);
330
331 DBG (DBG_proc, "leo_free: exit\n");
332 }
333
334 /* Inquiry a device and returns TRUE if is supported. */
335 static int
leo_identify_scanner(Leo_Scanner * dev)336 leo_identify_scanner (Leo_Scanner * dev)
337 {
338 CDB cdb;
339 SANE_Status status;
340 size_t size;
341 int i;
342
343 DBG (DBG_proc, "leo_identify_scanner: enter\n");
344
345 size = 5;
346 MKSCSI_INQUIRY (cdb, size);
347 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
348 NULL, 0, dev->buffer, &size);
349
350 if (status)
351 {
352 DBG (DBG_error,
353 "leo_identify_scanner: inquiry failed with status %s\n",
354 sane_strstatus (status));
355 return (SANE_FALSE);
356 }
357
358 size = dev->buffer[4] + 5; /* total length of the inquiry data */
359
360 if (size < 36)
361 {
362 DBG (DBG_error,
363 "leo_identify_scanner: not enough data to identify device\n");
364 return (SANE_FALSE);
365 }
366
367 MKSCSI_INQUIRY (cdb, size);
368 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
369 NULL, 0, dev->buffer, &size);
370
371 if (status)
372 {
373 DBG (DBG_error,
374 "leo_identify_scanner: inquiry failed with status %s\n",
375 sane_strstatus (status));
376 return (SANE_FALSE);
377 }
378
379 dev->scsi_type = dev->buffer[0] & 0x1f;
380 memcpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
381 dev->scsi_vendor[0x08] = 0;
382 memcpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
383 dev->scsi_product[0x10] = 0;
384 memcpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
385 dev->scsi_version[0x04] = 0;
386
387 DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n",
388 dev->scsi_vendor, dev->scsi_product, dev->scsi_version);
389
390 /* Lookup through the supported scanners table to find if this
391 * backend supports that one. */
392 for (i = 0; i < NELEMS (scanners); i++)
393 {
394 if (dev->scsi_type == scanners[i].scsi_type &&
395 strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 &&
396 strcmp (dev->scsi_product, scanners[i].scsi_product) == 0)
397 {
398
399 DBG (DBG_error, "leo_identify_scanner: scanner supported\n");
400
401 /* Get the full inquiry, since that scanner does not fill
402 the length correctly. */
403 size = 0x30;
404 MKSCSI_INQUIRY (cdb, size);
405 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
406 NULL, 0, dev->buffer, &size);
407 if (status != SANE_STATUS_GOOD)
408 {
409 return (SANE_FALSE);
410 }
411
412 hexdump (DBG_info2, "inquiry", dev->buffer, size);
413
414 dev->def = &(scanners[i]);
415 dev->res_range.min = 1;
416 dev->res_range.max = B16TOI (&dev->buffer[42]);
417
418 dev->x_resolution_max = B16TOI (&dev->buffer[40]);
419 dev->y_resolution_max = B16TOI (&dev->buffer[42]);
420
421
422 return (SANE_TRUE);
423 }
424 }
425
426 DBG (DBG_proc, "leo_identify_scanner: exit, device not supported\n");
427
428 return (SANE_FALSE);
429 }
430
431 /* SCSI sense handler. Callback for SANE. */
432 static SANE_Status
leo_sense_handler(int scsi_fd,unsigned char * result,void __sane_unused__ * arg)433 leo_sense_handler (int scsi_fd, unsigned char *result, void __sane_unused__ *arg)
434 {
435 int asc, ascq, sensekey;
436 int len;
437
438 DBG (DBG_proc, "leo_sense_handler (scsi_fd = %d)\n", scsi_fd);
439
440 sensekey = get_RS_sense_key (result);
441 len = 7 + get_RS_additional_length (result);
442
443 hexdump (DBG_info2, "sense", result, len);
444
445 if (get_RS_error_code (result) != 0x70)
446 {
447 DBG (DBG_error,
448 "leo_sense_handler: invalid sense key error code (%d)\n",
449 get_RS_error_code (result));
450
451 return SANE_STATUS_IO_ERROR;
452 }
453
454 if (get_RS_ILI (result) != 0)
455 {
456 DBG (DBG_sense, "leo_sense_handler: short read\n");
457 }
458
459 if (len < 14)
460 {
461 DBG (DBG_error, "leo_sense_handler: sense too short, no ASC/ASCQ\n");
462
463 return SANE_STATUS_IO_ERROR;
464 }
465
466 asc = get_RS_ASC (result);
467 ascq = get_RS_ASCQ (result);
468
469 DBG (DBG_sense, "leo_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n",
470 sensekey, asc, ascq);
471
472 switch (sensekey)
473 {
474 case 0x00: /* no sense */
475 case 0x02: /* not ready */
476 case 0x03: /* medium error */
477 case 0x05:
478 case 0x06:
479 break;
480 }
481
482 DBG (DBG_sense,
483 "leo_sense_handler: unknown error condition. Please report it to the backend maintainer\n");
484
485 return SANE_STATUS_IO_ERROR;
486 }
487
488 /* Set a window. */
489 static SANE_Status
leo_set_window(Leo_Scanner * dev)490 leo_set_window (Leo_Scanner * dev)
491 {
492 size_t size;
493 CDB cdb;
494 unsigned char window[48];
495 SANE_Status status;
496
497 DBG (DBG_proc, "leo_set_window: enter\n");
498
499 size = sizeof (window);
500 MKSCSI_SET_WINDOW (cdb, size);
501
502 memset (window, 0, size);
503
504 /* size of the windows descriptor block */
505 window[7] = sizeof (window) - 8;
506 window[1] = sizeof (window) - 2;
507
508 /* X and Y resolution */
509 Ito16 (dev->x_resolution, &window[10]);
510 Ito16 (dev->y_resolution, &window[12]);
511
512 /* Upper Left (X,Y) */
513 Ito32 (dev->x_tl, &window[14]);
514 Ito32 (dev->y_tl, &window[18]);
515
516 /* Width and length */
517 Ito32 (dev->width, &window[22]);
518 Ito32 (dev->length, &window[26]);
519
520
521 /* Image Composition */
522 switch (dev->scan_mode)
523 {
524 case LEO_BW:
525 window[33] = 0x00;
526 break;
527 case LEO_HALFTONE:
528 window[33] = 0x01;
529 break;
530 case LEO_GRAYSCALE:
531 window[33] = 0x02;
532 break;
533 case LEO_COLOR:
534 window[33] = 0x05;
535 break;
536 }
537
538 /* Depth */
539 window[34] = dev->depth;
540
541 /* Unknown - invariants */
542 window[31] = 0x80;
543 window[43] = 0x01;
544
545 hexdump (DBG_info2, "windows", window, sizeof (window));
546
547 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
548 window, sizeof (window), NULL, NULL);
549
550 DBG (DBG_proc, "leo_set_window: exit, status=%d\n", status);
551
552 return status;
553 }
554
555 /* Read the size of the scan. */
556 static SANE_Status
leo_get_scan_size(Leo_Scanner * dev)557 leo_get_scan_size (Leo_Scanner * dev)
558 {
559 size_t size;
560 CDB cdb;
561 SANE_Status status;
562
563 DBG (DBG_proc, "leo_get_scan_size: enter\n");
564
565 size = 0x10;
566 MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size);
567 hexdump (DBG_info2, "CDB:", cdb.data, cdb.len);
568 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
569 NULL, 0, dev->buffer, &size);
570
571 if (size != 0x10)
572 {
573 DBG (DBG_error,
574 "leo_get_scan_size: GET DATA BUFFER STATUS returned an invalid size (%ld)\n",
575 (long) size);
576 return SANE_STATUS_IO_ERROR;
577 }
578
579 hexdump (DBG_info2, "leo_get_scan_size return", dev->buffer, size);
580
581
582 dev->params.pixels_per_line = B16TOI (&dev->buffer[14]);
583
584 /* The number of lines if the number of lines left plus the number
585 * of lines already waiting in the buffer. */
586 dev->params.lines = B16TOI (&dev->buffer[12]) +
587 (B24TOI (&dev->buffer[9]) / dev->params.bytes_per_line);
588
589 switch (dev->scan_mode)
590 {
591 case LEO_BW:
592 case LEO_HALFTONE:
593 dev->params.pixels_per_line &= ~0x7;
594 dev->params.bytes_per_line = dev->params.pixels_per_line / 8;
595 break;
596 case LEO_GRAYSCALE:
597 dev->params.bytes_per_line = dev->params.pixels_per_line;
598 break;
599 case LEO_COLOR:
600 dev->params.bytes_per_line = dev->params.pixels_per_line * 3;
601 break;
602 }
603
604 DBG (DBG_proc, "leo_get_scan_size: exit, status=%d\n", status);
605
606 DBG (DBG_proc, "lines=%d, bpl=%d\n", dev->params.lines,
607 dev->params.bytes_per_line);
608
609 return (status);
610 }
611
612 /* Return the number of byte that can be read. */
613 static SANE_Status
get_filled_data_length(Leo_Scanner * dev,size_t * to_read)614 get_filled_data_length (Leo_Scanner * dev, size_t * to_read)
615 {
616 size_t size;
617 CDB cdb;
618 SANE_Status status;
619
620 DBG (DBG_proc, "get_filled_data_length: enter\n");
621
622 *to_read = 0;
623
624 size = 0x10;
625 MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size);
626 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
627 NULL, 0, dev->buffer, &size);
628
629 if (size != 0x10)
630 {
631 DBG (DBG_error,
632 "get_filled_data_length: GET DATA BUFFER STATUS returned an invalid size (%ld)\n",
633 (long) size);
634 return SANE_STATUS_IO_ERROR;
635 }
636
637 hexdump (DBG_info2, "get_filled_data_length return", dev->buffer, size);
638
639 *to_read = B24TOI (&dev->buffer[9]);
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
leo_scan(Leo_Scanner * dev)650 leo_scan (Leo_Scanner * dev)
651 {
652 CDB cdb;
653 SANE_Status status;
654
655 DBG (DBG_proc, "leo_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, "leo_scan: exit, status=%d\n", status);
662
663 return status;
664 }
665
666 /* Attach a scanner to this backend. */
667 static SANE_Status
attach_scanner(const char * devicename,Leo_Scanner ** devp)668 attach_scanner (const char *devicename, Leo_Scanner ** devp)
669 {
670 Leo_Scanner *dev;
671 int sfd;
672
673 DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename);
674
675 if (devp)
676 *devp = NULL;
677
678 /* Check if we know this device name. */
679 for (dev = first_dev; dev; dev = dev->next)
680 {
681 if (strcmp (dev->sane.name, devicename) == 0)
682 {
683 if (devp)
684 {
685 *devp = dev;
686 }
687 DBG (DBG_info, "device is already known\n");
688 return SANE_STATUS_GOOD;
689 }
690 }
691
692 /* Allocate a new scanner entry. */
693 dev = leo_init ();
694 if (dev == NULL)
695 {
696 DBG (DBG_error, "ERROR: not enough memory\n");
697 return SANE_STATUS_NO_MEM;
698 }
699
700 DBG (DBG_info, "attach_scanner: opening %s\n", devicename);
701
702 if (sanei_scsi_open (devicename, &sfd, leo_sense_handler, dev) != 0)
703 {
704 DBG (DBG_error, "ERROR: attach_scanner: open failed\n");
705 leo_free (dev);
706 return SANE_STATUS_INVAL;
707 }
708
709 /* Fill some scanner specific values. */
710 dev->devicename = strdup (devicename);
711 dev->sfd = sfd;
712
713 /* Now, check that it is a scanner we support. */
714 if (leo_identify_scanner (dev) == SANE_FALSE)
715 {
716 DBG (DBG_error,
717 "ERROR: attach_scanner: scanner-identification failed\n");
718 leo_free (dev);
719 return SANE_STATUS_INVAL;
720 }
721
722 leo_close (dev);
723
724 /* Set the default options for that scanner. */
725 dev->sane.name = dev->devicename;
726 dev->sane.vendor = dev->def->real_vendor;
727 dev->sane.model = dev->def->real_product;
728 dev->sane.type = "flatbed scanner";
729
730 /* Link the scanner with the others. */
731 dev->next = first_dev;
732 first_dev = dev;
733
734 if (devp)
735 {
736 *devp = dev;
737 }
738
739 num_devices++;
740
741 DBG (DBG_proc, "attach_scanner: exit\n");
742
743 return SANE_STATUS_GOOD;
744 }
745
746 static SANE_Status
attach_one(const char * dev)747 attach_one (const char *dev)
748 {
749 attach_scanner (dev, NULL);
750 return SANE_STATUS_GOOD;
751 }
752
753 /* Reset the options for that scanner. */
754 static void
leo_init_options(Leo_Scanner * dev)755 leo_init_options (Leo_Scanner * dev)
756 {
757 int i;
758
759 /* Pre-initialize the options. */
760 memset (dev->opt, 0, sizeof (dev->opt));
761 memset (dev->val, 0, sizeof (dev->val));
762
763 for (i = 0; i < OPT_NUM_OPTIONS; ++i)
764 {
765 dev->opt[i].size = sizeof (SANE_Word);
766 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
767 }
768
769 /* Number of options. */
770 dev->opt[OPT_NUM_OPTS].name = "";
771 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
772 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
773 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
774 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
775 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
776
777 /* Mode group */
778 dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan mode");
779 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
780 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
781 dev->opt[OPT_MODE_GROUP].cap = 0;
782 dev->opt[OPT_MODE_GROUP].size = 0;
783 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
784
785 /* Scanner supported modes */
786 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
787 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
788 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
789 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
790 dev->opt[OPT_MODE].size = max_string_size (scan_mode_list);
791 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
792 dev->opt[OPT_MODE].constraint.string_list = scan_mode_list;
793 dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
794
795 /* X and Y resolution */
796 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
797 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
798 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
799 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
800 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
801 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
802 dev->opt[OPT_RESOLUTION].constraint.range = &dev->res_range;
803 dev->val[OPT_RESOLUTION].w = dev->res_range.max / 2;
804
805 /* Halftone pattern */
806 dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
807 dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
808 dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
809 dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
810 dev->opt[OPT_HALFTONE_PATTERN].size =
811 max_string_size (halftone_pattern_list);
812 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
813 dev->opt[OPT_HALFTONE_PATTERN].constraint_type =
814 SANE_CONSTRAINT_STRING_LIST;
815 dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
816 halftone_pattern_list;
817 dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
818
819 /* Geometry group */
820 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
821 dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
822 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
823 dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
824 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
825 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
826
827 /* Upper left X */
828 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
829 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
830 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
831 dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
832 dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
833 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
834 dev->opt[OPT_TL_X].constraint.range = &x_range;
835 dev->val[OPT_TL_X].w = x_range.min;
836
837 /* Upper left Y */
838 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
839 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
840 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
841 dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
842 dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
843 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
844 dev->opt[OPT_TL_Y].constraint.range = &y_range;
845 dev->val[OPT_TL_Y].w = y_range.min;
846
847 /* Bottom-right x */
848 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
849 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
850 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
851 dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
852 dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
853 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
854 dev->opt[OPT_BR_X].constraint.range = &x_range;
855 dev->val[OPT_BR_X].w = x_range.max;
856
857 /* Bottom-right y */
858 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
859 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
860 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
861 dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
862 dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
863 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
864 dev->opt[OPT_BR_Y].constraint.range = &y_range;
865 dev->val[OPT_BR_Y].w = y_range.max;
866
867 /* Enhancement group */
868 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
869 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
870 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
871 dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
872 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
873 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
874
875 /* custom-gamma table */
876 dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
877 dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
878 dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
879 dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
880 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
881 dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
882
883 /* red gamma vector */
884 dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
885 dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
886 dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
887 dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
888 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
889 dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
890 dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word);
891 dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
892 dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range;
893 dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R;
894
895 /* green gamma vector */
896 dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
897 dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
898 dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
899 dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
900 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
901 dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
902 dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word);
903 dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
904 dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range;
905 dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G;
906
907 /* blue gamma vector */
908 dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
909 dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
910 dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
911 dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
912 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
913 dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
914 dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word);
915 dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
916 dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range;
917 dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B;
918
919 /* grayscale gamma vector */
920 dev->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR;
921 dev->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR;
922 dev->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR;
923 dev->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT;
924 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
925 dev->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE;
926 dev->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word);
927 dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE;
928 dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &gamma_range;
929 dev->val[OPT_GAMMA_VECTOR_GRAY].wa = dev->gamma_GRAY;
930
931 /* preview */
932 dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
933 dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
934 dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
935 dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
936 dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
937 dev->val[OPT_PREVIEW].w = SANE_FALSE;
938
939 /* Lastly, set the default scan mode. This might change some
940 * values previously set here. */
941 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
942 (SANE_String_Const *) scan_mode_list[0], NULL);
943 }
944
945 /*
946 * Wait until the scanner is ready.
947 */
948 static SANE_Status
leo_wait_scanner(Leo_Scanner * dev)949 leo_wait_scanner (Leo_Scanner * dev)
950 {
951 SANE_Status status;
952 int timeout;
953 CDB cdb;
954
955 DBG (DBG_proc, "leo_wait_scanner: enter\n");
956
957 MKSCSI_TEST_UNIT_READY (cdb);
958
959 /* Set the timeout to 60 seconds. */
960 timeout = 60;
961
962 while (timeout > 0)
963 {
964
965 /* test unit ready */
966 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
967 NULL, 0, NULL, NULL);
968
969 if (status == SANE_STATUS_GOOD)
970 {
971 return SANE_STATUS_GOOD;
972 }
973
974 sleep (1);
975 };
976
977 DBG (DBG_proc, "leo_wait_scanner: scanner not ready\n");
978 return (SANE_STATUS_IO_ERROR);
979 }
980
981 /* Read the image from the scanner and fill the temporary buffer with it. */
982 static SANE_Status
leo_fill_image(Leo_Scanner * dev)983 leo_fill_image (Leo_Scanner * dev)
984 {
985 SANE_Status status;
986 size_t size;
987 CDB cdb;
988 unsigned char *image;
989
990 DBG (DBG_proc, "leo_fill_image: enter\n");
991
992 assert (dev->image_begin == dev->image_end);
993 assert (dev->real_bytes_left > 0);
994
995 dev->image_begin = 0;
996 dev->image_end = 0;
997
998 while (dev->real_bytes_left)
999 {
1000 /*
1001 * Try to read the maximum number of bytes.
1002 */
1003 size = 0;
1004 while (size == 0)
1005 {
1006 status = get_filled_data_length (dev, &size);
1007 if (status)
1008 return (status);
1009 if (size == 0)
1010 usleep (100000); /* sleep 1/10th of second */
1011 }
1012
1013 if (size > dev->real_bytes_left)
1014 size = dev->real_bytes_left;
1015 if (size > dev->image_size - dev->image_end)
1016 size = dev->image_size - dev->image_end;
1017
1018 /* The scanner seems to hang if more than 32KB are read. */
1019 if (size > 0x7fff)
1020 size = 0x7fff;
1021
1022 /* Always read a multiple of a line. */
1023 size = size - (size % dev->params.bytes_per_line);
1024
1025 if (size == 0)
1026 {
1027 /* Probably reached the end of the buffer.
1028 * Check, just in case. */
1029 assert (dev->image_end != 0);
1030 return (SANE_STATUS_GOOD);
1031 }
1032
1033 DBG (DBG_info, "leo_fill_image: to read = %ld bytes (bpl=%d)\n",
1034 (long) size, dev->params.bytes_per_line);
1035
1036 MKSCSI_READ_10 (cdb, 0, 0, size);
1037
1038 hexdump (DBG_info2, "leo_fill_image: READ_10 CDB", cdb.data, 10);
1039
1040 image = dev->image + dev->image_end;
1041
1042 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1043 NULL, 0, image, &size);
1044
1045 if (status != SANE_STATUS_GOOD)
1046 {
1047 DBG (DBG_error, "leo_fill_image: cannot read from the scanner\n");
1048 return status;
1049 }
1050
1051 /* Some format conversion. */
1052 if (dev->scan_mode == LEO_COLOR)
1053 {
1054
1055 /* Reorder the lines. The scanner gives color by color for
1056 * each line. */
1057 unsigned char *src = image;
1058 int nb_lines = size / dev->params.bytes_per_line;
1059 int i, j;
1060
1061 for (i = 0; i < nb_lines; i++)
1062 {
1063
1064 unsigned char *dest = dev->buffer;
1065
1066 for (j = 0; j < dev->params.pixels_per_line; j++)
1067 {
1068 *dest = src[j + 0 * dev->params.pixels_per_line];
1069 dest++;
1070 *dest = src[j + 1 * dev->params.pixels_per_line];
1071 dest++;
1072 *dest = src[j + 2 * dev->params.pixels_per_line];
1073 dest++;
1074 }
1075
1076 /* Copy the line back. */
1077 memcpy (src, dev->buffer, dev->params.bytes_per_line);
1078
1079 src += dev->params.bytes_per_line;
1080 }
1081 }
1082
1083 dev->image_end += size;
1084 dev->real_bytes_left -= size;
1085
1086 DBG (DBG_info, "leo_fill_image: real bytes left = %ld\n",
1087 (long) dev->real_bytes_left);
1088 }
1089
1090 return (SANE_STATUS_GOOD); /* unreachable */
1091 }
1092
1093 /* Copy from the raw buffer to the buffer given by the backend.
1094 *
1095 * len in input is the maximum length available in buf, and, in
1096 * output, is the length written into buf.
1097 */
1098 static void
leo_copy_raw_to_frontend(Leo_Scanner * dev,SANE_Byte * buf,size_t * len)1099 leo_copy_raw_to_frontend (Leo_Scanner * dev, SANE_Byte * buf, size_t * len)
1100 {
1101 size_t size;
1102
1103 size = dev->image_end - dev->image_begin;
1104 if (size > *len)
1105 {
1106 size = *len;
1107 }
1108 *len = size;
1109
1110 memcpy (buf, dev->image + dev->image_begin, size);
1111
1112 dev->image_begin += size;
1113 }
1114
1115 /* Stop a scan. */
1116 static SANE_Status
do_cancel(Leo_Scanner * dev)1117 do_cancel (Leo_Scanner * dev)
1118 {
1119 DBG (DBG_sane_proc, "do_cancel enter\n");
1120
1121 if (dev->scanning == SANE_TRUE)
1122 {
1123
1124 /* Reset the scanner */
1125 dev->x_tl = 0;
1126 dev->x_tl = 0;
1127 dev->width = 0;
1128 dev->length = 0;
1129 leo_set_window (dev);
1130
1131 leo_scan (dev);
1132
1133 leo_close (dev);
1134 }
1135
1136 dev->scanning = SANE_FALSE;
1137
1138 DBG (DBG_sane_proc, "do_cancel exit\n");
1139
1140 return SANE_STATUS_CANCELLED;
1141 }
1142
1143 /* A default gamma table. */
1144 static const SANE_Word gamma_init[GAMMA_LENGTH] = {
1145 0x00, 0x06, 0x0A, 0x0D, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F,
1146 0x21, 0x23, 0x25, 0x27,
1147 0x28, 0x2A, 0x2C, 0x2D, 0x2F, 0x30, 0x32, 0x33, 0x35, 0x36, 0x38, 0x39,
1148 0x3A, 0x3C, 0x3D, 0x3F,
1149 0x40, 0x41, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4A, 0x4B, 0x4D, 0x4E,
1150 0x4F, 0x50, 0x51, 0x53,
1151 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
1152 0x61, 0x62, 0x63, 0x64,
1153 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
1154 0x72, 0x73, 0x74, 0x75,
1155 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F, 0x80,
1156 0x81, 0x82, 0x83, 0x84,
1157 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
1158 0x90, 0x91, 0x92, 0x92,
1159 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
1160 0x9E, 0x9F, 0x9F, 0xA0,
1161 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xA9, 0xAA,
1162 0xAB, 0xAC, 0xAD, 0xAD,
1163 0xAE, 0xAF, 0xB0, 0xB1, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7,
1164 0xB8, 0xB9, 0xB9, 0xBA,
1165 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0, 0xC1, 0xC2, 0xC3, 0xC3,
1166 0xC4, 0xC5, 0xC6, 0xC6,
1167 0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCF, 0xCF,
1168 0xD0, 0xD1, 0xD2, 0xD2,
1169 0xD3, 0xD4, 0xD5, 0xD5, 0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xDA, 0xDA, 0xDB,
1170 0xDC, 0xDC, 0xDD, 0xDE,
1171 0xDF, 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE6,
1172 0xE7, 0xE8, 0xE8, 0xE9,
1173 0xEA, 0xEB, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1,
1174 0xF2, 0xF3, 0xF4, 0xF4,
1175 0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFC,
1176 0xFD, 0xFE, 0xFE, 0xFF
1177 };
1178
1179 /* Send the gamma */
1180 static SANE_Status
leo_send_gamma(Leo_Scanner * dev)1181 leo_send_gamma (Leo_Scanner * dev)
1182 {
1183 CDB cdb;
1184 SANE_Status status;
1185 struct
1186 {
1187 unsigned char gamma_R[GAMMA_LENGTH];
1188 unsigned char gamma_G[GAMMA_LENGTH]; /* also gray */
1189 unsigned char gamma_B[GAMMA_LENGTH];
1190 }
1191 param;
1192 size_t i;
1193 size_t size;
1194
1195 DBG (DBG_proc, "leo_send_gamma: enter\n");
1196
1197 size = sizeof (param);
1198 assert (size == 3 * GAMMA_LENGTH);
1199 MKSCSI_SEND_10 (cdb, 0x03, 0x01, size);
1200
1201 if (dev->val[OPT_CUSTOM_GAMMA].w)
1202 {
1203 /* Use the custom gamma. */
1204 if (dev->scan_mode == LEO_GRAYSCALE)
1205 {
1206 /* Gray */
1207 for (i = 0; i < GAMMA_LENGTH; i++)
1208 {
1209 param.gamma_R[i] = dev->gamma_GRAY[i];
1210 param.gamma_G[i] = 0;
1211 param.gamma_B[i] = 0;
1212 }
1213 }
1214 else
1215 {
1216 /* Color */
1217 for (i = 0; i < GAMMA_LENGTH; i++)
1218 {
1219 param.gamma_R[i] = dev->gamma_R[i];
1220 param.gamma_G[i] = dev->gamma_G[i];
1221 param.gamma_B[i] = dev->gamma_B[i];
1222 }
1223 }
1224 }
1225 else
1226 {
1227 for (i = 0; i < GAMMA_LENGTH; i++)
1228 {
1229 param.gamma_R[i] = gamma_init[i];
1230 param.gamma_G[i] = gamma_init[i];
1231 param.gamma_B[i] = gamma_init[i];
1232 }
1233 }
1234
1235 hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len);
1236
1237 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1238 ¶m, size, NULL, NULL);
1239
1240 DBG (DBG_proc, "leo_send_gamma: exit, status=%d\n", status);
1241
1242 return (status);
1243 }
1244
1245 /* Send the halftone pattern */
1246 static SANE_Status
leo_send_halftone_pattern(Leo_Scanner * dev)1247 leo_send_halftone_pattern (Leo_Scanner * dev)
1248 {
1249 int i;
1250 const halftone_pattern_t *pattern;
1251 SANE_Status status;
1252 size_t size;
1253 CDB cdb;
1254
1255 DBG (DBG_proc, "leo_send_halftone_pattern: enter\n");
1256
1257 if (dev->scan_mode == LEO_HALFTONE)
1258 {
1259
1260 i = get_string_list_index (halftone_pattern_list,
1261 dev->val[OPT_HALFTONE_PATTERN].s);
1262 pattern = halftone_pattern_val[i];
1263
1264 assert (pattern != NULL);
1265
1266 size = sizeof (halftone_pattern_t);
1267 assert (size == 256);
1268 MKSCSI_SEND_10 (cdb, 0x02, 0x0F, size);
1269
1270 hexdump (DBG_info2, "leo_send_gamma:", cdb.data, cdb.len);
1271
1272 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1273 pattern, size, NULL, NULL);
1274 }
1275 else
1276 {
1277 status = SANE_STATUS_GOOD;
1278 }
1279
1280 DBG (DBG_proc, "leo_send_halftone_pattern: exit, status=%d\n", status);
1281
1282 return status;
1283 }
1284
1285 /*--------------------------------------------------------------------------*/
1286
1287 /* Sane entry points */
1288
1289 SANE_Status
sane_init(SANE_Int * version_code,SANE_Auth_Callback __sane_unused__ authorize)1290 sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize)
1291 {
1292 FILE *fp;
1293 char dev_name[PATH_MAX];
1294 size_t len;
1295
1296 DBG_INIT ();
1297
1298 DBG (DBG_sane_init, "sane_init\n");
1299
1300 DBG (DBG_error, "This is sane-leo version %d.%d-%d\n", SANE_CURRENT_MAJOR,
1301 SANE_CURRENT_MINOR, BUILD);
1302 DBG (DBG_error, "(C) 2002 by Frank Zago\n");
1303
1304 if (version_code)
1305 {
1306 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD);
1307 }
1308
1309 fp = sanei_config_open (LEO_CONFIG_FILE);
1310 if (!fp)
1311 {
1312 /* default to /dev/scanner instead of insisting on config file */
1313 attach_scanner ("/dev/scanner", 0);
1314 return SANE_STATUS_GOOD;
1315 }
1316
1317 while (sanei_config_read (dev_name, sizeof (dev_name), fp))
1318 {
1319 if (dev_name[0] == '#') /* ignore line comments */
1320 continue;
1321 len = strlen (dev_name);
1322
1323 if (!len)
1324 continue; /* ignore empty lines */
1325
1326 sanei_config_attach_matching_devices (dev_name, attach_one);
1327 }
1328
1329 fclose (fp);
1330
1331 DBG (DBG_proc, "sane_init: leave\n");
1332
1333 return SANE_STATUS_GOOD;
1334 }
1335
1336 SANE_Status
sane_get_devices(const SANE_Device *** device_list,SANE_Bool __sane_unused__ local_only)1337 sane_get_devices (const SANE_Device *** device_list, SANE_Bool __sane_unused__ local_only)
1338 {
1339 Leo_Scanner *dev;
1340 int i;
1341
1342 DBG (DBG_proc, "sane_get_devices: enter\n");
1343
1344 if (devlist)
1345 free (devlist);
1346
1347 devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
1348 if (!devlist)
1349 return SANE_STATUS_NO_MEM;
1350
1351 i = 0;
1352 for (dev = first_dev; i < num_devices; dev = dev->next)
1353 devlist[i++] = &dev->sane;
1354 devlist[i++] = 0;
1355
1356 *device_list = devlist;
1357
1358 DBG (DBG_proc, "sane_get_devices: exit\n");
1359
1360 return SANE_STATUS_GOOD;
1361 }
1362
1363 SANE_Status
sane_open(SANE_String_Const devicename,SANE_Handle * handle)1364 sane_open (SANE_String_Const devicename, SANE_Handle * handle)
1365 {
1366 Leo_Scanner *dev;
1367 SANE_Status status;
1368
1369 DBG (DBG_proc, "sane_open: enter\n");
1370
1371 /* search for devicename */
1372 if (devicename[0])
1373 {
1374 DBG (DBG_info, "sane_open: devicename=%s\n", devicename);
1375
1376 for (dev = first_dev; dev; dev = dev->next)
1377 {
1378 if (strcmp (dev->sane.name, devicename) == 0)
1379 {
1380 break;
1381 }
1382 }
1383
1384 if (!dev)
1385 {
1386 status = attach_scanner (devicename, &dev);
1387 if (status != SANE_STATUS_GOOD)
1388 {
1389 return status;
1390 }
1391 }
1392 }
1393 else
1394 {
1395 DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n");
1396 dev = first_dev; /* empty devicename -> use first device */
1397 }
1398
1399 if (!dev)
1400 {
1401 DBG (DBG_error, "No scanner found\n");
1402
1403 return SANE_STATUS_INVAL;
1404 }
1405
1406 leo_init_options (dev);
1407
1408 /* Initialize the gamma table. */
1409 memcpy (dev->gamma_R, gamma_init, dev->opt[OPT_GAMMA_VECTOR_R].size);
1410 memcpy (dev->gamma_G, gamma_init, dev->opt[OPT_GAMMA_VECTOR_G].size);
1411 memcpy (dev->gamma_B, gamma_init, dev->opt[OPT_GAMMA_VECTOR_B].size);
1412 memcpy (dev->gamma_GRAY, gamma_init, dev->opt[OPT_GAMMA_VECTOR_GRAY].size);
1413
1414 *handle = dev;
1415
1416 DBG (DBG_proc, "sane_open: exit\n");
1417
1418 return SANE_STATUS_GOOD;
1419 }
1420
1421 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle,SANE_Int option)1422 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
1423 {
1424 Leo_Scanner *dev = handle;
1425
1426 DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option);
1427
1428 if ((unsigned) option >= OPT_NUM_OPTIONS)
1429 {
1430 return NULL;
1431 }
1432
1433 DBG (DBG_proc, "sane_get_option_descriptor: exit\n");
1434
1435 return dev->opt + option;
1436 }
1437
1438 SANE_Status
sane_control_option(SANE_Handle handle,SANE_Int option,SANE_Action action,void * val,SANE_Int * info)1439 sane_control_option (SANE_Handle handle, SANE_Int option,
1440 SANE_Action action, void *val, SANE_Int * info)
1441 {
1442 Leo_Scanner *dev = handle;
1443 SANE_Status status;
1444 SANE_Word cap;
1445 int i;
1446
1447 DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n",
1448 option, action);
1449
1450 if (info)
1451 {
1452 *info = 0;
1453 }
1454
1455 if (dev->scanning)
1456 {
1457 return SANE_STATUS_DEVICE_BUSY;
1458 }
1459
1460 if (option < 0 || option >= OPT_NUM_OPTIONS)
1461 {
1462 return SANE_STATUS_INVAL;
1463 }
1464
1465 cap = dev->opt[option].cap;
1466 if (!SANE_OPTION_IS_ACTIVE (cap))
1467 {
1468 return SANE_STATUS_INVAL;
1469 }
1470
1471 if (action == SANE_ACTION_GET_VALUE)
1472 {
1473
1474 switch (option)
1475 {
1476 /* word options */
1477 case OPT_NUM_OPTS:
1478 case OPT_RESOLUTION:
1479 case OPT_TL_Y:
1480 case OPT_BR_Y:
1481 case OPT_TL_X:
1482 case OPT_BR_X:
1483 case OPT_CUSTOM_GAMMA:
1484 case OPT_PREVIEW:
1485 *(SANE_Word *) val = dev->val[option].w;
1486 return SANE_STATUS_GOOD;
1487
1488 /* string options */
1489 case OPT_MODE:
1490 case OPT_HALFTONE_PATTERN:
1491 strcpy (val, dev->val[option].s);
1492 return SANE_STATUS_GOOD;
1493
1494 /* Gamma */
1495 case OPT_GAMMA_VECTOR_R:
1496 case OPT_GAMMA_VECTOR_G:
1497 case OPT_GAMMA_VECTOR_B:
1498 case OPT_GAMMA_VECTOR_GRAY:
1499 memcpy (val, dev->val[option].wa, dev->opt[option].size);
1500 return SANE_STATUS_GOOD;
1501
1502 default:
1503 return SANE_STATUS_INVAL;
1504 }
1505 }
1506 else if (action == SANE_ACTION_SET_VALUE)
1507 {
1508
1509 if (!SANE_OPTION_IS_SETTABLE (cap))
1510 {
1511 DBG (DBG_error, "could not set option, not settable\n");
1512 return SANE_STATUS_INVAL;
1513 }
1514
1515 status = sanei_constrain_value (dev->opt + option, val, info);
1516 if (status != SANE_STATUS_GOOD)
1517 {
1518 DBG (DBG_error, "could not set option, invalid value\n");
1519 return status;
1520 }
1521
1522 switch (option)
1523 {
1524
1525 /* Numeric side-effect options */
1526 case OPT_TL_Y:
1527 case OPT_BR_Y:
1528 case OPT_TL_X:
1529 case OPT_BR_X:
1530 case OPT_RESOLUTION:
1531 if (info)
1532 {
1533 *info |= SANE_INFO_RELOAD_PARAMS;
1534 }
1535 dev->val[option].w = *(SANE_Word *) val;
1536 return SANE_STATUS_GOOD;
1537
1538 /* Numeric side-effect free options */
1539 case OPT_PREVIEW:
1540 dev->val[option].w = *(SANE_Word *) val;
1541 return SANE_STATUS_GOOD;
1542
1543 /* String side-effect options */
1544 case OPT_MODE:
1545 if (strcmp (dev->val[option].s, val) == 0)
1546 return SANE_STATUS_GOOD;
1547
1548 free (dev->val[OPT_MODE].s);
1549 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
1550
1551 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1552 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1553 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1554 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1555 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
1556 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
1557
1558 if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0)
1559 {
1560 i = get_string_list_index (halftone_pattern_list,
1561 dev->val[OPT_HALFTONE_PATTERN].s);
1562 if (halftone_pattern_val[i] == NULL)
1563 {
1564 dev->scan_mode = LEO_BW;
1565 }
1566 else
1567 {
1568 dev->scan_mode = LEO_HALFTONE;
1569 }
1570 dev->depth = 1;
1571 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
1572 }
1573 else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0)
1574 {
1575 dev->scan_mode = LEO_GRAYSCALE;
1576 dev->depth = 8;
1577 dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1578 if (dev->val[OPT_CUSTOM_GAMMA].w)
1579 {
1580 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE;
1581 }
1582 }
1583 else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0)
1584 {
1585 dev->scan_mode = LEO_COLOR;
1586 dev->depth = 8;
1587 dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1588 if (dev->val[OPT_CUSTOM_GAMMA].w)
1589 {
1590 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1591 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1592 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1593 }
1594 }
1595
1596 if (info)
1597 {
1598 *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
1599 }
1600 return SANE_STATUS_GOOD;
1601
1602 case OPT_HALFTONE_PATTERN:
1603 free (dev->val[option].s);
1604 dev->val[option].s = (SANE_String) strdup (val);
1605 i = get_string_list_index (halftone_pattern_list,
1606 dev->val[OPT_HALFTONE_PATTERN].s);
1607 if (halftone_pattern_val[i] == NULL)
1608 {
1609 dev->scan_mode = LEO_BW;
1610 }
1611 else
1612 {
1613 dev->scan_mode = LEO_HALFTONE;
1614 }
1615
1616 return SANE_STATUS_GOOD;
1617
1618 case OPT_GAMMA_VECTOR_R:
1619 case OPT_GAMMA_VECTOR_G:
1620 case OPT_GAMMA_VECTOR_B:
1621 case OPT_GAMMA_VECTOR_GRAY:
1622 memcpy (dev->val[option].wa, val, dev->opt[option].size);
1623 return SANE_STATUS_GOOD;
1624
1625 case OPT_CUSTOM_GAMMA:
1626 dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val;
1627 if (dev->val[OPT_CUSTOM_GAMMA].w)
1628 {
1629 /* use custom_gamma_table */
1630 if (dev->scan_mode == LEO_GRAYSCALE)
1631 {
1632 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE;
1633 }
1634 else
1635 {
1636 /* color mode */
1637 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1638 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1639 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1640 }
1641 }
1642 else
1643 {
1644 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1645 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1646 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1647 dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
1648 }
1649 if (info)
1650 {
1651 *info |= SANE_INFO_RELOAD_OPTIONS;
1652 }
1653 return SANE_STATUS_GOOD;
1654
1655 default:
1656 return SANE_STATUS_INVAL;
1657 }
1658 }
1659
1660 DBG (DBG_proc, "sane_control_option: exit, bad\n");
1661
1662 return SANE_STATUS_UNSUPPORTED;
1663 }
1664
1665 SANE_Status
sane_get_parameters(SANE_Handle handle,SANE_Parameters * params)1666 sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
1667 {
1668 Leo_Scanner *dev = handle;
1669
1670 DBG (DBG_proc, "sane_get_parameters: enter\n");
1671
1672 if (!(dev->scanning))
1673 {
1674
1675 /* Setup the parameters for the scan. These values will be re-used
1676 * in the SET WINDOWS command. */
1677 if (dev->val[OPT_PREVIEW].w == SANE_TRUE)
1678 {
1679 dev->x_resolution = 28;
1680 dev->y_resolution = 28;
1681 dev->x_tl = 0;
1682 dev->y_tl = 0;
1683 dev->x_br = mmToIlu (SANE_UNFIX (x_range.max));
1684 dev->y_br = mmToIlu (SANE_UNFIX (y_range.max));
1685 }
1686 else
1687 {
1688 dev->x_resolution = dev->val[OPT_RESOLUTION].w;
1689 dev->y_resolution = dev->val[OPT_RESOLUTION].w;
1690 dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
1691 dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
1692 dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
1693 dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
1694 }
1695
1696 /* Check the corners are OK. */
1697 if (dev->x_tl > dev->x_br)
1698 {
1699 int s;
1700 s = dev->x_tl;
1701 dev->x_tl = dev->x_br;
1702 dev->x_br = s;
1703 }
1704 if (dev->y_tl > dev->y_br)
1705 {
1706 int s;
1707 s = dev->y_tl;
1708 dev->y_tl = dev->y_br;
1709 dev->y_br = s;
1710 }
1711
1712 dev->width = dev->x_br - dev->x_tl;
1713 dev->length = dev->y_br - dev->y_tl;
1714
1715 /* Prepare the parameters for the caller. */
1716 memset (&dev->params, 0, sizeof (SANE_Parameters));
1717
1718 dev->params.last_frame = SANE_TRUE;
1719
1720 switch (dev->scan_mode)
1721 {
1722 case LEO_BW:
1723 case LEO_HALFTONE:
1724 dev->params.format = SANE_FRAME_GRAY;
1725 dev->params.pixels_per_line = dev->width & ~0x7;
1726 dev->params.bytes_per_line = dev->params.pixels_per_line / 8;
1727 dev->params.depth = 1;
1728 break;
1729 case LEO_GRAYSCALE:
1730 dev->params.format = SANE_FRAME_GRAY;
1731 dev->params.pixels_per_line = dev->width;
1732 dev->params.bytes_per_line = dev->params.pixels_per_line;
1733 dev->params.depth = 8;
1734 break;
1735 case LEO_COLOR:
1736 dev->params.format = SANE_FRAME_RGB;
1737 dev->params.pixels_per_line = dev->width;
1738 dev->params.bytes_per_line = dev->params.pixels_per_line * 3;
1739 dev->params.depth = 8;
1740 break;
1741 }
1742
1743 dev->params.lines = dev->length;
1744 }
1745
1746 /* Return the current values. */
1747 if (params)
1748 {
1749 *params = (dev->params);
1750 }
1751
1752 DBG (DBG_proc, "sane_get_parameters: exit\n");
1753
1754 return SANE_STATUS_GOOD;
1755 }
1756
1757 SANE_Status
sane_start(SANE_Handle handle)1758 sane_start (SANE_Handle handle)
1759 {
1760 Leo_Scanner *dev = handle;
1761 SANE_Status status;
1762
1763 DBG (DBG_proc, "sane_start: enter\n");
1764
1765 if (!(dev->scanning))
1766 {
1767
1768 sane_get_parameters (dev, NULL);
1769
1770 /* Open again the scanner. */
1771 if (sanei_scsi_open
1772 (dev->devicename, &(dev->sfd), leo_sense_handler, dev) != 0)
1773 {
1774 DBG (DBG_error, "ERROR: sane_start: open failed\n");
1775 return SANE_STATUS_INVAL;
1776 }
1777
1778 /* The scanner must be ready. */
1779 status = leo_wait_scanner (dev);
1780 if (status)
1781 {
1782 leo_close (dev);
1783 return status;
1784 }
1785
1786 status = leo_set_window (dev);
1787 if (status)
1788 {
1789 leo_close (dev);
1790 return status;
1791 }
1792
1793 status = leo_send_gamma (dev);
1794 if (status)
1795 {
1796 leo_close (dev);
1797 return status;
1798 }
1799
1800 status = leo_send_halftone_pattern (dev);
1801 if (status)
1802 {
1803 leo_close (dev);
1804 return status;
1805 }
1806
1807 status = leo_scan (dev);
1808 if (status)
1809 {
1810 leo_close (dev);
1811 return status;
1812 }
1813
1814 status = leo_wait_scanner (dev);
1815 if (status)
1816 {
1817 leo_close (dev);
1818 return status;
1819 }
1820
1821 status = leo_get_scan_size (dev);
1822 if (status)
1823 {
1824 leo_close (dev);
1825 return status;
1826 }
1827
1828 }
1829
1830 dev->image_end = 0;
1831 dev->image_begin = 0;
1832
1833 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
1834 dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines;
1835
1836 dev->scanning = SANE_TRUE;
1837
1838 DBG (DBG_proc, "sane_start: exit\n");
1839
1840 return SANE_STATUS_GOOD;
1841 }
1842
1843 SANE_Status
sane_read(SANE_Handle handle,SANE_Byte * buf,SANE_Int max_len,SANE_Int * len)1844 sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
1845 SANE_Int * len)
1846 {
1847 SANE_Status status;
1848 Leo_Scanner *dev = handle;
1849 size_t size;
1850 int buf_offset; /* offset into buf */
1851
1852 DBG (DBG_proc, "sane_read: enter\n");
1853
1854 *len = 0;
1855
1856 if (!(dev->scanning))
1857 {
1858 /* OOPS, not scanning */
1859 return do_cancel (dev);
1860 }
1861
1862 if (dev->bytes_left <= 0)
1863 {
1864 return (SANE_STATUS_EOF);
1865 }
1866
1867 buf_offset = 0;
1868
1869 do
1870 {
1871 if (dev->image_begin == dev->image_end)
1872 {
1873 /* Fill image */
1874 status = leo_fill_image (dev);
1875 if (status != SANE_STATUS_GOOD)
1876 {
1877 return (status);
1878 }
1879 }
1880
1881 /* Something must have been read */
1882 if (dev->image_begin == dev->image_end)
1883 {
1884 DBG (DBG_info, "sane_read: nothing read\n");
1885 return SANE_STATUS_IO_ERROR;
1886 }
1887
1888 /* Copy the data to the frontend buffer. */
1889 size = max_len - buf_offset;
1890 if (size > dev->bytes_left)
1891 {
1892 size = dev->bytes_left;
1893 }
1894 leo_copy_raw_to_frontend (dev, buf + buf_offset, &size);
1895
1896 buf_offset += size;
1897
1898 dev->bytes_left -= size;
1899 *len += size;
1900
1901 }
1902 while ((buf_offset != max_len) && dev->bytes_left);
1903
1904 DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n",
1905 (long) dev->bytes_left);
1906
1907 return SANE_STATUS_GOOD;
1908 }
1909
1910 SANE_Status
sane_set_io_mode(SANE_Handle __sane_unused__ handle,SANE_Bool __sane_unused__ non_blocking)1911 sane_set_io_mode (SANE_Handle __sane_unused__ handle, SANE_Bool __sane_unused__ non_blocking)
1912 {
1913 SANE_Status status;
1914 Leo_Scanner *dev = handle;
1915
1916 DBG (DBG_proc, "sane_set_io_mode: enter\n");
1917
1918 if (!dev->scanning)
1919 {
1920 return SANE_STATUS_INVAL;
1921 }
1922
1923 if (non_blocking == SANE_FALSE)
1924 {
1925 status = SANE_STATUS_GOOD;
1926 }
1927 else
1928 {
1929 status = SANE_STATUS_UNSUPPORTED;
1930 }
1931
1932 DBG (DBG_proc, "sane_set_io_mode: exit\n");
1933
1934 return status;
1935 }
1936
1937 SANE_Status
sane_get_select_fd(SANE_Handle __sane_unused__ handle,SANE_Int __sane_unused__ * fd)1938 sane_get_select_fd (SANE_Handle __sane_unused__ handle, SANE_Int __sane_unused__ * fd)
1939 {
1940 DBG (DBG_proc, "sane_get_select_fd: enter\n");
1941
1942 DBG (DBG_proc, "sane_get_select_fd: exit\n");
1943
1944 return SANE_STATUS_UNSUPPORTED;
1945 }
1946
1947 void
sane_cancel(SANE_Handle handle)1948 sane_cancel (SANE_Handle handle)
1949 {
1950 Leo_Scanner *dev = handle;
1951
1952 DBG (DBG_proc, "sane_cancel: enter\n");
1953
1954 do_cancel (dev);
1955
1956 DBG (DBG_proc, "sane_cancel: exit\n");
1957 }
1958
1959 void
sane_close(SANE_Handle handle)1960 sane_close (SANE_Handle handle)
1961 {
1962 Leo_Scanner *dev = handle;
1963 Leo_Scanner *dev_tmp;
1964
1965 DBG (DBG_proc, "sane_close: enter\n");
1966
1967 do_cancel (dev);
1968 leo_close (dev);
1969
1970 /* Unlink dev. */
1971 if (first_dev == dev)
1972 {
1973 first_dev = dev->next;
1974 }
1975 else
1976 {
1977 dev_tmp = first_dev;
1978 while (dev_tmp->next && dev_tmp->next != dev)
1979 {
1980 dev_tmp = dev_tmp->next;
1981 }
1982 if (dev_tmp->next != NULL)
1983 {
1984 dev_tmp->next = dev_tmp->next->next;
1985 }
1986 }
1987
1988 leo_free (dev);
1989 num_devices--;
1990
1991 DBG (DBG_proc, "sane_close: exit\n");
1992 }
1993
1994 void
sane_exit(void)1995 sane_exit (void)
1996 {
1997 DBG (DBG_proc, "sane_exit: enter\n");
1998
1999 while (first_dev)
2000 {
2001 sane_close (first_dev);
2002 }
2003
2004 if (devlist)
2005 {
2006 free (devlist);
2007 devlist = NULL;
2008 }
2009
2010 DBG (DBG_proc, "sane_exit: exit\n");
2011 }
2012