1 /*
2 Copyright (C) 2008, Panasonic Russia Ltd.
3 */
4 /* sane - Scanner Access Now Easy.
5 Panasonic KV-S1020C / KV-S1025C USB scanners.
6 */
7
8 #define DEBUG_DECLARE_ONLY
9
10 #include "../include/sane/config.h"
11
12 #include <errno.h>
13 #include <fcntl.h>
14 #include <limits.h>
15 #include <signal.h>
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <sys/types.h>
20 #include <sys/wait.h>
21 #include <unistd.h>
22
23 #include "../include/sane/sane.h"
24 #include "../include/sane/saneopts.h"
25 #include "../include/sane/sanei.h"
26 #include "../include/sane/sanei_usb.h"
27 #include "../include/sane/sanei_backend.h"
28 #include "../include/sane/sanei_config.h"
29 #include "../include/lassert.h"
30 #include "../include/sane/sanei_magic.h"
31
32 #include "kvs1025.h"
33 #include "kvs1025_low.h"
34 #include "kvs1025_usb.h"
35
36 #include "../include/sane/sanei_debug.h"
37
38 /* Global storage */
39
40 PKV_DEV g_devices = NULL; /* Chain of devices */
41 const SANE_Device **g_devlist = NULL;
42
43 /* Static functions */
44
45 /* Free one device */
46 static void
kv_free(KV_DEV ** pdev)47 kv_free (KV_DEV ** pdev)
48 {
49 KV_DEV *dev;
50
51 dev = *pdev;
52
53 if (dev == NULL)
54 return;
55
56 DBG (DBG_proc, "kv_free : enter\n");
57
58 kv_close (dev);
59
60 DBG (DBG_proc, "kv_free : free image buffer 0 \n");
61 if (dev->img_buffers[0])
62 free (dev->img_buffers[0]);
63 DBG (DBG_proc, "kv_free : free image buffer 1 \n");
64 if (dev->img_buffers[1])
65 free (dev->img_buffers[1]);
66 DBG (DBG_proc, "kv_free : free scsi device name\n");
67 if (dev->scsi_device_name)
68 free (dev->scsi_device_name);
69
70 DBG (DBG_proc, "kv_free : free SCSI buffer\n");
71 if (dev->buffer0)
72 free (dev->buffer0);
73
74 DBG (DBG_proc, "kv_free : free dev \n");
75 free (dev);
76
77 *pdev = NULL;
78
79 DBG (DBG_proc, "kv_free : exit\n");
80 }
81
82 /* Free all devices */
83 static void
kv_free_devices(void)84 kv_free_devices (void)
85 {
86 PKV_DEV dev;
87 while (g_devices)
88 {
89 dev = g_devices;
90 g_devices = dev->next;
91 kv_free (&dev);
92 }
93 if (g_devlist)
94 {
95 free (g_devlist);
96 g_devlist = NULL;
97 }
98 }
99
100 /* Get all supported scanners, and store into g_scanners_supported */
101 SANE_Status
kv_enum_devices(void)102 kv_enum_devices (void)
103 {
104 SANE_Status status;
105 kv_free_devices ();
106 status = kv_usb_enum_devices ();
107 if (status)
108 {
109 kv_free_devices ();
110 }
111
112 return status;
113 }
114
115 /* Return devices list to the front end */
116 void
kv_get_devices_list(const SANE_Device *** devices_list)117 kv_get_devices_list (const SANE_Device *** devices_list)
118 {
119 *devices_list = g_devlist;
120 }
121
122 /* Close all open handles and clean up global storage */
123 void
kv_exit(void)124 kv_exit (void)
125 {
126 kv_free_devices (); /* Free all devices */
127 kv_usb_cleanup (); /* Clean USB bus */
128 }
129
130 /* Open device by name */
131 SANE_Status
kv_open_by_name(SANE_String_Const devicename, SANE_Handle * handle)132 kv_open_by_name (SANE_String_Const devicename, SANE_Handle * handle)
133 {
134
135 PKV_DEV pd = g_devices;
136 DBG (DBG_proc, "sane_open: enter (dev_name=%s)\n", devicename);
137 while (pd)
138 {
139 if (strcmp (pd->sane.name, devicename) == 0)
140 {
141 if (kv_open (pd) == 0)
142 {
143 *handle = (SANE_Handle) pd;
144 DBG (DBG_proc, "sane_open: leave\n");
145 return SANE_STATUS_GOOD;
146 }
147 }
148 pd = pd->next;
149 }
150 DBG (DBG_proc, "sane_open: leave -- no device found\n");
151 return SANE_STATUS_UNSUPPORTED;
152 }
153
154 /* Open a device */
155 SANE_Status
kv_open(PKV_DEV dev)156 kv_open (PKV_DEV dev)
157 {
158 SANE_Status status = SANE_STATUS_UNSUPPORTED;
159 int i;
160 #define RETRAY_NUM 3
161
162
163 if (dev->bus_mode == KV_USB_BUS)
164 {
165 status = kv_usb_open (dev);
166 }
167 if (status)
168 return status;
169 for (i = 0; i < RETRAY_NUM; i++)
170 {
171 SANE_Bool dev_ready;
172 status = CMD_test_unit_ready (dev, &dev_ready);
173 if (!status && dev_ready)
174 break;
175 }
176
177 if (status == 0)
178 {
179 /* Read device support info */
180 status = CMD_read_support_info (dev);
181
182 if (status == 0)
183 {
184 /* Init options */
185 kv_init_options (dev);
186 status = CMD_set_timeout (dev, dev->val[OPT_FEED_TIMEOUT].w);
187 }
188 }
189 dev->scanning = 0;
190 return status;
191 }
192
193 /* Check if device is already open */
194
195 SANE_Bool
kv_already_open(PKV_DEV dev)196 kv_already_open (PKV_DEV dev)
197 {
198 SANE_Bool status = 0;
199
200 if (dev->bus_mode == KV_USB_BUS)
201 {
202 status = kv_usb_already_open (dev);
203 }
204
205 return status;
206 }
207
208 /* Close a device */
209 void
kv_close(PKV_DEV dev)210 kv_close (PKV_DEV dev)
211 {
212 if (dev->bus_mode == KV_USB_BUS)
213 {
214 kv_usb_close (dev);
215 }
216 dev->scanning = 0;
217 }
218
219 /* Send command to a device */
220 SANE_Status
kv_send_command(PKV_DEV dev, PKV_CMD_HEADER header, PKV_CMD_RESPONSE response)221 kv_send_command (PKV_DEV dev,
222 PKV_CMD_HEADER header, PKV_CMD_RESPONSE response)
223 {
224 SANE_Status status = SANE_STATUS_UNSUPPORTED;
225 if (dev->bus_mode == KV_USB_BUS)
226 {
227 if (!kv_usb_already_open(dev))
228 {
229 DBG (DBG_error, "kv_send_command error: device not open.\n");
230 return SANE_STATUS_IO_ERROR;
231 }
232
233 status = kv_usb_send_command (dev, header, response);
234 }
235
236 return status;
237 }
238
239 /* Commands */
240
241 SANE_Status
CMD_test_unit_ready(PKV_DEV dev, SANE_Bool * ready)242 CMD_test_unit_ready (PKV_DEV dev, SANE_Bool * ready)
243 {
244 SANE_Status status;
245 KV_CMD_HEADER hdr;
246 KV_CMD_RESPONSE rs;
247
248 DBG (DBG_proc, "CMD_test_unit_ready\n");
249
250 memset (&hdr, 0, sizeof (hdr));
251
252 hdr.direction = KV_CMD_NONE;
253 hdr.cdb[0] = SCSI_TEST_UNIT_READY;
254 hdr.cdb_size = 6;
255
256 status = kv_send_command (dev, &hdr, &rs);
257
258 if (status == 0)
259 {
260 *ready = (rs.status == KV_SUCCESS ? 1 : 0);
261 }
262
263 return status;
264 }
265
266 SANE_Status
CMD_set_timeout(PKV_DEV dev, SANE_Word timeout)267 CMD_set_timeout (PKV_DEV dev, SANE_Word timeout)
268 {
269 SANE_Status status;
270 KV_CMD_HEADER hdr;
271 KV_CMD_RESPONSE rs;
272
273 DBG (DBG_proc, "CMD_set_timeout\n");
274
275 memset (&hdr, 0, sizeof (hdr));
276
277 hdr.direction = KV_CMD_OUT;
278 hdr.cdb[0] = SCSI_SET_TIMEOUT;
279 hdr.cdb[2] = 0x8D;
280 hdr.cdb[8] = 0x2;
281 hdr.cdb_size = 10;
282 hdr.data = dev->buffer;
283 dev->buffer[0] = 0;
284 dev->buffer[1] = (SANE_Byte) timeout;
285 hdr.data_size = 2;
286
287 status = kv_send_command (dev, &hdr, &rs);
288
289 return status;
290 }
291
292 SANE_Status
CMD_read_support_info(PKV_DEV dev)293 CMD_read_support_info (PKV_DEV dev)
294 {
295 SANE_Status status;
296 KV_CMD_HEADER hdr;
297 KV_CMD_RESPONSE rs;
298
299 DBG (DBG_proc, "CMD_read_support_info\n");
300
301 memset (&hdr, 0, sizeof (hdr));
302
303 hdr.direction = KV_CMD_IN;
304 hdr.cdb_size = 10;
305 hdr.cdb[0] = SCSI_READ_10;
306 hdr.cdb[2] = 0x93;
307 Ito24 (32, &hdr.cdb[6]);
308 hdr.data = dev->buffer;
309 hdr.data_size = 32;
310
311 status = kv_send_command (dev, &hdr, &rs);
312
313 DBG (DBG_error, "test.\n");
314
315 if (status == 0)
316 {
317 if (rs.status == 0)
318 {
319 int min_x_res, min_y_res, max_x_res, max_y_res;
320 int step_x_res, step_y_res;
321
322 dev->support_info.memory_size
323 = (dev->buffer[2] << 8 | dev->buffer[3]);
324 min_x_res = (dev->buffer[4] << 8) | dev->buffer[5];
325 min_y_res = (dev->buffer[6] << 8) | dev->buffer[7];
326 max_x_res = (dev->buffer[8] << 8) | dev->buffer[9];
327 max_y_res = (dev->buffer[10] << 8) | dev->buffer[11];
328 step_x_res = (dev->buffer[12] << 8) | dev->buffer[13];
329 step_y_res = (dev->buffer[14] << 8) | dev->buffer[15];
330
331 dev->support_info.min_resolution =
332 min_x_res > min_y_res ? min_x_res : min_y_res;
333 dev->support_info.max_resolution =
334 max_x_res < max_y_res ? max_x_res : max_y_res;
335 dev->support_info.step_resolution =
336 step_x_res > step_y_res ? step_x_res : step_y_res;
337 dev->support_info.support_duplex =
338 ((dev->buffer[0] & 0x08) == 0) ? 1 : 0;
339 dev->support_info.support_lamp =
340 ((dev->buffer[23] & 0x80) != 0) ? 1 : 0;
341
342 dev->support_info.max_x_range = KV_MAX_X_RANGE;
343 dev->support_info.max_y_range = KV_MAX_Y_RANGE;
344
345 dev->x_range.min = dev->y_range.min = 0;
346 dev->x_range.max = SANE_FIX (dev->support_info.max_x_range);
347 dev->y_range.max = SANE_FIX (dev->support_info.max_y_range);
348 dev->x_range.quant = dev->y_range.quant = 0;
349
350 DBG (DBG_error,
351 "support_info.memory_size = %d (MB)\n",
352 dev->support_info.memory_size);
353 DBG (DBG_error,
354 "support_info.min_resolution = %d (DPI)\n",
355 dev->support_info.min_resolution);
356 DBG (DBG_error,
357 "support_info.max_resolution = %d (DPI)\n",
358 dev->support_info.max_resolution);
359 DBG (DBG_error,
360 "support_info.step_resolution = %d (DPI)\n",
361 dev->support_info.step_resolution);
362 DBG (DBG_error,
363 "support_info.support_duplex = %s\n",
364 dev->support_info.support_duplex ? "TRUE" : "FALSE");
365 DBG (DBG_error, "support_info.support_lamp = %s\n",
366 dev->support_info.support_lamp ? "TRUE" : "FALSE");
367 }
368 else
369 {
370 DBG (DBG_error, "Error in CMD_get_support_info, "
371 "sense_key=%d, ASC=%d, ASCQ=%d\n",
372 get_RS_sense_key (rs.sense),
373 get_RS_ASC (rs.sense), get_RS_ASCQ (rs.sense));
374
375 }
376 }
377
378 return status;
379 }
380
381 SANE_Status
CMD_scan(PKV_DEV dev)382 CMD_scan (PKV_DEV dev)
383 {
384 SANE_Status status;
385 KV_CMD_HEADER hdr;
386 KV_CMD_RESPONSE rs;
387
388 DBG (DBG_proc, "CMD_scan\n");
389
390 memset (&hdr, 0, sizeof (hdr));
391
392 hdr.direction = KV_CMD_NONE;
393 hdr.cdb[0] = SCSI_SCAN;
394 hdr.cdb_size = 6;
395
396 status = kv_send_command (dev, &hdr, &rs);
397
398 if (status == 0 && rs.status != 0)
399 {
400 DBG (DBG_error,
401 "Error in CMD_scan, sense_key=%d, ASC=%d, ASCQ=%d\n",
402 get_RS_sense_key (rs.sense), get_RS_ASC (rs.sense),
403 get_RS_ASCQ (rs.sense));
404 }
405
406 return status;
407 }
408
409 SANE_Status
CMD_set_window(PKV_DEV dev, int side, PKV_CMD_RESPONSE rs)410 CMD_set_window (PKV_DEV dev, int side, PKV_CMD_RESPONSE rs)
411 {
412 unsigned char *window;
413 unsigned char *windowdata;
414 int size = 74;
415 KV_SCAN_MODE scan_mode;
416 KV_CMD_HEADER hdr;
417
418 DBG (DBG_proc, "CMD_set_window\n");
419
420 window = (unsigned char *) dev->buffer;
421 windowdata = window + 8;
422
423 memset (&hdr, 0, sizeof (hdr));
424 memset (window, 0, size);
425
426 Ito16 (66, &window[6]); /* Window descriptor block length */
427
428 /* Set window data */
429
430 scan_mode = kv_get_mode (dev);
431
432 kv_set_window_data (dev, scan_mode, side, windowdata);
433
434 hdr.direction = KV_CMD_OUT;
435 hdr.cdb_size = 10;
436 hdr.cdb[0] = SCSI_SET_WINDOW;
437 Ito24 (size, &hdr.cdb[6]);
438 hdr.data = window;
439 hdr.data_size = size;
440
441 hexdump (DBG_error, "window", window, size);
442
443 return kv_send_command (dev, &hdr, rs);
444 }
445
446 SANE_Status
CMD_reset_window(PKV_DEV dev)447 CMD_reset_window (PKV_DEV dev)
448 {
449 KV_CMD_HEADER hdr;
450 KV_CMD_RESPONSE rs;
451 SANE_Status status;
452
453 DBG (DBG_proc, "CMD_reset_window\n");
454
455 memset (&hdr, 0, sizeof (hdr));
456
457 hdr.direction = KV_CMD_NONE;
458 hdr.cdb_size = 10;
459 hdr.cdb[0] = SCSI_SET_WINDOW;
460
461 status = kv_send_command (dev, &hdr, &rs);
462 if (rs.status != 0)
463 status = SANE_STATUS_INVAL;
464
465 return status;
466 }
467
468 SANE_Status
CMD_get_buff_status(PKV_DEV dev, int *front_size, int *back_size)469 CMD_get_buff_status (PKV_DEV dev, int *front_size, int *back_size)
470 {
471 KV_CMD_HEADER hdr;
472 KV_CMD_RESPONSE rs;
473 SANE_Status status;
474 unsigned char *data = (unsigned char *) dev->buffer;
475 int size = 12;
476 memset (&hdr, 0, sizeof (hdr));
477 memset (data, 0, size);
478
479 hdr.direction = KV_CMD_IN;
480 hdr.cdb_size = 10;
481 hdr.cdb[0] = SCSI_GET_BUFFER_STATUS;
482 hdr.cdb[8] = size;
483 hdr.data = data;
484 hdr.data_size = size;
485
486 status = kv_send_command (dev, &hdr, &rs);
487 if (status == 0)
488 {
489 if (rs.status == KV_CHK_CONDITION)
490 return SANE_STATUS_NO_DOCS;
491 else
492 {
493 unsigned char *p = data + 4;
494 if (p[0] == SIDE_FRONT)
495 {
496 *front_size = (p[5] << 16) | (p[6] << 8) | p[7];
497 }
498 else
499 {
500 *back_size = (p[5] << 16) | (p[6] << 8) | p[7];
501 }
502 return SANE_STATUS_GOOD;
503 }
504 }
505 return status;
506 }
507
508 SANE_Status
CMD_wait_buff_status(PKV_DEV dev, int *front_size, int *back_size)509 CMD_wait_buff_status (PKV_DEV dev, int *front_size, int *back_size)
510 {
511 SANE_Status status = SANE_STATUS_GOOD;
512 int cnt = 0;
513 *front_size = 0;
514 *back_size = 0;
515
516 DBG (DBG_proc, "CMD_wait_buff_status: enter feed %s\n",
517 dev->val[OPT_MANUALFEED].s);
518
519 do
520 {
521 DBG (DBG_proc, "CMD_wait_buff_status: tray #%d of %d\n", cnt,
522 dev->val[OPT_FEED_TIMEOUT].w);
523 status = CMD_get_buff_status (dev, front_size, back_size);
524 sleep (1);
525 }
526 while (status == SANE_STATUS_GOOD && (*front_size == 0)
527 && (*back_size == 0) && cnt++ < dev->val[OPT_FEED_TIMEOUT].w);
528
529 if (cnt > dev->val[OPT_FEED_TIMEOUT].w)
530 status = SANE_STATUS_NO_DOCS;
531
532 if (status == 0)
533 DBG (DBG_proc, "CMD_wait_buff_status: exit "
534 "front_size %d, back_size %d\n", *front_size, *back_size);
535 else
536 DBG (DBG_proc, "CMD_wait_buff_status: exit with no docs\n");
537 return status;
538 }
539
540
541 SANE_Status
CMD_read_pic_elements(PKV_DEV dev, int page, int side, int *width, int *height)542 CMD_read_pic_elements (PKV_DEV dev, int page, int side,
543 int *width, int *height)
544 {
545 SANE_Status status;
546 KV_CMD_HEADER hdr;
547 KV_CMD_RESPONSE rs;
548
549 DBG (DBG_proc, "CMD_read_pic_elements\n");
550
551 memset (&hdr, 0, sizeof (hdr));
552
553 hdr.direction = KV_CMD_IN;
554 hdr.cdb_size = 10;
555 hdr.cdb[0] = SCSI_READ_10;
556 hdr.cdb[2] = 0x80;
557 hdr.cdb[4] = page;
558 hdr.cdb[5] = side;
559 Ito24 (16, &hdr.cdb[6]);
560 hdr.data = dev->buffer;
561 hdr.data_size = 16;
562
563 status = kv_send_command (dev, &hdr, &rs);
564 if (status == 0)
565 {
566 if (rs.status == 0)
567 {
568 int s = side == SIDE_FRONT ? 0 : 1;
569 int depth = kv_get_depth (kv_get_mode (dev));
570 *width = B32TOI (dev->buffer);
571 *height = B32TOI (&dev->buffer[4]);
572
573 assert ((*width) % 8 == 0);
574
575 DBG (DBG_proc, "CMD_read_pic_elements: "
576 "Page %d, Side %s, W=%d, H=%d\n",
577 page, side == SIDE_FRONT ? "F" : "B", *width, *height);
578
579 dev->params[s].format = kv_get_mode (dev) == SM_COLOR ?
580 SANE_FRAME_RGB : SANE_FRAME_GRAY;
581 dev->params[s].last_frame = SANE_TRUE;
582 dev->params[s].depth = depth > 8 ? 8 : depth;
583 dev->params[s].lines = *height ? *height
584 : dev->val[OPT_LANDSCAPE].w ? (*width * 3) / 4 : (*width * 4) / 3;
585 dev->params[s].pixels_per_line = *width;
586 dev->params[s].bytes_per_line =
587 (dev->params[s].pixels_per_line / 8) * depth;
588 }
589 else
590 {
591 DBG (DBG_proc, "CMD_read_pic_elements: failed\n");
592 status = SANE_STATUS_INVAL;
593 }
594 }
595
596 return status;
597 }
598
599 SANE_Status
CMD_read_image(PKV_DEV dev, int page, int side, unsigned char *buffer, int *psize, KV_CMD_RESPONSE * rs)600 CMD_read_image (PKV_DEV dev, int page, int side,
601 unsigned char *buffer, int *psize, KV_CMD_RESPONSE * rs)
602 {
603 SANE_Status status;
604 KV_CMD_HEADER hdr;
605 int size = *psize;
606
607 DBG (DBG_proc, "CMD_read_image\n");
608
609 memset (&hdr, 0, sizeof (hdr));
610
611 hdr.direction = KV_CMD_IN;
612 hdr.cdb_size = 10;
613 hdr.cdb[0] = SCSI_READ_10;
614 hdr.cdb[4] = page;
615 hdr.cdb[5] = side;
616 Ito24 (size, &hdr.cdb[6]);
617 hdr.data = buffer;
618 hdr.data_size = size;
619
620 *psize = 0;
621
622 status = kv_send_command (dev, &hdr, rs);
623
624 if (status)
625 return status;
626
627 *psize = size;
628
629 if (rs->status == KV_CHK_CONDITION && get_RS_ILI (rs->sense))
630 {
631 int delta = B32TOI (&rs->sense[3]);
632 DBG (DBG_error, "size=%d, delta=0x%x (%d)\n", size, delta, delta);
633 *psize = size - delta;
634 }
635
636 DBG (DBG_error, "CMD_read_image: bytes requested=%d, read=%d\n",
637 size, *psize);
638 DBG (DBG_error, "CMD_read_image: ILI=%d, EOM=%d\n",
639 get_RS_ILI (rs->sense), get_RS_EOM (rs->sense));
640
641 return status;
642 }
643
644 SANE_Status
CMD_get_document_existanse(PKV_DEV dev)645 CMD_get_document_existanse (PKV_DEV dev)
646 {
647 SANE_Status status;
648 KV_CMD_HEADER hdr;
649 KV_CMD_RESPONSE rs;
650
651 DBG (DBG_proc, "CMD_get_document_existanse\n");
652
653 memset (&hdr, 0, sizeof (hdr));
654
655 hdr.direction = KV_CMD_IN;
656 hdr.cdb_size = 10;
657 hdr.cdb[0] = SCSI_READ_10;
658 hdr.cdb[2] = 0x81;
659 Ito24 (6, &hdr.cdb[6]);
660 hdr.data = dev->buffer;
661 hdr.data_size = 6;
662
663 status = kv_send_command (dev, &hdr, &rs);
664 if (status)
665 return status;
666 if (rs.status)
667 return SANE_STATUS_NO_DOCS;
668 if ((dev->buffer[0] & 0x20) != 0)
669 {
670 return SANE_STATUS_GOOD;
671 }
672
673 return SANE_STATUS_NO_DOCS;
674 }
675
676 SANE_Status
CMD_wait_document_existanse(PKV_DEV dev)677 CMD_wait_document_existanse (PKV_DEV dev)
678 {
679 SANE_Status status;
680 KV_CMD_HEADER hdr;
681 KV_CMD_RESPONSE rs;
682 int cnt;
683
684 DBG (DBG_proc, "CMD_wait_document_existanse\n");
685
686 memset (&hdr, 0, sizeof (hdr));
687
688 hdr.direction = KV_CMD_IN;
689 hdr.cdb_size = 10;
690 hdr.cdb[0] = SCSI_READ_10;
691 hdr.cdb[2] = 0x81;
692 Ito24 (6, &hdr.cdb[6]);
693 hdr.data = dev->buffer;
694 hdr.data_size = 6;
695
696 for (cnt = 0; cnt < dev->val[OPT_FEED_TIMEOUT].w; cnt++)
697 {
698 DBG (DBG_proc, "CMD_wait_document_existanse: tray #%d of %d\n", cnt,
699 dev->val[OPT_FEED_TIMEOUT].w);
700 status = kv_send_command (dev, &hdr, &rs);
701 if (status)
702 return status;
703 if (rs.status)
704 return SANE_STATUS_NO_DOCS;
705 if ((dev->buffer[0] & 0x20) != 0)
706 {
707 return SANE_STATUS_GOOD;
708 }
709 else if (strcmp (dev->val[OPT_MANUALFEED].s, "off") == 0)
710 {
711 return SANE_STATUS_NO_DOCS;
712 }
713 sleep (1);
714 }
715
716 return SANE_STATUS_NO_DOCS;
717 }
718
719 SANE_Status
CMD_request_sense(PKV_DEV dev)720 CMD_request_sense (PKV_DEV dev)
721 {
722 KV_CMD_HEADER hdr;
723 KV_CMD_RESPONSE rs;
724
725 DBG (DBG_proc, "CMD_request_sense\n");
726 memset (&hdr, 0, sizeof (hdr));
727 hdr.direction = KV_CMD_IN;
728 hdr.cdb[0] = SCSI_REQUEST_SENSE;
729 hdr.cdb[4] = 0x12;
730 hdr.cdb_size = 6;
731 hdr.data_size = 0x12;
732 hdr.data = dev->buffer;
733
734 return kv_send_command (dev, &hdr, &rs);
735 }
736
737 /* Scan routines */
738
739 /* Allocate image buffer for one page (1 or 2 sides) */
740
741 SANE_Status
AllocateImageBuffer(PKV_DEV dev)742 AllocateImageBuffer (PKV_DEV dev)
743 {
744 int *size = dev->bytes_to_read;
745 int sides = IS_DUPLEX (dev) ? 2 : 1;
746 int i;
747 size[0] = dev->params[0].bytes_per_line * dev->params[0].lines;
748 size[1] = dev->params[1].bytes_per_line * dev->params[1].lines;
749
750 DBG (DBG_proc, "AllocateImageBuffer: enter\n");
751
752 for (i = 0; i < sides; i++)
753 {
754 SANE_Byte *p;
755 DBG (DBG_proc, "AllocateImageBuffer: size(%c)=%d\n",
756 i ? 'B' : 'F', size[i]);
757
758 if (dev->img_buffers[i] == NULL)
759 {
760 p = (SANE_Byte *) malloc (size[i]);
761 if (p == NULL)
762 {
763 return SANE_STATUS_NO_MEM;
764 }
765 dev->img_buffers[i] = p;
766 }
767 else
768 {
769 p = (SANE_Byte *) realloc (dev->img_buffers[i], size[i]);
770 if (p == NULL)
771 {
772 return SANE_STATUS_NO_MEM;
773 }
774 else
775 {
776 dev->img_buffers[i] = p;
777 }
778 }
779 }
780 DBG (DBG_proc, "AllocateImageBuffer: exit\n");
781
782 return SANE_STATUS_GOOD;
783 }
784
785 /* Read image data from scanner dev->img_buffers[0],
786 for the simplex page */
787 SANE_Status
ReadImageDataSimplex(PKV_DEV dev, int page)788 ReadImageDataSimplex (PKV_DEV dev, int page)
789 {
790 int bytes_to_read = dev->bytes_to_read[0];
791 SANE_Byte *buffer = (SANE_Byte *) dev->buffer;
792 int buff_size = SCSI_BUFFER_SIZE;
793 SANE_Byte *pt = dev->img_buffers[0];
794 KV_CMD_RESPONSE rs;
795 dev->img_size[0] = 0;
796 dev->img_size[1] = 0;
797
798 /* read loop */
799 do
800 {
801 int size = buff_size;
802 SANE_Status status;
803 DBG (DBG_error, "Bytes left = %d\n", bytes_to_read);
804 status = CMD_read_image (dev, page, SIDE_FRONT, buffer, &size, &rs);
805 if (status)
806 {
807 return status;
808 }
809 if (rs.status)
810 {
811 if (get_RS_sense_key (rs.sense))
812 {
813 DBG (DBG_error, "Error reading image data, "
814 "sense_key=%d, ASC=%d, ASCQ=%d",
815 get_RS_sense_key (rs.sense),
816 get_RS_ASC (rs.sense), get_RS_ASCQ (rs.sense));
817
818 if (get_RS_sense_key (rs.sense) == 3)
819 {
820 if (!get_RS_ASCQ (rs.sense))
821 return SANE_STATUS_NO_DOCS;
822 return SANE_STATUS_JAMMED;
823 }
824 return SANE_STATUS_IO_ERROR;
825 }
826
827 }
828 /* copy data to image buffer */
829 if (size > bytes_to_read)
830 {
831 size = bytes_to_read;
832 }
833 if (size > 0)
834 {
835 memcpy (pt, buffer, size);
836 bytes_to_read -= size;
837 pt += size;
838 dev->img_size[0] += size;
839 }
840 }
841 while (!get_RS_EOM (rs.sense));
842
843 assert (pt == dev->img_buffers[0] + dev->img_size[0]);
844 DBG (DBG_error, "Image size = %d\n", dev->img_size[0]);
845 return SANE_STATUS_GOOD;
846 }
847
848 /* Read image data from scanner dev->img_buffers[0],
849 for the duplex page */
850 SANE_Status
ReadImageDataDuplex(PKV_DEV dev, int page)851 ReadImageDataDuplex (PKV_DEV dev, int page)
852 {
853 int bytes_to_read[2];
854 SANE_Byte *buffer = (SANE_Byte *) dev->buffer;
855 int buff_size[2];
856 SANE_Byte *pt[2];
857 KV_CMD_RESPONSE rs;
858 int sides[2];
859 SANE_Bool eoms[2];
860 int current_side = 1;
861
862 bytes_to_read[0] = dev->bytes_to_read[0];
863 bytes_to_read[1] = dev->bytes_to_read[1];
864
865 pt[0] = dev->img_buffers[0];
866 pt[1] = dev->img_buffers[1];
867
868 sides[0] = SIDE_FRONT;
869 sides[1] = SIDE_BACK;
870 eoms[0] = eoms[1] = 0;
871
872 buff_size[0] = SCSI_BUFFER_SIZE;
873 buff_size[1] = SCSI_BUFFER_SIZE;
874 dev->img_size[0] = 0;
875 dev->img_size[1] = 0;
876
877 /* read loop */
878 do
879 {
880 int size = buff_size[current_side];
881 SANE_Status status;
882 DBG (DBG_error, "Bytes left (F) = %d\n", bytes_to_read[0]);
883 DBG (DBG_error, "Bytes left (B) = %d\n", bytes_to_read[1]);
884
885 status = CMD_read_image (dev, page, sides[current_side],
886 buffer, &size, &rs);
887 if (status)
888 {
889 return status;
890 }
891 if (rs.status)
892 {
893 if (get_RS_sense_key (rs.sense))
894 {
895 DBG (DBG_error, "Error reading image data, "
896 "sense_key=%d, ASC=%d, ASCQ=%d",
897 get_RS_sense_key (rs.sense),
898 get_RS_ASC (rs.sense), get_RS_ASCQ (rs.sense));
899
900 if (get_RS_sense_key (rs.sense) == 3)
901 {
902 if (!get_RS_ASCQ (rs.sense))
903 return SANE_STATUS_NO_DOCS;
904 return SANE_STATUS_JAMMED;
905 }
906 return SANE_STATUS_IO_ERROR;
907 }
908 }
909
910 /* copy data to image buffer */
911 if (size > bytes_to_read[current_side])
912 {
913 size = bytes_to_read[current_side];
914 }
915 if (size > 0)
916 {
917 memcpy (pt[current_side], buffer, size);
918 bytes_to_read[current_side] -= size;
919 pt[current_side] += size;
920 dev->img_size[current_side] += size;
921 }
922 if (rs.status)
923 {
924 if (get_RS_EOM (rs.sense))
925 {
926 eoms[current_side] = 1;
927 }
928 if (get_RS_ILI (rs.sense))
929 {
930 current_side++;
931 current_side &= 1;
932 }
933 }
934 }
935 while (eoms[0] == 0 || eoms[1] == 0);
936
937 DBG (DBG_error, "Image size (F) = %d\n", dev->img_size[0]);
938 DBG (DBG_error, "Image size (B) = %d\n", dev->img_size[1]);
939
940 assert (pt[0] == dev->img_buffers[0] + dev->img_size[0]);
941 assert (pt[1] == dev->img_buffers[1] + dev->img_size[1]);
942
943 return SANE_STATUS_GOOD;
944 }
945
946 /* Read image data for one page */
947 SANE_Status
ReadImageData(PKV_DEV dev, int page)948 ReadImageData (PKV_DEV dev, int page)
949 {
950 SANE_Status status;
951 DBG (DBG_proc, "Reading image data for page %d\n", page);
952
953 if (IS_DUPLEX (dev))
954 {
955 DBG (DBG_proc, "ReadImageData: Duplex %d\n", page);
956 status = ReadImageDataDuplex (dev, page);
957 }
958 else
959 {
960 DBG (DBG_proc, "ReadImageData: Simplex %d\n", page);
961 status = ReadImageDataSimplex (dev, page);
962 }
963 dev->img_pt[0] = dev->img_buffers[0];
964 dev->img_pt[1] = dev->img_buffers[1];
965
966 DBG (DBG_proc, "Reading image data for page %d, finished\n", page);
967
968 return status;
969 }
970
971 /* Look in image for likely upper and left paper edges, then rotate
972 * image so that upper left corner of paper is upper left of image.
973 * FIXME: should we do this before we binarize instead of after? */
974 SANE_Status
buffer_deskew(PKV_DEV s, int side)975 buffer_deskew(PKV_DEV s, int side)
976 {
977 SANE_Status ret = SANE_STATUS_GOOD;
978 int bg_color = 0xd6;
979 int side_index = (side == SIDE_FRONT)?0:1;
980 int resolution = s->val[OPT_RESOLUTION].w;
981
982 DBG (10, "buffer_deskew: start\n");
983
984 /*only find skew on first image from a page, or if first image had error */
985 if(side == SIDE_FRONT || s->deskew_stat){
986
987 s->deskew_stat = sanei_magic_findSkew(
988 &s->params[side_index],s->img_buffers[side_index],
989 resolution,resolution,
990 &s->deskew_vals[0],&s->deskew_vals[1],&s->deskew_slope);
991
992 if(s->deskew_stat){
993 DBG (5, "buffer_despeck: bad findSkew, bailing\n");
994 goto cleanup;
995 }
996 }
997 /* backside images can use a 'flipped' version of frontside data */
998 else{
999 s->deskew_slope *= -1;
1000 s->deskew_vals[0]
1001 = s->params[side_index].pixels_per_line - s->deskew_vals[0];
1002 }
1003
1004 ret = sanei_magic_rotate(&s->params[side_index],s->img_buffers[side_index],
1005 s->deskew_vals[0],s->deskew_vals[1],s->deskew_slope,bg_color);
1006
1007 if(ret){
1008 DBG(5,"buffer_deskew: rotate error: %d",ret);
1009 ret = SANE_STATUS_GOOD;
1010 goto cleanup;
1011 }
1012
1013 cleanup:
1014 DBG (10, "buffer_deskew: finish\n");
1015 return ret;
1016 }
1017
1018 /* Look in image for likely left/right/bottom paper edges, then crop image.
1019 * Does not attempt to rotate the image, that should be done first.
1020 * FIXME: should we do this before we binarize instead of after? */
1021 SANE_Status
buffer_crop(PKV_DEV s, int side)1022 buffer_crop(PKV_DEV s, int side)
1023 {
1024 SANE_Status ret = SANE_STATUS_GOOD;
1025 int side_index = (side == SIDE_FRONT)?0:1;
1026 int resolution = s->val[OPT_RESOLUTION].w;
1027
1028 DBG (10, "buffer_crop: start\n");
1029
1030 /*only find edges on first image from a page, or if first image had error */
1031 if(side == SIDE_FRONT || s->crop_stat){
1032
1033 s->crop_stat = sanei_magic_findEdges(
1034 &s->params[side_index],s->img_buffers[side_index],
1035 resolution,resolution,
1036 &s->crop_vals[0],&s->crop_vals[1],&s->crop_vals[2],&s->crop_vals[3]);
1037
1038 if(s->crop_stat){
1039 DBG (5, "buffer_crop: bad edges, bailing\n");
1040 goto cleanup;
1041 }
1042
1043 DBG (15, "buffer_crop: t:%d b:%d l:%d r:%d\n",
1044 s->crop_vals[0],s->crop_vals[1],s->crop_vals[2],s->crop_vals[3]);
1045
1046 /* we don't listen to the 'top' value, since the top is not padded */
1047 /*s->crop_vals[0] = 0;*/
1048 }
1049 /* backside images can use a 'flipped' version of frontside data */
1050 else{
1051 int left = s->crop_vals[2];
1052 int right = s->crop_vals[3];
1053
1054 s->crop_vals[2] = s->params[side_index].pixels_per_line - right;
1055 s->crop_vals[3] = s->params[side_index].pixels_per_line - left;
1056 }
1057
1058 /* now crop the image */
1059 ret = sanei_magic_crop(&s->params[side_index],s->img_buffers[side_index],
1060 s->crop_vals[0],s->crop_vals[1],s->crop_vals[2],s->crop_vals[3]);
1061
1062 if(ret){
1063 DBG (5, "buffer_crop: bad crop, bailing\n");
1064 ret = SANE_STATUS_GOOD;
1065 goto cleanup;
1066 }
1067
1068 /* update image size counter to new, smaller size */
1069 s->img_size[side_index]
1070 = s->params[side_index].lines * s->params[side_index].bytes_per_line;
1071
1072 cleanup:
1073 DBG (10, "buffer_crop: finish\n");
1074 return ret;
1075 }
1076
1077 /* Look in image for disconnected 'spots' of the requested size.
1078 * Replace the spots with the average color of the surrounding pixels.
1079 * FIXME: should we do this before we binarize instead of after? */
1080 SANE_Status
buffer_despeck(PKV_DEV s, int side)1081 buffer_despeck(PKV_DEV s, int side)
1082 {
1083 SANE_Status ret = SANE_STATUS_GOOD;
1084 int side_index = (side == SIDE_FRONT)?0:1;
1085
1086 DBG (10, "buffer_despeck: start\n");
1087
1088 ret = sanei_magic_despeck(
1089 &s->params[side_index],s->img_buffers[side_index],s->val[OPT_SWDESPECK].w
1090 );
1091 if(ret){
1092 DBG (5, "buffer_despeck: bad despeck, bailing\n");
1093 ret = SANE_STATUS_GOOD;
1094 goto cleanup;
1095 }
1096
1097 cleanup:
1098 DBG (10, "buffer_despeck: finish\n");
1099 return ret;
1100 }
1101
1102 /* Look if image has too few dark pixels.
1103 * FIXME: should we do this before we binarize instead of after? */
1104 int
buffer_isblank(PKV_DEV s, int side)1105 buffer_isblank(PKV_DEV s, int side)
1106 {
1107 SANE_Status ret = SANE_STATUS_GOOD;
1108 int side_index = (side == SIDE_FRONT)?0:1;
1109 int status = 0;
1110
1111 DBG (10, "buffer_isblank: start\n");
1112
1113 ret = sanei_magic_isBlank(
1114 &s->params[side_index],s->img_buffers[side_index],
1115 SANE_UNFIX(s->val[OPT_SWSKIP].w)
1116 );
1117
1118 if(ret == SANE_STATUS_NO_DOCS){
1119 DBG (5, "buffer_isblank: blank!\n");
1120 status = 1;
1121 }
1122 else if(ret){
1123 DBG (5, "buffer_isblank: error %d\n",ret);
1124 }
1125
1126 DBG (10, "buffer_isblank: finished\n");
1127 return status;
1128 }
1129
1130 /* Look if image needs rotation
1131 * FIXME: should we do this before we binarize instead of after? */
1132 SANE_Status
buffer_rotate(PKV_DEV s, int side)1133 buffer_rotate(PKV_DEV s, int side)
1134 {
1135 SANE_Status ret = SANE_STATUS_GOOD;
1136 int angle = 0;
1137 int side_index = (side == SIDE_FRONT)?0:1;
1138 int resolution = s->val[OPT_RESOLUTION].w;
1139
1140 DBG (10, "buffer_rotate: start\n");
1141
1142 if(s->val[OPT_SWDEROTATE].w){
1143 ret = sanei_magic_findTurn(
1144 &s->params[side_index],s->img_buffers[side_index],
1145 resolution,resolution,&angle);
1146
1147 if(ret){
1148 DBG (5, "buffer_rotate: error %d\n",ret);
1149 ret = SANE_STATUS_GOOD;
1150 goto cleanup;
1151 }
1152 }
1153
1154 angle += s->val[OPT_ROTATE].w;
1155
1156 /*90 or 270 degree rotations are reversed on back side*/
1157 if(side == SIDE_BACK && s->val[OPT_ROTATE].w % 180){
1158 angle += 180;
1159 }
1160
1161 ret = sanei_magic_turn(
1162 &s->params[side_index],s->img_buffers[side_index],
1163 angle);
1164
1165 if(ret){
1166 DBG (5, "buffer_rotate: error %d\n",ret);
1167 ret = SANE_STATUS_GOOD;
1168 goto cleanup;
1169 }
1170
1171 /* update image size counter to new, smaller size */
1172 s->img_size[side_index]
1173 = s->params[side_index].lines * s->params[side_index].bytes_per_line;
1174
1175 cleanup:
1176 DBG (10, "buffer_rotate: finished\n");
1177 return ret;
1178 }
1179