Logo Search packages:      
Sourcecode: sane-backends version File versions

mustek_usb_low.c

/* sane - Scanner Access Now Easy.

   Copyright (C) 2000 Mustek.
   Originally maintained by Tom Wang <tom.wang@mustek.com.tw>

   Copyright (C) 2001 - 2004 by Henning Meier-Geinitz.

   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.

   This file implements a SANE backend for Mustek 1200UB and similar 
   USB flatbed scanners.  */

#include <unistd.h>

#include "../include/sane/sane.h"
#include "../include/sane/sanei_usb.h"
#include "mustek_usb_low.h"


SANE_Status
usb_low_init (ma1017 ** chip_address)
{
  SANE_Int i;
  ma1017 *chip;

  DBG (7, "usb_low_init: start\n");
  if (!chip_address)
    return SANE_STATUS_INVAL;

  chip = (ma1017 *) malloc (sizeof (ma1017));

  if (!chip)
    {
      DBG (3, "usb_low_init: couldn't malloc %ld bytes for chip\n",
         (long int) sizeof (ma1017));
      *chip_address = 0;
      return SANE_STATUS_NO_MEM;
    }
  *chip_address = chip;

  /* io */
  chip->is_rowing = SANE_FALSE;
  chip->is_opened = SANE_FALSE;
  chip->fd = -1;

  /* Construction/Destruction */
  chip->is_opened = SANE_FALSE;
  chip->is_rowing = SANE_FALSE;

  /* A2 */
  chip->append = 0x00;
  chip->test_sram = 0x00;
  chip->fix_pattern = 0x00;
  /* A4 */
  chip->select = 0x00;
  chip->frontend = 0x00;
  /* A6 */
  chip->rgb_sel_pin = 0x02;
  chip->asic_io_pins = 0x9c;
  /* A7 */
  chip->timing = 0xe8;
  chip->sram_bank = 0x02;
  /* A8 */
  chip->dummy_msb = 0x00;
  chip->ccd_width_msb = 0x00;
  chip->cmt_table_length = 0x00;
  /* A9 */
  chip->cmt_second_pos = 0x00;
  /* A10 + A8ID5 */
  chip->ccd_width = 0x0c80;
  /* A11 + A8ID6 */
  chip->dummy = 0x0020;
  /* A12 + A13 */
  chip->byte_width = 0x09f6;
  /* A14 + A30W */
  chip->loop_count = 0x0db5;
  /* A15 */
  chip->motor_enable = 0x00;
  chip->motor_movement = 0x60;
  chip->motor_direction = 0x10;
  chip->motor_signal = 0x00;
  chip->motor_home = 0x00;
  /* A16 */
  chip->pixel_depth = 0x00;
  chip->image_invert = 0x00;
  chip->optical_600 = 0x00;
  chip->sample_way = 0x06;
  /* A17 + A18 + A19 */
  chip->red_ref = 0xff;
  chip->green_ref = 0xff;
  chip->blue_ref = 0xff;
  /* A20 + A21 + A22 */
  chip->red_pd = 0x00;
  chip->green_pd = 0x00;
  chip->blue_pd = 0x00;
  /* A23 */
  chip->a23 = 0x80;
  /* A24 */
  chip->fy1_delay = 0x00;
  chip->special_ad = 0x00;
  /* A27 */
  chip->sclk = 0x00;
  chip->sen = 0x00;
  chip->serial_length = 0x10;

  /* Use for Rowing */
  chip->get_row = NULL;

  chip->cmt_table_length_word = 0x00000000;
  chip->cmt_second_pos_word = 0x00000000;
  chip->row_size = 0x00;
  chip->soft_resample = 0x01;
  chip->total_lines = 0x00;
  chip->lines_left = 0x00;
  for (i = 0; i < 32; i++)
    chip->is_transfer_table[i] = SANE_FALSE;
  chip->sensor = ST_CANON600;
  chip->motor = MT_1200;

  chip->total_read_urbs = 0;
  chip->total_write_urbs = 0;
  DBG (7, "usb_low_init: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_exit (ma1017 * chip)
{
  DBG (7, "usb_low_exit: chip = %p\n", (void *) chip);
  if (chip)
    {
      if (chip->fd >= 0 && chip->is_opened)
      usb_low_close (chip);
      DBG (7, "usb_low_exit: freeing chip\n");
      free (chip);
    }
  DBG (5, "usb_low_exit: read %d URBs, wrote %d URBs\n", 
       chip->total_read_urbs, chip->total_write_urbs);
  DBG (7, "usb_low_exit: exit\n");
  return SANE_STATUS_GOOD;
}

/* A0 ~ A1 */
SANE_Status
usb_low_set_cmt_table (ma1017 * chip, SANE_Int index, Channel channel,
                   SANE_Bool is_move_motor, SANE_Bool is_transfer)
{
  SANE_Byte pattern = ((SANE_Byte) index) << 4;
  SANE_Byte reg_no = 0;
  SANE_Status status;

  DBG (7, "usb_low_set_cmt_table: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_cmt_table: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_cmt_table: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if ((unsigned int) index > 31)
    {
      DBG (7, "usb_low_set_cmt_table: CMT index (%d) exceed 31", index);
      return SANE_STATUS_INVAL;
    }

  switch (channel)
    {
    case CH_RED:
      pattern |= 0x04;
      break;
    case CH_GREEN:
      pattern |= 0x08;
      break;
    case CH_BLUE:
      pattern |= 0x0c;
      break;
    default:
      break;
    }
  if (is_move_motor)
    pattern |= 0x02;
  if (is_transfer)
    pattern |= 0x01;
  if (index > 15)
    reg_no++;

  RIE (usb_low_write_reg (chip, reg_no, pattern));

  chip->is_transfer_table[index] = is_transfer;

  DBG (7, "usb_low_set_cmt_table: exit\n");

  return SANE_STATUS_GOOD;
}

/* A2 */
SANE_Status
usb_low_get_a2 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a2: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a2: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a2: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  RIE (usb_low_read_reg (chip, 2, &pattern));

  chip->append = pattern & 0x10;
  chip->test_sram = pattern & 0x20;
  chip->fix_pattern = pattern & 0x80;
  if (value)
    *value = pattern;
  DBG (7, "usb_low_get_a2: exit, value =%d\n", pattern);
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_start_cmt_table (ma1017 * chip)
{
  SANE_Byte data_field[2];
  SANE_Status status;
  size_t n;

  DBG (7, "usb_low_start_cmt_table: start\n");

  data_field[0] = 0x02 | chip->append | chip->test_sram | chip->fix_pattern;
  data_field[1] = 2;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_start_cmt_table: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (7, "usb_low_start_cmt_table: Already Rowing\n");
      return SANE_STATUS_INVAL;
    }

  data_field[1] |= 0x60;
  n = 2;
  status = sanei_usb_write_bulk (chip->fd, data_field, &n);
  if (status != SANE_STATUS_GOOD || n != 2)
    {
      DBG (3, "usb_low_start_cmt_table: can't write, wanted 2 bytes, "
         "wrote %lu bytes\n", (unsigned long int) n);
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_write_urbs++;
  chip->is_rowing = SANE_TRUE;
  DBG (7, "usb_low_start_cmt_table: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_stop_cmt_table (ma1017 * chip)
{
  SANE_Byte data_field[2];
  SANE_Byte read_byte;
  size_t n;
  SANE_Status status;

  DBG (7, "usb_low_stop_cmt_table: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_stop_cmt_table: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (!chip->is_rowing)
    {
      DBG (7, "usb_low_stop_cmt_table: Not Rowing yet\n");
      return SANE_STATUS_INVAL;
    }

  data_field[0] = 0x01 | chip->append | chip->test_sram | chip->fix_pattern;
  data_field[1] = 2;
  data_field[1] |= 0x80;
  n = 2;
  status = sanei_usb_write_bulk (chip->fd, data_field, &n);
  if (status != SANE_STATUS_GOOD || n != 2)
    {
      DBG (3, "usb_low_stop_cmt_table: couldn't write, wanted 2 bytes, wrote "
         "%lu bytes\n", (unsigned long int) n);
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_write_urbs++;
  n = 1;
  status = sanei_usb_read_bulk (chip->fd, &read_byte, &n);
  if (status != SANE_STATUS_GOOD || n != 1)
    {
      DBG (3, "usb_low_stop_cmt_table: couldn't read, wanted 1 byte, got %lu "
         "bytes\n", (unsigned long int) n);
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_read_urbs++;
  chip->is_rowing = SANE_FALSE;

  DBG (7, "usb_low_stop_cmt_table: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_test_sram_mode (ma1017 * chip, SANE_Bool is_test)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_test_sram_mode: start\n");

  data = chip->append | chip->test_sram | chip->fix_pattern;
  reg_no = 2;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_test_sram_mode: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_test_sram_mode: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  if (is_test)
    chip->test_sram = 0x20;
  else
    chip->test_sram = 0x00;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_test_sram_mode: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_fix_pattern (ma1017 * chip, SANE_Bool is_fix)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_fix_pattern: start\n");

  data = chip->append | chip->test_sram | chip->fix_pattern;
  reg_no = 2;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_fix_pattern: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_fix_pattern: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  if (is_fix)
    chip->fix_pattern = 0x80;
  else
    chip->fix_pattern = 0x00;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_fix_pattern: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_adjust_timing (ma1017 * chip, SANE_Byte data)
{
  SANE_Status status;
  SANE_Byte reg_no;

  DBG (7, "usb_low_adjust_timing: start\n");

  reg_no = 3;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_adjust_timing: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_adjust_timing: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_adjust_timing: exit\n");

  return SANE_STATUS_GOOD;
}

/* A4 */
SANE_Status
usb_low_get_a4 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Status status;
  SANE_Byte pattern;

  DBG (7, "usb_low_get_a4: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a4: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a4: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 4, &pattern));

  chip->select = pattern & 0xfe;
  chip->frontend = pattern & 0x01;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a4: exit, value=%d\n", pattern);

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_select_timing (ma1017 * chip, SANE_Byte data)
{
  SANE_Status status;
  SANE_Byte reg_no;

  DBG (7, "usb_low_select_timing: start\n");

  reg_no = 4;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_select_timing: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_select_timing: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->select = data & 0xfe;
  chip->frontend = data & 0x01;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_select_timing: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_turn_frontend_mode (ma1017 * chip, SANE_Bool is_on)
{
  SANE_Status status;
  SANE_Byte data, reg_no;

  DBG (7, "usb_low_turn_frontend_mode: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_turn_frontend_mode: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_turn_frontend_mode: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  if (is_on)
    chip->frontend = 0x01;
  else
    chip->frontend = 0x00;

  data = chip->select | chip->frontend;
  reg_no = 4;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_turn_frontend_mode: exit\n");
  return SANE_STATUS_GOOD;
}

/* A6 */
SANE_Status
usb_low_get_a6 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a6: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a6: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a6: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  RIE (usb_low_read_reg (chip, 6, &pattern));

  chip->asic_io_pins = pattern & 0xdc;
  chip->rgb_sel_pin = pattern & 0x03;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a6: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_asic_io_pins (ma1017 * chip, SANE_Byte data)
{
  SANE_Status status;
  SANE_Byte reg_no;

  DBG (7, "usb_low_set_asic_io_pins: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_asic_io_pins: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_asic_io_pins: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->asic_io_pins = data & 0xdc;

  data = chip->asic_io_pins | chip->rgb_sel_pin;
  reg_no = 6;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_asic_io_pins: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_rgb_sel_pins (ma1017 * chip, SANE_Byte data)
{
  SANE_Status status;
  SANE_Byte reg_no;

  DBG (7, "usb_low_set_rgb_sel_pins: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_rgb_sel_pins: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_rgb_sel_pins: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  chip->rgb_sel_pin = data & 0x03;
  data = chip->asic_io_pins | chip->rgb_sel_pin;
  reg_no = 6;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_rgb_sel_pins: exit\n");
  return SANE_STATUS_GOOD;    /* was false? */
}

/* A7 */
SANE_Status
usb_low_get_a7 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a7: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a7: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a7: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  RIE (usb_low_read_reg (chip, 7, &pattern));

  if (value)
    *value = pattern;

  chip->timing = pattern & 0xfc;
  chip->sram_bank = pattern & 0x03;

  DBG (7, "usb_low_get_a7: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_timing (ma1017 * chip, SANE_Byte data)
{
  SANE_Status status;
  SANE_Byte reg_no;

  DBG (7, "usb_low_set_timing: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_timing: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_timing: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->timing = data & 0xfc;
  data = chip->timing | chip->sram_bank;
  reg_no = 7;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_timing: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_sram_bank (ma1017 * chip, Banksize banksize)
{
  SANE_Status status;
  SANE_Byte data, reg_no;

  DBG (7, "usb_low_set_sram_bank: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_sram_bank: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_sram_bank: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  switch (banksize)
    {
    case BS_4K:
      chip->sram_bank = 0x00;
      break;
    case BS_8K:
      chip->sram_bank = 0x01;
      break;
    case BS_16K:
      chip->sram_bank = 0x02;
      break;
    default:
      DBG (3, "usb_low_set_sram_bank: bsBankSize error\n");
      return SANE_STATUS_INVAL;
      break;
    }
  data = chip->timing | chip->sram_bank;
  reg_no = 7;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_sram_bank: exit\n");
  return SANE_STATUS_GOOD;
}

/* A8 */
SANE_Status
usb_low_get_a8 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a8: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a8: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a8: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 8, &pattern));

  chip->dummy_msb = pattern & 0x40;
  chip->ccd_width_msb = pattern & 0x20;
  chip->cmt_table_length = pattern & 0x1f;
  chip->ccd_width =
    ((chip->ccd_width / 32) & 0x00ff) * 32 +
    ((chip->ccd_width_msb == 0) ? 0 : 0x0100 * 32);
  chip->dummy =
    ((chip->dummy / 32) & 0x00ff) * 32 +
    ((chip->dummy_msb == 0) ? 0 : 0x0100 * 32);

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a8: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_cmt_table_length (ma1017 * chip, SANE_Byte table_length)
{
  SANE_Status status;
  SANE_Byte data, reg_no;

  DBG (7, "usb_low_set_cmt_table_length: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_cmt_table_length: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_cmt_table_length: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if (table_length > 32)
    {
      DBG (3, "usb_low_set_cmt_table_length: length %d exceeds 32\n",
         (int) table_length);
      return SANE_STATUS_INVAL;
    }
  if (table_length == 0)
    {
      DBG (3, "usb_low_set_cmt_table_length: length is 0\n");
      return SANE_STATUS_INVAL;
    }

  chip->cmt_table_length = table_length - 1;
  chip->cmt_table_length_word = (SANE_Word) table_length;
  data = chip->cmt_table_length | chip->ccd_width_msb | chip->dummy_msb;
  reg_no = 8;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_cmt_table_length: exit\n");
  return SANE_STATUS_GOOD;
}

/* A9 */
SANE_Status
usb_low_get_a9 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a9: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a9: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a9: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  RIE (usb_low_read_reg (chip, 9, &pattern));

  chip->cmt_second_pos = pattern & 0x1f;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a9: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_cmt_second_position (ma1017 * chip, SANE_Byte position)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_cmt_second_position: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_cmt_second_position: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_cmt_second_position: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if (position > 31)
    {
      DBG (3, "usb_low_set_cmt_second_position: length: %d exceeds 31\n",
         (int) position);
      return SANE_STATUS_INVAL;
    }

  chip->cmt_second_pos = position;
  chip->cmt_second_pos_word = (SANE_Word) (position);
  data = chip->cmt_second_pos;
  reg_no = 9;

  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_cmt_second_position: exit\n");

  return SANE_STATUS_GOOD;
}

/* A10 + A8ID5 */
SANE_Status
usb_low_get_a10 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a10: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a10: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a10: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 10, &pattern));

  chip->ccd_width =
    ((SANE_Word) (pattern)) * 32 +
    ((chip->ccd_width_msb == 0) ? 0 : 0x0100 * 32);

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a10: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_ccd_width (ma1017 * chip, SANE_Word ccd_width)
{
  SANE_Status status;
  SANE_Byte data, reg_no;

  DBG (7, "usb_low_set_ccd_width: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_ccd_width: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_ccd_width: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if (ccd_width / 32 > 0x01ff)
    {
      DBG (3, "usb_low_set_ccd_width: width %d too high\n", (int) ccd_width);
      return SANE_STATUS_INVAL;
    }

  chip->ccd_width = ccd_width;
  ccd_width /= 32;
  if (HIBYTE (ccd_width) == 0x01)
    chip->ccd_width_msb = 0x20;
  else
    chip->ccd_width_msb = 0x00;

  data = chip->cmt_table_length | chip->ccd_width_msb | chip->dummy_msb;
  reg_no = 8;
  RIE (usb_low_write_reg (chip, reg_no, data));

  data = LOBYTE (ccd_width);
  reg_no = 10;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_ccd_width: exit\n");
  return SANE_STATUS_GOOD;
}

/* A11 + A8ID6 */
SANE_Status
usb_low_get_a11 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a11: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a11: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a11: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 11, &pattern));

  chip->dummy =
    ((SANE_Word) (pattern)) * 32 + ((chip->dummy_msb == 0) ? 0 : 0x0100 * 32);

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a11: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_dummy (ma1017 * chip, SANE_Word dummy)
{
  SANE_Status status;
  SANE_Byte data, reg_no;

  DBG (7, "usb_low_set_dummy: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_dummy: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_dummy: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if (dummy / 32 > 0x01ff)
    {
      DBG (7, "usb_low_set_dummy: width %d exceeded\n", (int) dummy);
      return SANE_STATUS_INVAL;
    }

  chip->dummy = dummy;
  dummy /= 32;
  dummy++;
  if (HIBYTE (dummy) == 0x01)
    chip->dummy_msb = 0x40;
  else
    chip->dummy_msb = 0x00;
  data = chip->cmt_table_length | chip->ccd_width_msb | chip->dummy_msb;
  reg_no = 8;
  RIE (usb_low_write_reg (chip, reg_no, data));

  data = LOBYTE (dummy);
  reg_no = 11;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_dummy: exit\n");
  return SANE_STATUS_GOOD;
}

/* A12 + A13 */
SANE_Status
usb_low_get_a12 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a12: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a12: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a12: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 12, &pattern));

  chip->byte_width = (chip->byte_width & 0x3f00) + ((SANE_Word) pattern);
  chip->soft_resample = (chip->soft_resample == 0) ? 1 : chip->soft_resample;
  chip->get_row =
    (chip->soft_resample == 1)
    ? &usb_low_get_row_direct : &usb_low_get_row_resample;
  chip->row_size = chip->byte_width / chip->soft_resample;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a12: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_a13 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a13: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a13: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a13: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 13, &pattern));

  chip->byte_width =
    (chip->byte_width & 0x00ff) + (((SANE_Word) (pattern & 0x3f)) << 8);
  chip->soft_resample = (chip->soft_resample == 0) ? 1 : chip->soft_resample;
  chip->get_row =
    (chip->soft_resample ==
     1) ? &usb_low_get_row_direct : &usb_low_get_row_resample;
  chip->row_size = chip->byte_width / chip->soft_resample;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a13: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_image_byte_width (ma1017 * chip, SANE_Word row_size)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_image_byte_width: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_image_byte_width: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_image_byte_width: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->row_size = row_size;
  chip->soft_resample = (chip->soft_resample == 0) ? 1 : chip->soft_resample;
  chip->get_row = (chip->soft_resample == 1) ? &usb_low_get_row_direct
    : &usb_low_get_row_resample;
  chip->byte_width = chip->row_size * chip->soft_resample;
  if (chip->byte_width > 0x3fff)
    {
      DBG (3, "usb_low_set_image_byte_width: width %d exceeded\n",
         (int) chip->byte_width);
      return SANE_STATUS_INVAL;
    }

  data = LOBYTE (chip->byte_width);
  reg_no = 12;
  RIE (usb_low_write_reg (chip, reg_no, data));

  data = HIBYTE (chip->byte_width);
  reg_no = 13;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_image_byte_width: exit\n");

  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_soft_resample (ma1017 * chip, SANE_Word soft_resample)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_soft_resample: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_soft_resample: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_soft_resample: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  if (soft_resample == 0x00)
    {
      DBG (3, "usb_low_set_soft_resample: soft_resample==0\n");
      return SANE_STATUS_INVAL;
    }

  chip->soft_resample = soft_resample;
  chip->get_row = (chip->soft_resample == 1) ? &usb_low_get_row_direct
    : &usb_low_get_row_resample;
  chip->byte_width = chip->row_size * chip->soft_resample;
  if (chip->byte_width > 0x3fff)
    {
      DBG (3, "usb_low_set_soft_resample: width %d exceeded",
         (int) chip->byte_width);
      return SANE_STATUS_INVAL;
    }

  data = LOBYTE (chip->byte_width);
  reg_no = 12;
  RIE (usb_low_write_reg (chip, reg_no, data));

  data = HIBYTE (chip->byte_width);
  reg_no = 13;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_soft_resample: exit\n");
  return SANE_STATUS_GOOD;
}

/* A14 + A30W */
SANE_Status
usb_low_set_cmt_loop_count (ma1017 * chip, SANE_Word loop_count)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_cmt_loop_count: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_cmt_loop_count: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_cmt_loop_count: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->loop_count = loop_count;

  data = LOBYTE (loop_count);
  reg_no = 14;
  RIE (usb_low_write_reg (chip, reg_no, data));

  data = HIBYTE (loop_count);
  reg_no = 30;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_cmt_loop_count: exit\n");
  return SANE_STATUS_GOOD;
}

/* A15 */
SANE_Status
usb_low_get_a15 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a15: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a15: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a15: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 15, &pattern));

  chip->motor_enable = pattern & 0x80;
  chip->motor_movement = pattern & 0x68;
  chip->motor_direction = pattern & 10;
  chip->motor_signal = pattern & 0x06;
  chip->motor_home = pattern & 0x01;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a15: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_enable_motor (ma1017 * chip, SANE_Bool is_enable)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_enable_motor: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_enable_motor: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_enable_motor: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->motor_enable = 0x00;
  if (is_enable)
    chip->motor_enable |= 0x80;
  data = chip->motor_enable | chip->motor_movement
    | chip->motor_direction | chip->motor_signal | chip->motor_home;
  reg_no = 15;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_enable_motor: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_motor_movement (ma1017 * chip, SANE_Bool is_full_step,
                      SANE_Bool is_double_phase, SANE_Bool is_two_step)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_motor_movement: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_motor_movement: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_motor_movement: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->motor_movement = 0x00;
  if (is_full_step)
    chip->motor_movement |= 0x40;
  if (is_double_phase)
    chip->motor_movement |= 0x20;
  if (is_two_step)
    chip->motor_movement |= 0x08;
  data = chip->motor_enable | chip->motor_movement
    | chip->motor_direction | chip->motor_signal | chip->motor_home;
  reg_no = 15;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_motor_movement:  exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_motor_direction (ma1017 * chip, SANE_Bool is_backward)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_motor_direction: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_motor_direction: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_motor_direction: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->motor_direction = 0x00;
  if (is_backward)
    chip->motor_direction |= 0x10;
  data = chip->motor_enable | chip->motor_movement
    | chip->motor_direction | chip->motor_signal | chip->motor_home;
  reg_no = 15;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_motor_direction: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_motor_signal (ma1017 * chip, SANE_Byte signal)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_motor_signal: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_motor_signal: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_motor_signal: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->motor_signal = signal & 0x06;
  data = chip->motor_enable | chip->motor_movement
    | chip->motor_direction | chip->motor_signal | chip->motor_home;
  reg_no = 15;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_motor_signal: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_move_motor_home (ma1017 * chip, SANE_Bool is_home,
                   SANE_Bool is_backward)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_move_motor_home: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_move_motor_home: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_move_motor_home: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->motor_enable = 0x00;
  chip->motor_direction = 0x00;
  chip->motor_home = 0x00;
  if (is_backward)
    chip->motor_direction |= 0x10;
  if (is_home)
    {
      chip->motor_enable |= 0x80;
      chip->motor_home |= 0x01;
    }
  data = chip->motor_enable | chip->motor_movement
    | chip->motor_direction | chip->motor_signal | chip->motor_home;
  reg_no = 15;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_move_motor_home: exit\n");
  return SANE_STATUS_GOOD;
}

/* A16 */
SANE_Status
usb_low_get_a16 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a16: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a16: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a16: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 16, &pattern));

  chip->pixel_depth = pattern & 0xe0;
  chip->image_invert = pattern & 0x10;
  chip->optical_600 = pattern & 0x08;
  chip->sample_way = pattern & 0x07;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a16: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_image_dpi (ma1017 * chip, SANE_Bool is_optical600,
                   Sampleway sampleway)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_image_dpi: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_image_dpi: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_image_dpi: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->optical_600 = 0x00;
  chip->sample_way = 0x00;
  if (is_optical600)
    chip->optical_600 |= 0x08;
  switch (sampleway)
    {
    case SW_P1P6:
      chip->sample_way = 0x01;
      break;
    case SW_P2P6:
      chip->sample_way = 0x02;
      break;
    case SW_P3P6:
      chip->sample_way = 0x03;
      break;
    case SW_P4P6:
      chip->sample_way = 0x04;
      break;
    case SW_P5P6:
      chip->sample_way = 0x05;
      break;
    case SW_P6P6:
      chip->sample_way = 0x06;
      break;
    default:
      DBG (3, "usb_low_set_image_dpi: swsample_way error\n");
      return SANE_STATUS_INVAL;
      break;
    }
  data = chip->pixel_depth | chip->image_invert | chip->optical_600
    | chip->sample_way;
  reg_no = 16;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_image_dpi: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_pixel_depth (ma1017 * chip, Pixeldepth pixeldepth)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_pixel_depth: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_pixel_depth: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_pixel_depth: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->pixel_depth = 0x00;
  switch (pixeldepth)
    {
    case PD_1BIT:
      chip->pixel_depth = 0x80;
      break;
    case PD_4BIT:
      chip->pixel_depth = 0xc0;
      break;
    case PD_8BIT:
      chip->pixel_depth = 0x00;
      break;
    case PD_12BIT:
      chip->pixel_depth = 0x20;
      break;
    default:
      DBG (3, "usb_low_set_pixel_depth: pdPixelDepth error\n");
      return SANE_STATUS_INVAL;
    }
  data = chip->pixel_depth | chip->image_invert | chip->optical_600
    | chip->sample_way;
  reg_no = 16;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_SetPixelDeepth: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_invert_image (ma1017 * chip, SANE_Bool is_invert)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_invert_image: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_invert_image: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_invert_image: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->image_invert = 0x00;
  if (is_invert)
    chip->image_invert |= 0x10;
  data = chip->pixel_depth | chip->image_invert | chip->optical_600
    | chip->sample_way;
  reg_no = 16;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_invert_image: exit\n");
  return SANE_STATUS_GOOD;
}

/* A17 + A18 + A19 */
SANE_Status
usb_low_get_a17 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a17: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a17: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a17: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 17, &pattern));

  chip->red_ref = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a17: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_a18 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a18: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a18: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a18: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 18, &pattern));

  chip->green_ref = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a18: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_a19 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a19: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a19: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a19:stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 19, &pattern));

  chip->blue_ref = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a19: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_red_ref (ma1017 * chip, SANE_Byte red_ref)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_red_ref: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_red_ref: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_red_ref: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->red_ref = red_ref;
  data = red_ref;
  reg_no = 17;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_red_ref: stop\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_green_ref (ma1017 * chip, SANE_Byte green_ref)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_green_ref: start\n");


  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_green_ref: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_green_ref: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->green_ref = green_ref;

  data = green_ref;
  reg_no = 18;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_green_ref: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_blue_ref (ma1017 * chip, SANE_Byte blue_ref)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_blue_ref: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_blue_ref: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_blue_ref: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->blue_ref = blue_ref;

  data = blue_ref;
  reg_no = 19;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_blue_ref: stop\n");
  return SANE_STATUS_GOOD;
}

