" : ""); */ 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 \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 Information = %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 parameter) */ 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 Current 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 Length=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 */ if (i >= 0x61 && i <= 0x7A) return SANE_TRUE; /* abcdefghijklmnopqrstuvwxyz */ 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 = 0; i < GAMMA_LENGTH; i++) { out.gamma[i + 2] = 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); }