slp
/
selphy_print
1
0
Fork 0
Code Issues Pull Requests Activity

shinkos2245: Further improvements: 

* Support setting image quality in the print command
 * Error code list improved.
 * Correct image correction data queries
 * Better documentation
 * Fix settime call

 Still broken:

    * Corrdata parsing
    * Print 'mode' enumeration (possibly media checking too)
    * And Printing, duh.
This commit is contained in:
Solomon Peachy 2020-07-29 19:36:10 -04:00
parent 0e59dd80f5
commit 9875b026ad
4 changed files with 187 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
backend_shinkos6145.c
View File

@ -517,8 +517,6 @@ static const char *s6145_error_codes(uint8_t major, uint8_t minor)
} }
} }
/* XXX these are generally assumed to be the same as S6145, but
at least the "user error" category is known to be different. */
static const char *s2245_error_codes(uint8_t major, uint8_t minor) static const char *s2245_error_codes(uint8_t major, uint8_t minor)
{ {
switch(major) { switch(major) {
@ -531,9 +529,9 @@ static const char *s2245_error_codes(uint8_t major, uint8_t minor)
case 0x0C: case 0x0C:
return "Controller: Print Parameter Table Mismatch"; return "Controller: Print Parameter Table Mismatch";
case 0x0F: case 0x0F:
return "Controller: Main FW Checksum"; return "Controller: Main FW Data Error";
case 0x10: case 0x10:
return "Controller: Flash Write Failed"; return "Controller: Main FW Write Failed";
case 0x13: case 0x13:
return "Controller: Print Parameter Table Checksum"; return "Controller: Print Parameter Table Checksum";
case 0x14: case 0x14:
@ -542,14 +540,8 @@ static const char *s2245_error_codes(uint8_t major, uint8_t minor)
return "Controller: User Tone Curve Write Failed"; return "Controller: User Tone Curve Write Failed";
case 0x16: case 0x16:
return "Controller: MSP Communication"; return "Controller: MSP Communication";
case 0x17:
return "Controller: THV Autotuning";
case 0x18:
return "Controller: THV Value Out of Range";
case 0x19: case 0x19:
return "Controller: Thermal Head"; return "Controller: Thermal Head";
case 0x1A:
return "Controller: Wake from Power Save Failed";
default: default:
return "Controller: Unknown"; return "Controller: Unknown";
} }
@ -563,39 +555,39 @@ static const char *s2245_error_codes(uint8_t major, uint8_t minor)
return "Mechanical: Pinch Head (position 2)"; return "Mechanical: Pinch Head (position 2)";
case 0x04: case 0x04:
return "Mechanical: Pinch Head (position 3)"; return "Mechanical: Pinch Head (position 3)";
case 0x0B: case 0x05:
return "Mechanical: Cutter (Right)"; return "Mechanical: Pinch Head (position 4)";
case 0x0C: case 0x14:
return "Mechanical: Cutter (Left)"; return "Mechanical: Cutter (Left-Right)";
case 0x15:
return "Mechanical: Cutter (Right-Left)";
default: default:
return "Mechanical: Unknown"; return "Mechanical: Unknown";
} }
case 0x03: /* "Sensor Error" */ case 0x03: /* "Sensor Error" */
switch (minor) { switch (minor) {
case 0x01: case 0x01:
return "Sensor: Head Up";
case 0x02:
return "Sensor: Head Down";
case 0x0B:
return "Sensor: Cutter Left";
case 0x0C:
return "Sensor: Cutter Right";
case 0x0D:
return "Sensor: Cutter Left+Right"; return "Sensor: Cutter Left+Right";
case 0x15: case 0x02:
return "Sensor: Head Up Unstable"; return "Sensor: Cutter Left drove";
case 0x16: case 0x03:
return "Sensor: Head Down Unstable"; return "Sensor: Cutter Right drove";
case 0x17:
return "Sensor: Cutter Left Unstable";
case 0x18:
return "Sensor: Cutter Right Unstable";
case 0x19:
return "Sensor: Cover Open Unstable";
case 0x1E: case 0x1E:
return "Sensor: Ribbon Mark (Cyan)"; return "Sensor: Left Front Lock";
case 0x1F: case 0x1F:
return "Sensor: Ribbon Mark (OC)"; return "Sensor: Right Front Lock";
case 0x20:
return "Sensor: Cutter Left";
case 0x21:
return "Sensor: Cutter Right";
case 0x22:
return "Sensor: Left Head/Pinch";
case 0x23:
return "Sensor: Right Head/Pinch";
case 0x24:
return "Sensor: Head/Pinch Encoder";
case 0x25:
return "Sensor: Supply Ribbon Encoder";
default: default:
return "Sensor: Unknown"; return "Sensor: Unknown";
} }
@ -619,93 +611,60 @@ static const char *s2245_error_codes(uint8_t major, uint8_t minor)
case 0x5: /* "Paper Jam" */ case 0x5: /* "Paper Jam" */
switch (minor) { switch (minor) {
case 0x01: case 0x01:
return "Paper Jam: Loading Paper Top On"; return "Paper Jam: Paper Not Detected";
case 0x02: case 0x02:
return "Paper Jam: Loading Print Position On"; return "Paper Jam: Pinch Roller Fail";
case 0x03: case 0x10:
return "Paper Jam: Loading Print Position Off"; return "Paper Jam: Print Position Sensor on";
case 0x04: case 0x11:
return "Paper Jam: Loading Paper Top Off"; return "Paper Jam: Print Position Sensor off";
case 0x05: case 0x12:
return "Paper Jam: Loading Cut Print Position Off"; return "Paper Jam: Paper End Sensor on";
case 0x0C: case 0x13:
return "Paper Jam: Initializing Print Position Off"; return "Paper Jam: Paper Cut";
case 0x0D:
return "Paper Jam: Initializing Print Position On";
case 0x15:
return "Paper Jam: Printing Print Position Off";
case 0x16:
return "Paper Jam: Printing Paper Top On";
case 0x17:
return "Paper Jam: Printing Paper Top Off";
case 0x1F:
return "Paper Jam: Precut Print Position Off";
case 0x20:
return "Paper Jam: Precut Print Position On";
case 0x29:
return "Paper Jam: Printing Paper Top On";
case 0x2A:
return "Paper Jam: Printing Pre-Yellow Print Position Off";
case 0x2B:
return "Paper Jam: Printing Yellow Print Position Off";
case 0x2C:
return "Paper Jam: Printing Yellow Print Position On";
case 0x2D:
return "Paper Jam: Printing Pre-Magenta Print Position Off";
case 0x2E:
return "Paper Jam: Printing Magenta Print Position On";
case 0x2F:
return "Paper Jam: Printing Magenta Print Position Off";
case 0x30: case 0x30:
return "Paper Jam: Printing Pre-Cyan Print Position Off"; return "Paper Jam: Print Position Sensor early";
case 0x31: case 0x31:
return "Paper Jam: Printing Cyan Print Position On"; return "Paper Jam: Print Position Sensor on";
case 0x32: case 0x32:
return "Paper Jam: Printing Cyan Print Position Off"; return "Paper Jam: Print Position Sensor off";
case 0x33: case 0x40:
return "Paper Jam: Printing Pre-OC Print Position Off"; return "Paper Jam: Cutter Left-Right";
case 0x34: case 0x41:
return "Paper Jam: Printing OC Print Position On"; return "Paper Jam: Cutter Right-Left";
case 0x35:
return "Paper Jam: Printing OC Print Position Off";
case 0x36:
return "Paper Jam: Cut Print Position Off";
case 0x37:
return "Paper Jam: Home Position Off";
case 0x38:
return "Paper Jam: Paper Top Off";
case 0x39:
return "Paper Jam: Print Position On";
case 0x51: case 0x51:
return "Paper Jam: Paper Empty On, Top On, Position On"; return "Paper Jam: Paper End On, Position Off";
case 0x52: case 0x52:
return "Paper Jam: Paper Empty On, Top On, Position Off"; return "Paper Jam: Paper End Off, Position On";
case 0x54: case 0x53:
return "Paper Jam: Paper Empty On, Top Off, Position Off"; return "Paper Jam: Paper End On, Position On";
case 0x60:
return "Paper Jam: Cutter Right";
case 0x61:
return "Paper Jam: Cutter Left";
default: default:
return "Paper Jam: Unknown"; return "Paper Jam: Unknown";
} }
case 0x06: /* User Error */ case 0x06: /* User Error */
switch (minor) { switch (minor) {
case 0x01: case 0x01:
return "Drawer Unit Open"; return "Cover Open";
case 0x02: case 0x02:
return "Cover Not Closed";
case 0x03:
return "Incorrect Ribbon"; return "Incorrect Ribbon";
case 0x04: case 0x04:
return "Ribbon Empty"; return "Ribbon End";
case 0x07: case 0x07:
return "UKNOWN USER ERROR 0x07";
case 0x08:
return "No Paper"; return "No Paper";
case 0x0C: case 0x08:
return "Paper End"; return "Paper End";
case 0x0D:
return "No Ribbon";
case 0x0E:
return "Ribbon Rewind Failure";
case 0x0F:
return "Ribbon Sense Failure";
case 0x20:
return "THV Tuning";
case 0x21:
return "THV Not Tuned";
default: default:
return "Unknown"; return "Unknown";
} }
@ -772,6 +731,8 @@ struct s2245_imagecorr_req {
uint8_t null[10]; uint8_t null[10];
} __attribute__((packed)); } __attribute__((packed));
#define S2245_IMAGECORR_FLAG_CONTOUR_ENH 0x01
struct s2245_imagecorr_resp { struct s2245_imagecorr_resp {
struct sinfonia_status_hdr hdr; struct sinfonia_status_hdr hdr;
uint32_t total_size; uint32_t total_size;
@ -810,7 +771,8 @@ struct shinkos6145_ctx {
uint16_t corrdatalen; uint16_t corrdatalen;
}; };
static int shinkos2245_get_imagecorr(struct shinkos6145_ctx *ctx, uint8_t options, uint8_t flags); static const char *s2245_drivermodes(uint8_t val);
static int shinkos2245_get_imagecorr(struct shinkos6145_ctx *ctx, uint8_t options);
static int shinkos6145_get_imagecorr(struct shinkos6145_ctx *ctx); static int shinkos6145_get_imagecorr(struct shinkos6145_ctx *ctx);
static int shinkos6145_get_eeprom(struct shinkos6145_ctx *ctx); static int shinkos6145_get_eeprom(struct shinkos6145_ctx *ctx);
@ -901,12 +863,15 @@ static int get_status(struct shinkos6145_ctx *ctx)
} }
INFO("Paper Preserve mode: %s\n", (val ? "On" : "Off")); INFO("Paper Preserve mode: %s\n", (val ? "On" : "Off"));
} }
if ((ret = sinfonia_getparam(&ctx->dev, PARAM_DRIVER_MODE, &val))) { if ((ret = sinfonia_getparam(&ctx->dev, PARAM_DRIVER_MODE, &val))) {
ERROR("Failed to execute command\n"); ERROR("Failed to execute command\n");
return ret; return ret;
} }
INFO("Driver mode: %s\n", (val ? "On" : "Off")); if (ctx->dev.type != P_SHINKO_S2245) {
INFO("Driver mode: %s\n", s2245_drivermodes(val));
} else {
INFO("Driver mode: %s\n", (val ? "On" : "Off"));
}
if ((ret = sinfonia_getparam(&ctx->dev, PARAM_PAPER_MODE, &val))) { if ((ret = sinfonia_getparam(&ctx->dev, PARAM_PAPER_MODE, &val))) {
ERROR("Failed to execute command\n"); ERROR("Failed to execute command\n");
@ -962,7 +927,7 @@ static int shinkos6145_dump_corrdata(struct shinkos6145_ctx *ctx, char *fname)
int ret; int ret;
if (ctx->dev.type == P_SHINKO_S2245) { if (ctx->dev.type == P_SHINKO_S2245) {
ret = shinkos2245_get_imagecorr(ctx, 0x0a, 0x01); // XXX have to supply something.. ret = shinkos2245_get_imagecorr(ctx, 0x0a); // XXX have to supply something.. this is HQ matte.
} else { } else {
ret = shinkos6145_get_imagecorr(ctx); ret = shinkos6145_get_imagecorr(ctx);
} }
@ -1080,7 +1045,7 @@ done:
// XXX this is bogus, corrdata is 10224 bytes vs the 12432 bytes of the S6145! // XXX this is bogus, corrdata is 10224 bytes vs the 12432 bytes of the S6145!
// However they use the same image processing DLL so the S2245 data must be // However they use the same image processing DLL so the S2245 data must be
// transforamble somehow. Or is it? // transforamble somehow. Or is it?
static int shinkos2245_get_imagecorr(struct shinkos6145_ctx *ctx, uint8_t options, uint8_t flags) static int shinkos2245_get_imagecorr(struct shinkos6145_ctx *ctx, uint8_t options)
{ {
struct s2245_imagecorr_req cmd; struct s2245_imagecorr_req cmd;
struct s2245_imagecorr_resp resp; struct s2245_imagecorr_resp resp;
@ -1090,7 +1055,7 @@ static int shinkos2245_get_imagecorr(struct shinkos6145_ctx *ctx, uint8_t option
cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_GETCORR); cmd.hdr.cmd = cpu_to_le16(SINFONIA_CMD_GETCORR);
cmd.hdr.len = sizeof(cmd) - sizeof(cmd.hdr); cmd.hdr.len = sizeof(cmd) - sizeof(cmd.hdr);
cmd.options = options; cmd.options = options;
cmd.flags = flags; cmd.flags = S2245_IMAGECORR_FLAG_CONTOUR_ENH; // XXX make configurable?
if (ctx->corrdata) { if (ctx->corrdata) {
free(ctx->corrdata); free(ctx->corrdata);
@ -1173,6 +1138,21 @@ done:
return ret; return ret;
} }
static const char *s2245_drivermodes(uint8_t val)
{
switch(val) {
case 0x00:
return "-Class/-iSerial";
case 0x01:
return "-Class/+iSerial";
case 0x02:
return "+Class/-iSerial";
case 0x03:
return "+Class/+iSerial";
}
return "Unknown";
}
static int s2245_get_errorlog(struct sinfonia_usbdev *usbh) static int s2245_get_errorlog(struct sinfonia_usbdev *usbh)
{ {
struct sinfonia_errorlog2_cmd cmd; struct sinfonia_errorlog2_cmd cmd;
@ -1736,13 +1716,43 @@ static int shinkos6145_main_loop(void *vctx, const void *vjob) {
// XXX check copies against remaining media? // XXX check copies against remaining media?
/* Query printer mode */ if (ctx->dev.type != P_SHINKO_S2245) {
ret = sinfonia_getparam(&ctx->dev, PARAM_OC_PRINT, &cur_mode); /* Query printer mode */
if (ret) { ret = sinfonia_getparam(&ctx->dev, PARAM_OC_PRINT, &cur_mode);
ERROR("Failed to execute command\n"); if (ret) {
return ret; ERROR("Failed to execute command\n");
return ret;
}
} }
/* Send Set Time */
if (ctx->dev.type == P_SHINKO_S2245) {
struct sinfonia_settime_cmd settime;
time_t now = time(NULL);
struct tm *cur = localtime(&now);
memset(&settime, 0, sizeof(settime));
settime.hdr.cmd = cpu_to_le16(SINFONIA_CMD_SETTIME);
settime.hdr.len = cpu_to_le16(sizeof(settime)-sizeof(settime.hdr));
settime.enable = 1;
settime.second = cur->tm_sec;
settime.minute = cur->tm_min;
settime.hour = cur->tm_hour;
settime.day = cur->tm_mday;
settime.month = cur->tm_mon;
settime.year = cur->tm_year + 1900 - 2000;
if ((ret = sinfonia_docmd(&ctx->dev,
(uint8_t*)&settime, sizeof(settime),
(uint8_t*)&sts, sizeof(sts),
&num))) {
return CUPS_BACKEND_FAILED;
}
if (sts.hdr.result != RESULT_SUCCESS)
return CUPS_BACKEND_FAILED;
}
top: top:
if (state != last_state) { if (state != last_state) {
if (dyesub_debug) if (dyesub_debug)
@ -1797,29 +1807,28 @@ top:
uint32_t oc_mode = job->jp.oc_mode; uint32_t oc_mode = job->jp.oc_mode;
uint32_t updated = 0; uint32_t updated = 0;
// XXX 2245 mode different? if (ctx->dev.type == P_SHINKO_S2245) {
if (!oc_mode) /* if nothing set, default to glossy */
oc_mode = PARAM_OC_PRINT_GLOSS;
if (!oc_mode) /* if nothing set, default to glossy */ if (cur_mode != oc_mode) {
oc_mode = PARAM_OC_PRINT_GLOSS; /* 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) {
INFO("Need to switch overcoat mode, waiting for printer idle\n");
sleep(1);
goto top;
}
if (cur_mode != oc_mode) {
/* 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) {
INFO("Need to switch overcoat mode, waiting for printer idle\n");
sleep(1);
goto top;
}
if (ctx->dev.type == P_SHINKO_S2245) {
ret = sinfonia_setparam(&ctx->dev, PARAM_OC_PRINT, oc_mode); ret = sinfonia_setparam(&ctx->dev, PARAM_OC_PRINT, oc_mode);
if (ret) { if (ret) {
ERROR("Failed to execute command\n"); ERROR("Failed to execute command\n");
return ret; return ret;
} }
updated = 1;
} }
updated = 1;
} }
ret = shinkos6145_get_eeprom(ctx); ret = shinkos6145_get_eeprom(ctx);
@ -1828,11 +1837,11 @@ top:
return ret; return ret;
} }
/* Get image correction parameters if necessary */ if (ctx->dev.type == P_SHINKO_S2245) {
if (updated || !ctx->corrdata || !ctx->corrdatalen) { ret = shinkos2245_get_imagecorr(ctx, (job->jp.oc_mode & SINFONIA_PRINT28_OC_MASK) | (job->jp.quality ? SINFONIA_PRINT28_OPTIONS_HQ : 0));
if (ctx->dev.type == P_SHINKO_S2245) { } else {
ret = shinkos2245_get_imagecorr(ctx, (job->jp.oc_mode & 0x3) | 0x08, 0x01); // XXX 0x08 pull from job, oc_mode! 0x01?? /* Get image correction parameters if necessary */
} else { if (updated || !ctx->corrdata || !ctx->corrdatalen) {
ret = shinkos6145_get_imagecorr(ctx); ret = shinkos6145_get_imagecorr(ctx);
} }
if (ret) { if (ret) {
@ -1913,10 +1922,10 @@ top:
print.options = job->jp.oc_mode & 0x3; print.options = job->jp.oc_mode & 0x3;
if (job->jp.quality) if (job->jp.quality)
print.options |= 0x08; print.options |= 0x08;
print.media = job->jp.media; print.media = 0; /* ignore job->jp.media! */
print.image_avg = ctx->image_avg[2]; /* Cyan level */ print.ipp = SINFONIA_PRINT28_IPP_CONTOUR;
print.method = cpu_to_le32(job->jp.method); print.method = cpu_to_le32(job->jp.method | SINFONIA_PRINT28_METHOD_ERR_RECOVERY | SINFONIA_PRINT28_METHOD_ERR_PREHEAT);
if ((ret = sinfonia_docmd(&ctx->dev, if ((ret = sinfonia_docmd(&ctx->dev,
(uint8_t*)&print, sizeof(print), (uint8_t*)&print, sizeof(print),
@ -2131,7 +2140,7 @@ static const char *shinkos6145_prefixes[] = {
struct dyesub_backend shinkos6145_backend = { struct dyesub_backend shinkos6145_backend = {
.name = "Shinko/Sinfonia CHC-S6145/CS2/S2245/S3", .name = "Shinko/Sinfonia CHC-S6145/CS2/S2245/S3",
.version = "0.49" " (lib " LIBSINFONIA_VER ")", .version = "0.40" " (lib " LIBSINFONIA_VER ")",
.uri_prefixes = shinkos6145_prefixes, .uri_prefixes = shinkos6145_prefixes,
.cmdline_usage = shinkos6145_cmdline, .cmdline_usage = shinkos6145_cmdline,
.cmdline_arg = shinkos6145_cmdline_arg, .cmdline_arg = shinkos6145_cmdline_arg,

17
backend_shinkos6245.c
View File

@ -142,17 +142,6 @@ static const struct sinfonia_param s6245_params[] =
#define PARAM_SLEEP_120MIN 0x00000004 #define PARAM_SLEEP_120MIN 0x00000004
#define PARAM_SLEEP_240MIN 0x00000005 #define PARAM_SLEEP_240MIN 0x00000005
struct s6245_settime_cmd {
struct sinfonia_cmd_hdr hdr;
uint8_t enable; /* 0 or 1 */
uint8_t second;
uint8_t minute;
uint8_t hour;
uint8_t day;
uint8_t month;
uint8_t year;
} __attribute__((packed));
static const char *s6245_error_codes(uint8_t major, uint8_t minor) static const char *s6245_error_codes(uint8_t major, uint8_t minor)
{ {
switch(major) { switch(major) {
@ -1174,13 +1163,13 @@ static int shinkos6245_main_loop(void *vctx, const void *vjob) {
/* Send Set Time */ /* Send Set Time */
if (ctx->dev.type != P_KODAK_8810) { if (ctx->dev.type != P_KODAK_8810) {
struct s6245_settime_cmd *settime = (struct s6245_settime_cmd *)cmdbuf; struct sinfonia_settime_cmd *settime = (struct sinfonia_settime_cmd *)cmdbuf;
time_t now = time(NULL); time_t now = time(NULL);
struct tm *cur = localtime(&now); struct tm *cur = localtime(&now);
memset(cmdbuf, 0, CMDBUF_LEN); memset(cmdbuf, 0, CMDBUF_LEN);
cmd->cmd = cpu_to_le16(SINFONIA_CMD_SETTIME); cmd->cmd = cpu_to_le16(SINFONIA_CMD_SETTIME);
cmd->len = cpu_to_le16(0); cmd->len = cpu_to_le16(sizeof(*settime)-sizeof(settime->hdr));
settime->enable = 1; settime->enable = 1;
settime->second = cur->tm_sec; settime->second = cur->tm_sec;
settime->minute = cur->tm_min; settime->minute = cur->tm_min;
@ -1479,7 +1468,7 @@ static const char *shinkos6245_prefixes[] = {
struct dyesub_backend shinkos6245_backend = { struct dyesub_backend shinkos6245_backend = {
.name = "Sinfonia CHC-S6245 / Kodak 8810", .name = "Sinfonia CHC-S6245 / Kodak 8810",
.version = "0.34" " (lib " LIBSINFONIA_VER ")", .version = "0.35" " (lib " LIBSINFONIA_VER ")",
.uri_prefixes = shinkos6245_prefixes, .uri_prefixes = shinkos6245_prefixes,
.cmdline_usage = shinkos6245_cmdline, .cmdline_usage = shinkos6245_cmdline,
.cmdline_arg = shinkos6245_cmdline_arg, .cmdline_arg = shinkos6245_cmdline_arg,

4
backend_sinfonia.c
View File

@ -280,8 +280,8 @@ int sinfonia_raw28_read_parse(int data_fd, struct sinfonia_printjob *job)
job->jp.rows = le16_to_cpu(hdr.rows); job->jp.rows = le16_to_cpu(hdr.rows);
job->jp.columns = le16_to_cpu(hdr.columns); job->jp.columns = le16_to_cpu(hdr.columns);
job->jp.media = hdr.media; job->jp.media = hdr.media;
job->jp.oc_mode = hdr.options & 0x03; job->jp.oc_mode = hdr.options & SINFONIA_PRINT28_OC_MASK;
job->jp.quality = hdr.options & 0x08; job->jp.quality = hdr.options & SINFONIA_PRINT28_OPTIONS_HQ;
job->jp.method = hdr.method; job->jp.method = hdr.method;
/* Allocate buffer */ /* Allocate buffer */

43
backend_sinfonia.h
View File

@ -24,7 +24,7 @@
* *
*/ */
#define LIBSINFONIA_VER "0.14" #define LIBSINFONIA_VER "0.15"
#define SINFONIA_HDR1_LEN 0x10 #define SINFONIA_HDR1_LEN 0x10
#define SINFONIA_HDR2_LEN 0x64 #define SINFONIA_HDR2_LEN 0x64
@ -168,6 +168,7 @@ const char *sinfonia_print_modes(uint8_t v);
#define PRINT_METHOD_COMBO_2 0x02 #define PRINT_METHOD_COMBO_2 0x02
#define PRINT_METHOD_COMBO_3 0x03 // S6245 only #define PRINT_METHOD_COMBO_3 0x03 // S6245 only
#define PRINT_METHOD_SPLIT 0x04 #define PRINT_METHOD_SPLIT 0x04
#define PRINT_METHOD_4SPLIT 0x05 // S2245 only
#define PRINT_METHOD_DOUBLE 0x08 // S6145 only #define PRINT_METHOD_DOUBLE 0x08 // S6145 only
#define PRINT_METHOD_DISABLE_ERR 0x10 // S6245 only #define PRINT_METHOD_DISABLE_ERR 0x10 // S6245 only
#define PRINT_METHOD_NOTRIM 0x80 // S6145 only #define PRINT_METHOD_NOTRIM 0x80 // S6145 only
@ -195,7 +196,7 @@ struct sinfonia_status_hdr {
uint8_t printer_major; uint8_t printer_major;
uint8_t printer_minor; uint8_t printer_minor;
uint8_t reserved[2]; uint8_t reserved[2];
uint8_t mode; /* S6245 and EK605 only, so far */ uint8_t mode; /* S2245, S6245 and EK605 only, so far */
uint8_t status; uint8_t status;
uint16_t payload_len; uint16_t payload_len;
} __attribute__((packed)); } __attribute__((packed));
@ -345,7 +346,6 @@ struct sinfonia_reset_cmd {
#define RESET_PRINTER 0x03 #define RESET_PRINTER 0x03
#define RESET_TONE_CURVE 0x04 #define RESET_TONE_CURVE 0x04
#define TONE_CURVE_ID 0x01 #define TONE_CURVE_ID 0x01
struct sinfonia_readtone_cmd { struct sinfonia_readtone_cmd {
@ -420,14 +420,41 @@ struct sinfonia_printcmd28_hdr {
uint16_t copies; uint16_t copies;
uint16_t columns; uint16_t columns;
uint16_t rows; uint16_t rows;
uint8_t media; uint8_t media; /* always 0 on S2245 */
uint8_t reserved[7]; uint8_t reserved[7];
uint8_t options; // XXX guess (passed into imagecorr fetch!) uint8_t options;
uint8_t method; // XXX guess could be image_avg uint8_t method;
uint8_t image_avg; // XXX guess could be matte? uint8_t ipp;
uint8_t reserved2[10]; uint8_t reserved2[10];
} __attribute__((packed)); } __attribute__((packed));
#define SINFONIA_PRINT28_OPTIONS_HQ 0x08
#define SINFONIA_PRINT28_OC_MASK 0x03
#define SINFONIA_PRINT28_OC_GLOSS 0x01
#define SINFONIA_PRINT28_OC_MATTE 0x02
#define SINFONIA_PRINT28_METHOD_PRINT_MASK 0x07
#define SINFONIA_PRINT28_METHOD_PRINT_COMBO 0x02
#define SINFONIA_PRINT28_METHOD_PRINT_SPLIT 0x04
#define SINFONIA_PRINT28_METHOD_PRINT_4SPLIT 0x05
#define SINFONIA_PRINT28_METHOD_ERR_RECOVERY 0x08
#define SINFONIA_PRINT28_METHOD_ERR_PREHEAT 0x10
#define SINFONIA_PRINT28_IPP_RESP 0x01
#define SINFONIA_PRINT28_IPP_CONTOUR 0x02
struct sinfonia_settime_cmd {
struct sinfonia_cmd_hdr hdr;
uint8_t enable; /* 0 or 1 */
uint8_t second;
uint8_t minute;
uint8_t hour;
uint8_t day;
uint8_t month;
uint8_t year;
} __attribute__((packed));
struct kodak701x_backprint { struct kodak701x_backprint {
struct sinfonia_cmd_hdr hdr; struct sinfonia_cmd_hdr hdr;
uint8_t unk_0; // unknown. maybe the line number? uint8_t unk_0; // unknown. maybe the line number?
@ -529,7 +556,7 @@ const char *sinfonia_status_str(uint8_t v);
#define SINFONIA_CMD_GETEEPROM 0x400E // 6x45 #define SINFONIA_CMD_GETEEPROM 0x400E // 6x45
#define SINFONIA_CMD_SETEEPROM 0x400F // 6x45 #define SINFONIA_CMD_SETEEPROM 0x400F // 6x45
#define SINFONIA_CMD_SETTIME 0x4011 // 6245 #define SINFONIA_CMD_SETTIME 0x4011 // 6245, 2245
#define SINFONIA_CMD_UNIVERSAL 0x4080 // EK70xx #define SINFONIA_CMD_UNIVERSAL 0x4080 // EK70xx