summaryrefslogtreecommitdiffstats
path: root/backend_sinfonia.h
blob: 2726054d7cad03b1d4e9b849527bdaad06469a7d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
 /*
 *   Shinko/Sinfonia Common Code
 *
 *   (c) 2019 Solomon Peachy <pizza@shaftnet.org>
 *
 *   The latest version of this program can be found at:
 *
 *     http://git.shaftnet.org/cgit/selphy_print.git
 *
 *   This program is free software; you can redistribute it and/or modify it
 *   under the terms of the GNU General Public License as published by the Free
 *   Software Foundation; either version 3 of the License, or (at your option)
 *   any later version.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 *   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *   for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *          [http://www.gnu.org/licenses/gpl-3.0.html]
 *
 *   SPDX-License-Identifier: GPL-3.0+
 *
 */

#define LIBSINFONIA_VER "0.13"

#define SINFONIA_HDR1_LEN 0x10
#define SINFONIA_HDR2_LEN 0x64
#define SINFONIA_HDR_LEN (SINFONIA_HDR1_LEN + SINFONIA_HDR2_LEN)
#define SINFONIA_DPI 300

struct sinfonia_job_param {
	uint32_t columns;
	uint32_t rows;
	uint32_t copies;

	uint32_t method;
	uint32_t media;
	uint32_t oc_mode;

	uint32_t quality;

	int      mattedepth;
	uint32_t dust;

	uint32_t ext_flags;
};
#define EXT_FLAG_PLANARYMC  0x01
#define EXT_FLAG_BACKPRINT  0x02
#define EXT_FLAG_DOUBLESLUG 0x04

struct sinfonia_printjob {
	struct sinfonia_job_param jp;

	uint8_t *databuf;
	int datalen;
	int copies;
};

int sinfonia_read_parse(int data_fd, uint32_t model,
			struct sinfonia_printjob *job);

int sinfonia_raw10_read_parse(int data_fd, struct sinfonia_printjob *job);
int sinfonia_raw18_read_parse(int data_fd, struct sinfonia_printjob *job);
int sinfonia_raw28_read_parse(int data_fd, struct sinfonia_printjob *job);
void sinfonia_cleanup_job(const void *vjob);


/* mapping param IDs to names */
struct sinfonia_param {
	const uint8_t id;
	const char *descr;
};

/* Common usb functions */
struct sinfonia_usbdev {
	struct libusb_device_handle *dev;
	uint8_t endp_up;
	uint8_t endp_down;
	int type;
	int iface;

	const struct sinfonia_param *params;
	int params_count;

	char const *(*error_codes)(uint8_t major, uint8_t minor);
};
int sinfonia_docmd(struct sinfonia_usbdev *usbh,
		   uint8_t *cmd, int cmdlen,
		   uint8_t *resp, int resplen,
		   int *num);
int sinfonia_flashled(struct sinfonia_usbdev *usbh);
int sinfonia_canceljob(struct sinfonia_usbdev *usbh, int id);
int sinfonia_getparam(struct sinfonia_usbdev *usbh, int target, uint32_t *param);
int sinfonia_setparam(struct sinfonia_usbdev *usbh, int target, uint32_t param);
int sinfonia_getfwinfo(struct sinfonia_usbdev *usbh);
int sinfonia_geterrorlog(struct sinfonia_usbdev *usbh);
int sinfonia_resetcurve(struct sinfonia_usbdev *usbh, int target, int id);
int sinfonia_gettonecurve(struct sinfonia_usbdev *usbh, int type, char *fname);
int sinfonia_settonecurve(struct sinfonia_usbdev *usbh, int target, char *fname);
int sinfonia_button_set(struct sinfonia_usbdev *dev, int enable);

int sinfonia_query_serno(struct libusb_device_handle *dev, uint8_t endp_up, uint8_t endp_down, char *buf, int buf_len);
int sinfonia_dumpallparams(struct sinfonia_usbdev *usbh, int known);
const char *sinfonia_paramname(struct sinfonia_usbdev *usbh, int id);

