[J-u-boot.git] / tools / kwboot.c

/*
 * Boot a Marvell SoC, with Xmodem over UART0.
 *  supports Kirkwood, Dove, Armada 370, Armada XP
 *
 * (c) 2012 Daniel Stodden <[email protected]>
 *
 * References: marvell.com, "88F6180, 88F6190, 88F6192, and 88F6281
 *   Integrated Controller: Functional Specifications" December 2,
 *   2008. Chapter 24.2 "BootROM Firmware".
 */

#include "kwbimage.h"
#include "mkimage.h"
#include "version.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <image.h>
#include <libgen.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdint.h>
#include <termios.h>
#include <sys/mman.h>
#include <sys/stat.h>

/*
 * Marvell BootROM UART Sensing
 */

static unsigned char kwboot_msg_boot[] = {
	0xBB, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
};

static unsigned char kwboot_msg_debug[] = {
	0xDD, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
};

/* Defines known to work on Kirkwood */
#define KWBOOT_MSG_REQ_DELAY	10 /* ms */
#define KWBOOT_MSG_RSP_TIMEO	50 /* ms */

/* Defines known to work on Armada XP */
#define KWBOOT_MSG_REQ_DELAY_AXP	1000 /* ms */
#define KWBOOT_MSG_RSP_TIMEO_AXP	1000 /* ms */

/*
 * Xmodem Transfers
 */

#define SOH	1	/* sender start of block header */
#define EOT	4	/* sender end of block transfer */
#define ACK	6	/* target block ack */
#define NAK	21	/* target block negative ack */
#define CAN	24	/* target/sender transfer cancellation */

#define KWBOOT_XM_BLKSZ	128 /* xmodem block size */

struct kwboot_block {
	uint8_t soh;
	uint8_t pnum;
	uint8_t _pnum;
	uint8_t data[KWBOOT_XM_BLKSZ];
	uint8_t csum;
} __packed;

#define KWBOOT_BLK_RSP_TIMEO 1000 /* ms */

static int kwboot_verbose;

static int msg_req_delay = KWBOOT_MSG_REQ_DELAY;
static int msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO;
static int blk_rsp_timeo = KWBOOT_BLK_RSP_TIMEO;

static ssize_t
kwboot_write(int fd, const char *buf, size_t len)
{
	size_t tot = 0;

	while (tot < len) {
		ssize_t wr = write(fd, buf + tot, len - tot);

		if (wr < 0)
			return -1;

		tot += wr;
	}

	return tot;
}

static void
kwboot_printv(const char *fmt, ...)
{
	va_list ap;

	if (kwboot_verbose) {
		va_start(ap, fmt);
		vprintf(fmt, ap);
		va_end(ap);
		fflush(stdout);
	}
}

static void
__spinner(void)
{
	const char seq[] = { '-', '\\', '|', '/' };
	const int div = 8;
	static int state, bs;

	if (state % div == 0) {
		fputc(bs, stdout);
		fputc(seq[state / div % sizeof(seq)], stdout);
		fflush(stdout);
	}

	bs = '\b';
	state++;
}

static void
kwboot_spinner(void)
{
	if (kwboot_verbose)
		__spinner();
}

static void
__progress(int pct, char c)
{
	const int width = 70;
	static const char *nl = "";
	static int pos;

	if (pos % width == 0)
		printf("%s%3d %% [", nl, pct);

	fputc(c, stdout);

	nl = "]\n";
	pos = (pos + 1) % width;

	if (pct == 100) {
		while (pos && pos++ < width)
			fputc(' ', stdout);
		fputs(nl, stdout);
		nl = "";
		pos = 0;
	}

	fflush(stdout);

}

static void
kwboot_progress(int _pct, char c)
{
	static int pct;

	if (_pct != -1)
		pct = _pct;

	if (kwboot_verbose)
		__progress(pct, c);

	if (pct == 100)
		pct = 0;
}

static int
kwboot_tty_recv(int fd, void *buf, size_t len, int timeo)
{
	int rc, nfds;
	fd_set rfds;
	struct timeval tv;
	ssize_t n;

	rc = -1;

	FD_ZERO(&rfds);
	FD_SET(fd, &rfds);

	tv.tv_sec = 0;
	tv.tv_usec = timeo * 1000;
	if (tv.tv_usec > 1000000) {
		tv.tv_sec += tv.tv_usec / 1000000;
		tv.tv_usec %= 1000000;
	}

	do {
		nfds = select(fd + 1, &rfds, NULL, NULL, &tv);
		if (nfds < 0)
			goto out;
		if (!nfds) {
			errno = ETIMEDOUT;
			goto out;
		}

		n = read(fd, buf, len);
		if (n <= 0)
			goto out;

		buf = (char *)buf + n;
		len -= n;
	} while (len > 0);

	rc = 0;
out:
	return rc;
}

static int
kwboot_tty_send(int fd, const void *buf, size_t len)
{
	if (!buf)
		return 0;

	if (kwboot_write(fd, buf, len) < 0)
		return -1;

	return tcdrain(fd);
}

static int
kwboot_tty_send_char(int fd, unsigned char c)
{
	return kwboot_tty_send(fd, &c, 1);
}

static speed_t
kwboot_tty_speed(int baudrate)
{
	switch (baudrate) {
	case 115200:
		return B115200;
	case 57600:
		return B57600;
	case 38400:
		return B38400;
	case 19200:
		return B19200;
	case 9600:
		return B9600;
	}

	return -1;
}

static int
kwboot_open_tty(const char *path, speed_t speed)
{
	int rc, fd;
	struct termios tio;

	rc = -1;

	fd = open(path, O_RDWR|O_NOCTTY|O_NDELAY);
	if (fd < 0)
		goto out;

	memset(&tio, 0, sizeof(tio));

	tio.c_iflag = 0;
	tio.c_cflag = CREAD|CLOCAL|CS8;

	tio.c_cc[VMIN] = 1;
	tio.c_cc[VTIME] = 10;

	cfsetospeed(&tio, speed);
	cfsetispeed(&tio, speed);

	rc = tcsetattr(fd, TCSANOW, &tio);
	if (rc)
		goto out;

	rc = fd;
out:
	if (rc < 0) {
		if (fd >= 0)
			close(fd);
	}

	return rc;
}

