Added split uart support based on chibios impl

16 files changed, 369 insertions, 355 deletions

diff --git a/src/board.h b/src/board.h
index 8e78a7c..f54cbe4 100644
--- a/src/board.h
+++ b/src/board.h
@@ -1,8 +1,6 @@
 #pragma once
 
-#include "neopix.h"
-
-#define ONBOARD_LED_PIN 25
+#include <stdint.h>
 
 #define REPORT_ID_MIN REPORT_ID_KEYBOARD
 enum {
@@ -12,7 +10,5 @@ enum {
 	REPORT_ID_MAX
 };
 
-extern struct neopix onboard_led;
-
 extern const uint32_t **keymap_layers;
 
diff --git a/src/led.c b/src/led.c
new file mode 100644
index 0000000..4826088
--- /dev/null
+++ b/src/led.c
@@ -0,0 +1,55 @@
+#include "led.h"
+#include "ws2812.h"
+#include "util.h"
+
+#include "bsp/board.h"
+
+#define ONBOARD_LED_PIN 25
+
+static struct ws2812 onboard_led;
+
+int led_mode;
+bool led_reset;
+uint32_t led_blink_ms;
+uint32_t led_rgb;
+
+void
+led_init(void)
+{
+	led_reset = true;
+	led_mode = LED_ON;
+	led_rgb = WS2812_U32RGB(100, 100, 100);
+	ws2812_init(&onboard_led, pio0, ONBOARD_LED_PIN);
+}
+
+void
+led_task(void)
+{
+	static uint32_t start_ms = 0;
+	static bool state = false;
+
+	switch (led_mode) {
+	case LED_OFF:
+		if (led_reset)
+			ws2812_put(&onboard_led, 0);
+		break;
+	case LED_ON:
+		if (led_reset)
+			ws2812_put(&onboard_led, led_rgb);
+		break;
+	case LED_BLINK:
+		if (led_reset)
+			start_ms = board_millis();
+
+		if (board_millis() - start_ms < led_blink_ms)
+			return;
+		start_ms += led_blink_ms;
+
+		state = !state;
+		ws2812_put(&onboard_led, state ? led_rgb : 0);
+		break;
+	}
+
+	led_reset = false;
+}
+
diff --git a/src/led.h b/src/led.h
new file mode 100644
index 0000000..aebf936
--- /dev/null
+++ b/src/led.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+enum {
+	LED_OFF,
+	LED_ON,
+	LED_BLINK
+};
+
+extern int led_mode;
+extern bool led_reset;
+extern uint32_t led_blink_ms;
+extern uint32_t led_rgb;
+
+void led_init(void);
+void led_task(void);
diff --git a/src/main.c b/src/main.c
index f6b0296..281bd9a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -2,9 +2,10 @@
 #include "usb_stdio.h"
 #include "matrix.h"
 #include "split.h"
+#include "led.h"
 #include "hid.h"
 #include "keymap.h"
-#include "neopix.h"
+#include "ws2812.h"
 #include "util.h"
 
 #include "hardware/gpio.h"
@@ -19,42 +20,26 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <sys/types.h>
-
-enum {
-	BLINK_NOT_MOUNTED = 250,
-	BLINK_MOUNTED = 1000,
-	BLINK_SUSPENDED = 2500,
-};
 
 bool send_hid_report(int id, bool state);
 
-void blink_task(void);
-
-static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
-
 static bool hit_state = false;
-
 const uint32_t **keymap_layers = keymap_layers_de;
 
-struct neopix onboard_led;
-
 int
 main(void)
 {
 	board_init();
 	tud_init(BOARD_TUD_RHPORT);
 	usb_stdio_init();
-	neopix_init(&onboard_led, ONBOARD_LED_PIN);
+	led_init();
 	matrix_init();
 	split_init();
 	//hid_init();
 
-	ASSERT(1 == 0);
-
 	while (true) {
 		tud_task();
-		blink_task();
+		led_task();
 		split_task();
 		//hid_task();
 	}
@@ -65,25 +50,34 @@ main(void)
 void
 tud_mount_cb(void)
 {
-	blink_interval_ms = BLINK_MOUNTED;
+	led_rgb = WS2812_U32RGB(100, 0, 100);
+	led_mode = LED_ON;
+	led_reset = true;
 }
 
 void
 tud_umount_cb(void)
 {
-	blink_interval_ms = BLINK_NOT_MOUNTED;
+	led_blink_ms = 500;
+	led_rgb = WS2812_U32RGB(100, 100, 100);
+	led_mode = LED_BLINK;
+	led_reset = true;
 }
 
 void
 tud_suspend_cb(bool remote_wakeup_en)
 {
-	blink_interval_ms = BLINK_SUSPENDED;
+	led_rgb = WS2812_U32RGB(100, 100, 100);
+	led_mode = LED_ON;
+	led_reset = true;
 }
 
 void
 tud_resume_cb(void)
 {
-	blink_interval_ms = BLINK_MOUNTED;
+	led_rgb = WS2812_U32RGB(100, 0, 100);
+	led_mode = LED_ON;
+	led_reset = true;
 }
 
 void
@@ -94,6 +88,7 @@ tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 void
 tud_cdc_rx_cb(uint8_t itf)
 {
+	printf("ALIVE\n\r");
 }
 
 uint16_t
@@ -201,20 +196,3 @@ send_hid_report_timed(void)
 
 	send_hid_report(REPORT_ID_MIN, hit_state);
 }
-
-void
-blink_task(void)
-{
-	static uint32_t start_ms = 0;
-	static bool state = false;
-
-	if (board_millis() - start_ms < blink_interval_ms)
-		return;
-	start_ms += blink_interval_ms;
-
-	DEBUG("blink");
-
-	state ^= true;
-	neopix_put(&onboard_led, neopix_u32rgb(255 * state, 0, 255 * state));
-}
-
diff --git a/src/neopix.c b/src/neopix.c
deleted file mode 100644
index 028f01c..0000000
--- a/src/neopix.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "neopix.h"
-#include "ws2812.pio.h"
-#include "util.h"
-
-#include "hardware/pio.h"
-
-void
-neopix_init(struct neopix *pix, uint pin)
-{
-	uint offset;
-	int sm;
-
-	pix->pio = pio0;
-	sm = pio_claim_unused_sm(pix->pio, true);
-	ASSERT(sm >= 0);
-	pix->sm = (uint) sm;
-	pix->pin = pin;
-	offset = pio_add_program(pix->pio, &ws2812_program);
-	ws2812_program_init(pix->pio, pix->sm, offset,
-		pix->pin, 800000, false);
-	pix->init = true;
-}
-
-void
-neopix_put(struct neopix *pix, uint32_t rgb) {
-	pio_sm_put_blocking(pix->pio, pix->sm, rgb << 8u);
-}
diff --git a/src/neopix.h b/src/neopix.h
deleted file mode 100644
index 0245373..0000000
--- a/src/neopix.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "hardware/pio.h"
-#include "hardware/gpio.h"
-
-#include <stdbool.h>
-
-struct neopix {
-	PIO pio;
-	uint sm;
-	uint pin;
-	bool init;
-};
-
-void neopix_init(struct neopix *pix, uint pin);
-void neopix_put(struct neopix *pix, uint32_t rgb);
-
-inline uint32_t
-neopix_u32rgb(uint8_t r, uint8_t g, uint8_t b) {
-	uint32_t rgb;
-
-	rgb = ((uint32_t) r) << 8;
-	rgb |= ((uint32_t) g) << 16;
-	rgb |= ((uint32_t) b) << 0;
-
-	return rgb;
-}
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;
+		}
+	} 
 }
