X-Git-Url: https://git.gag.com/?p=fw%2Faltos;a=blobdiff_plain;f=ao-tools%2Flib%2Fcc-usb.c;h=38dfff04936c87e6fbed2b8df73b5286edd92987;hp=81309983fd46b7487aaba7cabc005051373322be;hb=d63319f6f29ef714bb1d5c359c2448f63e7a4534;hpb=9789ca5e8caa9a013e804f307b9da380e147bd75

diff --git a/ao-tools/lib/cc-usb.c b/ao-tools/lib/cc-usb.c
index 81309983..38dfff04 100644
--- a/ao-tools/lib/cc-usb.c
+++ b/ao-tools/lib/cc-usb.c
@@ -30,27 +30,32 @@
 #include "cc-usb.h"
 
 
-#define CC_NUM_READ		16
+#define CC_NUM_HEX_READ		64
 /*
  * AltOS has different buffer sizes for in/out packets
  */
-#define CC_IN_BUF		256
+#define CC_IN_BUF		65536
 #define CC_OUT_BUF		64
 #define DEFAULT_TTY		"/dev/ttyACM0"
 
-struct cc_read {
+struct cc_hex_read {
 	uint8_t	*buf;
 	int	len;
 };
 
 struct cc_usb {
-	int		fd;
-	uint8_t		in_buf[CC_IN_BUF];
-	int		in_count;
-	uint8_t		out_buf[CC_OUT_BUF];
-	int		out_count;
-	struct cc_read	read_buf[CC_NUM_READ];
-	int		read_count;
+	int			fd;
+	uint8_t			in_buf[CC_IN_BUF];
+	int			in_pos;
+	int			in_count;
+	uint8_t			out_buf[CC_OUT_BUF];
+	int			out_count;
+
+	struct cc_hex_read	hex_buf[CC_NUM_HEX_READ];
+	int			hex_count;
+	int			show_input;
+
+	int			remote;
 };
 
 #define NOT_HEX	0xff
@@ -72,69 +77,57 @@ cc_hex_nibble(uint8_t c)
  * and write them to the waiting buffer
  */
 static void
-cc_handle_in(struct cc_usb *cc)
+cc_handle_hex_read(struct cc_usb *cc)
 {
 	uint8_t	h, l;
-	int	in_pos;
-	int	read_pos;
+	int	hex_pos;
 
-	in_pos = 0;
-	read_pos = 0;
-	while (read_pos < cc->read_count && in_pos < cc->in_count) {
+	hex_pos = 0;
+	while (hex_pos < cc->hex_count && cc->in_pos < cc->in_count) {
 		/*
 		 * Skip to next hex character
 		 */
-		while (in_pos < cc->in_count &&
-		       cc_hex_nibble(cc->in_buf[in_pos]) == NOT_HEX)
-			in_pos++;
+		while (cc->in_pos < cc->in_count &&
+		       cc_hex_nibble(cc->in_buf[cc->in_pos]) == NOT_HEX)
+			cc->in_pos++;
 		/*
 		 * Make sure we have two characters left
 		 */
-		if (cc->in_count - in_pos < 2)
+		if (cc->in_count - cc->in_pos < 2)
 			break;
 		/*
 		 * Parse hex number
 		 */
-		h = cc_hex_nibble(cc->in_buf[in_pos]);
-		l = cc_hex_nibble(cc->in_buf[in_pos+1]);
+		h = cc_hex_nibble(cc->in_buf[cc->in_pos]);
+		l = cc_hex_nibble(cc->in_buf[cc->in_pos+1]);
 		if (h == NOT_HEX || l == NOT_HEX) {
 			fprintf(stderr, "hex read error\n");
 			break;
 		}
-		in_pos += 2;
+		cc->in_pos += 2;
 		/*
 		 * Store hex number
 		 */
-		*cc->read_buf[read_pos].buf++ = (h << 4) | l;
-		if (--cc->read_buf[read_pos].len <= 0)
-			read_pos++;
+		*cc->hex_buf[hex_pos].buf++ = (h << 4) | l;
+		if (--cc->hex_buf[hex_pos].len <= 0)
+			hex_pos++;
 	}
 
-	/* Move remaining bytes to the start of the input buffer */
-	if (in_pos) {
-		memmove(cc->in_buf, cc->in_buf + in_pos,
-			cc->in_count - in_pos);
-		cc->in_count -= in_pos;
+	/* Move pending hex reads to the start of the array */
+	if (hex_pos) {
+		memmove(cc->hex_buf, cc->hex_buf + hex_pos,
+			(cc->hex_count - hex_pos) * sizeof (cc->hex_buf[0]));
+		cc->hex_count -= hex_pos;
 	}
-
-	/* Move pending reads to the start of the array */
-	if (read_pos) {
-		memmove(cc->read_buf, cc->read_buf + read_pos,
-			(cc->read_count - read_pos) * sizeof (cc->read_buf[0]));
-		cc->read_count -= read_pos;
-	}
-
-	/* Once we're done reading, flush any pending input */
-	if (cc->read_count == 0)
-		cc->in_count = 0;
 }
 
 static void
 cc_usb_dbg(int indent, uint8_t *bytes, int len)
 {
-	int	eol = 1;
+	static int	eol = 1;
 	int	i;
 	uint8_t	c;
+	ccdbg_debug(CC_DEBUG_BITBANG, "<<<%d bytes>>>", len);
 	while (len--) {
 		c = *bytes++;
 		if (eol) {
@@ -144,12 +137,17 @@ cc_usb_dbg(int indent, uint8_t *bytes, int len)
 		}
 		switch (c) {
 		case '\r':
-			ccdbg_debug(CC_DEBUG_BITBANG, "^M");
+			ccdbg_debug(CC_DEBUG_BITBANG, "\\r");
 			break;
 		case '\n':
 			eol = 1;
+			ccdbg_debug(CC_DEBUG_BITBANG, "\\n\n");
+			break;
 		default:
-			ccdbg_debug(CC_DEBUG_BITBANG, "%c", c);
+			if (c < ' ' || c > '~')
+				ccdbg_debug(CC_DEBUG_BITBANG, "\\%02x", c);
+			else
+				ccdbg_debug(CC_DEBUG_BITBANG, "%c", c);
 		}
 	}
 }
@@ -157,8 +155,9 @@ cc_usb_dbg(int indent, uint8_t *bytes, int len)
 /*
  * Flush pending writes, fill pending reads
  */
-void
-cc_usb_sync(struct cc_usb *cc)
+
+static int
+_cc_usb_sync(struct cc_usb *cc, int wait_for_input, int write_timeout)
 {
 	int		ret;
 	struct pollfd	fds;
@@ -166,21 +165,33 @@ cc_usb_sync(struct cc_usb *cc)
 
 	fds.fd = cc->fd;
 	for (;;) {
-		if (cc->read_count || cc->out_count)
-			timeout = -1;
+		if (cc->hex_count || cc->out_count)
+			timeout = write_timeout;
+		else if (wait_for_input && cc->in_pos == cc->in_count)
+			timeout = wait_for_input;
 		else
 			timeout = 0;
 		fds.events = 0;
+		/* Move remaining bytes to the start of the input buffer */
+		if (cc->in_pos) {
+			memmove(cc->in_buf, cc->in_buf + cc->in_pos,
+				cc->in_count - cc->in_pos);
+			cc->in_count -= cc->in_pos;
+			cc->in_pos = 0;
+		}
 		if (cc->in_count < CC_IN_BUF)
 			fds.events |= POLLIN;
 		if (cc->out_count)
 			fds.events |= POLLOUT;
 		ret = poll(&fds, 1, timeout);
-		if (ret == 0)
+		if (ret == 0) {
+			if (timeout)
+				return -1;
 			break;
+		}
 		if (ret < 0) {
 			perror("poll");
-			break;
+			return -1;
 		}
 		if (fds.revents & POLLIN) {
 			ret = read(cc->fd, cc->in_buf + cc->in_count,
@@ -188,7 +199,12 @@ cc_usb_sync(struct cc_usb *cc)
 			if (ret > 0) {
 				cc_usb_dbg(24, cc->in_buf + cc->in_count, ret);
 				cc->in_count += ret;
-				cc_handle_in(cc);
+				if (cc->hex_count)
+					cc_handle_hex_read(cc);
+				if (cc->show_input && cc->in_count) {
+					write(2, cc->in_buf, cc->in_count);
+					cc->in_count = 0;
+				}
 			} else if (ret < 0)
 				perror("read");
 		}
@@ -205,6 +221,16 @@ cc_usb_sync(struct cc_usb *cc)
 				perror("write");
 		}
 	}
+	return 0;
+}
+
+void
+cc_usb_sync(struct cc_usb *cc)
+{
+	if (_cc_usb_sync(cc, 0, 5000) < 0) {
+		fprintf(stderr, "USB link timeout\n");
+		exit(1);
+	}
 }
 
 void
@@ -238,6 +264,44 @@ cc_usb_printf(struct cc_usb *cc, char *format, ...)
 	}
 }
 
+int
+cc_usb_getchar_timeout(struct cc_usb *cc, int timeout)
+{
+	while (cc->in_pos == cc->in_count) {
+		if (_cc_usb_sync(cc, timeout, 5000) < 0) {
+			fprintf(stderr, "USB link timeout\n");
+			exit(1);
+		}
+	}
+	return cc->in_buf[cc->in_pos++];
+}
+
+int
+cc_usb_getchar(struct cc_usb *cc)
+{
+	return cc_usb_getchar_timeout(cc, 5000);
+}
+
+void
+cc_usb_getline(struct cc_usb *cc, char *line, int max)
+{
+	int	c;
+
+	while ((c = cc_usb_getchar(cc)) != '\n') {
+		switch (c) {
+		case '\r':
+			break;
+		default:
+			if (max > 1) {
+				*line++ = c;
+				max--;
+			}
+			break;
+		}
+	}
+	*line++ = '\0';
+}
+
 int
 cc_usb_send_bytes(struct cc_usb *cc, uint8_t *bytes, int len)
 {
@@ -260,12 +324,18 @@ cc_usb_send_bytes(struct cc_usb *cc, uint8_t *bytes, int len)
 void
 cc_queue_read(struct cc_usb *cc, uint8_t *buf, int len)
 {
-	struct cc_read	*read_buf;
-	while (cc->read_count >= CC_NUM_READ)
+	struct cc_hex_read	*hex_buf;
+
+	/* At the start of a command sequence, flush any pending input */
+	if (cc->hex_count == 0) {
+		cc_usb_sync(cc);
+		cc->in_count = 0;
+	}
+	while (cc->hex_count >= CC_NUM_HEX_READ)
 		cc_usb_sync(cc);
-	read_buf = &cc->read_buf[cc->read_count++];
-	read_buf->buf = buf;
-	read_buf->len = len;
+	hex_buf = &cc->hex_buf[cc->hex_count++];
+	hex_buf->buf = buf;
+	hex_buf->len = len;
 }
 
 int
@@ -321,21 +391,61 @@ cc_usb_reset(struct cc_usb *cc)
 	return 1;
 }
 
+void
+cc_usb_open_remote(struct cc_usb *cc, int freq, char *call)
+{
+	if (!cc->remote) {
+		fprintf (stderr, "freq %dkHz\n", freq);
+		fprintf (stderr, "call %s\n", call);
+		cc_usb_printf(cc, "\nc F %d\nc c %s\np\nE 0\n", freq, call);
+		do {
+			cc->in_count = cc->in_pos = 0;
+			_cc_usb_sync(cc, 100, 5000);
+		} while (cc->in_count > 0);
+		cc->remote = 1;
+	}
+}
+
+void
+cc_usb_close_remote(struct cc_usb *cc)
+{
+	if (cc->remote) {
+		cc_usb_printf(cc, "~");
+		cc->remote = 0;
+	}
+}
+
 static struct termios	save_termios;
 
+#include <errno.h>
+
 struct cc_usb *
 cc_usb_open(char *tty)
 {
 	struct cc_usb	*cc;
 	struct termios	termios;
+	int		i;
 
 	if (!tty)
 		tty = DEFAULT_TTY;
 	cc = calloc (sizeof (struct cc_usb), 1);
 	if (!cc)
 		return NULL;
-	cc->fd = open(tty, O_RDWR | O_NONBLOCK);
-	if (cc->fd < 0) {
+	i = 0;
+	for (;;) {
+		cc->fd = open(tty, O_RDWR | O_NONBLOCK);
+		if (cc->fd >= 0)
+			break;
+		i++;
+		if (errno == EBUSY || errno == EPERM || errno == EACCES) {
+			fprintf(stderr, "open failed, pausing");
+			perror(tty);
+			if (i < 20) {
+				sleep(3);
+				continue;
+			}
+		}
+
 		perror(tty);
 		free (cc);
 		return NULL;
@@ -343,18 +453,46 @@ cc_usb_open(char *tty)
 	tcgetattr(cc->fd, &termios);
 	save_termios = termios;
 	cfmakeraw(&termios);
+	cfsetospeed(&termios, B9600);
+	cfsetispeed(&termios, B9600);
 	tcsetattr(cc->fd, TCSAFLUSH, &termios);
-	cc_usb_printf(cc, "E 0\nm 0\n");
-	cc_usb_sync(cc);
-	sleep(1);
-	cc_usb_sync(cc);
+	cc_usb_printf(cc, "\nE 0\nm 0\n");
+	do {
+		cc->in_count = cc->in_pos = 0;
+		_cc_usb_sync(cc, 100, 5000);
+	} while (cc->in_count > 0);
 	return cc;
 }
 
 void
 cc_usb_close(struct cc_usb *cc)
 {
+	cc_usb_close_remote(cc);
+	cc_usb_sync(cc);
 	tcsetattr(cc->fd, TCSAFLUSH, &save_termios);
 	close (cc->fd);
 	free (cc);
 }
+
+int
+cc_usb_write(struct cc_usb *cc, void *buf, int c)
+{
+	uint8_t	*b;
+	int this_time;
+
+	b = buf;
+	cc->show_input = 1;
+	while (c > 0) {
+		this_time = c;
+		if (this_time > CC_OUT_BUF - cc->out_count)
+			this_time = CC_OUT_BUF - cc->out_count;
+		memcpy(cc->out_buf + cc->out_count, b, this_time);
+		cc->out_count += this_time;
+		c -= this_time;
+		b += this_time;
+		while (cc->out_count >= CC_OUT_BUF) {
+			_cc_usb_sync(cc, 0, -1);
+		}
+	}
+	return 1;
+}