diff options
Diffstat (limited to 'backend/hpsj5s.c')
| -rw-r--r-- | backend/hpsj5s.c | 1568 |
1 files changed, 1568 insertions, 0 deletions
diff --git a/backend/hpsj5s.c b/backend/hpsj5s.c new file mode 100644 index 0000000..75f3526 --- /dev/null +++ b/backend/hpsj5s.c @@ -0,0 +1,1568 @@ +/* sane - Scanner Access Now Easy. + Copyright (C) 2002 Max Vorobiev <pcwizard@telecoms.sins.ru> + 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. */ + +#define BUILD 3 + +#define BACKEND_NAME hpsj5s +#define HPSJ5S_CONFIG_FILE "hpsj5s.conf" + +#include "../include/sane/config.h" +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" +#include "../include/sane/saneopts.h" + +#include "../include/sane/sanei_config.h" +#include "../include/sane/sanei_backend.h" + +#include "hpsj5s.h" + +#include <string.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + + +#define LINES_TO_FEED 480 /*Default feed length */ + +static int scanner_d = -1; /*This is handler to the only-supported. Will be fixed. */ +static char scanner_path[PATH_MAX] = ""; /*String for device-file */ +static SANE_Byte bLastCalibration; /*Here we store calibration result */ +static SANE_Byte bCalibration; /*Here we store new calibration value */ +static SANE_Byte bHardwareState; /*Here we store copy of hardware flags register */ + +/*Here we store Parameters:*/ +static SANE_Word wWidth = 2570; /*Scan area width */ +static SANE_Word wResolution = 300; /*Resolution in DPI */ +static SANE_Frame wCurrentFormat = SANE_FRAME_GRAY; /*Type of colors in image */ +static SANE_Int wCurrentDepth = 8; /*Bits per pixel in image */ + +/*Here we count lines of every new image...*/ +static SANE_Word wVerticalResolution; + +/*Limits for resolution control*/ +static const SANE_Range ImageWidthRange = { + 0, /*minimal */ + 2570, /*maximum */ + 2 /*quant */ +}; + +static const SANE_Word ImageResolutionsList[] = { + 6, /*Number of resolutions */ + 75, + 100, + 150, + 200, + 250, + 300 +}; + +static SANE_Option_Descriptor sod[] = { + { /*Number of options */ + SANE_NAME_NUM_OPTIONS, + SANE_TITLE_NUM_OPTIONS, + SANE_DESC_NUM_OPTIONS, + SANE_TYPE_INT, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} /*No constraints required */ + } + , + { /*Width of scaned area */ + "width", + "Width", + "Width of area to scan", + SANE_TYPE_INT, + SANE_UNIT_PIXEL, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_RANGE, + {NULL} /*Range constrain setted in sane_init */ + } + , + { /*Resolution for scan */ + "resolution", + "Resolution", + "Image resolution", + SANE_TYPE_INT, + SANE_UNIT_DPI, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_WORD_LIST, + {NULL} /*Word list constrain setted in sane_init */ + } +}; + +static SANE_Parameters parms; + +/*Recalculate Lenght in dependace of resolution*/ +static SANE_Word +LengthForRes (SANE_Word Resolution, SANE_Word Length) +{ + switch (Resolution) + { + case 75: + return Length / 4; + case 100: + return Length / 3; + case 150: + return Length / 2; + case 200: + return Length * 2 / 3; + case 250: + return Length * 5 / 6; + case 300: + default: + return Length; + } +} + +static struct parport_list pl; /*List of detected parallel ports. */ + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + char line[PATH_MAX]; /*Line from config file */ + int len; /*Length of string from config file */ + FILE *config_file; /*Handle to config file of this backend */ + + DBG_INIT (); + DBG (1, ">>sane_init"); + DBG (2, "sane_init: version_code %s 0, authorize %s 0\n", + version_code == 0 ? "=" : "!=", authorize == 0 ? "=" : "!="); + DBG (1, "sane_init: SANE hpsj5s backend version %d.%d.%d\n", + SANE_CURRENT_MAJOR, V_MINOR, BUILD); + + /*Inform about supported version */ + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); + + /*Open configuration file for this backend */ + config_file = sanei_config_open (HPSJ5S_CONFIG_FILE); + + if (!config_file) /*Failed to open config file */ + { + DBG (1, "sane_init: no config file found."); + return SANE_STATUS_GOOD; + } + + /*Read line by line */ + while (sanei_config_read (line, PATH_MAX, config_file)) + { + if ((line[0] == '#') || (line[0] == '\0')) /*comment line or empty line */ + continue; + len = strlen (line); /*sanei_config_read guaranty, it's not more then PATH_MAX-1 */ + strcpy (scanner_path, line); /*so, we choose last in file (uncommented) */ + } + + fclose (config_file); /*We don't need config file any more */ + + /*sanei_config_attach_matching_devices(devname, attach_one); To do latter */ + + scanner_d = -1; /*scanner device not opened yet. */ + DBG (1, "<<sane_init"); + + /*Init params structure with defaults values: */ + wCurrentFormat = SANE_FRAME_GRAY; + wCurrentDepth = 8; + wWidth = 2570; + wResolution = 300; + + /*Setup some option descriptors */ + sod[1].constraint.range = &ImageWidthRange; /*Width option */ + sod[2].constraint.word_list = &ImageResolutionsList[0]; /*Resolution option */ + + /*Search for ports in system: */ + ieee1284_find_ports (&pl, 0); + + return SANE_STATUS_GOOD; +} + +void +sane_exit (void) +{ + if (scanner_d != -1) + { + CloseScanner (scanner_d); + scanner_d = -1; + } + + /*Free alocated ports information: */ + ieee1284_free_ports (&pl); + + DBG (2, "sane_exit\n"); + return; +} + +/* Device select/open/close */ +static const SANE_Device dev[] = { + { + "hpsj5s", + "Hewlett-Packard", + "ScanJet 5S", + "sheetfed scanner"} +}; + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + /*One device is supported and currently present */ + static const SANE_Device *devlist[] = { + dev + 0, 0 + }; + + /*No scanners presents */ + static const SANE_Device *void_devlist[] = { 0 }; + + DBG (2, "sane_get_devices: local_only = %d\n", local_only); + + if (scanner_d != -1) /*Device is opened, so it's present. */ + { + *device_list = devlist; + return SANE_STATUS_GOOD; + }; + + /*Device was not opened. */ + scanner_d = OpenScanner (scanner_path); + + if (scanner_d == -1) /*No devices present */ + { + DBG (1, "failed to open scanner.\n"); + *device_list = void_devlist; + return SANE_STATUS_GOOD; + } + DBG (1, "port opened.\n"); + + /*Check device. */ + DBG (1, "sane_get_devices: check scanner started."); + if (DetectScanner () == 0) + { /*Device malfunction! */ + DBG (1, "sane_get_devices: Device malfunction."); + *device_list = void_devlist; + return SANE_STATUS_GOOD; + } + else + { + DBG (1, "sane_get_devices: Device works OK."); + *device_list = devlist; + } + + /*We do not need it any more */ + CloseScanner (scanner_d); + scanner_d = -1; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_open (SANE_String_Const devicename, SANE_Handle * handle) +{ + int i; + + if (!devicename) + { + DBG (1, "sane_open: devicename is NULL!"); + return SANE_STATUS_INVAL; + } + + DBG (2, "sane_open: devicename = \"%s\"\n", devicename); + + if (!devicename[0]) + i = 0; + else + for (i = 0; i < NELEMS (dev); ++i) /*Search for device in list */ + if (strcmp (devicename, dev[i].name) == 0) + break; + + if (i >= NELEMS (dev)) /*No such device */ + return SANE_STATUS_INVAL; + + if (scanner_d != -1) /*scanner opened already! */ + return SANE_STATUS_DEVICE_BUSY; + + DBG (1, "sane_open: scanner device path name is \'%s\'\n", scanner_path); + + scanner_d = OpenScanner (scanner_path); + if (scanner_d == -1) + return SANE_STATUS_DEVICE_BUSY; /*This should be done more carefully */ + + /*Check device. */ + DBG (1, "sane_open: check scanner started."); + if (DetectScanner () == 0) + { /*Device malfunction! */ + DBG (1, "sane_open: Device malfunction."); + CloseScanner (scanner_d); + scanner_d = -1; + return SANE_STATUS_IO_ERROR; + } + DBG (1, "sane_open: Device found.All are green."); + *handle = (SANE_Handle) (unsigned long)scanner_d; + + return SANE_STATUS_GOOD; +} + +void +sane_close (SANE_Handle handle) +{ + DBG (2, "sane_close\n"); + /*We support only single device - so ignore handle (FIX IT LATER) */ + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + return; /* wrong device */ + StandByScanner (); + CloseScanner (scanner_d); + scanner_d = -1; +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + DBG (2, "sane_get_option_descriptor: option = %d\n", option); + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + return NULL; /* wrong device */ + + if (option < 0 || option >= NELEMS (sod)) /*No real options supported */ + return NULL; + + return &sod[option]; /*Return demanded option */ +} + +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *value, SANE_Int * info) +{ + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + return SANE_STATUS_INVAL; /* wrong device */ + + if ((option >= NELEMS (sod)) || (option < 0)) /*Supported only this option */ + return SANE_STATUS_INVAL; + + switch (option) + { + case 0: /*Number of options */ + if (action != SANE_ACTION_GET_VALUE) /*It can be only read */ + return SANE_STATUS_INVAL; + + *((SANE_Int *) value) = NELEMS (sod); + return SANE_STATUS_GOOD; + case 1: /*Scan area width */ + switch (action) + { + case SANE_ACTION_GET_VALUE: + *((SANE_Word *) value) = wWidth; + return SANE_STATUS_GOOD; + case SANE_ACTION_SET_VALUE: /*info should be setted */ + wWidth = *((SANE_Word *) value); + if (info != NULL) + *info = SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + default: + return SANE_STATUS_INVAL; + } + case 2: /*Resolution */ + switch (action) + { + case SANE_ACTION_GET_VALUE: + *((SANE_Word *) value) = wResolution; + return SANE_STATUS_GOOD; + case SANE_ACTION_SET_VALUE: /*info should be setted */ + wResolution = *((SANE_Word *) value); + if (info != NULL) + *info = 0; + return SANE_STATUS_GOOD; + default: + return SANE_STATUS_INVAL; + } + default: + return SANE_STATUS_INVAL; + } + return SANE_STATUS_GOOD; /*For now we have no options to control */ +} + +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + DBG (2, "sane_get_parameters\n"); + + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + return SANE_STATUS_INVAL; /* wrong device */ + + /*Ignore handle parameter for now. FIX it latter. */ + /*These parameters are OK for gray scale mode. */ + parms.depth = /*wCurrentDepth */ 8; + parms.format = /*wCurrentFormat */ SANE_FRAME_GRAY; + parms.last_frame = SANE_TRUE; /*For grayscale... */ + parms.lines = -1; /*Unknown a priory */ + parms.pixels_per_line = LengthForRes (wResolution, wWidth); /*For grayscale... */ + parms.bytes_per_line = parms.pixels_per_line; /*For grayscale... */ + *params = parms; + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_start (SANE_Handle handle) +{ + int i; + DBG (2, "sane_start\n"); + + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + return SANE_STATUS_IO_ERROR; + + CallFunctionWithParameter (0x93, 2); + bLastCalibration = CallFunctionWithRetVal (0xA9); + if (bLastCalibration == 0) + bLastCalibration = -1; + + /*Turn on the lamp: */ + CallFunctionWithParameter (FUNCTION_SETUP_HARDWARE, FLAGS_HW_LAMP_ON); + bHardwareState = FLAGS_HW_LAMP_ON; + /*Get average white point */ + bCalibration = GetCalibration (); + + if (bLastCalibration - bCalibration > 16) + { /*Lamp is not warm enouth */ + DBG (1, "sane_start: warming lamp for 30 sec.\n"); + for (i = 0; i < 30; i++) + sleep (1); + } + + /*Check paper presents */ + if (CheckPaperPresent () == 0) + { + DBG (1, "sane_start: no paper detected."); + return SANE_STATUS_NO_DOCS; + } + CalibrateScanElements (); + TransferScanParameters (GrayScale, wResolution, wWidth); + /*Turn on indicator and prepare engine. */ + SwitchHardwareState (FLAGS_HW_INDICATOR_OFF | FLAGS_HW_MOTOR_READY, 1); + /*Feed paper */ + if (PaperFeed (LINES_TO_FEED) == 0) /*Feed only for fixel lenght. Change it */ + { + DBG (1, "sane_start: paper feed failed."); + SwitchHardwareState (FLAGS_HW_INDICATOR_OFF | FLAGS_HW_MOTOR_READY, 0); + return SANE_STATUS_JAMMED; + } + /*Set paper moving speed */ + TurnOnPaperPulling (GrayScale, wResolution); + + wVerticalResolution = 0; /*Reset counter */ + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * data, + SANE_Int max_length, SANE_Int * length) +{ + SANE_Byte bFuncResult, bTest; + int timeout; + + if (!length) + { + DBG (1, "sane_read: length == NULL\n"); + return SANE_STATUS_INVAL; + } + *length = 0; + if (!data) + { + DBG (1, "sane_read: data == NULL\n"); + return SANE_STATUS_INVAL; + } + + if ((handle != (SANE_Handle) (unsigned long)scanner_d) || (scanner_d == -1)) + { + DBG (1, "sane_read: unknown handle\n"); + return SANE_STATUS_INVAL; + } + + /*While end of paper sheet was not reached */ + /*Wait for scaned line ready */ + timeout = 0; + while (((bFuncResult = CallFunctionWithRetVal (0xB2)) & 0x20) == 0) + { + bTest = CallFunctionWithRetVal (0xB5); + usleep (1); + timeout++; + if ((timeout < 1000) && + (((bTest & 0x80) && ((bTest & 0x3F) <= 2)) || + (((bTest & 0x80) == 0) && ((bTest & 0x3F) >= 5)))) + continue; + + if (timeout >= 1000) + continue; /*do it again! */ + + /*Data ready state! */ + + if ((bFuncResult & 0x20) != 0) /*End of paper reached! */ + { + *length = 0; + return SANE_STATUS_EOF; + } + + /*Data ready */ + *length = LengthForRes (wResolution, wWidth); + if (*length >= max_length) + *length = max_length; + + CallFunctionWithParameter (0xCD, 0); + CallFunctionWithRetVal (0xC8); + WriteScannerRegister (REGISTER_FUNCTION_CODE, 0xC8); + WriteAddress (ADDRESS_RESULT); + /*Test if we need this line for current resolution + (scanner doesn't control vertical resolution in hardware) */ + wVerticalResolution -= wResolution; + if (wVerticalResolution > 0) + { + timeout = 0; + continue; + } + else + wVerticalResolution = 300; /*Reset counter */ + + ReadDataBlock (data, *length); + + /*switch indicator */ + bHardwareState ^= FLAGS_HW_INDICATOR_OFF; + CallFunctionWithParameter (FUNCTION_SETUP_HARDWARE, bHardwareState); + return SANE_STATUS_GOOD; + } + return SANE_STATUS_EOF; +} + +void +sane_cancel (SANE_Handle handle) +{ + DBG (2, "sane_cancel: handle = %p\n", handle); + /*Stop motor */ + TurnOffPaperPulling (); + + /*Indicator turn off */ + bHardwareState |= FLAGS_HW_INDICATOR_OFF; + CallFunctionWithParameter (FUNCTION_SETUP_HARDWARE, bHardwareState); + + /*Get out of paper */ + ReleasePaper (); + + /*Restore indicator */ + bHardwareState &= ~FLAGS_HW_INDICATOR_OFF; + CallFunctionWithParameter (FUNCTION_SETUP_HARDWARE, bHardwareState); + + bLastCalibration = CallFunctionWithRetVal (0xA9); + CallFunctionWithParameter (0xA9, bLastCalibration); + CallFunctionWithParameter (0x93, 4); + +} + +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + DBG (2, "sane_set_io_mode: handle = %p, non_blocking = %d\n", handle, + non_blocking); + return SANE_STATUS_UNSUPPORTED; +} + +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + DBG (2, "sane_get_select_fd: handle = %p, fd %s 0\n", handle, + fd ? "!=" : "="); + return SANE_STATUS_UNSUPPORTED; +} + +/* + Middle-level API: +*/ + +/* + Detect if scanner present and works correctly. + Ret Val: 0 = detection failed, 1 = detection OK. +*/ +static int +DetectScanner (void) +{ + int Result1, Result2; + int Successful, Total; + + Result1 = OutputCheck (); + Result2 = InputCheck (); + + if (!(Result1 || Result2)) /*If all are 0 - it's error */ + { + return 0; + } + + WriteScannerRegister (0x7C, 0x80); + WriteScannerRegister (0x7F, 0x1); + WriteScannerRegister (0x72, 0x10); + WriteScannerRegister (0x72, 0x90); + WriteScannerRegister (0x7C, 0x24); + WriteScannerRegister (0x75, 0x0C); + WriteScannerRegister (0x78, 0x0); + WriteScannerRegister (0x79, 0x10); + WriteScannerRegister (0x71, 0x10); + WriteScannerRegister (0x71, 0x1); + WriteScannerRegister (0x72, 0x1); + + for (Successful = 0, Total = 0; Total < 5; Total++) + { + if (CallCheck ()) + Successful++; + if (Successful >= 3) + return 1; /*Correct and Stable */ + } + return 0; +} + +static void +StandByScanner () +{ + WriteScannerRegister (0x74, 0x80); + WriteScannerRegister (0x75, 0x0C); + WriteScannerRegister (0x77, 0x0); + WriteScannerRegister (0x78, 0x0); + WriteScannerRegister (0x79, 0x0); + WriteScannerRegister (0x7A, 0x0); + WriteScannerRegister (0x7B, 0x0); + WriteScannerRegister (0x7C, 0x4); + WriteScannerRegister (0x70, 0x0); + WriteScannerRegister (0x72, 0x90); + WriteScannerRegister (0x70, 0x0); +} + +static void +SwitchHardwareState (SANE_Byte mask, SANE_Byte invert_mask) +{ + if (!invert_mask) + { + bHardwareState &= ~mask; + } + else + bHardwareState |= mask; + + CallFunctionWithParameter (FUNCTION_SETUP_HARDWARE, bHardwareState); +} + +/*return value: 0 - no paper, 1 - paper loaded.*/ +static int +CheckPaperPresent () +{ + if ((CallFunctionWithRetVal (0xB2) & 0x10) == 0) + return 1; /*Ok - paper present. */ + return 0; /*No paper present */ +} + +static int +ReleasePaper () +{ + int i; + + if ((CallFunctionWithRetVal (0xB2) & 0x20) == 0) + { /*End of paper was not reached */ + CallFunctionWithParameter (0xA7, 0xF); + CallFunctionWithParameter (0xA8, 0xFF); + CallFunctionWithParameter (0xC2, 0); + + for (i = 0; i < 90000; i++) + { + if (CallFunctionWithRetVal (0xB2) & 0x80) + break; + usleep (1); + } + if (i >= 90000) + return 0; /*Fail. */ + + for (i = 0; i < 90000; i++) + { + if ((CallFunctionWithRetVal (0xB2) & 0x20) == 0) + break; + else if ((CallFunctionWithRetVal (0xB2) & 0x80) == 0) + { + i = 90000; + break; + } + usleep (1); + } + + CallFunctionWithParameter (0xC5, 0); + + if (i >= 90000) + return 0; /*Fail. */ + + while (CallFunctionWithRetVal (0xB2) & 0x80); /*Wait bit dismiss */ + + CallFunctionWithParameter (0xA7, 1); + CallFunctionWithParameter (0xA8, 0x25); + CallFunctionWithParameter (0xC2, 0); + + for (i = 0; i < 90000; i++) + { + if (CallFunctionWithRetVal (0xB2) & 0x80) + break; + usleep (1); + } + if (i >= 90000) + return 0; /*Fail. */ + + for (i = 0; i < 90000; i++) + { + if ((CallFunctionWithRetVal (0xB2) & 0x80) == 0) + break; + usleep (1); + } + if (i >= 90000) + return 0; /*Fail. */ + } + + if (CallFunctionWithRetVal (0xB2) & 0x10) + { + CallFunctionWithParameter (0xA7, 1); + CallFunctionWithParameter (0xA8, 0x40); + } + else + { + CallFunctionWithParameter (0xA7, 0); + CallFunctionWithParameter (0xA8, 0xFA); + } + CallFunctionWithParameter (0xC2, 0); + + for (i = 0; i < 9000; i++) + { + if (CallFunctionWithRetVal (0xB2) & 0x80) + break; + usleep (1); + } + if (i >= 9000) + return 0; /*Fail. */ + + while (CallFunctionWithRetVal (0xB2) & 0x80) + usleep (1); + + return 1; +} + +static void +TransferScanParameters (enumColorDepth enColor, SANE_Word wResolution, + SANE_Word wPixelsLength) +{ + SANE_Word wRightBourder = (2570 + wPixelsLength) / 2 + 65; + SANE_Word wLeftBourder = (2570 - wPixelsLength) / 2 + 65; + + switch (enColor) + { + case Drawing: + CallFunctionWithParameter (0x90, 2); /*Not supported correctle. FIX ME!!! */ + break; + case Halftone: + CallFunctionWithParameter (0x90, 0xE3); /*Not supported correctly. FIX ME!!! */ + CallFunctionWithParameter (0x92, 3); + break; + case GrayScale: + case TrueColor: + CallFunctionWithParameter (0x90, 0); /*Not suppoted correctly. FIX ME!!! */ + break; + }; + CallFunctionWithParameter (0xA1, 2); + CallFunctionWithParameter (0xA2, 1); + CallFunctionWithParameter (0xA3, 0x98); + /*Resolution: */ + CallFunctionWithParameter (0x9A, (SANE_Byte) (wResolution >> 8)); /*High byte */ + CallFunctionWithParameter (0x9B, (SANE_Byte) wResolution); /*Low byte */ + + LoadingPaletteToScanner (); + + CallFunctionWithParameter (0xA4, 31); /*Some sort of constant parameter */ + /*Left bourder */ + CallFunctionWithParameter (0xA5, wLeftBourder / 256); + CallFunctionWithParameter (0xA6, wLeftBourder % 256); + /*Right bourder */ + CallFunctionWithParameter (0xAA, wRightBourder / 256); + CallFunctionWithParameter (0xAB, wRightBourder % 256); + + CallFunctionWithParameter (0xD0, 0); + CallFunctionWithParameter (0xD1, 0); + CallFunctionWithParameter (0xD2, 0); + CallFunctionWithParameter (0xD3, 0); + CallFunctionWithParameter (0xD4, 0); + CallFunctionWithParameter (0xD5, 0); + + CallFunctionWithParameter (0x9D, 5); +} + +static void +TurnOnPaperPulling (enumColorDepth enColor, SANE_Word wResolution) +{ + switch (enColor) + { + case Drawing: + case Halftone: + CallFunctionWithParameter (0x91, 0xF7); + return; + case GrayScale: + switch (wResolution) + { + case 50: + case 75: + case 100: + CallFunctionWithParameter (0x91, 0xB7); + return; + case 150: + case 200: + CallFunctionWithParameter (0x91, 0x77); + return; + case 250: + case 300: + CallFunctionWithParameter (0x91, 0x37); + return; + default: + return; + } + case TrueColor: + switch (wResolution) + { + case 75: + case 100: + CallFunctionWithParameter (0x91, 0xA3); + return; + case 150: + case 200: + CallFunctionWithParameter (0x91, 0x53); + return; + case 250: + case 300: + CallFunctionWithParameter (0x91, 0x3); + return; + default: + return; + } + default: + return; + } +} + +static void +TurnOffPaperPulling () +{ + CallFunctionWithParameter (0x91, 0); +} + +/* + Returns avarage value of scaned row. + While paper not loaded this is base "white point". +*/ +static SANE_Byte +GetCalibration () +{ + int i; + int Result; + SANE_Byte Buffer[2600]; + SANE_Byte bTest; + + CallFunctionWithParameter (0xA1, 2); + CallFunctionWithParameter (0xA2, 1); + CallFunctionWithParameter (0xA3, 0x98); + + /*Resolution to 300 DPI */ + CallFunctionWithParameter (0x9A, 1); + CallFunctionWithParameter (0x9B, 0x2C); + + CallFunctionWithParameter (0x92, 0); + CallFunctionWithParameter (0xC6, 0); + CallFunctionWithParameter (0x92, 0x80); + + for (i = 1; i < 256; i++) + CallFunctionWithParameter (0xC6, i); + + for (i = 0; i < 256; i++) + CallFunctionWithParameter (0xC6, i); + + for (i = 0; i < 256; i++) + CallFunctionWithParameter (0xC6, i); + + CallFunctionWithParameter (0xA4, 31); /*Some sort of constant */ + + /*Left bourder */ + CallFunctionWithParameter (0xA5, 0); + CallFunctionWithParameter (0xA6, 0x41); + + /*Right bourder */ + CallFunctionWithParameter (0xAA, 0xA); + CallFunctionWithParameter (0xAB, 0x39); + + CallFunctionWithParameter (0xD0, 0); + CallFunctionWithParameter (0xD1, 0); + CallFunctionWithParameter (0xD2, 0); + CallFunctionWithParameter (0xD3, 0); + CallFunctionWithParameter (0xD4, 0); + CallFunctionWithParameter (0xD5, 0); + + CallFunctionWithParameter (0x9C, 0x1B); + CallFunctionWithParameter (0x9D, 5); + + CallFunctionWithParameter (0x92, 0x10); + CallFunctionWithParameter (0xC6, 0xFF); + CallFunctionWithParameter (0x92, 0x90); + + for (i = 0; i < 2999; i++) + CallFunctionWithParameter (0xC6, 0xFF); + + CallFunctionWithParameter (0x92, 0x50); + CallFunctionWithParameter (0xC6, 0); + CallFunctionWithParameter (0x92, 0xD0); + + for (i = 0; i < 2999; i++) + CallFunctionWithParameter (0xC6, 0); + + CallFunctionWithParameter (0x98, 0xFF); /*Up limit */ + CallFunctionWithParameter (0x95, 0); /*Low limit */ + + CallFunctionWithParameter (0x90, 0); /*Gray scale... */ + + CallFunctionWithParameter (0x91, 0x3B); /*Turn motor on. */ + + for (i = 0; i < 5; i++) + { + do + { /*WARNING!!! Deadlock possible! */ + bTest = CallFunctionWithRetVal (0xB5); + } + while ((((bTest & 0x80) == 1) && ((bTest & 0x3F) <= 2)) || + (((bTest & 0x80) == 0) && ((bTest & 0x3F) >= 5))); + + CallFunctionWithParameter (0xCD, 0); + /*Skip this line for ECP: */ + CallFunctionWithRetVal (0xC8); + + WriteScannerRegister (REGISTER_FUNCTION_CODE, 0xC8); + WriteAddress (0x20); + ReadDataBlock (Buffer, 2552); + }; + CallFunctionWithParameter (0x91, 0); /*Turn off motor. */ + usleep (10); + for (Result = 0, i = 0; i < 2552; i++) + Result += Buffer[i]; + return Result / 2552; +} + +static int +PaperFeed (SANE_Word wLinesToFeed) +{ + int i; + + CallFunctionWithParameter (0xA7, 0xF); + CallFunctionWithParameter (0xA8, 0xFF); + CallFunctionWithParameter (0xC2, 0); + + for (i = 0; i < 9000; i++) + { + if (CallFunctionWithRetVal (0xB2) & 0x80) + break; + usleep (1); + } + if (i >= 9000) + return 0; /*Fail. */ + + for (i = 0; i < 9000; i += 5) + { + if ((CallFunctionWithRetVal (0xB2) & 0x20) == 0) + break; + else if ((CallFunctionWithRetVal (0xB2) & 0x80) == 0) + { + i = 9000; + break; + } + usleep (5); + } + + CallFunctionWithParameter (0xC5, 0); + + if (i >= 9000) + return 0; /*Fail. */ + + /*Potential deadlock */ + while (CallFunctionWithRetVal (0xB2) & 0x80); /*Wait bit dismiss */ + + CallFunctionWithParameter (0xA7, wLinesToFeed / 256); + CallFunctionWithParameter (0xA8, wLinesToFeed % 256); + CallFunctionWithParameter (0xC2, 0); + + for (i = 0; i < 9000; i++) + { + if (CallFunctionWithRetVal (0xB2) & 0x80) + break; + usleep (1); + } + if (i >= 9000) + return 0; /*Fail. */ + + for (i = 0; i < 9000; i++) + { + if ((CallFunctionWithRetVal (0xB2) & 0x80) == 0) + break; + usleep (1); + } + if (i >= 9000) + return 0; /*Fail. */ + + return 1; +} + +/*For now we do no calibrate elements - just set maximum limits. FIX ME?*/ +static void +CalibrateScanElements () +{ + /*Those arrays will be used in future for correct calibration. */ + /*Then we need to transfer UP brightness border, we use these registers */ + SANE_Byte arUpTransferBorders[] = { 0x10, 0x20, 0x30 }; + /*Then we need to transfer LOW brightness border, we use these registers */ + SANE_Byte arLowTransferBorders[] = { 0x50, 0x60, 0x70 }; + /*Then we need to save UP brightness border, we use these registers */ + SANE_Byte arUpSaveBorders[] = { 0x98, 0x97, 0x99 }; + /*Then we need to save LOW brightness border, we use these registers */ + SANE_Byte arLowSaveBorders[] = { 0x95, 0x94, 0x96 }; + /*Speeds, used for calibration */ + SANE_Byte arSpeeds[] = { 0x3B, 0x37, 0x3F }; + int j, Average, Temp, Index, /* Line, */ timeout,Calibration; + SANE_Byte bTest /*, Min, Max, Result */ ; + /*For current color component: (values from arrays). Next two lines - starting and terminating. */ + + SANE_Byte CurrentUpTransferBorder; + SANE_Byte CurrentLowTransferBorder; + SANE_Byte CurrentUpSaveBorder; + SANE_Byte CurrentLowSaveBorder; + SANE_Byte CurrentSpeed1, CurrentSpeed2; + SANE_Byte CorrectionValue; + SANE_Byte FilteredBuffer[2570]; + + CallFunctionWithParameter (0xA1, 2); + CallFunctionWithParameter (0xA2, 0); + CallFunctionWithParameter (0xA3, 0x98); + + /*DPI = 300 */ + CallFunctionWithParameter (0x9A, 1); /*High byte */ + CallFunctionWithParameter (0x9B, 0x2C); /*Low byte */ + + /*Paletter settings. */ + CallFunctionWithParameter (0x92, 0); + CallFunctionWithParameter (0xC6, 0); + CallFunctionWithParameter (0x92, 0x80); + + /*First color component */ + for (j = 1; j < 256; j++) + CallFunctionWithParameter (0xC6, j); + + /*Second color component */ + for (j = 0; j < 256; j++) + CallFunctionWithParameter (0xC6, j); + + /*Third color component */ + for (j = 0; j < 256; j++) + CallFunctionWithParameter (0xC6, j); + + CallFunctionWithParameter (0xA4, 31); + + /*Left border */ + CallFunctionWithParameter (0xA5, 0); /*High byte */ + CallFunctionWithParameter (0xA6, 0x41); /*Low byte */ + + /*Right border */ + CallFunctionWithParameter (0xAA, 0xA); /*High byte */ + CallFunctionWithParameter (0xAB, 0x4B); /*Low byte */ + + /*Zero these registers... */ + CallFunctionWithParameter (0xD0, 0); + CallFunctionWithParameter (0xD1, 0); + CallFunctionWithParameter (0xD2, 0); + CallFunctionWithParameter (0xD3, 0); + CallFunctionWithParameter (0xD4, 0); + CallFunctionWithParameter (0xD5, 0); + + CallFunctionWithParameter (0x9C, 0x1B); + CallFunctionWithParameter (0x9D, 0x5); + + Average = 0; + for (Index = 0; Index < 3; Index++) /*For theree color components */ + { + /*Up border = 0xFF */ + CallFunctionWithParameter (0x92, arUpTransferBorders[Index]); + CallFunctionWithParameter (0xC6, 0xFF); + CallFunctionWithParameter (0x92, arUpTransferBorders[Index] | 0x80); + + for (j = 2999; j > 0; j--) + CallFunctionWithParameter (0xC6, 0xFF); + + /*Low border = 0x0 */ + CallFunctionWithParameter (0x92, arLowTransferBorders[Index]); + CallFunctionWithParameter (0xC6, 0x0); + CallFunctionWithParameter (0x92, arLowTransferBorders[Index] | 0x80); + + for (j = 2999; j > 0; j--) + CallFunctionWithParameter (0xC6, 0x0); + + /*Save borders */ + CallFunctionWithParameter (arUpSaveBorders[Index], 0xFF); + CallFunctionWithParameter (arLowSaveBorders[Index], 0x0); + CallFunctionWithParameter (0x90, 0); /*Gray Scale or True color sign :) */ + + CallFunctionWithParameter (0x91, arSpeeds[Index]); + + /*waiting for scaned line... */ + timeout = 0; + do + { + bTest = CallFunctionWithRetVal (0xB5); + timeout++; + usleep (1); + } + while ((timeout < 1000) && + ((((bTest & 0x80) == 1) && ((bTest & 0x3F) <= 2)) || + (((bTest & 0x80) == 0) && ((bTest & 0x3F) >= 5)))); + + /*Let's read it... */ + if(timeout < 1000) + { + CallFunctionWithParameter (0xCD, 0); + CallFunctionWithRetVal (0xC8); + WriteScannerRegister (0x70, 0xC8); + WriteAddress (0x20); + + ReadDataBlock (FilteredBuffer, 2570); + } + + CallFunctionWithParameter (0x91, 0); /*Stop engine. */ + + /*Note: if first read failed, junk would be calculated, but if previous + read was succeded, but last one failed, previous data'ld be used. + */ + for(Temp = 0, j = 0; j < 2570; j++) + Temp += FilteredBuffer[j]; + Temp /= 2570; + + if((Average == 0)||(Average > Temp)) + Average = Temp; + } + + for(Index = 0; Index < 3; Index++) /*Three color components*/ + { + CurrentUpTransferBorder = arUpTransferBorders[Index]; + CallFunctionWithParameter (0xC6, 0xFF); + CallFunctionWithParameter (0x92, CurrentUpTransferBorder|0x80); + for(j=2999; j>0; j--) + CallFunctionWithParameter (0xC6, 0xFF); + + CurrentLowTransferBorder = arLowTransferBorders[Index]; + CallFunctionWithParameter (0xC6, 0x0); + CallFunctionWithParameter (0x92, CurrentLowTransferBorder|0x80); + for(j=2999; j>0; j--) + CallFunctionWithParameter (0xC6, 0); + + CurrentUpSaveBorder = arUpSaveBorders[Index]; + CallFunctionWithParameter (CurrentUpSaveBorder, 0xFF); + + CurrentLowSaveBorder = arLowSaveBorders[Index]; + CallFunctionWithParameter (CurrentLowSaveBorder, 0x0); + CallFunctionWithParameter (0x90,0); + Calibration = 0x80; + CallFunctionWithParameter (CurrentUpSaveBorder, 0x80); + + CurrentSpeed1 = CurrentSpeed2 = arSpeeds[Index]; + + for(CorrectionValue = 0x40; CorrectionValue != 0;CorrectionValue >>= 2) + { + CallFunctionWithParameter (0x91, CurrentSpeed2); + usleep(10); + + /*waiting for scaned line... */ + for(j = 0; j < 5; j++) + { + timeout = 0; + do + { + bTest = CallFunctionWithRetVal (0xB5); + timeout++; + usleep (1); + } + while ((timeout < 1000) && + ((((bTest & 0x80) == 1) && ((bTest & 0x3F) <= 2)) || + (((bTest & 0x80) == 0) && ((bTest & 0x3F) >= 5)))); + + /*Let's read it... */ + if(timeout < 1000) + { + CallFunctionWithParameter (0xCD, 0); + CallFunctionWithRetVal (0xC8); + WriteScannerRegister (0x70, 0xC8); + WriteAddress (0x20); + + ReadDataBlock (FilteredBuffer, 2570); + } + }/*5 times we read. I don't understand what for, but so does HP's driver. + Perhaps, we can optimize it in future.*/ + WriteScannerRegister (0x91, 0); + usleep(10); + + for(Temp = 0,j = 0; j < 16;j++) + Temp += FilteredBuffer[509+j]; /*At this offset calcalates HP's driver.*/ + Temp /= 16; + + if(Average > Temp) + { + Calibration += CorrectionValue; + Calibration = 0xFF < Calibration ? 0xFF : Calibration; /*min*/ + } + else + Calibration -= CorrectionValue; + + WriteScannerRegister (CurrentUpSaveBorder, Calibration); + }/*By CorrectionValue we tune UpSaveBorder*/ + + WriteScannerRegister (0x90, 8); + WriteScannerRegister (0x91, CurrentSpeed1); + usleep(10); + }/*By color components*/ + + return; +} + +/* + Internal use functions: +*/ + +/*Returns 0 in case of fail and 1 in success.*/ +static int +OutputCheck () +{ + int i; + + WriteScannerRegister (0x7F, 0x1); + WriteAddress (0x7E); + for (i = 0; i < 256; i++) + WriteData ((SANE_Byte) i); + + WriteAddress (0x3F); + if (ReadDataByte () & 0x80) + return 0; + + return 1; +} + +static int +InputCheck () +{ + int i; + SANE_Byte Buffer[256]; + + WriteAddress (0x3E); + for (i = 0; i < 256; i++) + { + Buffer[i] = ReadDataByte (); + } + + for (i = 0; i < 256; i++) + { + if (Buffer[i] != i) + return 0; + } + + return 1; +} + +static int +CallCheck () +{ + int i; + SANE_Byte Buffer[256]; + + CallFunctionWithParameter (0x92, 0x10); + CallFunctionWithParameter (0xC6, 0x0); + CallFunctionWithParameter (0x92, 0x90); + WriteScannerRegister (REGISTER_FUNCTION_CODE, 0xC6); + + WriteAddress (0x60); + + for (i = 1; i < 256; i++) + WriteData ((SANE_Byte) i); + + CallFunctionWithParameter (0x92, 0x10); + CallFunctionWithRetVal (0xC6); + CallFunctionWithParameter (0x92, 0x90); + WriteScannerRegister (REGISTER_FUNCTION_CODE, 0xC6); + + WriteAddress (ADDRESS_RESULT); + + ReadDataBlock (Buffer, 256); + + for (i = 0; i < 255; i++) + { + if (Buffer[i + 1] != (SANE_Byte) i) + return 0; + } + return 1; +} + +static void +LoadingPaletteToScanner () +{ + /*For now we have statical gamma. */ + SANE_Byte Gamma[256]; + int i; + for (i = 0; i < 256; i++) + Gamma[i] = i; + + CallFunctionWithParameter (0x92, 0); + CallFunctionWithParameter (0xC6, Gamma[0]); + CallFunctionWithParameter (0x92, 0x80); + for (i = 1; i < 256; i++) + CallFunctionWithParameter (0xC6, Gamma[i]); + + for (i = 0; i < 256; i++) + CallFunctionWithParameter (0xC6, Gamma[i]); + + for (i = 0; i < 256; i++) + CallFunctionWithParameter (0xC6, Gamma[i]); +} + +/* + Low level warappers: +*/ +static void +WriteAddress (SANE_Byte Address) +{ + ieee1284_data_dir (pl.portv[scanner_d], 0); /*Forward mode */ + ieee1284_frob_control (pl.portv[scanner_d], C1284_NINIT, C1284_NINIT); + ieee1284_epp_write_addr (pl.portv[scanner_d], 0, (char *) &Address, 1); +} + +static void +WriteData (SANE_Byte Data) +{ + ieee1284_data_dir (pl.portv[scanner_d], 0); /*Forward mode */ + ieee1284_frob_control (pl.portv[scanner_d], C1284_NINIT, C1284_NINIT); + ieee1284_epp_write_data (pl.portv[scanner_d], 0, (char *) &Data, 1); +} + +static void +WriteScannerRegister (SANE_Byte Address, SANE_Byte Data) +{ + WriteAddress (Address); + WriteData (Data); +} + +static void +CallFunctionWithParameter (SANE_Byte Function, SANE_Byte Parameter) +{ + WriteScannerRegister (REGISTER_FUNCTION_CODE, Function); + WriteScannerRegister (REGISTER_FUNCTION_PARAMETER, Parameter); +} + +static SANE_Byte +CallFunctionWithRetVal (SANE_Byte Function) +{ + WriteScannerRegister (REGISTER_FUNCTION_CODE, Function); + WriteAddress (ADDRESS_RESULT); + return ReadDataByte (); +} + +static SANE_Byte +ReadDataByte () +{ + SANE_Byte Result; + + ieee1284_data_dir (pl.portv[scanner_d], 1); /*Reverse mode */ + ieee1284_frob_control (pl.portv[scanner_d], C1284_NINIT, C1284_NINIT); + ieee1284_epp_read_data (pl.portv[scanner_d], 0, (char *) &Result, 1); + return Result; +} + +static void +ReadDataBlock (SANE_Byte * Buffer, int length) +{ + + ieee1284_data_dir (pl.portv[scanner_d], 1); /*Reverse mode */ + ieee1284_frob_control (pl.portv[scanner_d], C1284_NINIT, C1284_NINIT); + ieee1284_epp_read_data (pl.portv[scanner_d], 0, (char *) Buffer, length); +} + +/* Send a daisy-chain-style CPP command packet. */ +int +cpp_daisy (struct parport *port, int cmd) +{ + unsigned char s; + + ieee1284_data_dir (port, 0); /*forward direction */ + ieee1284_write_control (port, C1284_NINIT); + ieee1284_write_data (port, 0xaa); + usleep (2); + ieee1284_write_data (port, 0x55); + usleep (2); + ieee1284_write_data (port, 0x00); + usleep (2); + ieee1284_write_data (port, 0xff); + usleep (2); + s = ieee1284_read_status (port) ^ S1284_INVERTED; /*Converted for PC-style */ + + s &= (S1284_BUSY | S1284_PERROR | S1284_SELECT | S1284_NFAULT); + + if (s != (S1284_BUSY | S1284_PERROR | S1284_SELECT | S1284_NFAULT)) + { + DBG (1, "%s: cpp_daisy: aa5500ff(%02x)\n", port->name, s); + return -1; + } + + ieee1284_write_data (port, 0x87); + usleep (2); + s = ieee1284_read_status (port) ^ S1284_INVERTED; /*Convert to PC-style */ + + s &= (S1284_BUSY | S1284_PERROR | S1284_SELECT | S1284_NFAULT); + + if (s != (S1284_SELECT | S1284_NFAULT)) + { + DBG (1, "%s: cpp_daisy: aa5500ff87(%02x)\n", port->name, s); + return -1; + } + + ieee1284_write_data (port, 0x78); + usleep (2); + ieee1284_write_control (port, C1284_NINIT); + ieee1284_write_data (port, cmd); + usleep (2); + ieee1284_frob_control (port, C1284_NSTROBE, C1284_NSTROBE); + usleep (1); + ieee1284_frob_control (port, C1284_NSTROBE, 0); + usleep (1); + s = ieee1284_read_status (port); + ieee1284_write_data (port, 0xff); + usleep (2); + + return s; +} + +/*Daisy chain deselect operation.*/ +void +daisy_deselect_all (struct parport *port) +{ + cpp_daisy (port, 0x30); +} + +/*Daisy chain select operation*/ +int +daisy_select (struct parport *port, int daisy, int mode) +{ + switch (mode) + { + /*For these modes we should switch to EPP mode: */ + case M1284_EPP: + case M1284_EPPSL: + case M1284_EPPSWE: + return cpp_daisy (port, 0x20 + daisy) & S1284_NFAULT; + /*For these modes we should switch to ECP mode: */ + case M1284_ECP: + case M1284_ECPRLE: + case M1284_ECPSWE: + return cpp_daisy (port, 0xd0 + daisy) & S1284_NFAULT; + /*Nothing was told for BECP in Daisy chain specification. + May be it's wise to use ECP? */ + case M1284_BECP: + /*Others use compat mode */ + case M1284_NIBBLE: + case M1284_BYTE: + case M1284_COMPAT: + default: + return cpp_daisy (port, 0xe0 + daisy) & S1284_NFAULT; + } +} + +/*Daisy chain assign address operation.*/ +int +assign_addr (struct parport *port, int daisy) +{ + return cpp_daisy (port, daisy); +} + +static int +OpenScanner (const char *scanner_path) +{ + int handle; + int caps; + + /*Scaner name was specified in config file?*/ + if (strlen(scanner_path) == 0) + return -1; + + for (handle = 0; handle < pl.portc; handle++) + { + if (strcmp (scanner_path, pl.portv[handle]->name) == 0) + break; + } + if (handle == pl.portc) /*No match found */ + return -1; + + /*Open port */ + if (ieee1284_open (pl.portv[handle], 0, &caps) != E1284_OK) + return -1; + + /*Claim port */ + if (ieee1284_claim (pl.portv[handle]) != E1284_OK) + return -1; + + /*Total chain reset. */ + daisy_deselect_all (pl.portv[handle]); + + /*Assign addresses. */ + assign_addr (pl.portv[handle], 0); /*Assume we have device first in chain. */ + + /*Select required device. For now - first in chain. */ + daisy_select (pl.portv[handle], 0, M1284_EPP); + + return handle; +} + +static void +CloseScanner (int handle) +{ + if (handle == -1) + return; + + daisy_deselect_all (pl.portv[handle]); + + ieee1284_release (pl.portv[handle]); + + ieee1284_close (pl.portv[handle]); +} |