diff --git a/src/split.h b/src/split.h
index 420b93d..ff845c3 100644
--- a/src/split.h
+++ b/src/split.h
@@ -1,4 +1,5 @@
 #pragma once
 
 void split_init(void);
+void split_test(void);
 void split_task(void);
diff --git a/src/uart_rx.pio b/src/uart_rx.pio
new file mode 100644
index 0000000..a903176
--- /dev/null
+++ b/src/uart_rx.pio
@@ -0,0 +1,22 @@
+.program uart_rx
+
+.wrap_target
+start:
+    wait    0 pin, 0                    [6]     ; wait for START bit
+
+    set     x, 7                        [4]     ; read 8 DATA bits and offset
+                                                ; clock for better readings
+bitloop:
+    in      pins, 1
+    jmp     x--, bitloop                [6]
+
+    jmp     pin, outb                           ; got STOP bit, output byte
+
+error:
+    irq     wait 0                              ; no STOP bit,
+    wait    1 pin, 0                            ; set err IRQ and await reset
+    jmp start
+
+outb:
+    push    block
+.wrap
diff --git a/src/uart_tx.pio b/src/uart_tx.pio
new file mode 100644
index 0000000..61d2e1a
--- /dev/null
+++ b/src/uart_tx.pio
@@ -0,0 +1,10 @@
+.program uart_tx
+.side_set 1 opt pindirs
+
+.wrap_target
+    pull    block           side 1      [7]     ; IDLE / STOP bit
+    set     x, 7            side 0      [7]     ; START bit
+bitloop:
+    out     pindirs, 1                          ; 8 DATA bits
+    jmp     x--, bitloop                [6]
+.wrap
diff --git a/src/util.c b/src/util.c
index 187c477..503105a 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,7 +1,9 @@
 #include "util.h"
 #include "board.h"
