diff options
Diffstat (limited to 'backend/gt68xx_low.c')
| -rw-r--r-- | backend/gt68xx_low.c | 1034 |
1 files changed, 1034 insertions, 0 deletions
diff --git a/backend/gt68xx_low.c b/backend/gt68xx_low.c new file mode 100644 index 0000000..6060c45 --- /dev/null +++ b/backend/gt68xx_low.c @@ -0,0 +1,1034 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 2002 Sergey Vlasov <vsu@altlinux.ru> + Copyright (C) 2002 - 2007 Henning Geinitz <sane@geinitz.org> + + 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. +*/ + +/** @file + * @brief Implementation of the low-level scanner interface functions. + */ + +#include "gt68xx_low.h" + +#include "../include/sane/sane.h" +#include "../include/sane/sanei_debug.h" +#include "../include/sane/sanei_usb.h" + +#include <stdlib.h> +#include <string.h> + +#ifdef USE_FORK +#include <sys/wait.h> +#include <unistd.h> +#include "gt68xx_shm_channel.c" +#endif + +/** Check that the device pointer is not NULL. + * + * @param dev Pointer to the device object (GT68xx_Device). + * @param func_name Function name (for use in debug messages). + */ +#define CHECK_DEV_NOT_NULL(dev, func_name) \ + do { \ + IF_DBG( \ + if (!(dev)) \ + { \ + DBG (0, "BUG: NULL device\n"); \ + return SANE_STATUS_INVAL; \ + } \ + ) \ + } while (SANE_FALSE) + +/** Check that the device is open. + * + * @param dev Pointer to the device object (GT68xx_Device). + * @param func_name Function name (for use in debug messages). + */ +#define CHECK_DEV_OPEN(dev, func_name) \ + do { \ + IF_DBG( \ + CHECK_DEV_NOT_NULL ((dev), (func_name)); \ + if ((dev)->fd == -1) \ + { \ + DBG (0, "%s: BUG: device %p not open\n", (func_name), \ + ((void *) dev)); \ + return SANE_STATUS_INVAL; \ + } \ + ) \ + } while (SANE_FALSE) + +/** Check that the device is open and active. + * + * @param dev Pointer to the device (GT68xx_Device). + * @param func_name Function name (for use in debug messages). + */ +#define CHECK_DEV_ACTIVE(dev, func_name) \ + do { \ + IF_DBG( \ + CHECK_DEV_OPEN ((dev), (func_name)); \ + if (!(dev)->active) \ + { \ + DBG (0, "%s: BUG: device %p not active\n", (func_name), \ + ((void *) dev)); \ + return SANE_STATUS_INVAL; \ + } \ + ) \ + } while (SANE_FALSE) + + +#ifndef NDEBUG + +/** Dump a request packet for debugging purposes. + * + * @param prefix String printed before the packet contents. + * @param req The request packet to be dumped. + */ +static void +dump_req (SANE_String_Const prefix, GT68xx_Packet req) +{ + int i; + char buf[GT68XX_PACKET_SIZE * 3 + 1]; + + for (i = 0; i < GT68XX_PACKET_SIZE; ++i) + sprintf (buf + i * 3, " %02x", req[i]); + DBG (8, "%s%s\n", prefix, buf); +} + +#endif /* not NDEBUG */ + +/** Dump a request packet if the debug level is at 8 or above. + * + * @param prefix String printed before the packet contents. + * @param req The request packet to be dumped. + */ +#define DUMP_REQ(prefix, req) \ + do { IF_DBG( if (DBG_LEVEL >= 8) dump_req ((prefix), (req)); ) } while (0) + + +SANE_Status +gt68xx_device_new (GT68xx_Device ** dev_return) +{ + GT68xx_Device *dev; + + DBG (7, "gt68xx_device_new: enter\n"); + if (!dev_return) + return SANE_STATUS_INVAL; + + dev = (GT68xx_Device *) malloc (sizeof (GT68xx_Device)); + + if (!dev) + { + DBG (3, "gt68xx_device_new: couldn't malloc %lu bytes for device\n", + (u_long) sizeof (GT68xx_Device)); + *dev_return = 0; + return SANE_STATUS_NO_MEM; + } + *dev_return = dev; + + memset (dev, 0, sizeof (GT68xx_Device)); + + dev->fd = -1; + dev->active = SANE_FALSE; + + dev->model = NULL; + dev->command_set_private = NULL; + + dev->read_buffer = NULL; + dev->read_buffer_size = 32768; + + dev->manual_selection = SANE_FALSE; + +#ifdef USE_FORK + dev->shm_channel = NULL; +#endif /* USE_FORK */ + + DBG (7, "gt68xx_device_new:: leave: ok\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_free (GT68xx_Device * dev) +{ + DBG (7, "gt68xx_device_free: enter: dev=%p\n", (void *) dev); + if (dev) + { + if (dev->active) + gt68xx_device_deactivate (dev); + + if (dev->fd != -1) + gt68xx_device_close (dev); + + if (dev->model && dev->model->allocated) + { + DBG (7, "gt68xx_device_free: freeing model data %p\n", + (void *) dev->model); + free (dev->model); + } + + DBG (7, "gt68xx_device_free: freeing dev\n"); + free (dev); + } + DBG (7, "gt68xx_device_free: leave: ok\n"); + return SANE_STATUS_GOOD; +} + +static GT68xx_USB_Device_Entry * +gt68xx_find_usb_device_entry (SANE_Word vendor, SANE_Word product) +{ + GT68xx_USB_Device_Entry *entry; + + for (entry = gt68xx_usb_device_list; entry->model; ++entry) + { + if (vendor == entry->vendor && product == entry->product) + return entry; + } + + return NULL; +} + +static SANE_Status +gt68xx_device_identify (GT68xx_Device * dev) +{ + SANE_Status status; + SANE_Word vendor, product; + GT68xx_USB_Device_Entry *entry; + + CHECK_DEV_OPEN (dev, "gt68xx_device_identify"); + + status = sanei_usb_get_vendor_product (dev->fd, &vendor, &product); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_identify: error getting USB id: %s\n", + sane_strstatus (status)); + return status; + } + + entry = gt68xx_find_usb_device_entry (vendor, product); + + if (entry) + { + dev->model = entry->model; + } + else + { + dev->model = NULL; + DBG (3, "gt68xx_device_identify: unknown USB device (vendor 0x%04x, " + "product 0x%04x)\n", vendor, product); + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_open (GT68xx_Device * dev, const char *dev_name) +{ + SANE_Status status; + SANE_Int fd; + + DBG (7, "gt68xx_device_open: enter: dev=%p\n", (void *) dev); + + CHECK_DEV_NOT_NULL (dev, "gt68xx_device_open"); + + if (dev->fd != -1) + { + DBG (3, "gt68xx_device_open: device already open\n"); + return SANE_STATUS_INVAL; + } + + status = sanei_usb_open (dev_name, &fd); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_open: sanei_usb_open failed: %s\n", + sane_strstatus (status)); + return status; + } + + dev->fd = fd; + + if (!dev->model) + gt68xx_device_identify (dev); + + DBG (7, "gt68xx_device_open: leave: ok\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_close (GT68xx_Device * dev) +{ + DBG (7, "gt68xx_device_close: enter: dev=%p\n", (void *) dev); + + CHECK_DEV_OPEN (dev, "gt68xx_device_close"); + + if (dev->active) + gt68xx_device_deactivate (dev); + + sanei_usb_close (dev->fd); + dev->fd = -1; + + DBG (7, "gt68xx_device_close: leave: ok\n"); + return SANE_STATUS_GOOD; +} + +SANE_Bool +gt68xx_device_is_configured (GT68xx_Device * dev) +{ + if (dev && dev->model && dev->model->command_set) + return SANE_TRUE; + else + return SANE_FALSE; +} + +SANE_Status +gt68xx_device_set_model (GT68xx_Device * dev, GT68xx_Model * model) +{ + if (dev->active) + { + DBG (3, "gt68xx_device_set_model: device already active\n"); + return SANE_STATUS_INVAL; + } + + if (dev->model && dev->model->allocated) + free (dev->model); + + dev->model = model; + + return SANE_STATUS_GOOD; +} + +static SANE_Bool +gt68xx_device_get_model (SANE_String name, GT68xx_Model ** model) +{ + GT68xx_USB_Device_Entry *entry; + + for (entry = gt68xx_usb_device_list; entry->model; ++entry) + { + if (strcmp (name, entry->model->name) == 0) + { + *model = entry->model; + return SANE_TRUE; + } + } + return SANE_FALSE; +} + + +SANE_Status +gt68xx_device_activate (GT68xx_Device * dev) +{ + SANE_Status status; + CHECK_DEV_OPEN (dev, "gt68xx_device_activate"); + if (dev->active) + { + DBG (3, "gt68xx_device_activate: device already active\n"); + return SANE_STATUS_INVAL; + } + + if (!gt68xx_device_is_configured (dev)) + { + DBG (3, "gt68xx_device_activate: device is not configured\n"); + return SANE_STATUS_INVAL; + } + + DBG (7, "gt68xx_device_activate: model \"%s\"\n", dev->model->name); + if (dev->model->command_set->activate) + { + status = (*dev->model->command_set->activate) (dev); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_activate: command-set-specific " + "activate failed: %s\n", sane_strstatus (status)); + return status; + } + } + dev->afe = malloc (sizeof (*dev->afe)); + dev->exposure = malloc (sizeof (*dev->exposure)); + if (!dev->afe || !dev->exposure) + return SANE_STATUS_NO_MEM; + memcpy (dev->afe, &dev->model->afe_params, sizeof (*dev->afe)); + memcpy (dev->exposure, &dev->model->exposure, sizeof (*dev->exposure)); + dev->gamma_value = dev->model->default_gamma_value; + dev->active = SANE_TRUE; + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_deactivate (GT68xx_Device * dev) +{ + SANE_Status status = SANE_STATUS_GOOD; + CHECK_DEV_ACTIVE (dev, "gt68xx_device_deactivate"); + if (dev->read_active) + gt68xx_device_read_finish (dev); + if (dev->model->command_set->deactivate) + { + status = (*dev->model->command_set->deactivate) (dev); + if (status != SANE_STATUS_GOOD) + { + DBG (3, + "gt68xx_device_deactivate: command set-specific deactivate failed: %s\n", + sane_strstatus (status)); + /* proceed with deactivate anyway */ + } + } + if (dev->afe) + free (dev->afe); + dev->afe = 0; + if (dev->exposure) + free (dev->exposure); + dev->exposure = 0; + dev->active = SANE_FALSE; + return status; +} + +SANE_Status +gt68xx_device_memory_write (GT68xx_Device * dev, + SANE_Word addr, SANE_Word size, SANE_Byte * data) +{ + SANE_Status status; + DBG (8, + "gt68xx_device_memory_write: dev=%p, addr=0x%x, size=0x%x, data=%p\n", + (void *) dev, addr, size, data); + CHECK_DEV_ACTIVE (dev, "gt68xx_device_memory_write"); + status = + sanei_usb_control_msg (dev->fd, 0x40, + dev->model->command_set->request, + dev->model->command_set->memory_write_value, + addr, size, data); + if (status != SANE_STATUS_GOOD) + { + DBG (3, + "gt68xx_device_memory_write: sanei_usb_control_msg failed: %s\n", + sane_strstatus (status)); + } + return status; +} + +SANE_Status +gt68xx_device_memory_read (GT68xx_Device * dev, + SANE_Word addr, SANE_Word size, SANE_Byte * data) +{ + SANE_Status status; + DBG (8, + "gt68xx_device_memory_read: dev=%p, addr=0x%x, size=0x%x, data=%p\n", + (void *) dev, addr, size, data); + CHECK_DEV_ACTIVE (dev, "gt68xx_device_memory_read"); + status = + sanei_usb_control_msg (dev->fd, 0xc0, + dev->model->command_set->request, + dev->model->command_set->memory_read_value, + addr, size, data); + if (status != SANE_STATUS_GOOD) + { + DBG (3, + "gt68xx_device_memory_read: sanei_usb_control_msg failed: %s\n", + sane_strstatus (status)); + } + + return status; +} + +static SANE_Status +gt68xx_device_generic_req (GT68xx_Device * dev, + SANE_Byte request_type, SANE_Word request, + SANE_Word cmd_value, SANE_Word cmd_index, + SANE_Word res_value, SANE_Word res_index, + GT68xx_Packet cmd, GT68xx_Packet res, + size_t res_size) +{ + SANE_Status status; + DBG (7, "gt68xx_device_generic_req: command=0x%02x\n", cmd[0]); + DUMP_REQ (">>", cmd); + CHECK_DEV_ACTIVE (dev, "gt68xx_device_generic_req"); + status = sanei_usb_control_msg (dev->fd, + request_type, request, cmd_value, + cmd_index, GT68XX_PACKET_SIZE, cmd); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_generic_req: writing command failed: %s\n", + sane_strstatus (status)); + return status; + } + + memset (res, 0, sizeof (GT68xx_Packet)); + status = sanei_usb_control_msg (dev->fd, + request_type | 0x80, request, + res_value, res_index, res_size, res); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_generic_req: reading response failed: %s\n", + sane_strstatus (status)); + return status; + } + + DUMP_REQ ("<<", res); + return status; +} + +SANE_Status +gt68xx_device_req (GT68xx_Device * dev, GT68xx_Packet cmd, GT68xx_Packet res) +{ + GT68xx_Command_Set *command_set = dev->model->command_set; + return gt68xx_device_generic_req (dev, + command_set->request_type, + command_set->request, + command_set->send_cmd_value, + command_set->send_cmd_index, + command_set->recv_res_value, + command_set->recv_res_index, cmd, + res, GT68XX_PACKET_SIZE); +} + +SANE_Status +gt68xx_device_small_req (GT68xx_Device * dev, GT68xx_Packet cmd, + GT68xx_Packet res) +{ + GT68xx_Command_Set *command_set = dev->model->command_set; + GT68xx_Packet fixed_cmd; + int i; + for (i = 0; i < 8; ++i) + memcpy (fixed_cmd + i * 8, cmd, 8); + return gt68xx_device_generic_req (dev, + command_set->request_type, + command_set->request, + command_set->send_small_cmd_value, + command_set->send_small_cmd_index, + command_set->recv_small_res_value, + command_set->recv_small_res_index, + fixed_cmd, res, 0x08); +} + + +SANE_Status +gt68xx_device_download_firmware (GT68xx_Device * dev, + SANE_Byte * data, SANE_Word size) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_download_firmware"); + if (dev->model->command_set->download_firmware) + return (*dev->model->command_set->download_firmware) (dev, data, size); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_get_power_status (GT68xx_Device * dev, SANE_Bool * power_ok) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_get_power_status"); + if (dev->model->command_set->get_power_status) + return (*dev->model->command_set->get_power_status) (dev, power_ok); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_get_ta_status (GT68xx_Device * dev, SANE_Bool * ta_attached) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_get_ta_status"); + if (dev->model->command_set->get_ta_status) + return (*dev->model->command_set->get_ta_status) (dev, ta_attached); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_lamp_control (GT68xx_Device * dev, SANE_Bool fb_lamp, + SANE_Bool ta_lamp) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_lamp_control"); + if (dev->model->command_set->lamp_control) + return (*dev->model->command_set->lamp_control) (dev, fb_lamp, ta_lamp); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_is_moving (GT68xx_Device * dev, SANE_Bool * moving) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_is_moving"); + if (dev->model->command_set->is_moving) + return (*dev->model->command_set->is_moving) (dev, moving); + else + return SANE_STATUS_UNSUPPORTED; +} + +/* currently not used */ +#if 0 +static SANE_Status +gt68xx_device_move_relative (GT68xx_Device * dev, SANE_Int distance) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_move_relative"); + if (dev->model->command_set->move_relative) + return (*dev->model->command_set->move_relative) (dev, distance); + else + return SANE_STATUS_UNSUPPORTED; +} +#endif + +SANE_Status +gt68xx_device_carriage_home (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_carriage_home"); + if (dev->model->command_set->carriage_home) + return (*dev->model->command_set->carriage_home) (dev); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_paperfeed (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_paperfeed"); + if (dev->model->command_set->paperfeed) + return (*dev->model->command_set->paperfeed) (dev); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_start_scan (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_start_scan"); + if (dev->model->command_set->start_scan) + return (*dev->model->command_set->start_scan) (dev); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_read_scanned_data (GT68xx_Device * dev, SANE_Bool * ready) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read_scanned_data"); + if (dev->model->command_set->read_scanned_data) + return (*dev->model->command_set->read_scanned_data) (dev, ready); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_setup_scan (GT68xx_Device * dev, + GT68xx_Scan_Request * request, + GT68xx_Scan_Action action, + GT68xx_Scan_Parameters * params) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_setup_scan"); + if (dev->model->command_set->setup_scan) + return (*dev->model->command_set->setup_scan) (dev, request, action, + params); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_set_afe (GT68xx_Device * dev, GT68xx_AFE_Parameters * params) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_set_afe"); + if (dev->model->command_set->set_afe) + return (*dev->model->command_set->set_afe) (dev, params); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_set_exposure_time (GT68xx_Device * dev, + GT68xx_Exposure_Parameters * params) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_set_exposure_time"); + if (dev->model->command_set->set_exposure_time) + return (*dev->model->command_set->set_exposure_time) (dev, params); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_stop_scan (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_stop_scan"); + if (dev->model->command_set->stop_scan) + return (*dev->model->command_set->stop_scan) (dev); + else + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +gt68xx_device_read_raw (GT68xx_Device * dev, SANE_Byte * buffer, + size_t * size) +{ + SANE_Status status; + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read_raw"); + DBG (7, "gt68xx_device_read_raw: enter: size=%lu\n", (unsigned long) *size); + status = sanei_usb_read_bulk (dev->fd, buffer, size); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_read_raw: bulk read failed: %s\n", + sane_strstatus (status)); + return status; + } + DBG (7, "gt68xx_device_read_raw: leave: size=%lu\n", (unsigned long) *size); + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_set_read_buffer_size (GT68xx_Device * dev, size_t buffer_size) +{ + CHECK_DEV_NOT_NULL (dev, "gt68xx_device_set_read_buffer_size"); + if (dev->read_active) + { + DBG (3, "gt68xx_device_set_read_buffer_size: BUG: read already " + "active\n"); + return SANE_STATUS_INVAL; + } + + buffer_size = (buffer_size + 63UL) & ~63UL; + if (buffer_size > 0) + { + dev->requested_buffer_size = buffer_size; + return SANE_STATUS_GOOD; + } + + DBG (3, "gt68xx_device_set_read_buffer_size: bad buffer size\n"); + return SANE_STATUS_INVAL; +} + +SANE_Status +gt68xx_device_read_prepare (GT68xx_Device * dev, + size_t expected_count, SANE_Bool final_scan) +{ + size_t buffer_size; + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read_prepare"); + if (dev->read_active) + { + DBG (3, "gt68xx_device_read_prepare: read already active\n"); + return SANE_STATUS_INVAL; + } + DBG (5, "gt68xx_device_read_prepare: total size: %lu bytes\n", + (unsigned long) expected_count); + buffer_size = dev->requested_buffer_size; + DBG (5, "gt68xx_device_read_prepare: requested buffer size: %lu\n", + (unsigned long) buffer_size); + if (buffer_size > expected_count) + { + buffer_size = (expected_count + 63UL) & ~63UL; + } + DBG (5, "gt68xx_device_read_prepare: real size: %lu\n", + (unsigned long) buffer_size); + dev->read_buffer_size = buffer_size; + dev->read_buffer = (SANE_Byte *) malloc (buffer_size); + if (!dev->read_buffer) + { + DBG (3, + "gt68xx_device_read_prepare: not enough memory for the read buffer (%lu bytes)\n", + (unsigned long) buffer_size); + return SANE_STATUS_NO_MEM; + } + + dev->read_active = SANE_TRUE; + dev->final_scan = final_scan; + dev->read_pos = dev->read_bytes_in_buffer = 0; + dev->read_bytes_left = expected_count; + return SANE_STATUS_GOOD; +} + +#ifdef USE_FORK + +static SANE_Status +gt68xx_reader_process (GT68xx_Device * dev) +{ + SANE_Status status = SANE_STATUS_GOOD; + SANE_Int buffer_id; + SANE_Byte *buffer_addr; + size_t size; + SANE_Int line = 0; + size_t read_bytes_left = dev->read_bytes_left; + shm_channel_writer_init (dev->shm_channel); + while (read_bytes_left > 0) + { + status = shm_channel_writer_get_buffer (dev->shm_channel, + &buffer_id, &buffer_addr); + if (status != SANE_STATUS_GOOD) + break; + DBG (9, "gt68xx_reader_process: buffer %d: get\n", buffer_id); + size = dev->read_buffer_size; + DBG (9, "gt68xx_reader_process: buffer %d: trying to read %lu bytes " + "(%lu bytes left, line %d)\n", buffer_id, (unsigned long) size, + (unsigned long) read_bytes_left, line); + status = gt68xx_device_read_raw (dev, buffer_addr, &size); + if (status != SANE_STATUS_GOOD) + break; + DBG (9, + "gt68xx_reader_process: buffer %d: read %lu bytes (line %d)\n", + buffer_id, (unsigned long) size, line); + status = + shm_channel_writer_put_buffer (dev->shm_channel, buffer_id, size); + if (status != SANE_STATUS_GOOD) + break; + DBG (9, "gt68xx_reader_process: buffer %d: put\n", buffer_id); + read_bytes_left -= size; + line++; + } + DBG (9, "gt68xx_reader_process: finished, now sleeping\n"); + if (status != SANE_STATUS_GOOD) + return status; + sleep (5 * 60); /* wait until we are killed (or timeout) */ + shm_channel_writer_close (dev->shm_channel); + return status; +} + +static SANE_Status +gt68xx_device_read_start_fork (GT68xx_Device * dev) +{ + SANE_Status status; + int pid; + if (dev->shm_channel) + { + DBG (3, + "gt68xx_device_read_start_fork: BUG: shm_channel already created\n"); + return SANE_STATUS_INVAL; + } + + status = + shm_channel_new (dev->read_buffer_size, SHM_BUFFERS, &dev->shm_channel); + if (status != SANE_STATUS_GOOD) + { + DBG (3, + "gt68xx_device_read_start_fork: cannot create shared memory channel: " + "%s\n", sane_strstatus (status)); + dev->shm_channel = NULL; + return status; + } + + pid = fork (); + if (pid == -1) + { + DBG (3, "gt68xx_device_read_start_fork: cannot fork: %s\n", + strerror (errno)); + shm_channel_free (dev->shm_channel); + dev->shm_channel = NULL; + return SANE_STATUS_NO_MEM; + } + + if (pid == 0) + { + /* Child process */ + status = gt68xx_reader_process (dev); + _exit (status); + } + else + { + /* Parent process */ + dev->reader_pid = pid; + shm_channel_reader_init (dev->shm_channel); + shm_channel_reader_start (dev->shm_channel); + return SANE_STATUS_GOOD; + } +} + +#endif /* USE_FORK */ + + +static SANE_Status +gt68xx_device_read_start (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read_start"); +#ifdef USE_FORK + /* Don't fork a separate process for every calibration scan. */ + if (dev->final_scan) + return gt68xx_device_read_start_fork (dev); +#endif /* USE_FORK */ + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_read (GT68xx_Device * dev, SANE_Byte * buffer, size_t * size) +{ + SANE_Status status; + size_t byte_count = 0; + size_t left_to_read = *size; + size_t transfer_size, block_size, raw_block_size; +#ifdef USE_FORK + SANE_Int buffer_id; + SANE_Byte *buffer_addr; + SANE_Int buffer_bytes; +#endif /* USE_FORK */ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read"); + if (!dev->read_active) + { + DBG (3, "gt68xx_device_read: read not active\n"); + return SANE_STATUS_INVAL; + } + + while (left_to_read > 0) + { + if (dev->read_bytes_in_buffer == 0) + { + block_size = dev->read_buffer_size; + if (block_size > dev->read_bytes_left) + block_size = dev->read_bytes_left; + if (block_size == 0) + break; + raw_block_size = (block_size + 63UL) & ~63UL; + DBG (7, "gt68xx_device_read: trying to read %ld bytes\n", + (long) raw_block_size); +#ifdef USE_FORK + if (dev->shm_channel) + { + status = shm_channel_reader_get_buffer (dev->shm_channel, + &buffer_id, + &buffer_addr, + &buffer_bytes); + if (status == SANE_STATUS_GOOD && buffer_addr != NULL) + { + DBG (9, "gt68xx_device_read: buffer %d: get\n", buffer_id); + memcpy (dev->read_buffer, buffer_addr, buffer_bytes); + shm_channel_reader_put_buffer (dev->shm_channel, buffer_id); + DBG (9, "gt68xx_device_read: buffer %d: put\n", buffer_id); + } + } + else +#endif /* USE_FORK */ + status = gt68xx_device_read_raw (dev, dev->read_buffer, + &raw_block_size); + if (status != SANE_STATUS_GOOD) + { + DBG (3, "gt68xx_device_read: read failed\n"); + return status; + } + dev->read_pos = 0; + dev->read_bytes_in_buffer = block_size; + dev->read_bytes_left -= block_size; + } + + transfer_size = left_to_read; + if (transfer_size > dev->read_bytes_in_buffer) + transfer_size = dev->read_bytes_in_buffer; + if (transfer_size > 0) + { + memcpy (buffer, dev->read_buffer + dev->read_pos, transfer_size); + dev->read_pos += transfer_size; + dev->read_bytes_in_buffer -= transfer_size; + byte_count += transfer_size; + left_to_read -= transfer_size; + buffer += transfer_size; + } + } + + *size = byte_count; + if (byte_count == 0) + return SANE_STATUS_EOF; + else + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_read_finish (GT68xx_Device * dev) +{ + SANE_Status status = SANE_STATUS_GOOD; + CHECK_DEV_ACTIVE (dev, "gt68xx_device_read_finish"); + if (!dev->read_active) + { + DBG (3, "gt68xx_device_read_finish: read not active\n"); + return SANE_STATUS_INVAL; + } + + DBG (7, "gt68xx_device_read_finish: read_bytes_left = %ld\n", + (long) dev->read_bytes_left); +#ifdef USE_FORK + if (dev->reader_pid != 0) + { + int pid_status; + /* usleep (100000); */ + DBG (7, "gt68xx_device_read_finish: trying to kill reader process\n"); + kill (dev->reader_pid, SIGKILL); + waitpid (dev->reader_pid, &pid_status, 0); + if (WIFEXITED (pid_status)) + status = WEXITSTATUS (pid_status); + DBG (7, "gt68xx_device_read_finish: reader process killed\n"); + dev->reader_pid = 0; + } + if (dev->shm_channel) + { + shm_channel_free (dev->shm_channel); + dev->shm_channel = NULL; + } + +#endif /* USE_FORK */ + + free (dev->read_buffer); + dev->read_buffer = NULL; + dev->read_active = SANE_FALSE; + DBG (7, "gt68xx_device_read_finish: exit (%s)\n", sane_strstatus (status)); + return status; +} + +static SANE_Status +gt68xx_device_check_result (GT68xx_Packet res, SANE_Byte command) +{ + if (res[0] != 0) + { + DBG (1, "gt68xx_device_check_result: result was %2X %2X " + "(expected: %2X %2X)\n", res[0], res[1], 0, command); + return SANE_STATUS_IO_ERROR; + } + /* The Gt681xfw.usb firmware doesn't return the command byte + in the second byte, so we can't rely on that test */ + if (res[1] != command) + DBG (5, "gt68xx_device_check_result: warning: result was %2X %2X " + "(expected: %2X %2X)\n", res[0], res[1], 0, command); + return SANE_STATUS_GOOD; +} + +SANE_Status +gt68xx_device_get_id (GT68xx_Device * dev) +{ + CHECK_DEV_ACTIVE (dev, "gt68xx_device_get_id"); + if (dev->model->command_set->get_id) + return (*dev->model->command_set->get_id) (dev); + else + return SANE_STATUS_UNSUPPORTED; +} + +static void +gt68xx_device_fix_descriptor (GT68xx_Device * dev) +{ + SANE_Byte data[8]; + sanei_usb_control_msg (dev->fd, 0x80, 0x06, 0x01 << 8, 0, 8, data); +} + + +/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */ |