Update upstream source from tag 'upstream/1.0.29'

Update to upstream version '1.0.29'
with Debian dir 2d358af604988ebe4348e38096245d66036fe5ed

1 files changed, 556 insertions, 0 deletions

diff --git a/backend/pixma/pixma_io_sanei.c b/backend/pixma/pixma_io_sanei.c
new file mode 100644
index 0000000..c30b404
--- /dev/null
+++ b/backend/pixma/pixma_io_sanei.c
@@ -0,0 +1,556 @@
+/* SANE - Scanner Access Now Easy.
+ * For limitations, see function sanei_usb_get_vendor_product().
+
+   Copyright (C) 2011-2019 Rolf Bensch <rolf at bensch hyphen online dot de>
+   Copyright (C) 2006-2007 Wittawat Yamwong <wittawat@web.de>
+
+   This file is part of the SANE package.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, the authors of SANE give permission for
+   additional uses of the libraries contained in this release of SANE.
+
+   The exception is that, if you link a SANE library with other files
+   to produce an executable, this does not by itself cause the
+   resulting executable to be covered by the GNU General Public
+   License.  Your use of that executable is in no way restricted on
+   account of linking the SANE library code into it.
+
+   This exception does not, however, invalidate any other reasons why
+   the executable file might be covered by the GNU General Public
+   License.
+
+   If you submit changes to SANE to the maintainers to be included in
+   a subsequent release, you agree by submitting the changes that
+   those changes may be distributed with this exception intact.
+
+   If you write modifications of your own for SANE, it is your choice
+   whether to permit this exception to apply to your modifications.
+   If you do not wish that, delete this exception notice.
+ */
+#include "../include/sane/config.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>		/* INT_MAX */
+
+#include "pixma_rename.h"
+#include "pixma_common.h"
+#include "pixma_io.h"
+#include "pixma_bjnp.h"
+
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/sane.h"
+
+
+#ifdef __GNUC__
+# define UNUSED(v) (void) v
+#else
+# define UNUSED(v)
+#endif
+
+/* MAC OS X does not support timeouts in darwin/libusb interrupt reads
+ * This is a very basic turnaround for MAC OS X
+ * Button scan will not work with this wrapper */
+#ifdef __APPLE__
+# define sanei_usb_read_int sanei_usb_read_bulk
+#endif
+
+
+struct pixma_io_t
+{
+  pixma_io_t *next;
+  int interface;
+  SANE_Int dev;
+};
+
+typedef struct scanner_info_t
+{
+  struct scanner_info_t *next;
+  char *devname;
+  int interface;
+  const pixma_config_t *cfg;
+  char serial[PIXMA_MAX_ID_LEN + 1];	/* "xxxxyyyy_zzzzzzz..."
+					   x = vid, y = pid, z = serial */
+} scanner_info_t;
+
+#define INT_USB 0
+#define INT_BJNP 1
+
+static scanner_info_t *first_scanner = NULL;
+static pixma_io_t *first_io = NULL;
+static unsigned nscanners;
+
+
+static scanner_info_t *
+get_scanner_info (unsigned devnr)
+{
+  scanner_info_t *si;
+  for (si = first_scanner; si && devnr != 0; --devnr, si = si->next)
+    {
+    }
+  return si;
+}
+
+static SANE_Status
+attach (SANE_String_Const devname)
+{
+  scanner_info_t *si;
+
+  si = (scanner_info_t *) calloc (1, sizeof (*si));
+  if (!si)
+    return SANE_STATUS_NO_MEM;
+  si->devname = strdup (devname);
+  if (!si->devname)
+    return SANE_STATUS_NO_MEM;
+  si -> interface = INT_USB;
+  si->next = first_scanner;
+  first_scanner = si;
+  nscanners++;
+  return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+attach_bjnp (SANE_String_Const devname,
+             SANE_String_Const serial,
+             const struct pixma_config_t *cfg)
+{
+  scanner_info_t *si;
+
+  si = (scanner_info_t *) calloc (1, sizeof (*si));
+  if (!si)
+    return SANE_STATUS_NO_MEM;
+  si->devname = strdup (devname);
+  if (!si->devname)
+    return SANE_STATUS_NO_MEM;
+
+  si->cfg = cfg;
+  sprintf(si->serial, "%s_%s", cfg->model, serial);
+  si -> interface = INT_BJNP;
+  si->next = first_scanner;
+  first_scanner = si;
+  nscanners++;
+  return SANE_STATUS_GOOD;
+}
+
+static void
+clear_scanner_list (void)
+{
+  scanner_info_t *si = first_scanner;
+  while (si)
+    {
+      scanner_info_t *temp = si;
+      free (si->devname);
+      si = si->next;
+      free (temp);
+    }
+  nscanners = 0;
+  first_scanner = NULL;
+}
+
+static SANE_Status
+get_descriptor (SANE_Int dn, SANE_Int type, SANE_Int descidx,
+		SANE_Int index, SANE_Int length, SANE_Byte * data)
+{
+  return sanei_usb_control_msg (dn, 0x80, USB_REQ_GET_DESCRIPTOR,
+				((type & 0xff) << 8) | (descidx & 0xff),
+				index, length, data);
+}
+
+static SANE_Status
+get_string_descriptor (SANE_Int dn, SANE_Int index, SANE_Int lang,
+		       SANE_Int length, SANE_Byte * data)
+{
+  return get_descriptor (dn, USB_DT_STRING, index, lang, length, data);
+}
+
+static void
+u16tohex (uint16_t x, char *str)
+{
+  static const char hdigit[16] =
+    { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F'
+    };
+  str[0] = hdigit[(x >> 12) & 0xf];
+  str[1] = hdigit[(x >> 8) & 0xf];
+  str[2] = hdigit[(x >> 4) & 0xf];
+  str[3] = hdigit[x & 0xf];
+  str[4] = '\0';
+}
+
+static void
+read_serial_number (scanner_info_t * si)
+{
+  uint8_t unicode[2 * (PIXMA_MAX_ID_LEN - 9) + 2];
+  uint8_t ddesc[18];
+  int iSerialNumber;
+  SANE_Int usb;
+  char *serial = si->serial;
+
+  u16tohex (si->cfg->vid, serial);
+  u16tohex (si->cfg->pid, serial + 4);
+
+  if (SANE_STATUS_GOOD != sanei_usb_open (si->devname, &usb))
+    return;
+  if (get_descriptor (usb, USB_DT_DEVICE, 0, 0, 18, ddesc)
+      != SANE_STATUS_GOOD)
+    goto done;
+  iSerialNumber = ddesc[16];
+  if (iSerialNumber != 0)
+    {
+      int i, len;
+      SANE_Status status;
+
+      /*int iSerialNumber = ddesc[16];*/
+      /* Read the first language code. Assumed that there is at least one. */
+      if (get_string_descriptor (usb, 0, 0, 4, unicode) != SANE_STATUS_GOOD)
+        goto done;
+      /* Read the serial number string. */
+      status = get_string_descriptor (usb, iSerialNumber,
+                                      unicode[3] * 256 + unicode[2],
+                                      sizeof (unicode), unicode);
+      if (status != SANE_STATUS_GOOD)
+        goto done;
+      /* Assumed charset: Latin1 */
+      len = unicode[0];
+      if (len > (int) sizeof (unicode))
+        {
+          len = sizeof (unicode);
+          PDBG (pixma_dbg (1, "WARNING:Truncated serial number\n"));
+        }
+            serial[8] = '_';
+            for (i = 2; i < len; i += 2)
+        {
+          serial[9 + i / 2 - 1] = unicode[i];
+        }
+      serial[9 + i / 2 - 1] = '\0';
+    }
+  else
+    {
+      PDBG (pixma_dbg (1, "WARNING:No serial number\n"));
+    }
+done:
+  sanei_usb_close (usb);
+}
+
+static int
+map_error (SANE_Status ss)
+{
+  switch (ss)
+    {
+    case SANE_STATUS_GOOD:
+      return 0;
+    case SANE_STATUS_UNSUPPORTED:
+      return PIXMA_ENODEV;
+    case SANE_STATUS_DEVICE_BUSY:
+      return PIXMA_EBUSY;
+    case SANE_STATUS_INVAL:
+      return PIXMA_EINVAL;
+    case SANE_STATUS_IO_ERROR:
+      return PIXMA_EIO;
+    case SANE_STATUS_NO_MEM:
+      return PIXMA_ENOMEM;
+    case SANE_STATUS_ACCESS_DENIED:
+      return PIXMA_EACCES;
+    case SANE_STATUS_CANCELLED:
+      return PIXMA_ECANCELED;
+    case SANE_STATUS_JAMMED:
+       return PIXMA_EPAPER_JAMMED;
+    case SANE_STATUS_COVER_OPEN:
+       return PIXMA_ECOVER_OPEN;
+    case SANE_STATUS_NO_DOCS:
+       return PIXMA_ENO_PAPER;
+    case SANE_STATUS_EOF:
+       return PIXMA_EOF;
+#ifdef SANE_STATUS_HW_LOCKED
+    case SANE_STATUS_HW_LOCKED:       /* unused by pixma */
+#endif
+#ifdef SANE_STATUS_WARMING_UP
+    case SANE_STATUS_WARMING_UP:      /* unused by pixma */
+#endif
+      break;
+    }
+  PDBG (pixma_dbg (1, "BUG:Unmapped SANE Status code %d\n", ss));
+  return PIXMA_EIO;		/* should not happen */
+}
+
+
+int
+pixma_io_init (void)
+{
+  sanei_usb_init ();
+  sanei_bjnp_init();
+  nscanners = 0;
+  return 0;
+}
+
+void
+pixma_io_cleanup (void)
+{
+  while (first_io)
+    pixma_disconnect (first_io);
+  clear_scanner_list ();
+}
+
+unsigned
+pixma_collect_devices (const char **conf_devices,
+                       const struct pixma_config_t *const pixma_devices[], SANE_Bool local_only)
+{
+  unsigned i, j;
+  struct scanner_info_t *si;
+  const struct pixma_config_t *cfg;
+
+  clear_scanner_list ();
+  j = 0;
+  for (i = 0; pixma_devices[i]; i++)
+    {
+      for (cfg = pixma_devices[i]; cfg->name; cfg++)
+        {
+          sanei_usb_find_devices (cfg->vid, cfg->pid, attach);
+          si = first_scanner;
+          while (j < nscanners)
+            {
+              PDBG (pixma_dbg (3, "pixma_collect_devices() found %s at %s\n",
+                   cfg->name, si->devname));
+              si->cfg = cfg;
+              read_serial_number (si);
+              si = si->next;
+              j++;
+            }
+        }
+    }
+  if (! local_only)
+    sanei_bjnp_find_devices(conf_devices, attach_bjnp, pixma_devices);
+
+  si = first_scanner;
+  while (j < nscanners)
+    {
+      PDBG (pixma_dbg (3, "pixma_collect_devices() found %s at %s\n",
+               si->cfg->name, si->devname));
+      si = si->next;
+      j++;
+
+    }
+  return nscanners;
+}
+
+const pixma_config_t *
+pixma_get_device_config (unsigned devnr)
+{
+  const scanner_info_t *si = get_scanner_info (devnr);
+  return (si) ? si->cfg : NULL;
+}
+
+const char *
+pixma_get_device_id (unsigned devnr)
+{
+  const scanner_info_t *si = get_scanner_info (devnr);
+  return (si) ? si->serial : NULL;
+}
+
+int
+pixma_connect (unsigned devnr, pixma_io_t ** handle)
+{
+  pixma_io_t *io;
+  SANE_Int dev;
+  const scanner_info_t *si;
+  int error;
+
+  *handle = NULL;
+  si = get_scanner_info (devnr);
+  if (!si)
+    return PIXMA_EINVAL;
+  if (si-> interface == INT_BJNP)
+    error = map_error (sanei_bjnp_open (si->devname, &dev));
+  else
+    error = map_error (sanei_usb_open (si->devname, &dev));
+
+  if (error < 0)
+    return error;
+  io = (pixma_io_t *) calloc (1, sizeof (*io));
+  if (!io)
+    {
+      if (si -> interface == INT_BJNP)
+        sanei_bjnp_close (dev);
+      else
+        sanei_usb_close (dev);
+      return PIXMA_ENOMEM;
+    }
+  io->next = first_io;
+  first_io = io;
+  io->dev = dev;
+  io->interface = si->interface;
+  *handle = io;
+  return 0;
+}
+
+
+void
+pixma_disconnect (pixma_io_t * io)
+{
+  pixma_io_t **p;
+
+  if (!io)
+    return;
+  for (p = &first_io; *p && *p != io; p = &((*p)->next))
+    {
+    }
+  PASSERT (*p);
+  if (!(*p))
+    return;
+  if (io-> interface == INT_BJNP)
+    sanei_bjnp_close (io->dev);
+  else
+    sanei_usb_close (io->dev);
+  *p = io->next;
+  free (io);
+}
+
+int pixma_activate (pixma_io_t * io)
+{
+  int error;
+  if (io->interface == INT_BJNP)
+    {
+      error = map_error(sanei_bjnp_activate (io->dev));
+    }
+  else
+    /* noop for USB interface */
+    error = 0;
+  return error;
+}
+
+int pixma_deactivate (pixma_io_t * io)
+{
+  int error;
+  if (io->interface == INT_BJNP)
+    {
+      error = map_error(sanei_bjnp_deactivate (io->dev));
+    }
+  else
+    /* noop for USB interface */
+    error = 0;
+  return error;
+
+}
+
+int
+pixma_reset_device (pixma_io_t * io)
+{
+  UNUSED (io);
+  return PIXMA_ENOTSUP;
+}
+
+int
+pixma_write (pixma_io_t * io, const void *cmd, unsigned len)
+{
+  size_t count = len;
+  int error;
+
+  if (io->interface == INT_BJNP)
+    {
+    sanei_bjnp_set_timeout (io->dev, PIXMA_BULKOUT_TIMEOUT);
+    error = map_error (sanei_bjnp_write_bulk (io->dev, cmd, &count));
+    }
+  else
+    {
+#ifdef HAVE_SANEI_USB_SET_TIMEOUT
+    sanei_usb_set_timeout (PIXMA_BULKOUT_TIMEOUT);
+#endif
+    error = map_error (sanei_usb_write_bulk (io->dev, cmd, &count));
+    }
+  if (error == PIXMA_EIO)
+    error = PIXMA_ETIMEDOUT;	/* FIXME: SANE doesn't have ETIMEDOUT!! */
+  if (count != len)
+    {
+      PDBG (pixma_dbg (1, "WARNING:pixma_write(): count(%u) != len(%u)\n",
+		       (unsigned) count, len));
+      error = PIXMA_EIO;
+    }
+  if (error >= 0)
+    error = count;
+  PDBG (pixma_dump (10, "OUT ", cmd, error, len, 128));
+  return error;
+}
+
+int
+pixma_read (pixma_io_t * io, void *buf, unsigned size)
+{
+  size_t count = size;
+  int error;
+
+  if (io-> interface == INT_BJNP)
+    {
+    sanei_bjnp_set_timeout (io->dev, PIXMA_BULKIN_TIMEOUT);
+    error = map_error (sanei_bjnp_read_bulk (io->dev, buf, &count));
+    }
+  else
+    {
+#ifdef HAVE_SANEI_USB_SET_TIMEOUT
+      sanei_usb_set_timeout (PIXMA_BULKIN_TIMEOUT);
+#endif
+      error = map_error (sanei_usb_read_bulk (io->dev, buf, &count));
+    }
+
+  if (error == PIXMA_EIO)
+    error = PIXMA_ETIMEDOUT;	/* FIXME: SANE doesn't have ETIMEDOUT!! */
+  if (error >= 0)
+    error = count;
+  PDBG (pixma_dump (10, "IN  ", buf, error, -1, 128));
+  return error;
+}
+
+int
+pixma_wait_interrupt (pixma_io_t * io, void *buf, unsigned size, int timeout)
+{
+  size_t count = size;
+  int error;
+
+  /* FIXME: What is the meaning of "timeout" in sanei_usb? */
+  if (timeout < 0)
+    timeout = INT_MAX;
+  else if (timeout < 100)
+    timeout = 100;
+  if (io-> interface == INT_BJNP)
+    {
+      sanei_bjnp_set_timeout (io->dev, timeout);
+      error = map_error (sanei_bjnp_read_int (io->dev, buf, &count));
+    }
+  else
+    {
+#ifdef HAVE_SANEI_USB_SET_TIMEOUT
+      sanei_usb_set_timeout (timeout);
+#endif
+      error = map_error (sanei_usb_read_int (io->dev, buf, &count));
+    }
+  if (error == PIXMA_EIO ||
+      (io->interface == INT_BJNP && error == PIXMA_EOF))     /* EOF is a bjnp timeout error! */
+    error = PIXMA_ETIMEDOUT;	/* FIXME: SANE doesn't have ETIMEDOUT!! */
+  if (error == 0)
+    error = count;
+  if (error != PIXMA_ETIMEDOUT)
+    PDBG (pixma_dump (10, "INTR", buf, error, -1, -1));
+  return error;
+}
+
+int
+pixma_set_interrupt_mode (pixma_io_t * s, int background)
+{
+  UNUSED (s);
+  return (background) ? PIXMA_ENOTSUP : 0;
+}