-#include "neopix.h"
+#include "led.h"
+#include "ws2812.h"
 
+#include "pico/stdio.h"
 #include "tusb.h"
 #include "bsp/board.h"
 #include "tusb_config.h"
@@ -28,27 +30,11 @@ panic_task(const char *fmtstr, va_list ap, uint32_t sleep_ms)
 	va_copy(cpy, ap);
 	vprintf(fmtstr, cpy);
 	printf("\n\r");
+	stdio_flush();
 
 	start_ms += sleep_ms;
 }
 
-static void
-blink_task(struct neopix *pix, uint32_t blink_ms)
-{
-	static uint32_t start_ms = 0;
-	static bool led_state = false;
-
-	if (!start_ms) start_ms = board_millis();
-
-	if (board_millis() < start_ms + blink_ms)
-		return;
-
-	neopix_put(pix, neopix_u32rgb(255 * led_state, 0, 0));
-	led_state ^= true;
-
-	start_ms += blink_ms;
-}
-
 void
 __attribute__ ((format (printf, 2, 3)))
 stdio_log(int level, const char *fmtstr, ...)
@@ -65,21 +51,25 @@ stdio_log(int level, const char *fmtstr, ...)
 	vprintf(fmtstr, ap);
 	va_end(ap);
 	printf("\n\r");
+	stdio_flush();
 }
 
 void