/* A20 + A21 + A22 */
SANE_Status
usb_low_get_a20 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a20: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a20: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a20: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }
  RIE (usb_low_read_reg (chip, 20, &pattern));

  chip->red_pd = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a20: stop\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_a21 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a21: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a21: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a21: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 21, &pattern));

  chip->green_pd = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a21: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_a22 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a22: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a22: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a22: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 22, &pattern));

  chip->blue_pd = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a22: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_red_pd (ma1017 * chip, SANE_Byte red_pd)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_red_pd: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_red_pd: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_red_pd: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->red_pd = red_pd;

  data = chip->red_pd;
  reg_no = 20;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_red_pd: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_green_pd (ma1017 * chip, SANE_Byte green_pd)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_green_pd: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_green_pd: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_green_pd: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->green_pd = green_pd;
  data = chip->green_pd;
  reg_no = 21;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_green_pd: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_blue_pd (ma1017 * chip, SANE_Byte blue_pd)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_blue_pd: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_blue_pd: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_blue_pd: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->blue_pd = blue_pd;

  data = chip->blue_pd;
  reg_no = 22;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_blue_pd: exit\n");
  return SANE_STATUS_GOOD;
}

/* A23 */
SANE_Status
usb_low_get_a23 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a23: start\n");
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a23: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a23: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 23, &pattern));

  chip->a23 = pattern;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a23: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_turn_peripheral_power (ma1017 * chip, SANE_Bool is_on)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_turn_peripheral_power: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_turn_peripheral_power: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_turn_peripheral_power: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->a23 &= 0x7f;
  if (is_on)
    chip->a23 |= 0x80;
  data = chip->a23;
  reg_no = 23;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_turn_peripheral_power: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_turn_lamp_power (ma1017 * chip, SANE_Bool is_on)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_turn_lamp_power: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_turn_lamp_power: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_turn_lamp_power: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->a23 &= 0xbf;
  if (is_on)
    chip->a23 |= 0x40;

  data = chip->a23;
  reg_no = 23;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_turn_lamp_power: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_io_3 (ma1017 * chip, SANE_Bool is_high)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_io_3: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_io_3: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_io_3: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->a23 &= 0xf7;
  if (is_high)
    chip->a23 |= 0x08;

  data = chip->a23;
  reg_no = 23;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_io_3: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_led_light_all (ma1017 * chip, SANE_Bool is_light_all)
{
  SANE_Byte data, reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_led_light_all: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_led_light_all: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_led_light_all: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->a23 &= 0xfe;
  if (is_light_all)
    chip->a23 |= 0x01;

  data = chip->a23;
  reg_no = 23;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_led_light_all: exit\n");
  return SANE_STATUS_GOOD;
}

