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

hpsj5s.c

/* 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",
       V_MAJOR, V_MINOR, BUILD);

  /*Inform about supported version */
  if (version_code)
    *version_code = SANE_VERSION_CODE (V_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) 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) 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) 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) 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) 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) 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) 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]);
}

Generated by  Doxygen 1.6.0   Back to index