-__attribute__((format(printf, 1, 2)))
-blink_panic(const char *fmtstr, ...)
+__attribute__((format(printf, 3, 4)))
+blink_panic(uint32_t blink_ms, uint32_t rgb, const char *fmtstr, ...)
 {
 	va_list ap;
 
 	va_start(ap, fmtstr);
 
+	led_blink_ms = blink_ms;
+	led_rgb = rgb;
+	led_mode = LED_BLINK;
+
 	while (1) {
 		tud_task();
 		panic_task(fmtstr, ap, 1000);
-		if (onboard_led.init)
-			blink_task(&onboard_led, 200);
+		led_task();
 	}
 
 	va_end(ap);
diff --git a/src/util.h b/src/util.h
index 9844360..8b33e2c 100644
--- a/src/util.h
+++ b/src/util.h
@@ -1,6 +1,9 @@
 #pragma once
 
+#include "ws2812.h"
+
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdarg.h>
 
 #define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))
@@ -10,12 +13,17 @@
 #define INFO(...) stdio_log(LOG_INFO, "INFO : " __VA_ARGS__)
 #define DEBUG(...) stdio_log(LOG_DEBUG, "DEBUG: " __VA_ARGS__)
 
-#define PANIC(...) blink_panic(__VA_ARGS__);
+#define PANIC(...) blink_panic(200, WS2812_U32RGB(255, 0, 0), __VA_ARGS__);
 #define ASSERT(cond) do { \
-		if (!(cond)) blink_panic("Assertion failed: (%s) in %s:%i", \
+		if (!(cond)) PANIC("Assertion failed: (%s) in %s:%i", \
 			#cond, __FILE__, __LINE__); \
 	} while (0)
 
+#define CLAIM_UNUSED_SM(pio) ({ \
+	int tmp = pio_claim_unused_sm(pio, false); \
+	ASSERT(tmp >= 0); \
+	(uint) tmp; })
+
 enum {
 	LOG_NONE,
 	LOG_ERR,
@@ -26,6 +34,6 @@ enum {
 
 void stdio_log(int loglevel, const char *fmtstr, ...);
 
-void blink_panic(const char *fmtstr, ...);
+void blink_panic(uint32_t blink_ms, uint32_t rgb, const char *fmtstr, ...);
 
 extern int loglevel;
diff --git a/src/ws2812.c b/src/ws2812.c
new file mode 100644
index 0000000..4140fd6
--- /dev/null
+++ b/src/ws2812.c
@@ -0,0 +1,43 @@
+#include "ws2812.h"
+#include "ws2812.pio.h"
+#include "util.h"
+
+#include "hardware/pio.h"
+#include "hardware/clocks.h"
+
+#define CYCLES_PER_BIT (ws2812_T1 + ws2812_T2 + ws2812_T3)
+
+void
+ws2812_init(struct ws2812 *pix, PIO pio, uint pin)
+{
+	pio_sm_config config;
+	uint offset;
+	uint sm;
+
+	pix->pio = pio;
+	pix->pin = pin;
+
+	sm = CLAIM_UNUSED_SM(pio);
+	pix->sm = sm;
+
+	pio_gpio_init(pio, pin);
+	pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true);
+
+	offset = pio_add_program(pix->pio, &ws2812_program);
+	config = ws2812_program_get_default_config(offset);
+	sm_config_set_sideset_pins(&config, pin);
+	sm_config_set_out_shift(&config, false, true, 24);
+	sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_TX);
+	sm_config_set_clkdiv(&config,
+		(float) clock_get_hz(clk_sys) / (800000 * CYCLES_PER_BIT));
+
+	pio_sm_init(pio, sm, offset, &config);
+	pio_sm_set_enabled(pio, sm, true);
+
+	pix->init = true;
+}
+
+void
+ws2812_put(struct ws2812 *pix, uint32_t rgb) {
+	pio_sm_put_blocking(pix->pio, pix->sm, rgb << 8u);
+}
diff --git a/src/ws2812.h b/src/ws2812.h
new file mode 100644
index 0000000..3a0cf5c
--- /dev/null
+++ b/src/ws2812.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "hardware/pio.h"
+#include "hardware/gpio.h"
+
+#include <stdbool.h>
+
+#define _WS2812_U8(v, s) (((uint32_t) (v) & 0xFF) << s)
+#define WS2812_U32RGB(r, g, b) \
+	(_WS2812_U8(b, 0) | _WS2812_U8(r, 8) | _WS2812_U8(g, 16))
+
+struct ws2812 {
+	PIO pio;
+	uint sm;
+	uint pin;
+	bool init;
+};
+
+void ws2812_init(struct ws2812 *pix, PIO pio, uint pin);
+void ws2812_put(struct ws2812 *pix, uint32_t rgb);
diff --git a/src/ws2812.pio b/src/ws2812.pio
index ae19a6b..45d646a 100644
--- a/src/ws2812.pio
+++ b/src/ws2812.pio
@@ -1,9 +1,3 @@
-;
-; Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
-;
-; SPDX-License-Identifier: BSD-3-Clause
-;
-
 .program ws2812
 .side_set 1
 
