2013-07-06 10:14:06 -04:00
|
|
|
/*
|
|
|
|
* Shinko/Sinfonia CHC-S2145 CUPS backend -- libusb-1.0 version
|
|
|
|
*
|
|
|
|
* (c) 2013 Solomon Peachy <pizza@shaftnet.org>
|
|
|
|
*
|
2013-07-06 19:08:17 -04:00
|
|
|
* Development of this backend was sponsored by:
|
|
|
|
*
|
|
|
|
* LiveLink Technology [ www.livelinktechnology.net ]
|
|
|
|
*
|
2013-07-06 10:14:06 -04:00
|
|
|
* The latest version of this program can be found at:
|
|
|
|
*
|
|
|
|
* http://git.shaftnet.org/git/gitweb.cgi?p=selphy_print.git
|
|
|
|
*
|
|
|
|
* 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 3 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.
|
|
|
|
*
|
|
|
|
* [http://www.gnu.org/licenses/gpl-3.0.html]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <signal.h>
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
#define VERSION "0.10"
|
2013-07-06 15:12:45 -04:00
|
|
|
#define URI_PREFIX "shinko_s2145://"
|
2013-07-06 10:14:06 -04:00
|
|
|
|
|
|
|
#include "backend_common.c"
|
|
|
|
|
|
|
|
/* USB Identifiers */
|
|
|
|
#define USB_VID_SHINKO 0x10CE
|
|
|
|
#define USB_PID_SHINKO_S2145 0x000E
|
|
|
|
|
|
|
|
enum {
|
|
|
|
S_IDLE = 0,
|
|
|
|
S_PRINTER_READY_CMD,
|
|
|
|
S_PRINTER_SENT_PRINT_CMD,
|
|
|
|
S_PRINTER_SENT_DATA,
|
|
|
|
S_FINISHED,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Structure of printjob header. All fields are LITTLE ENDIAN */
|
|
|
|
struct s2145_printjob_hdr {
|
|
|
|
uint32_t len1; /* Fixed at 0x10 */
|
|
|
|
uint32_t model; /* Fixed at '2145' (decimal) */
|
|
|
|
uint32_t unk2;
|
|
|
|
uint32_t unk3;
|
|
|
|
|
|
|
|
uint32_t len2; /* Fixed at 0x64 */
|
|
|
|
uint32_t unk5;
|
|
|
|
uint32_t media;
|
|
|
|
uint32_t unk6;
|
|
|
|
|
|
|
|
uint32_t method;
|
|
|
|
uint32_t mode;
|
|
|
|
uint32_t unk7;
|
|
|
|
uint32_t unk8;
|
|
|
|
|
|
|
|
uint32_t unk9;
|
|
|
|
uint32_t columns;
|
|
|
|
uint32_t rows;
|
|
|
|
uint32_t copies;
|
|
|
|
|
|
|
|
uint32_t unk10;
|
|
|
|
uint32_t unk11;
|
|
|
|
uint32_t unk12;
|
|
|
|
uint32_t unk13;
|
|
|
|
|
|
|
|
uint32_t unk14;
|
|
|
|
uint32_t unk15;
|
|
|
|
uint32_t dpi; /* Fixed at '300' (decimal) */
|
|
|
|
uint32_t unk16;
|
|
|
|
|
|
|
|
uint32_t unk17;
|
|
|
|
uint32_t unk18;
|
|
|
|
uint32_t unk19;
|
|
|
|
uint32_t unk20;
|
|
|
|
|
|
|
|
uint32_t unk21;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
/* Structs for printer */
|
|
|
|
struct s2145_cmd_hdr {
|
|
|
|
uint16_t cmd;
|
|
|
|
uint16_t len; /* Not including this header */
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
#define S2145_CMD_STATUS 0x0001
|
|
|
|
#define S2145_CMD_MEDIAINFO 0x0002
|
|
|
|
#define S2145_CMD_MODELNAME 0x0003
|
|
|
|
#define S2145_CMD_ERRORLOG 0x0004
|
|
|
|
#define S2145_CMD_PRINTJOB 0x4001
|
|
|
|
#define S2145_CMD_CANCELJOB 0x4002
|
|
|
|
#define S2145_CMD_FLASHLED 0x4003
|
|
|
|
#define S2145_CMD_RESET 0x4004
|
|
|
|
#define S2145_CMD_READTONE 0x4005
|
|
|
|
#define S2145_CMD_BUTTON 0x4006
|
|
|
|
#define S2145_CMD_GETUNIQUE 0x8003
|
|
|
|
#define S2145_CMD_FWINFO 0xC003
|
|
|
|
#define S2145_CMD_UPDATE 0xC004
|
|
|
|
#define S2145_CMD_SETUNIQUE 0xC007
|
|
|
|
|
|
|
|
struct s2145_print_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t id;
|
|
|
|
uint16_t count;
|
|
|
|
uint16_t columns;
|
|
|
|
uint16_t rows;
|
|
|
|
uint8_t media;
|
|
|
|
uint8_t mode;
|
|
|
|
uint8_t method;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
#define PRINT_MEDIA_4x6 0x00
|
|
|
|
#define PRINT_MEDIA_5x3_5 0x01
|
|
|
|
#define PRINT_MEDIA_5x7 0x03
|
|
|
|
#define PRINT_MEDIA_6x9 0x05
|
|
|
|
#define PRINT_MEDIA_6x8 0x06
|
|
|
|
#define PRINT_MEDIA_2x6 0x07
|
|
|
|
|
|
|
|
static char *print_medias[] = {
|
|
|
|
"4x6",
|
|
|
|
"5x3.5",
|
|
|
|
"Unused",
|
|
|
|
"5x7",
|
|
|
|
"Unused",
|
|
|
|
"6x9",
|
|
|
|
"6x8",
|
|
|
|
"2x6"
|
|
|
|
};
|
|
|
|
|
|
|
|
#define PRINT_MODE_DEFAULT 0x01
|
|
|
|
#define PRINT_MODE_STD_GLOSSY 0x02
|
|
|
|
#define PRINT_MODE_FINE_GLOSSY 0x03
|
|
|
|
#define PRINT_MODE_STD_MATTE 0x04
|
|
|
|
#define PRINT_MODE_FINE_MATTE 0x05
|
|
|
|
#define PRINT_MODE_STD_EGLOSSY 0x06
|
|
|
|
#define PRINT_MODE_FINE_EGLOSSY 0x07
|
|
|
|
|
|
|
|
static char *print_modes[] = {
|
|
|
|
"Unused",
|
|
|
|
"Default",
|
|
|
|
"Std Glossy",
|
|
|
|
"Fine Glossy",
|
|
|
|
"Std Matte",
|
|
|
|
"Fine Matte",
|
|
|
|
"Std ExGlossy",
|
|
|
|
"Fine ExGlossy"
|
|
|
|
};
|
|
|
|
|
|
|
|
#define PRINT_METHOD_STD 0x00
|
|
|
|
#define PRINT_METHOD_4x6_2UP 0x02
|
|
|
|
#define PRINT_METHOD_2x6_2UP 0x04
|
|
|
|
|
|
|
|
static char *print_methods[] = {
|
|
|
|
"Standard",
|
|
|
|
"Unused",
|
|
|
|
"4x6 2up",
|
|
|
|
"Unused",
|
|
|
|
"2x6 2up",
|
|
|
|
};
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_cancel_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t id;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_reset_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t target;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 15:12:45 -04:00
|
|
|
#define RESET_PRINTER 0x03
|
|
|
|
#define RESET_USER_CURVE 0x04
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_readtone_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t curveid;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_button_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t enabled;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 15:12:45 -04:00
|
|
|
#define BUTTON_ENABLED 0x01
|
|
|
|
#define BUTTON_DISABLED 0x00
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_fwinfo_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t target;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 15:12:45 -04:00
|
|
|
#define FWINFO_TARGET_MAIN_BOOT 0x01
|
|
|
|
#define FWINFO_TARGET_MAIN_APP 0x02
|
|
|
|
#define FWINFO_TARGET_DSP_BOOT 0x03
|
|
|
|
#define FWINFO_TARGET_DSP_APP 0x04
|
|
|
|
#define FWINFO_TARGET_USB_BOOT 0x05
|
|
|
|
#define FWINFO_TARGET_USB_APP 0x06
|
|
|
|
#define FWINFO_TARGET_TABLES 0x07
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
static char *fwinfo_targets[] = {
|
|
|
|
"Unused",
|
|
|
|
"Main Boot",
|
|
|
|
"Main App",
|
|
|
|
"DSP Boot",
|
|
|
|
"DSP App",
|
|
|
|
"USB Boot",
|
|
|
|
"USB App",
|
|
|
|
"Tables"
|
|
|
|
};
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_update_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t target;
|
|
|
|
uint32_t reserved;
|
|
|
|
uint32_t size;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 22:44:51 -04:00
|
|
|
#define UPDATE_TARGET_USER 0x03
|
|
|
|
#define UPDATE_TARGET_CURRENT 0x04
|
|
|
|
|
2013-07-08 20:15:39 -04:00
|
|
|
static char *update_targets[] = {
|
|
|
|
"Unused",
|
|
|
|
"Unused",
|
|
|
|
"Unused",
|
|
|
|
"User",
|
|
|
|
"Current",
|
|
|
|
};
|
|
|
|
|
2013-07-06 22:44:51 -04:00
|
|
|
#define UPDATE_SIZE 0x600
|
|
|
|
/* Update is three channels, Y, M, C;
|
|
|
|
each is 256 entries of 11-bit data padded to 16-bits.
|
|
|
|
Printer expects LE data. We use BE data on disk.
|
|
|
|
*/
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_setunique_cmd {
|
|
|
|
struct s2145_cmd_hdr hdr;
|
|
|
|
uint8_t len;
|
|
|
|
uint8_t data[23]; /* Not necessarily all used. */
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_status_hdr {
|
|
|
|
uint8_t result;
|
|
|
|
uint8_t error;
|
|
|
|
uint8_t printer_major;
|
|
|
|
uint8_t printer_minor;
|
|
|
|
uint8_t reserved[3];
|
|
|
|
uint8_t status;
|
|
|
|
uint16_t payload_len;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
#define RESULT_SUCCESS 0x01
|
|
|
|
#define RESULT_FAIL 0x02
|
|
|
|
|
|
|
|
#define ERROR_NONE 0x00
|
|
|
|
#define ERROR_INVALID_PARAM 0x01
|
|
|
|
#define ERROR_MAIN_APP_INACTIVE 0x02
|
|
|
|
#define ERROR_COMMS_TIMEOUT 0x03
|
|
|
|
#define ERROR_MAINT_NEEDED 0x04
|
|
|
|
#define ERROR_BAD_COMMAND 0x05
|
|
|
|
#define ERROR_PRINTER 0x11
|
|
|
|
#define ERROR_BUFFER_FULL 0x21
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
/* XXX observed major/minor error codes:
|
|
|
|
|
|
|
|
0x01/0x16 @ 77845 [maybe paper out?]
|
|
|
|
0x06/0x0b @ 77822, 70053
|
|
|
|
0x05/0x64 @ 76034
|
|
|
|
0x05/0x61 @ 76034, 75420
|
|
|
|
0x05/0x62 @ 76034
|
|
|
|
0x05/0x4e @ 69824, 69820, 69781
|
|
|
|
|
|
|
|
Unfortunately I have no idea what these refer to.
|
|
|
|
|
|
|
|
major (0x01/5/6) may refer to above error codes or media/print modes.
|
|
|
|
minor (0x61/62/64) may refer to equivalent status codes (see below)
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
#define STATUS_READY 0x00
|
|
|
|
#define STATUS_INIT_CPU 0x31
|
|
|
|
#define STATUS_INIT_RIBBON 0x32
|
|
|
|
#define STATUS_INIT_PAPER 0x33
|
|
|
|
#define STATUS_THERMAL_PROTECT 0x34
|
|
|
|
#define STATUS_USING_PANEL 0x35
|
|
|
|
#define STATUS_SELF_DIAG 0x36
|
|
|
|
#define STATUS_DOWNLOADING 0x37
|
|
|
|
|
|
|
|
#define STATUS_FEEDING_PAPER 0x61
|
|
|
|
#define STATUS_PRE_HEAT 0x62
|
|
|
|
#define STATUS_PRINT_Y 0x63
|
|
|
|
#define STATUS_BACK_FEED_Y 0x64
|
|
|
|
#define STATUS_PRINT_M 0x65
|
|
|
|
#define STATUS_BACK_FEED_M 0x66
|
|
|
|
#define STATUS_PRINT_C 0x67
|
|
|
|
#define STATUS_BACK_FEED_C 0x68
|
|
|
|
#define STATUS_PRINT_QP 0x69
|
|
|
|
#define STATUS_PAPER_CUT 0x6A
|
|
|
|
#define STATUS_PAPER_EJECT 0x6B
|
|
|
|
#define STATUS_BACK_FEED_E 0x6C
|
|
|
|
#define STATUS_FINISHED 0x6D
|
|
|
|
|
|
|
|
struct s2145_status_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint32_t count_lifetime;
|
|
|
|
uint32_t count_maint;
|
|
|
|
uint32_t count_paper;
|
|
|
|
uint32_t count_cutter;
|
|
|
|
uint32_t count_head;
|
|
|
|
uint32_t count_ribbon_left;
|
|
|
|
uint8_t bank1_printid;
|
|
|
|
uint8_t bank2_printid;
|
|
|
|
uint16_t bank1_remaining;
|
|
|
|
uint16_t bank1_finished;
|
|
|
|
uint16_t bank1_specified;
|
|
|
|
uint8_t bank1_status;
|
|
|
|
uint16_t bank2_remaining;
|
|
|
|
uint16_t bank2_finished;
|
|
|
|
uint16_t bank2_specified;
|
|
|
|
uint8_t bank2_status;
|
|
|
|
uint8_t tonecurve_status;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
#define BANK_STATUS_FREE 0x00
|
|
|
|
#define BANK_STATUS_XFER 0x01
|
|
|
|
#define BANK_STATUS_FULL 0x02
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
static char *bank_statuses[] = {
|
|
|
|
"Free",
|
|
|
|
"Xfer",
|
|
|
|
"Full",
|
|
|
|
};
|
|
|
|
|
2013-07-06 20:29:30 -04:00
|
|
|
#define TONECURVE_INIT 0x00
|
|
|
|
#define TONECURVE_USER 0x01
|
|
|
|
#define TONECURVE_CURRENT 0x02
|
2013-07-06 18:56:19 -04:00
|
|
|
|
|
|
|
static char *tonecurve_statuses[] = {
|
|
|
|
"Initial",
|
|
|
|
"UserSet",
|
|
|
|
"Current",
|
|
|
|
};
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_readtone_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
2013-07-06 20:29:30 -04:00
|
|
|
uint16_t total_size;
|
2013-07-06 10:14:06 -04:00
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_mediainfo_item {
|
|
|
|
uint8_t code;
|
|
|
|
uint16_t columns;
|
|
|
|
uint16_t rows;
|
|
|
|
uint8_t media_type;
|
|
|
|
uint8_t print_type;
|
|
|
|
uint8_t reserved[3];
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
#define MEDIA_TYPE_UNKNOWN 0x00
|
|
|
|
#define MEDIA_TYPE_PAPER 0x01
|
|
|
|
|
|
|
|
static char *media_types[] = {
|
|
|
|
"Unknown",
|
|
|
|
"Paper"
|
|
|
|
};
|
|
|
|
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_mediainfo_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint8_t count;
|
|
|
|
struct s2145_mediainfo_item items[10]; /* Not all necessarily used */
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_modelname_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint8_t vendor[4];
|
|
|
|
uint8_t product[4];
|
|
|
|
uint8_t modelname[40];
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_error_item {
|
|
|
|
uint8_t major;
|
|
|
|
uint8_t minor;
|
|
|
|
uint32_t print_counter;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 13:39:00 -04:00
|
|
|
struct s2145_errorlog_resp {
|
2013-07-06 10:14:06 -04:00
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint8_t count;
|
|
|
|
struct s2145_error_item items[10]; /* Not all necessarily used */
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct s2145_fwinfo_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint8_t name[8];
|
|
|
|
uint8_t type[16];
|
|
|
|
uint8_t date[10];
|
|
|
|
uint8_t major;
|
2013-07-06 12:48:19 -04:00
|
|
|
uint8_t minor;
|
2013-07-06 10:14:06 -04:00
|
|
|
uint16_t checksum;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2013-07-06 14:11:41 -04:00
|
|
|
struct s2145_getunique_resp {
|
|
|
|
struct s2145_status_hdr hdr;
|
|
|
|
uint8_t data[24]; /* Not necessarily all used. */
|
|
|
|
} __attribute__((packed));
|
2013-07-06 10:14:06 -04:00
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
#define READBACK_LEN 128 /* Needs to be larger than largest response hdr */
|
2013-07-06 10:14:06 -04:00
|
|
|
#define CMDBUF_LEN sizeof(struct s2145_print_cmd)
|
|
|
|
|
|
|
|
static int find_and_enumerate(struct libusb_context *ctx,
|
|
|
|
struct libusb_device ***list,
|
|
|
|
char *match_serno,
|
|
|
|
int scan_only)
|
|
|
|
{
|
|
|
|
int num;
|
|
|
|
int i;
|
|
|
|
int found = -1;
|
|
|
|
|
|
|
|
/* Enumerate and find suitable device */
|
|
|
|
num = libusb_get_device_list(ctx, list);
|
|
|
|
|
|
|
|
for (i = 0 ; i < num ; i++) {
|
|
|
|
struct libusb_device_descriptor desc;
|
|
|
|
|
|
|
|
libusb_get_device_descriptor((*list)[i], &desc);
|
|
|
|
|
|
|
|
if (desc.idVendor != USB_VID_SHINKO)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch(desc.idProduct) {
|
|
|
|
case USB_PID_SHINKO_S2145:
|
|
|
|
found = i;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
found = print_scan_output((*list)[i], &desc,
|
2013-07-06 20:58:23 -04:00
|
|
|
URI_PREFIX, "",
|
2013-07-06 10:14:06 -04:00
|
|
|
found, (found == i), 1,
|
|
|
|
scan_only, match_serno);
|
|
|
|
}
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2013-07-06 13:39:00 -04:00
|
|
|
static int get_status(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
2013-07-06 12:48:19 -04:00
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 13:39:00 -04:00
|
|
|
struct s2145_cmd_hdr cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_status_resp *resp = (struct s2145_status_resp *) rdbuf;
|
2013-07-06 13:39:00 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
|
|
|
|
cmd.cmd = cpu_to_le16(S2145_CMD_STATUS);
|
|
|
|
cmd.len = cpu_to_le16(0);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 13:39:00 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 13:39:00 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO("Printer Status: 0x%02x\n", resp->hdr.status);
|
2013-07-06 12:48:19 -04:00
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->hdr.result != RESULT_SUCCESS) {
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
|
|
|
resp->hdr.result, resp->hdr.error, resp->hdr.printer_major,
|
|
|
|
resp->hdr.printer_minor);
|
|
|
|
}
|
2013-07-06 12:48:19 -04:00
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_status_resp) - sizeof(struct s2145_status_hdr)))
|
2013-07-06 13:39:00 -04:00
|
|
|
return 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
|
|
|
|
INFO(" Prints:\n");
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO("\tLifetime:\t\t%08d\n", le32_to_cpu(resp->count_lifetime));
|
|
|
|
INFO("\tMaintainence:\t\t%08d\n", le32_to_cpu(resp->count_maint));
|
|
|
|
INFO("\tSince Paper Changed:\t%08d\n", le32_to_cpu(resp->count_paper));
|
|
|
|
INFO("\tCutter:\t\t\t%08d\n", le32_to_cpu(resp->count_cutter));
|
|
|
|
INFO("\tPrint Head:\t\t%08d\n", le32_to_cpu(resp->count_head));
|
|
|
|
INFO("\tRibbon Remaining:\t%08d\n", le32_to_cpu(resp->count_ribbon_left));
|
2013-07-06 18:56:19 -04:00
|
|
|
INFO("Bank 1: 0x%02x (%s) Job %03d @ %03d/%03d (%03d remaining)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->bank1_status, bank_statuses[resp->bank1_status],
|
|
|
|
resp->bank1_printid,
|
|
|
|
le16_to_cpu(resp->bank1_remaining),
|
|
|
|
le16_to_cpu(resp->bank1_finished),
|
|
|
|
le16_to_cpu(resp->bank1_specified));
|
2013-07-06 13:39:00 -04:00
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
INFO("Bank 2: 0x%02x (%s) Job %03d @ %03d/%03d (%03d remaining)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->bank2_status, bank_statuses[resp->bank1_status],
|
|
|
|
resp->bank2_printid,
|
|
|
|
le16_to_cpu(resp->bank2_remaining),
|
|
|
|
le16_to_cpu(resp->bank2_finished),
|
|
|
|
le16_to_cpu(resp->bank2_specified));
|
2013-07-06 13:39:00 -04:00
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO("Tonecurve Status: 0x%02x (%s)\n", resp->tonecurve_status, tonecurve_statuses[resp->tonecurve_status]);
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
return 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
}
|
|
|
|
|
2013-07-06 13:39:00 -04:00
|
|
|
static int get_fwinfo(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
2013-07-06 12:48:19 -04:00
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 13:39:00 -04:00
|
|
|
struct s2145_fwinfo_cmd cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_fwinfo_resp *resp = (struct s2145_fwinfo_resp *)rdbuf;
|
2013-07-06 13:39:00 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cmd.hdr.cmd = cpu_to_le16(S2145_CMD_FWINFO);
|
|
|
|
cmd.hdr.len = cpu_to_le16(1);
|
|
|
|
|
|
|
|
INFO("FW Information:\n");
|
|
|
|
|
|
|
|
for (i = 1 ; i <= 7 ; i++) {
|
|
|
|
cmd.target = i;
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 13:39:00 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 13:39:00 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->hdr.result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->hdr.status);
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->hdr.result, resp->hdr.error, resp->hdr.printer_major,
|
|
|
|
resp->hdr.printer_minor);
|
2013-07-06 13:39:00 -04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_fwinfo_resp) - sizeof(struct s2145_status_hdr)))
|
2013-07-06 13:39:00 -04:00
|
|
|
continue;
|
|
|
|
|
2013-07-06 18:56:19 -04:00
|
|
|
INFO(" '%s'\t ver %02x.%02x\n", fwinfo_targets[i],
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->major, resp->minor);
|
2013-07-06 13:39:00 -04:00
|
|
|
#if 0
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO(" name: '%s'\n", resp->name);
|
|
|
|
INFO(" type: '%s'\n", resp->type);
|
|
|
|
INFO(" date: '%s'\n", resp->date);
|
|
|
|
INFO(" version: %02x.%02x (CRC %04x)\n", resp->major, resp->minor,
|
|
|
|
le16_to_cpu(resp->checksum));
|
2013-07-06 13:39:00 -04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
}
|
|
|
|
|
2013-07-06 13:39:00 -04:00
|
|
|
static int get_errorlog(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
2013-07-06 12:48:19 -04:00
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 13:39:00 -04:00
|
|
|
struct s2145_cmd_hdr cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_errorlog_resp *resp = (struct s2145_errorlog_resp *) rdbuf;
|
2013-07-06 13:39:00 -04:00
|
|
|
int ret, num = 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
int i;
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
cmd.cmd = cpu_to_le16(S2145_CMD_ERRORLOG);
|
|
|
|
cmd.len = cpu_to_le16(0);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 13:39:00 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 13:39:00 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->hdr.result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->hdr.status);
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->hdr.result, resp->hdr.error, resp->hdr.printer_major,
|
|
|
|
resp->hdr.printer_minor);
|
2013-07-06 13:39:00 -04:00
|
|
|
return -1;
|
2013-07-06 12:48:19 -04:00
|
|
|
}
|
2013-07-06 13:39:00 -04:00
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_errorlog_resp) - sizeof(struct s2145_status_hdr)))
|
2013-07-06 13:39:00 -04:00
|
|
|
return -2;
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO("Stored Error Events: %d entries:\n", resp->count);
|
|
|
|
for (i = 0 ; i < resp->count ; i++) {
|
2013-07-06 13:39:00 -04:00
|
|
|
INFO(" %02d: 0x%02x/0x%02x @ %08d prints\n", i,
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->items[i].major, resp->items[i].minor,
|
|
|
|
le32_to_cpu(resp->items[i].print_counter));
|
2013-07-06 13:39:00 -04:00
|
|
|
}
|
|
|
|
return 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
}
|
|
|
|
|
2013-07-06 13:39:00 -04:00
|
|
|
static int get_mediainfo(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
2013-07-06 12:48:19 -04:00
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 13:39:00 -04:00
|
|
|
struct s2145_cmd_hdr cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_mediainfo_resp *resp = (struct s2145_mediainfo_resp *) rdbuf;
|
2013-07-06 13:39:00 -04:00
|
|
|
int ret, num = 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
int i;
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
cmd.cmd = cpu_to_le16(S2145_CMD_MEDIAINFO);
|
|
|
|
cmd.len = cpu_to_le16(0);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 13:39:00 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 13:39:00 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->hdr.result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->hdr.status);
|
2013-07-06 13:39:00 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->hdr.result, resp->hdr.error, resp->hdr.printer_major,
|
|
|
|
resp->hdr.printer_minor);
|
2013-07-06 13:39:00 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_mediainfo_resp) - sizeof(struct s2145_status_hdr)))
|
2013-07-06 13:39:00 -04:00
|
|
|
return -2;
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
INFO("Supported Media Information: %d entries:\n", resp->count);
|
|
|
|
for (i = 0 ; i < resp->count ; i++) {
|
2013-07-06 18:56:19 -04:00
|
|
|
INFO(" %02d: C 0x%02x (%s), %04dx%04d, M 0x%02x (%s), P 0x%02x (%s)\n", i,
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->items[i].code, print_medias[resp->items[i].code],
|
|
|
|
le16_to_cpu(resp->items[i].columns),
|
|
|
|
le16_to_cpu(resp->items[i].rows),
|
|
|
|
resp->items[i].media_type, media_types[resp->items[i].media_type],
|
|
|
|
resp->items[i].print_type, print_methods[resp->items[i].print_type]);
|
2013-07-06 13:39:00 -04:00
|
|
|
}
|
|
|
|
return 0;
|
2013-07-06 12:48:19 -04:00
|
|
|
}
|
|
|
|
|
2013-07-06 14:11:41 -04:00
|
|
|
static int get_user_string(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 14:11:41 -04:00
|
|
|
struct s2145_cmd_hdr cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_getunique_resp *resp = (struct s2145_getunique_resp*) rdbuf;
|
2013-07-06 14:11:41 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
|
|
|
|
cmd.cmd = cpu_to_le16(S2145_CMD_GETUNIQUE);
|
|
|
|
cmd.len = cpu_to_le16(0);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 14:11:41 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 14:11:41 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->hdr.result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->hdr.status);
|
2013-07-06 14:11:41 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->hdr.result, resp->hdr.error, resp->hdr.printer_major,
|
|
|
|
resp->hdr.printer_minor);
|
2013-07-06 14:11:41 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Null-terminate */
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->hdr.payload_len = le16_to_cpu(resp->hdr.payload_len);
|
|
|
|
if (resp->hdr.payload_len > 23)
|
|
|
|
resp->hdr.payload_len = 23;
|
|
|
|
resp->data[resp->hdr.payload_len] = 0;
|
|
|
|
INFO("Unique String: '%s'\n", resp->data);
|
2013-07-06 14:11:41 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int set_user_string(char *str, libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 14:11:41 -04:00
|
|
|
struct s2145_setunique_cmd cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_status_hdr *resp = (struct s2145_status_hdr *) rdbuf;
|
2013-07-06 14:11:41 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
|
|
|
|
if (str) {
|
|
|
|
cmd.len = strlen(str);
|
|
|
|
if (cmd.len > 23)
|
|
|
|
cmd.len = 23;
|
|
|
|
memset(cmd.data, 0, sizeof(cmd.data));
|
|
|
|
strncpy((char*)cmd.data, str, cmd.len);
|
|
|
|
} else {
|
|
|
|
cmd.len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd.hdr.cmd = cpu_to_le16(S2145_CMD_SETUNIQUE);
|
|
|
|
cmd.hdr.len = cpu_to_le16(cmd.len + 1);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, cmd.len + 1 + sizeof(cmd.hdr))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 14:11:41 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 14:11:41 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->status);
|
2013-07-06 14:11:41 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->result, resp->error, resp->printer_major,
|
|
|
|
resp->printer_minor);
|
2013-07-06 14:11:41 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-06 15:12:45 -04:00
|
|
|
static int cancel_job(char *str, libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 15:12:45 -04:00
|
|
|
struct s2145_cancel_cmd cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_status_hdr *resp = (struct s2145_status_hdr *) rdbuf;
|
2013-07-06 15:12:45 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
|
|
|
|
if (!str)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
cmd.id = atoi(str);
|
|
|
|
|
|
|
|
cmd.hdr.cmd = cpu_to_le16(S2145_CMD_CANCELJOB);
|
|
|
|
cmd.hdr.len = cpu_to_le16(1);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 15:12:45 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof(resp), endp_up);
|
2013-07-06 15:12:45 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-14 17:37:48 -04:00
|
|
|
if (resp->result != RESULT_SUCCESS) {
|
|
|
|
INFO("Printer Status: %02x\n", resp->status);
|
2013-07-06 15:12:45 -04:00
|
|
|
|
|
|
|
INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x)\n",
|
2013-07-14 17:37:48 -04:00
|
|
|
resp->result, resp->error, resp->printer_major,
|
|
|
|
resp->printer_minor);
|
2013-07-06 15:12:45 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int flash_led(libusb_device_handle *dev,
|
|
|
|
uint8_t endp_down, uint8_t endp_up)
|
|
|
|
{
|
2013-07-14 17:37:48 -04:00
|
|
|
uint8_t rdbuf[READBACK_LEN];
|
2013-07-06 15:12:45 -04:00
|
|
|
struct s2145_cmd_hdr cmd;
|
2013-07-14 17:37:48 -04:00
|
|
|
struct s2145_status_hdr *resp = (struct s2145_status_hdr *) rdbuf;
|
2013-07-06 15:12:45 -04:00
|
|
|
int ret, num = 0;
|
|
|
|
|
|
|
|
cmd.cmd = cpu_to_le16(S2145_CMD_FLASHLED);
|
|
|
|
cmd.len = cpu_to_le16(0);
|
|
|
|
|
|
|
|
if ((ret = send_data(dev, endp_down,
|
|
|
|
(uint8_t *) &cmd, sizeof(cmd))))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = libusb_bulk_transfer(dev, endp_up,
|
2013-07-14 17:37:48 -04:00
|
|
|
rdbuf,
|
|
|
|
READBACK_LEN,
|
2013-07-06 15:12:45 -04:00
|
|
|
&num,
|
|
|
|
5000);
|
|
|
|
|
|
|
|
if (ret < 0 || (num < sizeof(struct s2145_status_hdr))) {
|
2013-07-06 20:29:30 -04:00
|
|
|
ERROR("Failure to receive data from printer (libusb error %d: (%d/%d from 0x%02x))\n", ret, num, (int)sizeof |