Added split uart support based on chibios impl

1 files changed, 158 insertions, 141 deletions

diff --git a/src/split.c b/src/split.c
index 75505ff..7bc7e63 100644
--- a/src/split.c
+++ b/src/split.c
@@ -1,29 +1,34 @@
+#include "hardware/regs/io_bank0.h"
+#include "hardware/structs/padsbank0.h"
+#include "uart_rx.pio.h"
+#include "uart_tx.pio.h"
+
 #include "split.h"
-#include "class/cdc/cdc_device.h"
 #include "util.h"
 #include "matrix.h"
 
 #include "hardware/pio.h"
 #include "hardware/irq.h"
 #include "hardware/gpio.h"
+#include "hardware/address_mapped.h"
 #include "hardware/regs/intctrl.h"
+#include "hardware/regs/pads_bank0.h"
 #include "hardware/uart.h"
 #include "hardware/timer.h"
 #include "hardware/clocks.h"
 #include "pico/time.h"
 #include "bsp/board.h"
+#include "class/cdc/cdc_device.h"
 #include "tusb.h"
+
 #include <stdint.h>
 
 #define UART_TIMEOUT 20
 #define UART_BAUD 115200
-
-/* same pin since half-duplex */
-#define UART_TX_PIN 0
-#define UART_RX_PIN 0
+#define UART_PIN 1
 
 enum {
-	CMD_SCAN_MATRIX_REQ = 0x80,
+	CMD_SCAN_MATRIX_REQ = 0x0F,
 	CMD_SCAN_MATRIX_RESP,
 	CMD_STDIO_PUTS
 };
@@ -33,15 +38,16 @@ enum { LEFT, RIGHT };
 
 static void uart_tx_init(void);
 static void uart_rx_init(void);
+static void uart_full_init(void);
 
-static void uart_enter_rx(void);
 static void uart_leave_rx(void);
+static void uart_enter_rx(void);
 
-static int uart_sync_rx(void);
-static int uart_sync_tx(void);
+static bool uart_await_rx(void);
+static bool uart_await_tx(void);
 
-static uint8_t uart_in_byte(void);
-static void uart_out_byte(uint8_t c);
+static uint8_t uart_rx_byte(void);
+static void uart_tx_byte(uint8_t c);
 
 static uint uart_recv(uint8_t *data, uint len);
 static uint uart_send(const uint8_t *data, uint len);
@@ -49,43 +55,11 @@ static uint uart_send(const uint8_t *data, uint len);
 static void irq_rx_cmd(uint8_t cmd);
 static void irq_rx(void);
 
-static const uint16_t uart_tx_program_asm[] = {
-	        //     .wrap_target
-	0x9fa0, //  0: pull   block           side 1 [7]
-	0xf727, //  1: set    x, 7            side 0 [7]
-	0x6081, //  2: out    pindirs, 1
-	0x0642, //  3: jmp    x--, 2                 [6]
-	        //     .wrap
-};
-
-static const uint16_t uart_rx_program_asm[] = {
-	        //     .wrap_target
-	0x2020, //  0: wait   0 pin, 0
-	0xea27, //  1: set    x, 7                   [10]
-	0x4001, //  2: in     pins, 1
-	0x0642, //  3: jmp    x--, 2                 [6]
-	0x00c8, //  4: jmp    pin, 8
-	0xc020, //  5: irq    wait 0
-	0x20a0, //  6: wait   1 pin, 0
-	0x0000, //  7: jmp    0
-	0x8020, //  8: push   block
-	        //     .wrap
-};
-
-static const pio_program_t uart_tx_program = {
-	.instructions = uart_tx_program_asm,
-	.length = 4,
-	.origin = -1,
-};
-
-static const pio_program_t uart_rx_program = {
-	.instructions = uart_rx_program_asm,
-	.length = 9,
-	.origin = -1,
-};
-
 static uint uart_tx_sm;
+static uint uart_tx_sm_offset;
+
 static uint uart_rx_sm;
+static uint uart_rx_sm_offset;
 
 static bool scan_pending = false;
 