#define BANK_STATUS_FREE  0x00
#define BANK_STATUS_XFER  0x01
#define BANK_STATUS_FULL  0x02
#define BANK_STATUS_PRINTING  0x12  /* Not on S2145 */

const char *sinfonia_bank_statuses(uint8_t v);

#define UPDATE_TARGET_TONE_USER     0x03
#define UPDATE_TARGET_TONE_CURRENT  0x04
#define UPDATE_TARGET_LAM_USER 0x10
#define UPDATE_TARGET_LAM_DEF  0x11
#define UPDATE_TARGET_LAM_CUR  0x12

/* Update is three channels, Y, M, C;
   each is 256 entries of 11-bit data padded to 16-bits.
   Printer expects LE data.  We use BE data on disk.
*/
#define TONE_CURVE_SIZE (256*3)
const char *sinfonia_update_targets (uint8_t v);

#define TONECURVE_INIT    0x00
#define TONECURVE_USER    0x01
#define TONECURVE_CURRENT 0x02

const char *sinfonia_tonecurve_statuses (uint8_t v);

struct sinfonia_error_item {
	uint8_t  major;
	uint8_t  minor;
	uint32_t print_counter;
} __attribute__((packed));

#define ERROR_NONE              0x00
#define ERROR_INVALID_PARAM     0x01
#define ERROR_MAIN_APP_INACTIVE 0x02
#define ERROR_COMMS_TIMEOUT     0x03
#define ERROR_MAINT_NEEDED      0x04
#define ERROR_BAD_COMMAND       0x05
#define ERROR_PRINTER           0x11
#define ERROR_BUFFER_FULL       0x21

const char *sinfonia_error_str(uint8_t v);

enum {
	MEDIA_TYPE_UNKNOWN = 0x00,
	MEDIA_TYPE_PAPER = 0x01,
};

const char *sinfonia_media_types(uint8_t v);

#define PRINT_MODE_NO_OC        0x01
#define PRINT_MODE_GLOSSY       0x02
#define PRINT_MODE_MATTE        0x03
const char *sinfonia_print_modes(uint8_t v);

#define PRINT_METHOD_STD     0x00
#define PRINT_METHOD_COMBO_2 0x02
#define PRINT_METHOD_COMBO_3 0x03 // S6245 only
#define PRINT_METHOD_SPLIT   0x04
#define PRINT_METHOD_DOUBLE  0x08 // S6145 only
#define PRINT_METHOD_DISABLE_ERR 0x10 // S6245 only
#define PRINT_METHOD_NOTRIM  0x80 // S6145 only

const char *sinfonia_print_methods (uint8_t v);

#define FWINFO_TARGET_MAIN_BOOT    0x01
#define FWINFO_TARGET_MAIN_APP     0x02
#define FWINFO_TARGET_PRINT_TABLES 0x03
#define FWINFO_TARGET_DSP          0x04
#define FWINFO_TARGET_USB          0x06
#define FWINFO_TARGET_PRINT_TABLES2 0x07

const char *sinfonia_fwinfo_targets (uint8_t v);

/* Common command structs */
struct sinfonia_cmd_hdr {
	uint16_t cmd;
	uint16_t len;  /* Not including this header */
} __attribute__((packed));

struct sinfonia_status_hdr {
	uint8_t  result;
	uint8_t  error;
	uint8_t  printer_major;
	uint8_t  printer_minor;
	uint8_t  reserved[2];
	uint8_t  mode;  /* S6245 and EK605 only, so far */
	uint8_t  status;
	uint16_t payload_len;
} __attribute__((packed));

struct sinfonia_cancel_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  id;
} __attribute__((packed));

struct sinfonia_fwinfo_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  target;
} __attribute__((packed));