/* A24 */
SANE_Status
usb_low_get_a24 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a24: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a24: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a24: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 24, &pattern));

  chip->fy1_delay = pattern & 0x01;
  chip->special_ad = pattern & 0x02;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a24: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_ad_timing (ma1017 * chip, SANE_Byte data)
{
  SANE_Byte reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_ad_timing: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_ad_timing: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_ad_timing: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  chip->fy1_delay = data & 0x01;
  chip->special_ad = data & 0x02;

  data = chip->special_ad | chip->fy1_delay;
  reg_no = 24;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_ad_timing: exit\n");
  return SANE_STATUS_GOOD;
}

/* A25 + A26 */
SANE_Status
usb_low_set_serial_byte1 (ma1017 * chip, SANE_Byte data)
{
  SANE_Byte reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_serial_byte1: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_serial_byte1: not opened\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_serial_byte1: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  reg_no = 25;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_serial_byte1: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_serial_byte2 (ma1017 * chip, SANE_Byte data)
{
  SANE_Byte reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_serial_byte2: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_serial_byte2: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_serial_byte2: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  reg_no = 26;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_serial_byte2: exit\n");
  return SANE_STATUS_GOOD;
}

/* A27 */
SANE_Status
usb_low_get_a27 (ma1017 * chip, SANE_Byte * value)
{
  SANE_Byte pattern;
  SANE_Status status;

  DBG (7, "usb_low_get_a27: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_a27: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_a27: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 27, &pattern));

  chip->sclk = pattern & 0x80;
  chip->sen = pattern & 0x40;
  chip->serial_length = pattern & 0x1f;

  if (value)
    *value = pattern;

  DBG (7, "usb_low_get_a27: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_set_serial_format (ma1017 * chip, SANE_Byte data)
{
  SANE_Byte reg_no;
  SANE_Status status;

  DBG (7, "usb_low_set_serial_format: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_set_serial_format: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_set_serial_format: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }


  chip->sclk = data & 0x80;
  chip->sen = data & 0x40;
  chip->serial_length = data & 0x1f;

  reg_no = 27;
  RIE (usb_low_write_reg (chip, reg_no, data));

  DBG (7, "usb_low_set_serial_format: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_home_sensor (ma1017 * chip)
{
  SANE_Byte data;
  SANE_Status status;

  DBG (7, "usb_low_get_home_sensor: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_get_home_sensor: not opened yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_get_home_sensor: stop rowing first\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_read_reg (chip, 31, &data));

  DBG (7, "usb_low_get_home_sensor: exit\n");
  if ((data & 0x80) != 0)
    return SANE_STATUS_GOOD;
  else
    return SANE_STATUS_IO_ERROR;
}

/* Special Mode */
SANE_Status
usb_low_start_rowing (ma1017 * chip)
{
  SANE_Word line_of_first = 0;
  SANE_Word line_of_second = 0;
  SANE_Int i;
  SANE_Status status;

  DBG (7, "usb_low_start_rowing: start\n");

  if (chip->loop_count == 0)
    {
      DBG (3, "usb_low_start_rowing loop_count hasn't been set yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->cmt_table_length_word == 0)
    {
      DBG (3, "usb_low_start_rowing: cmt_table_length_word hasn't been set "
         "yet\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->cmt_table_length_word <= chip->cmt_second_pos_word)
    {
      DBG (3, "usb_low_start_rowing: cmt_second_pos_word cannot be larger "
         "than cmt_table_length_word\n");
      return SANE_STATUS_INVAL;
    }

  for (i = 0; i < (int) chip->cmt_second_pos_word; i++)
    {
      if (chip->is_transfer_table[i])
      line_of_first++;
    }
  for (; i < (int) chip->cmt_table_length_word; i++)
    {
      if (chip->is_transfer_table[i])
      {
        line_of_first++;
        line_of_second++;
      }
    }

  chip->total_lines =
    ((SANE_Word) (chip->loop_count - 1)) * line_of_second + line_of_first;
  chip->lines_left = chip->total_lines;

  RIE (usb_low_start_cmt_table (chip));

  DBG (7, "usb_low_start_rowing: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_stop_rowing (ma1017 * chip)
{
  SANE_Status status;

  DBG (7, "usb_low_stop_rowing: start\n");

  RIE (usb_low_stop_cmt_table (chip));

  DBG (7, "usb_low_stop_rowing: exit\n");
  return SANE_STATUS_GOOD;

}

SANE_Status
usb_low_wait_rowing_stop (ma1017 * chip)
{
  SANE_Status status;

  DBG (7, "usb_low_wait_rowing_stop: start\n");
  if (chip->total_lines != 0)
    {
      DBG (3, "usb_low_wait_rowing_stop: total_lines must be 0\n");
      return SANE_STATUS_INVAL;
    }

  RIE (usb_low_wait_rowing (chip));
  chip->is_rowing = SANE_FALSE;
  DBG (7, "usb_low_wait_rowing_stop: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_read_all_registers (ma1017 * chip)
{
  SANE_Status status;

  DBG (7, "usb_low_read_all_registers: start\n");

  RIE (usb_low_get_a2 (chip, 0));
  RIE (usb_low_get_a4 (chip, 0));
  RIE (usb_low_get_a6 (chip, 0));
  RIE (usb_low_get_a7 (chip, 0));
  RIE (usb_low_get_a8 (chip, 0));
  RIE (usb_low_get_a9 (chip, 0));
  RIE (usb_low_get_a10 (chip, 0));
  RIE (usb_low_get_a11 (chip, 0));
  RIE (usb_low_get_a12 (chip, 0));
  RIE (usb_low_get_a13 (chip, 0));
  RIE (usb_low_get_a15 (chip, 0));
  RIE (usb_low_get_a16 (chip, 0));
  RIE (usb_low_get_a17 (chip, 0));
  RIE (usb_low_get_a18 (chip, 0));
  RIE (usb_low_get_a19 (chip, 0));
  RIE (usb_low_get_a20 (chip, 0));
  RIE (usb_low_get_a21 (chip, 0));
  RIE (usb_low_get_a22 (chip, 0));
  RIE (usb_low_get_a23 (chip, 0));
  RIE (usb_low_get_a24 (chip, 0));
  RIE (usb_low_get_a27 (chip, 0));

  return SANE_STATUS_GOOD;
  DBG (7, "usb_low_read_all_registers: exit\n");
}

SANE_Status
usb_low_get_row (ma1017 * chip, SANE_Byte * data, SANE_Word * lines_left)
{
  SANE_Status status;

  DBG (7, "usb_low_get_row: start\n");
  RIE ((*chip->get_row) (chip, data, lines_left));
  DBG (7, "usb_low_get_row: exit\n");
  return SANE_STATUS_GOOD;;
}

SANE_Status
usb_low_get_row_direct (ma1017 * chip, SANE_Byte * data,
                  SANE_Word * lines_left)
{
  SANE_Status status;

  DBG (7, "usb_low_get_row_direct: start\n");
  if (chip->lines_left == 0)
    {
      DBG (3, "usb_low_get_row_direct: lines_left == 0\n");
      return SANE_STATUS_INVAL;
    }

  if (chip->lines_left <= 1)
    {
      RIE (usb_low_read_rows (chip, data, chip->byte_width));
      RIE (usb_low_wait_rowing (chip));

      chip->lines_left = 0x00;
      chip->is_rowing = SANE_FALSE;
      *lines_left = 0;
    }
  else
    {
      RIE (usb_low_read_rows (chip, data, chip->byte_width));
      chip->lines_left--;
      *lines_left = chip->lines_left;
    }
  DBG (7, "usb_low_get_row_direct: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_get_row_resample (ma1017 * chip, SANE_Byte * data,
                    SANE_Word * lines_left)
{
  static SANE_Byte resample_buffer[8 * 1024];
  SANE_Word *pixel_temp;
  SANE_Word i;
  SANE_Word j;
  SANE_Word k;
  SANE_Status status;

  DBG (7, "usb_low_get_row_resample: start\n");

  if (chip->lines_left == 0)
    {
      DBG (3, "usb_low_get_row_resample: lines_left == 0\n");
      return SANE_STATUS_INVAL;
    }

  if (chip->lines_left <= 1)
    {
      RIE (usb_low_read_rows (chip, resample_buffer, chip->byte_width));

      if ((chip->sensor == ST_CANON600) && (chip->pixel_depth == 0x20))
      {
        pixel_temp = (SANE_Word *) malloc (6 * 1024 * sizeof (SANE_Word));
        if (!pixel_temp)
          return SANE_STATUS_NO_MEM;

        j = 0;
        for (i = 0; i < chip->byte_width; i += 3)
          {
            pixel_temp[j] = (SANE_Word) resample_buffer[i];
            pixel_temp[j] |= ((SANE_Word)
                        (resample_buffer[i + 1] & 0xf0)) << 4;
            j++;
            pixel_temp[j] = ((SANE_Word)
                         (resample_buffer[i + 1] & 0x0f)) << 8;
            pixel_temp[j] |= (SANE_Word) resample_buffer[i + 2];
            j++;
          }

        k = 0;
        for (i = 0; i < j; i += chip->soft_resample * 2)
          {
            data[k] = (SANE_Byte) (pixel_temp[i] & 0x00ff);
            k++;
            data[k] = (SANE_Byte) ((pixel_temp[i] & 0x0f00) >> 4);
            data[k] |= (SANE_Byte) ((pixel_temp[i + 2] & 0x0f00) >> 8);
            k++;
            data[k] = (SANE_Byte) (pixel_temp[i + 2] & 0x00ff);
            k++;
          }
        free (pixel_temp);
      }
      else              /* fixme ? */
      {
        for (i = 0; i < chip->byte_width; i += chip->soft_resample)
          *(data++) = resample_buffer[i];
      }
      RIE (usb_low_wait_rowing (chip));

      chip->lines_left = 0x00;
      chip->is_rowing = SANE_FALSE;
      *lines_left = 0;
    }
  else
    {
      RIE (usb_low_read_rows (chip, resample_buffer, chip->byte_width));

      if ((chip->sensor == ST_CANON600) && (chip->pixel_depth == 0x20))
      {
        pixel_temp = (SANE_Word *) malloc (6 * 1024 * sizeof (SANE_Word));
        if (!pixel_temp)
          return SANE_STATUS_NO_MEM;

        j = 0;
        for (i = 0; i < chip->byte_width; i += 3)
          {
            pixel_temp[j] = (SANE_Word) resample_buffer[i];
            pixel_temp[j] |=
            ((SANE_Word) (resample_buffer[i + 1] & 0xf0)) << 4;
            j++;
            pixel_temp[j] =
            ((SANE_Word) (resample_buffer[i + 1] & 0x0f)) << 8;
            pixel_temp[j] |= (SANE_Word) resample_buffer[i + 2];
            j++;
          }

        k = 0;
        for (i = 0; i < j; i += chip->soft_resample * 2)
          {
            data[k] = (SANE_Byte) (pixel_temp[i] & 0x00ff);
            k++;
            data[k] = (SANE_Byte) ((pixel_temp[i] & 0x0f00) >> 4);
            data[k] |= (SANE_Byte) ((pixel_temp[i + 2] & 0x0f00) >> 8);
            k++;
            data[k] = (SANE_Byte) (pixel_temp[i + 2] & 0x00ff);
            k++;
          }
        free (pixel_temp);
      }
      else              /* fixme? */
      {
        for (i = 0; i < chip->byte_width; i += chip->soft_resample)
          *(data++) = resample_buffer[i];
      }
      chip->lines_left--;
      *lines_left = chip->lines_left;
    }
  DBG (7, "usb_low_get_row_resample: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_wait_rowing (ma1017 * chip)
{
  SANE_Byte read_byte;
  size_t n;
  SANE_Status status;

  DBG (7, "usb_low_wait_rowing: start\n");

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_wait_rowing: open first\n");
      return SANE_STATUS_INVAL;
    }
  if (!chip->is_rowing)
    {
      DBG (3, "usb_low_wait_rowing: not rowing\n");
      return SANE_STATUS_INVAL;
    }
  n = 1;
  status = sanei_usb_read_bulk (chip->fd, (SANE_Byte *) & read_byte, &n);
  if (status != SANE_STATUS_GOOD || n != 1)
    {
      DBG (3, "usb_low_wait_rowing: couldn't read: %s\n",
         sane_strstatus (status));
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_read_urbs++;
  chip->is_rowing = SANE_FALSE;
  DBG (7, "usb_low_wait_rowing: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_read_rows (ma1017 * chip, SANE_Byte * data, SANE_Word byte_count)
{
  size_t n, bytes_total;
  SANE_Status status;

  DBG (7, "usb_low_read_rows: start\n");
  if (!(chip->is_opened))
    {
      DBG (3, "usb_low_read_rows: is_opened==SANE_FALSE\n");
      return SANE_STATUS_INVAL;
    }
  if (!(chip->is_rowing))
    {
      DBG (3, "usb_low_read_rows: is_rowing==SANE_FALSE\n");
      return SANE_STATUS_INVAL;
    }

  n = MIN (byte_count, chip->max_block_size);
  bytes_total = 0;

  while ((SANE_Word) bytes_total < byte_count)
    {
      status =
      sanei_usb_read_bulk (chip->fd, (SANE_Byte *) (data + bytes_total),
                       &n);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (7, "usb_low_read_rows: problems during read: %s -- exiting\n",
             sane_strstatus (status));
        return status;
      }
      /* Count the number of URBs. This is a bit tricky, as we are reading
       bigger chunks here but the scanner can only handle 64 bytes at once. */
      chip->total_read_urbs += ((n +  63) / 64);
      bytes_total += n;
      if ((SANE_Word) bytes_total != byte_count)
      {
        DBG (7, "usb_low_read_rows:  wanted %d, got %d "
             "bytes (%d in total) -- retrying\n", byte_count, (SANE_Word) n,
             (SANE_Word) bytes_total);
      }
      n = MIN ((byte_count - (SANE_Word) bytes_total), chip->max_block_size);
    }

  DBG (7, "usb_low_read_rows: exit, read %d bytes\n",
       (SANE_Word) bytes_total);
  return SANE_STATUS_GOOD;
}


SANE_Status
usb_low_write_reg (ma1017 * chip, SANE_Byte reg_no, SANE_Byte data)
{
  size_t n;
  SANE_Status status;
  SANE_Byte data_field[2];

  data_field[0] = data;
  data_field[1] = reg_no;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_write_reg: open first\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_write_reg: rowing, stop first\n");
      return SANE_STATUS_INVAL;
    }
  if (reg_no > 0x20)
    {
      DBG (3, "usb_low_write_reg: reg_no out of range\n");
      return SANE_STATUS_INVAL;
    }
  n = 2;
  status = sanei_usb_write_bulk (chip->fd, data_field, &n);
  if (status != SANE_STATUS_GOOD || n != 2)
    {
      DBG (3, "usb_low_write_reg: couldn't write, tried to write %d, "
         "wrote %lu: %s\n", 2, (unsigned long int) n,
         sane_strstatus (status));
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_write_urbs++;
  DBG (7, "usb_low_write_reg: reg: 0x%02x, value: 0x%02x\n", reg_no, data);
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_read_reg (ma1017 * chip, SANE_Byte reg_no, SANE_Byte * data)
{
  SANE_Byte data_field[2];
  SANE_Byte read_byte;
  size_t n;
  SANE_Status status;

  data_field[0] = 0x00;
  data_field[1] = reg_no | 0x20;

  if (!chip->is_opened)
    {
      DBG (3, "usb_low_read_reg: open first\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_rowing)
    {
      DBG (3, "usb_low_read_reg: rowing, stop first\n");
      return SANE_STATUS_INVAL;
    }
  if (reg_no > 0x20)
    {
      DBG (3, "usb_low_read_reg: reg_no out of range\n");
      return SANE_STATUS_INVAL;
    }
  n = 2;
  DBG (5, "usb_low_read_reg: trying to write %lu bytes\n", (unsigned long int) n);

  status = sanei_usb_write_bulk (chip->fd, data_field, &n);
  if (status != SANE_STATUS_GOOD || n != 2)
    {
      DBG (3, "usb_low_read_reg: couldn't write, tried to write %d, "
         "wrote %lu: %s\n", 2, (unsigned long int) n,
         sane_strstatus (status));
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_write_urbs++;
  n = 1;
  DBG (5, "usb_low_read_reg: trying to read %lu bytes\n", (unsigned long int) n);
  status = sanei_usb_read_bulk (chip->fd, (SANE_Byte *) & read_byte, &n);
  if (status != SANE_STATUS_GOOD || n != 1)
    {
      DBG (3, "usb_low_read_reg: couldn't read, tried to read %lu, "
         "read %lu: %s\n", (unsigned long int) 1,
         (unsigned long int) n, sane_strstatus (status));
      return SANE_STATUS_IO_ERROR;
    }
  chip->total_read_urbs++;
  if (data)
    *data = read_byte;
  DBG (7, "usb_low_read_reg: Reg: 0x%02x, Value: 0x%02x\n",
       reg_no, read_byte);
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_identify_scanner (SANE_Int fd, Mustek_Type * scanner_type)
{
  SANE_Status status;
  SANE_Word devvendor, devproduct;
  Mustek_Type devtype;

  DBG (7, "usb_low_identify_scanner: start\n");

  status = sanei_usb_get_vendor_product (fd, &devvendor, &devproduct);
  devtype = MT_UNKNOWN;
  if (status == SANE_STATUS_GOOD)
    {
      if (devvendor == 0x055f)
      {
        switch (devproduct)
          {
          case 0x0001:
            devtype = MT_1200CU;
            break;
          case 0x0002:
            devtype = MT_600CU;
            break;
          case 0x0003:
            devtype = MT_1200USB;
            break;
          case 0x0006:
            devtype = MT_1200UB;
            break;
          case 0x0008:
            devtype = MT_1200CU_PLUS;
            break;
          case 0x0873:
            devtype = MT_600USB;
            break;
          default:
            if (scanner_type)
            *scanner_type = devtype;
            DBG (3, "usb_low_identify_scanner: unknown product id: "
               "0x%04x\n", devproduct);
            return SANE_STATUS_INVAL;
            break;
          }
      }
      else
      {
        if (scanner_type)
          *scanner_type = devtype;
        DBG (3, "usb_low_identify_scanner: unknown vendor id: 0x%04d\n",
             devvendor);
        return SANE_STATUS_INVAL;
      }
    }
  if (scanner_type)
    *scanner_type = devtype;
  DBG (7, "usb_low_identify_scanner: exit\n");
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_open (ma1017 * chip, SANE_String_Const devname)
{
  SANE_Status status;
  Mustek_Type scanner_type;

  DBG (7, "usb_low_open: start: chip = %p\n", (void *) chip);

  if (chip->is_rowing)
    {
      DBG (3, "usb_low_open: already rowing\n");
      return SANE_STATUS_INVAL;
    }
  if (chip->is_opened)
    {
      DBG (3, "usb_low_open: already opened\n");
      return SANE_STATUS_INVAL;
    }

  status = sanei_usb_open ((SANE_String_Const) devname, &chip->fd);

  if (status == SANE_STATUS_GOOD)
    {
      DBG (7, "usb_low_open: device %s successfully opened\n", devname);
      chip->is_opened = SANE_TRUE;
      /* Try to get vendor and device ids */
      DBG (7, "usb_low_open: trying to identify device `%s'\n", devname);
      status = usb_low_identify_scanner (chip->fd, &scanner_type);
      if (status != SANE_STATUS_GOOD)
      {
        DBG (3, "usb_low_open: device `%s' doesn't look like a supported "
             "scanner\n", devname);
        sanei_usb_close (chip->fd);
        return status;
      }
      else
      {
        if (scanner_type == MT_UNKNOWN)
          {
            DBG (3, "usb_low_open: device `%s' can't be identified\n",
               devname);
          }
        else if (scanner_type != chip->scanner_type)
          {
            DBG (3, "usb_low_open: device `%s' is supported but"
               "it's not the same as at the start\n", devname);
            return SANE_STATUS_INVAL;
          }
      }
    }
  else
    {
      DBG (1, "usb_low_open: device %s couldn't be opened: %s\n",
         devname, sane_strstatus (status));
      return status;
    }

  chip->is_opened = SANE_TRUE;

  RIE (usb_low_read_all_registers (chip));

  DBG (7, "usb_low_open: exit, type is %d\n", scanner_type);
  return SANE_STATUS_GOOD;
}

SANE_Status
usb_low_close (ma1017 * chip)
{
  DBG (7, "usb_low_close: start, chip=%p\n", (void *) chip);
  if (!chip->is_opened)
    {
      DBG (3, "usb_low_close: already close or never opened\n");
      return SANE_STATUS_INVAL;
    }

  if (chip->fd >= 0)
    {
      SANE_Byte dummy;

      if (chip->is_rowing)
      usb_low_stop_rowing (chip);
      /* Now make sure that both the number of written and
       read URBs is even. Use some dummy writes/reads. That's to avoid
       a nasty bug in the MA 1017 chipset that causes timeouts when
       the number of URBs is odd (toggle bug). */
      if ((chip->total_read_urbs % 2) == 1)
      usb_low_get_a4 (chip, &dummy);
      if ((chip->total_write_urbs % 2) == 1)
      usb_low_set_fix_pattern (chip, SANE_FALSE);
      sanei_usb_close (chip->fd);
      chip->fd = -1;
    }
  chip->is_opened = SANE_FALSE;
  chip->is_rowing = SANE_FALSE;

  DBG (7, "usb_low_close: exit\n");
  return SANE_STATUS_GOOD;
}

Generated by  Doxygen 1.6.0   Back to index