@@ -93,93 +67,112 @@ void
 uart_tx_init(void)
 {
 	pio_sm_config config;
-	uint offset;
-	int sm;
-
-	sm = pio_claim_unused_sm(pio0, true);
-	ASSERT(sm >= 0);
-	uart_tx_sm = (uint) sm;
-
-	offset = pio_add_program(pio0, &uart_tx_program);
-	pio_sm_set_pins_with_mask(pio0, uart_tx_sm, 0, 1 << UART_TX_PIN);
-	pio_sm_set_consecutive_pindirs(pio0,
-		uart_tx_sm, UART_TX_PIN, 1, true);
-
-	config = pio_get_default_sm_config();
-	sm_config_set_wrap(&config, offset,
-		offset + ARRLEN(uart_tx_program_asm) - 1);
-	sm_config_set_sideset(&config, 2, true, true);
+
+	uart_tx_sm = CLAIM_UNUSED_SM(pio0);
+	uart_tx_sm_offset = pio_add_program(pio0, &uart_tx_program);
+
+	config = uart_tx_program_get_default_config(uart_tx_sm_offset);
 	sm_config_set_out_shift(&config, true, false, 32);
-	sm_config_set_out_pins(&config, UART_TX_PIN, 1);
-	sm_config_set_sideset_pins(&config, UART_TX_PIN);
+	sm_config_set_out_pins(&config, UART_PIN, 1);
+	sm_config_set_sideset_pins(&config, UART_PIN);
 	sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_TX);
 	sm_config_set_clkdiv(&config,
-		(float) clock_get_hz(clk_sys) / (8 * UART_BAUD));
+		((float) clock_get_hz(clk_sys)) / (8 * UART_BAUD));
 
-	pio_sm_init(pio0, uart_tx_sm, offset, &config);
-	pio_sm_set_enabled(pio0, uart_tx_sm, true);
+	pio_sm_init(pio0, uart_tx_sm, uart_tx_sm_offset, &config);
+	pio_sm_set_enabled(pio0, uart_tx_sm, false);
 }
 
 void
 uart_rx_init(void)
 {
 	pio_sm_config config;
-	uint offset;
-	int sm;
-
-	sm = pio_claim_unused_sm(pio0, true);
-	ASSERT(sm >= 0);
-	uart_rx_sm = (uint) sm;
 
-	offset = pio_add_program(pio0, &uart_rx_program);
+	uart_rx_sm = CLAIM_UNUSED_SM(pio0);
+	uart_rx_sm_offset = pio_add_program(pio0, &uart_rx_program);
 
-	config = pio_get_default_sm_config();
-	sm_config_set_wrap(&config, offset,
-		offset + ARRLEN(uart_rx_program_asm) - 1);
-	sm_config_set_in_pins(&config, UART_RX_PIN);
-	sm_config_set_jmp_pin(&config, UART_RX_PIN);
+	config = uart_rx_program_get_default_config(uart_rx_sm_offset);
+	sm_config_set_in_pins(&config, UART_PIN);
+	sm_config_set_jmp_pin(&config, UART_PIN);
 	sm_config_set_in_shift(&config, true, false, 32);
 	sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_RX);
 	sm_config_set_clkdiv(&config,
-		(float) clock_get_hz(clk_sys) / (8 * UART_BAUD));
+		((float) clock_get_hz(clk_sys)) / (8 * UART_BAUD));
 
-	pio_sm_init(pio0, uart_rx_sm, offset, &config);
-	pio_sm_set_enabled(pio0, uart_rx_sm, true);
+	pio_sm_init(pio0, uart_rx_sm, uart_rx_sm_offset, &config);
+	pio_sm_set_enabled(pio0, uart_rx_sm, false);
 }
 
 void
