selphy_print/backend_sonyupdr150.c

/*
 *   Sony UP-DR150 Photo Printer CUPS backend -- libusb-1.0 version
 *
 *   (c) 2013-2018 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+
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>

#define BACKEND updr150_backend

#include "backend_common.h"

/* Printer status
  --> 1b e0 00 00 00 00 XX 00   [[ XX is 0xe on UPD895, 0xf on others ]]
  <-- this struct
*/
struct sony_updsts {
	uint8_t  hdr[2];   /* 0x0d 0x00 */
	uint8_t  printing; /* 0xe0 if printing, 0x00 otherwise */
	uint8_t  remain;   /* Number of remaining pages */
	uint8_t  zero1;
	uint8_t  sts1;     /* primary status */
	uint8_t  sts2;     /* seconday status */
	uint8_t  sts3;     /* tertiary status */
	uint8_t  zero2[2];
	uint16_t max_cols; /* BE */
	uint16_t max_rows; /* BE */
	uint8_t  percent;  /* 0-99, if job is printing */
} __attribute__((packed));

/* Private data structures */
struct updr150_printjob {
	uint8_t *databuf;
	int datalen;

	int copies;
	uint16_t rows;
	uint16_t cols;
	uint32_t imglen;
};

struct updr150_ctx {
	struct libusb_device_handle *dev;
	uint8_t endp_up;
	uint8_t endp_down;
	int type;

	int native_bpp;

	struct sony_updsts stsbuf;

	struct marker marker;
};

/* Now for the code */
static void* updr150_init(void)
{
	struct updr150_ctx *ctx = malloc(sizeof(struct updr150_ctx));
	if (!ctx) {
		ERROR("Memory Allocation Failure!");
		return NULL;
	}
	memset(ctx, 0, sizeof(struct updr150_ctx));
	return ctx;
}

static int updr150_attach(void *vctx, struct libusb_device_handle *dev, int type,
			  uint8_t endp_up, uint8_t endp_down, uint8_t jobid)
{
	struct updr150_ctx *ctx = vctx;

	UNUSED(jobid);

	ctx->dev = dev;
	ctx->endp_up = endp_up;
	ctx->endp_down = endp_down;
	ctx->type = type;

	if (ctx->type == P_SONY_UPD895 || ctx->type == P_SONY_UPD897) {
		ctx->marker.color = "#000000";  /* Ie black! */
		ctx->native_bpp = 1;
	} else {
		ctx->marker.color = "#00FFFF#FF00FF#FFFF00";
		ctx->native_bpp = 3;
	}

	ctx->marker.name = "Unknown";
	ctx->marker.levelmax = -1;
	ctx->marker.levelnow = -2;

	return CUPS_BACKEND_OK;
}

static void updr150_cleanup_job(const void *vjob)
{
	const struct updr150_printjob *job = vjob;

	if (job->databuf)
		free(job->databuf);

	free((void*)job);
}

static void updr150_teardown(void *vctx) {
	struct updr150_ctx *ctx = vctx;

	if (!ctx)
		return;

	free(ctx);
}

static char* upd895_statuses(uint8_t code)
{
	switch (code) {
	case 0x00:
		return "Idle";
	case 0x08:
		return "Door open";
	case 0x40:
		return "No paper";
	case 0x80:
		return "Idle";
	default:
		return "Unknown";
	}
}

static int sony_get_status(struct updr150_ctx *ctx, struct sony_updsts *buf)
{
	int ret, num = 0;
	uint8_t query[7] = { 0x1b, 0xe0, 0, 0, 0, 0x0e, 0 };

	if (ctx->type != P_SONY_UPD895)
		query[5] = 0x0f;

	if ((ret = send_data(ctx->dev, ctx->endp_down,
			     query, sizeof(query))))
		return CUPS_BACKEND_FAILED;

	ret = read_data(ctx->dev, ctx->endp_up, (uint8_t*) buf, sizeof(*buf),
			&num);

	if (ret < 0)
		return CUPS_BACKEND_FAILED;
#if 0
	if (ctx->type == P_SONY_UPD895 && ret != 14)
		return CUPS_BACKEND_FAILED;
	else if (ret != 15)
		return CUPS_BACKEND_FAILED;
#endif

	return CUPS_BACKEND_OK;
}