struct sinfonia_fwinfo_resp {
	struct sinfonia_status_hdr hdr;
	uint8_t  name[8];
	uint8_t  type[16];
	uint8_t  date[10];
	uint8_t  major;
	uint8_t  minor;
	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_6x45_mediainfo_resp {
	struct sinfonia_status_hdr hdr;
	uint8_t ribbon_code;
	uint8_t reserved;
	uint8_t count;
	struct sinfonia_mediainfo_item items[10];  /* Not all necessarily used */
} __attribute__((packed));

/* resp needs to be at least sizeof(struct sinfonia_6x45_mediainfo_resp) */

int sinfonia_query_media(struct sinfonia_usbdev *usbh,
			 void *resp);

struct sinfonia_setparam_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t target;
	uint32_t param;
} __attribute__((packed));

struct sinfonia_diagnostic_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t arg1;
	uint8_t arg2;
	uint8_t arg3;
} __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_button_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  enabled;
} __attribute__((packed));

#define BUTTON_ENABLED  0x01
#define BUTTON_DISABLED 0x00

struct sinfonia_reset_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  target;
	uint8_t  curveid;
} __attribute__((packed));

#define RESET_PRINTER       0x03
#define RESET_TONE_CURVE    0x04

#define TONE_CURVE_ID       0x01

struct sinfonia_readtone_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  target;
	uint8_t  curveid;
} __attribute__((packed));

#define READ_TONE_CURVE_USER 0x01
#define READ_TONE_CURVE_CURR 0x02

struct sinfonia_readtone_resp {
	struct sinfonia_status_hdr hdr;
	uint16_t total_size;
} __attribute__((packed));

struct sinfonia_update_cmd {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  target;    // UPDATE_TARGET_TONE_*
	uint8_t  curve_id;  // 00 for lamination, 01 for tone?
	uint8_t  reset;     // ??
	uint8_t  reserved[3];
	uint32_t size;  // TONE_CURVE_SIZE or lamination data that is rows*cols bytes
} __attribute__((packed));

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));

struct sinfonia_printcmd10_hdr {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  jobid;
	uint16_t copies;
	uint16_t columns;
	uint16_t rows;
	uint8_t  media;
	uint8_t  oc_mode;
	uint8_t  method;
} __attribute__((packed));

struct sinfonia_printcmd18_hdr {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  jobid;
	uint16_t copies;
	uint16_t columns;
	uint16_t rows;
	uint16_t columns2;
	uint16_t rows2;
	uint8_t  reserved[4]; // then nulls
	uint8_t  oc_mode;
	uint8_t  method;
	uint8_t  media; // reserved?
} __attribute__((packed));

struct sinfonia_printcmd28_hdr {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  jobid;
	uint16_t copies;
	uint16_t columns;
	uint16_t rows;
	uint8_t  media;
	uint8_t  reserved[7];
	uint8_t  options;
	uint8_t  method;
	uint8_t  reserved2[11];
} __attribute__((packed));

struct kodak701x_backprint {
	struct sinfonia_cmd_hdr hdr;
	uint8_t unk_0;  // unknown.  maybe the line number?
	uint8_t null[6]; // always zero.
	uint8_t unk_1;  // length of text?  (max 40)
	uint8_t text[42]; //
} __attribute__((packed));

struct kodak8810_cutlist {
	struct sinfonia_cmd_hdr hdr;
	uint8_t  entries; /* max 24 */
	uint16_t cut[36]; /* LE, row number to cut at. Deltas must be >= 12. */
} __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_8x12K   0x02  /* Kodak 8810 */


#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
#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 // 6145

#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?
#define SINFONIA_CMD_SETPARAM   0x4007 // !2145

#define SINFONIA_CMD_SETLAMSTR  0x4008 // EK70xx, EK8810? (len 28)
#define SINFONIA_CMD_COMMPPA    0x4009 // EK70xx
#define SINFONIA_CMD_SETCUTLIST 0x4009 // EK8810 (len 73, count + 36 entries, 16bit LE)
#define SINFONIA_CMD_SETPPAPARM 0x400A // EK70xx
#define SINFONIA_CMD_WAKEUPSDBY 0x400A // EK8810 (len 1)
#define SINFONIA_CMD_BACKPRINT  0x400B // EK701x only! (len 50)
#define SINFONIA_CMD_UNKNOWN4C  0x400C // EK8810, panorama setup?