static int
kwboot_bootmsg(int tty, void *msg)
{
	int rc;
	char c;
	int count;

	if (msg == NULL)
		kwboot_printv("Please reboot the target into UART boot mode...");
	else
		kwboot_printv("Sending boot message. Please reboot the target...");

	do {
		rc = tcflush(tty, TCIOFLUSH);
		if (rc)
			break;

		for (count = 0; count < 128; count++) {
			rc = kwboot_tty_send(tty, msg, 8);
			if (rc) {
				usleep(msg_req_delay * 1000);
				continue;
			}
		}

		rc = kwboot_tty_recv(tty, &c, 1, msg_rsp_timeo);

		kwboot_spinner();

	} while (rc || c != NAK);

	kwboot_printv("\n");

	return rc;
}

static int
kwboot_debugmsg(int tty, void *msg)
{
	int rc;

	kwboot_printv("Sending debug message. Please reboot the target...");

	do {
		char buf[16];

		rc = tcflush(tty, TCIOFLUSH);
		if (rc)
			break;

		rc = kwboot_tty_send(tty, msg, 8);
		if (rc) {
			usleep(msg_req_delay * 1000);
			continue;
		}

		rc = kwboot_tty_recv(tty, buf, 16, msg_rsp_timeo);

		kwboot_spinner();

	} while (rc);

	kwboot_printv("\n");

	return rc;
}

static size_t
kwboot_xm_makeblock(struct kwboot_block *block, const void *data,
		    size_t size, int pnum)
{
	size_t i, n;

	block->soh = SOH;
	block->pnum = pnum;
	block->_pnum = ~block->pnum;

	n = size < KWBOOT_XM_BLKSZ ? size : KWBOOT_XM_BLKSZ;
	memcpy(&block->data[0], data, n);
	memset(&block->data[n], 0, KWBOOT_XM_BLKSZ - n);

	block->csum = 0;
	for (i = 0; i < n; i++)
		block->csum += block->data[i];

	return n;
}

static int
_is_xm_reply(char c)
{
	return c == ACK || c == NAK || c == CAN;
}

static int
kwboot_xm_sendblock(int fd, struct kwboot_block *block)
{
	int rc, retries;
	char c;

	retries = 16;
	do {
		rc = kwboot_tty_send(fd, block, sizeof(*block));
		if (rc)
			return rc;

		do {
			rc = kwboot_tty_recv(fd, &c, 1, blk_rsp_timeo);
			if (rc) {
				if (errno != ETIMEDOUT)
					return rc;
				c = NAK;
			}

			if (!_is_xm_reply(c))
				printf("%c", c);

		} while (!_is_xm_reply(c));

		if (c != ACK)
			kwboot_progress(-1, '+');

	} while (c == NAK && retries-- > 0);

	rc = -1;

	switch (c) {
	case ACK:
		rc = 0;
		break;
	case NAK:
		errno = EBADMSG;
		break;
	case CAN:
		errno = ECANCELED;
		break;
	default:
		errno = EPROTO;
		break;
	}

	return rc;
}

static int
kwboot_xmodem_one(int tty, int *pnum, int header, const uint8_t *data,
		  size_t size)
{
	size_t sent, left;
	int rc;

	kwboot_printv("Sending boot image %s (%zu bytes)...\n",
		      header ? "header" : "data", size);

	left = size;
	sent = 0;

	while (sent < size) {
		struct kwboot_block block;
		size_t blksz;

		blksz = kwboot_xm_makeblock(&block, data, left, (*pnum)++);
		data += blksz;

		rc = kwboot_xm_sendblock(tty, &block);
		if (rc)
			goto out;

		sent += blksz;
		left -= blksz;

		kwboot_progress(sent * 100 / size, '.');
	}

	kwboot_printv("Done\n");

	return 0;
out:
	kwboot_printv("\n");
	return rc;
}

static int
kwboot_xmodem(int tty, const void *_img, size_t size)
{
	const uint8_t *img = _img;
	int rc, pnum;
	size_t hdrsz;

	if (image_version(img) == 0)
		hdrsz = KWBHEADER_V0_SIZE((struct main_hdr_v0 *)img);
	else
		hdrsz = KWBHEADER_V1_SIZE((struct main_hdr_v1 *)img);

	kwboot_printv("Waiting 2s and flushing tty\n");
	sleep(2); /* flush isn't effective without it */
	tcflush(tty, TCIOFLUSH);

	pnum = 1;

	rc = kwboot_xmodem_one(tty, &pnum, 1, img, hdrsz);
	if (rc)
		return rc;

	img += hdrsz;
	size -= hdrsz;

	rc = kwboot_xmodem_one(tty, &pnum, 0, img, size);
	if (rc)
		return rc;

	return kwboot_tty_send_char(tty, EOT);
}

static int
kwboot_term_pipe(int in, int out, const char *quit, int *s)
{
	ssize_t nin;
	char _buf[128], *buf = _buf;

	nin = read(in, buf, sizeof(_buf));
	if (nin <= 0)
		return -1;

	if (quit) {
		int i;

		for (i = 0; i < nin; i++) {
			if (*buf == quit[*s]) {
				(*s)++;
				if (!quit[*s])
					return 0;
				buf++;
				nin--;
			} else {
				if (kwboot_write(out, quit, *s) < 0)
					return -1;
				*s = 0;
			}
		}
	}

	if (kwboot_write(out, buf, nin) < 0)
		return -1;

	return 0;
}

