1 files changed, 235 insertions, 0 deletions
diff --git a/payloads/libpayload/gdb/transport.c b/payloads/libpayload/gdb/transport.c
new file mode 100644
index 0000000000..596ceb5c6d
--- /dev/null
+++ b/payloads/libpayload/gdb/transport.c
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * 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 2 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <gdb.h>
+#include <libpayload.h>
+
+static const int timeout_us = 100 * 1000;
+static const char output_overrun[] = "GDB output buffer overrun (try "
+				     "increasing reply.size)!\n";
+static const char input_underrun[] = "GDB input message truncated (bug or "
+				     "communication problem)?\n";
+
+/* Serial-specific glue code... add more transport layers here when desired. */
+
+static void gdb_raw_putchar(u8 c)
+{
+	serial_putchar(c);
+}
+
+static int gdb_raw_getchar(void)
+{
+	u64 start = timer_us(0);
+
+	while (!serial_havechar())
+		if (timer_us(start) > timeout_us)
+			return -1;
+
+	return serial_getchar();
+}
+
+void gdb_transport_init(void)
+{
+	console_remove_output_driver(serial_putchar);
+}
+
+void gdb_transport_teardown(void)
+{
+	serial_console_init();
+}
+
+/* Hex digit character <-> number conversion (illegal chars undefined!). */
+
+static s8 from_hex(unsigned char c)
+{
+	static const s8 values[] = {
+		-1, 10, 11, 12, 13, 14, 15, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1,
+		 0,  1,  2,  3,  4,  5,  6,  7,
+		 8,  9, -1, -1, -1, -1, -1, -1,
+	};
+
+	return values[c & 0x1f];
+}
+
+static char to_hex(u8 v)
+{
+	static const char digits[] = "0123456789abcdef";
+
+	return digits[v & 0xf];
+}
+
+/* Message encode/decode functions */
+
+void gdb_message_encode_bytes(struct gdb_message *message, const void *data,
+			      int length)
+{
+	const u8 *bytes = data;
+	die_if(message->used + length * 2 > message->size, output_overrun);
+	while (length--) {
+		message->buf[message->used++] = to_hex(*bytes >> 4);
+		message->buf[message->used++] = to_hex(*bytes & 0xf);
+		bytes++;
+	}
+}
+
+void gdb_message_decode_bytes(const struct gdb_message *message, int offset,
+			      void *data, int length)
+{
+	u8 *bytes = data;
+	die_if(offset + 2 * length > message->used, "Decode overrun in GDB "
+		"message: %.*s", message->used, message->buf);
+	while (length--) {
+		*bytes = from_hex(message->buf[offset++]) << 4;
+		*bytes += from_hex(message->buf[offset++]);
+		bytes++;
+	}
+}
+
+void gdb_message_encode_zero_bytes(struct gdb_message *message, int length)
+{
+	die_if(message->used + length * 2 > message->size, output_overrun);
+	memset(message->buf + message->used, '0', length * 2);
+	message->used += length * 2;
+}
+
+void gdb_message_add_string(struct gdb_message *message, const char *string)
+{
+	message->used += strlcpy((char *)message->buf + message->used,
+			     string, message->size - message->used);
+
+	/* Check >= instead of > to account for strlcpy's trailing '\0'. */
+	die_if(message->used >= message->size, output_overrun);
+}
+
+void gdb_message_encode_int(struct gdb_message *message, uintptr_t val)
+{
+	int length = sizeof(uintptr_t) * 2 - __builtin_clz(val) / 4;
+	die_if(message->used + length > message->size, output_overrun);
+	while (length--)
+		message->buf[message->used++] =
+			to_hex((val >> length * 4) & 0xf);
+}
+
+uintptr_t gdb_message_decode_int(const struct gdb_message *message, int offset,
+				 int length)
+{
+	uintptr_t val = 0;
+
+	die_if(length > sizeof(uintptr_t) * 2, "GDB decoding invalid number: "
+	       "%.*s", message->used, message->buf);
+
+	while (length--) {
+		val <<= 4;
+		val |= from_hex(message->buf[offset++]);
+	}
+
+	return val;
+}
+
+/* Like strtok/strsep: writes back offset argument, returns original offset. */
+int gdb_message_tokenize(const struct gdb_message *message, int *offset)
+{
+	int token = *offset;
+	while (!strchr(",;:", message->buf[(*offset)++]))
+		die_if(*offset >= message->used, "Undelimited token in GDB "
+				"message at offset %d: %.*s",
+				token, message->used, message->buf);
+	return token;
+}
+
+/* High-level send/receive functions. */
+
+void gdb_get_command(struct gdb_message *command)
+{
+	enum command_state {
+		STATE_WAITING,
+		STATE_COMMAND,
+		STATE_CHECKSUM0,
+		STATE_CHECKSUM1,
+	};
+
+	u8 checksum = 0;
+	u8 running_checksum = 0;
+	enum command_state state = STATE_WAITING;
+
+	while (1) {
+		int c = gdb_raw_getchar();
+		if (c < 0) {
+			/*
+			 * Timeout waiting for a byte. Reset the
+			 * state machine.
+			 */
+			state = STATE_WAITING;
+			continue;
+		}
+
+		switch (state) {
+		case STATE_WAITING:
+			if (c == '$') {
+				running_checksum = 0;
+				command->used = 0;
+				state = STATE_COMMAND;
+			}
+			break;
+		case STATE_COMMAND:
+			if (c == '#') {
+				state = STATE_CHECKSUM0;
+				break;
+			}
+			die_if(command->used >= command->size, "GDB input buf"
+			       "fer overrun (try increasing command.size)!\n");
+			command->buf[command->used++] = c;
+			running_checksum += c;
+			break;
+		case STATE_CHECKSUM0:
+			checksum = from_hex(c) << 4;
+			state = STATE_CHECKSUM1;
+			break;
+		case STATE_CHECKSUM1:
+			checksum += from_hex(c);
+			if (running_checksum == checksum) {
+				gdb_raw_putchar('+');
+				return;
+			} else {
+				state = STATE_WAITING;
+				gdb_raw_putchar('-');
+			}
+			break;
+		}
+	}
+}
+
+void gdb_send_reply(const struct gdb_message *reply)
+{
+	int i;
+	int retries = 1 * 1000 * 1000 / timeout_us;
+	u8 checksum = 0;
+
+	for (i = 0; i < reply->used; i++)
+		checksum += reply->buf[i];
+
+	do {
+		gdb_raw_putchar('$');
+		for (i = 0; i < reply->used; i++)
+			gdb_raw_putchar(reply->buf[i]);
+		gdb_raw_putchar('#');
+		gdb_raw_putchar(to_hex(checksum >> 4));
+		gdb_raw_putchar(to_hex(checksum & 0xf));
+	} while (gdb_raw_getchar() != '+' && retries--);
+}