#define MAX_PRINTJOB_LEN (2048*2764*3 + 2048)

static int updr150_read_parse(void *vctx, const void **vjob, int data_fd, int copies) {
	struct updr150_ctx *ctx = vctx;
	int len, run = 1;
	uint32_t copies_offset = 0;

	struct updr150_printjob *job = NULL;

	if (!ctx)
		return CUPS_BACKEND_FAILED;

	job = malloc(sizeof(*job));
	if (!job) {
		ERROR("Memory allocation failure!\n");
		return CUPS_BACKEND_RETRY_CURRENT;
	}
	memset(job, 0, sizeof(*job));
	job->copies = copies;

	job->datalen = 0;
	job->databuf = malloc(MAX_PRINTJOB_LEN);
	if (!job->databuf) {
		ERROR("Memory allocation failure!\n");
		updr150_cleanup_job(job);
		return CUPS_BACKEND_RETRY_CURRENT;
	}

	while(run) {
		int i;
		int keep = 0;
		i = read(data_fd, job->databuf + job->datalen, 4);
		if (i < 0) {
			updr150_cleanup_job(job);
			return CUPS_BACKEND_CANCEL;
		}
		if (i == 0)
			break;

		memcpy(&len, job->databuf + job->datalen, sizeof(len));
		len = le32_to_cpu(len);

		/* Filter out chunks we don't send to the printer */
		if (len & 0xf0000000) {
			switch (len) {
			case 0xfffffff3:
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 0);
				len = 0;
				if (ctx->type == P_SONY_UPDR150)
					run = 0;
				break;
			case 0xfffffff7:
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 0);
				len = 0;
				if (ctx->type == P_SONY_UPCR10)
					run = 0;
				break;
			case 0xfffffff8: // 895
			case 0xfffffff4: // 897
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 0);
				len = 0;
				if (ctx->type == P_SONY_UPD895 || ctx->type == P_SONY_UPD897)
					run = 0;
				break;
			case 0xffffff97:
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 12);
				len = 12;
				break;
			case 0xffffffef:
				if (ctx->type == P_SONY_UPD895 || ctx->type == P_SONY_UPD897) {
					if(dyesub_debug)
						DEBUG("Block ID '%08x' (len %d)\n", len, 0);
					len = 0;
					break;
				}
				/* Intentional Fallthrough */
			case 0xffffffeb:
			case 0xffffffee:
			case 0xfffffff5:
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 4);
				len = 4;
				break;
			default:
				if(dyesub_debug)
					DEBUG("Block ID '%08x' (len %d)\n", len, 0);
				len = 0;
				break;
			}
		} else {
			/* Only keep these chunks */
			if(dyesub_debug)
				DEBUG("Data block (len %d)\n", len);
			if (len > 0)
				keep = 1;
		}
		if (keep)
			job->datalen += sizeof(uint32_t);

		/* Read in the data chunk */
		while(len > 0) {
			i = read(data_fd, job->databuf + job->datalen, len);
			if (i < 0) {
				updr150_cleanup_job(job);
				return CUPS_BACKEND_CANCEL;
			}
			if (i == 0)
				break;

			/* Work out offset of copies command */
			if (job->databuf[job->datalen] == 0x1b) {
				switch (job->databuf[job->datalen + 1]) {
				case 0xee:
					if (i == 7)
						copies_offset = job->datalen + 11;
					else
						copies_offset = job->datalen + 7;
					break;
				case 0xe1:
					memcpy(&job->cols, job->databuf + job->datalen + 14, sizeof(uint16_t));
					memcpy(&job->rows, job->databuf + job->datalen + 16, sizeof(uint16_t));
					job->cols = be16_to_cpu(job->cols);
					job->rows = be16_to_cpu(job->rows);
					break;
				case 0xea:
					memcpy(&job->imglen, job->databuf + job->datalen + 6, sizeof(uint32_t));
					job->imglen = be32_to_cpu(job->imglen);
					break;
				default:
					break;
				}
			}

			if (keep)
				job->datalen += i;
			len -= i;
		}
	}
	if (!job->datalen) {
		updr150_cleanup_job(job);
		return CUPS_BACKEND_CANCEL;
	}

	/* Some models specify copies in the print job */
	if (copies_offset) {
		uint16_t tmp = copies;
		tmp = cpu_to_be16(copies);
		memcpy(job->databuf + copies_offset, &tmp, sizeof(tmp));
		job->copies = 1;
	}

	*vjob = job;

	return CUPS_BACKEND_OK;
}