static int
kwboot_terminal(int tty)
{
	int rc, in, s;
	const char *quit = "\34c";
	struct termios otio, tio;

	rc = -1;

	in = STDIN_FILENO;
	if (isatty(in)) {
		rc = tcgetattr(in, &otio);
		if (!rc) {
			tio = otio;
			cfmakeraw(&tio);
			rc = tcsetattr(in, TCSANOW, &tio);
		}
		if (rc) {
			perror("tcsetattr");
			goto out;
		}

		kwboot_printv("[Type Ctrl-%c + %c to quit]\r\n",
			      quit[0]|0100, quit[1]);
	} else
		in = -1;

	rc = 0;
	s = 0;

	do {
		fd_set rfds;
		int nfds = 0;

		FD_SET(tty, &rfds);
		nfds = nfds < tty ? tty : nfds;

		if (in >= 0) {
			FD_SET(in, &rfds);
			nfds = nfds < in ? in : nfds;
		}

		nfds = select(nfds + 1, &rfds, NULL, NULL, NULL);
		if (nfds < 0)
			break;

		if (FD_ISSET(tty, &rfds)) {
			rc = kwboot_term_pipe(tty, STDOUT_FILENO, NULL, NULL);
			if (rc)
				break;
		}

		if (in >= 0 && FD_ISSET(in, &rfds)) {
			rc = kwboot_term_pipe(in, tty, quit, &s);
			if (rc)
				break;
		}
	} while (quit[s] != 0);

	if (in >= 0)
		tcsetattr(in, TCSANOW, &otio);
	printf("\n");
out:
	return rc;
}

static void *
kwboot_mmap_image(const char *path, size_t *size, int prot)
{
	int rc, fd, flags;
	struct stat st;
	void *img;

	rc = -1;
	img = NULL;

	fd = open(path, O_RDONLY);
	if (fd < 0)
		goto out;

	rc = fstat(fd, &st);
	if (rc)
		goto out;

	flags = (prot & PROT_WRITE) ? MAP_PRIVATE : MAP_SHARED;

	img = mmap(NULL, st.st_size, prot, flags, fd, 0);
	if (img == MAP_FAILED) {
		img = NULL;
		goto out;
	}

	rc = 0;
	*size = st.st_size;
out:
	if (rc && img) {
		munmap(img, st.st_size);
		img = NULL;
	}
	if (fd >= 0)
		close(fd);

	return img;
}

static uint8_t
kwboot_img_csum8(void *_data, size_t size)
{
	uint8_t *data = _data, csum;

	for (csum = 0; size-- > 0; data++)
		csum += *data;

	return csum;
}

static int
kwboot_img_patch_hdr(void *img, size_t size)
{
	int rc;
	struct main_hdr_v1 *hdr;
	uint8_t csum;
	size_t hdrsz = sizeof(*hdr);
	int image_ver;

	rc = -1;
	hdr = img;

	if (size < hdrsz) {
		errno = EINVAL;
		goto out;
	}

	image_ver = image_version(img);
	if (image_ver != 0 && image_ver != 1) {
		fprintf(stderr, "Invalid image header version\n");
		errno = EINVAL;
		goto out;
	}

	if (image_ver == 0)
		hdrsz = sizeof(*hdr);
	else
		hdrsz = KWBHEADER_V1_SIZE(hdr);

	if (size < hdrsz) {
		errno = EINVAL;
		goto out;
	}

	csum = kwboot_img_csum8(hdr, hdrsz) - hdr->checksum;
	if (csum != hdr->checksum) {
		errno = EINVAL;
		goto out;
	}

	if (hdr->blockid == IBR_HDR_UART_ID) {
		rc = 0;
		goto out;
	}

	hdr->blockid = IBR_HDR_UART_ID;

	if (image_ver == 0) {
		struct main_hdr_v0 *hdr_v0 = img;

		hdr_v0->nandeccmode = IBR_HDR_ECC_DISABLED;
		hdr_v0->nandpagesize = 0;

		hdr_v0->srcaddr = hdr_v0->ext
			? sizeof(struct kwb_header)
			: sizeof(*hdr_v0);
	}

	hdr->checksum = kwboot_img_csum8(hdr, hdrsz) - csum;

	rc = 0;
out:
	return rc;
}

static void
kwboot_usage(FILE *stream, char *progname)
{
	fprintf(stream, "kwboot version %s\n", PLAIN_VERSION);
	fprintf(stream,
		"Usage: %s [OPTIONS] [-b <image> | -D <image> ] [-B <baud> ] <TTY>\n",
		progname);
	fprintf(stream, "\n");
	fprintf(stream,
		"  -b <image>: boot <image> with preamble (Kirkwood, Armada 370/XP)\n");
	fprintf(stream, "  -p: patch <image> to type 0x69 (uart boot)\n");
	fprintf(stream,
		"  -D <image>: boot <image> without preamble (Dove)\n");
	fprintf(stream, "  -d: enter debug mode\n");
	fprintf(stream, "  -a: use timings for Armada XP\n");
	fprintf(stream, "  -q <req-delay>:  use specific request-delay\n");
	fprintf(stream, "  -s <resp-timeo>: use specific response-timeout\n");
	fprintf(stream,
		"  -o <block-timeo>: use specific xmodem block timeout\n");
	fprintf(stream, "\n");
	fprintf(stream, "  -t: mini terminal\n");
	fprintf(stream, "\n");
	fprintf(stream, "  -B <baud>: set baud rate\n");
	fprintf(stream, "\n");
}

