diff options
Diffstat (limited to 'backend/mustek_usb_low.c')
| -rw-r--r-- | backend/mustek_usb_low.c | 2914 |
1 files changed, 2914 insertions, 0 deletions
diff --git a/backend/mustek_usb_low.c b/backend/mustek_usb_low.c new file mode 100644 index 0000000..e626b65 --- /dev/null +++ b/backend/mustek_usb_low.c @@ -0,0 +1,2914 @@ +/* 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; +} |