static int updr150_main_loop(void *vctx, const void *vjob) {
	struct updr150_ctx *ctx = vctx;
	int i, ret;
	int copies;

	const struct updr150_printjob *job = vjob;

	if (!ctx)
		return CUPS_BACKEND_FAILED;
	if (!job)
		return CUPS_BACKEND_FAILED;

	copies = job->copies;

top:
	/* Send Unknown CMD.  Resets? */
	if (ctx->type == P_SONY_UPD897) {
		const uint8_t cmdbuf[7] = { 0x1b, 0x1f, 0, 0, 0, 0, 0 };
		ret = send_data(ctx->dev, ctx->endp_down,
				cmdbuf, sizeof(cmdbuf));
		if (ret)
			return CUPS_BACKEND_FAILED;
	}

	/* Query printer status */
	ret = sony_get_status(ctx, &ctx->stsbuf);

	if (ret)
		return CUPS_BACKEND_FAILED;

	/* Sanity check job parameters */
	if (job->rows > ctx->stsbuf.max_rows ||
	    job->cols > ctx->stsbuf.max_cols) {
		ERROR("Job dimensions (%u/%u) exceed printer max (%u/%u)\n",
		      job->cols, job->rows,
		      ctx->stsbuf.max_cols,
		      ctx->stsbuf.max_rows);
		return CUPS_BACKEND_CANCEL;
	}
	if (job->imglen != (uint32_t)(job->rows * job->cols * ctx->native_bpp))
	{
		ERROR("Job data length mismatch!\n");
		return CUPS_BACKEND_CANCEL;
	}

	/* Check for idle */
	if (ctx->stsbuf.sts1 != 0x00) {
		if (ctx->stsbuf.sts1 == 0x80) {
			INFO("Waiting for printer idle...\n");
			sleep(1);
			goto top;
		}
	}

	/* Send RESET */
	if (ctx->type != P_SONY_UPD895) {
		const uint8_t rstbuf[7] = { 0x1b, 0x16, 0, 0, 0, 0, 0 };
		ret = send_data(ctx->dev, ctx->endp_down,
				rstbuf, sizeof(rstbuf));
		if (ret)
			return CUPS_BACKEND_FAILED;
	}

#if 0 /* Unknown query */
	if (ctx->type == P_SONY_UPD897) {
		// -> 1b e6 00 00 00 08 00
		// <- ???
	}
#endif

	/* Send over job */
	i = 0;
	while (i < job->datalen) {
		uint32_t len;
		memcpy(&len, job->databuf + i, sizeof(len));
		len = le32_to_cpu(len);

		i += sizeof(uint32_t);

		if ((ret = send_data(ctx->dev, ctx->endp_down,
				     job->databuf + i, len)))
			return CUPS_BACKEND_FAILED;

		i += len;
	}

	// XXX generate and send copy cmd instead of using the offset.
	// 1b ee 00 00 00 02 00  NN NN  (BE)

	/* Check for idle, if appropriate */
	if (ctx->type == P_SONY_UPD895 || ctx->type == P_SONY_UPD897) {
	retry:
		sleep(1);

		ret = sony_get_status(ctx, &ctx->stsbuf);
		if (ret)
			return ret;

		switch (ctx->stsbuf.sts1) {
		case 0x00:
			goto done;
		case 0x80:
			break;
		default:
			ERROR("Printer error: %s (%02x)\n", upd895_statuses(ctx->stsbuf.sts1),
			      ctx->stsbuf.sts1);
			return CUPS_BACKEND_STOP;
		}

		if (fast_return && ctx->stsbuf.printing > 0) {
			INFO("Fast return mode enabled.\n");
		} else {
			goto retry;
		}
	}

	/* Clean up */
	if (terminate)
		copies = 1;

done:
	INFO("Print complete (%d copies remaining)\n", copies - 1);

	if (copies && --copies) {
		goto top;
	}

	return CUPS_BACKEND_OK;
}