int
main(int argc, char **argv)
{
	const char *ttypath, *imgpath;
	int rv, rc, tty, term, prot, patch;
	void *bootmsg;
	void *debugmsg;
	void *img;
	size_t size;
	speed_t speed;

	rv = 1;
	tty = -1;
	bootmsg = NULL;
	debugmsg = NULL;
	imgpath = NULL;
	img = NULL;
	term = 0;
	patch = 0;
	size = 0;
	speed = B115200;

	kwboot_verbose = isatty(STDOUT_FILENO);

	do {
		int c = getopt(argc, argv, "hb:ptaB:dD:q:s:o:");
		if (c < 0)
			break;

		switch (c) {
		case 'b':
			bootmsg = kwboot_msg_boot;
			imgpath = optarg;
			break;

		case 'D':
			bootmsg = NULL;
			imgpath = optarg;
			break;

		case 'd':
			debugmsg = kwboot_msg_debug;
			break;

		case 'p':
			patch = 1;
			break;

		case 't':
			term = 1;
			break;

		case 'a':
			msg_req_delay = KWBOOT_MSG_REQ_DELAY_AXP;
			msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO_AXP;
			break;

		case 'q':
			msg_req_delay = atoi(optarg);
			break;

		case 's':
			msg_rsp_timeo = atoi(optarg);
			break;

		case 'o':
			blk_rsp_timeo = atoi(optarg);
			break;

		case 'B':
			speed = kwboot_tty_speed(atoi(optarg));
			if (speed == -1)
				goto usage;
			break;

		case 'h':
			rv = 0;
		default:
			goto usage;
		}
	} while (1);

	if (!bootmsg && !term && !debugmsg)
		goto usage;

	if (patch && !imgpath)
		goto usage;

	if (argc - optind < 1)
		goto usage;

	ttypath = argv[optind++];

	tty = kwboot_open_tty(ttypath, speed);
	if (tty < 0) {
		perror(ttypath);
		goto out;
	}

	if (imgpath) {
		prot = PROT_READ | (patch ? PROT_WRITE : 0);

		img = kwboot_mmap_image(imgpath, &size, prot);
		if (!img) {
			perror(imgpath);
			goto out;
		}
	}

	if (patch) {
		rc = kwboot_img_patch_hdr(img, size);
		if (rc) {
			fprintf(stderr, "%s: Invalid image.\n", imgpath);
			goto out;
		}
	}

	if (debugmsg) {
		rc = kwboot_debugmsg(tty, debugmsg);
		if (rc) {
			perror("debugmsg");
			goto out;
		}
	} else if (bootmsg) {
		rc = kwboot_bootmsg(tty, bootmsg);
		if (rc) {
			perror("bootmsg");
			goto out;
		}
	}

	if (img) {
		rc = kwboot_xmodem(tty, img, size);
		if (rc) {
			perror("xmodem");
			goto out;
		}
	}

	if (term) {
		rc = kwboot_terminal(tty);
		if (rc && !(errno == EINTR)) {
			perror("terminal");
			goto out;
		}
	}

	rv = 0;
out:
	if (tty >= 0)
		close(tty);

	if (img)
		munmap(img, size);

	return rv;

usage:
	kwboot_usage(rv ? stderr : stdout, basename(argv[0]));
	goto out;
}
Commit	Line	Data
d131ad68	1	/*
84899e2d SR	2	* Boot a Marvell SoC, with Xmodem over UART0.
84899e2d SR	3	* supports Kirkwood, Dove, Armada 370, Armada XP
d131ad68 LP	4	*
	5	* (c) 2012 Daniel Stodden <[email protected]>
	6	*
	7	* References: marvell.com, "88F6180, 88F6190, 88F6192, and 88F6281
	8	* Integrated Controller: Functional Specifications" December 2,
	9	* 2008. Chapter 24.2 "BootROM Firmware".
	10	*/
	11
f4db6c97 SR	12	#include "kwbimage.h"
f4db6c97 SR	13	#include "mkimage.h"
a050a862	14	#include "version.h"
f4db6c97	15
d131ad68 LP	16	#include <stdlib.h>
	17	#include <stdio.h>
	18	#include <string.h>
	19	#include <stdarg.h>
f4db6c97	20	#include <image.h>
d131ad68 LP	21	#include <libgen.h>
	22	#include <fcntl.h>
	23	#include <errno.h>
	24	#include <unistd.h>
	25	#include <stdint.h>
	26	#include <termios.h>
	27	#include <sys/mman.h>
	28	#include <sys/stat.h>
	29
d131ad68 LP	30	/*
	31	* Marvell BootROM UART Sensing
	32	*/
	33
	34	static unsigned char kwboot_msg_boot[] = {
	35	0xBB, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
	36	};
	37
84899e2d SR	38	static unsigned char kwboot_msg_debug[] = {
	39	0xDD, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
	40	};
	41
	42	/* Defines known to work on Kirkwood */
d131ad68 LP	43	#define KWBOOT_MSG_REQ_DELAY 10 /* ms */
	44	#define KWBOOT_MSG_RSP_TIMEO 50 /* ms */
	45
84899e2d SR	46	/* Defines known to work on Armada XP */
	47	#define KWBOOT_MSG_REQ_DELAY_AXP 1000 /* ms */
	48	#define KWBOOT_MSG_RSP_TIMEO_AXP 1000 /* ms */
	49
d131ad68 LP	50	/*
	51	* Xmodem Transfers
	52	*/
	53
	54	#define SOH 1 /* sender start of block header */
	55	#define EOT 4 /* sender end of block transfer */
	56	#define ACK 6 /* target block ack */
	57	#define NAK 21 /* target block negative ack */
	58	#define CAN 24 /* target/sender transfer cancellation */
	59
2ef87f75 T	60	#define KWBOOT_XM_BLKSZ 128 /* xmodem block size */
2ef87f75 T	61
d131ad68 LP	62	struct kwboot_block {
	63	uint8_t soh;
	64	uint8_t pnum;
	65	uint8_t _pnum;
2ef87f75	66	uint8_t data[KWBOOT_XM_BLKSZ];
d131ad68	67	uint8_t csum;
a107c61b	68	} __packed;
d131ad68 LP	69
	70	#define KWBOOT_BLK_RSP_TIMEO 1000 /* ms */
	71
	72	static int kwboot_verbose;
	73
84899e2d SR	74	static int msg_req_delay = KWBOOT_MSG_REQ_DELAY;
84899e2d SR	75	static int msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO;
7497a6a1	76	static int blk_rsp_timeo = KWBOOT_BLK_RSP_TIMEO;
84899e2d	77
e453bb42 MB	78	static ssize_t
	79	kwboot_write(int fd, const char *buf, size_t len)
	80	{
	81	size_t tot = 0;
	82
	83	while (tot < len) {
	84	ssize_t wr = write(fd, buf + tot, len - tot);
	85
	86	if (wr < 0)
	87	return -1;
	88
	89	tot += wr;
	90	}
	91
	92	return tot;
	93	}
	94
