From a65eb7256219898ba0ce633b61d9ce70c3d61a8e Mon Sep 17 00:00:00 2001 From: Solomon Peachy Date: Mon, 13 May 2019 10:41:28 -0400 Subject: [PATCH] sinfonia: More common code & definitions, and normalize code for more. --- backend_kodak605.c | 146 +++------ backend_kodak6800.c | 26 +- backend_shinkos1245.c | 44 +-- backend_shinkos2145.c | 604 +++++++++++------------------------ backend_shinkos6145.c | 714 +++++++++++------------------------------- backend_shinkos6245.c | 503 +++++++---------------------- backend_sinfonia.c | 229 ++++++++++++-- backend_sinfonia.h | 160 +++++++++- 8 files changed, 884 insertions(+), 1542 deletions(-) diff --git a/backend_kodak605.c b/backend_kodak605.c index 1191d3d..5a4ea29 100644 --- a/backend_kodak605.c +++ b/backend_kodak605.c @@ -45,81 +45,26 @@ #define USB_VID_KODAK 0x040A #define USB_PID_KODAK_605 0x402E -/* Command Header */ -struct kodak605_cmd { - uint16_t cmd; /* LE */ - uint16_t len; /* LE, not counting this header */ -} __attribute__((packed)); - -/* List of known commands */ -#define KODAK605_CMD_GETSTATUS 0x0001 -#define KODAK605_CMD_MEDIAINFO 0x0002 -#define KODAK605_CMD_ERRORLOG 0x0004 // guess -#define KODAK605_CMD_PRINTJOB 0x4001 -#define KODAK605_CMD_CANCELJOB 0x4002 // guess -#define KODAK605_CMD_FLASHLED 0x4003 // guess -#define KODAK605_CMD_RESET 0x4004 // guess -#define KODAK605_CMD_READTONE 0x4005 // guess -#define KODAK605_CMD_FWINFO 0xC003 // guess -#define KODAK605_CMD_UPDATE 0xC004 - -struct kodak605_sts_hdr { - uint8_t result; /* RESULT_* */ - uint8_t error; /* ERROR_* */ - uint8_t printer_major; - uint8_t printer_minor; - uint8_t reserved[3]; /* 00 00 [00|01|02] */ - uint8_t status; /* STATUS_* */ - uint16_t length; /* LE, not counting this header */ -} __attribute__((packed)); - -/* ERROR_* and STATUS_* are all guesses */ -#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_READY 0x00 -#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_OP 0x69 -#define STATUS_PAPER_CUT 0x6A -#define STATUS_PAPER_EJECT 0x6B -#define STATUS_BACK_FEED_E 0x6C +/* List of confirmed commands */ +//#define SINFONIA_CMD_GETSTATUS 0x0001 +//#define SINFONIA_CMD_MEDIAINFO 0x0002 +//#define SINFONIA_CMD_PRINTJOB 0x4001 +//#define SINFONIA_CMD_UPDATE 0xC004 /* Media structure */ -struct kodak605_medium { - uint8_t index; - uint16_t cols; /* LE */ - uint16_t rows; /* LE */ - uint8_t type; /* MEDIA_TYPE_* */ - uint8_t unk[4]; /* 00 00 00 00 */ -} __attribute__((packed)); - -#define MEDIA_TYPE_UNKNOWN 0x00 -#define MEDIA_TYPE_PAPER 0x01 - struct kodak605_media_list { - struct kodak605_sts_hdr hdr; + struct sinfonia_status_hdr hdr; uint8_t unk; /* always seen 02 */ uint8_t type; /* KODAK68x0_MEDIA_* */ uint8_t count; - struct kodak605_medium entries[]; + struct sinfonia_mediainfo_item entries[]; } __attribute__((packed)); #define MAX_MEDIA_LEN 128 /* Status response */ struct kodak605_status { - struct kodak605_sts_hdr hdr; + struct sinfonia_status_hdr hdr; /*@10*/ uint32_t ctr_life; /* Lifetime Prints */ uint32_t ctr_maint; /* Prints since last maintenance */ uint32_t ctr_media; /* Prints on current media */ @@ -145,13 +90,6 @@ struct kodak605_status { /*@70*/ uint8_t unk_12[6]; /* 01 00 00 00 00 00 */ } __attribute__((packed)); -/* Error logs are guesses */ -struct kodak605_errorlog_resp { - struct kodak605_sts_hdr hdr; - uint8_t count; - struct sinfonia_error_item items[10]; /* Not all necessarily used */ -} __attribute__((packed)); - /* File header */ struct kodak605_hdr { uint8_t hdr[4]; /* 01 40 0a 00 */ @@ -411,7 +349,7 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { /* Validate against supported media list */ for (num = 0 ; num < ctx->media->count; num++) { if (ctx->media->entries[num].rows == hdr.rows && - ctx->media->entries[num].cols == hdr.columns) + ctx->media->entries[num].columns == hdr.columns) break; } if (num == ctx->media->count) { @@ -431,7 +369,8 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { } if (sts.hdr.result != RESULT_SUCCESS) { - ERROR("Printer Status: %02x\n", sts.hdr.status); + ERROR("Printer Status: %02x (%s)\n", sts.hdr.status, + sinfonia_status_str(sts.hdr.status)); ERROR("Result: %02x Error: %02x (%s) %02x/%02x\n", sts.hdr.result, sts.hdr.error, sinfonia_error_str(sts.hdr.error), @@ -467,7 +406,7 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { (uint8_t*)&hdr, sizeof(hdr)))) return CUPS_BACKEND_FAILED; - struct kodak605_sts_hdr resp; + struct sinfonia_status_hdr resp; if ((ret = read_data(ctx->dev, ctx->endp_up, (uint8_t*) &resp, sizeof(resp), &num))) return CUPS_BACKEND_FAILED; @@ -478,11 +417,11 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { sleep(1); continue; } else if ((resp.status & 0xf0) == 0x30 || resp.status == 0x21) { - INFO("Printer busy (%02x), retrying\n", resp.status); + INFO("Printer busy (%02x : %s), retrying\n", resp.status, sinfonia_status_str(resp.status)); } else { ERROR("Unexpected response from print command!\n"); - ERROR("Printer Status: %02x\n", resp.status); + ERROR("Printer Status: %02x: %s\n", resp.status, sinfonia_status_str(resp.status)); ERROR("Result: %02x Error: %02x (%02x %02x)\n", resp.result, resp.error, resp.printer_major, resp.printer_minor); @@ -514,7 +453,8 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { if (sts.hdr.result != RESULT_SUCCESS || sts.hdr.error == ERROR_PRINTER) { - INFO("Printer Status: %02x\n", sts.hdr.status); + INFO("Printer Status: %02x (%s)\n", sts.hdr.status, + sinfonia_status_str(sts.hdr.status)); INFO("Result: %02x Error: %02x (%s) %02x/%02x\n", sts.hdr.result, sts.hdr.error, sinfonia_error_str(sts.hdr.error), @@ -544,9 +484,10 @@ static int kodak605_main_loop(void *vctx, const void *vjob) { static void kodak605_dump_status(struct kodak605_ctx *ctx, struct kodak605_status *sts) { - INFO("Status: %02x Error: %02x (%s) %02x/%02x\n", - sts->hdr.status, sts->hdr.error, - sinfonia_error_str(sts->hdr.error), + INFO("Status: %02x (%s)\n", + sts->hdr.status, sinfonia_status_str(sts->hdr.status)); + INFO("Error: %02x (%s) %02x/%02x\n", + sts->hdr.error, sinfonia_error_str(sts->hdr.error), sts->hdr.printer_major, sts->hdr.printer_minor); INFO("Bank 1: %s Job %03u @ %03u/%03u\n", @@ -583,23 +524,20 @@ static void kodak605_dump_status(struct kodak605_ctx *ctx, struct kodak605_statu INFO("Donor : %u%%\n", sts->donor); } - static int kodak605_get_errorlog(struct kodak605_ctx *ctx) { - uint8_t cmdbuf[16]; - struct kodak605_errorlog_resp resp; + struct sinfonia_cmd_hdr cmd; + struct sinfonia_errorlog_resp resp; int ret, num = 0; int i; /* Initial Request */ - cmdbuf[0] = 0x04; - cmdbuf[1] = 0x00; - cmdbuf[2] = 0x00; - cmdbuf[3] = 0x00; + cmd.cmd = cpu_to_le16(SINFONIA_CMD_ERRORLOG); + cmd.len = cpu_to_le16(0); if ((ret = send_data(ctx->dev, ctx->endp_down, - cmdbuf, 4))) + (uint8_t*)&cmd, sizeof(cmd)))) goto done; /* Get response back */ @@ -608,11 +546,8 @@ static int kodak605_get_errorlog(struct kodak605_ctx *ctx) if (ret < 0) goto done; - if (num != sizeof(resp)) { - ERROR("Short Read! (%d/%d)\n", num, 10); - ret = 4; - goto done; - } + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct sinfonia_errorlog_resp) - sizeof(struct sinfonia_status_hdr))) + return -2; INFO("Stored Error Events: %u entries:\n", resp.count); for (i = 0 ; i < resp.count ; i++) { @@ -638,7 +573,7 @@ static void kodak605_dump_mediainfo(struct kodak605_media_list *media) DEBUG("Legal print sizes:\n"); for (i = 0 ; i < media->count ; i++) { DEBUG("\t%d: %ux%u\n", i, - le16_to_cpu(media->entries[i].cols), + le16_to_cpu(media->entries[i].columns), le16_to_cpu(media->entries[i].rows)); } DEBUG("\n"); @@ -713,36 +648,35 @@ static int kodak605_set_tonecurve(struct kodak605_ctx *ctx, char *fname) static int kodak605_cancel_job(struct kodak605_ctx *ctx, char *str) { - uint8_t cmdbuf[5]; + struct sinfonia_cancel_cmd cmd; + struct sinfonia_status_hdr resp; int ret, num = 0; - struct kodak605_sts_hdr hdr; if (!str) return -1; /* Send Job Cancel */ - cmdbuf[0] = 0x02; - cmdbuf[1] = 0x40; - cmdbuf[2] = 0x01; - cmdbuf[3] = 0x00; - cmdbuf[4] = atoi(str); + cmd.id = atoi(str); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_CANCELJOB); + cmd.hdr.len = cpu_to_le16(1); + if ((ret = send_data(ctx->dev, ctx->endp_down, - cmdbuf, sizeof(cmdbuf)))) + (uint8_t*)&cmd, sizeof(cmd)))) return ret; /* Read the media response */ ret = read_data(ctx->dev, ctx->endp_up, - (uint8_t*) &hdr, sizeof(hdr), &num); + (uint8_t*) &resp, sizeof(resp), &num); if (ret < 0) return ret; - if (num < (int)sizeof(hdr)) { - ERROR("Short Read! (%d/%d)\n", num, (int)sizeof(hdr)); + if (num < (int)sizeof(resp)) { + ERROR("Short Read! (%d/%d)\n", num, (int)sizeof(resp)); return CUPS_BACKEND_FAILED; } - if (hdr.result != RESULT_SUCCESS) { - ERROR("Unexpected response from job cancel query (%x)!\n", hdr.result); + if (resp.result != RESULT_SUCCESS) { + ERROR("Unexpected response from job cancel query (%x)!\n", resp.result); return CUPS_BACKEND_FAILED; } diff --git a/backend_kodak6800.c b/backend_kodak6800.c index efa73ea..f47fe60 100644 --- a/backend_kodak6800.c +++ b/backend_kodak6800.c @@ -90,16 +90,6 @@ struct kodak68x0_status_readback { uint8_t curve_status; /* Always seems to be 0x00 */ } __attribute__((packed)); -struct kodak6800_printsize { - uint8_t code; /* 0x06 (6x8) or 0x03 (5x7) */ - uint16_t width; /* BE */ - uint16_t height; /* BE */ - uint8_t type; /* MEDIA_TYPE_* [ ie paper ] */ - uint8_t method; /* Special handling.. */ - uint8_t flag; /* 00 if it can be done without skipping a panel, 01 otherwise */ - uint8_t null[2]; -} __attribute__((packed)); - #define MAX_MEDIA_LEN 128 #define MAX_MEDIAS 16 @@ -108,7 +98,7 @@ struct kodak68x0_media_readback { uint8_t type; /* Media code, KODAK68x0_MEDIA_xxx */ uint8_t null[5]; uint8_t count; /* Always 0x04 (6800) or 0x06 (6850)? */ - struct kodak6800_printsize sizes[]; + struct sinfonia_mediainfo_item sizes[]; } __attribute__((packed)); #define CMDBUF_LEN 17 @@ -131,7 +121,7 @@ struct kodak6800_ctx { uint8_t jobid; - struct kodak6800_printsize sizes[MAX_MEDIA_LEN]; + struct sinfonia_mediainfo_item sizes[MAX_MEDIA_LEN]; uint8_t media_count; uint8_t media_type; @@ -163,7 +153,7 @@ static int kodak6800_do_cmd(struct kodak6800_ctx *ctx, return 0; } -static void kodak68x0_dump_mediainfo(struct kodak6800_printsize *sizes, uint8_t media_count, uint8_t media_type) { +static void kodak68x0_dump_mediainfo(struct sinfonia_mediainfo_item *sizes, uint8_t media_count, uint8_t media_type) { int i; if (media_type == KODAK6_MEDIA_NONE) { @@ -175,8 +165,8 @@ static void kodak68x0_dump_mediainfo(struct kodak6800_printsize *sizes, uint8_t INFO("Legal print sizes:\n"); for (i = 0 ; i < media_count ; i++) { INFO("\t%d: %dx%d (%02x)\n", i, - be16_to_cpu(sizes[i].width), - be16_to_cpu(sizes[i].height), + be16_to_cpu(sizes[i].columns), + be16_to_cpu(sizes[i].rows), sizes[i].method); } INFO("\n"); @@ -221,7 +211,7 @@ static int kodak6800_get_mediainfo(struct kodak6800_ctx *ctx) ctx->media_type = media->type; for (i = 0; i < media->count ; i++) { - memcpy(&ctx->sizes[ctx->media_count], &media->sizes[i], sizeof(struct kodak6800_printsize)); + memcpy(&ctx->sizes[ctx->media_count], &media->sizes[i], sizeof(struct sinfonia_mediainfo_item)); ctx->media_count++; } if (i < 6) @@ -953,8 +943,8 @@ static int kodak6800_main_loop(void *vctx, const void *vjob) { /* Validate against supported media list */ for (num = 0 ; num < ctx->media_count; num++) { - if (ctx->sizes[num].height == hdr.rows && - ctx->sizes[num].width == hdr.columns && + if (ctx->sizes[num].rows == hdr.rows && + ctx->sizes[num].columns == hdr.columns && ctx->sizes[num].method == hdr.method) break; } diff --git a/backend_shinkos1245.c b/backend_shinkos1245.c index ff0c792..9687a32 100644 --- a/backend_shinkos1245.c +++ b/backend_shinkos1245.c @@ -44,48 +44,6 @@ #include "backend_common.h" #include "backend_sinfonia.h" -#if 0 -/* Structure of printjob header. All fields are LITTLE ENDIAN */ -struct s1245_printjob_hdr { - uint32_t len1; /* Fixed at 0x10 */ - uint32_t model; /* Equal to the printer model (eg '1245' or '2145' decimal) */ - uint32_t unk2; /* Null */ - uint32_t unk3; /* Fixed at 0x01 */ - - uint32_t len2; /* Fixed at 0x64 */ - uint32_t unk5; /* Null */ - uint32_t media; /* Fixed at 0x10 */ - uint32_t unk6; /* Null */ - - uint32_t method; /* Print Method */ - uint32_t oc_mode; /* Lamination Mode */ - uint32_t unk7; /* Null */ - int32_t mattedepth; /* 0x7fffffff for glossy, 0x00 +- 25 for matte */ - - uint32_t dust; /* Dust control */ - uint32_t columns; - uint32_t rows; - uint32_t copies; - - uint32_t unk10; /* Null */ - uint32_t unk11; /* Null */ - uint32_t unk12; /* Null */ - uint32_t unk13; /* 0xceffffff */ - - uint32_t unk14; /* Null */ - uint32_t unk15; /* 0xceffffff */ - uint32_t dpi; /* Fixed at '300' (decimal) */ - uint32_t unk16; /* 0xceffffff */ - - uint32_t unk17; /* Null */ - uint32_t unk18; /* 0xceffffff */ - uint32_t unk19; /* Null */ - uint32_t unk20; /* Null */ - - uint32_t unk21; /* Null */ -} __attribute__((packed)); -#endif - /* Printer data structures */ struct shinkos1245_cmd_hdr { uint8_t prefix; /* 0x03 */ @@ -1084,7 +1042,7 @@ static int shinkos1245_read_parse(void *vctx, const void **vjob, int data_fd, in memset(job, 0, sizeof(*job)); /* Common read/parse code */ - ret = sinfonia_read_parse(data_fd, 1245, &job->jp, &job->databuf, &job->datalen); + ret = sinfonia_read_parse(data_fd, 1245, job); if (ret) { free(job); return ret; diff --git a/backend_shinkos2145.c b/backend_shinkos2145.c index 859560d..18621ea 100644 --- a/backend_shinkos2145.c +++ b/backend_shinkos2145.c @@ -53,99 +53,7 @@ enum { S_FINISHED, }; -#if 0 -/* Structure of printjob header. All fields are LITTLE ENDIAN */ -struct s2145_printjob_hdr { - uint32_t len1; /* Fixed at 0x10 */ - uint32_t model; /* Equal to the printer model (eg '2145' or '1245' decimal) */ - uint32_t unk2; - uint32_t unk3; /* Fixed at 0x01 */ - - uint32_t len2; /* Fixed at 0x64 */ - uint32_t unk5; - uint32_t media; - uint32_t unk6; - - uint32_t method; - uint32_t oc_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)); -#endif - /* Structs for printer */ -#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 - -static char *cmd_names(uint16_t v) { - switch (le16_to_cpu(v)) { - case S2145_CMD_STATUS: - return "Get Status"; - case S2145_CMD_MEDIAINFO: - return "Get Media Info"; - case S2145_CMD_MODELNAME: - return "Get Model Name"; - case S2145_CMD_ERRORLOG: - return "Get Error Log"; - case S2145_CMD_PRINTJOB: - return "Print"; - case S2145_CMD_CANCELJOB: - return "Cancel Print"; - case S2145_CMD_FLASHLED: - return "Flash LEDs"; - case S2145_CMD_RESET: - return "Reset"; - case S2145_CMD_READTONE: - return "Read Tone Curve"; - case S2145_CMD_BUTTON: - return "Button Enable"; - case S2145_CMD_GETUNIQUE: - return "Get Unique String"; - case S2145_CMD_FWINFO: - return "Get Firmware Info"; - case S2145_CMD_UPDATE: - return "Update"; - case S2145_CMD_SETUNIQUE: - return "Set Unique String"; - default: - return "Unknown Command"; - } -} - struct s2145_print_cmd { struct sinfonia_cmd_hdr hdr; uint8_t id; @@ -157,43 +65,17 @@ struct s2145_print_cmd { uint8_t method; } __attribute__((packed)); -#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_sizes (uint8_t v) { - switch (v) { - case PRINT_MEDIA_4x6: - return "4x6"; - case PRINT_MEDIA_5x3_5: - return "5x3.5"; - case PRINT_MEDIA_5x7: - return "5x7"; - case PRINT_MEDIA_6x9: - return "6x9"; - case PRINT_MEDIA_6x8: - return "6x8"; - case PRINT_MEDIA_2x6: - return "2x6"; - default: - return "Unknown"; - } -} - static int print_counts (uint8_t v) { switch (v) { - case PRINT_MEDIA_4x6: + case CODE_4x6: return 700; - case PRINT_MEDIA_5x3_5: + case CODE_3_5x5: return 800; - case PRINT_MEDIA_5x7: + case CODE_5x7: return 400; - case PRINT_MEDIA_6x9: + case CODE_6x9: return 310; - case PRINT_MEDIA_6x8: + case CODE_6x8: return 350; default: return 700; @@ -492,81 +374,6 @@ static char *error_codes(uint8_t major, uint8_t minor) } } - -#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_OP 0x69 -#define STATUS_PAPER_CUT 0x6A -#define STATUS_PAPER_EJECT 0x6B -#define STATUS_BACK_FEED_E 0x6C -#define STATUS_FINISHED 0x6D - -static char *status_str(uint8_t v) { - switch (v) { - case STATUS_READY: - return "Ready"; - case STATUS_INIT_CPU: - return "Initializing CPU"; - case STATUS_INIT_RIBBON: - return "Initializing Ribbon"; - case STATUS_INIT_PAPER: - return "Loading Paper"; - case STATUS_THERMAL_PROTECT: - return "Thermal Protection"; - case STATUS_USING_PANEL: - return "Using Operation Panel"; - case STATUS_SELF_DIAG: - return "Processing Self Diagnosis"; - case STATUS_DOWNLOADING: - return "Processing Download"; - case STATUS_FEEDING_PAPER: - return "Feeding Paper"; - case STATUS_PRE_HEAT: - return "Pre-Heating"; - case STATUS_PRINT_Y: - return "Printing Yellow"; - case STATUS_BACK_FEED_Y: - return "Back-Feeding - Yellow Complete"; - case STATUS_PRINT_M: - return "Printing Magenta"; - case STATUS_BACK_FEED_M: - return "Back-Feeding - Magenta Complete"; - case STATUS_PRINT_C: - return "Printing Cyan"; - case STATUS_BACK_FEED_C: - return "Back-Feeding - Cyan Complete"; - case STATUS_PRINT_OP: - return "Laminating"; - case STATUS_PAPER_CUT: - return "Cutting Paper"; - case STATUS_PAPER_EJECT: - return "Ejecting Paper"; - case STATUS_BACK_FEED_E: - return "Back-Feeding - Ejected"; - case STATUS_FINISHED: - return "Print Finished"; - case ERROR_PRINTER: - return "Printer Error"; - default: - return "Unknown"; - } -} - struct s2145_status_resp { struct sinfonia_status_hdr hdr; uint32_t count_lifetime; @@ -593,19 +400,10 @@ struct s2145_readtone_resp { uint16_t total_size; } __attribute__((packed)); -struct s2145_mediainfo_item { - uint8_t code; - uint16_t columns; - uint16_t rows; - uint8_t media_type; - uint8_t print_method; - uint8_t reserved[3]; -} __attribute__((packed)); - struct s2145_mediainfo_resp { struct sinfonia_status_hdr hdr; uint8_t count; - struct s2145_mediainfo_item items[10]; /* Not all necessarily used */ + struct sinfonia_mediainfo_item items[10]; /* Not all necessarily used */ } __attribute__((packed)); struct s2145_modelname_resp { @@ -615,12 +413,6 @@ struct s2145_modelname_resp { uint8_t modelname[40]; } __attribute__((packed)); -struct s2145_errorlog_resp { - struct sinfonia_status_hdr hdr; - uint8_t count; - struct sinfonia_error_item items[10]; /* Not all necessarily used */ -} __attribute__((packed)); - struct s2145_getunique_resp { struct sinfonia_status_hdr hdr; uint8_t data[24]; /* Not necessarily all used. */ @@ -641,17 +433,14 @@ struct shinkos2145_ctx { int media_code; }; -#define READBACK_LEN 128 /* Needs to be larger than largest response hdr */ -#define CMDBUF_LEN sizeof(struct s2145_print_cmd) - -static uint8_t rdbuf[READBACK_LEN]; - static int s2145_do_cmd(struct shinkos2145_ctx *ctx, uint8_t *cmd, int cmdlen, - int minlen, int *num) + uint8_t *resp, int resplen, + int *num) { int ret; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr *resphdr = (struct sinfonia_status_hdr *)resp; + struct sinfonia_cmd_hdr *cmdhdr = (struct sinfonia_cmd_hdr *) cmd; libusb_device_handle *dev = ctx->dev; uint8_t endp_up = ctx->endp_up; @@ -659,83 +448,84 @@ static int s2145_do_cmd(struct shinkos2145_ctx *ctx, if ((ret = send_data(dev, endp_down, cmd, cmdlen))) - return (ret < 0) ? ret : -99; + goto fail; ret = read_data(dev, endp_up, - rdbuf, READBACK_LEN, num); + resp, resplen, num); if (ret < 0) - return ret; - if (*num < minlen) { - ERROR("Short read! (%d/%d))\n", *num, minlen); - return -99; - } + goto fail; - if (resp->result != RESULT_SUCCESS) { - INFO("Printer Status: %02x (%s)\n", resp->status, - status_str(resp->status)); + if (resphdr->result != RESULT_SUCCESS) { + INFO("Printer Status: %02x (%s)\n", resphdr->status, + sinfonia_status_str(resphdr->status)); INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x = %s)\n", - resp->result, resp->error, resp->printer_major, - resp->printer_minor, error_codes(resp->printer_major, resp->printer_minor)); - return -99; + resphdr->result, resphdr->error, resphdr->printer_major, + resphdr->printer_minor, error_codes(resphdr->printer_major, resphdr->printer_minor)); + goto fail; } - return ret; + return 0; +fail: + ERROR("Failed to execute %s command\n", sinfonia_cmd_names(cmdhdr->cmd)); + if (ret < 0) + return ret; + else + return -99; } static int get_status(struct shinkos2145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s2145_status_resp *resp = (struct s2145_status_resp *) rdbuf; + struct s2145_status_resp resp; int ret, num = 0; - cmd.cmd = cpu_to_le16(S2145_CMD_STATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - INFO("Printer Status: 0x%02x (%s)\n", resp->hdr.status, - status_str(resp->hdr.status)); - if (resp->hdr.status == ERROR_PRINTER) { - if(resp->hdr.error == ERROR_NONE) - resp->hdr.error = resp->hdr.status; + INFO("Printer Status: 0x%02x (%s)\n", resp.hdr.status, + sinfonia_status_str(resp.hdr.status)); + if (resp.hdr.status == ERROR_PRINTER) { + if(resp.hdr.error == ERROR_NONE) + resp.hdr.error = resp.hdr.status; INFO(" Error 0x%02x (%s) 0x%02x/0x%02x (%s)\n", - resp->hdr.error, - sinfonia_error_str(resp->hdr.error), - resp->hdr.printer_major, - resp->hdr.printer_minor, error_codes(resp->hdr.printer_major, resp->hdr.printer_minor)); + resp.hdr.error, + sinfonia_error_str(resp.hdr.error), + resp.hdr.printer_major, + resp.hdr.printer_minor, error_codes(resp.hdr.printer_major, resp.hdr.printer_minor)); } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_status_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct s2145_status_resp) - sizeof(struct sinfonia_status_hdr))) return 0; INFO(" Print Counts:\n"); - INFO("\tSince Paper Changed:\t%08u\n", le32_to_cpu(resp->count_paper)); - INFO("\tLifetime:\t\t%08u\n", le32_to_cpu(resp->count_lifetime)); - INFO("\tMaintenance:\t\t%08u\n", le32_to_cpu(resp->count_maint)); - INFO("\tPrint Head:\t\t%08u\n", le32_to_cpu(resp->count_head)); - INFO(" Cutter Actuations:\t%08u\n", le32_to_cpu(resp->count_cutter)); - INFO(" Ribbon Remaining:\t%08u\n", le32_to_cpu(resp->count_ribbon_left)); + INFO("\tSince Paper Changed:\t%08u\n", le32_to_cpu(resp.count_paper)); + INFO("\tLifetime:\t\t%08u\n", le32_to_cpu(resp.count_lifetime)); + INFO("\tMaintenance:\t\t%08u\n", le32_to_cpu(resp.count_maint)); + INFO("\tPrint Head:\t\t%08u\n", le32_to_cpu(resp.count_head)); + INFO(" Cutter Actuations:\t%08u\n", le32_to_cpu(resp.count_cutter)); + INFO(" Ribbon Remaining:\t%08u\n", le32_to_cpu(resp.count_ribbon_left)); INFO("Bank 1: 0x%02x (%s) Job %03u @ %03u/%03u (%03u remaining)\n", - resp->bank1_status, sinfonia_bank_statuses(resp->bank1_status), - resp->bank1_printid, - le16_to_cpu(resp->bank1_finished), - le16_to_cpu(resp->bank1_specified), - le16_to_cpu(resp->bank1_remaining)); + resp.bank1_status, sinfonia_bank_statuses(resp.bank1_status), + resp.bank1_printid, + le16_to_cpu(resp.bank1_finished), + le16_to_cpu(resp.bank1_specified), + le16_to_cpu(resp.bank1_remaining)); INFO("Bank 2: 0x%02x (%s) Job %03u @ %03u/%03u (%03u remaining)\n", - resp->bank2_status, sinfonia_bank_statuses(resp->bank1_status), - resp->bank2_printid, - le16_to_cpu(resp->bank2_finished), - le16_to_cpu(resp->bank2_specified), - le16_to_cpu(resp->bank2_remaining)); + resp.bank2_status, sinfonia_bank_statuses(resp.bank1_status), + resp.bank2_printid, + le16_to_cpu(resp.bank2_finished), + le16_to_cpu(resp.bank2_specified), + le16_to_cpu(resp.bank2_remaining)); - INFO("Tonecurve Status: 0x%02x (%s)\n", resp->tonecurve_status, sinfonia_tonecurve_statuses(resp->tonecurve_status)); + INFO("Tonecurve Status: 0x%02x (%s)\n", resp.tonecurve_status, sinfonia_tonecurve_statuses(resp.tonecurve_status)); return 0; } @@ -743,11 +533,11 @@ static int get_status(struct shinkos2145_ctx *ctx) static int get_fwinfo(struct shinkos2145_ctx *ctx) { struct sinfonia_fwinfo_cmd cmd; - struct sinfonia_fwinfo_resp *resp = (struct sinfonia_fwinfo_resp *)rdbuf; + struct sinfonia_fwinfo_resp resp; int num = 0; int i; - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_FWINFO); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_FWINFO); cmd.hdr.len = cpu_to_le16(1); INFO("FW Information:\n"); @@ -758,23 +548,22 @@ static int get_fwinfo(struct shinkos2145_ctx *ctx) if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); continue; } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct sinfonia_fwinfo_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct sinfonia_fwinfo_resp) - sizeof(struct sinfonia_status_hdr))) continue; INFO(" %s\t ver %02x.%02x\n", fwinfo_targets(i), - resp->major, resp->minor); + resp.major, resp.minor); #if 0 - 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)); + 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)); #endif } return 0; @@ -783,30 +572,29 @@ static int get_fwinfo(struct shinkos2145_ctx *ctx) static int get_errorlog(struct shinkos2145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s2145_errorlog_resp *resp = (struct s2145_errorlog_resp *) rdbuf; + struct sinfonia_errorlog_resp resp; int ret, num = 0; int i; - cmd.cmd = cpu_to_le16(S2145_CMD_ERRORLOG); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_ERRORLOG); cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s2145_errorlog_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct sinfonia_errorlog_resp) - sizeof(struct sinfonia_status_hdr))) return -2; - INFO("Stored Error Events: %u entries:\n", resp->count); - for (i = 0 ; i < resp->count ; i++) { + INFO("Stored Error Events: %u entries:\n", resp.count); + for (i = 0 ; i < resp.count ; i++) { INFO(" %02d: @ %08u prints : 0x%02x/0x%02x (%s)\n", i, - le32_to_cpu(resp->items[i].print_counter), - resp->items[i].major, resp->items[i].minor, - error_codes(resp->items[i].major, resp->items[i].minor)); + le32_to_cpu(resp.items[i].print_counter), + resp.items[i].major, resp.items[i].minor, + error_codes(resp.items[i].major, resp.items[i].minor)); } return 0; } @@ -818,44 +606,44 @@ static void dump_mediainfo(struct s2145_mediainfo_resp *resp) INFO("Supported Media Information: %u entries:\n", resp->count); for (i = 0 ; i < resp->count ; i++) { INFO(" %02d: C 0x%02x (%s), %04ux%04u, P 0x%02x (%s)\n", i, - resp->items[i].code, print_sizes(resp->items[i].code), + resp->items[i].code, + sinfonia_print_codes(resp->items[i].code, 0), resp->items[i].columns, resp->items[i].rows, - resp->items[i].print_method, - sinfonia_print_methods(resp->items[i].print_method)); + resp->items[i].method, + sinfonia_print_methods(resp->items[i].method)); } } static int get_user_string(struct shinkos2145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s2145_getunique_resp *resp = (struct s2145_getunique_resp*) rdbuf; + struct s2145_getunique_resp resp; int ret, num = 0; - cmd.cmd = cpu_to_le16(S2145_CMD_GETUNIQUE); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETUNIQUE); cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp) - 1, + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } /* Null-terminate */ - 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); + 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); return 0; } static int set_user_string(struct shinkos2145_ctx *ctx, char *str) { struct s2145_setunique_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; if (str) { @@ -868,14 +656,13 @@ static int set_user_string(struct shinkos2145_ctx *ctx, char *str) cmd.len = 0; } - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_SETUNIQUE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_SETUNIQUE); cmd.hdr.len = cpu_to_le16(cmd.len + 1); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, cmd.len + 1 + sizeof(cmd.hdr), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -885,7 +672,7 @@ static int set_user_string(struct shinkos2145_ctx *ctx, char *str) static int cancel_job(struct shinkos2145_ctx *ctx, char *str) { struct sinfonia_cancel_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; if (!str) @@ -893,14 +680,13 @@ static int cancel_job(struct shinkos2145_ctx *ctx, char *str) cmd.id = atoi(str); - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_CANCELJOB); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_CANCELJOB); cmd.hdr.len = cpu_to_le16(1); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -910,17 +696,16 @@ static int cancel_job(struct shinkos2145_ctx *ctx, char *str) static int flash_led(struct shinkos2145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; - cmd.cmd = cpu_to_le16(S2145_CMD_FLASHLED); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_FLASHLED); cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } @@ -930,19 +715,19 @@ static int flash_led(struct shinkos2145_ctx *ctx) static int reset_curve(struct shinkos2145_ctx *ctx, int target) { struct s2145_reset_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; + int ret, num = 0; cmd.target = target; - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_RESET); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_RESET); cmd.hdr.len = cpu_to_le16(1); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -952,19 +737,18 @@ static int reset_curve(struct shinkos2145_ctx *ctx, int target) static int button_set(struct shinkos2145_ctx *ctx, int enable) { struct s2145_button_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_BUTTON); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_BUTTON); cmd.hdr.len = cpu_to_le16(1); cmd.enabled = enable; if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&cmd, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -974,7 +758,7 @@ static int button_set(struct shinkos2145_ctx *ctx, int enable) static int get_tonecurve(struct shinkos2145_ctx *ctx, int type, char *fname) { struct s2145_readtone_cmd cmd; - struct s2145_readtone_resp *resp = (struct s2145_readtone_resp *) rdbuf; + struct s2145_readtone_resp resp; int ret, num = 0; uint8_t *data; @@ -984,33 +768,32 @@ static int get_tonecurve(struct shinkos2145_ctx *ctx, int type, char *fname) cmd.curveid = type; - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_READTONE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_READTONE); cmd.hdr.len = cpu_to_le16(1); INFO("Dump %s Tone Curve to '%s'\n", sinfonia_tonecurve_statuses(type), fname); if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } - resp->total_size = le16_to_cpu(resp->total_size); + resp.total_size = le16_to_cpu(resp.total_size); - data = malloc(resp->total_size * 2); + data = malloc(resp.total_size * 2); if (!data) { ERROR("Memory allocation failure! (%d bytes)\n", - resp->total_size * 2); + resp.total_size * 2); return -1; } i = 0; - while (i < resp->total_size) { + while (i < resp.total_size) { ret = read_data(ctx->dev, ctx->endp_up, data + i, - resp->total_size * 2 - i, + resp.total_size * 2 - i, &num); if (ret < 0) goto done; @@ -1018,7 +801,7 @@ static int get_tonecurve(struct shinkos2145_ctx *ctx, int type, char *fname) } i = j = 0; - while (i < resp->total_size) { + while (i < resp.total_size) { memcpy(curves + j, data + i+2, data[i+1]); j += data[i+1] / 2; i += data[i+1] + 2; @@ -1054,7 +837,7 @@ done: static int set_tonecurve(struct shinkos2145_ctx *ctx, int target, char *fname) { struct s2145_update_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; INFO("Set %s Tone Curve from '%s'\n", sinfonia_update_targets(target), fname); @@ -1083,7 +866,7 @@ static int set_tonecurve(struct shinkos2145_ctx *ctx, int target, char *fname) cmd.reserved = 0; cmd.size = cpu_to_le32(TONE_CURVE_SIZE * sizeof(uint16_t)); - cmd.hdr.cmd = cpu_to_le16(S2145_CMD_UPDATE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_UPDATE); cmd.hdr.len = cpu_to_le16(sizeof(struct s2145_update_cmd)-sizeof(cmd.hdr)); /* Byteswap data to format printer is expecting.. */ @@ -1093,9 +876,8 @@ static int set_tonecurve(struct shinkos2145_ctx *ctx, int target, char *fname) if ((ret = s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); goto done; } @@ -1234,21 +1016,18 @@ static int shinkos2145_attach(void *vctx, struct libusb_device_handle *dev, int if (test_mode < TEST_MODE_NOATTACH) { /* Query Media */ struct sinfonia_cmd_hdr cmd; - struct s2145_mediainfo_resp *resp = (struct s2145_mediainfo_resp *) rdbuf; int num = 0; int i; - cmd.cmd = cpu_to_le16(S2145_CMD_MEDIAINFO); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_MEDIAINFO); cmd.len = cpu_to_le16(0); if (s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&ctx->media, sizeof(ctx->media), &num)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return CUPS_BACKEND_FAILED; } - memcpy(&ctx->media, resp, sizeof(ctx->media)); /* Byteswap media descriptor.. */ for (i = 0 ; i < ctx->media.count ; i++) { @@ -1264,7 +1043,7 @@ static int shinkos2145_attach(void *vctx, struct libusb_device_handle *dev, int } } } else { - int media_code = PRINT_MEDIA_6x9; + int media_code = CODE_6x9; if (getenv("MEDIA_CODE")) media_code = atoi(getenv("MEDIA_CODE")); @@ -1273,7 +1052,7 @@ static int shinkos2145_attach(void *vctx, struct libusb_device_handle *dev, int } ctx->marker.color = "#00FFFF#FF00FF#FFFF00"; - ctx->marker.name = print_sizes(ctx->media_code); + ctx->marker.name = sinfonia_print_codes(ctx->media_code, 0); ctx->marker.levelmax = media_prints; ctx->marker.levelnow = -2; @@ -1315,7 +1094,7 @@ static int shinkos2145_read_parse(void *vctx, const void **vjob, int data_fd, in memset(job, 0, sizeof(*job)); /* Common read/parse code */ - ret = sinfonia_read_parse(data_fd, 2145, &job->jp, &job->databuf, &job->datalen); + ret = sinfonia_read_parse(data_fd, 2145, job); if (ret) { free(job); return ret; @@ -1335,23 +1114,19 @@ static int shinkos2145_main_loop(void *vctx, const void *vjob) { struct shinkos2145_ctx *ctx = vctx; int ret, num; - uint8_t cmdbuf[CMDBUF_LEN]; - uint8_t rdbuf2[READBACK_LEN]; int i, last_state = -1, state = S_IDLE; - struct sinfonia_cmd_hdr *cmd = (struct sinfonia_cmd_hdr *) cmdbuf;; - struct s2145_print_cmd *print = (struct s2145_print_cmd *) cmdbuf; - struct s2145_status_resp *sts = (struct s2145_status_resp *) rdbuf; - struct sinfonia_printjob *job = (struct sinfonia_printjob*) vjob; + struct sinfonia_cmd_hdr cmd; + struct s2145_status_resp sts, sts2; /* Validate print sizes */ for (i = 0; i < ctx->media.count ; i++) { /* Look for matching media */ if (ctx->media.items[i].columns == job->jp.columns && ctx->media.items[i].rows == job->jp.rows && - ctx->media.items[i].print_method == job->jp.method) + ctx->media.items[i].method == job->jp.method) break; } if (i == ctx->media.count) { @@ -1368,32 +1143,30 @@ top: } /* Send Status Query */ - memset(cmdbuf, 0, CMDBUF_LEN); - cmd->cmd = cpu_to_le16(S2145_CMD_STATUS); - cmd->len = cpu_to_le16(0); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); + cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(ctx, - cmdbuf, sizeof(*cmd), - sizeof(struct sinfonia_status_hdr), + (uint8_t*)&cmd, sizeof(cmd), + (uint8_t*)&sts, sizeof(sts), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd->cmd)); return CUPS_BACKEND_FAILED; } - if (memcmp(rdbuf, rdbuf2, READBACK_LEN)) { - memcpy(rdbuf2, rdbuf, READBACK_LEN); + if (memcmp(&sts, &sts2, sizeof(sts))) { + memcpy(&sts2, &sts, sizeof(sts)); INFO("Printer Status: 0x%02x (%s)\n", - sts->hdr.status, status_str(sts->hdr.status)); + sts.hdr.status, sinfonia_status_str(sts.hdr.status)); - if (ctx->marker.levelnow != (int)sts->count_ribbon_left) { - ctx->marker.levelnow = sts->count_ribbon_left; + if (ctx->marker.levelnow != (int)sts.count_ribbon_left) { + ctx->marker.levelnow = sts.count_ribbon_left; dump_markers(&ctx->marker, 1, 0); } - if (sts->hdr.result != RESULT_SUCCESS) + if (sts.hdr.result != RESULT_SUCCESS) goto printer_error; - if (sts->hdr.error == ERROR_PRINTER) + if (sts.hdr.error == ERROR_PRINTER) goto printer_error; } else if (state == last_state) { sleep(1); @@ -1409,8 +1182,8 @@ top: /* make sure we're not colliding with an existing jobid */ - while (ctx->jobid == sts->bank1_printid || - ctx->jobid == sts->bank2_printid) { + while (ctx->jobid == sts.bank1_printid || + ctx->jobid == sts.bank2_printid) { ctx->jobid++; ctx->jobid &= 0x7f; if (!ctx->jobid) @@ -1418,42 +1191,43 @@ top: } /* If either bank is free, continue */ - if (sts->bank1_status == BANK_STATUS_FREE || - sts->bank2_status == BANK_STATUS_FREE) + if (sts.bank1_status == BANK_STATUS_FREE || + sts.bank2_status == BANK_STATUS_FREE) state = S_PRINTER_READY_CMD; break; - case S_PRINTER_READY_CMD: + case S_PRINTER_READY_CMD: { + struct s2145_print_cmd print; + INFO("Sending print job (internal id %u)\n", ctx->jobid); - memset(cmdbuf, 0, CMDBUF_LEN); - print->hdr.cmd = cpu_to_le16(S2145_CMD_PRINTJOB); - print->hdr.len = cpu_to_le16(sizeof (*print) - sizeof(*cmd)); + memset(&print, 0, sizeof(print)); + print.hdr.cmd = cpu_to_le16(SINFONIA_CMD_PRINTJOB); + print.hdr.len = cpu_to_le16(sizeof(print) - sizeof(print.hdr)); - print->id = ctx->jobid; - print->count = cpu_to_le16(job->copies); - print->columns = cpu_to_le16(job->jp.columns); - print->rows = cpu_to_le16(job->jp.rows); - print->media = job->jp.media; - print->mode = job->jp.oc_mode; - print->method = job->jp.method; + print.id = ctx->jobid; + print.count = cpu_to_le16(job->copies); + print.columns = cpu_to_le16(job->jp.columns); + print.rows = cpu_to_le16(job->jp.rows); + print.media = job->jp.media; + print.mode = job->jp.oc_mode; + print.method = job->jp.method; if ((ret = s2145_do_cmd(ctx, - cmdbuf, sizeof(*print), - sizeof(struct sinfonia_status_hdr), + (uint8_t*)&print, sizeof(print), + (uint8_t*)&sts, sizeof(sts), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(print->hdr.cmd)); return ret; } - if (sts->hdr.result != RESULT_SUCCESS) { - if (sts->hdr.error == ERROR_BUFFER_FULL) { + if (sts.hdr.result != RESULT_SUCCESS) { + if (sts.hdr.error == ERROR_BUFFER_FULL) { INFO("Printer Buffers full, retrying\n"); break; - } else if ((sts->hdr.status & 0xf0) == 0x30 || sts->hdr.status == 0x21) { - INFO("Printer busy (%s), retrying\n", status_str(sts->hdr.status)); + } else if ((sts.hdr.status & 0xf0) == 0x30 || sts.hdr.status == 0x21) { + INFO("Printer busy (%s), retrying\n", sinfonia_status_str(sts.hdr.status)); break; - } else if (sts->hdr.status != ERROR_NONE) + } else if (sts.hdr.status != ERROR_NONE) goto printer_error; } @@ -1466,13 +1240,14 @@ top: sleep(1); state = S_PRINTER_SENT_DATA; break; + } case S_PRINTER_SENT_DATA: if (fast_return) { INFO("Fast return mode enabled.\n"); state = S_FINISHED; - } else if (sts->hdr.status == STATUS_READY || - sts->hdr.status == STATUS_FINISHED || - sts->hdr.status == ERROR_PRINTER) { + } else if (sts.hdr.status == STATUS_READY || + sts.hdr.status == STATUS_FINISHED || + sts.hdr.status == ERROR_PRINTER) { state = S_FINISHED; } break; @@ -1483,14 +1258,14 @@ top: if (state != S_FINISHED) goto top; - if (sts->hdr.status == ERROR_PRINTER) { - if(sts->hdr.error == ERROR_NONE) - sts->hdr.error = sts->hdr.status; + if (sts.hdr.status == ERROR_PRINTER) { + if(sts.hdr.error == ERROR_NONE) + sts.hdr.error = sts.hdr.status; INFO(" Error 0x%02x (%s) 0x%02x/0x%02x (%s)\n", - sts->hdr.error, - sinfonia_error_str(sts->hdr.error), - sts->hdr.printer_major, - sts->hdr.printer_minor, error_codes(sts->hdr.printer_major, sts->hdr.printer_minor)); + sts.hdr.error, + sinfonia_error_str(sts.hdr.error), + sts.hdr.printer_major, + sts.hdr.printer_minor, error_codes(sts.hdr.printer_major, sts.hdr.printer_minor)); } INFO("Print complete\n"); @@ -1499,19 +1274,19 @@ top: printer_error: ERROR("Printer reported error: %#x (%s) status: %#x (%s) -> %#x.%#x (%s)\n", - sts->hdr.error, - sinfonia_error_str(sts->hdr.error), - sts->hdr.status, - status_str(sts->hdr.status), - sts->hdr.printer_major, sts->hdr.printer_minor, - error_codes(sts->hdr.printer_major, sts->hdr.printer_minor)); + sts.hdr.error, + sinfonia_error_str(sts.hdr.error), + sts.hdr.status, + sinfonia_status_str(sts.hdr.status), + sts.hdr.printer_major, sts.hdr.printer_minor, + error_codes(sts.hdr.printer_major, sts.hdr.printer_minor)); return CUPS_BACKEND_FAILED; } static int shinkos2145_query_serno(struct libusb_device_handle *dev, uint8_t endp_up, uint8_t endp_down, char *buf, int buf_len) { struct sinfonia_cmd_hdr cmd; - struct s2145_getunique_resp *resp = (struct s2145_getunique_resp*) rdbuf; + struct s2145_getunique_resp resp; int ret, num = 0; struct shinkos2145_ctx ctx = { @@ -1520,24 +1295,20 @@ static int shinkos2145_query_serno(struct libusb_device_handle *dev, uint8_t end .endp_down = endp_down, }; - cmd.cmd = cpu_to_le16(S2145_CMD_GETUNIQUE); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETUNIQUE); cmd.len = cpu_to_le16(0); if ((ret = s2145_do_cmd(&ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp) - 1, + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - /* Null-terminate */ - 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; - strncpy(buf, (char*)resp->data, buf_len); - buf[buf_len-1] = 0; /* ensure it's null terminated */ + /* Copy and Null-terminate */ + num = (buf_len > (int)sizeof(resp.data)) ? (int)sizeof(resp.data) : (buf_len - 1); + memcpy(buf, resp.data, num); + buf[num] = 0; return CUPS_BACKEND_OK; } @@ -1546,22 +1317,21 @@ static int shinkos2145_query_markers(void *vctx, struct marker **markers, int *c { struct shinkos2145_ctx *ctx = vctx; struct sinfonia_cmd_hdr cmd; - struct s2145_status_resp *sts = (struct s2145_status_resp *) rdbuf; + struct s2145_status_resp sts; int num; /* Query Status */ - cmd.cmd = cpu_to_le16(S2145_CMD_STATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if (s2145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*sts), + (uint8_t*)&sts, sizeof(sts), &num)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return CUPS_BACKEND_FAILED; } - ctx->marker.levelnow = ctx->marker.levelmax - le32_to_cpu(sts->count_ribbon_left); + ctx->marker.levelnow = ctx->marker.levelmax - le32_to_cpu(sts.count_ribbon_left); *markers = &ctx->marker; *count = 1; @@ -1584,7 +1354,7 @@ static const char *shinkos2145_prefixes[] = { struct dyesub_backend shinkos2145_backend = { .name = "Shinko/Sinfonia CHC-S2145/S2", - .version = "0.58", + .version = "0.60", .uri_prefixes = shinkos2145_prefixes, .cmdline_usage = shinkos2145_cmdline, .cmdline_arg = shinkos2145_cmdline_arg, diff --git a/backend_shinkos6145.c b/backend_shinkos6145.c index 62ceba1..a6f3b10 100644 --- a/backend_shinkos6145.c +++ b/backend_shinkos6145.c @@ -96,48 +96,6 @@ enum { S_FINISHED, }; -#if 0 -/* Structure of printjob header. All fields are LITTLE ENDIAN */ -struct s6145_printjob_hdr { - uint32_t len1; /* Fixed at 0x10 */ - uint32_t model; /* Equal to the printer model (eg '6245' or '1245' decimal) */ - uint32_t media_w; /* 0x02 for 5", 0x03 for 6" <-- IGNORED by backend. */ - uint32_t unk3; /* Fixed at 0x01 */ - - uint32_t len2; /* Fixed at 0x64 */ - uint32_t unk5; - uint32_t media; /* 0x08 5x5, 0x03 5x7, 0x07 2x6, 0x00 4x6, 0x06 6x6/6x6+6x2/4x6*2/6x8 */ - uint32_t unk6; - - uint32_t method; /* 0x00 normal, 0x02 4x6*2, 0x04 2x6*2, 0x05 6x6+2x6 */ - uint32_t qual; /* 0x00 default, 0x01 std <-- IGNORED by backend */ - uint32_t oc_mode; /* 0x00 default, 0x01 off, 0x02 glossy, 0x03 matte */ - 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 ext_flags; /* 0x00 in the official headers. 0x01 to mark inout data as YMC planar */ -} __attribute__((packed)); -#endif - /* "Image Correction Parameter" File */ // 128 bytes total, apparently an array of 32-bit values struct tankParamTable { @@ -265,72 +223,6 @@ struct shinkos6145_correctionparam { } __attribute__((packed)); /* 16384 bytes */ /* Structs for printer */ -#define S6145_CMD_GETSTATUS 0x0001 -#define S6145_CMD_MEDIAINFO 0x0002 -#define S6145_CMD_ERRORLOG 0x0004 -#define S6145_CMD_GETPARAM 0x0005 -#define S6145_CMD_GETSERIAL 0x0006 -#define S6145_CMD_PRINTSTAT 0x0007 -#define S6145_CMD_EXTCOUNTER 0x0008 -#define S6145_CMD_MEMORYBANK 0x000A // Brava 21 only? - -#define S6145_CMD_PRINTJOB 0x4001 -#define S6145_CMD_CANCELJOB 0x4002 -#define S6145_CMD_FLASHLED 0x4003 -#define S6145_CMD_RESET 0x4004 -#define S6145_CMD_READTONE 0x4005 -#define S6145_CMD_SETPARAM 0x4007 - -#define S6145_CMD_GETCORR 0x400D -#define S6145_CMD_GETEEPROM 0x400E -#define S6145_CMD_SETEEPROM 0x400F - -#define S6145_CMD_FWINFO 0xC003 -#define S6145_CMD_UPDATE 0xC004 - -static char *cmd_names(uint16_t v) { - switch (le16_to_cpu(v)) { - case S6145_CMD_GETSTATUS: - return "Get Status"; - case S6145_CMD_MEDIAINFO: - return "Get Media Info"; - case S6145_CMD_ERRORLOG: - return "Get Error Log"; - case S6145_CMD_GETPARAM: - return "Get Parameter"; - case S6145_CMD_GETSERIAL: - return "Get Serial Number"; - case S6145_CMD_PRINTSTAT: - return "Get Print ID Status"; - case S6145_CMD_EXTCOUNTER: - return "Get Extended Counters"; - case S6145_CMD_PRINTJOB: - return "Print"; - case S6145_CMD_CANCELJOB: - return "Cancel Print"; - case S6145_CMD_FLASHLED: - return "Flash LEDs"; - case S6145_CMD_RESET: - return "Reset"; - case S6145_CMD_READTONE: - return "Read Tone Curve"; - case S6145_CMD_SETPARAM: - return "Set Parameter"; - case S6145_CMD_GETCORR: - return "Get Image Correction Parameter"; - case S6145_CMD_GETEEPROM: - return "Get EEPROM Backup Parameter"; - case S6145_CMD_SETEEPROM: - return "Set EEPROM Backup Parameter"; - case S6145_CMD_FWINFO: - return "Get Firmware Info"; - case S6145_CMD_UPDATE: - return "Update"; - default: - return "Unknown Command"; - } -} - struct s6145_print_cmd { struct sinfonia_cmd_hdr hdr; uint8_t id; @@ -384,12 +276,6 @@ struct s6145_readtone_cmd { #define READ_TONE_CURVE_USER 0x01 #define READ_TONE_CURVE_CURR 0x02 -struct s6145_setparam_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t target; - uint32_t param; -} __attribute__((packed)); - #define PARAM_OC_PRINT 0x20 #define PARAM_PAPER_PRESV 0x3d #define PARAM_DRIVER_MODE 0x3e @@ -418,26 +304,11 @@ struct s6145_setparam_cmd { #define PARAM_SLEEP_120MIN 0x00000004 #define PARAM_SLEEP_240MIN 0x00000005 -struct s6145_seteeprom_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t data[256]; /* Maxlen */ -} __attribute__((packed)); - struct s6145_errorlog_cmd { struct sinfonia_cmd_hdr hdr; uint16_t index; /* 0 is latest */ } __attribute__((packed)); -struct s6145_getparam_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t target; -} __attribute__((packed)); - -struct s6145_getprintidstatus_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t id; -} __attribute__((packed)); - #define FWINFO_TARGET_MAIN_BOOT 0x01 #define FWINFO_TARGET_MAIN_APP 0x02 #define FWINFO_TARGET_PRINT_TABLES 0x03 @@ -660,77 +531,6 @@ static char *error_codes(uint8_t major, uint8_t minor) } } -#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_OP 0x69 -#define STATUS_PAPER_CUT 0x6A -#define STATUS_PAPER_EJECT 0x6B -#define STATUS_BACK_FEED_E 0x6C - -static char *status_str(uint8_t v) { - switch (v) { - case STATUS_READY: - return "Ready"; - case STATUS_INIT_CPU: - return "Initializing CPU"; - case STATUS_INIT_RIBBON: - return "Initializing Ribbon"; - case STATUS_INIT_PAPER: - return "Loading Paper"; - case STATUS_THERMAL_PROTECT: - return "Thermal Protection"; - case STATUS_USING_PANEL: - return "Using Operation Panel"; - case STATUS_SELF_DIAG: - return "Processing Self Diagnosis"; - case STATUS_DOWNLOADING: - return "Processing Download"; - case STATUS_FEEDING_PAPER: - return "Feeding Paper"; - case STATUS_PRE_HEAT: - return "Pre-Heating"; - case STATUS_PRINT_Y: - return "Printing Yellow"; - case STATUS_BACK_FEED_Y: - return "Back-Feeding - Yellow Complete"; - case STATUS_PRINT_M: - return "Printing Magenta"; - case STATUS_BACK_FEED_M: - return "Back-Feeding - Magenta Complete"; - case STATUS_PRINT_C: - return "Printing Cyan"; - case STATUS_BACK_FEED_C: - return "Back-Feeding - Cyan Complete"; - case STATUS_PRINT_OP: - return "Laminating"; - case STATUS_PAPER_CUT: - return "Cutting Paper"; - case STATUS_PAPER_EJECT: - return "Ejecting Paper"; - case STATUS_BACK_FEED_E: - return "Back-Feeding - Ejected"; - case ERROR_PRINTER: - return "Printer Error"; - default: - return "Unknown"; - } -} - struct s6145_status_resp { struct sinfonia_status_hdr hdr; uint32_t count_lifetime; @@ -768,62 +568,6 @@ struct s6145_readtone_resp { uint16_t total_size; } __attribute__((packed)); -struct s6145_mediainfo_item { - uint8_t media_code; - uint16_t columns; - uint16_t rows; - uint8_t reserved; - uint8_t print_method; /* PRINT_METHOD_* */ - uint8_t reserved2[3]; -} __attribute__((packed)); - -#define MEDIA_4x6 0x00 -#define MEDIA_3_5x5 0x01 -#define MEDIA_5x7 0x03 -#define MEDIA_6x9 0x05 -#define MEDIA_6x8 0x06 -#define MEDIA_2x6 0x07 -#define MEDIA_6x6 0x08 -#define MEDIA_89x60mm 0x10 -#define MEDIA_89x59mm 0x11 -#define MEDIA_89x58mm 0x12 -#define MEDIA_89x57mm 0x13 -#define MEDIA_89x56mm 0x14 -#define MEDIA_89x55mm 0x15 - -static char *print_sizes (uint8_t v) { - switch (v) { - case MEDIA_4x6: - return "4x6"; - case MEDIA_3_5x5: - return "3.5x5"; - case MEDIA_5x7: - return "5x7"; - case MEDIA_6x9: - return "6x9"; - case MEDIA_6x8: - return "6x8"; - case MEDIA_2x6: - return "2x6"; - case MEDIA_6x6: - return "6x6"; - case MEDIA_89x60mm: - return "89x60mm"; - case MEDIA_89x59mm: - return "89x59mm"; - case MEDIA_89x58mm: - return "89x58mm"; - case MEDIA_89x57mm: - return "89x57mm"; - case MEDIA_89x56mm: - return "89x56mm"; - case MEDIA_89x55mm: - return "89x55mm"; - default: - return "Unknown"; - } -} - #define RIBBON_NONE 0x00 #define RIBBON_4x6 0x01 #define RIBBON_3_5x5 0x02 @@ -875,45 +619,7 @@ struct s6145_mediainfo_resp { uint8_t ribbon; uint8_t reserved; uint8_t count; - struct s6145_mediainfo_item items[10]; /* Not all necessarily used */ -} __attribute__((packed)); - -struct s6145_errorlog_resp { - struct sinfonia_status_hdr hdr; - uint8_t count; - struct sinfonia_error_item items[10]; /* Not all necessarily used */ -} __attribute__((packed)); - -struct s6145_getparam_resp { - struct sinfonia_status_hdr hdr; - uint32_t param; -} __attribute__((packed)); - -struct s6145_getserial_resp { - struct sinfonia_status_hdr hdr; - uint8_t data[8]; -} __attribute__((packed)); - -struct s6145_getprintidstatus_resp { - struct sinfonia_status_hdr hdr; - uint8_t id; - uint16_t remaining; - uint16_t finished; - uint16_t specified; - uint16_t status; -} __attribute__((packed)); - -#define STATUS_WAITING 0x0000 -#define STATUS_PRINTING 0x0100 -#define STATUS_COMPLETED 0x0200 -#define STATUS_ERROR 0xFFFF - -struct s6145_getextcounter_resp { - struct sinfonia_status_hdr hdr; - uint32_t lifetime_distance; /* Inches */ - uint32_t maint_distance; - uint32_t head_distance; - uint8_t reserved[32]; + struct sinfonia_mediainfo_item items[10]; /* Not all necessarily used */ } __attribute__((packed)); struct s6145_imagecorr_resp { @@ -957,121 +663,115 @@ static int shinkos6145_get_imagecorr(struct shinkos6145_ctx *ctx); static int shinkos6145_get_eeprom(struct shinkos6145_ctx *ctx); static int get_param(struct shinkos6145_ctx *ctx, int target, uint32_t *param); -#define READBACK_LEN 512 /* Needs to be larger than largest response hdr */ -#define CMDBUF_LEN sizeof(struct s6145_print_cmd) - -uint8_t rdbuf[READBACK_LEN]; - static int s6145_do_cmd(struct shinkos6145_ctx *ctx, uint8_t *cmd, int cmdlen, - int minlen, int *num) + uint8_t *resp, int resplen, + int *num) { - int ret; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; - libusb_device_handle *dev = ctx->dev; uint8_t endp_up = ctx->endp_up; uint8_t endp_down = ctx->endp_down; + int ret; + + struct sinfonia_cmd_hdr *cmdhdr = (struct sinfonia_cmd_hdr *) cmd; + struct sinfonia_status_hdr *resphdr = (struct sinfonia_status_hdr *)resp; if ((ret = send_data(dev, endp_down, - cmd, cmdlen))) - return (ret < 0) ? ret : -99; + cmd, cmdlen))) { + goto fail; + } ret = read_data(dev, endp_up, - rdbuf, READBACK_LEN, num); + (uint8_t *)resp, resplen, num); if (ret < 0) - return ret; - if (*num < minlen) { - ERROR("Short read! (%d/%d))\n", *num, minlen); - return -99; - } + goto fail; - if (resp->result != RESULT_SUCCESS) { - INFO("Printer Status: %02x (%s)\n", resp->status, - status_str(resp->status)); + if (resphdr->result != RESULT_SUCCESS) { + INFO("Printer Status: %02x (%s)\n", resphdr->status, + sinfonia_status_str(resphdr->status)); INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x = %s)\n", - resp->result, resp->error, resp->printer_major, - resp->printer_minor, error_codes(resp->printer_major, resp->printer_minor)); - return -99; + resphdr->result, resphdr->error, resphdr->printer_major, + resphdr->printer_minor, error_codes(resphdr->printer_major, resphdr->printer_minor)); + goto fail; } + return 0; +fail: + ERROR("Failed to execute %s command\n", sinfonia_cmd_names(cmdhdr->cmd)); return ret; } static int get_status(struct shinkos6145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s6145_status_resp *resp = (struct s6145_status_resp *) rdbuf; - struct s6145_getextcounter_resp *resp2 = (struct s6145_getextcounter_resp *) rdbuf; + struct s6145_status_resp resp; + struct sinfonia_getextcounter_resp resp2; int ret, num = 0; uint32_t val; - cmd.cmd = cpu_to_le16(S6145_CMD_GETSTATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), - &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { return ret; } - INFO("Printer Status: 0x%02x (%s)\n", resp->hdr.status, - status_str(resp->hdr.status)); - if (resp->hdr.status == ERROR_PRINTER) { - if(resp->hdr.error == ERROR_NONE) - resp->hdr.error = resp->hdr.status; + INFO("Printer Status: 0x%02x (%s)\n", resp.hdr.status, + sinfonia_status_str(resp.hdr.status)); + if (resp.hdr.status == ERROR_PRINTER) { + if(resp.hdr.error == ERROR_NONE) + resp.hdr.error = resp.hdr.status; INFO(" Error 0x%02x (%s) 0x%02x/0x%02x (%s)\n", - resp->hdr.error, - sinfonia_error_str(resp->hdr.error), - resp->hdr.printer_major, - resp->hdr.printer_minor, error_codes(resp->hdr.printer_major, resp->hdr.printer_minor)); + resp.hdr.error, + sinfonia_error_str(resp.hdr.error), + resp.hdr.printer_major, + resp.hdr.printer_minor, error_codes(resp.hdr.printer_major, resp.hdr.printer_minor)); } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s6145_status_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct s6145_status_resp) - sizeof(struct sinfonia_status_hdr))) return -1; INFO(" Print Counts:\n"); - INFO("\tSince Paper Changed:\t%08u\n", le32_to_cpu(resp->count_paper)); - INFO("\tLifetime:\t\t%08u\n", le32_to_cpu(resp->count_lifetime)); - INFO("\tMaintenance:\t\t%08u\n", le32_to_cpu(resp->count_maint)); - INFO("\tPrint Head:\t\t%08u\n", le32_to_cpu(resp->count_head)); - INFO(" Cutter Actuations:\t%08u\n", le32_to_cpu(resp->count_cutter)); - INFO(" Ribbon Remaining:\t%08u\n", le32_to_cpu(resp->count_ribbon_left)); + INFO("\tSince Paper Changed:\t%08u\n", le32_to_cpu(resp.count_paper)); + INFO("\tLifetime:\t\t%08u\n", le32_to_cpu(resp.count_lifetime)); + INFO("\tMaintenance:\t\t%08u\n", le32_to_cpu(resp.count_maint)); + INFO("\tPrint Head:\t\t%08u\n", le32_to_cpu(resp.count_head)); + INFO(" Cutter Actuations:\t%08u\n", le32_to_cpu(resp.count_cutter)); + INFO(" Ribbon Remaining:\t%08u\n", le32_to_cpu(resp.count_ribbon_left)); INFO("Bank 1: 0x%02x (%s) Job %03u @ %03u/%03u (%03u remaining)\n", - resp->bank1_status, sinfonia_bank_statuses(resp->bank1_status), - resp->bank1_printid, - le16_to_cpu(resp->bank1_finished), - le16_to_cpu(resp->bank1_specified), - le16_to_cpu(resp->bank1_remaining)); + resp.bank1_status, sinfonia_bank_statuses(resp.bank1_status), + resp.bank1_printid, + le16_to_cpu(resp.bank1_finished), + le16_to_cpu(resp.bank1_specified), + le16_to_cpu(resp.bank1_remaining)); INFO("Bank 2: 0x%02x (%s) Job %03u @ %03u/%03u (%03u remaining)\n", - resp->bank2_status, sinfonia_bank_statuses(resp->bank1_status), - resp->bank2_printid, - le16_to_cpu(resp->bank2_finished), - le16_to_cpu(resp->bank2_specified), - le16_to_cpu(resp->bank2_remaining)); + resp.bank2_status, sinfonia_bank_statuses(resp.bank1_status), + resp.bank2_printid, + le16_to_cpu(resp.bank2_finished), + le16_to_cpu(resp.bank2_specified), + le16_to_cpu(resp.bank2_remaining)); - INFO("Tonecurve Status: 0x%02x (%s)\n", resp->tonecurve_status, sinfonia_tonecurve_statuses(resp->tonecurve_status)); + INFO("Tonecurve Status: 0x%02x (%s)\n", resp.tonecurve_status, sinfonia_tonecurve_statuses(resp.tonecurve_status)); /* Query Extended counters */ - cmd.cmd = cpu_to_le16(S6145_CMD_EXTCOUNTER); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_EXTCOUNTER); cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp2), + (uint8_t*)&resp2, sizeof(resp2), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - if (le16_to_cpu(resp2->hdr.payload_len) != (sizeof(struct s6145_getextcounter_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp2.hdr.payload_len) != (sizeof(struct sinfonia_getextcounter_resp) - sizeof(struct sinfonia_status_hdr))) return -1; - INFO("Lifetime Distance: %08u inches\n", le32_to_cpu(resp2->lifetime_distance)); - INFO("Maintenance Distance: %08u inches\n", le32_to_cpu(resp2->maint_distance)); - INFO("Head Distance: %08u inches\n", le32_to_cpu(resp2->head_distance)); + INFO("Lifetime Distance: %08u inches\n", le32_to_cpu(resp2.lifetime_distance)); + INFO("Maintenance Distance: %08u inches\n", le32_to_cpu(resp2.maint_distance)); + INFO("Head Distance: %08u inches\n", le32_to_cpu(resp2.head_distance)); /* Query various params */ if (ctx->type == P_SHINKO_S6145D) { @@ -1127,11 +827,11 @@ static int get_status(struct shinkos6145_ctx *ctx) static int get_fwinfo(struct shinkos6145_ctx *ctx) { struct sinfonia_fwinfo_cmd cmd; - struct sinfonia_fwinfo_resp *resp = (struct sinfonia_fwinfo_resp *)rdbuf; + struct sinfonia_fwinfo_resp resp; int num = 0; int i; - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_FWINFO); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_FWINFO); cmd.hdr.len = cpu_to_le16(1); INFO("FW Information:\n"); @@ -1142,23 +842,22 @@ static int get_fwinfo(struct shinkos6145_ctx *ctx) if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); continue; } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct sinfonia_fwinfo_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct sinfonia_fwinfo_resp) - sizeof(struct sinfonia_status_hdr))) continue; INFO(" %s\t ver %02x.%02x\n", fwinfo_targets(i), - resp->major, resp->minor); + resp.major, resp.minor); #if 0 - 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)); + 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)); #endif } return 0; @@ -1167,30 +866,29 @@ static int get_fwinfo(struct shinkos6145_ctx *ctx) static int get_errorlog(struct shinkos6145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s6145_errorlog_resp *resp = (struct s6145_errorlog_resp *) rdbuf; + struct sinfonia_errorlog_resp resp; int ret, num = 0; int i; - cmd.cmd = cpu_to_le16(S6145_CMD_ERRORLOG); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_ERRORLOG); cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - if (le16_to_cpu(resp->hdr.payload_len) != (sizeof(struct s6145_errorlog_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp.hdr.payload_len) != (sizeof(struct sinfonia_errorlog_resp) - sizeof(struct sinfonia_status_hdr))) return -2; - INFO("Stored Error Events: %u entries:\n", resp->count); - for (i = 0 ; i < resp->count ; i++) { + INFO("Stored Error Events: %u entries:\n", resp.count); + for (i = 0 ; i < resp.count ; i++) { INFO(" %02d: @ %08u prints : 0x%02x/0x%02x (%s)\n", i, - le32_to_cpu(resp->items[i].print_counter), - resp->items[i].major, resp->items[i].minor, - error_codes(resp->items[i].major, resp->items[i].minor)); + le32_to_cpu(resp.items[i].print_counter), + resp.items[i].major, resp.items[i].minor, + error_codes(resp.items[i].major, resp.items[i].minor)); } return 0; } @@ -1203,18 +901,19 @@ static void dump_mediainfo(struct s6145_mediainfo_resp *resp) INFO("Supported Print Sizes: %u entries:\n", resp->count); for (i = 0 ; i < resp->count ; i++) { INFO(" %02d: C 0x%02x (%s), %04ux%04u, P 0x%02x (%s)\n", i, - resp->items[i].media_code, print_sizes(resp->items[i].media_code), + resp->items[i].code, + sinfonia_print_codes(resp->items[i].code, 0), resp->items[i].columns, resp->items[i].rows, - resp->items[i].print_method, - sinfonia_print_methods(resp->items[i].print_method)); + resp->items[i].method, + sinfonia_print_methods(resp->items[i].method)); } } static int cancel_job(struct shinkos6145_ctx *ctx, char *str) { struct sinfonia_cancel_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; if (!str) @@ -1222,14 +921,13 @@ static int cancel_job(struct shinkos6145_ctx *ctx, char *str) cmd.id = atoi(str); - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_CANCELJOB); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_CANCELJOB); cmd.hdr.len = cpu_to_le16(1); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -1239,42 +937,39 @@ static int cancel_job(struct shinkos6145_ctx *ctx, char *str) static int flash_led(struct shinkos6145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; - cmd.cmd = cpu_to_le16(S6145_CMD_FLASHLED); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_FLASHLED); cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } return 0; } - static int set_param(struct shinkos6145_ctx *ctx, int target, uint32_t param) { - struct s6145_setparam_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_setparam_cmd cmd; + struct sinfonia_status_hdr resp; int ret, num = 0; /* Set up command */ cmd.target = target; cmd.param = cpu_to_le32(param); - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_SETPARAM); - cmd.hdr.len = cpu_to_le16(sizeof(struct s6145_setparam_cmd)-sizeof(cmd.hdr)); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_SETPARAM); + cmd.hdr.len = cpu_to_le16(sizeof(struct sinfonia_setparam_cmd)-sizeof(cmd.hdr)); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); } return ret; @@ -1282,44 +977,41 @@ static int set_param(struct shinkos6145_ctx *ctx, int target, uint32_t param) static int get_param(struct shinkos6145_ctx *ctx, int target, uint32_t *param) { - struct s6145_getparam_cmd cmd; - struct s6145_getparam_resp *resp = (struct s6145_getparam_resp *) rdbuf; + struct sinfonia_getparam_cmd cmd; + struct sinfonia_getparam_resp resp; int ret, num = 0; /* Set up command */ cmd.target = target; - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_GETPARAM); - cmd.hdr.len = cpu_to_le16(sizeof(struct s6145_getparam_cmd)-sizeof(cmd.hdr)); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_GETPARAM); + cmd.hdr.len = cpu_to_le16(sizeof(struct sinfonia_getparam_cmd)-sizeof(cmd.hdr)); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); } - *param = le32_to_cpu(resp->param); + *param = le32_to_cpu(resp.param); return ret; } - static int reset_curve(struct shinkos6145_ctx *ctx, int target) { struct s6145_reset_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; cmd.target = target; - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_RESET); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_RESET); cmd.hdr.len = cpu_to_le16(1); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } @@ -1389,7 +1081,7 @@ static int shinkos6145_dump_eeprom(struct shinkos6145_ctx *ctx, char *fname) static int get_tonecurve(struct shinkos6145_ctx *ctx, int type, char *fname) { struct s6145_readtone_cmd cmd; - struct s6145_readtone_resp *resp = (struct s6145_readtone_resp *) rdbuf; + struct s6145_readtone_resp resp; int ret, num = 0; uint8_t *data; @@ -1400,32 +1092,31 @@ static int get_tonecurve(struct shinkos6145_ctx *ctx, int type, char *fname) cmd.target = type; cmd.curveid = TONE_CURVE_ID; - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_READTONE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_READTONE); cmd.hdr.len = cpu_to_le16(1); INFO("Dump %s Tone Curve to '%s'\n", sinfonia_tonecurve_statuses(type), fname); if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); return ret; } - resp->total_size = le16_to_cpu(resp->total_size); + resp.total_size = le16_to_cpu(resp.total_size); - data = malloc(resp->total_size * 2); + data = malloc(resp.total_size * 2); if (!data) { ERROR("Memory Allocation Failure!\n"); return -1; } i = 0; - while (i < resp->total_size) { + while (i < resp.total_size) { ret = read_data(ctx->dev, ctx->endp_up, data + i, - resp->total_size * 2 - i, + resp.total_size * 2 - i, &num); if (ret < 0) goto done; @@ -1433,7 +1124,7 @@ static int get_tonecurve(struct shinkos6145_ctx *ctx, int type, char *fname) } i = j = 0; - while (i < resp->total_size) { + while (i < resp.total_size) { memcpy(curves + j, data + i+2, data[i+1]); j += data[i+1] / 2; i += data[i+1] + 2; @@ -1463,7 +1154,7 @@ done: static int set_tonecurve(struct shinkos6145_ctx *ctx, int target, char *fname) { struct s6145_update_cmd cmd; - struct sinfonia_status_hdr *resp = (struct sinfonia_status_hdr *) rdbuf; + struct sinfonia_status_hdr resp; int ret, num = 0; INFO("Set %s Tone Curve from '%s'\n", sinfonia_update_targets(target), fname); @@ -1491,7 +1182,7 @@ static int set_tonecurve(struct shinkos6145_ctx *ctx, int target, char *fname) cmd.reset = 0; cmd.size = cpu_to_le32(TONE_CURVE_SIZE * sizeof(uint16_t)); - cmd.hdr.cmd = cpu_to_le16(S6145_CMD_UPDATE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_UPDATE); cmd.hdr.len = cpu_to_le16(sizeof(struct s6145_update_cmd)-sizeof(cmd.hdr)); /* Byteswap data to format printer is expecting.. */ @@ -1501,9 +1192,8 @@ static int set_tonecurve(struct shinkos6145_ctx *ctx, int target, char *fname) if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); goto done; } @@ -1522,11 +1212,11 @@ done: static int shinkos6145_get_imagecorr(struct shinkos6145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s6145_imagecorr_resp *resp = (struct s6145_imagecorr_resp *) rdbuf; + struct s6145_imagecorr_resp resp; size_t total = 0; int ret, num; - cmd.cmd = cpu_to_le16(S6145_CMD_GETCORR); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETCORR); cmd.len = 0; if (ctx->corrdata) { @@ -1536,13 +1226,12 @@ static int shinkos6145_get_imagecorr(struct shinkos6145_ctx *ctx) if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); goto done; } - ctx->corrdatalen = le16_to_cpu(resp->total_size); + ctx->corrdatalen = le16_to_cpu(resp.total_size); INFO("Fetching %zu bytes of image correction data\n", ctx->corrdatalen); ctx->corrdata = malloc(sizeof(struct shinkos6145_correctionparam)); @@ -1579,10 +1268,10 @@ done: static int shinkos6145_get_eeprom(struct shinkos6145_ctx *ctx) { struct sinfonia_cmd_hdr cmd; - struct s6145_geteeprom_resp *resp = (struct s6145_geteeprom_resp *) rdbuf; + struct s6145_geteeprom_resp resp; int ret, num; - cmd.cmd = cpu_to_le16(S6145_CMD_GETEEPROM); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETEEPROM); cmd.len = 0; if (ctx->eeprom) { @@ -1592,20 +1281,19 @@ static int shinkos6145_get_eeprom(struct shinkos6145_ctx *ctx) if ((ret = s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); goto done; } - ctx->eepromlen = le16_to_cpu(resp->hdr.payload_len); + ctx->eepromlen = le16_to_cpu(resp.hdr.payload_len); ctx->eeprom = malloc(ctx->eepromlen); if (!ctx->eeprom) { ERROR("Memory allocation failure\n"); ret = -ENOMEM; goto done; } - memcpy(ctx->eeprom, resp->data, ctx->eepromlen); + memcpy(ctx->eeprom, resp.data, ctx->eepromlen); done: return ret; @@ -1765,18 +1453,18 @@ static int shinkos6145_attach(void *vctx, struct libusb_device_handle *dev, int if (test_mode < TEST_MODE_NOATTACH) { /* Query Media */ - struct s6145_mediainfo_resp *resp = (struct s6145_mediainfo_resp *) rdbuf; struct sinfonia_cmd_hdr cmd; int num; + cmd.cmd = cpu_to_le16(SINFONIA_CMD_MEDIAINFO); + cmd.len = cpu_to_le16(0); + if (s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp), + (uint8_t*)&ctx->media, sizeof(&ctx->media), &num)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return CUPS_BACKEND_FAILED; } - memcpy(&ctx->media, resp, sizeof(*resp)); /* Byteswap media descriptor.. */ int i; @@ -1937,7 +1625,7 @@ static int shinkos6145_read_parse(void *vctx, const void **vjob, int data_fd, in memset(job, 0, sizeof(*job)); /* Common read/parse code */ - ret = sinfonia_read_parse(data_fd, 6145, &job->jp, &job->databuf, &job->datalen); + ret = sinfonia_read_parse(data_fd, 6145, job); if (ret) { free(job); return ret; @@ -1992,15 +1680,11 @@ static int shinkos6145_main_loop(void *vctx, const void *vjob) { struct shinkos6145_ctx *ctx = vctx; int ret, num; - uint8_t cmdbuf[CMDBUF_LEN]; - uint8_t rdbuf2[READBACK_LEN]; int i, last_state = -1, state = S_IDLE; - struct sinfonia_cmd_hdr *cmd = (struct sinfonia_cmd_hdr *) cmdbuf; - struct s6145_print_cmd *print = (struct s6145_print_cmd *) cmdbuf; - struct s6145_status_resp *sts = (struct s6145_status_resp *) rdbuf; - struct s6145_mediainfo_resp *media = (struct s6145_mediainfo_resp *) rdbuf; + struct sinfonia_cmd_hdr cmd; + struct s6145_status_resp sts, sts2; uint32_t cur_mode; @@ -2009,32 +1693,16 @@ static int shinkos6145_main_loop(void *vctx, const void *vjob) { if (!job) return CUPS_BACKEND_FAILED; - /* Send Media Query */ - memset(cmdbuf, 0, CMDBUF_LEN); - cmd->cmd = cpu_to_le16(S6145_CMD_MEDIAINFO); - cmd->len = cpu_to_le16(0); - - if ((ret = s6145_do_cmd(ctx, - cmdbuf, sizeof(*cmd), - sizeof(*media), - &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd->cmd)); - return CUPS_BACKEND_FAILED; - } - - if (le16_to_cpu(media->hdr.payload_len) != (sizeof(struct s6145_mediainfo_resp) - sizeof(struct sinfonia_status_hdr))) - return CUPS_BACKEND_FAILED; - /* Validate print sizes */ - for (i = 0; i < media->count ; i++) { + for (i = 0; i < ctx->media.count ; i++) { /* Look for matching media */ - if (media->items[i].columns == job->jp.columns && - media->items[i].rows == job->jp.rows && - media->items[i].print_method == job->jp.method && - media->items[i].media_code == job->jp.media) + if (ctx->media.items[i].columns == job->jp.columns && + ctx->media.items[i].rows == job->jp.rows && + ctx->media.items[i].method == job->jp.method && + ctx->media.items[i].code == job->jp.media) break; } - if (i == media->count) { + if (i == ctx->media.count) { ERROR("Incorrect media loaded for print!\n"); return CUPS_BACKEND_HOLD; } @@ -2055,32 +1723,30 @@ top: } /* Send Status Query */ - memset(cmdbuf, 0, CMDBUF_LEN); - cmd->cmd = cpu_to_le16(S6145_CMD_GETSTATUS); - cmd->len = cpu_to_le16(0); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); + cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(ctx, - cmdbuf, sizeof(*cmd), - sizeof(struct sinfonia_status_hdr), + (uint8_t*)&cmd, sizeof(cmd), + (uint8_t*)&sts, sizeof(sts), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd->cmd)); return CUPS_BACKEND_FAILED; } - if (memcmp(rdbuf, rdbuf2, READBACK_LEN)) { - memcpy(rdbuf2, rdbuf, READBACK_LEN); + if (memcmp(&sts, &sts2, sizeof(sts))) { + memcpy(&sts2, &sts, sizeof(sts)); INFO("Printer Status: 0x%02x (%s)\n", - sts->hdr.status, status_str(sts->hdr.status)); + sts.hdr.status, sinfonia_status_str(sts.hdr.status)); - if (ctx->marker.levelnow != (int)sts->count_ribbon_left) { - ctx->marker.levelnow = sts->count_ribbon_left; + if (ctx->marker.levelnow != (int)sts.count_ribbon_left) { + ctx->marker.levelnow = sts.count_ribbon_left; dump_markers(&ctx->marker, 1, 0); } - if (sts->hdr.result != RESULT_SUCCESS) + if (sts.hdr.result != RESULT_SUCCESS) goto printer_error; - if (sts->hdr.status == ERROR_PRINTER) + if (sts.hdr.status == ERROR_PRINTER) goto printer_error; } else if (state == last_state) { sleep(1); @@ -2094,8 +1760,8 @@ top: case S_IDLE: INFO("Waiting for printer idle\n"); /* If either bank is free, continue */ - if (sts->bank1_status == BANK_STATUS_FREE || - sts->bank2_status == BANK_STATUS_FREE) + if (sts.bank1_status == BANK_STATUS_FREE || + sts.bank2_status == BANK_STATUS_FREE) state = S_PRINTER_READY_CMD; break; @@ -2112,8 +1778,8 @@ top: /* If cur_mode is not the same as desired oc_mode, change it -- but we have to wait until the printer is COMPLETELY idle */ - if (sts->bank1_status != BANK_STATUS_FREE || - sts->bank2_status != BANK_STATUS_FREE) { + if (sts.bank1_status != BANK_STATUS_FREE || + sts.bank2_status != BANK_STATUS_FREE) { INFO("Need to switch overcoat mode, waiting for printer idle\n"); sleep(1); goto top; @@ -2173,42 +1839,43 @@ top: job->databuf = (uint8_t*) databuf2; job->datalen = newlen; + struct s6145_print_cmd print; + INFO("Sending print job (internal id %u)\n", ctx->jobid); - memset(cmdbuf, 0, CMDBUF_LEN); - print->hdr.cmd = cpu_to_le16(S6145_CMD_PRINTJOB); - print->hdr.len = cpu_to_le16(sizeof (*print) - sizeof(*cmd)); + memset(&print, 0, sizeof(print)); + print.hdr.cmd = cpu_to_le16(SINFONIA_CMD_PRINTJOB); + print.hdr.len = cpu_to_le16(sizeof (print) - sizeof(cmd)); - print->id = ctx->jobid; - print->count = cpu_to_le16(job->copies); - print->columns = cpu_to_le16(job->jp.columns); - print->rows = cpu_to_le16(job->jp.rows); - print->image_avg = ctx->image_avg[2]; /* Cyan level */ - print->method = cpu_to_le32(job->jp.method); - print->combo_wait = 0; + print.id = ctx->jobid; + print.count = cpu_to_le16(job->copies); + print.columns = cpu_to_le16(job->jp.columns); + print.rows = cpu_to_le16(job->jp.rows); + print.image_avg = ctx->image_avg[2]; /* Cyan level */ + print.method = cpu_to_le32(job->jp.method); + print.combo_wait = 0; /* Brava21 header has a few quirks */ if(ctx->type == P_SHINKO_S6145D) { - print->media = job->jp.media; - print->unk_1 = 0x01; + print.media = job->jp.media; + print.unk_1 = 0x01; } if ((ret = s6145_do_cmd(ctx, - cmdbuf, sizeof(*print), - sizeof(struct sinfonia_status_hdr), + (uint8_t*)&print, sizeof(print), + (uint8_t*)&sts, sizeof(sts), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(print->hdr.cmd)); return ret; } - if (sts->hdr.result != RESULT_SUCCESS) { - if (sts->hdr.error == ERROR_BUFFER_FULL) { + if (sts.hdr.result != RESULT_SUCCESS) { + if (sts.hdr.error == ERROR_BUFFER_FULL) { INFO("Printer Buffers full, retrying\n"); break; - } else if ((sts->hdr.status & 0xf0) == 0x30 || sts->hdr.status == 0x21) { - INFO("Printer busy (%s), retrying\n", status_str(sts->hdr.status)); + } else if ((sts.hdr.status & 0xf0) == 0x30 || sts.hdr.status == 0x21) { + INFO("Printer busy (%s), retrying\n", sinfonia_status_str(sts.hdr.status)); break; - } else if (sts->hdr.status != ERROR_NONE) + } else if (sts.hdr.status != ERROR_NONE) goto printer_error; } @@ -2228,7 +1895,7 @@ top: if (fast_return) { INFO("Fast return mode enabled.\n"); state = S_FINISHED; - } else if (sts->hdr.status == STATUS_READY) { + } else if (sts.hdr.status == STATUS_READY) { state = S_FINISHED; } break; @@ -2245,19 +1912,19 @@ top: printer_error: ERROR("Printer reported error: %#x (%s) status: %#x (%s) -> %#x.%#x (%s)\n", - sts->hdr.error, - sinfonia_error_str(sts->hdr.error), - sts->hdr.status, - status_str(sts->hdr.status), - sts->hdr.printer_major, sts->hdr.printer_minor, - error_codes(sts->hdr.printer_major, sts->hdr.printer_minor)); + sts.hdr.error, + sinfonia_error_str(sts.hdr.error), + sts.hdr.status, + sinfonia_status_str(sts.hdr.status), + sts.hdr.printer_major, sts.hdr.printer_minor, + error_codes(sts.hdr.printer_major, sts.hdr.printer_minor)); return CUPS_BACKEND_FAILED; } static int shinkos6145_query_serno(struct libusb_device_handle *dev, uint8_t endp_up, uint8_t endp_down, char *buf, int buf_len) { struct sinfonia_cmd_hdr cmd; - struct s6145_getserial_resp *resp = (struct s6145_getserial_resp*) rdbuf; + struct sinfonia_getserial_resp resp; int ret, num = 0; struct shinkos6145_ctx ctx = { @@ -2266,24 +1933,20 @@ static int shinkos6145_query_serno(struct libusb_device_handle *dev, uint8_t end .endp_down = endp_down, }; - cmd.cmd = cpu_to_le16(S6145_CMD_GETSERIAL); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSERIAL); cmd.len = cpu_to_le16(0); if ((ret = s6145_do_cmd(&ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*resp) - 1, + (uint8_t*)&resp, sizeof(resp), &num)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return ret; } - /* Null-terminate */ - resp->hdr.payload_len = le16_to_cpu(resp->hdr.payload_len); - if (resp->hdr.payload_len > 23) - resp->hdr.payload_len = 23; - rdbuf[resp->hdr.payload_len] = 0; - strncpy(buf, (char*)resp->data, buf_len); - buf[buf_len-1] = 0; /* ensure it's null terminated */ + /* Copy and Null-terminate */ + num = (buf_len > (int)sizeof(resp.data)) ? (int)sizeof(resp.data) : (buf_len - 1); + memcpy(buf, resp.data, num); + buf[num] = 0; return CUPS_BACKEND_OK; } @@ -2292,18 +1955,17 @@ static int shinkos6145_query_markers(void *vctx, struct marker **markers, int *c { struct shinkos6145_ctx *ctx = vctx; struct sinfonia_cmd_hdr cmd; - struct s6145_status_resp *sts = (struct s6145_status_resp *) rdbuf; + struct s6145_status_resp *sts; int num; /* Query Status */ - cmd.cmd = cpu_to_le16(S6145_CMD_GETSTATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if (s6145_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(*sts), + (uint8_t*)&sts, sizeof(sts), &num)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); return CUPS_BACKEND_FAILED; } @@ -2331,7 +1993,7 @@ static const char *shinkos6145_prefixes[] = { struct dyesub_backend shinkos6145_backend = { .name = "Shinko/Sinfonia CHC-S6145/CS2", - .version = "0.33", + .version = "0.34", .uri_prefixes = shinkos6145_prefixes, .cmdline_usage = shinkos6145_cmdline, .cmdline_arg = shinkos6145_cmdline_arg, diff --git a/backend_shinkos6245.c b/backend_shinkos6245.c index cab3c0c..db0b282 100644 --- a/backend_shinkos6245.c +++ b/backend_shinkos6245.c @@ -52,114 +52,7 @@ enum { S_FINISHED, }; -#if 0 -/* Structure of printjob header. All fields are LITTLE ENDIAN */ -struct s6245_printjob_hdr { - uint32_t len1; /* Fixed at 0x10 */ - uint32_t model; /* Equal to the printer model (eg '6245' or '1245' decimal) */ - uint32_t unk2; - uint32_t unk3; /* Fixed at 0x01 */ - - uint32_t len2; /* Fixed at 0x64 */ - uint32_t unk5; - uint32_t media; // 8x4->8x12 - uint32_t unk6; - - uint32_t unk7; - uint32_t unk7a; - uint32_t oc_mode; /* 6145/6245 only, Matte/Glossy/None */ - 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)); -#endif - /* Structs for printer */ -#define S6245_CMD_GETSTATUS 0x0001 -#define S6245_CMD_MEDIAINFO 0x0002 -#define S6245_CMD_ERRORLOG 0x0004 -#define S6245_CMD_GETPARAM 0x0005 -#define S6245_CMD_GETSERIAL 0x0006 -#define S6245_CMD_PRINTSTAT 0x0007 -#define S6245_CMD_EXTCOUNTER 0x0008 - -#define S6245_CMD_PRINTJOB 0x4001 -#define S6245_CMD_CANCELJOB 0x4002 -#define S6245_CMD_FLASHLED 0x4003 -#define S6245_CMD_RESET 0x4004 -#define S6245_CMD_READTONE 0x4005 -#define S6245_CMD_SETPARAM 0x4007 - -#define S6245_CMD_GETEEPROM 0x400E -#define S6245_CMD_SETEEPROM 0x400F -#define S6245_CMD_SETTIME 0x4011 - -#define S6245_CMD_FWINFO 0xC003 -#define S6245_CMD_UPDATE 0xC004 - -static char *cmd_names(uint16_t v) { - switch (le16_to_cpu(v)) { - case S6245_CMD_GETSTATUS: - return "Get Status"; - case S6245_CMD_MEDIAINFO: - return "Get Media Info"; - case S6245_CMD_ERRORLOG: - return "Get Error Log"; - case S6245_CMD_GETPARAM: - return "Get Parameter"; - case S6245_CMD_GETSERIAL: - return "Get Serial Number"; - case S6245_CMD_PRINTSTAT: - return "Get Print ID Status"; - case S6245_CMD_EXTCOUNTER: - return "Get Extended Counters"; - case S6245_CMD_PRINTJOB: - return "Print"; - case S6245_CMD_CANCELJOB: - return "Cancel Print"; - case S6245_CMD_FLASHLED: - return "Flash LEDs"; - case S6245_CMD_RESET: - return "Reset"; - case S6245_CMD_READTONE: - return "Read Tone Curve"; - case S6245_CMD_SETPARAM: - return "Set Parameter"; - case S6245_CMD_GETEEPROM: - return "Get EEPROM Backup Parameter"; - case S6245_CMD_SETEEPROM: - return "Set EEPROM Backup Parameter"; - case S6245_CMD_SETTIME: - return "Time Setting"; - case S6245_CMD_FWINFO: - return "Get Firmware Info"; - case S6245_CMD_UPDATE: - return "Update"; - default: - return "Unknown Command"; - } -} - struct s6245_print_cmd { struct sinfonia_cmd_hdr hdr; uint8_t id; @@ -211,12 +104,6 @@ struct s6245_readtone_cmd { #define READ_TONE_CURVE_USER 0x01 #define READ_TONE_CURVE_CURR 0x02 -struct s6245_setparam_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t target; - uint32_t param; -} __attribute__((packed)); - #define PARAM_DRIVER_MODE 0x3e #define PARAM_PAPER_MODE 0x3f #define PARAM_SLEEP_TIME 0x54 @@ -234,11 +121,6 @@ struct s6245_setparam_cmd { #define PARAM_SLEEP_120MIN 0x00000004 #define PARAM_SLEEP_240MIN 0x00000005 -struct s6245_seteeprom_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t data[256]; /* Maxlen */ -} __attribute__((packed)); - struct s6245_settime_cmd { struct sinfonia_cmd_hdr hdr; uint8_t enable; /* 0 or 1 */ @@ -255,16 +137,6 @@ struct s6245_errorlog_cmd { uint16_t index; /* 0 is latest */ } __attribute__((packed)); -struct s6245_getparam_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t target; -} __attribute__((packed)); - -struct s6245_getprintidstatus_cmd { - struct sinfonia_cmd_hdr hdr; - uint8_t id; -} __attribute__((packed)); - #define FWINFO_TARGET_MAIN_BOOT 0x01 #define FWINFO_TARGET_MAIN_APP 0x02 #define FWINFO_TARGET_PRINT_TABLES 0x03 @@ -509,77 +381,6 @@ static char *error_codes(uint8_t major, uint8_t minor) } } -#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_OP 0x69 -#define STATUS_PAPER_CUT 0x6A -#define STATUS_PAPER_EJECT 0x6B -#define STATUS_BACK_FEED_E 0x6C - -static char *status_str(uint8_t v) { - switch (v) { - case STATUS_READY: - return "Ready"; - case STATUS_INIT_CPU: - return "Initializing CPU"; - case STATUS_INIT_RIBBON: - return "Initializing Ribbon"; - case STATUS_INIT_PAPER: - return "Loading Paper"; - case STATUS_THERMAL_PROTECT: - return "Thermal Protection"; - case STATUS_USING_PANEL: - return "Using Operation Panel"; - case STATUS_SELF_DIAG: - return "Processing Self Diagnosis"; - case STATUS_DOWNLOADING: - return "Processing Download"; - case STATUS_FEEDING_PAPER: - return "Feeding Paper"; - case STATUS_PRE_HEAT: - return "Pre-Heating"; - case STATUS_PRINT_Y: - return "Printing Yellow"; - case STATUS_BACK_FEED_Y: - return "Back-Feeding - Yellow Complete"; - case STATUS_PRINT_M: - return "Printing Magenta"; - case STATUS_BACK_FEED_M: - return "Back-Feeding - Magenta Complete"; - case STATUS_PRINT_C: - return "Printing Cyan"; - case STATUS_BACK_FEED_C: - return "Back-Feeding - Cyan Complete"; - case STATUS_PRINT_OP: - return "Laminating"; - case STATUS_PAPER_CUT: - return "Cutting Paper"; - case STATUS_PAPER_EJECT: - return "Ejecting Paper"; - case STATUS_BACK_FEED_E: - return "Back-Feeding - Ejected"; - case ERROR_PRINTER: - return "Printer Error"; - default: - return "Unknown"; - } -} - struct s6245_status_resp { struct sinfonia_status_hdr hdr; uint32_t count_lifetime; @@ -617,68 +418,25 @@ struct s6245_readtone_resp { uint16_t total_size; } __attribute__((packed)); -struct s6245_mediainfo_item { - uint8_t media_code; - uint16_t columns; - uint16_t rows; - uint8_t reserved; - uint8_t print_method; /* PRINT_METHOD_* */ - uint8_t reserved2[3]; -} __attribute__((packed)); - -#define MEDIA_8x10 0x10 -#define MEDIA_8x12 0x11 -#define MEDIA_8x4 0x20 -#define MEDIA_8x5 0x21 -#define MEDIA_8x6 0x22 -#define MEDIA_8x8 0x23 -#define MEDIA_8x4_2 0x30 -#define MEDIA_8x5_2 0x31 -#define MEDIA_8x6_2 0x32 -#define MEDIA_8x4_3 0x40 - -static const char *print_sizes (uint8_t v) { - switch (v) { - case MEDIA_8x10: - return "8x10"; - case MEDIA_8x12: - return "8x12"; - case MEDIA_8x4: - return "8x4"; - case MEDIA_8x5: - return "8x5"; - case MEDIA_8x6: - return "8x6"; - case MEDIA_8x8: - return "8x8"; - case MEDIA_8x4_2: - return "8x4*2"; - case MEDIA_8x5_2: - return "8x5*2"; - case MEDIA_8x6_2: - return "8x6*2"; - case MEDIA_8x4_3: - return "8x4*3"; - default: - return "Unknown"; - } -} - struct s6245_mediainfo_resp { struct sinfonia_status_hdr hdr; uint8_t ribbon_code; uint8_t reserved; uint8_t count; - struct s6245_mediainfo_item items[10]; /* Not all necessarily used */ + struct sinfonia_mediainfo_item items[10]; /* Not all necessarily used */ } __attribute__((packed)); +#define RIBBON_NONE 0x00 +#define RIBBON_8x10 0x11 +#define RIBBON_8x12 0x12 + static const char *ribbon_sizes (uint8_t v) { switch (v) { - case 0x00: + case RIBBON_NONE: return "None"; - case 0x11: + case RIBBON_8x10: return "8x10"; - case 0x12: + case RIBBON_8x12: return "8x12"; default: return "Unknown"; @@ -687,9 +445,9 @@ static const char *ribbon_sizes (uint8_t v) { static int ribbon_counts (uint8_t v) { switch (v) { - case 0x11: + case RIBBON_8x10: return 120; - case 0x12: + case RIBBON_8x12: return 100; default: return 120; @@ -728,38 +486,6 @@ struct s6245_errorlog_resp { uint8_t reserved5[8]; } __attribute__((packed)); -struct s6245_getparam_resp { - struct sinfonia_status_hdr hdr; - uint32_t param; -} __attribute__((packed)); - -struct s6245_getserial_resp { - struct sinfonia_status_hdr hdr; - uint8_t data[8]; -} __attribute__((packed)); - -struct s6245_getprintidstatus_resp { - struct sinfonia_status_hdr hdr; - uint8_t id; - uint16_t remaining; - uint16_t finished; - uint16_t specified; - uint16_t status; -} __attribute__((packed)); - -#define STATUS_WAITING 0x0000 -#define STATUS_PRINTING 0x0100 -#define STATUS_COMPLETED 0x0200 -#define STATUS_ERROR 0xFFFF - -struct s6245_getextcounter_resp { - struct sinfonia_status_hdr hdr; - uint32_t lifetime_distance; /* Inches */ - uint32_t maint_distance; - uint32_t head_distance; - uint8_t reserved[32]; -} __attribute__((packed)); - /* Private data structure */ struct shinkos6245_ctx { struct libusb_device_handle *dev; @@ -779,33 +505,40 @@ struct shinkos6245_ctx { static int s6245_do_cmd(struct shinkos6245_ctx *ctx, uint8_t *cmd, int cmdlen, - int buflen, - int *num, struct sinfonia_status_hdr *resp) + uint8_t *resp, int resplen, + int *num) { libusb_device_handle *dev = ctx->dev; uint8_t endp_up = ctx->endp_up; uint8_t endp_down = ctx->endp_down; int ret; + struct sinfonia_cmd_hdr *cmdhdr = (struct sinfonia_cmd_hdr *) cmd; + struct sinfonia_status_hdr *resphdr = (struct sinfonia_status_hdr *)resp; + if ((ret = send_data(dev, endp_down, - cmd, cmdlen))) - return (ret < 0) ? ret : -99; - - ret = read_data(dev, endp_up, - (uint8_t *)resp, buflen, num); - - if (ret < 0) - return ret; - - if (resp->result != RESULT_SUCCESS) { - INFO("Printer Status: %02x (%s)\n", resp->status, - status_str(resp->status)); - INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x = %s)\n", - resp->result, resp->error, resp->printer_major, - resp->printer_minor, error_codes(resp->printer_major, resp->printer_minor)); - return -99; + cmd, cmdlen))) { + goto fail; } + ret = read_data(dev, endp_up, + (uint8_t *)resp, resplen, num); + + if (ret < 0) + goto fail; + + if (resphdr->result != RESULT_SUCCESS) { + INFO("Printer Status: %02x (%s)\n", resphdr->status, + sinfonia_status_str(resphdr->status)); + INFO(" Result: 0x%02x Error: 0x%02x (0x%02x/0x%02x = %s)\n", + resphdr->result, resphdr->error, resphdr->printer_major, + resphdr->printer_minor, error_codes(resphdr->printer_major, resphdr->printer_minor)); + goto fail; + } + + return 0; +fail: + ERROR("Failed to execute %s command\n", sinfonia_cmd_names(cmdhdr->cmd)); return ret; } @@ -813,22 +546,21 @@ static int get_status(struct shinkos6245_ctx *ctx) { struct sinfonia_cmd_hdr cmd; struct s6245_status_resp resp; - struct s6245_getextcounter_resp resp2; + struct sinfonia_getextcounter_resp resp2; int ret, num = 0; - cmd.cmd = cpu_to_le16(S6245_CMD_GETSTATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*) &resp, sizeof(resp), + &num)) < 0) { return ret; } INFO("Printer Status: 0x%02x (%s)\n", resp.hdr.status, - status_str(resp.hdr.status)); + sinfonia_status_str(resp.hdr.status)); if (resp.hdr.status == ERROR_PRINTER) { if(resp.hdr.error == ERROR_NONE) resp.hdr.error = resp.hdr.status; @@ -865,17 +597,16 @@ static int get_status(struct shinkos6245_ctx *ctx) INFO("Tonecurve Status: 0x%02x (%s)\n", resp.tonecurve_status, sinfonia_tonecurve_statuses(resp.tonecurve_status)); /* Query Extended counters */ - cmd.cmd = cpu_to_le16(S6245_CMD_EXTCOUNTER); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_EXTCOUNTER); cmd.len = cpu_to_le16(0); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp2), - &num, (void*)&resp2)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&resp2, sizeof(resp2), + &num)) < 0) { return ret; } - if (le16_to_cpu(resp2.hdr.payload_len) != (sizeof(struct s6245_getextcounter_resp) - sizeof(struct sinfonia_status_hdr))) + if (le16_to_cpu(resp2.hdr.payload_len) != (sizeof(struct sinfonia_getextcounter_resp) - sizeof(struct sinfonia_status_hdr))) return 0; INFO("Lifetime Distance: %08u inches\n", le32_to_cpu(resp2.lifetime_distance)); @@ -892,7 +623,7 @@ static int get_fwinfo(struct shinkos6245_ctx *ctx) int num = 0; int i; - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_FWINFO); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_FWINFO); cmd.hdr.len = cpu_to_le16(1); INFO("FW Information:\n"); @@ -903,9 +634,8 @@ static int get_fwinfo(struct shinkos6245_ctx *ctx) if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { continue; } @@ -932,7 +662,7 @@ static int get_errorlog(struct shinkos6245_ctx *ctx) int num = 0; int i = 0; - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_ERRORLOG); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_ERRORLOG); cmd.hdr.len = cpu_to_le16(2); do { @@ -941,9 +671,8 @@ static int get_errorlog(struct shinkos6245_ctx *ctx) if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } @@ -972,11 +701,12 @@ static void dump_mediainfo(struct s6245_mediainfo_resp *resp) INFO("Supported Media Information: %u entries:\n", resp->count); for (i = 0 ; i < resp->count ; i++) { INFO(" %02d: C 0x%02x (%s), %04ux%04u, P 0x%02x (%s)\n", i, - resp->items[i].media_code, print_sizes(resp->items[i].media_code), + resp->items[i].code, + sinfonia_print_codes(resp->items[i].code, 1), resp->items[i].columns, resp->items[i].rows, - resp->items[i].print_method, - sinfonia_print_methods(resp->items[i].print_method)); + resp->items[i].method, + sinfonia_print_methods(resp->items[i].method)); } } @@ -991,14 +721,13 @@ static int cancel_job(struct shinkos6245_ctx *ctx, char *str) cmd.id = atoi(str); - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_CANCELJOB); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_CANCELJOB); cmd.hdr.len = cpu_to_le16(1); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } @@ -1011,24 +740,22 @@ static int flash_led(struct shinkos6245_ctx *ctx) struct sinfonia_status_hdr resp; int ret, num = 0; - cmd.cmd = cpu_to_le16(S6245_CMD_FLASHLED); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_FLASHLED); cmd.len = cpu_to_le16(0); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } return 0; } - static int set_param(struct shinkos6245_ctx *ctx, int target, uint32_t param) { - struct s6245_setparam_cmd cmd; + struct sinfonia_setparam_cmd cmd; struct sinfonia_status_hdr resp; int ret, num = 0; @@ -1036,14 +763,14 @@ static int set_param(struct shinkos6245_ctx *ctx, int target, uint32_t param) cmd.target = target; cmd.param = cpu_to_le32(param); - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_SETPARAM); - cmd.hdr.len = cpu_to_le16(sizeof(struct s6245_setparam_cmd)-sizeof(cmd.hdr)); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_SETPARAM); + cmd.hdr.len = cpu_to_le16(sizeof(struct sinfonia_setparam_cmd)-sizeof(cmd.hdr)); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command (%d)\n", cmd_names(cmd.hdr.cmd), ret); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { + return ret; } return ret; @@ -1057,14 +784,13 @@ static int reset_curve(struct shinkos6245_ctx *ctx, int target) cmd.target = target; - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_RESET); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_RESET); cmd.hdr.len = cpu_to_le16(1); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } @@ -1085,16 +811,15 @@ static int get_tonecurve(struct shinkos6245_ctx *ctx, int type, char *fname) cmd.target = type; cmd.curveid = TONE_CURVE_ID; - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_READTONE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_READTONE); cmd.hdr.len = cpu_to_le16(1); INFO("Dump %s Tone Curve to '%s'\n", sinfonia_tonecurve_statuses(type), fname); if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } @@ -1176,7 +901,7 @@ static int set_tonecurve(struct shinkos6245_ctx *ctx, int target, char *fname) cmd.reset = 0; cmd.size = cpu_to_le32(TONE_CURVE_SIZE * sizeof(uint16_t)); - cmd.hdr.cmd = cpu_to_le16(S6245_CMD_UPDATE); + cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_UPDATE); cmd.hdr.len = cpu_to_le16(sizeof(struct s6245_update_cmd)-sizeof(cmd.hdr)); /* Byteswap data to format printer is expecting.. */ @@ -1186,10 +911,9 @@ static int set_tonecurve(struct shinkos6245_ctx *ctx, int target, char *fname) if ((ret = s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.hdr.cmd)); - goto done; + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { + return ret; } /* Sent transfer */ @@ -1330,14 +1054,13 @@ static int shinkos6245_attach(void *vctx, struct libusb_device_handle *dev, int /* Query Media */ if (test_mode < TEST_MODE_NOATTACH) { struct sinfonia_cmd_hdr cmd; - cmd.cmd = cpu_to_le16(S6245_CMD_MEDIAINFO); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_MEDIAINFO); cmd.len = cpu_to_le16(0); if (s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(ctx->media), - &num, (void*)&ctx->media)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&ctx->media, sizeof(ctx->media), + &num)) { return CUPS_BACKEND_FAILED; } @@ -1349,11 +1072,10 @@ static int shinkos6245_attach(void *vctx, struct libusb_device_handle *dev, int } } else { - int media_code = 0x12; + int media_code = RIBBON_8x12; if (getenv("MEDIA_CODE")) media_code = atoi(getenv("MEDIA_CODE")); - ctx->media.ribbon_code = media_code; } @@ -1400,7 +1122,7 @@ static int shinkos6245_read_parse(void *vctx, const void **vjob, int data_fd, in memset(job, 0, sizeof(*job)); /* Common read/parse code */ - ret = sinfonia_read_parse(data_fd, 6245, &job->jp, &job->databuf, &job->datalen); + ret = sinfonia_read_parse(data_fd, 6245, job); if (ret) { free(job); return ret; @@ -1443,12 +1165,12 @@ static int shinkos6245_main_loop(void *vctx, const void *vjob) { /* Set up mcut */ switch (job->jp.media) { - case MEDIA_8x4_2: - case MEDIA_8x5_2: - case MEDIA_8x6_2: + case CODE_8x4_2: + case CODE_8x5_2: + case CODE_8x6_2: mcut = PRINT_METHOD_COMBO_2; break; - case MEDIA_8x4_3: + case CODE_8x4_3: mcut = PRINT_METHOD_COMBO_3; break; default: @@ -1475,7 +1197,7 @@ static int shinkos6245_main_loop(void *vctx, const void *vjob) { struct tm *cur = localtime(&now); memset(cmdbuf, 0, CMDBUF_LEN); - cmd->cmd = cpu_to_le16(S6245_CMD_SETTIME); + cmd->cmd = cpu_to_le16(SINFONIA_CMD_SETTIME); cmd->len = cpu_to_le16(0); settime->enable = 1; settime->second = cur->tm_sec; @@ -1487,9 +1209,8 @@ static int shinkos6245_main_loop(void *vctx, const void *vjob) { if ((ret = s6245_do_cmd(ctx, cmdbuf, sizeof(*settime), - sizeof(struct sinfonia_status_hdr), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(settime->hdr.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return CUPS_BACKEND_FAILED; } if (resp.result != RESULT_SUCCESS) { @@ -1508,14 +1229,13 @@ top: /* Send Status Query */ memset(cmdbuf, 0, CMDBUF_LEN); - cmd->cmd = cpu_to_le16(S6245_CMD_GETSTATUS); + cmd->cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd->len = cpu_to_le16(0); if ((ret = s6245_do_cmd(ctx, cmdbuf, sizeof(*cmd), - sizeof(sts), - &num, (void*)&sts)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd->cmd)); + (uint8_t*)&sts, sizeof(sts), + &num)) < 0) { return CUPS_BACKEND_FAILED; } @@ -1523,7 +1243,7 @@ top: memcpy(&sts2, &sts, sizeof(sts)); INFO("Printer Status: 0x%02x (%s)\n", - sts.hdr.status, status_str(sts.hdr.status)); + sts.hdr.status, sinfonia_status_str(sts.hdr.status)); if (ctx->marker.levelnow != (int)sts.count_ribbon_left) { ctx->marker.levelnow = sts.count_ribbon_left; @@ -1568,7 +1288,7 @@ top: INFO("Sending print job (internal id %u)\n", ctx->jobid); memset(cmdbuf, 0, CMDBUF_LEN); - print->hdr.cmd = cpu_to_le16(S6245_CMD_PRINTJOB); + print->hdr.cmd = cpu_to_le16(SINFONIA_CMD_PRINTJOB); print->hdr.len = cpu_to_le16(sizeof (*print) - sizeof(*cmd)); print->id = ctx->jobid; @@ -1580,9 +1300,8 @@ top: if ((ret = s6245_do_cmd(ctx, cmdbuf, sizeof(*print), - sizeof(resp), - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(print->hdr.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } @@ -1591,7 +1310,7 @@ top: INFO("Printer Buffers full, retrying\n"); break; } else if ((resp.status & 0xf0) == 0x30 || sts.hdr.status == 0x21) { - INFO("Printer busy (%s), retrying\n", status_str(sts.hdr.status)); + INFO("Printer busy (%s), retrying\n", sinfonia_status_str(sts.hdr.status)); break; } else if (resp.status != ERROR_NONE) goto printer_error; @@ -1630,7 +1349,7 @@ printer_error: sts.hdr.error, sinfonia_error_str(sts.hdr.error), sts.hdr.status, - status_str(sts.hdr.status), + sinfonia_status_str(sts.hdr.status), sts.hdr.printer_major, sts.hdr.printer_minor, error_codes(sts.hdr.printer_major, sts.hdr.printer_minor)); fail: @@ -1640,7 +1359,7 @@ fail: static int shinkos6245_query_serno(struct libusb_device_handle *dev, uint8_t endp_up, uint8_t endp_down, char *buf, int buf_len) { struct sinfonia_cmd_hdr cmd; - struct s6245_getserial_resp resp; + struct sinfonia_getserial_resp resp; int ret, num = 0; struct shinkos6245_ctx ctx = { @@ -1649,23 +1368,20 @@ static int shinkos6245_query_serno(struct libusb_device_handle *dev, uint8_t end .endp_down = endp_down, }; - cmd.cmd = cpu_to_le16(S6245_CMD_GETSERIAL); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSERIAL); cmd.len = cpu_to_le16(0); if ((ret = s6245_do_cmd(&ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(resp) - 1, - &num, (void*)&resp)) < 0) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&resp, sizeof(resp), + &num)) < 0) { return ret; } - /* Null-terminate */ - resp.hdr.payload_len = le16_to_cpu(resp.hdr.payload_len); - if (resp.hdr.payload_len > 23) - resp.hdr.payload_len = 23; - strncpy(buf, (char*)resp.data, buf_len); - buf[buf_len-1] = 0; /* ensure it's null terminated */ + /* Copy and Null-terminate */ + num = (buf_len > (int)sizeof(resp.data)) ? (int)sizeof(resp.data) : (buf_len - 1); + memcpy(buf, resp.data, num); + buf[num] = 0; return CUPS_BACKEND_OK; } @@ -1678,14 +1394,13 @@ static int shinkos6245_query_markers(void *vctx, struct marker **markers, int *c int num; /* Query Status */ - cmd.cmd = cpu_to_le16(S6245_CMD_GETSTATUS); + cmd.cmd = cpu_to_le16(SINFONIA_CMD_GETSTATUS); cmd.len = cpu_to_le16(0); if (s6245_do_cmd(ctx, (uint8_t*)&cmd, sizeof(cmd), - sizeof(status), - &num, (void*)&status)) { - ERROR("Failed to execute %s command\n", cmd_names(cmd.cmd)); + (uint8_t*)&status, sizeof(status), + &num)) { return CUPS_BACKEND_FAILED; } @@ -1714,7 +1429,7 @@ static const char *shinkos6245_prefixes[] = { struct dyesub_backend shinkos6245_backend = { .name = "Shinko/Sinfonia CHC-S6245", - .version = "0.17WIP", + .version = "0.18WIP", .uri_prefixes = shinkos6245_prefixes, .cmdline_usage = shinkos6245_cmdline, .cmdline_arg = shinkos6245_cmdline_arg, diff --git a/backend_sinfonia.c b/backend_sinfonia.c index fd1cc3b..1c4e598 100644 --- a/backend_sinfonia.c +++ b/backend_sinfonia.c @@ -41,8 +41,7 @@ #include "backend_sinfonia.h" int sinfonia_read_parse(int data_fd, uint32_t model, - struct sinfonia_job_param *jp, - uint8_t **data, int *datalen) + struct sinfonia_printjob *job) { uint32_t hdr[29]; int ret, i; @@ -82,25 +81,25 @@ int sinfonia_read_parse(int data_fd, uint32_t model, } /* Work out data length */ - *datalen = hdr[13] * hdr[14] * 3; - *data = malloc(*datalen); - if (!*data) { + job->datalen = hdr[13] * hdr[14] * 3; + job->databuf = malloc(job->datalen); + if (!job->databuf) { ERROR("Memory allocation failure!\n"); return CUPS_BACKEND_RETRY_CURRENT; } /* Read in payload data */ { - uint32_t remain = *datalen; - uint8_t *ptr = *data; + uint32_t remain = job->datalen; + uint8_t *ptr = job->databuf; do { ret = read(data_fd, ptr, remain); if (ret < 0) { ERROR("Read failed (%d/%d/%d)\n", - ret, remain, *datalen); + ret, remain, job->datalen); perror("ERROR: Read failed"); - free(*data); - *data = NULL; + free(job->databuf); + job->databuf = NULL; return ret; } ptr += ret; @@ -113,8 +112,8 @@ int sinfonia_read_parse(int data_fd, uint32_t model, if (ret != 4) { ERROR("Read failed (%d/%d)\n", ret, 4); perror("ERROR: Read failed"); - free(*data); - *data = NULL; + free(job->databuf); + job->databuf = NULL; return ret; } if (tmpbuf[0] != 0x04 || @@ -122,33 +121,31 @@ int sinfonia_read_parse(int data_fd, uint32_t model, tmpbuf[2] != 0x02 || tmpbuf[3] != 0x01) { ERROR("Unrecognized footer data format!\n"); - free (*data); - *data = NULL; + free (job->databuf); + job->databuf = NULL; return CUPS_BACKEND_CANCEL; } /* Fill out job params */ - if (jp) { - jp->media = hdr[6]; - if (hdr[1] != 6245) - jp->method = hdr[8]; - if (hdr[1] == 2245 || hdr[1] == 6245) - jp->quality = hdr[9]; - if (hdr[1] == 1245 || hdr[1] == 2145) - jp->oc_mode = hdr[9]; - else - jp->oc_mode = hdr[10]; - if (hdr[1] == 1245) - jp->mattedepth = hdr[11]; - if (hdr[1] == 1245) - jp->dust = hdr[12]; - jp->columns = hdr[13]; - jp->rows = hdr[14]; - jp->copies = hdr[15]; + job->jp.media = hdr[6]; + if (hdr[1] != 6245) + job->jp.method = hdr[8]; + if (hdr[1] == 2245 || hdr[1] == 6245) + job->jp.quality = hdr[9]; + if (hdr[1] == 1245 || hdr[1] == 2145) + job->jp.oc_mode = hdr[9]; + else + job->jp.oc_mode = hdr[10]; + if (hdr[1] == 1245) + job->jp.mattedepth = hdr[11]; + if (hdr[1] == 1245) + job->jp.dust = hdr[12]; + job->jp.columns = hdr[13]; + job->jp.rows = hdr[14]; + job->jp.copies = hdr[15]; - if (hdr[1] == 2245 || hdr[1] == 6145) - jp->ext_flags = hdr[28]; - } + if (hdr[1] == 2245 || hdr[1] == 6145) + job->jp.ext_flags = hdr[28]; return CUPS_BACKEND_OK; } @@ -245,6 +242,170 @@ const char *sinfonia_print_methods (uint8_t v) { } } +const char *sinfonia_print_codes (uint8_t v, int eightinch) { + if (eightinch) { + switch (v) { + case CODE_8x10: + return "8x10"; + case CODE_8x12: + return "8x12"; + case CODE_8x4: + return "8x4"; + case CODE_8x5: + return "8x5"; + case CODE_8x6: + return "8x6"; + case CODE_8x8: + return "8x8"; + case CODE_8x4_2: + return "8x4*2"; + case CODE_8x5_2: + return "8x5*2"; + case CODE_8x6_2: + return "8x6*2"; + case CODE_8x4_3: + return "8x4*3"; + default: + return "Unknown"; + } + } + + switch (v) { + case CODE_4x6: + return "4x6"; + case CODE_3_5x5: + return "3.5x5"; + case CODE_5x7: + return "5x7"; + case CODE_6x9: + return "6x9"; + case CODE_6x8: + return "6x8"; + case CODE_2x6: + return "2x6"; + case CODE_6x6: + return "6x6"; + case CODE_89x60mm: + return "89x60mm"; + case CODE_89x59mm: + return "89x59mm"; + case CODE_89x58mm: + return "89x58mm"; + case CODE_89x57mm: + return "89x57mm"; + case CODE_89x56mm: + return "89x56mm"; + case CODE_89x55mm: + return "89x55mm"; + default: + return "Unknown"; + } +} + +const char *sinfonia_status_str(uint8_t v) { + switch (v) { + case STATUS_READY: + return "Ready"; + case STATUS_INIT_CPU: + return "Initializing CPU"; + case STATUS_INIT_RIBBON: + return "Initializing Ribbon"; + case STATUS_INIT_PAPER: + return "Loading Paper"; + case STATUS_THERMAL_PROTECT: + return "Thermal Protection"; + case STATUS_USING_PANEL: + return "Using Operation Panel"; + case STATUS_SELF_DIAG: + return "Processing Self Diagnosis"; + case STATUS_DOWNLOADING: + return "Processing Download"; + case STATUS_FEEDING_PAPER: + return "Feeding Paper"; + case STATUS_PRE_HEAT: + return "Pre-Heating"; + case STATUS_PRINT_Y: + return "Printing Yellow"; + case STATUS_BACK_FEED_Y: + return "Back-Feeding - Yellow Complete"; + case STATUS_PRINT_M: + return "Printing Magenta"; + case STATUS_BACK_FEED_M: + return "Back-Feeding - Magenta Complete"; + case STATUS_PRINT_C: + return "Printing Cyan"; + case STATUS_BACK_FEED_C: + return "Back-Feeding - Cyan Complete"; + case STATUS_PRINT_OP: + return "Laminating"; + case STATUS_PAPER_CUT: + return "Cutting Paper"; + case STATUS_PAPER_EJECT: + return "Ejecting Paper"; + case STATUS_BACK_FEED_E: + return "Back-Feeding - Ejected"; + case STATUS_FINISHED: + return "Print Finished"; + case ERROR_PRINTER: + return "Printer Error"; + default: + return "Unknown"; + } +} + +const char *sinfonia_cmd_names(uint16_t v) { + switch (le16_to_cpu(v)) { + case SINFONIA_CMD_GETSTATUS: + return "Get Status"; + case SINFONIA_CMD_MEDIAINFO: + return "Get Media Info"; + case SINFONIA_CMD_MODELNAME: + return "Get Model Name"; + case SINFONIA_CMD_ERRORLOG: + return "Get Error Log"; + case SINFONIA_CMD_GETPARAM: + return "Get Parameter"; + case SINFONIA_CMD_GETSERIAL: + return "Get Serial Number"; + case SINFONIA_CMD_PRINTSTAT: + return "Get Print ID Status"; + case SINFONIA_CMD_EXTCOUNTER: + return "Get Extended Counters"; + case SINFONIA_CMD_PRINTJOB: + return "Print"; + case SINFONIA_CMD_CANCELJOB: + return "Cancel Print"; + case SINFONIA_CMD_FLASHLED: + return "Flash LEDs"; + case SINFONIA_CMD_RESET: + return "Reset"; + case SINFONIA_CMD_READTONE: + return "Read Tone Curve"; + case SINFONIA_CMD_BUTTON: + return "Button Enable"; + case SINFONIA_CMD_SETPARAM: + return "Set Parameter"; + case SINFONIA_CMD_GETUNIQUE: + return "Get Unique String"; + case SINFONIA_CMD_GETCORR: + return "Get Image Correction Parameter"; + case SINFONIA_CMD_GETEEPROM: + return "Get EEPROM Backup Parameter"; + case SINFONIA_CMD_SETEEPROM: + return "Set EEPROM Backup Parameter"; + case SINFONIA_CMD_SETTIME: + return "Time Setting"; + case SINFONIA_CMD_FWINFO: + return "Get Firmware Info"; + case SINFONIA_CMD_UPDATE: + return "Update"; + case SINFONIA_CMD_SETUNIQUE: + return "Set Unique String"; + default: + return "Unknown Command"; + } +} + const char *kodak6_mediatypes(int type) { switch(type) { diff --git a/backend_sinfonia.h b/backend_sinfonia.h index e054685..556067d 100644 --- a/backend_sinfonia.h +++ b/backend_sinfonia.h @@ -58,9 +58,7 @@ struct sinfonia_printjob { }; int sinfonia_read_parse(int data_fd, uint32_t model, - struct sinfonia_job_param *jp, - uint8_t **data, int *datalen); - + struct sinfonia_printjob *job); #define BANK_STATUS_FREE 0x00 #define BANK_STATUS_XFER 0x01 @@ -132,7 +130,7 @@ struct sinfonia_status_hdr { uint8_t printer_major; uint8_t printer_minor; uint8_t reserved[2]; - uint8_t mode; /* S6245 only, so far */ + uint8_t mode; /* S6245 and EK605 only, so far */ uint8_t status; uint16_t payload_len; } __attribute__((packed)); @@ -157,6 +155,160 @@ struct sinfonia_fwinfo_resp { uint16_t checksum; } __attribute__((packed)); +struct sinfonia_errorlog_resp { + struct sinfonia_status_hdr hdr; + uint8_t count; + struct sinfonia_error_item items[10]; /* Not all necessarily used */ +} __attribute__((packed)); + +struct sinfonia_mediainfo_item { + uint8_t code; + uint16_t columns; + uint16_t rows; + uint8_t type; /* S2145, EK68xx, EK605 only -- MEDIA_TYPE_* */ + uint8_t method; /* PRINT_METHOD_* */ + uint8_t flag; /* EK68xx only */ + uint8_t reserved[2]; +} __attribute__((packed)); + +struct sinfonia_setparam_cmd { + struct sinfonia_cmd_hdr hdr; + uint8_t target; + uint32_t param; +} __attribute__((packed)); + +struct sinfonia_getparam_cmd { + struct sinfonia_cmd_hdr hdr; + uint8_t target; +} __attribute__((packed)); + +struct sinfonia_getparam_resp { + struct sinfonia_status_hdr hdr; + uint32_t param; +} __attribute__((packed)); + +struct sinfonia_getprintidstatus_cmd { + struct sinfonia_cmd_hdr hdr; + uint8_t id; +} __attribute__((packed)); + +struct sinfonia_getprintidstatus_resp { + struct sinfonia_status_hdr hdr; + uint8_t id; + uint16_t remaining; + uint16_t finished; + uint16_t specified; + uint16_t status; +} __attribute__((packed)); + +#define IDSTATUS_WAITING 0x0000 +#define IDSTATUS_PRINTING 0x0100 +#define IDSTATUS_COMPLETED 0x0200 +#define IDSTATUS_ERROR 0xFFFF + +struct sinfonia_getserial_resp { + struct sinfonia_status_hdr hdr; + uint8_t data[8]; +} __attribute__((packed)); + +struct sinfonia_getextcounter_resp { + struct sinfonia_status_hdr hdr; + uint32_t lifetime_distance; /* Inches */ + uint32_t maint_distance; + uint32_t head_distance; + uint8_t reserved[32]; +} __attribute__((packed)); + +struct sinfonia_seteeprom_cmd { + struct sinfonia_cmd_hdr hdr; + uint8_t data[256]; /* Maxlen */ +} __attribute__((packed)); + +#define CODE_4x6 0x00 +#define CODE_3_5x5 0x01 +#define CODE_5x7 0x03 +#define CODE_6x9 0x05 +#define CODE_6x8 0x06 +#define CODE_2x6 0x07 +#define CODE_6x6 0x08 + +#define CODE_8x10 0x10 +#define CODE_8x12 0x11 +#define CODE_8x4 0x20 +#define CODE_8x5 0x21 +#define CODE_8x6 0x22 +#define CODE_8x8 0x23 +#define CODE_8x4_2 0x30 +#define CODE_8x5_2 0x31 +#define CODE_8x6_2 0x32 +#define CODE_8x4_3 0x40 + +#define CODE_89x60mm 0x10 +#define CODE_89x59mm 0x11 +#define CODE_89x58mm 0x12 +#define CODE_89x57mm 0x13 +#define CODE_89x56mm 0x14 +#define CODE_89x55mm 0x15 + +const char *sinfonia_print_codes (uint8_t v, int eightinch); + +#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_OP 0x69 +#define STATUS_PAPER_CUT 0x6A +#define STATUS_PAPER_EJECT 0x6B +#define STATUS_BACK_FEED_E 0x6C +#define STATUS_FINISHED 0x6D + +const char *sinfonia_status_str(uint8_t v); + +#define SINFONIA_CMD_GETSTATUS 0x0001 +#define SINFONIA_CMD_MEDIAINFO 0x0002 +#define SINFONIA_CMD_MODELNAME 0x0003 // 2145 only +#define SINFONIA_CMD_ERRORLOG 0x0004 +#define SINFONIA_CMD_GETPARAM 0x0005 // !2145 +#define SINFONIA_CMD_GETSERIAL 0x0006 // !2145 +#define SINFONIA_CMD_PRINTSTAT 0x0007 // !2145 +#define SINFONIA_CMD_EXTCOUNTER 0x0008 // !2145 + +#define SINFONIA_CMD_MEMORYBANK 0x000A // Brava 21 only? + +#define SINFONIA_CMD_PRINTJOB 0x4001 +#define SINFONIA_CMD_CANCELJOB 0x4002 +#define SINFONIA_CMD_FLASHLED 0x4003 +#define SINFONIA_CMD_RESET 0x4004 +#define SINFONIA_CMD_READTONE 0x4005 +#define SINFONIA_CMD_BUTTON 0x4006 // 2145 only +#define SINFONIA_CMD_SETPARAM 0x4007 + +#define SINFONIA_CMD_GETUNIQUE 0x8003 // 2145 only + +#define SINFONIA_CMD_GETCORR 0x400D +#define SINFONIA_CMD_GETEEPROM 0x400E +#define SINFONIA_CMD_SETEEPROM 0x400F +#define SINFONIA_CMD_SETTIME 0x4011 // 6245 only + +#define SINFONIA_CMD_FWINFO 0xC003 +#define SINFONIA_CMD_UPDATE 0xC004 +#define SINFONIA_CMD_SETUNIQUE 0xC007 // 2145 only + +const char *sinfonia_cmd_names(uint16_t v); + /* 6R: Also seen: 101-0867, 141-9597, 659-9054, 169-6418, DNP 900-060 */ #define KODAK6_MEDIA_6R 0x0b // 197-4096 #define KODAK6_MEDIA_UNK 0x03