-uart_enter_rx(void)
+uart_full_init(void)
 {
-	while (!pio_sm_is_tx_fifo_empty(pio0, uart_tx_sm));
-	/* even after fifo is empty, we still need to wait until last byte
-	 * = max (1 start + 8 data + 1 stop + 1 par) is fully transmitted */
-	sleep_us(1000000U * 11 / UART_BAUD);
+	pio_sm_set_pins_with_mask(pio0, uart_tx_sm, 0U, 1U << UART_PIN);
+	pio_sm_set_consecutive_pindirs(pio0, uart_tx_sm, UART_PIN, 1, true);
 
-	pio_sm_set_enabled(pio0, uart_tx_sm, false);
-	gpio_set_drive_strength(UART_TX_PIN, GPIO_DRIVE_STRENGTH_2MA);
-	pio_sm_set_pins_with_mask(pio0,
-		uart_tx_sm, 1U << UART_TX_PIN, 1U << UART_TX_PIN);
-	pio_sm_set_consecutive_pindirs(pio0,
-		uart_tx_sm, UART_TX_PIN, 1, false);
-	pio_sm_set_enabled(pio0, uart_rx_sm, true);
+	pio_gpio_init(pio0, UART_PIN);
+	gpio_pull_up(UART_PIN);
+	gpio_set_slew_rate(UART_PIN, GPIO_SLEW_RATE_FAST);
+	/* 1 => set INPUT and pull line HIGH from pullup
+	 * 0 => set OUTPUT and pull line LOW from signal */
+	gpio_set_oeover(UART_PIN, GPIO_OVERRIDE_INVERT);
+
+	uart_rx_init();
+	uart_tx_init();
+
+	pio_set_irq0_source_enabled(pio0,
+		pis_sm0_rx_fifo_not_empty + uart_rx_sm, false);
+	pio_set_irq0_source_enabled(pio0,
+		pis_sm0_tx_fifo_not_full + uart_tx_sm, false);
+	pio_set_irq0_source_enabled(pio0, pis_interrupt0, true);
+	pio_set_irq0_source_enabled(pio0, pis_interrupt1, true);
+
+	irq_set_priority(PIO0_IRQ_0, PICO_HIGHEST_IRQ_PRIORITY);
+	irq_set_exclusive_handler(PIO0_IRQ_0, irq_rx);
+	irq_set_enabled(PIO0_IRQ_0, true);
+
+	pio_sm_set_enabled(pio0, uart_tx_sm, true);
+	uart_enter_rx();
 }
 
 void
 uart_leave_rx(void)
 {
-	/* disable rx to not receive when we send */
+	irq_set_enabled(USBCTRL_IRQ, false);
 	pio_sm_set_enabled(pio0, uart_rx_sm, false);
-	pio_sm_set_consecutive_pindirs(pio0,
-		uart_tx_sm, UART_TX_PIN, 1, true);
-	pio_sm_set_pins_with_mask(UART_TX_PIN,
-		uart_tx_sm, 0, 1U << UART_TX_PIN);
-	gpio_set_drive_strength(UART_TX_PIN, GPIO_DRIVE_STRENGTH_12MA);
+
+	/* because of OE override pindir true = INPUT (!) */
+	pio_sm_set_consecutive_pindirs(pio0, uart_tx_sm, UART_PIN, 1, true);
+
+	/* drive LOW with high drive-current for steep falling edges */
+	pio_sm_set_pins_with_mask(pio0, uart_tx_sm, 0U, 1 << UART_PIN);
+	gpio_set_drive_strength(UART_PIN, GPIO_DRIVE_STRENGTH_12MA);
+
 	pio_sm_restart(pio0, uart_tx_sm);
 	pio_sm_set_enabled(pio0, uart_tx_sm, true);
 }
 
-int
-uart_sync_rx(void)
+void
+uart_enter_rx(void)
+{
+	/* wait for tx fifo to empty and final byte to transmit
+	 * + extra max. 1 start + 8 data + 1 stop + 1 par bits */
+	while (!pio_sm_is_tx_fifo_empty(pio0, uart_tx_sm));
+	sleep_us(1000000U * 11 / UART_BAUD);
+	pio_sm_set_enabled(pio0, uart_tx_sm, false);
+
+	/* pull HIGH with low drive-current for steeper rising edge */
+	gpio_set_drive_strength(UART_PIN, GPIO_DRIVE_STRENGTH_2MA);
+	pio_sm_set_pins_with_mask(pio0, uart_tx_sm, ~0U, 1 << UART_PIN);
+
+	/* because of OE override pindir false = OUTPUT (!) */
+	pio_sm_set_consecutive_pindirs(pio0, uart_tx_sm, UART_PIN, 1, false);
+
+	pio_sm_set_enabled(pio0, uart_rx_sm, true);
+	irq_set_enabled(USBCTRL_IRQ, true);
+}
+
+bool
+uart_await_rx(void)
 {
 	uint32_t start_ms;
 	bool empty;
@@ -191,11 +184,11 @@ uart_sync_rx(void)
 		tud_task();
 	} while (board_millis() < start_ms + UART_TIMEOUT);
 
-	return empty;
+	return !empty;
 }
 
-int
-uart_sync_tx(void)
+bool
+uart_await_tx(void)
 {
 	uint32_t start_ms;
 	bool full;
@@ -207,17 +200,17 @@ uart_sync_tx(void)
 		tud_task();
 	} while (board_millis() < start_ms + UART_TIMEOUT);
 
-	return full;
+	return !full;
 }
 
 uint8_t
-uart_in_byte(void)
+uart_rx_byte(void)
 {
 	return *(uint8_t*)((uintptr_t)&pio0->rxf[uart_rx_sm] + 3);
 }
 
 void
-uart_out_byte(uint8_t c)
+uart_tx_byte(uint8_t c)
 {
 	pio_sm_put(pio0, uart_tx_sm, c);
 }