d131ad68 LP	95	static void
	96	kwboot_printv(const char *fmt, ...)
	97	{
	98	va_list ap;
	99
	100	if (kwboot_verbose) {
	101	va_start(ap, fmt);
	102	vprintf(fmt, ap);
	103	va_end(ap);
	104	fflush(stdout);
	105	}
	106	}
	107
	108	static void
	109	__spinner(void)
	110	{
	111	const char seq[] = { '-', '\\', '\|', '/' };
	112	const int div = 8;
	113	static int state, bs;
	114
	115	if (state % div == 0) {
	116	fputc(bs, stdout);
	117	fputc(seq[state / div % sizeof(seq)], stdout);
	118	fflush(stdout);
	119	}
	120
	121	bs = '\b';
	122	state++;
	123	}
	124
	125	static void
	126	kwboot_spinner(void)
	127	{
	128	if (kwboot_verbose)
	129	__spinner();
	130	}
	131
	132	static void
	133	__progress(int pct, char c)
	134	{
	135	const int width = 70;
	136	static const char *nl = "";
	137	static int pos;
	138
	139	if (pos % width == 0)
	140	printf("%s%3d %% [", nl, pct);
	141
	142	fputc(c, stdout);
	143
	144	nl = "]\n";
5a1f8cbe	145	pos = (pos + 1) % width;
d131ad68 LP	146
d131ad68 LP	147	if (pct == 100) {
5a1f8cbe	148	while (pos && pos++ < width)
d131ad68 LP	149	fputc(' ', stdout);
d131ad68 LP	150	fputs(nl, stdout);
5a1f8cbe T	151	nl = "";
5a1f8cbe T	152	pos = 0;
d131ad68 LP	153	}
	154
	155	fflush(stdout);
	156
	157	}
	158
	159	static void
	160	kwboot_progress(int _pct, char c)
	161	{
	162	static int pct;
	163
	164	if (_pct != -1)
	165	pct = _pct;
	166
	167	if (kwboot_verbose)
	168	__progress(pct, c);
5a1f8cbe T	169
	170	if (pct == 100)
	171	pct = 0;
d131ad68 LP	172	}
	173
	174	static int
	175	kwboot_tty_recv(int fd, void *buf, size_t len, int timeo)
	176	{
	177	int rc, nfds;
	178	fd_set rfds;
	179	struct timeval tv;
	180	ssize_t n;
	181
	182	rc = -1;
	183
	184	FD_ZERO(&rfds);
	185	FD_SET(fd, &rfds);
	186
	187	tv.tv_sec = 0;
	188	tv.tv_usec = timeo * 1000;
	189	if (tv.tv_usec > 1000000) {
	190	tv.tv_sec += tv.tv_usec / 1000000;
	191	tv.tv_usec %= 1000000;
	192	}
	193
	194	do {
	195	nfds = select(fd + 1, &rfds, NULL, NULL, &tv);
	196	if (nfds < 0)
	197	goto out;
	198	if (!nfds) {
	199	errno = ETIMEDOUT;
	200	goto out;
	201	}
	202
	203	n = read(fd, buf, len);
4469bd7b	204	if (n <= 0)
d131ad68 LP	205	goto out;
	206
	207	buf = (char *)buf + n;
	208	len -= n;
	209	} while (len > 0);
	210
	211	rc = 0;
	212	out:
	213	return rc;
	214	}
	215
	216	static int
	217	kwboot_tty_send(int fd, const void *buf, size_t len)
	218	{
84899e2d SR	219	if (!buf)
	220	return 0;
	221
e453bb42 MB	222	if (kwboot_write(fd, buf, len) < 0)
e453bb42 MB	223	return -1;
d131ad68	224
e453bb42	225	return tcdrain(fd);
d131ad68 LP	226	}
	227
	228	static int
	229	kwboot_tty_send_char(int fd, unsigned char c)
	230	{
	231	return kwboot_tty_send(fd, &c, 1);
	232	}
	233
	234	static speed_t
	235	kwboot_tty_speed(int baudrate)
	236	{
	237	switch (baudrate) {
	238	case 115200:
	239	return B115200;
	240	case 57600:
	241	return B57600;
	242	case 38400:
	243	return B38400;
	244	case 19200:
	245	return B19200;
	246	case 9600:
	247	return B9600;
	248	}
	249
	250	return -1;
	251	}
	252
	253	static int
	254	kwboot_open_tty(const char *path, speed_t speed)
	255	{
	256	int rc, fd;
	257	struct termios tio;
	258
	259	rc = -1;
	260
	261	fd = open(path, O_RDWR\|O_NOCTTY\|O_NDELAY);
	262	if (fd < 0)
	263	goto out;
	264
	265	memset(&tio, 0, sizeof(tio));
	266
	267	tio.c_iflag = 0;
	268	tio.c_cflag = CREAD\|CLOCAL\|CS8;
	269
	270	tio.c_cc[VMIN] = 1;
	271	tio.c_cc[VTIME] = 10;
	272
	273	cfsetospeed(&tio, speed);
	274	cfsetispeed(&tio, speed);
	275
	276	rc = tcsetattr(fd, TCSANOW, &tio);
	277	if (rc)
	278	goto out;
	279
	280	rc = fd;
	281	out:
	282	if (rc < 0) {
	283	if (fd >= 0)
	284	close(fd);
	285	}
	286
	287	return rc;
	288	}
	289
290	static int
291	kwboot_bootmsg(int tty, void *msg)
292	{
293	int rc;
294	char c;
9ca6fae9	295	int count;
d131ad68	296
84899e2d SR	297	if (msg == NULL)
	298	kwboot_printv("Please reboot the target into UART boot mode...");
	299	else
	300	kwboot_printv("Sending boot message. Please reboot the target...");
d131ad68 LP	301
	302	do {
	303	rc = tcflush(tty, TCIOFLUSH);
	304	if (rc)
	305	break;
	306
9ca6fae9 JN	307	for (count = 0; count < 128; count++) {
	308	rc = kwboot_tty_send(tty, msg, 8);
	309	if (rc) {
	310	usleep(msg_req_delay * 1000);
	311	continue;
	312	}
d131ad68 LP	313	}
d131ad68 LP	314
84899e2d	315	rc = kwboot_tty_recv(tty, &c, 1, msg_rsp_timeo);
d131ad68 LP	316
	317	kwboot_spinner();
	318
	319	} while (rc \|\| c != NAK);
	320
	321	kwboot_printv("\n");
	322
	323	return rc;
	324	}
	325
