1 /*
2 Copyright (C) 2009, Panasonic Russia Ltd.
3 Copyright (C) 2010,2011, m. allan noah
4 */
5 /*
6 Panasonic KV-S40xx USB-SCSI scanner driver.
7 */
8
9 #include "../include/sane/config.h"
10
11 #include <ctype.h> /*isspace*/
12 #include <math.h> /*tan*/
13
14 #include <string.h>
15 #include <unistd.h>
16 #include <pthread.h>
17 #define DEBUG_NOT_STATIC
18 #include "../include/sane/sanei_backend.h"
19 #include "../include/sane/sane.h"
20 #include "../include/sane/saneopts.h"
21 #include "../include/sane/sanei.h"
22 #include "../include/sane/sanei_config.h"
23 #include "../include/sane/sanei_usb.h"
24 #include "../include/sane/sanei_scsi.h"
25 #include "lassert.h"
26
27 #include "kvs40xx.h"
28
29 #include "sane/sanei_debug.h"
30
31 #define DATA_TAIL 0x200
32
33 struct known_device
34 {
35 const SANE_Int id;
36 const SANE_Device scanner;
37 };
38
39 static const struct known_device known_devices[] = {
40 {
41 KV_S4085C,
42 {
43 "MATSHITA",
44 "KV-S4085C",
45 "High Speed Color ADF Scanner",
46 "scanner"
47 },
48 },
49 {
50 KV_S4065C,
51 {
52 "MATSHITA",
53 "KV-S4065C",
54 "High Speed Color ADF Scanner",
55 "scanner"
56 },
57 },
58 {
59 KV_S7075C,
60 {
61 "MATSHITA",
62 "KV-S7075C",
63 "High Speed Color ADF Scanner",
64 "scanner"
65 },
66 },
67 };
68
buf_init(struct buf * b,SANE_Int sz)69 static inline SANE_Status buf_init(struct buf *b, SANE_Int sz)
70 {
71 const int num = sz / BUF_SIZE + 1;
72 b->buf = (u8 **) realloc(b->buf, num * sizeof(u8 *));
73 if (!b->buf)
74 return SANE_STATUS_NO_MEM;
75 memset(b->buf, 0, num * sizeof(void *));
76 b->size = b->head = b->tail = 0;
77 b->sem = 0;
78 b->st = SANE_STATUS_GOOD;
79 pthread_cond_init(&b->cond, NULL);
80 pthread_mutex_init(&b->mu, NULL);
81 return SANE_STATUS_GOOD;
82 }
83
buf_deinit(struct buf * b)84 static inline void buf_deinit(struct buf *b)
85 {
86 int i;
87 if (!b->buf)
88 return;
89 for (i = b->head; i < b->tail; i++)
90 if (b->buf[i])
91 free(b->buf[i]);
92 free(b->buf);
93 b->buf = NULL;
94 b->head = b->tail = 0;
95 }
96
new_buf(struct buf * b,u8 ** p)97 static inline SANE_Status new_buf(struct buf *b, u8 ** p)
98 {
99 b->buf[b->tail] = (u8 *) malloc(BUF_SIZE);
100 if (!b->buf[b->tail])
101 return SANE_STATUS_NO_MEM;
102 *p = b->buf[b->tail];
103 ++b->tail;
104 return SANE_STATUS_GOOD;
105 }
106
buf_get_err(struct buf * b)107 static inline SANE_Status buf_get_err(struct buf *b)
108 {
109 return b->size ? SANE_STATUS_GOOD : b->st;
110 }
111
buf_set_st(struct buf * b,SANE_Status st)112 static inline void buf_set_st(struct buf *b, SANE_Status st)
113 {
114 pthread_mutex_lock(&b->mu);
115 b->st = st;
116 if (buf_get_err(b))
117 pthread_cond_signal(&b->cond);
118 pthread_mutex_unlock(&b->mu);
119 }
120
push_buf(struct buf * b,SANE_Int sz)121 static inline void push_buf(struct buf *b, SANE_Int sz)
122 {
123 pthread_mutex_lock(&b->mu);
124 b->sem++;
125 b->size += sz;
126 pthread_cond_signal(&b->cond);
127 pthread_mutex_unlock(&b->mu);
128 }
129
get_buf(struct buf * b,SANE_Int * sz)130 static inline u8 *get_buf(struct buf *b, SANE_Int * sz)
131 {
132 SANE_Status err = buf_get_err(b);
133 if (err)
134 return NULL;
135
136 pthread_mutex_lock(&b->mu);
137 while (!b->sem && !buf_get_err(b))
138 pthread_cond_wait(&b->cond, &b->mu);
139 b->sem--;
140 err = buf_get_err(b);
141 if (!err) {
142 *sz = b->size < BUF_SIZE ? b->size : BUF_SIZE;
143 b->size -= *sz;
144 }
145 pthread_mutex_unlock(&b->mu);
146 return err ? NULL : b->buf[b->head];
147 }
148
pop_buf(struct buf * b)149 static inline void pop_buf(struct buf *b)
150 {
151 free(b->buf[b->head]);
152 b->buf[b->head] = NULL;
153 ++b->head;
154 }
155
156 SANE_Status
sane_init(SANE_Int __sane_unused__ * version_code,SANE_Auth_Callback __sane_unused__ authorize)157 sane_init (SANE_Int __sane_unused__ * version_code,
158 SANE_Auth_Callback __sane_unused__ authorize)
159 {
160 DBG_INIT ();
161 DBG (DBG_INFO, "This is panasonic kvs40xx driver\n");
162
163 *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, 1);
164
165 /* Initialize USB */
166 sanei_usb_init ();
167
168 return SANE_STATUS_GOOD;
169 }
170
171 /*
172 * List of available devices, allocated by sane_get_devices, released
173 * by sane_exit()
174 */
175 static SANE_Device **devlist = NULL;
176 static unsigned curr_scan_dev = 0;
177
178 void
sane_exit(void)179 sane_exit (void)
180 {
181 if (devlist)
182 {
183 int i;
184 for (i = 0; devlist[i]; i++)
185 {
186 free ((void *) devlist[i]);
187 }
188 free ((void *) devlist);
189 devlist = NULL;
190 }
191 }
192
193 SANE_Status
194 attach (SANE_String_Const devname);
195
196 SANE_Status
attach(SANE_String_Const devname)197 attach (SANE_String_Const devname)
198 {
199 int i = 0;
200 if (devlist)
201 {
202 for (; devlist[i]; i++);
203 devlist = realloc (devlist, sizeof (SANE_Device *) * (i + 1));
204 if (!devlist)
205 return SANE_STATUS_NO_MEM;
206 }
207 else
208 {
209 devlist = malloc (sizeof (SANE_Device *) * 2);
210 if (!devlist)
211 return SANE_STATUS_NO_MEM;
212 }
213 devlist[i] = malloc (sizeof (SANE_Device));
214 if (!devlist[i])
215 return SANE_STATUS_NO_MEM;
216 memcpy (devlist[i], &known_devices[curr_scan_dev].scanner,
217 sizeof (SANE_Device));
218 devlist[i]->name = strdup (devname);
219 /* terminate device list with NULL entry: */
220 devlist[i + 1] = 0;
221 DBG (DBG_INFO, "%s device attached\n", devname);
222 return SANE_STATUS_GOOD;
223 }
224
225 /* Get device list */
226 SANE_Status
sane_get_devices(const SANE_Device *** device_list,SANE_Bool __sane_unused__ local_only)227 sane_get_devices (const SANE_Device *** device_list,
228 SANE_Bool __sane_unused__ local_only)
229 {
230 if (devlist)
231 {
232 int i;
233 for (i = 0; devlist[i]; i++)
234 {
235 free ((void *) devlist[i]);
236 }
237 free ((void *) devlist);
238 devlist = NULL;
239 }
240
241 for (curr_scan_dev = 0;
242 curr_scan_dev <
243 sizeof (known_devices) / sizeof (known_devices[0]); curr_scan_dev++)
244 {
245 sanei_usb_find_devices (PANASONIC_ID,
246 known_devices[curr_scan_dev].id, attach);
247 }
248
249 for (curr_scan_dev = 0;
250 curr_scan_dev <
251 sizeof (known_devices) / sizeof (known_devices[0]); curr_scan_dev++)
252 {
253 sanei_scsi_find_devices (known_devices[curr_scan_dev].
254 scanner.vendor,
255 known_devices[curr_scan_dev].
256 scanner.model, NULL, -1, -1, -1, -1, attach);
257 }
258 if(device_list)
259 *device_list = (const SANE_Device **) devlist;
260 return SANE_STATUS_GOOD;
261 }
262
263 /* Open device, return the device handle */
264 SANE_Status
sane_open(SANE_String_Const devname,SANE_Handle * handle)265 sane_open (SANE_String_Const devname, SANE_Handle * handle)
266 {
267 unsigned i, j, id = 0;
268 struct scanner *s;
269 SANE_Int h, bus;
270 SANE_Status st = SANE_STATUS_GOOD;
271 if (!devlist)
272 {
273 st = sane_get_devices (NULL, 0);
274 if (st)
275 return st;
276 }
277 for (i = 0; devlist[i]; i++)
278 {
279 if (!strcmp (devlist[i]->name, devname))
280 break;
281 }
282 if (!devlist[i])
283 return SANE_STATUS_INVAL;
284 for (j = 0; j < sizeof (known_devices) / sizeof (known_devices[0]); j++)
285 {
286 if (!strcmp (devlist[i]->model, known_devices[j].scanner.model))
287 {
288 id = known_devices[j].id;
289 break;
290 }
291 }
292
293 st = sanei_usb_open (devname, &h);
294
295 if (st == SANE_STATUS_ACCESS_DENIED)
296 return st;
297 if (st)
298 {
299 st = sanei_scsi_open (devname, &h, kvs40xx_sense_handler, NULL);
300 if (st)
301 {
302 return st;
303 }
304 bus = SCSI;
305 }
306 else
307 {
308 bus = USB;
309 st = sanei_usb_claim_interface (h, 0);
310 if (st)
311 {
312 sanei_usb_close (h);
313 return st;
314 }
315 }
316
317 s = malloc (sizeof (struct scanner));
318 if (!s)
319 return SANE_STATUS_NO_MEM;
320 memset (s, 0, sizeof (struct scanner));
321 s->buffer = malloc (MAX_READ_DATA_SIZE + BULK_HEADER_SIZE);
322 if (!s->buffer)
323 return SANE_STATUS_NO_MEM;
324
325 s->file = h;
326 s->bus = bus;
327 s->id = id;
328 strcpy (s->name, devname);
329 *handle = s;
330 for (i = 0; i < 3; i++)
331 {
332 st = kvs40xx_test_unit_ready (s);
333 if (st)
334 {
335 if (s->bus == SCSI)
336 {
337 sanei_scsi_close (s->file);
338 st = sanei_scsi_open (devname, &h, kvs40xx_sense_handler, NULL);
339 if (st)
340 return st;
341 }
342 else
343 {
344 sanei_usb_release_interface (s->file, 0);
345 sanei_usb_close (s->file);
346 st = sanei_usb_open (devname, &h);
347 if (st)
348 return st;
349 st = sanei_usb_claim_interface (h, 0);
350 if (st)
351 {
352 sanei_usb_close (h);
353 return st;
354 }
355 }
356 s->file = h;
357 }
358 else
359 break;
360 }
361 if (i == 3)
362 return SANE_STATUS_DEVICE_BUSY;
363
364 if (id == KV_S4085C || id == KV_S4065C)
365 {
366 char str[16];
367 st = inquiry (s, str);
368 if (st)
369 goto err;
370 if (id == KV_S4085C)
371 s->id = !strcmp (str, "KV-S4085CL") ? KV_S4085CL : KV_S4085CW;
372 else
373 s->id = !strcmp (str, "KV-S4065CL") ? KV_S4065CL : KV_S4065CW;
374 }
375 kvs40xx_init_options (s);
376 st = kvs40xx_set_timeout (s, s->val[FEED_TIMEOUT].w);
377 if (st)
378 goto err;
379
380 return SANE_STATUS_GOOD;
381 err:
382 sane_close (s);
383 return st;
384 }
385
386 /* Close device */
387 void
sane_close(SANE_Handle handle)388 sane_close (SANE_Handle handle)
389 {
390 struct scanner *s = (struct scanner *) handle;
391 unsigned i;
392 hopper_down (s);
393 if (s->bus == USB)
394 {
395 sanei_usb_release_interface (s->file, 0);
396 sanei_usb_close (s->file);
397 }
398 else
399 sanei_scsi_close (s->file);
400
401 for (i = 1; i < NUM_OPTIONS; i++)
402 {
403 if (s->opt[i].type == SANE_TYPE_STRING && s->val[i].s)
404 free (s->val[i].s);
405 }
406
407 for (i = 0; i < sizeof (s->buf) / sizeof (s->buf[0]); i++)
408 buf_deinit (&s->buf[i]);
409
410 free (s->buffer);
411 free (s);
412
413 }
414
415 /* Get option descriptor */
416 const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle handle,SANE_Int option)417 sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
418 {
419 struct scanner *s = handle;
420
421 if ((unsigned) option >= NUM_OPTIONS || option < 0)
422 return NULL;
423 return s->opt + option;
424 }
425
426 static SANE_Status
wait_document(struct scanner * s)427 wait_document (struct scanner *s)
428 {
429 SANE_Status st;
430 int i;
431 if (!strcmp ("fb", s->val[SOURCE].s))
432 return SANE_STATUS_GOOD;
433 if (!strcmp ("off", s->val[MANUALFEED].s))
434 return kvs40xx_document_exist (s);
435
436 for (i = 0; i < s->val[FEED_TIMEOUT].w; i++)
437 {
438 st = kvs40xx_document_exist (s);
439 if (st != SANE_STATUS_NO_DOCS)
440 return st;
441 sleep (1);
442 }
443 return SANE_STATUS_NO_DOCS;
444 }
445
read_image_duplex(SANE_Handle handle)446 static SANE_Status read_image_duplex(SANE_Handle handle)
447 {
448 struct scanner *s = (struct scanner *) handle;
449 SANE_Status st = SANE_STATUS_GOOD;
450 unsigned read, side;
451 int i;
452 struct side {
453 unsigned mx, eof;
454 u8 *p;
455 struct buf *buf;
456 } a[2], *b;
457
458 for (i = 0; i < 2; i++) {
459 a[i].mx = BUF_SIZE;
460 a[i].eof = 0;
461 a[i].buf = &s->buf[i];
462 st = new_buf(&s->buf[i], &a[i].p);
463 if (st)
464 goto err;
465 }
466 for (b = &a[0], side = SIDE_FRONT; (!a[0].eof || !a[1].eof);) {
467 pthread_testcancel();
468 if (b->mx == 0) {
469 push_buf(b->buf, BUF_SIZE);
470 st = new_buf(b->buf, &b->p);
471 if (st)
472 goto err;
473 b->mx = BUF_SIZE;
474 }
475
476 st = kvs40xx_read_image_data(s, s->page, side,
477 b->p + BUF_SIZE - b->mx, b->mx,
478 &read);
479 b->mx -= read;
480 if (st) {
481 if (st != INCORRECT_LENGTH
482 && st != SANE_STATUS_EOF)
483 goto err;
484
485 if (st == SANE_STATUS_EOF) {
486 b->eof = 1;
487 push_buf(b->buf, BUF_SIZE - b->mx);
488 }
489 side ^= SIDE_BACK;
490 b = &a[side == SIDE_FRONT ? 0 : 1];
491 }
492 }
493
494 err:
495 for (i = 0; i < 2; i++)
496 buf_set_st(&s->buf[i], st);
497 return st;
498 }
499
read_image_simplex(SANE_Handle handle)500 static SANE_Status read_image_simplex(SANE_Handle handle)
501 {
502 struct scanner *s = (struct scanner *) handle;
503 SANE_Status st = SANE_STATUS_GOOD;
504
505 for (; (!st || st == INCORRECT_LENGTH);) {
506 unsigned read, mx;
507 unsigned char *p = NULL;
508 st = new_buf(&s->buf[0], &p);
509 for (read = 0, mx = BUF_SIZE; mx &&
510 (!st || st == INCORRECT_LENGTH); mx -= read) {
511 pthread_testcancel();
512 st = kvs40xx_read_image_data(s, s->page, SIDE_FRONT,
513 p + BUF_SIZE - mx, mx,
514 &read);
515 }
516 push_buf(&s->buf[0], BUF_SIZE - mx);
517 }
518 buf_set_st(&s->buf[0], st);
519 return st;
520 }
521
read_data(void * arg)522 static void * read_data (void *arg)
523 {
524 struct scanner *s = (struct scanner *) arg;
525 SANE_Status st;
526 int duplex = s->val[DUPLEX].w;
527 s->read = 0;
528 s->side = SIDE_FRONT;
529
530 st = duplex ? read_image_duplex(s) : read_image_simplex(s);
531 if (st && (st != SANE_STATUS_EOF))
532 goto err;
533
534 st = kvs40xx_read_picture_element(s, SIDE_FRONT, &s->params);
535 if (st)
536 goto err;
537 if (!s->params.lines) {
538 st = SANE_STATUS_INVAL;
539 goto err;
540 }
541
542 sane_get_parameters(s, NULL);
543
544 s->page++;
545 return NULL;
546 err:
547 s->scanning = 0;
548 return NULL;
549 }
550
551 /* Start scanning */
552 SANE_Status
sane_start(SANE_Handle handle)553 sane_start (SANE_Handle handle)
554 {
555 struct scanner *s = (struct scanner *) handle;
556 SANE_Status st = SANE_STATUS_GOOD;
557 int duplex = s->val[DUPLEX].w, i;
558 unsigned data_avalible;
559 int start = 0;
560
561 if (s->thread)
562 {
563 pthread_join (s->thread, NULL);
564 s->thread = 0;
565 }
566 if (!s->scanning)
567 {
568 st = kvs40xx_test_unit_ready (s);
569 if (st)
570 return st;
571
572 st = wait_document (s);
573 if (st)
574 return st;
575
576 st = kvs40xx_reset_window (s);
577 if (st)
578 return st;
579 st = kvs40xx_set_window (s, SIDE_FRONT);
580
581 if (st)
582 return st;
583
584 if (duplex)
585 {
586 st = kvs40xx_set_window (s, SIDE_BACK);
587 if (st)
588 return st;
589 }
590
591 st = kvs40xx_scan (s);
592 if (st)
593 return st;
594
595 if (s->val[CROP].b || s->val[LENGTHCTL].b || s->val[LONG_PAPER].b)
596 {
597 unsigned w, h, res = s->val[RESOLUTION].w;
598 SANE_Parameters *p = &s->params;
599 w = 297; /*A3 */
600 h = 420;
601 p->pixels_per_line = w * res / 25.4 + .5;
602 p->lines = h * res / 25.4 + .5;
603 }
604 else
605 {
606 st = kvs40xx_read_picture_element (s, SIDE_FRONT, &s->params);
607 if (st)
608 return st;
609 }
610
611 start = 1;
612 s->scanning = 1;
613 s->page = 0;
614 s->read = 0;
615 s->side = SIDE_FRONT;
616 sane_get_parameters (s, NULL);
617 }
618
619 if (duplex && s->side == SIDE_FRONT && !start)
620 {
621 s->side = SIDE_BACK;
622 s->read = 0;
623 return SANE_STATUS_GOOD;
624 }
625 do {
626 st = get_buffer_status(s, &data_avalible);
627 if (st)
628 goto err;
629
630 } while (!data_avalible);
631
632 for (i = 0; i < (duplex ? 2 : 1); i++)
633 {
634 st = buf_init (&s->buf[i], s->side_size);
635 if (st)
636 goto err;
637 }
638
639 if (pthread_create (&s->thread, NULL, read_data, s))
640 {
641 st = SANE_STATUS_IO_ERROR;
642 goto err;
643 }
644
645 if (s->val[CROP].b || s->val[LENGTHCTL].b || s->val[LONG_PAPER].b)
646 {
647 pthread_join (s->thread, NULL);
648 s->thread = 0;
649 }
650
651 return SANE_STATUS_GOOD;
652 err:
653 s->scanning = 0;
654 return st;
655 }
656
657 SANE_Status
sane_read(SANE_Handle handle,SANE_Byte * buf,SANE_Int max_len,SANE_Int * len)658 sane_read(SANE_Handle handle, SANE_Byte * buf,
659 SANE_Int max_len, SANE_Int * len)
660 {
661 struct scanner *s = (struct scanner *) handle;
662 int duplex = s->val[DUPLEX].w;
663 struct buf *b = s->side == SIDE_FRONT ? &s->buf[0] : &s->buf[1];
664 SANE_Status err = buf_get_err(b);
665 SANE_Int inbuf = 0;
666 *len = 0;
667
668 if (!s->scanning)
669 return SANE_STATUS_EOF;
670 if (err)
671 goto out;
672
673 if (s->read) {
674 *len =
675 max_len <
676 (SANE_Int) s->read ? max_len : (SANE_Int) s->read;
677 memcpy(buf, s->data + BUF_SIZE - s->read, *len);
678 s->read -= *len;
679
680 if (!s->read)
681 pop_buf(b);
682 goto out;
683 }
684
685 s->data = get_buf(b, &inbuf);
686 if (!s->data)
687 goto out;
688
689 *len = max_len < inbuf ? max_len : inbuf;
690 if (*len > BUF_SIZE)
691 *len = BUF_SIZE;
692 memcpy(buf, s->data, *len);
693 s->read = inbuf > BUF_SIZE ? BUF_SIZE - *len : inbuf - *len;
694
695 if (!s->read)
696 pop_buf(b);
697 out:
698 err = *len ? SANE_STATUS_GOOD : buf_get_err(b);
699 if (err == SANE_STATUS_EOF) {
700 if (strcmp(s->val[FEEDER_MODE].s, SANE_I18N("continuous"))) {
701 if (!duplex || s->side == SIDE_BACK)
702 s->scanning = 0;
703 }
704 buf_deinit(b);
705 } else if (err) {
706 unsigned i;
707 for (i = 0; i < sizeof(s->buf) / sizeof(s->buf[0]); i++)
708 buf_deinit(&s->buf[i]);
709 }
710 return err;
711 }
712
713 void
sane_cancel(SANE_Handle handle)714 sane_cancel (SANE_Handle handle)
715 {
716 unsigned i;
717 struct scanner *s = (struct scanner *) handle;
718 if (s->scanning && !strcmp (s->val[FEEDER_MODE].s, SANE_I18N ("continuous")))
719 {
720 stop_adf (s);
721 }
722 if (s->thread)
723 {
724 pthread_cancel (s->thread);
725 pthread_join (s->thread, NULL);
726 s->thread = 0;
727 }
728 for (i = 0; i < sizeof (s->buf) / sizeof (s->buf[0]); i++)
729 buf_deinit (&s->buf[i]);
730 s->scanning = 0;
731 }
732
733 SANE_Status
sane_set_io_mode(SANE_Handle __sane_unused__ h,SANE_Bool __sane_unused__ m)734 sane_set_io_mode (SANE_Handle __sane_unused__ h, SANE_Bool __sane_unused__ m)
735 {
736 return SANE_STATUS_UNSUPPORTED;
737 }
738
739 SANE_Status
sane_get_select_fd(SANE_Handle __sane_unused__ h,SANE_Int __sane_unused__ * fd)740 sane_get_select_fd (SANE_Handle __sane_unused__ h,
741 SANE_Int __sane_unused__ * fd)
742 {
743 return SANE_STATUS_UNSUPPORTED;
744 }
745