static int upd895_dump_status(struct updr150_ctx *ctx)
{
	int ret = sony_get_status(ctx, &ctx->stsbuf);
	if (ret < 0)
		return CUPS_BACKEND_FAILED;

	ctx->stsbuf.max_cols = be16_to_cpu(ctx->stsbuf.max_cols);
	ctx->stsbuf.max_rows = be16_to_cpu(ctx->stsbuf.max_rows);

	INFO("Printer status: %s (%02x)\n", upd895_statuses(ctx->stsbuf.sts1), ctx->stsbuf.sts1);
	if (ctx->stsbuf.printing == 0x0e0 && ctx->stsbuf.sts1 == 0x80)
		INFO("Remaining copies: %d\n", ctx->stsbuf.remain);

	return CUPS_BACKEND_OK;
}


static void updr150_cmdline(void)
{
	DEBUG("\t\t[ -s ]           # Query printer status (only UP-D895)\n");
}

static int updr150_cmdline_arg(void *vctx, int argc, char **argv)
{
	struct updr150_ctx *ctx = vctx;
	int i, j = 0;

	if (!ctx)
		return -1;

	while ((i = getopt(argc, argv, GETOPT_LIST_GLOBAL "s")) >= 0) {
		switch(i) {
		GETOPT_PROCESS_GLOBAL
		case 's':
			if (ctx->type == P_SONY_UPD895 ||
			    ctx->type == P_SONY_UPD897)
				j = upd895_dump_status(ctx);
			break;
		}

		if (j) return j;
	}

	return 0;
}

static int updr150_query_markers(void *vctx, struct marker **markers, int *count)
{
	struct updr150_ctx *ctx = vctx;

	*markers = &ctx->marker;
	*count = 1;

	if (ctx->type == P_SONY_UPD895 ||
	    ctx->type == P_SONY_UPD897) {
		int ret = sony_get_status(ctx, &ctx->stsbuf);

		if (ret)
			return CUPS_BACKEND_FAILED;

		if (ctx->stsbuf.sts1 == 0x40 ||
		    ctx->stsbuf.sts1 == 0x08) {
			ctx->marker.levelnow = 0;
			STATE("+media-empty");
		} else {
			ctx->marker.levelnow = -3;
			STATE("-media-empty");
		}
	}



	return CUPS_BACKEND_OK;
}

static const char *sonyupdr150_prefixes[] = {
	"sonyupdr150",  // Family name.
	"sony-updr150", "sony-updr200", "sony-upcr10l",
	// Backwards compatibility
	"sonyupdr200", "sonyupcr10",
	"sony-upd895", "sony-upd897",
//	"sony-upd898",
	NULL
};

/* Exported */
#define USB_VID_SONY         0x054C
#define USB_PID_SONY_UPDR150 0x01E8
#define USB_PID_SONY_UPDR200 0x035F
#define USB_PID_SONY_UPCR10  0x0226
#define USB_PID_SONY_UPD895  0x0049
#define USB_PID_SONY_UPD897  0x01E7
//#define USB_PID_SONY_UPD898 XXXXX // 0x589a?

struct dyesub_backend updr150_backend = {
	.name = "Sony UP-DR150/UP-DR200/UP-CR10/UP-D895/UP-D897",
	.version = "0.32",
	.uri_prefixes = sonyupdr150_prefixes,
	.cmdline_arg = updr150_cmdline_arg,
	.cmdline_usage = updr150_cmdline,
	.init = updr150_init,
	.attach = updr150_attach,
	.teardown = updr150_teardown,
	.cleanup_job = updr150_cleanup_job,
	.read_parse = updr150_read_parse,
	.main_loop = updr150_main_loop,
	.query_markers = updr150_query_markers,
	.devices = {
		{ USB_VID_SONY, USB_PID_SONY_UPDR150, P_SONY_UPDR150, NULL, "sony-updr150"},
		{ USB_VID_SONY, USB_PID_SONY_UPDR200, P_SONY_UPDR150, NULL, "sony-updr200"},
		{ USB_VID_SONY, USB_PID_SONY_UPCR10, P_SONY_UPCR10, NULL, "sony-upcr10l"},
		{ USB_VID_SONY, USB_PID_SONY_UPD895, P_SONY_UPD895, NULL, "sonyupd895"},
		{ USB_VID_SONY, USB_PID_SONY_UPD897, P_SONY_UPD897, NULL, "sony-upd897"},
//		{ USB_VID_SONY, USB_PID_SONY_UPD898MD, P_SONY_UPD89x, NULL, "sonyupd898"},
		{ 0, 0, 0, NULL, NULL}
	}
};