84899e2d SR	326	static int
	327	kwboot_debugmsg(int tty, void *msg)
	328	{
	329	int rc;
	330
	331	kwboot_printv("Sending debug message. Please reboot the target...");
	332
	333	do {
	334	char buf[16];
	335
	336	rc = tcflush(tty, TCIOFLUSH);
	337	if (rc)
	338	break;
	339
	340	rc = kwboot_tty_send(tty, msg, 8);
	341	if (rc) {
	342	usleep(msg_req_delay * 1000);
	343	continue;
	344	}
	345
	346	rc = kwboot_tty_recv(tty, buf, 16, msg_rsp_timeo);
	347
	348	kwboot_spinner();
	349
	350	} while (rc);
	351
	352	kwboot_printv("\n");
	353
	354	return rc;
	355	}
	356
c5d666aa	357	static size_t
d131ad68 LP	358	kwboot_xm_makeblock(struct kwboot_block block, const void data,
	359	size_t size, int pnum)
	360	{
d8cc851d	361	size_t i, n;
d131ad68	362
84899e2d	363	block->soh = SOH;
d131ad68 LP	364	block->pnum = pnum;
	365	block->_pnum = ~block->pnum;
	366
2ef87f75	367	n = size < KWBOOT_XM_BLKSZ ? size : KWBOOT_XM_BLKSZ;
d131ad68	368	memcpy(&block->data[0], data, n);
2ef87f75	369	memset(&block->data[n], 0, KWBOOT_XM_BLKSZ - n);
d131ad68 LP	370
	371	block->csum = 0;
	372	for (i = 0; i < n; i++)
	373	block->csum += block->data[i];
	374
	375	return n;
	376	}
	377
408ea613 MB	378	static int
	379	_is_xm_reply(char c)
	380	{
	381	return c == ACK \|\| c == NAK \|\| c == CAN;
	382	}
	383
d131ad68 LP	384	static int
	385	kwboot_xm_sendblock(int fd, struct kwboot_block *block)
	386	{
	387	int rc, retries;
	388	char c;
	389
	390	retries = 16;
	391	do {
	392	rc = kwboot_tty_send(fd, block, sizeof(*block));
	393	if (rc)
00a1deed	394	return rc;
d131ad68	395
84899e2d	396	do {
7497a6a1	397	rc = kwboot_tty_recv(fd, &c, 1, blk_rsp_timeo);
00a1deed T	398	if (rc) {
	399	if (errno != ETIMEDOUT)
	400	return rc;
	401	c = NAK;
	402	}
84899e2d	403
408ea613	404	if (!_is_xm_reply(c))
84899e2d SR	405	printf("%c", c);
84899e2d SR	406
408ea613	407	} while (!_is_xm_reply(c));
d131ad68 LP	408
	409	if (c != ACK)
	410	kwboot_progress(-1, '+');
	411
	412	} while (c == NAK && retries-- > 0);
	413
	414	rc = -1;
	415
	416	switch (c) {
	417	case ACK:
	418	rc = 0;
	419	break;
	420	case NAK:
	421	errno = EBADMSG;
	422	break;
	423	case CAN:
	424	errno = ECANCELED;
	425	break;
	426	default:
	427	errno = EPROTO;
	428	break;
	429	}
	430
	431	return rc;
	432	}
	433
	434	static int
2ef87f75 T	435	kwboot_xmodem_one(int tty, int pnum, int header, const uint8_t data,
2ef87f75 T	436	size_t size)
d131ad68	437	{
2ef87f75 T	438	size_t sent, left;
2ef87f75 T	439	int rc;
d131ad68	440
2ef87f75 T	441	kwboot_printv("Sending boot image %s (%zu bytes)...\n",
2ef87f75 T	442	header ? "header" : "data", size);
d131ad68	443
2ef87f75 T	444	left = size;
2ef87f75 T	445	sent = 0;
d131ad68	446
2ef87f75	447	while (sent < size) {
d131ad68	448	struct kwboot_block block;
2ef87f75	449	size_t blksz;
d131ad68	450
2ef87f75 T	451	blksz = kwboot_xm_makeblock(&block, data, left, (*pnum)++);
2ef87f75 T	452	data += blksz;
d131ad68 LP	453
	454	rc = kwboot_xm_sendblock(tty, &block);
	455	if (rc)
	456	goto out;
	457
2ef87f75 T	458	sent += blksz;
	459	left -= blksz;
	460
	461	kwboot_progress(sent * 100 / size, '.');
	462	}
d131ad68	463
2ef87f75	464	kwboot_printv("Done\n");
d131ad68	465
2ef87f75	466	return 0;
d131ad68	467	out:
d5ba8dbd	468	kwboot_printv("\n");
d131ad68	469	return rc;
2ef87f75 T	470	}
	471
	472	static int
	473	kwboot_xmodem(int tty, const void *_img, size_t size)
	474	{
	475	const uint8_t *img = _img;
	476	int rc, pnum;
	477	size_t hdrsz;
	478
	479	if (image_version(img) == 0)
	480	hdrsz = KWBHEADER_V0_SIZE((struct main_hdr_v0 *)img);
	481	else
	482	hdrsz = KWBHEADER_V1_SIZE((struct main_hdr_v1 *)img);
	483
	484	kwboot_printv("Waiting 2s and flushing tty\n");
	485	sleep(2); /* flush isn't effective without it */
	486	tcflush(tty, TCIOFLUSH);
	487
	488	pnum = 1;
	489
	490	rc = kwboot_xmodem_one(tty, &pnum, 1, img, hdrsz);
	491	if (rc)
	492	return rc;
	493
	494	img += hdrsz;
	495	size -= hdrsz;
	496
	497	rc = kwboot_xmodem_one(tty, &pnum, 0, img, size);
	498	if (rc)
	499	return rc;
d131ad68	500
2ef87f75	501	return kwboot_tty_send_char(tty, EOT);
d131ad68 LP	502	}
	503
	504	static int
