summaryrefslogtreecommitdiff
path: root/backend/kvs20xx.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/kvs20xx.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/kvs20xx.c')
-rw-r--r--backend/kvs20xx.c535
1 files changed, 535 insertions, 0 deletions
diff --git a/backend/kvs20xx.c b/backend/kvs20xx.c
new file mode 100644
index 0000000..955252a
--- /dev/null
+++ b/backend/kvs20xx.c
@@ -0,0 +1,535 @@
+/*
+ Copyright (C) 2008, Panasonic Russia Ltd.
+ Copyright (C) 2010, m. allan noah
+*/
+/*
+ Panasonic KV-S20xx USB-SCSI scanners.
+*/
+
+#define DEBUG_NOT_STATIC
+#define BUILD 2
+
+#include "../include/sane/config.h"
+
+#include <string.h>
+#include <unistd.h>
+
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_scsi.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/lassert.h"
+
+#include "kvs20xx.h"
+#include "kvs20xx_cmd.h"
+
+struct known_device
+{
+ const SANE_Int id;
+ const SANE_Device scanner;
+};
+
+static const struct known_device known_devices[] = {
+ {
+ KV_S2025C,
+ { "", "MATSHITA", "KV-S2025C", "sheetfed scanner" },
+ },
+ {
+ KV_S2045C,
+ { "", "MATSHITA", "KV-S2045C", "sheetfed scanner" },
+ },
+ {
+ KV_S2026C,
+ { "", "MATSHITA", "KV-S2026C", "sheetfed scanner" },
+ },
+ {
+ KV_S2046C,
+ { "", "MATSHITA", "KV-S2046C", "sheetfed scanner" },
+ },
+ {
+ KV_S2028C,
+ { "", "MATSHITA", "KV-S2028C", "sheetfed scanner" },
+ },
+ {
+ KV_S2048C,
+ { "", "MATSHITA", "KV-S2048C", "sheetfed scanner" },
+ },
+};
+
+SANE_Status
+sane_init (SANE_Int __sane_unused__ * version_code,
+ SANE_Auth_Callback __sane_unused__ authorize)
+{
+ DBG_INIT ();
+ DBG (DBG_INFO, "This is panasonic kvs20xx driver\n");
+
+ *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD);
+
+ /* Initialize USB */
+ sanei_usb_init ();
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * List of available devices, allocated by sane_get_devices, released
+ * by sane_exit()
+ */
+static SANE_Device **devlist = NULL;
+static unsigned curr_scan_dev = 0;
+
+void
+sane_exit (void)
+{
+ if (devlist)
+ {
+ int i;
+ for (i = 0; devlist[i]; i++)
+ {
+ free ((void *) devlist[i]->name);
+ free ((void *) devlist[i]);
+ }
+ free ((void *) devlist);
+ devlist = NULL;
+ }
+}
+
+static SANE_Status
+attach (SANE_String_Const devname)
+{
+ int i = 0;
+ if (devlist)
+ {
+ for (; devlist[i]; i++);
+ devlist = realloc (devlist, sizeof (SANE_Device *) * (i + 1));
+ if (!devlist)
+ return SANE_STATUS_NO_MEM;
+ }
+ else
+ {
+ devlist = malloc (sizeof (SANE_Device *) * 2);
+ if (!devlist)
+ return SANE_STATUS_NO_MEM;
+ }
+ devlist[i] = malloc (sizeof (SANE_Device));
+ if (!devlist[i])
+ return SANE_STATUS_NO_MEM;
+ memcpy (devlist[i], &known_devices[curr_scan_dev].scanner,
+ sizeof (SANE_Device));
+ devlist[i]->name = strdup (devname);
+ /* terminate device list with NULL entry: */
+ devlist[i + 1] = 0;
+ DBG (DBG_INFO, "%s device attached\n", devname);
+ return SANE_STATUS_GOOD;
+}
+
+/* Get device list */
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list,
+ SANE_Bool __sane_unused__ local_only)
+{
+ if (devlist)
+ {
+ int i;
+ for (i = 0; devlist[i]; i++)
+ {
+ free ((void *) devlist[i]->name);
+ free ((void *) devlist[i]);
+ }
+ free ((void *) devlist);
+ devlist = NULL;
+ }
+
+ for (curr_scan_dev = 0;
+ curr_scan_dev < sizeof (known_devices) / sizeof (known_devices[0]);
+ curr_scan_dev++)
+ {
+ sanei_usb_find_devices (PANASONIC_ID,
+ known_devices[curr_scan_dev].id, attach);
+ }
+ for (curr_scan_dev = 0;
+ curr_scan_dev < sizeof (known_devices) / sizeof (known_devices[0]);
+ curr_scan_dev++)
+ {
+ sanei_scsi_find_devices (known_devices[curr_scan_dev].scanner.vendor,
+ known_devices[curr_scan_dev].scanner.model,
+ NULL, -1, -1, -1, -1, attach);
+ }
+ *device_list = (const SANE_Device **) devlist;
+ return SANE_STATUS_GOOD;
+}
+
+/* Open device, return the device handle */
+SANE_Status
+sane_open (SANE_String_Const devname, SANE_Handle * handle)
+{
+ unsigned i, j, id = 0;
+ struct scanner *s;
+ SANE_Int h, bus;
+ SANE_Status st;
+ for (i = 0; devlist[i]; i++)
+ {
+ if (!strcmp (devlist[i]->name, devname))
+ break;
+ }
+ if (!devlist[i])
+ return SANE_STATUS_INVAL;
+ for (j = 0; j < sizeof (known_devices) / sizeof (known_devices[0]); j++)
+ {
+ if (!strcmp (devlist[i]->model, known_devices[j].scanner.model))
+ {
+ id = known_devices[j].id;
+ break;
+ }
+ }
+
+ st = sanei_usb_open (devname, &h);
+ if (st == SANE_STATUS_ACCESS_DENIED)
+ return st;
+ if (st)
+ {
+ st = sanei_scsi_open (devname, &h, kvs20xx_sense_handler, NULL);
+ if (st)
+ {
+ return st;
+ }
+ bus = SCSI;
+ }
+ else
+ {
+ bus = USB;
+ st = sanei_usb_claim_interface (h, 0);
+ if (st)
+ {
+ sanei_usb_close (h);
+ return st;
+ }
+ }
+
+ s = malloc (sizeof (struct scanner));
+ if (!s)
+ return SANE_STATUS_NO_MEM;
+ memset (s, 0, sizeof (struct scanner));
+ s->buffer = malloc (MAX_READ_DATA_SIZE + BULK_HEADER_SIZE);
+ if (!s->buffer)
+ return SANE_STATUS_NO_MEM;
+ s->file = h;
+ s->bus = bus;
+ s->id = id;
+ kvs20xx_init_options (s);
+ *handle = s;
+ for (i = 0; i < 3; i++)
+ {
+ st = kvs20xx_test_unit_ready (s);
+ if (st)
+ {
+ if (s->bus == SCSI)
+ {
+ sanei_scsi_close (s->file);
+ st = sanei_scsi_open (devname, &h, kvs20xx_sense_handler, NULL);
+ if (st)
+ return st;
+ }
+ else
+ {
+ sanei_usb_release_interface (s->file, 0);
+ sanei_usb_close (s->file);
+ st = sanei_usb_open (devname, &h);
+ if (st)
+ return st;
+ st = sanei_usb_claim_interface (h, 0);
+ if (st)
+ {
+ sanei_usb_close (h);
+ return st;
+ }
+ }
+ s->file = h;
+ }
+ else
+ break;
+ }
+ if (i == 3)
+ return SANE_STATUS_DEVICE_BUSY;
+
+ st = kvs20xx_set_timeout (s, s->val[FEED_TIMEOUT].w);
+ if (st)
+ {
+ sane_close (s);
+ return st;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Close device */
+void
+sane_close (SANE_Handle handle)
+{
+ struct scanner *s = (struct scanner *) handle;
+ int i;
+ if (s->bus == USB)
+ {
+ sanei_usb_release_interface (s->file, 0);
+ sanei_usb_close (s->file);
+ }
+ else
+ sanei_scsi_close (s->file);
+
+ for (i = 1; i < NUM_OPTIONS; i++)
+ {
+ if (s->opt[i].type == SANE_TYPE_STRING && s->val[i].s)
+ free (s->val[i].s);
+ }
+ if (s->data)
+ free (s->data);
+ free (s->buffer);
+ free (s);
+
+}
+
+/* Get option descriptor */
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ struct scanner *s = handle;
+
+ if ((unsigned) option >= NUM_OPTIONS || option < 0)
+ return NULL;
+ return s->opt + option;
+}
+
+static SANE_Status
+wait_document (struct scanner *s)
+{
+ SANE_Status st;
+ int i;
+ if (!strcmp ("off", s->val[MANUALFEED].s))
+ return kvs20xx_document_exist (s);
+
+ for (i = 0; i < s->val[FEED_TIMEOUT].w; i++)
+ {
+ st = kvs20xx_document_exist (s);
+ if (st != SANE_STATUS_NO_DOCS)
+ return st;
+ sleep (1);
+ }
+ return SANE_STATUS_NO_DOCS;
+}
+
+/* Start scanning */
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ struct scanner *s = (struct scanner *) handle;
+ SANE_Status st;
+ int duplex = s->val[DUPLEX].w;
+
+ if (!s->scanning)
+ {
+ unsigned dummy_length;
+ st = kvs20xx_test_unit_ready (s);
+ if (st)
+ return st;
+
+ st = wait_document (s);
+ if (st)
+ return st;
+
+ st = kvs20xx_reset_window (s);
+ if (st)
+ return st;
+ st = kvs20xx_set_window (s, SIDE_FRONT);
+ if (st)
+ return st;
+ if (duplex)
+ {
+ st = kvs20xx_set_window (s, SIDE_BACK);
+ if (st)
+ return st;
+ }
+ st = kvs20xx_scan (s);
+ if (st)
+ return st;
+
+ st = kvs20xx_read_picture_element (s, SIDE_FRONT, &s->params);
+ if (st)
+ return st;
+ if (duplex)
+ {
+ st = get_adjust_data (s, &dummy_length);
+ if (st)
+ return st;
+ }
+ else
+ {
+ dummy_length = 0;
+ }
+ s->scanning = 1;
+ s->page = 0;
+ s->read = 0;
+ s->side = SIDE_FRONT;
+ sane_get_parameters (s, NULL);
+ s->saved_dummy_size = s->dummy_size = dummy_length
+ ? (dummy_length * s->val[RESOLUTION].w / 1200 - 1)
+ * s->params.bytes_per_line : 0;
+ s->side_size = s->params.lines * s->params.bytes_per_line;
+
+ s->data = realloc (s->data, duplex ? s->side_size * 2 : s->side_size);
+ if (!s->data)
+ {
+ s->scanning = 0;
+ return SANE_STATUS_NO_MEM;
+ }
+ }
+
+ if (duplex)
+ {
+ unsigned side = SIDE_FRONT;
+ unsigned read, mx;
+ if (s->side == SIDE_FRONT && s->read == s->side_size - s->dummy_size)
+ {
+ s->side = SIDE_BACK;
+ s->read = s->dummy_size;
+ s->dummy_size = 0;
+ return SANE_STATUS_GOOD;
+ }
+ s->read = 0;
+ s->dummy_size = s->saved_dummy_size;
+ s->side = SIDE_FRONT;
+ st = kvs20xx_document_exist (s);
+ if (st)
+ return st;
+ for (mx = s->side_size * 2; !st; mx -= read, side ^= SIDE_BACK)
+ st = kvs20xx_read_image_data (s, s->page, side,
+ &s->data[s->side_size * 2 - mx], mx,
+ &read);
+ }
+ else
+ {
+ unsigned read, mx;
+ s->read = 0;
+ st = kvs20xx_document_exist (s);
+ if (st)
+ return st;
+ DBG (DBG_INFO, "start: %d\n", s->page);
+
+ for (mx = s->side_size; !st; mx -= read)
+ st = kvs20xx_read_image_data (s, s->page, SIDE_FRONT,
+ &s->data[s->side_size - mx], mx, &read);
+ }
+ if (st && st != SANE_STATUS_EOF)
+ {
+ s->scanning = 0;
+ return st;
+ }
+ s->page++;
+ return SANE_STATUS_GOOD;
+}
+
+inline static void
+memcpy24 (u8 * dest, u8 * src, unsigned size, unsigned ls)
+{
+ unsigned i;
+ for (i = 0; i < size; i++)
+ {
+ dest[i * 3] = src[i];
+ dest[i * 3 + 1] = src[i + ls];
+ dest[i * 3 + 2] = src[i + 2 * ls];
+ }
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf,
+ SANE_Int max_len, SANE_Int * len)
+{
+ struct scanner *s = (struct scanner *) handle;
+ int duplex = s->val[DUPLEX].w;
+ int color = !strcmp (s->val[MODE].s, SANE_VALUE_SCAN_MODE_COLOR);
+ int rest = s->side_size - s->read - s->dummy_size;
+ *len = 0;
+
+ if (!s->scanning || !rest)
+ {
+ if (strcmp (s->val[FEEDER_MODE].s, SANE_I18N ("continuous")))
+ {
+ if (!duplex || s->side == SIDE_BACK)
+ s->scanning = 0;
+ }
+ return SANE_STATUS_EOF;
+ }
+
+ *len = max_len < rest ? max_len : rest;
+ if (duplex && (s->id == KV_S2025C
+ || s->id == KV_S2026C || s->id == KV_S2028C))
+ {
+ if (color)
+ {
+ unsigned ls = s->params.bytes_per_line;
+ unsigned i, a = s->side == SIDE_FRONT ? 0 : ls / 3;
+ u8 *data;
+ *len = (*len / ls) * ls;
+ for (i = 0, data = s->data + s->read * 2 + a;
+ i < *len / ls; buf += ls, data += 2 * ls, i++)
+ memcpy24 (buf, data, ls / 3, ls * 2 / 3);
+ }
+ else
+ {
+ unsigned ls = s->params.bytes_per_line;
+ unsigned i = s->side == SIDE_FRONT ? 0 : ls;
+ unsigned head = ls - (s->read % ls);
+ unsigned tail = (*len - head) % ls;
+ unsigned lines = (*len - head) / ls;
+ u8 *data = s->data + (s->read / ls) * ls * 2 + i + s->read % ls;
+ assert (data <= s->data + s->side_size * 2);
+ memcpy (buf, data, head);
+ for (i = 0, buf += head, data += head + (head ? ls : 0);
+ i < lines; buf += ls, data += ls * 2, i++)
+ {
+ assert (data <= s->data + s->side_size * 2);
+ memcpy (buf, data, ls);
+ }
+ assert ((data <= s->data + s->side_size * 2) || !tail);
+ memcpy (buf, data, tail);
+ }
+ s->read += *len;
+ }
+ else
+ {
+ if (color)
+ {
+ unsigned i, ls = s->params.bytes_per_line;
+ u8 *data = s->data + s->read;
+ *len = (*len / ls) * ls;
+ for (i = 0; i < *len / ls; buf += ls, data += ls, i++)
+ memcpy24 (buf, data, ls / 3, ls / 3);
+ }
+ else
+ {
+ memcpy (buf, s->data + s->read, *len);
+ }
+ s->read += *len;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+ struct scanner *s = (struct scanner *) handle;
+ s->scanning = 0;
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle __sane_unused__ h, SANE_Bool __sane_unused__ m)
+{
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle __sane_unused__ h,
+ SANE_Int __sane_unused__ * fd)
+{
+ return SANE_STATUS_UNSUPPORTED;
+}