/* Sony spool file format

   The spool file is a series of 4-byte commands, followed by optional
   arguments.  The purpose of the commands is unknown, but they presumably
   instruct the driver to perform certain things.

   If you treat these 4 bytes as a 32-bit little-endian number, if any of the
   least significant 4 bits are non-zero, the value is is to
   be interpreted as a driver command.  If the most significant bits are
   zero, the value signifies that the following N bytes of data should be
   sent to the printer as-is.

   Known driver "commands":

    97 ff ff ff
    eb ff ff ff  ?? 00 00 00
    ec ff ff ff  ?? 00 00 00
    ed ff ff ff  ?? 00 00 00
    ee ff ff ff  ?? 00 00 00
    ef ff ff ff  XX 00 00 00   # XX == print size (0x01/0x02/0x03/0x04)
    ef ff ff ff                # On UP-D895/897
    f3 ff ff ff
    f4 ff ff ff                # End of job on UP-D897
    f5 ff ff ff  YY 00 00 00   # YY == ??? (seen 0x01)
    f7 ff ff ff                # End of job on UP-D895

   All printer commands start with 0x1b, and are at least 7 bytes long.
   General Command format:

    1b XX ?? ?? ?? LL 00       # XX is cmd, LL is data or response length.

   UNKNOWN QUERY

 <- 1b 03 00 00 00 13 00
 -> 70 00 00 00 00 00 00 0b  00 00 00 00 00 00 00 00
    00 00 00

   UNKNOWN CMD (UP-DR & SL)

 <- 1b 0a 00 00 00 00 00

   PRINT DIMENSIONS

 <- 1b 15 00 00 00 0d 00
 <- 00 00 00 00 ZZ QQ QQ WW  WW YY YY XX XX

    QQ/WW/YY/XX are (origin_cols/origin_rows/cols/rows) in BE.
    ZZ is 0x07 on UP-DR series, 0x01 on UP-D89x series.

   RESET

 <- 1b 16 00 00 00 00 00

   UNKNOWN CMD (UP-DR & SL)

 <- 1b 17 00 00 00 00 00

   UNKNOWN CMD (UP-D897)

 <- 1b 1f 00 00 00 00 00

   SET PARAM

 <- 1b c0 00 NN LL 00 00    # LL is response length, NN is number.
 <- [ NN bytes]

   QUERY PARAM

 <- 1b c1 00 NN LL 00 00    # LL is response length, NN is number.
 -> [ NN bytes ]

      PARAMS SEEN:

    02, len 06   [ 02 02 00 03 00 00 ]
    01, len 10   [ 02 01 00 06 00 02 00 00 00 00 ]    (UP-D897)
    00, len 5    [ 02 01 00 01 XX ]                   XX == Gamma table

   STATUS QUERY

 <- 1b e0 00 00 00 XX 00       # XX = 0xe (UP-D895), 0xf (All others)
 -> [14 or 15 bytes]

   PRINT DIMENSIONS  [[ May actually be PRINT START command ]]

 <- 1b e1 00 00 00 0b 00
 <- 00 80 00 00 00 00 00 XX XX YY YY  # XX = cols, YY == rows

   UNKNOWN

 <- 1b e5 00 00 00 08 00
 <- 00 00 00 00 00 00 00 XX  00  #  XX = 0 on UP-D89x & SL, 1 on up-dr series.

   UNKNOWN  (UP-D897)

 <- 1b e6 00 00 00 08 00
 <- 07 00 00 00 00 00 00 00

   DATA TRANSFER

 <- 1b ea 00 00 00 00 ZZ ZZ ZZ ZZ 00  # ZZ is BIG ENDIAN
 <- [ ZZ ZZ ZZ ZZ bytes of data ]

   UNKNOWN  (UPDR series)

 <- 1b ef 00 00 00 06 00
 -> 05 00 00 00 00 22

   COPIES

 <- 1b ee 00 00 00 02 00
 <- NN NN                        # Number of copies (BE, 1-???)


  ****************************************************************