@@ -227,13 +220,11 @@ uart_recv(uint8_t *data, uint len)
 {
 	uint recv;
 
-	recv = 0;
-	while (recv < len) {
+	for (recv = 0; recv < len; recv++) {
 		if (pio_sm_is_rx_fifo_empty(pio0, uart_rx_sm)) {
-			if (uart_sync_rx()) break;
+			if (!uart_await_rx()) break;
 		}
-		*data++ = uart_in_byte();
-		recv++;
+		*data++ = uart_rx_byte();
 	}
 
 	return recv;
@@ -245,13 +236,11 @@ uart_send(const uint8_t *data, uint len)
 	uint sent;
 
 	uart_leave_rx();
-	sent = 0;
-	while (sent < len) {
+	for (sent = 0; sent < len; sent++) {
 		if (pio_sm_is_tx_fifo_full(pio0, uart_tx_sm)) {
-			if (uart_sync_tx()) break;
+			if (!uart_await_tx()) break;
 		}
-		uart_out_byte(*data++);
-		sent++;
+		uart_tx_byte(*data++);
 	}
 	uart_enter_rx();
 
@@ -291,9 +280,21 @@ irq_rx(void)
 {
 	uint8_t cmd;
 
-	DEBUG("UART IRQ\n");
+	(void) cmd;
+	(void) irq_rx_cmd;
+
+	if (pio_interrupt_get(pio0, 0)) {
+		DEBUG("RX ERR");
+		pio_interrupt_clear(pio0, 0);
+	}
+
+	//DEBUG("UART IRQ");
+	// while (!pio_sm_is_rx_fifo_empty(pio0, uart_rx_sm))
+	// 	uart_rx_byte();
+	// ASSERT(1 == 0);
+
 	while (!pio_sm_is_rx_fifo_empty(pio0, uart_rx_sm)) {
-		cmd = uart_in_byte();
+		cmd = uart_rx_byte();
 		DEBUG("UART RX CMD %i\n", cmd);
 		irq_rx_cmd(cmd);
 	}
@@ -302,20 +303,22 @@ irq_rx(void)
 void
 split_init(void)
 {
-	uart_tx_init();
-	uart_rx_init();
+	uart_full_init();
+}
 
-	pio_set_irq0_source_enabled(pio0,
-		pis_sm0_rx_fifo_not_empty + uart_rx_sm, false);
-	pio_set_irq0_source_enabled(pio0,
-		pis_sm0_tx_fifo_not_full + uart_tx_sm, false);
-	pio_set_irq0_source_enabled(pio0, pis_interrupt0, false);
+void
+split_test(void)
+{
+	pio_sm_set_pins_with_mask(pio0, uart_tx_sm, 0U, 1U << UART_PIN);
+	pio_sm_set_consecutive_pindirs(pio0, uart_tx_sm, UART_PIN, 1, false);
 
-	irq_set_priority(PIO0_IRQ_0, PICO_HIGHEST_IRQ_PRIORITY);
-	irq_set_exclusive_handler(PIO0_IRQ_0, irq_rx);
-	irq_set_enabled(PIO0_IRQ_0, true);
+	pio_gpio_init(pio0, UART_PIN);
+	gpio_pull_up(UART_PIN);
+	gpio_set_slew_rate(UART_PIN, GPIO_SLEW_RATE_FAST);
 
-	uart_enter_rx();
+	/* 1 => set INPUT and pull line HIGH from pullup
+	 * 0 => set OUTPUT and pull line LOW from signal */
+	gpio_set_oeover(UART_PIN, GPIO_OVERRIDE_INVERT);
 }
 
 void
@@ -324,17 +327,20 @@ split_task(void)
 	uint32_t start_ms;
 	uint8_t cmd;
 
-	if (SPLIT_ROLE == SLAVE) {
-		if (scan_pending) {
-			scan_matrix();
-			cmd = CMD_SCAN_MATRIX_RESP;
-			ASSERT(uart_send(&cmd, 1));
-			scan_pending = false;
-		}
-	} else if (SPLIT_ROLE == MASTER) {
+	// if (!uart_await_tx())
+	// 	return;
+
+	// sleep_us(100);
+	// uart_leave_rx();
+	// uart_tx_byte(0xAA);
+	// uart_enter_rx();
+
+	// return;
+
+	if (SPLIT_ROLE == MASTER) {
 		scan_pending = true;
 		cmd = CMD_SCAN_MATRIX_REQ;
-		ASSERT(uart_send(&cmd, 1));
+		ASSERT(uart_send(&cmd, 1) == 1);
 		scan_matrix(); /* scan our side in parallel */
 		start_ms = board_millis();
 		while (scan_pending && board_millis() < start_ms + 50)
@@ -342,5 +348,16 @@ split_task(void)
 		if (scan_pending) WARN("Slave matrix scan timeout");
 		else DEBUG("Slave matrix scan success");
 		scan_pending = false;
-	}
+	} else {
+		if (!uart_await_rx())
+			return;
+		cmd = uart_rx_byte();
+		DEBUG("GOT RX: %i", cmd);
+		if (scan_pending) {
+			scan_matrix();
+			cmd = CMD_SCAN_MATRIX_RESP;
+			ASSERT(uart_send(&cmd, 1) == 1);
+			scan_pending = false;
+		}
+	} 
 }