#define SINFONIA_CMD_GETCORR    0x400D // 6145/2245
#define SINFONIA_CMD_GETEEPROM  0x400E // 6x45
#define SINFONIA_CMD_SETEEPROM  0x400F // 6x45

#define SINFONIA_CMD_SETTIME    0x4011 // 6245

#define SINFONIA_CMD_UNIVERSAL  0x4080 // EK70xx

#define SINFONIA_CMD_USBFWDL    0x8001 // EK70xx (len 5)
#define SINFONIA_CMD_MAINTPERM  0x8002 // EK70xx
#define SINFONIA_CMD_GETUNIQUE  0x8003 // 2145

#define SINFONIA_CMD_SELFDIAG   0xC001 // (len 3)
#define SINFONIA_CMD_DIAGRES    0xC002
#define SINFONIA_CMD_FWINFO     0xC003
#define SINFONIA_CMD_UPDATE     0xC004
#define SINFONIA_CMD_GETEEPROM2 0xC005 // EK70xx
#define SINFONIA_CMD_SETEEPROM2 0xC006 // EK70xx
#define SINFONIA_CMD_SETUNIQUE  0xC007 // 2145
#define SINFONIA_CMD_RESETERR   0xC008
#define SINFONIA_CMD_GETSERIAL2 0xC009 // EK70xx (len 8)

const char *sinfonia_cmd_names(uint16_t v);

#define KODAK6_MEDIA_5R   0xff //XX 189-9160
#define KODAK6_MEDIA_6R   0x0b // 197-4096  [ Also: 101-0867, 141-9597, 659-9054, 169-6418, DNP-900-060 ]
#define KODAK6_MEDIA_UNK  0x03 // ??? reported but unknown
#define KODAK6_MEDIA_6TR2 0x2c // 396-2941
//#define KODAK6_MEDIA_5FR2    // 6900-compatible
//#define KODAK6_MEDIA_6FR2    // 6900-compatible, 102-5925
#define KODAK6_MEDIA_NONE 0x00
#define KODAK7_MEDIA_5R   0xfe //XX 164-9011 137-0600
#define KODAK7_MEDIA_6R   0x29 // 659-9047 166-1925 396-2966 846-2004 103-7688 DNP-900-070 -- ALSO FUJI R68-D2P570 16578944
//#define KODAK7_MEDIA_6TA2
//#define KODAK7_MEDIA_5TA2

int kodak6_mediamax(int type);
const char *kodak6_mediatypes(int type);
void kodak6_dumpmediacommon(int type);

#define RESULT_SUCCESS 0x01
#define RESULT_FAIL    0x02

/* ********** Below are for the old S1145 (EK68xx) and S1245 only! */

enum {
	TONE_TABLE_STANDARD = 0,
	TONE_TABLE_USER = 1,
	TONE_TABLE_CURRENT = 2,
};
enum {
	PARAM_TABLE_NONE = 0,
	PARAM_TABLE_STANDARD = 1,
	PARAM_TABLE_FINE = 2,
};

enum {
	CMD_CODE_OK = 1,
	CMD_CODE_BAD = 2,
};

enum {
        STATUS_PRINTING = 1,
        STATUS_IDLE = 2,
};

enum {
        STATE_STATUS1_STANDBY = 1,
        STATE_STATUS1_ERROR = 2,
        STATE_STATUS1_WAIT = 3,
};

#define STATE_STANDBY_STATUS2 0x0

enum {
        WAIT_STATUS2_INIT = 0,
        WAIT_STATUS2_RIBBON = 1,
        WAIT_STATUS2_THERMAL = 2,
        WAIT_STATUS2_OPERATING = 3,
        WAIT_STATUS2_BUSY = 4,
};

#define ERROR_STATUS2_CTRL_CIRCUIT   (0x80000000)
#define ERROR_STATUS2_MECHANISM_CTRL (0x40000000)
#define ERROR_STATUS2_SENSOR         (0x00002000)
#define ERROR_STATUS2_COVER_OPEN     (0x00001000)
#define ERROR_STATUS2_TEMP_SENSOR    (0x00000200)
#define ERROR_STATUS2_PAPER_JAM      (0x00000100)
#define ERROR_STATUS2_PAPER_EMPTY    (0x00000040)
#define ERROR_STATUS2_RIBBON_ERR     (0x00000010)