46237e63	505	kwboot_term_pipe(int in, int out, const char quit, int s)
d131ad68	506	{
e453bb42	507	ssize_t nin;
d131ad68 LP	508	char _buf[128], *buf = _buf;
d131ad68 LP	509
43fef8d4	510	nin = read(in, buf, sizeof(_buf));
4469bd7b	511	if (nin <= 0)
d131ad68 LP	512	return -1;
	513
	514	if (quit) {
	515	int i;
	516
	517	for (i = 0; i < nin; i++) {
	518	if (buf == quit[s]) {
	519	(*s)++;
	520	if (!quit[*s])
	521	return 0;
	522	buf++;
	523	nin--;
b943eee9	524	} else {
e453bb42 MB	525	if (kwboot_write(out, quit, *s) < 0)
	526	return -1;
	527	*s = 0;
b943eee9	528	}
d131ad68 LP	529	}
	530	}
	531
e453bb42 MB	532	if (kwboot_write(out, buf, nin) < 0)
e453bb42 MB	533	return -1;
d131ad68 LP	534
	535	return 0;
	536	}
	537
	538	static int
	539	kwboot_terminal(int tty)
	540	{
	541	int rc, in, s;
46237e63	542	const char *quit = "\34c";
d131ad68 LP	543	struct termios otio, tio;
	544
	545	rc = -1;
	546
	547	in = STDIN_FILENO;
	548	if (isatty(in)) {
	549	rc = tcgetattr(in, &otio);
	550	if (!rc) {
	551	tio = otio;
	552	cfmakeraw(&tio);
	553	rc = tcsetattr(in, TCSANOW, &tio);
	554	}
	555	if (rc) {
	556	perror("tcsetattr");
	557	goto out;
	558	}
	559
	560	kwboot_printv("[Type Ctrl-%c + %c to quit]\r\n",
	561	quit[0]\|0100, quit[1]);
	562	} else
	563	in = -1;
	564
	565	rc = 0;
	566	s = 0;
	567
	568	do {
	569	fd_set rfds;
	570	int nfds = 0;
	571
	572	FD_SET(tty, &rfds);
	573	nfds = nfds < tty ? tty : nfds;
	574
	575	if (in >= 0) {
	576	FD_SET(in, &rfds);
	577	nfds = nfds < in ? in : nfds;
	578	}
	579
	580	nfds = select(nfds + 1, &rfds, NULL, NULL, NULL);
	581	if (nfds < 0)
	582	break;
	583
	584	if (FD_ISSET(tty, &rfds)) {
	585	rc = kwboot_term_pipe(tty, STDOUT_FILENO, NULL, NULL);
	586	if (rc)
	587	break;
	588	}
	589
f30cb0d3	590	if (in >= 0 && FD_ISSET(in, &rfds)) {
d131ad68 LP	591	rc = kwboot_term_pipe(in, tty, quit, &s);
	592	if (rc)
	593	break;
	594	}
	595	} while (quit[s] != 0);
	596
ec0fe5b8 T	597	if (in >= 0)
ec0fe5b8 T	598	tcsetattr(in, TCSANOW, &otio);
49a0a3b8	599	printf("\n");
d131ad68 LP	600	out:
	601	return rc;
	602	}
	603
	604	static void *
	605	kwboot_mmap_image(const char path, size_t size, int prot)
	606	{
	607	int rc, fd, flags;
	608	struct stat st;
	609	void *img;
	610
	611	rc = -1;
d131ad68 LP	612	img = NULL;
	613
	614	fd = open(path, O_RDONLY);
	615	if (fd < 0)
	616	goto out;
	617
	618	rc = fstat(fd, &st);
	619	if (rc)
	620	goto out;
	621
	622	flags = (prot & PROT_WRITE) ? MAP_PRIVATE : MAP_SHARED;
	623
	624	img = mmap(NULL, st.st_size, prot, flags, fd, 0);
	625	if (img == MAP_FAILED) {
	626	img = NULL;
	627	goto out;
	628	}
	629
	630	rc = 0;
	631	*size = st.st_size;
	632	out:
	633	if (rc && img) {
	634	munmap(img, st.st_size);
	635	img = NULL;
	636	}
	637	if (fd >= 0)
	638	close(fd);
	639
	640	return img;
	641	}
	642
	643	static uint8_t
	644	kwboot_img_csum8(void *_data, size_t size)
	645	{
	646	uint8_t *data = _data, csum;
	647
	648	for (csum = 0; size-- > 0; data++)
	649	csum += *data;
	650
	651	return csum;
	652	}
	653
	654	static int
	655	kwboot_img_patch_hdr(void *img, size_t size)
	656	{
	657	int rc;
e29f1db3	658	struct main_hdr_v1 *hdr;
d131ad68	659	uint8_t csum;
e29f1db3 SR	660	size_t hdrsz = sizeof(*hdr);
e29f1db3 SR	661	int image_ver;
d131ad68 LP	662
	663	rc = -1;
	664	hdr = img;
	665
	666	if (size < hdrsz) {
	667	errno = EINVAL;
	668	goto out;
	669	}
	670
e29f1db3	671	image_ver = image_version(img);
5029d7bf	672	if (image_ver != 0 && image_ver != 1) {
e29f1db3 SR	673	fprintf(stderr, "Invalid image header version\n");
	674	errno = EINVAL;
	675	goto out;
	676	}
	677
	678	if (image_ver == 0)
	679	hdrsz = sizeof(*hdr);
	680	else
	681	hdrsz = KWBHEADER_V1_SIZE(hdr);
	682
825a2ca0 T	683	if (size < hdrsz) {
	684	errno = EINVAL;
	685	goto out;
	686	}
	687
e29f1db3 SR	688	csum = kwboot_img_csum8(hdr, hdrsz) - hdr->checksum;
e29f1db3 SR	689	if (csum != hdr->checksum) {
d131ad68 LP	690	errno = EINVAL;
	691	goto out;
	692	}
	693
	694	if (hdr->blockid == IBR_HDR_UART_ID) {
	695	rc = 0;
	696	goto out;
	697	}
	698
	699	hdr->blockid = IBR_HDR_UART_ID;
	700
e29f1db3 SR	701	if (image_ver == 0) {
e29f1db3 SR	702	struct main_hdr_v0 *hdr_v0 = img;
d131ad68	703
e29f1db3 SR	704	hdr_v0->nandeccmode = IBR_HDR_ECC_DISABLED;
	705	hdr_v0->nandpagesize = 0;
	706
	707	hdr_v0->srcaddr = hdr_v0->ext
	708	? sizeof(struct kwb_header)
	709	: sizeof(*hdr_v0);
	710	}
d131ad68	711
e29f1db3	712	hdr->checksum = kwboot_img_csum8(hdr, hdrsz) - csum;
d131ad68 LP	713
	714	rc = 0;
	715	out:
	716	return rc;
	717	}
	718
	719	static void
	720	kwboot_usage(FILE stream, char progname)
	721	{
a050a862	722	fprintf(stream, "kwboot version %s\n", PLAIN_VERSION);
d131ad68	723	fprintf(stream,
8669dacf	724	"Usage: %s [OPTIONS] [-b <image> \| -D <image> ] [-B <baud> ] <TTY>\n",
84899e2d	725	progname);
d131ad68	726	fprintf(stream, "\n");
84899e2d SR	727	fprintf(stream,
84899e2d SR	728	" -b <image>: boot <image> with preamble (Kirkwood, Armada 370/XP)\n");
d131ad68	729	fprintf(stream, " -p: patch <image> to type 0x69 (uart boot)\n");
84899e2d SR	730	fprintf(stream,
	731	" -D <image>: boot <image> without preamble (Dove)\n");
	732	fprintf(stream, " -d: enter debug mode\n");
	733	fprintf(stream, " -a: use timings for Armada XP\n");
1c0df9ef SR	734	fprintf(stream, " -q <req-delay>: use specific request-delay\n");
1c0df9ef SR	735	fprintf(stream, " -s <resp-timeo>: use specific response-timeout\n");
7497a6a1 KS	736	fprintf(stream,
7497a6a1 KS	737	" -o <block-timeo>: use specific xmodem block timeout\n");
d131ad68 LP	738	fprintf(stream, "\n");
	739	fprintf(stream, " -t: mini terminal\n");
	740	fprintf(stream, "\n");
	741	fprintf(stream, " -B <baud>: set baud rate\n");
	742	fprintf(stream, "\n");
	743	}
	744
	745	int
	746	main(int argc, char **argv)
	747	{
	748	const char ttypath, imgpath;
	749	int rv, rc, tty, term, prot, patch;
	750	void *bootmsg;
84899e2d	751	void *debugmsg;
d131ad68 LP	752	void *img;
	753	size_t size;
	754	speed_t speed;
	755
	756	rv = 1;
	757	tty = -1;
	758	bootmsg = NULL;
84899e2d	759	debugmsg = NULL;
d131ad68 LP	760	imgpath = NULL;
	761	img = NULL;
	762	term = 0;
	763	patch = 0;
	764	size = 0;
	765	speed = B115200;
	766
	767	kwboot_verbose = isatty(STDOUT_FILENO);
	768
	769	do {
7497a6a1	770	int c = getopt(argc, argv, "hb:ptaB:dD:q:s:o:");
d131ad68 LP	771	if (c < 0)
	772	break;
	773
	774	switch (c) {
	775	case 'b':
	776	bootmsg = kwboot_msg_boot;
	777	imgpath = optarg;
	778	break;
	779
84899e2d SR	780	case 'D':
	781	bootmsg = NULL;
	782	imgpath = optarg;
	783	break;
	784
	785	case 'd':
	786	debugmsg = kwboot_msg_debug;
	787	break;
	788
d131ad68 LP	789	case 'p':
	790	patch = 1;
	791	break;
	792
	793	case 't':
	794	term = 1;
	795	break;
	796
84899e2d SR	797	case 'a':
	798	msg_req_delay = KWBOOT_MSG_REQ_DELAY_AXP;
	799	msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO_AXP;
	800	break;
	801
1c0df9ef SR	802	case 'q':
	803	msg_req_delay = atoi(optarg);
	804	break;
	805
	806	case 's':
	807	msg_rsp_timeo = atoi(optarg);
	808	break;
	809
7497a6a1 KS	810	case 'o':
	811	blk_rsp_timeo = atoi(optarg);
	812	break;
	813
d131ad68 LP	814	case 'B':
	815	speed = kwboot_tty_speed(atoi(optarg));
	816	if (speed == -1)
	817	goto usage;
	818	break;
	819
	820	case 'h':
	821	rv = 0;
	822	default:
	823	goto usage;
	824	}
	825	} while (1);
	826
84899e2d	827	if (!bootmsg && !term && !debugmsg)
d131ad68 LP	828	goto usage;
	829
	830	if (patch && !imgpath)
	831	goto usage;
	832
	833	if (argc - optind < 1)
	834	goto usage;
	835
	836	ttypath = argv[optind++];
	837
	838	tty = kwboot_open_tty(ttypath, speed);
	839	if (tty < 0) {
	840	perror(ttypath);
	841	goto out;
	842	}
	843
	844	if (imgpath) {
	845	prot = PROT_READ \| (patch ? PROT_WRITE : 0);
	846
	847	img = kwboot_mmap_image(imgpath, &size, prot);
	848	if (!img) {
	849	perror(imgpath);
	850	goto out;
	851	}
	852	}
	853
	854	if (patch) {
	855	rc = kwboot_img_patch_hdr(img, size);
	856	if (rc) {
	857	fprintf(stderr, "%s: Invalid image.\n", imgpath);
	858	goto out;
	859	}
	860	}
	861
84899e2d SR	862	if (debugmsg) {
	863	rc = kwboot_debugmsg(tty, debugmsg);
	864	if (rc) {
	865	perror("debugmsg");
	866	goto out;
	867	}
3475a71d	868	} else if (bootmsg) {
d131ad68 LP	869	rc = kwboot_bootmsg(tty, bootmsg);
	870	if (rc) {
	871	perror("bootmsg");
	872	goto out;
	873	}
	874	}
	875
	876	if (img) {
	877	rc = kwboot_xmodem(tty, img, size);
	878	if (rc) {
	879	perror("xmodem");
	880	goto out;
	881	}
	882	}
	883
	884	if (term) {
	885	rc = kwboot_terminal(tty);
	886	if (rc && !(errno == EINTR)) {
	887	perror("terminal");
	888	goto out;
	889	}
	890	}
	891
	892	rv = 0;
	893	out:
	894	if (tty >= 0)
	895	close(tty);
	896
	897	if (img)
	898	munmap(img, size);
	899
	900	return rv;
	901
	902	usage:
	903	kwboot_usage(rv ? stderr : stdout, basename(argv[0]));
	904	goto out;
	905	}