@@ -11,10 +5,6 @@
 .define public T2 5
 .define public T3 3
 
-.lang_opt python sideset_init = pico.PIO.OUT_HIGH
-.lang_opt python out_init     = pico.PIO.OUT_HIGH
-.lang_opt python out_shiftdir = 1
-
 .wrap_target
 bitloop:
     out x, 1       side 0 [T3 - 1] ; Side-set still takes place when instruction stalls
@@ -24,25 +14,3 @@ do_one:
 do_zero:
     nop            side 0 [T2 - 1] ; Or drive low, for a short pulse
 .wrap
-
-% c-sdk {
-#include "hardware/clocks.h"
-
-static inline void ws2812_program_init(PIO pio, uint sm, uint offset, uint pin, float freq, bool rgbw) {
-
-    pio_gpio_init(pio, pin);
-    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true);
-
-    pio_sm_config c = ws2812_program_get_default_config(offset);
-    sm_config_set_sideset_pins(&c, pin);
-    sm_config_set_out_shift(&c, false, true, rgbw ? 32 : 24);
-    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
-
-    int cycles_per_bit = ws2812_T1 + ws2812_T2 + ws2812_T3;
-    float div = clock_get_hz(clk_sys) / (freq * cycles_per_bit);
-    sm_config_set_clkdiv(&c, div);
-
-    pio_sm_init(pio, sm, offset, &c);
-    pio_sm_set_enabled(pio, sm, true);
-}
-%}
diff --git a/src/ws2812.pio.h b/src/ws2812.pio.h
deleted file mode 100644
index e95f7ea..0000000
--- a/src/ws2812.pio.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// -------------------------------------------------- //
-// This file is autogenerated by pioasm; do not edit! //
-// -------------------------------------------------- //
-
-#if !PICO_NO_HARDWARE
-#include "hardware/pio.h"
-#endif
-
-// ------ //
-// ws2812 //
-// ------ //
-
-#define ws2812_wrap_target 0
-#define ws2812_wrap 3
-
-#define ws2812_T1 2
-#define ws2812_T2 5
-#define ws2812_T3 3
-
-static const uint16_t ws2812_program_instructions[] = {
-            //     .wrap_target
-    0x6221, //  0: out    x, 1            side 0 [2] 
-    0x1123, //  1: jmp    !x, 3           side 1 [1] 
-    0x1400, //  2: jmp    0               side 1 [4] 
-    0xa442, //  3: nop                    side 0 [4] 
-            //     .wrap
-};
-
-#if !PICO_NO_HARDWARE
-static const struct pio_program ws2812_program = {
-    .instructions = ws2812_program_instructions,
-    .length = 4,
-    .origin = -1,
-};
-
-static inline pio_sm_config ws2812_program_get_default_config(uint offset) {
-    pio_sm_config c = pio_get_default_sm_config();
-    sm_config_set_wrap(&c, offset + ws2812_wrap_target, offset + ws2812_wrap);
-    sm_config_set_sideset(&c, 1, false, false);
-    return c;
-}
-
-#include "hardware/clocks.h"
-static inline void ws2812_program_init(PIO pio, uint sm, uint offset, uint pin, float freq, bool rgbw) {
-    pio_gpio_init(pio, pin);
-    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true);
-    pio_sm_config c = ws2812_program_get_default_config(offset);
-    sm_config_set_sideset_pins(&c, pin);
-    sm_config_set_out_shift(&c, false, true, rgbw ? 32 : 24);
-    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
-    int cycles_per_bit = ws2812_T1 + ws2812_T2 + ws2812_T3;
-    float div = ((float) clock_get_hz(clk_sys)) / (freq * (float) cycles_per_bit);
-    sm_config_set_clkdiv(&c, div);
-    pio_sm_init(pio, sm, offset, &c);
-    pio_sm_set_enabled(pio, sm, true);
-}
-
-#endif