enum {
        CTRL_CIR_ERROR_EEPROM1  = 0x01,
        CTRL_CIR_ERROR_EEPROM2  = 0x02,
        CTRL_CIR_ERROR_DSP      = 0x04,
        CTRL_CIR_ERROR_CRC_MAIN = 0x06,
        CTRL_CIR_ERROR_DL_MAIN  = 0x07,
        CTRL_CIR_ERROR_CRC_DSP  = 0x08,
        CTRL_CIR_ERROR_DL_DSP   = 0x09,
        CTRL_CIR_ERROR_ASIC     = 0x0a,
        CTRL_CIR_ERROR_DRAM     = 0x0b,
        CTRL_CIR_ERROR_DSPCOMM  = 0x29,
};

enum {
        MECH_ERROR_HEAD_UP            = 0x01,
        MECH_ERROR_HEAD_DOWN          = 0x02,
        MECH_ERROR_MAIN_PINCH_UP      = 0x03,
        MECH_ERROR_MAIN_PINCH_DOWN    = 0x04,
        MECH_ERROR_SUB_PINCH_UP       = 0x05,
        MECH_ERROR_SUB_PINCH_DOWN     = 0x06,
        MECH_ERROR_FEEDIN_PINCH_UP    = 0x07,
        MECH_ERROR_FEEDIN_PINCH_DOWN  = 0x08,
        MECH_ERROR_FEEDOUT_PINCH_UP   = 0x09,
        MECH_ERROR_FEEDOUT_PINCH_DOWN = 0x0a,
        MECH_ERROR_CUTTER_LR          = 0x0b,
        MECH_ERROR_CUTTER_RL          = 0x0c,
};

enum {
        SENSOR_ERROR_CUTTER           = 0x05,
        SENSOR_ERROR_HEAD_DOWN        = 0x09,
        SENSOR_ERROR_HEAD_UP          = 0x0a,
        SENSOR_ERROR_MAIN_PINCH_DOWN  = 0x0b,
        SENSOR_ERROR_MAIN_PINCH_UP    = 0x0c,
        SENSOR_ERROR_FEED_PINCH_DOWN  = 0x0d,
        SENSOR_ERROR_FEED_PINCH_UP    = 0x0e,
        SENSOR_ERROR_EXIT_PINCH_DOWN  = 0x0f,
        SENSOR_ERROR_EXIT_PINCH_UP    = 0x10,
        SENSOR_ERROR_LEFT_CUTTER      = 0x11,
        SENSOR_ERROR_RIGHT_CUTTER     = 0x12,
        SENSOR_ERROR_CENTER_CUTTER    = 0x13,
        SENSOR_ERROR_UPPER_CUTTER     = 0x14,
        SENSOR_ERROR_PAPER_FEED_COVER = 0x15,
};

enum {
        TEMP_SENSOR_ERROR_HEAD_HIGH = 0x01,
        TEMP_SENSOR_ERROR_HEAD_LOW  = 0x02,
        TEMP_SENSOR_ERROR_ENV_HIGH  = 0x03,
        TEMP_SENSOR_ERROR_ENV_LOW   = 0x04,
};

enum {
        COVER_OPEN_ERROR_UPPER = 0x01,
        COVER_OPEN_ERROR_LOWER = 0x02,
};

enum {
        PAPER_EMPTY_ERROR = 0x00,
};

enum {
        RIBBON_ERROR = 0x00,
};

enum {
        CURVE_TABLE_STATUS_INITIAL = 0x00,
        CURVE_TABLE_STATUS_USERSET = 0x01,
        CURVE_TABLE_STATUS_CURRENT = 0x02,
};

const char *sinfonia_1x45_status_str(uint8_t status1, uint32_t status2, uint8_t error);