summaryrefslogtreecommitdiff
path: root/backend/hs2p-scsi.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/hs2p-scsi.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hs2p-scsi.c')
-rw-r--r--backend/hs2p-scsi.c2198
1 files changed, 2198 insertions, 0 deletions
diff --git a/backend/hs2p-scsi.c b/backend/hs2p-scsi.c
new file mode 100644
index 0000000..82640e9
--- /dev/null
+++ b/backend/hs2p-scsi.c
@@ -0,0 +1,2198 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 2007 Jeremy Johnson
+ This file is part of a SANE backend for Ricoh IS450
+ and IS420 family of HS2P Scanners using the SCSI controller.
+
+ 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. */
+
+#include <time.h>
+#include "hs2p.h"
+
+
+static SANE_String_Const
+print_devtype (SANE_Byte devtype)
+{
+ int i = devtype;
+ static SANE_String devtypes[] = {
+ "disk",
+ "tape",
+ "printer",
+ "processor",
+ "CD-writer",
+ "CD-drive",
+ "scanner",
+ "optical-drive",
+ "jukebox",
+ "communicator"
+ };
+
+ return (i >= 0 && i < NELEMS (devtypes)) ? devtypes[i] : "unknown-device";
+}
+static void
+print_bytes (const void *buf, size_t bufsize)
+{
+ const SANE_Byte *bp;
+ unsigned i;
+
+ for (i = 0, bp = buf; i < bufsize; i++, bp++)
+ DBG (DBG_error, "%3d: 0x%02x %d\n", i, *bp, *bp);
+}
+
+static void
+ScannerDump (HS2P_Scanner * s)
+{
+ int i;
+ HS2P_Info *info;
+ SANE_Device *sdev;
+
+ info = &s->hw->info;
+ sdev = &s->hw->sane;
+
+ DBG (DBG_info, "\n\n");
+ DBG (DBG_info, ">> ScannerDump:\n");
+ DBG (DBG_info, "SANE Device: '%s' Vendor: '%s' Model: '%s' Type: '%s'\n",
+ sdev->name, sdev->vendor, sdev->model, sdev->type);
+
+ DBG (DBG_info, "Type: '%s' Vendor: '%s' Product: '%s' Revision: '%s'\n",
+ print_devtype (info->devtype), info->vendor, info->product,
+ info->revision);
+
+ DBG (DBG_info, "Automatic Document Feeder: %s%s%s%s\n",
+ info->hasADF ? "Installed " : "Not Installed ",
+ info->hasSimplex ? "simplex" : "",
+ info->hasDuplex ? "duplex" : "",
+ info->hasARDF ? "reverse double-sided" : "");
+ DBG (DBG_info, "Endorser :%s\n",
+ info->hasEndorser ? " <Installed>" : " <Not Installed>");
+ DBG (DBG_info, "Image Processing Unit:%s\n",
+ info->hasIPU ? " <Installed>" : " <Not Installed>");
+ DBG (DBG_info, "Extended Board :%s\n",
+ info->hasXBD ? " <Installed>" : " <Not Installed>");
+
+ DBG (DBG_info, "\n");
+ DBG (DBG_info, "Image Composition Support\n");
+ DBG (DBG_info, "Line Art (B/W) Support : %s\n",
+ info->supports_lineart ? "Yes" : "No");
+ DBG (DBG_info, "Dithering (Halftone) Support: %s\n",
+ info->supports_dithering ? "Yes" : "No");
+ DBG (DBG_info, "Error Diffusion Support : %s\n",
+ info->supports_errordiffusion ? "Yes" : "No");
+ DBG (DBG_info, "Color Support : %s\n",
+ info->supports_color ? "Yes" : "No");
+ DBG (DBG_info, "4 Bit Gray Support : %s\n",
+ info->supports_4bitgray ? "Yes" : "No");
+ DBG (DBG_info, "5-8 Bit Gray Support : %s\n",
+ info->supports_8bitgray ? "Yes" : "No");
+
+ DBG (DBG_info, "Image Data processing:%s%s%s%s%s%s\n",
+ info->supports_whiteframing ? " <White Frame>" : "",
+ info->supports_blackframing ? " <Black Frame>" : "",
+ info->supports_edgeextraction ? " <Edge Extraction>" : "",
+ info->supports_noiseremoval ? " <Noise Filter>" : "",
+ info->supports_smoothing ? " <Smooth>" : "",
+ info->supports_linebolding ? " <Line Bolding>" : "");
+
+ DBG (DBG_info, "Image Compression:%s%s%s%s\n",
+ info->supports_MH ? " <MH support>" : "",
+ info->supports_MR ? " <MR support>" : "",
+ info->supports_MMR ? " <MMR support>" : "",
+ info->supports_MHB ? " <MH byte boundary support>" : "");
+ DBG (DBG_info, "Marker Recognition: %s\n",
+ info->supports_markerrecognition ? "<supported>" : "<not supported>");
+ DBG (DBG_info, "Size Recognition : %s\n",
+ info->supports_sizerecognition ? "<supported>" : "<not supported>");
+ DBG (DBG_info, "X Maximum Output Pixels = %d\n", info->xmaxoutputpixels);
+
+ /*
+ DBG (DBG_info, "Optional Features:%s%s%s%s\n",
+ info->canBorderRecog ? " <Border Recognition>" : "",
+ info->canBarCode ? " <BarCode Decoding>" : "",
+ info->canIcon ? " <Icon Generation>" : "",
+ info->canSection ? " <Section Support>" : "");
+ */
+
+ DBG (DBG_info, "Max bytes per scan-line: %d (%d pixels)\n",
+ info->xmaxoutputpixels / 8, info->xmaxoutputpixels);
+
+ DBG (DBG_info, "Basic resolution (X/Y) : %d/%d\n", info->resBasicX,
+ info->resBasicY);
+ DBG (DBG_info, "Maximum resolution (X/Y) : %d/%d\n", info->resMaxX,
+ info->resMaxY);
+ DBG (DBG_info, "Minimum resolution (X/Y) : %d/%d\n", info->resMinX,
+ info->resMinY);
+ DBG (DBG_info, "Standard Resolutions:\n");
+ for (i = 1; i <= info->resStdList[0]; i++)
+ DBG (DBG_info, " %d\n", info->resStdList[i]);
+
+ DBG (DBG_info,
+ "Window Width/Height (in basic res) %d/%d (%.2f/%.2f inches)\n",
+ info->winWidth, info->winHeight,
+ (info->resBasicX !=
+ 0) ? ((float) info->winWidth) / info->resBasicX : 0.0,
+ (info->resBasicY) ? ((float) info->winHeight) / info->resBasicY : 0.0);
+
+ /*
+ DBG (DBG_info, "Summary:%s%s%s\n",
+ info->canDuplex ? "Duplex Scanner" : "Simplex Scanner",
+ info->canACE ? " (ACE capable)" : "",
+ info->canCheckADF ? " (ADF Paper Sensor capable)" : "");
+ */
+
+ DBG (DBG_info, "Buffer Full Ratio = %#02x\n",
+ info->cxn.buffer_full_ratio);
+ DBG (DBG_info, "Buffer Empty Ratio = %#02x\n",
+ info->cxn.buffer_empty_ratio);
+ DBG (DBG_info, "Bus Inactive Limit = %#02x\n",
+ info->cxn.bus_inactive_limit[0] << 8 | info->cxn.
+ bus_inactive_limit[1]);
+ DBG (DBG_info, "Disconnect Time Limit = %#04x\n",
+ info->cxn.disconnect_time_limit[0] << 8 | info->cxn.
+ disconnect_time_limit[1]);
+ DBG (DBG_info, "Connect Time Limit = %#02x\n",
+ info->cxn.connect_time_limit[0] << 8 | info->cxn.
+ connect_time_limit[1]);
+ DBG (DBG_info, "Maximum Burst Size = %#04x\n",
+ info->cxn.maximum_burst_size[0] << 8 | info->cxn.
+ maximum_burst_size[1]);
+ DBG (DBG_info, "DTDC = %#02x\n", info->cxn.dtdc & 0x03);
+
+ DBG (DBG_info, "White Balance is %s\n",
+ info->white_balance == 1 ? "Absolute" : "Relative");
+ DBG (DBG_info, "Medium Wait Timer is <not supported>\n"); /* get_medium_wait_timer(fd) */
+ DBG (DBG_info, "Scan Wait Mode is %s\n",
+ info->scan_wait_mode == 0 ? "OFF" : "ON");
+ DBG (DBG_info, "Service Mode is in Select %s Mode\n",
+ info->service_mode == 0 ? "Self-Diagnostics" : "Optical Adjustment");
+
+ sprintf (info->inquiry_data, "Vendor: %s Product: %s Rev: %s %s%s\n",
+ info->vendor, info->product, info->revision,
+ info->hasADF && info->hasDuplex ? "Duplex Scanner" : "",
+ info->hasADF && info->hasSimplex ? "Simplex Scanner" : "");
+
+ DBG (DBG_info, "duplex_default=%d\n", info->default_duplex);
+ /*
+ DBG (DBG_info, "autoborder_default=%d\n", info->autoborder_default);
+ DBG (DBG_info, "batch_default=%d\n", info->batch_default);
+ DBG (DBG_info, "deskew_default=%d\n", info->deskew_default);
+ DBG (DBG_info, "check_adf_default=%d\n", info->check_adf_default);
+ DBG (DBG_info, "timeout_adf_default=%d\n", info->timeout_adf_default);
+ DBG (DBG_info, "timeout_manual_default=%d\n", info->timeout_manual_default);
+ DBG (DBG_info, "control_panel_default=%d\n", info->control_panel_default);
+ */
+
+ DBG (DBG_info, "bmu = %d\n", info->bmu);
+ DBG (DBG_info, "mud = %d\n", info->mud);
+ DBG (DBG_info, "white balance = %#0x\n", info->white_balance);
+ DBG (DBG_info, "adf control = %#0x\n", info->adf_control);
+ DBG (DBG_info, "adf mode control = %#0x\n", info->adf_mode_control);
+ DBG (DBG_info, "endorser control = %#0x\n", info->endorser_control);
+ DBG (DBG_info, "endorser string = %s\n", info->endorser_string);
+ DBG (DBG_info, "scan wait mode = %#0x\n", info->scan_wait_mode);
+ DBG (DBG_info, "service mode = %#0x\n", info->service_mode);
+
+ DBG (DBG_info, "BasicXRes = %d\n", info->resBasicX);
+ DBG (DBG_info, "BasicYRes = %d\n", info->resBasicY);
+
+ DBG (DBG_info, "XResStep = %d\n", info->resXstep);
+ DBG (DBG_info, "YResStep = %d\n", info->resYstep);
+
+ DBG (DBG_info, "MaxXres = %d\n", info->resMaxX);
+ DBG (DBG_info, "MaxYres = %d\n", info->resMaxY);
+
+ DBG (DBG_info, "MinXres = %d\n", info->resMinX);
+ DBG (DBG_info, "MinYres = %d\n", info->resMinY);
+
+ DBG (DBG_info, "Width = %d\n", info->winWidth);
+ DBG (DBG_info, "Height = %d\n", info->winHeight);
+
+ DBG (DBG_info, "<< ScannerDump\n");
+}
+static void
+print_vpd_info (struct inquiry_vpd_data *vbuf)
+{
+ DBG (DBG_info, "VPD IDENTIFIER C0H\n");
+ DBG (DBG_info, "[00] Peripheral %#02x\n", vbuf->devtype);
+ DBG (DBG_info, "[01] Page Code %#02x\n", vbuf->pagecode);
+ DBG (DBG_info, "[02] reserved %#02x\n", vbuf->byte2);
+ DBG (DBG_info, "[03] Page Length %#02x\n", vbuf->pagelength);
+ DBG (DBG_info, "[04] ADF ID %#02x\n", vbuf->adf_id);
+ DBG (DBG_info, "[05] Endorser ID %#02x\n", vbuf->end_id);
+ DBG (DBG_info, "[06] Image Processing Unit %#02x\n", vbuf->ipu_id);
+ DBG (DBG_info, "[07] Image Composition %#02x\n",
+ vbuf->imagecomposition);
+ DBG (DBG_info, "[08] Image Data Processing %lu\n",
+ _2btol (&vbuf->imagedataprocessing[0]));
+ DBG (DBG_info, "[10] Compression %#02x\n", vbuf->compression);
+ DBG (DBG_info, "[11] Marker Recognition %#02x\n",
+ vbuf->markerrecognition);
+ DBG (DBG_info, "[12] Size Recognition %#02x\n",
+ vbuf->sizerecognition);
+ DBG (DBG_info, "[13] reserved %#02x\n", vbuf->byte13);
+ DBG (DBG_info, "[14] X Maximum Output Pixel %lu\n",
+ _2btol (&vbuf->xmaxoutputpixels[0]));
+}
+static void
+print_jis_info (struct inquiry_jis_data *jbuf)
+{
+ DBG (DBG_info, "JIS IDENTIFIER F0H\n");
+ DBG (DBG_info, "[00] devtype %#02x\n", jbuf->devtype);
+ DBG (DBG_info, "[01] Page Code %#02x\n", jbuf->pagecode);
+ DBG (DBG_info, "[02] JIS Ver %#02x\n", jbuf->jisversion);
+ DBG (DBG_info, "[03] reserved1 %#02x\n", jbuf->reserved1);
+ DBG (DBG_info, "[04] Page Len %#02x\n", jbuf->alloclen);
+ DBG (DBG_info, "[05] BasicXRes %lu\n", _2btol (&jbuf->BasicRes.x[0]));
+ DBG (DBG_info, "[07] BasicYRes %lu\n", _2btol (&jbuf->BasicRes.y[0]));
+ DBG (DBG_info, "[09] Resolution step %#02x\n", jbuf->resolutionstep);
+ DBG (DBG_info, "[10] MaxXRes %lu\n", _2btol (&jbuf->MaxRes.x[0]));
+ DBG (DBG_info, "[12] MaxYRes %lu\n", _2btol (&jbuf->MaxRes.y[0]));
+ DBG (DBG_info, "[14] MinXRes %lu\n", _2btol (&jbuf->MinRes.x[0]));
+ DBG (DBG_info, "[16] MinYRes %lu\n", _2btol (&jbuf->MinRes.y[0]));
+ DBG (DBG_info, "[18] Std Res %#0x\n",
+ (jbuf->standardres[0] << 8) | jbuf->standardres[1]);
+ DBG (DBG_info, "[20] Win Width %lu\n", _4btol (&jbuf->Window.width[0])); /* Manual says 4787/12B3H pixels @400dpi = 12in */
+ DBG (DBG_info, "[24] Win Len %lu\n", _4btol (&jbuf->Window.length[0])); /* Manual says 6803/1A93H pixels @400dpi = 17in) */
+ DBG (DBG_info, "[28] function %#02x\n", jbuf->functions);
+ DBG (DBG_info, "[29] reserved %#02x\n", jbuf->reserved2);
+}
+
+/* 1-3-1 TEST UNIT READY
+ Byte0: | 0x00 |
+ Byte1: | 7-5 Logical Unit Number | Reserved |
+ Byte2: | Reserved |
+ Byte3: | Reserved |
+ Byte4: | Reserved |
+ Byte5: | 7-6 Vendor Unique | 5-2 Reserved | 1 Flag | 0 Link |
+*/
+static SANE_Status
+test_unit_ready (int fd)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> test_unit_ready\n");
+
+ memset (cmd, 0, sizeof (cmd));
+ cmd[0] = HS2P_SCSI_TEST_UNIT_READY;
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< test_unit_ready\n");
+ return (status);
+}
+
+/* 1-3-2 REQUEST SENSE
+ Byte0: | 0x00 |
+ Byte1: | 7-5 Logical Unit Number | Reserved |
+ Byte2: | Reserved |
+ Byte3: | Reserved |
+ Byte4: | Allocation Length |
+ Byte5: | 7-6 Vendor Unique | 5-2 Reserved | 1 Flag | 0 Link |
+*/
+
+#if 0
+static SANE_Status
+get_sense_data (int fd, SENSE_DATA * sense_data)
+{
+ SANE_Status status;
+ DBG (DBG_sane_proc, ">> get_sense_data\n");
+
+ static SANE_Byte cmd[6];
+ size_t len;
+
+ len = sizeof (*sense_data);
+ memset (sense_data, 0, len);
+ memset (cmd, 0, sizeof (cmd));
+
+ cmd[0] = HS2P_SCSI_REQUEST_SENSE;
+ cmd[4] = len;
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), sense_data, &len);
+
+ DBG (DBG_proc, "<< get_sense_data\n");
+ return (status);
+}
+#endif
+
+static SANE_Status
+print_sense_data (int dbg_level, SENSE_DATA * data)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ SANE_Byte *bp, *end;
+ SANE_Int i;
+
+ DBG (DBG_sane_proc, ">> print_sense_data\n");
+
+ bp = (SANE_Byte *) data;
+ end = bp + (SANE_Byte) sizeof (SENSE_DATA);
+ for (i = 0; bp < end; bp++, i++)
+ {
+ DBG (dbg_level, "Byte #%2d is %3d, 0x%02x\n", i, *bp, *bp);
+ }
+
+ DBG (dbg_level, "Valid=%1d, ErrorCode=%#x\n",
+ (data->error_code & 0x80) >> 7, data->error_code & 0x7F);
+ DBG (dbg_level, "Segment number = %d\n", data->segment_number);
+ DBG (dbg_level,
+ "F-mark=%1d, EOM=%1d, ILI=%1d, Reserved=%1d, SenseKey=%#x\n",
+ (data->sense_key & 0x80) >> 7, (data->sense_key & 0x40) >> 6,
+ (data->sense_key & 0x20) >> 5, (data->sense_key & 0x10) >> 4,
+ (data->sense_key & 0x0F));
+ DBG (dbg_level, "Information Byte = %lu\n", _4btol (data->information));
+ DBG (dbg_level, "Additional Sense Length = %d\n", data->sense_length);
+ DBG (dbg_level, "Command Specific Infomation = %lu\n",
+ _4btol (data->command_specific_information));
+ DBG (dbg_level, "Additional Sense Code = %#x\n", data->sense_code);
+ DBG (dbg_level, "Additional Sense Code Qualifier = %#x\n",
+ data->sense_code_qualifier);
+
+ DBG (DBG_proc, "<< print_sense_data\n");
+ return (status);
+}
+
+static struct sense_key *
+lookup_sensekey_errmsg (int code)
+{
+ int i;
+ struct sense_key *k = &sensekey_errmsg[0];
+
+ for (i = 0; i < 16; i++, k++)
+ if (k->key == code)
+ return k;
+ return NULL;
+}
+static struct ASCQ *
+lookup_ascq_errmsg (unsigned int code)
+{
+ unsigned int i;
+ struct ASCQ *k = &ascq_errmsg[0];
+
+ for (i = 0; i < 74; i++, k++)
+ if (k->codequalifier == code)
+ return k;
+ return NULL;
+}
+
+/* a sensible sense handler
+ arg is a pointer to the associated HS2P_Scanner structure
+
+ SENSE DATA FORMAT: 14 bytes bits[7-0]
+ Byte 0: [7]:valid [6-0]:Error Code
+ Byte 1: Segment Number
+ Byte 2: [7]: F-mark; [6]:EOM; [5]:ILI; [4]:reserved; [3-0]:Sense Key
+ Byte 3: Information Byte
+ Byte 4: Information Byte
+ Byte 5: Information Byte
+ Byte 6: Information Byte
+ Byte 7: Additional Sense Length (n-7)
+ Byte 8: Command Specific Information
+ Byte 9: Command Specific Information
+ Byte 10: Command Specific Information
+ Byte 11: Command Specific Information
+ Byte 12: Additional Sense Code
+ Byte 13: Additional Sense Code Qualifier
+*/
+static SANE_Status
+sense_handler (int __sane_unused__ scsi_fd, u_char * sense_buffer, void *sd)
+{
+ u_char sense, asc, ascq, EOM, ILI, ErrorCode, ValidData;
+ u_long MissingBytes;
+ char *sense_str = "";
+
+ struct sense_key *skey;
+ struct ASCQ *ascq_key;
+ SENSE_DATA *sdp = (SENSE_DATA *) sd;
+ SANE_Int i;
+ SANE_Status status = SANE_STATUS_INVAL;
+ SANE_Char print_sense[(16 * 3) + 1];
+
+ DBG (DBG_proc, ">> sense_handler\n");
+ if (DBG_LEVEL >= DBG_info)
+ print_sense_data (DBG_LEVEL, (SENSE_DATA *) sense_buffer);
+
+ /* store sense_buffer */
+ DBG (DBG_info, ">> copying %lu bytes from sense_buffer[] to sense_data\n",
+ (u_long) sizeof (SENSE_DATA));
+ memcpy (sdp, sense_buffer, sizeof (SENSE_DATA));
+ if (DBG_LEVEL >= DBG_info)
+ print_sense_data (DBG_LEVEL, sdp);
+
+ ErrorCode = sense_buffer[0] & 0x7F;
+ ValidData = (sense_buffer[0] & 0x80) != 0;
+ sense = sense_buffer[2] & 0x0f; /* Sense Key */
+ asc = sense_buffer[12]; /* Additional Sense Code */
+ ascq = sense_buffer[13]; /* Additional Sense Code Qualifier */
+ EOM = (sense_buffer[2] & 0x40) != 0; /* End Of Media */
+ ILI = (sense_buffer[2] & 0x20) != 0; /* Invalid Length Indicator */
+ MissingBytes = ValidData ? _4btol (&sense_buffer[3]) : 0;
+
+ DBG (DBG_sense,
+ "sense_handler: sense_buffer=%#x, sense=%#x, asc=%#x, ascq=%#x\n",
+ sense_buffer[0], sense, asc, ascq);
+ DBG (DBG_sense,
+ "sense_handler: ErrorCode %02x ValidData: %d "
+ "EOM: %d ILI: %d MissingBytes: %lu\n", ErrorCode, ValidData, EOM,
+ ILI, MissingBytes);
+
+ memset (print_sense, '\0', sizeof (print_sense));
+ for (i = 0; i < 16; i++)
+ sprintf (print_sense + strlen (print_sense), "%02x ", sense_buffer[i]);
+ DBG (DBG_sense, "sense_handler: sense=%s\n", print_sense);
+
+ if (ErrorCode != 0x70 && ErrorCode != 0x71)
+ {
+ DBG (DBG_error, "sense_handler: error code is invalid.\n");
+ return SANE_STATUS_IO_ERROR; /* error code is invalid */
+ }
+
+ skey = lookup_sensekey_errmsg (sense); /* simple sequential search */
+ DBG (DBG_sense, "sense_handler: sense_key=%#x '%s - %s'\n", skey->key,
+ skey->meaning, skey->description);
+
+ DBG (DBG_sense, "Looking up ascq=(%#x,%#x)=%#x\n", asc, ascq,
+ (asc << 8) | ascq);
+ ascq_key = lookup_ascq_errmsg ((asc << 8) | ascq); /* simple sequential search */
+ DBG (DBG_sense, "sense_handler: ascq=(%#x,%#x): %#x '%s'\n", asc, ascq,
+ ascq_key->codequalifier, ascq_key->description);
+
+ /* handle each sense key: Translate from HS2P message to SANE_STATUS_ message
+ * SANE_STATUS_GOOD, _ACCESS_DEINIED, _NO_MEM, _INVAL, _IO_ERROR, _DEVICE_BUSY,
+ * _EOF, _UNSUPPORTED, _CANCELLED, _JAMMED, _NO_DOCS, _COVER_OPEN
+ */
+ switch (sense)
+ {
+ case 0x00: /* no sense */
+ status = SANE_STATUS_GOOD;
+ break;
+ case 0x01: /* recovered error */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x02: /* not ready */
+ status = SANE_STATUS_DEVICE_BUSY;
+ break;
+ case 0x03: /* medium error */
+ status = SANE_STATUS_JAMMED;
+ break;
+ case 0x04: /* hardware error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x05: /* illegal request */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x06: /* unit attention */
+ status = SANE_STATUS_GOOD;
+ break;
+ case 0x07: /* data protect */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x08: /* blank check */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x09: /* vendor specific */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x0A: /* copy aborted */
+ status = SANE_STATUS_CANCELLED;
+ break;
+ case 0x0B: /* aborted command */
+ status = SANE_STATUS_CANCELLED;
+ break;
+ case 0x0C: /* equal */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x0D: /* volume overflow */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x0E: /* miscompare */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x0F: /* reserved */
+ status = SANE_STATUS_INVAL;
+ break;
+ }
+ if (ErrorCode == 0x70) /* Additional Sense Codes available */
+ switch ((asc << 8) | ascq)
+ {
+ case 0x0000: /* No additional Information */
+ status = SANE_STATUS_GOOD;
+ break;
+ case 0x0002: /* End of Medium */
+ status = SANE_STATUS_NO_DOCS;
+ break;
+ case 0x0005: /* End of Data */
+ status = SANE_STATUS_EOF;
+ break;
+ case 0x0400: /* LUN not ready */
+ status = SANE_STATUS_DEVICE_BUSY;
+ break;
+ case 0x0401: /* LUN becoming ready */
+ status = SANE_STATUS_DEVICE_BUSY;
+ break;
+ case 0x0403: /* LUN not ready. Manual intervention needed */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x0500: /* LUN doesn't respond to selection */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x0700: /* Multiple peripheral devices selected */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x1100: /* Unrecovered read error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x1101: /* Read retries exhausted */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x1501: /* Mechanical positioning error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x1A00: /* Parameter list length error */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2000: /* Invalid command operation code */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2400: /* Invalid field in CDB (check field pointer) */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2500: /* LUN not supported */
+ status = SANE_STATUS_UNSUPPORTED;
+ break;
+ case 0x2600: /* Invalid field in parameter list (check field pointer) */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2900: /* Power on, reset, or BUS DEVICE RESET occurred */
+ status = SANE_STATUS_GOOD;
+ break;
+ case 0x2A01: /* (MODE parameter changed) */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2C00: /* Command sequence error */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2C01: /* Too many windows specified */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x2C02: /* Invalid combination of windows specified */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x3700: /* (Rounded paramter) */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x3900: /* (Saving parameters not supported) */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x3A00: /* Medium not present */
+ status = SANE_STATUS_NO_DOCS;
+ break;
+ case 0x3B09: /* Read past end of medium */
+ status = SANE_STATUS_EOF;
+ break;
+ case 0x3B0B: /* Position past end of medium */
+ status = SANE_STATUS_EOF;
+ break;
+ case 0x3D00: /* Invalid bits in IDENTIFY message */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x4300: /* Message error */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x4500: /* Select/Reselect failure */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x4700: /* (SCSI parity error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x4800: /* Initiator detected error message received */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x4900: /* Invalid message error */
+ status = SANE_STATUS_INVAL;
+ break;
+ case 0x4B00: /* Data phase error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x5300: /* (Media Load/Eject failed) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6000: /* Lamp failure */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6001: /* Shading error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6002: /* White adjustment error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6010: /* Reverse Side Lamp Failure */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6200: /* Scan head positioning error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x6300: /* Document Waiting Cancel */
+ status = SANE_STATUS_CANCELLED;
+ break;
+ case 0x8000: /* (PSU over heate) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8001: /* (PSU 24V fuse down) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8002: /* (ADF 24V fuse down) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8003: /* (5V fuse down) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8004: /* (-12V fuse down) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8100: /* (ADF 24V power off) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8102: /* (Base 12V power off) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8103: /* Lamp cover open (Lamp 24V power off) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8104: /* (-12V power off) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8105: /* (Endorser 6V power off) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8106: /* SCU 3.3V power down error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8107: /* RCU 3.3V power down error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8108: /* OIPU 3.3V power down error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8200: /* Memory Error (Bus error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8210: /* Reverse-side memory error (Bus error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8300: /* (Image data processing LSI error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8301: /* (Interface LSI error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8302: /* (SCSI controller error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8303: /* (Compression unit error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8304: /* (Marker detect unit error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8400: /* Endorser error */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8500: /* (Origin Positioning error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8600: /* Mechanical Time Out error (Pick Up Roller error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8700: /* (Heater error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8800: /* (Thermistor error) */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ case 0x8900: /* ADF cover open */
+ status = SANE_STATUS_COVER_OPEN;
+ break;
+ case 0x8901: /* (ADF lift up) */
+ status = SANE_STATUS_COVER_OPEN;
+ break;
+ case 0x8902: /* Document jam error for ADF */
+ status = SANE_STATUS_JAMMED;
+ break;
+ case 0x8903: /* Document misfeed for ADF */
+ status = SANE_STATUS_JAMMED;
+ break;
+ case 0x8A00: /* (Interlock open) */
+ status = SANE_STATUS_COVER_OPEN;
+ break;
+ case 0x8B00: /* (Not enough memory) */
+ status = SANE_STATUS_NO_MEM;
+ break;
+ case 0x8C00: /* Size Detection failed */
+ status = SANE_STATUS_IO_ERROR;
+ break;
+ default: /* Should never get here */
+ status = SANE_STATUS_INVAL;
+ DBG (DBG_sense,
+ "sense_handler: 'Undocumented code': ascq=(%#x,%#x)\n",
+ asc & 0xFF00, ascq & 0x00FF);
+ break;
+ }
+
+
+ DBG (DBG_proc, "sense_handler %s: '%s'-'%s' '%s' return:%d\n", sense_str,
+ skey->meaning, skey->description, ascq_key->description, status);
+ return status;
+}
+
+/* VPD IDENTIFIER Page Code 0x00
+ * A list of all Page Codes supported by scanner is returned as data
+ * Byte0 => bit7-5: Peripheral Qualifier, bits4-0: Peripheral Device Type
+ * Byte1 => Page Code of CDB is set as Page Code 0
+ * Byte2 => Reserved
+ * Byte3 => Page Length is 2 because scanner supports just two page codes: C0H and F0H
+ * Byte4 => First Support Page Code
+ * Byte5 => Second Support Page Code
+*/
+#if 0
+static SANE_Status
+vpd_indentifier_00H (int fd)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> vpd_identifier_00H\n");
+
+ cmd[0] = HS2P_SCSI_REQUEST_SENSE;
+ memset (cmd, 0, sizeof (cmd));
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< vpd_identifier_00H\n");
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+vpd_identifier_C0H (int fd)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> vpd_identifier_C0H\n");
+
+ cmd[0] = HS2P_SCSI_REQUEST_SENSE;
+ memset (cmd, 0, sizeof (cmd));
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< vpd_identifier_C0H\n");
+ return (status);
+}
+#endif
+
+/* 1-3-3 INQUIRY : 6 bytes:
+ * Byte0 => 0x12
+ * Byte1 => bits7-5: Logical Unit number
+ * bits4-1: Reserved
+ * bit0: EVPD
+ * Byte2 => Page Code
+ * Byte3 => Reserved
+ * Byte4 => Allocation Length
+ * Byte5 => bits7-6: Vendor Unique
+ * bits5-2: Reserved
+ * bit1: Flag
+ * bit0: Link
+*/
+static SANE_Status
+inquiry (int fd, void *buf, size_t * buf_size, SANE_Byte evpd,
+ SANE_Byte page_code)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> inquiry\n");
+
+ memset (cmd, 0, sizeof (cmd));
+ cmd[0] = HS2P_SCSI_INQUIRY;
+ cmd[1] = evpd;
+ cmd[2] = page_code;
+/*cmd[3] Reserved */
+ cmd[4] = *buf_size;
+/*cmd[5] vendorunique+reserved+flag+link */
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
+
+ DBG (DBG_proc, "<< inquiry\n");
+ return (status);
+}
+
+/* 1-3-6 MODE SELECT -- sets various operation mode parameters for scanner */
+static SANE_Status
+mode_select (int fd, MP * settings)
+{
+ static struct
+ {
+ SELECT cmd; /* Mode page Select command */
+ MP mp; /* Hdr + Parameters */
+ } msc; /* Mode Select Command */
+ SANE_Status status;
+ size_t npages;
+
+ DBG (DBG_proc, ">> mode_select\n");
+
+ memset (&msc, 0, sizeof (msc)); /* Fill struct with zeros */
+ msc.cmd.opcode = HS2P_SCSI_MODE_SELECT; /* choose Mode Select Command */
+ msc.cmd.byte1 &= ~SMS_SP; /* unset bit0 SavePage to 0 */
+ msc.cmd.byte1 |= SMS_PF; /* set bit4 PageFormat to 1 */
+ npages = (settings->page.code == 2) ? 16 : 8;
+ msc.cmd.len = sizeof (msc.mp.hdr) + npages; /* either 4+8 or 4+20 */
+
+ memcpy (&msc.mp, settings, msc.cmd.len); /* Copy hdr+pages from Settings to msc.mp */
+ memset (&msc.mp.hdr, 0, sizeof (msc.mp.hdr)); /* make sure the hdr is all zeros */
+ /*
+ msc.hdr.data_len = 0x00;
+ msc.hdr.medium_type = 0x00;
+ msc.hdr.dev_spec = 0x00;
+ msc.hdr.blk_desc_len = 0x00;
+ */
+
+ /* Now execute the whole command */
+ if ((status =
+ sanei_scsi_cmd (fd, &msc, sizeof (msc.cmd) + msc.cmd.len, 0,
+ 0)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "ERROR: mode_select: %s\n", sane_strstatus (status));
+ DBG (DBG_error, "PRINTING CMD BLOCK:\n");
+ print_bytes (&msc.cmd, sizeof (msc.cmd));
+ DBG (DBG_error, "PRINTING MP HEADER:\n");
+ print_bytes (&msc.mp.hdr, sizeof (msc.mp.hdr));
+ DBG (DBG_error, "PRINTING MP PAGES:\n");
+ print_bytes (&msc.mp.page, msc.cmd.len);
+ }
+
+ DBG (DBG_proc, "<< mode_select\n");
+ return (status);
+}
+
+/* 1-3-7 MODE SENSE -- gets various operation mode parameters from scanner */
+static SANE_Status
+mode_sense (int fd, MP * buf, SANE_Byte page_code)
+{
+ SANE_Status status;
+ SENSE cmd; /* 6byte cmd */
+ MP msp; /* Mode Sense Page
+ * 4byte hdr + {2bytes +14 bytes}
+ * buffer to hold mode sense data gotten from scanner */
+
+ size_t nbytes;
+
+ DBG (DBG_proc, ">>>>> mode_sense: fd=%d, page_code=%#02x\n", fd, page_code);
+ nbytes = sizeof (msp);
+
+ DBG (DBG_info,
+ ">>>>> mode_sense: Zero'ing ModeSenseCommand msc and msp structures\n");
+
+ memset (&cmd, 0, sizeof (cmd)); /* Fill cmd struct with zeros */
+ memset (&msp, 0, sizeof (msp)); /* Fill msp struct with zeros */
+
+ /* set up Mode Sense Command */
+ DBG (DBG_info, ">>>>> mode_sense: Initializing Mode Sense cmd\n");
+ cmd.opcode = HS2P_SCSI_MODE_SENSE;
+ cmd.dbd &= ~(1 << 3); /* Disable Block Description (bit3) is set to 0 */
+ cmd.pc = (page_code & 0x3F); /* bits 5-0 */
+ cmd.pc &= ~(0x03 << 6); /* unset PC Field (bits7-6)
+ * 00 Curent Value is the only effective value
+ * 01 Changeable Value
+ * 10 Default Value
+ * 11 Saved Value */
+ /* cmd.len = ??? Allocation Length */
+
+ /* Now execute the whole command and store results in msc */
+ DBG (DBG_info, ">>>>> mode_sense: sanei_scsi_cmd\n");
+ DBG (DBG_info, ">>>>> cmd.opcode=%#0x cmd.dbd=%#02x, cmd.pc=%#02x\n",
+ cmd.opcode, cmd.dbd, cmd.pc);
+
+ nbytes = (page_code == 2) ? 20 : 12;
+ DBG (DBG_info,
+ ">>>>> sizeof(cmd)=%lu sizeof(msp)=%lu sizeof(hdr)=%lu sizeof(page)=%lu requesting %lu bytes\n",
+ (u_long) sizeof (cmd), (u_long) sizeof (msp),
+ (u_long) sizeof (msp.hdr), (u_long) sizeof (msp.page),
+ (u_long) nbytes);
+
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), &msp, &nbytes);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "ERROR mode_sense: sanei_scsi_cmd error \"%s\"\n",
+ sane_strstatus (status));
+ DBG (DBG_error,
+ ">>>>> mode sense: number of bytes received from scanner: %lu\n",
+ (u_long) nbytes);
+ DBG (DBG_error, "PRINTING CMD BLOCK:\n");
+ print_bytes (&cmd, sizeof (cmd));
+ DBG (DBG_error, "PRINTING MP HEADER:\n");
+ print_bytes (&msp.hdr, sizeof (msp.hdr));
+ DBG (DBG_error, "PRINTING MP PAGES:\n");
+ print_bytes (&msp.page, sizeof (msp.page));
+ }
+ else
+ {
+ /* nbytes = (page_code==2)? 14 : 6; */
+ DBG (DBG_info, ">> >> got %lu bytes from scanner\n", (u_long) nbytes);
+ nbytes -= 4; /* we won't copy 4 byte hdr */
+ DBG (DBG_info, ">>>>> copying from msp to calling function's buf\n"
+ ">>>>> msp.page_size=%lu bytes=%lu buf_size=%lu\n",
+ (u_long) sizeof (msp.page), (u_long) nbytes,
+ (u_long) sizeof (*buf));
+ memcpy (buf, &(msp.page), nbytes);
+ }
+
+ DBG (DBG_proc, "<<<<< mode_sense\n");
+ return (status);
+}
+
+static SANE_Status
+set_window (int fd, SWD * swd)
+{
+ static struct
+ {
+ struct set_window_cmd cmd;
+ struct set_window_data swd;
+ } win;
+ SANE_Status status;
+ static size_t wdl, tl; /*window descriptor length, transfer length */
+ DBG (DBG_proc, ">> set_window\n");
+
+ /* initialize our struct with zeros */
+ memset (&win, 0, sizeof (win));
+
+ /* fill in struct with opcode */
+ win.cmd.opcode = HS2P_SCSI_SET_WINDOW;
+
+ /* bytes 1-5 are reserved */
+
+ /* Transfer length is header + window data */
+ tl = sizeof (*swd);
+ _lto3b (tl, &win.cmd.len[0]); /* 8 + (2*320) = 648 */
+ DBG (DBG_info,
+ "set_window: SET WINDOW COMMAND Transfer Length = %lu (should be 648)\n",
+ (unsigned long) tl);
+
+ /* Copy data from swd (including 8-byte header) to win.swd */
+ DBG (DBG_info,
+ "set_window: COPYING %lu bytes from settings to Set Window Command (%lu)\n",
+ (u_long) sizeof (*swd), (u_long) sizeof (win.swd));
+ if (!memcpy (&(win.swd), swd, sizeof (*swd)))
+ {
+ DBG (DBG_error, "set_window: error with memcpy\n");
+ }
+
+ /* Set Window Data Header: 0-5:reserved; 6-7:Window Descriptor Lenght=640 */
+ wdl = sizeof (win.swd) - sizeof (win.swd.hdr);
+ _lto2b (wdl, &win.swd.hdr.len[0]);
+ DBG (DBG_info,
+ "set_window: SET WINDOW COMMAND Window Descriptor Length = %lu (should be 640)\n",
+ (unsigned long) wdl);
+
+ /* Now execute command */
+ DBG (DBG_info,
+ "set_window: calling sanei_scsi_cmd(%d,&win,%lu, NULL, NULL)\n", fd,
+ (u_long) sizeof (win));
+ status = sanei_scsi_cmd (fd, &win, sizeof (win), NULL, NULL);
+ /*
+ status = sanei_scsi_cmd2 (fd, &win.cmd, sizeof(win.cmd), &win.swd, sizeof(win.swd), NULL, NULL);
+ */
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "*********************\n");
+ DBG (DBG_error, "ERROR: set_window: %s\n", sane_strstatus (status));
+ DBG (DBG_error, "PRINTING SWD CMD BLK:\n");
+ print_bytes (&win.cmd, sizeof (win.cmd));
+ DBG (DBG_error, "PRINTING SWD HEADER:\n");
+ print_bytes (&win.swd.hdr, sizeof (win.swd.hdr));
+ DBG (DBG_error, "PRINTING SWD DATA[0]:\n");
+ print_bytes (&win.swd.data[0], sizeof (win.swd.data[0]));
+ DBG (DBG_error, "PRINTING SWD DATA[1]:\n");
+ print_bytes (&win.swd.data[1], sizeof (win.swd.data[1]));
+ DBG (DBG_error, "*********************\n");
+ }
+
+ DBG (DBG_proc, "<< set_window\n");
+ return (status);
+}
+
+static SANE_Status
+get_window (int fd, GWD * gwd)
+{
+ struct get_window_cmd cmd;
+ SANE_Status status;
+ static size_t gwd_size;
+
+ DBG (DBG_proc, ">> get_window\n");
+
+ gwd_size = sizeof (*gwd);
+ DBG (DBG_info, ">> get_window datalen = %lu\n", (unsigned long) gwd_size);
+
+ /* fill in get_window_cmd */
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR cmd */
+ cmd.opcode = HS2P_SCSI_GET_WINDOW;
+ cmd.byte1 &= ~0x01; /* unset single bit 0 */
+ cmd.win_id = 0x00; /* either 0 or 1 */
+ _lto3b (gwd_size, cmd.len); /* Transfer Length is byte length of DATA to be returned */
+
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), gwd, &gwd_size);
+
+ DBG (DBG_proc, "<< get_window, datalen = %lu\n", (unsigned long) gwd_size);
+ return (status);
+}
+static void
+print_window_data (SWD * buf)
+{
+ int i, j, k;
+ struct hs2p_window_data *data;
+ struct window_section *ws;
+
+ DBG (DBG_proc, ">> print_window_data\n");
+ DBG (DBG_info, "HEADER\n");
+ for (i = 0; i < 6; i++)
+ DBG (DBG_info, "%#02x\n", buf->hdr.reserved[i]);
+ DBG (DBG_info, "Window Descriptor Length=%lu\n\n", _2btol (buf->hdr.len));
+
+ for (i = 0; i < 2; i++)
+ {
+ data = &buf->data[i];
+ DBG (DBG_info, "Window Identifier = %d\n", data->window_id);
+ DBG (DBG_info, "AutoBit = %#x\n", data->auto_bit);
+ DBG (DBG_info, "X-Axis Resolution = %lu\n", _2btol (data->xres));
+ DBG (DBG_info, "Y-Axis Resolution = %lu\n", _2btol (data->yres));
+ DBG (DBG_info, "X-Axis Upper Left = %lu\n", _4btol (data->ulx));
+ DBG (DBG_info, "Y-Axis Upper Left = %lu\n", _4btol (data->uly));
+ DBG (DBG_info, "Window Width = %lu\n", _4btol (data->width));
+ DBG (DBG_info, "Window Length = %lu\n", _4btol (data->length));
+ DBG (DBG_info, "Brightness = %d\n", data->brightness);
+ DBG (DBG_info, "Threshold = %d\n", data->threshold);
+ DBG (DBG_info, "Contrast = %d\n", data->contrast);
+ DBG (DBG_info, "Image Composition = %#0x\n", data->image_composition);
+ DBG (DBG_info, "Bits per Pixel = %d\n", data->bpp);
+ DBG (DBG_info, "Halftone Code = %#0x\n", data->halftone_code);
+ DBG (DBG_info, "Halftone Id = %#0x\n", data->halftone_id);
+ DBG (DBG_info, "Byte29 = %#0x RIF=%d PaddingType=%d\n", data->byte29,
+ data->byte29 & 0x80, data->byte29 & 0x7);
+ DBG (DBG_info, "Bit Ordering = %lu\n", _2btol (data->bit_ordering));
+ DBG (DBG_info, "Compression Type = %#x\n", data->compression_type);
+ DBG (DBG_info, "Compression Arg = %#x\n", data->compression_arg);
+ for (j = 0; j < 6; j++)
+ DBG (DBG_info, "Reserved=%#x\n", data->reserved2[j]);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored1);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored2);
+ DBG (DBG_info, "Byte42 = %#x MRIF=%d Filtering=%d GammaID=%d\n",
+ data->byte42, data->byte42 & 0x80, data->byte42 & 0x70,
+ data->byte42 & 0x0F);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored3);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored4);
+ DBG (DBG_info, "Binary Filtering = %#x\n", data->binary_filtering);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored5);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored6);
+ DBG (DBG_info, "Automatic Separation = %#x\n",
+ data->automatic_separation);
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored7);
+ DBG (DBG_info, "Automatic Binarization = %#x\n",
+ data->automatic_binarization);
+ for (j = 0; j < 13; j++)
+ DBG (DBG_info, "Ignored = %#x\n", data->ignored8[j]);
+
+ for (k = 0; k < 8; k++)
+ {
+ ws = &data->sec[k];
+ DBG (DBG_info, "\n\n");
+ DBG (DBG_info, "SECTION %d\n", k);
+ DBG (DBG_info, "Section Enable Flat (sef bit) = %#x\n", ws->sef);
+ DBG (DBG_info, "ignored = %d\n", ws->ignored0);
+ DBG (DBG_info, "Upper Left X = %lu\n", _4btol (ws->ulx));
+ DBG (DBG_info, "Upper Left Y = %lu\n", _4btol (ws->uly));
+ DBG (DBG_info, "Width = %lu\n", _4btol (ws->width));
+ DBG (DBG_info, "Length = %lu\n", _4btol (ws->length));
+ DBG (DBG_info, "Binary Filtering = %#x\n", ws->binary_filtering);
+ DBG (DBG_info, "ignored = %d\n", ws->ignored1);
+ DBG (DBG_info, "Threshold = %#x\n", ws->threshold);
+ DBG (DBG_info, "ignored = %d\n", ws->ignored2);
+ DBG (DBG_info, "Image Composition = %#x\n", ws->image_composition);
+ DBG (DBG_info, "Halftone Id = %#x\n", ws->halftone_id);
+ DBG (DBG_info, "Halftone Code = %#x\n", ws->halftone_code);
+ for (j = 0; j < 7; j++)
+ DBG (DBG_info, "ignored = %d\n", ws->ignored3[j]);
+ }
+ }
+ DBG (DBG_proc, "<< print_window_data\n");
+}
+
+static SANE_Status
+read_data (int fd, void *buf, size_t * buf_size, SANE_Byte dtc, u_long dtq)
+{
+ static struct scsi_rs_scanner_cmd cmd;
+ SANE_Status status;
+ DBG (DBG_proc, ">> read_data buf_size=%lu dtc=0x%2.2x dtq=%lu\n",
+ (unsigned long) *buf_size, (int) dtc, dtq);
+ if (fd < 0)
+ {
+ DBG (DBG_error, "read_data: scanner is closed!\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR */
+ cmd.opcode = HS2P_SCSI_READ_DATA;
+ cmd.dtc = dtc;
+ _lto2b (dtq, cmd.dtq);
+ _lto3b (*buf_size, cmd.len);
+
+ DBG (DBG_info, "read_data ready to send scsi cmd\n");
+ DBG (DBG_info, "opcode=0x%2.2x, dtc=0x%2.2x, dtq=%lu, transfer len =%d\n",
+ cmd.opcode, cmd.dtc, _2btol (cmd.dtq), _3btol (cmd.len));
+
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), buf, buf_size);
+
+ if (status != SANE_STATUS_GOOD)
+ DBG (DBG_error, "read_data: %s\n", sane_strstatus (status));
+ DBG (DBG_proc, "<< read_data %lu\n", (unsigned long) *buf_size);
+ return (status);
+}
+
+#if 0
+static SANE_Status
+send_data (int fd, void *buf, size_t * buf_size)
+{
+ static struct scsi_rs_scanner_cmd cmd;
+ SANE_Status status;
+ DBG (DBG_proc, ">> send_data %lu\n", (unsigned long) *buf_size);
+
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR */
+ memcpy (&cmd, buf, sizeof (*buf)); /* Fill in our struct with set values */
+ cmd.opcode = HS2P_SCSI_SEND_DATA;
+ _lto3b (*buf_size, cmd.len);
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), buf, buf_size);
+
+ DBG (DBG_proc, "<< send_data %lu\n", (unsigned long) *buf_size);
+ return (status);
+}
+#endif
+
+static SANE_Bool
+is_valid_endorser_character (char c)
+{
+ int i = (int) c;
+ /* 44 characters can be printed by endorser */
+
+ if (i >= 0x30 && i <= 0x3A)
+ return SANE_TRUE; /* 0123456789: */
+ if (i == 0x23)
+ return SANE_TRUE; /* # */
+ if (i == 0x27)
+ return SANE_TRUE; /* ` */
+ if (i >= 0x2C && i <= 0x2F)
+ return SANE_TRUE; /* '-./ */
+ if (i == 0x20)
+ return SANE_TRUE; /* space */
+ if (i >= 0x41 && i <= 0x5A)
+ return SANE_TRUE; /* ABCDEFGHIJKLMNOPQRSTUVWXYZ <spaces> */
+ if (i >= 0x61 && i <= 0x7A)
+ return SANE_TRUE; /* abcdefghijklmnopqrstuvwxyz <spaces> */
+
+ return SANE_FALSE;
+}
+
+static SANE_Status
+set_endorser_string (int fd, SANE_String s)
+{
+ struct
+ {
+ struct scsi_rs_scanner_cmd cmd;
+ SANE_Byte endorser[19];
+ } out;
+ char *t;
+ int i, len;
+
+ SANE_Status status;
+ DBG (DBG_proc, ">> set_endorser_string %s\n", s);
+
+ for (i = 0, t = s; *t != '\0' && i < 19; i++)
+ {
+ DBG (DBG_info, "CHAR=%c\n", *t);
+ if (!is_valid_endorser_character (*t++))
+ return SANE_STATUS_INVAL;
+ }
+ len = strlen (s);
+
+ memset (&out, 0, sizeof (out)); /* CLEAR */
+ out.cmd.opcode = HS2P_SCSI_SEND_DATA; /* 2AH */
+ out.cmd.dtc = 0x80; /* Endorser Data */
+ _lto3b (len, &out.cmd.len[0]); /* 19 bytes max */
+ memset (&out.endorser[0], ' ', 19); /* fill with spaces */
+ memcpy (&out.endorser[0], s, len);
+
+ status = sanei_scsi_cmd (fd, &out, sizeof (out), NULL, NULL);
+
+
+ DBG (DBG_proc, "<< set_endorser_string s=\"%s\" len=%d\n", s, len);
+ return (status);
+}
+
+static SANE_Status
+hs2p_send_gamma (HS2P_Scanner * s)
+{
+ SANE_Status status;
+ struct
+ {
+ struct scsi_rs_scanner_cmd cmd;
+ SANE_Byte gamma[2 + GAMMA_LENGTH];
+ } out;
+ int i;
+ size_t len = sizeof (out.gamma);
+
+ DBG (DBG_proc, ">> teco_send_gamma\n");
+
+ memset (&out, 0, sizeof (out)); /* CLEAR */
+ out.cmd.opcode = HS2P_SCSI_SEND_DATA; /* 2AH */
+ out.cmd.dtc = 0x03; /* Gamma Function Data */
+ _lto3b (len, &out.cmd.len[0]); /* 19 bytes max */
+ out.gamma[0] = 0x08; /* Gamma ID for Download table */
+ out.gamma[1] = 0x08; /* The Number of gray scale (M) = 8 */
+ for (i = 2; i < 2 + GAMMA_LENGTH; i++)
+ {
+ out.gamma[i] = s->gamma_table[i];
+ }
+ status = sanei_scsi_cmd (s->fd, &out, sizeof (out), NULL, NULL);
+
+ DBG (DBG_proc, "<< teco_send_gamma\n");
+ return (status);
+}
+
+#if 0
+static SANE_Status
+clear_maintenance_data (int fd, int code, char XorY, int number)
+{
+ struct
+ {
+ struct scsi_rs_scanner_cmd cmd;
+ char string[20];
+ } out;
+
+ SANE_Status status;
+ DBG (DBG_proc, ">> set_maintenance data\n");
+
+ memset (&out, 0, sizeof (out)); /* CLEAR */
+ out.cmd.opcode = HS2P_SCSI_SEND_DATA; /* 2AH */
+ out.cmd.dtc = 0x85; /* Maintenance Data */
+ _lto3b (20, out.cmd.len); /* 20 bytes */
+ switch (code)
+ {
+ case 1:
+ strcpy (out.string, "EEPROM ALL ALL RESET");
+ break;
+ case 2:
+ strcpy (out.string, "EEPROM ALL RESET");
+ break;
+ case 3:
+ strcpy (out.string, "ADF RESET");
+ break;
+ case 4:
+ strcpy (out.string, "FLATBED RESET");
+ break;
+ case 5:
+ strcpy (out.string, "LAMP RESET");
+ break;
+ case 6:
+ sprintf (out.string, "EEPROM ADF %c %+4.1d", XorY, number);
+ break;
+ case 7:
+ sprintf (out.string, "EEPROM BOOK %c %4.1d", XorY, number);
+ break;
+ case 8:
+ sprintf (out.string, "WHITE ADJUST DATA %3d", number);
+ break;
+ case 9:
+ strcpy (out.string, "EEPROM FIRST WHITE ODD");
+ break;
+ case 10:
+ strcpy (out.string, "EEPROM FIRST WHITE EVEN");
+ break;
+ case 11:
+ strcpy (out.string, "R ADF RESET");
+ break;
+ case 12:
+ strcpy (out.string, "R LAMP RESET");
+ break;
+ case 13:
+ sprintf (out.string, "EEPROM R ADF %c %4.1d", XorY, number);
+ break;
+ case 14:
+ strcpy (out.string, "ENDORSER RESET");
+ break;
+ }
+ status = sanei_scsi_cmd (fd, &out, sizeof (out), NULL, NULL);
+
+ DBG (DBG_proc, "<< set_maintenance data\n");
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+read_halftone_mask (int fd, SANE_Byte halftone_id, void *buf,
+ size_t * buf_size)
+{
+ static struct scsi_rs_scanner_cmd cmd;
+ SANE_Status status;
+ SANE_Int len;
+ DBG (DBG_proc, ">> read_halftone_mask\n");
+
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR */
+ cmd.opcode = HS2P_SCSI_READ_DATA;
+ cmd.dtc = DATA_TYPE_HALFTONE;
+ _lto2b (halftone_id, cmd.dtq);
+
+ /* Each cell of an NxM dither pattern is 1 byte from the set {2,3,4,6,8,16} */
+ switch (halftone_id)
+ {
+ case 0x01:
+ len = 32;
+ break; /* 8x4, 45 degree */
+ case 0x02:
+ len = 36;
+ break; /* 6x6, spiral */
+ case 0x03:
+ len = 16;
+ break; /* 4x4, spiral */
+ case 0x04:
+ len = 64;
+ break; /* 8x8, 90 degree */
+ case 0x05:
+ len = 70;
+ break; /* 70 lines */
+ case 0x06:
+ len = 95;
+ break; /* 95 lines */
+ case 0x07:
+ len = 180;
+ break; /* 180 lines */
+ case 0x08:
+ len = 128;
+ break; /* 16x8, 45 degree */
+ case 0x09:
+ len = 256;
+ break; /* 16x16, 90 degree */
+ case 0x0A:
+ len = 64;
+ break; /* 8x8, Bayer */
+ default:
+ return SANE_STATUS_INVAL; /* Reserved */
+ }
+
+ _lto3b (len, cmd.len);
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), buf, buf_size);
+
+ DBG (DBG_proc, "<< read_halftone_mask\n");
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+set_halftone_mask (int fd, SANE_Byte halftone_id, void *buf,
+ size_t * buf_size)
+{
+ static struct scsi_rs_scanner_cmd cmd;
+ SANE_Status status;
+ DBG (DBG_proc, ">> set_halftone_mask\n");
+
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR */
+ cmd.opcode = HS2P_SCSI_READ_DATA;
+ cmd.dtc = DATA_TYPE_HALFTONE;
+ _lto2b (halftone_id, cmd.dtq);
+
+ /* Each cell of an NxM dither pattern is 1 byte from the set {2,3,4,6,8,16}
+ * 0x80, 0x81 are User definable custom dither patterns
+ */
+ if (halftone_id != 0x80 && halftone_id != 0x81)
+ return SANE_STATUS_INVAL;
+
+ _lto3b (*buf_size, cmd.len);
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), buf, buf_size);
+
+ DBG (DBG_proc, "<< set_halftone_mask\n");
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+read_gamma_function (int fd)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ return (status);
+}
+
+static SANE_Status
+read_endorser_data (int fd)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ return (status);
+}
+
+static SANE_Status
+read_size_data (int fd)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+read_maintenance_data (int fd)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ return (status);
+}
+#endif
+
+/* Bit0: is 0 if document on ADF; else 1
+ * Bit1: is 0 if ADF cover is closed; else 1
+ * Bit2: reserved
+ * Bits7-3: reserved
+*/
+
+
+#if 0
+static SANE_Status
+read_adf_status (int fd, SANE_Byte * adf_status_byte)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ struct scsi_rs_scanner_cmd cmd;
+ static size_t len = 1;
+
+ DBG (DBG_proc, ">> read_adf_status\n");
+
+ memset (&cmd, 0, sizeof (cmd));
+ cmd.opcode = HS2P_SCSI_READ_DATA;
+ cmd.dtc = DATA_TYPE_ADF_STATUS;
+ _lto3b (0x01, cmd.len); /* convert 0x01 into 3-byte Transfer Length */
+ if ((status =
+ sanei_scsi_cmd (fd, &cmd, sizeof (cmd), adf_status_byte,
+ &len)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "read_adf_status ERROR: %s\n", sane_strstatus (status));
+ }
+ DBG (DBG_proc, "<< read_adf_status\n");
+ return (status);
+}
+#endif
+
+/*
+ * read_ipu_photoletter_parameters
+ * read_ipu_threshold_parameters
+ * read_sensor_data (WHAT DATA TYPE CODE?)
+*/
+/* SEND CMD */
+/*
+ * send_halftone_mask
+ * send_gamma_function
+ * send_endorser_data
+ * send_maintenance_data
+ * EPROM All Clear
+ * EPROM Counter Clear
+ * ADF Counter Clear
+ * Flatbed Counter Clear
+ * Lamp Counter Clear
+ * ADF Register Data
+ * Flatbed Register Data
+ * White Adjustment Data
+ * White level first Data (ODD)
+ * White level first Data (EVEN)
+ * Reverse side ADF Counter Clear
+ * Reverse side Lamp Counter Clear
+ * Reverse side ADF Register Data
+ * Endorser Character Counter Clear
+ * send_ipu_parameters
+*/
+
+/* OBJECT POSITION */
+/* GET DATA BUFFER STATUS */
+
+/* 1-3-4 MODE SELECT */
+
+/* 1-3-5 Reserve Unit: 0x16
+ * 1-3-6 Release Unit: 0x17
+*/
+static SANE_Status
+unit_cmd (int fd, SANE_Byte opcode)
+{
+ static struct
+ {
+ SANE_Byte opcode; /* 16H: Reserve Unit 17H: Release Unit */
+ SANE_Byte byte1; /* 7-5: LUN; 4: 3rd Party; 3-1: 3rd Party Device; 0: Reserved */
+ SANE_Byte reserved[3];
+ SANE_Byte control; /* 7-6: Vendor Unique; 5-2: Reserved; 1: Flag; 0: Link */
+ } cmd;
+
+ SANE_Byte LUN = (0x00 & 0x07) << 5;
+ SANE_Status status;
+ DBG (DBG_proc, ">> unit_cmd\n");
+
+ cmd.opcode = opcode;
+ cmd.byte1 = LUN & 0xE1; /* Mask=11100001 3rd Party and 3rd Party Device must be 0 */
+ memset (&cmd, 0, sizeof (cmd));
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< unit_cmd\n");
+ return (status);
+
+}
+
+/* The OBJECT POSITION command is used for carriage control or
+ * document feed and eject with ADF
+ *
+ * Position Function: Byte1 bits2-0
+ * 000 Unload instructs document eject
+ * 001 Load instructs document feed to scan start position
+ * 010 Absolute Positioning - instructs carriage to move to carriage lock position
+ * The carriage moves in the Y-axis direction as the amount set in Count when
+ * count>0
+ * (Not supported in IS420)
+ *
+*/
+static SANE_Status
+object_position (int fd, int load)
+{
+ static struct scsi_object_position_cmd cmd;
+ SANE_Status status;
+ DBG (DBG_proc, ">> object_position\n");
+
+ /* byte 0 opcode
+ * byte 1 position function
+ * bytes 2-4 reserved
+ * bytes 5-8 reserved
+ * byte 9 control
+ */
+
+
+ memset (&cmd, 0, sizeof (cmd));
+ cmd.opcode = HS2P_SCSI_OBJECT_POSITION;
+ if (load)
+ cmd.position_func = OBJECT_POSITION_LOAD;
+ else
+ cmd.position_func = OBJECT_POSITION_UNLOAD;
+
+
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< object_position\n");
+ return (status);
+}
+
+static SANE_Status
+get_data_status (int fd, STATUS_DATA * dbs)
+{
+ static GET_DBS_CMD cmd;
+ static STATUS_BUFFER buf; /* hdr + data */
+ size_t bufsize = sizeof (buf);
+ SANE_Status status;
+ DBG (DBG_proc, ">> get_data_status %lu\n", (unsigned long) bufsize);
+
+ /* Set up GET DATA BUFFER STATUS cmd */
+ memset (&cmd, 0, sizeof (cmd)); /* CLEAR cmd */
+ cmd.opcode = HS2P_SCSI_GET_BUFFER_STATUS;
+ cmd.wait &= ~0x01; /* unset Wait bit0 */
+ _lto2b (bufsize, cmd.len);
+
+ /* Now execute cmd, and put returned results in buf */
+ status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), &buf, &bufsize);
+
+ /* Now copy from buf.data to dbs */
+ memcpy (dbs, &buf.data, sizeof (*dbs));
+
+ if (status == SANE_STATUS_GOOD &&
+ ((unsigned int) _3btol (buf.hdr.len) <= sizeof (*dbs)
+ || _3btol (buf.data.filled) == 0))
+ {
+ DBG (DBG_info, "get_data_status: busy\n");
+ status = SANE_STATUS_DEVICE_BUSY;
+ }
+ DBG (DBG_proc, "<< get_data_status %lu\n", (unsigned long) bufsize);
+ return (status);
+}
+
+/* 1-3-7 MODE SENSE */
+/* 1-3-8 SCAN */
+
+/* 1-3-9 Receive Diagnostic
+ * Byte0: 1CH
+ * Byte1: 7-5 LUN; 4-0: reserved
+ * Byte2: Reserved
+ * Byte3-4: Allocation Length
+ * Byte5: 7-6: Vendor Unique; 5-2: Reserved; 1: Flag; 0: Link
+ *
+ * This command is treated as a dummy command
+ * Return GOOD unless there is an error in command in which case it returns CHECK
+*/
+
+/*
+* The IS450 performs 7 self-diagnostics tests
+* 1) Home position error check
+* 2) Exposure lamp error check
+* 3) White level error check
+* 4) Document table error check
+* 5) SCU error check
+* 6) RCU error check
+* 7) Memory error check
+*
+* and uses the lights on the scanner to indicate the result
+*
+* PowerOn MachineBusy DocumentInPlace Error
+* (green) (green) (green) (red)
+*
+* SCU error check Blinking Blinking
+* RCU error check Blinking On Blinking
+* Home position error check Blinking Blinking Blinking On
+* Exposure lamp error check Blinking Blinking On On
+* White level error check Blinking Blinking
+* Memory Error (Simplex) Blinking
+* Memory Error (Duplex) Blinking
+*
+*/
+#if 0
+static SANE_Status
+receive_diagnostic (int fd)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> receive_diagnostic\n");
+
+ cmd[0] = HS2P_SCSI_RECEIVE_DIAGNOSTICS;
+ memset (cmd, 0, sizeof (cmd));
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< receive_diagnostic\n");
+ return (status);
+}
+#endif
+
+/* 1-3-10 Send Diagnostic
+ * Byte0: 1DH
+ * Byte1: 7-5 LUN; 4: PF; 3: Reserved; 2: S-Test; 1: DevOfl; 0: U-Ofl
+ * Byte2: Reserved
+ * Byte3-4: Parameter List Length
+ * Byte5: 7-6: Vendor Unique; 5-2: Reserved; 1: Flag; 0: Link
+ * This command executes self-diagnostic and optical-adjustment
+ * PF, DevOfl, and Parameter List Length must be 0 or CHECK condition is returned.
+*/
+#if 0
+static SANE_Status
+send_diagnostic (int fd)
+{
+ static SANE_Byte cmd[6];
+ SANE_Status status;
+ DBG (DBG_proc, ">> send_diagnostic\n");
+
+ cmd[0] = HS2P_SCSI_SEND_DIAGNOSTICS;
+ cmd[1] = 0x00 & (1 << 2) & 0xED; /* Set Self-Test bit and clear PF, DevOfl bits */
+ cmd[3] = 0x00;
+ cmd[4] = 0x00; /* Parameter list (bytes3-4) must be 0x00 */
+ memset (cmd, 0, sizeof (cmd));
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (DBG_proc, "<< send_diagnostic\n");
+ return (status);
+}
+#endif
+
+
+/* 1-3-8 SCAN command is used to instruct scanner to start scanning */
+static SANE_Status
+trigger_scan (HS2P_Scanner * s)
+{
+ static struct
+ {
+ START_SCAN cmd;
+ SANE_Byte wid[2]; /* scanner supports up to 2 windows */
+ } scan;
+ SANE_Status status;
+ DBG (DBG_proc, ">> trigger scan\n");
+
+ memset (&scan, 0, sizeof (scan)); /* CLEAR scan */
+ scan.cmd.opcode = HS2P_SCSI_START_SCAN;
+ /* Transfer length is the byte length of Window List transferred
+ * Window List is a list of Window Identifier created by SET WINDOW command
+ * Since only 1 Window is supported by SCAN command, 0 or 1 is used for Window Identifier
+ * and 1 or 2 for length
+ status = sanei_scsi_cmd (s->fd, &trigger, sizeof (trigger), &window_id_list[0], &wl_size);
+ */
+ scan.cmd.len = (s->val[OPT_DUPLEX].w == SANE_TRUE) ? 2 : 1;
+
+ DBG (DBG_info, "trigger_scan: sending %d Window Id to scanner\n",
+ scan.cmd.len);
+ status =
+ sanei_scsi_cmd (s->fd, &scan, sizeof (scan.cmd) + scan.cmd.len, NULL,
+ NULL);
+
+ DBG (DBG_proc, "<< trigger scan\n");
+ return (status);
+}
+
+#define MAX_WAITING_TIME 15
+static SANE_Status
+hs2p_wait_ready (HS2P_Scanner * s)
+{
+ STATUS_DATA dbs; /* Status Buffer Status DATA */
+ time_t now, start;
+ SANE_Status status;
+
+ start = time (NULL);
+
+ while (1)
+ {
+ status = get_data_status (s->fd, &dbs);
+
+ switch (status)
+ {
+ default:
+ /* Ignore errors while waiting for scanner to become ready.
+ Some SCSI drivers return EIO while the scanner is
+ returning to the home position. */
+ DBG (DBG_error, "scsi_wait_ready: get datat status failed (%s)\n",
+ sane_strstatus (status));
+ /* fall through */
+ case SANE_STATUS_DEVICE_BUSY:
+ now = time (NULL);
+ if (now - start >= MAX_WAITING_TIME)
+ {
+ DBG (DBG_error,
+ "hs2p_wait_ready: timed out after %lu seconds\n",
+ (u_long) (now - start));
+ return SANE_STATUS_INVAL;
+ }
+ break;
+
+ case SANE_STATUS_GOOD:
+ DBG (DBG_proc, "hs2p_wait_ready: %d bytes ready\n",
+ _3btol (dbs.filled));
+ return status;
+ break;
+ }
+ usleep (1000000); /* retry after 100ms */
+ }
+ return SANE_STATUS_INVAL;
+}
+
+
+/* MODE PAGES GET/SET */
+static SANE_Status
+connection_parameters (int fd, MP_CXN * settings, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_CXN buf;
+ size_t nbytes;
+ DBG (DBG_proc, ">> connection_parameters\n");
+ nbytes = sizeof (buf);
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET connection_parameters >> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf, (SANE_Byte) PAGE_CODE_CONNECTION);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "get_connection_parameters: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ memcpy (settings, &buf, nbytes);
+ }
+ else
+ { /* SET */
+ DBG (DBG_info, ">> SET connection_parameters >> calling mode_select\n");
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ memcpy (&buf, settings, nbytes);
+ /* Make sure calling function didn't change these bytes */
+ memset (&buf.hdr, 0, sizeof (buf.hdr)); /* Make sure 4bytes are 0 */
+ buf.code = PAGE_CODE_CONNECTION; /* bits5-0: Page Code 02H */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x0E; /* This is the only page with 14 bytes */
+
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_connection_parameters: MODE_SELECT failed with status=%d\n",
+ status);
+ return (-1);
+ }
+ }
+ DBG (DBG_proc, "<< connection_parameters\n");
+ return (status);
+}
+
+static SANE_Status
+get_basic_measurement_unit (int fd, SANE_Int * bmu, SANE_Int * mud)
+{
+ SANE_Status status;
+ MP_SMU buf;
+
+ DBG (DBG_proc, ">> get_basic_measurement_unit: fd=\"%d\"\n", fd);
+
+ status =
+ mode_sense (fd, (MP *) & buf,
+ (SANE_Byte) PAGE_CODE_SCANNING_MEASUREMENTS);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_basic_measurement_unit: MODE_SELECT failed with status=%d\n",
+ status);
+ return (SANE_STATUS_INVAL);
+ }
+ *bmu = buf.bmu;
+ *mud = ((buf.mud[0] << 8) | buf.mud[1]);
+
+ DBG (DBG_proc, "<< get_basic_measurement_unit: bmu=%d mud=%d\n", *bmu,
+ *mud);
+ return (status);
+}
+
+static SANE_Status
+set_basic_measurement_unit (int fd, SANE_Byte bmu)
+{
+ MP_SMU buf; /* Mode Page Scanning Measurements Page Code */
+ SANE_Status status;
+ SANE_Int mud;
+ size_t bufsize = sizeof (buf);
+
+ DBG (DBG_proc, ">> set_basic_measurement_unit: %d\n", bmu);
+
+ /* Set up buf */
+ memset (&buf, 0, bufsize); /* CLEAR buf */
+ buf.code = PAGE_CODE_SCANNING_MEASUREMENTS; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+
+ buf.bmu = bmu; /* Power on default is POINTS */
+ mud = (bmu == INCHES) ? DEFAULT_MUD : 1;
+ DBG (DBG_info, "SET_BASIC_MEASUREMENT_UNIT: bmu=%d mud=%d\n", bmu, mud);
+ _lto2b (mud, &buf.mud[0]); /* buf.mud[0] = (mud >> 8) & 0xff; buf.mud[1] = (mud & 0xff); */
+
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_basic_measurement_unit: MODE_SELECT failed with status=%d\n",
+ status);
+ status = SANE_STATUS_INVAL;
+ }
+
+ DBG (DBG_proc,
+ "<< set_basic_measurement_unit: opcode=%d len=%d bmu=%d mud=%ld\n",
+ buf.code, buf.len, buf.bmu, _2btol (&buf.mud[0]));
+ return (status);
+}
+
+static SANE_Status
+adf_control (int fd, SANE_Bool flag, SANE_Byte * adf_control,
+ SANE_Byte * adf_mode, SANE_Byte * mwt)
+{
+ SANE_Status status;
+ MP_ADF buf;
+ size_t bufsize = sizeof (buf);
+
+ DBG (DBG_proc, ">> adf_control\n");
+
+ memset (&buf, 0, bufsize); /* Fill struct with zeros */
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET ADF_control>> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf, (SANE_Byte) PAGE_CODE_ADF_CONTROL);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "get_adf_control: MODE_SELECT failed\n");
+ return (status);
+ }
+ *adf_control = buf.adf_control;
+ *adf_mode = buf.adf_mode_control;
+ *mwt = buf.medium_wait_timer;
+ }
+ else
+ { /* SET */
+ /* Fill in struct then hand off to mode_select */
+ buf.code = PAGE_CODE_ADF_CONTROL; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+ /* Byte2: adf_control: 7-2:reserved; 1-0:adf_control: Default 00H Flatbed, 01H Simplex, 02H Duplex */
+ /* Byte3: adf_mode_control: 7-3:reserved; 2: Prefeed Mode: 0 invalid, 1 valid; 1-0: ignored */
+ /* Byte4: medium_wait_timer: timeout period. Not supported */
+ buf.adf_control = (*adf_control & 0x03);
+ buf.adf_mode_control = (*adf_mode & 0x04);
+ buf.medium_wait_timer = *mwt;
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_adf_control: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ }
+ DBG (DBG_proc, ">> adf_control\n");
+ return (status);
+}
+
+static SANE_Status
+white_balance (int fd, int *val, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_WhiteBal buf; /* White Balance Page Code */
+ size_t bufsize = sizeof (buf);
+
+ memset (&buf, 0, bufsize);
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_proc, ">> GET white_balance>> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf, (SANE_Byte) PAGE_CODE_WHITE_BALANCE);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "get_white_balance: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ *val = buf.white_balance;
+ }
+ else
+ { /* SET */
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ buf.code = PAGE_CODE_WHITE_BALANCE; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+ buf.white_balance = *val; /* Power on default is RELATIVE_WHITE */
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_white_balance: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ }
+ DBG (DBG_proc, "<< white balance: buf.white_balance=%#02x\n",
+ buf.white_balance);
+ return (status);
+}
+
+#if 0
+static SANE_Int
+lamp_timer (int fd, int val, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_LampTimer buf; /* Lamp Timer Page Code */
+
+ DBG (DBG_proc, ">> lamp timer\n");
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET lamp_timer>> calling mode_sense\n");
+ if ((status =
+ mode_sense (fd, (MP *) & buf,
+ (SANE_Byte) PAGE_CODE_LAMP_TIMER_SET)) !=
+ SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "get_lamp_timer: MODE_SELECT failed\n");
+ return (-1);
+ }
+ }
+ else
+ { /* SET */
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ buf.code = PAGE_CODE_LAMP_TIMER_SET; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+ buf.time_on = val; /* time lamp has been on */
+ if ((status = mode_select (fd, (MP *) & buf)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_lamp_timer: MODE_SELECT failed with status=%d\n", status);
+ return (-1);
+ }
+ }
+ DBG (DBG_proc, "<< lamp timer\n");
+ return (buf.time_on);
+}
+#endif
+
+static SANE_Status
+endorser_control (int fd, int *val, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_EndCtrl buf; /* MPHdr (4bytes) + MPP (8bytes) */
+ SANE_Byte mask = 0x7; /* 7-3:reserved; 2-0: Endorser Control */
+ size_t bufsize = sizeof (buf);
+
+ DBG (DBG_proc, ">> endorser_control: fd=%d val=%d flag=%d\n", fd, *val,
+ flag);
+
+ memset (&buf, 0, bufsize); /* Fill struct with zeros */
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET endorser control >> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf, (SANE_Byte) PAGE_CODE_ENDORSER_CONTROL);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "get_endorser_control: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ *val = buf.endorser_control & mask;
+ }
+ else
+ { /* SET */
+ DBG (DBG_info, ">> SET endorser control >> calling mode_select\n");
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ buf.code = PAGE_CODE_ENDORSER_CONTROL; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+
+ buf.endorser_control = *val & mask; /* Power on default is OFF */
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_endorser_control: MODE_SELECT failed with status=%d\n",
+ status);
+ return (status);
+ }
+ }
+ DBG (DBG_proc, "<< endorser_control: endorser_control=%#02x\n",
+ buf.endorser_control);
+ return (status);
+}
+
+/* When SCAN, READ, or LOAD (in ADF mode) is issued, scanner waits until operator panel start button is pressed */
+static SANE_Status
+scan_wait_mode (int fd, int val, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_SWM buf; /* Scan Wait Mode Page Code */
+ DBG (DBG_proc, ">> scan_wait_mode\n");
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET scan_wait_mode >> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf, (SANE_Byte) PAGE_CODE_SCAN_WAIT_MODE);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "get_scan_wait_mode: MODE_SELECT failed with status=%d\n",
+ status);
+ return (-1);
+ }
+ }
+ else
+ { /* SET */
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ buf.code = PAGE_CODE_SCAN_WAIT_MODE; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+ buf.swm = 0x00;
+ if (val == 1)
+ buf.swm |= 1; /* set bit 1 if scan_wait_mode ON */
+ else
+ buf.swm &= ~1; /* unset bit 1 if scan_wait_mode OFF */
+
+ DBG (DBG_info, ">> SET scan_wait_mode >> calling mode_sense\n");
+ if ((status = mode_select (fd, (MP *) & buf)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "mode_select ERROR %s\n", sane_strstatus (status));
+ }
+ }
+ DBG (DBG_proc, "<< scan_wait_mode: buf.swm=%#02x\n", buf.swm);
+ return (status);
+}
+
+/* Selectable when Send Diagnostics command is performed */
+static SANE_Int
+service_mode (int fd, int val, SANE_Bool flag)
+{
+ SANE_Status status;
+ MP_SRV buf; /* Service Mode Page Code */
+ DBG (DBG_proc, ">> service_mode\n");
+
+ if (flag)
+ { /* GET */
+ DBG (DBG_info, ">> GET service_mode >> calling mode_sense\n");
+ status =
+ mode_sense (fd, (MP *) & buf,
+ (SANE_Byte) PAGE_CODE_SERVICE_MODE_SELECT);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "get_service_mode: MODE_SELECT failed with status=%d\n",
+ status);
+ return (-1);
+ }
+ }
+ else
+ { /* SET */
+ /* Fill in struct then hand off to mode_select */
+ memset (&buf, 0, sizeof (buf)); /* Fill struct with zeros */
+ buf.code = PAGE_CODE_SERVICE_MODE_SELECT; /* bits5-0: Page Code */
+ buf.code &= ~(1 << 7); /* Bit7 PS is set to 0 */
+ buf.len = 0x06;
+ /* 0H: Self-Diagnostics Mode, 1H: Optical Adjustment Mode */
+ buf.service = val & 0x01;
+ status = mode_select (fd, (MP *) & buf);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ "set_service_mode: MODE_SELECT failed with status=%d\n",
+ status);
+ return (-1);
+ }
+ }
+ DBG (DBG_proc, "<< service_mode\n");
+ return (buf.service & 0x01);
+}