blinky/src/usb_cdc_module.c

#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include <app_event_manager.h>

#define MODULE usb_cdc_module
#include <caf/events/module_state_event.h>
#include <caf/events/power_event.h>

#include <zephyr/device.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/ring_buffer.h>
#include <zephyr/sys/util.h>

#include "proto_rx_event.h"
#include "proto_transport_state_event.h"
#include "proto_tx_event.h"
#include "usb_control_event.h"
#include "usb_state_event.h"

LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);

#define USB_CDC_RX_RING_BUF_SIZE 256
#define USB_CDC_TX_RING_BUF_SIZE 256
#define USB_CDC_RX_CHUNK_SIZE 32
#define USB_CDC_PROTO_RX_BUF_SIZE 128
#define USB_CDC_PROTO_RX_FLUSH_DELAY K_MSEC(3)
#define USB_CDC_EXPECTED_BAUDRATE 115200U

enum usb_cdc_business_state {
	USB_CDC_BUS_OFFLINE = 0,
	USB_CDC_WAIT_DTR,
	USB_CDC_SESSION_READY,
};

struct usb_cdc_ctx {
	enum module_state lifecycle;
	enum usb_cdc_business_state business;
	bool usb_active;
	size_t proto_rx_len;
};

static const struct device *const cdc_dev = DEVICE_DT_GET_ONE(zephyr_cdc_acm_uart);

static uint8_t rx_ring_buffer[USB_CDC_RX_RING_BUF_SIZE];
static uint8_t tx_ring_buffer[USB_CDC_TX_RING_BUF_SIZE];
static struct ring_buf rx_ringbuf;
static struct ring_buf tx_ringbuf;
static struct k_work rx_work;
static struct k_work_delayable rx_flush_work;
static uint8_t proto_rx_buf[USB_CDC_PROTO_RX_BUF_SIZE];
static struct usb_cdc_ctx ctx = {
	.lifecycle = MODULE_STATE_OFF,
	.business = USB_CDC_BUS_OFFLINE,
	.usb_active = false,
	.proto_rx_len = 0U,
};

static void validate_line_coding(void);

static bool lifecycle_is_ready(void)
{
	return ctx.lifecycle == MODULE_STATE_READY;
}

static enum proto_transport_link_state transport_link_state_get(void)
{
	return (lifecycle_is_ready() &&
		(ctx.business == USB_CDC_SESSION_READY)) ?
		       PROTO_TRANSPORT_LINK_READY :
		       PROTO_TRANSPORT_LINK_DOWN;
}

static bool control_poll_needed(enum module_state lifecycle,
				enum usb_cdc_business_state business)
{
	ARG_UNUSED(lifecycle);
	ARG_UNUSED(business);
	return false;
}

static void reset_ring_buffers(void)
{
	unsigned int key = irq_lock();

	ring_buf_init(&rx_ringbuf, sizeof(rx_ring_buffer), rx_ring_buffer);
	ring_buf_init(&tx_ringbuf, sizeof(tx_ring_buffer), tx_ring_buffer);

	irq_unlock(key);
}

static void disable_uart_io(void)
{
	uart_irq_rx_disable(cdc_dev);
	uart_irq_tx_disable(cdc_dev);
	ctx.proto_rx_len = 0U;
	k_work_cancel_delayable(&rx_flush_work);
	reset_ring_buffers();
}

static void state_reconcile(enum module_state old_lifecycle,
			    enum usb_cdc_business_state old_business)
{
	enum proto_transport_link_state old_link =
		((old_lifecycle == MODULE_STATE_READY) &&
		 (old_business == USB_CDC_SESSION_READY)) ?
			PROTO_TRANSPORT_LINK_READY :
			PROTO_TRANSPORT_LINK_DOWN;
	enum proto_transport_link_state new_link = transport_link_state_get();

	if ((old_lifecycle == MODULE_STATE_READY) &&
	    (old_business == USB_CDC_SESSION_READY) &&
	    (new_link == PROTO_TRANSPORT_LINK_DOWN)) {
		disable_uart_io();
	}

	if ((old_link == PROTO_TRANSPORT_LINK_DOWN) &&
	    (new_link == PROTO_TRANSPORT_LINK_READY)) {
		int err;

		validate_line_coding();

		err = uart_line_ctrl_set(cdc_dev, UART_LINE_CTRL_DCD, 1);
		if (err) {
			LOG_WRN("Failed to set DCD (%d)", err);
		}

		err = uart_line_ctrl_set(cdc_dev, UART_LINE_CTRL_DSR, 1);
		if (err) {
			LOG_WRN("Failed to set DSR (%d)", err);
		}

		uart_irq_rx_enable(cdc_dev);
	}

	if (old_link != new_link) {
		submit_proto_transport_state_event(PROTO_TRANSPORT_USB_CDC,
						   new_link);
	}
}

static void lifecycle_set(enum module_state new_state)
{
	enum module_state old_lifecycle = ctx.lifecycle;
	enum usb_cdc_business_state old_business = ctx.business;

	if (ctx.lifecycle == new_state) {
		return;
	}

	ctx.lifecycle = new_state;
	state_reconcile(old_lifecycle, old_business);
	module_set_state(new_state);
}

static void business_state_set(enum usb_cdc_business_state new_state)
{
	enum module_state old_lifecycle = ctx.lifecycle;
	enum usb_cdc_business_state old_business = ctx.business;

	if (ctx.business == new_state) {
		return;
	}

	ctx.business = new_state;
	state_reconcile(old_lifecycle, old_business);
}

static void business_state_sync_from_usb(void)
{
	if (!ctx.usb_active) {
		business_state_set(USB_CDC_BUS_OFFLINE);
		return;
	}

	if (!lifecycle_is_ready()) {
		return;
	}

	if (ctx.business == USB_CDC_BUS_OFFLINE) {
		business_state_set(USB_CDC_WAIT_DTR);
	}
}

static void kick_tx(void)
{
	if (transport_link_state_get() != PROTO_TRANSPORT_LINK_READY) {
		return;
	}

	uart_irq_tx_enable(cdc_dev);
}

static void validate_line_coding(void)
{
	uint32_t baudrate = 0U;
	int err;

	err = uart_line_ctrl_get(cdc_dev, UART_LINE_CTRL_BAUD_RATE, &baudrate);
	if (err) {
		LOG_WRN("Failed to get CDC baudrate (%d)", err);
	} else {
		LOG_INF("CDC baudrate %u", baudrate);
		if (baudrate != USB_CDC_EXPECTED_BAUDRATE) {
			LOG_WRN("Expected CDC baudrate %u, got %u",
				USB_CDC_EXPECTED_BAUDRATE, baudrate);
		}
	}

#ifdef CONFIG_UART_USE_RUNTIME_CONFIGURE
	{
		struct uart_config cfg;

		err = uart_config_get(cdc_dev, &cfg);
		if (err) {
			LOG_WRN("uart_config_get failed (%d)", err);
		} else {
			LOG_INF("CDC line coding data:%u stop:%u parity:%u flow:%u",
				cfg.data_bits, cfg.stop_bits, cfg.parity,
				cfg.flow_ctrl);
			if ((cfg.data_bits != UART_CFG_DATA_BITS_8) ||
			    (cfg.stop_bits != UART_CFG_STOP_BITS_1) ||
			    (cfg.parity != UART_CFG_PARITY_NONE) ||
			    (cfg.flow_ctrl != UART_CFG_FLOW_CTRL_NONE)) {
				LOG_WRN("Expected CDC line coding 115200 8N1 no flow control");
			}
		}
	}
#endif
}

static void rx_work_handler(struct k_work *work)
{
	uint8_t buffer[USB_CDC_RX_CHUNK_SIZE];

	ARG_UNUSED(work);

	while (true) {
		uint32_t len;
		unsigned int key = irq_lock();

		len = ring_buf_get(&rx_ringbuf, buffer, sizeof(buffer));
		irq_unlock(key);

		if (len == 0U) {
			return;
		}

		if ((ctx.proto_rx_len + len) > sizeof(proto_rx_buf)) {
			LOG_WRN("Drop oversized CDC protobuf message len:%u",
				(uint32_t)(ctx.proto_rx_len + len));
			ctx.proto_rx_len = 0U;
		}

		if (len > 0U) {
			memcpy(&proto_rx_buf[ctx.proto_rx_len], buffer, len);
			ctx.proto_rx_len += len;
			k_work_reschedule(&rx_flush_work, USB_CDC_PROTO_RX_FLUSH_DELAY);
		}
	}
}

static void rx_flush_work_handler(struct k_work *work)
{
	ARG_UNUSED(work);

	if ((transport_link_state_get() != PROTO_TRANSPORT_LINK_READY) ||
	    (ctx.proto_rx_len == 0U)) {
		return;
	}

	(void)submit_proto_rx_event(PROTO_TRANSPORT_USB_CDC, proto_rx_buf,
				    ctx.proto_rx_len);
	ctx.proto_rx_len = 0U;
}

static void cdc_interrupt_handler(const struct device *dev, void *user_data)
{
	ARG_UNUSED(user_data);

	while (uart_irq_update(dev) && uart_irq_is_pending(dev)) {
		if (uart_irq_rx_ready(dev)) {
			uint8_t buffer[USB_CDC_RX_CHUNK_SIZE];
			int recv_len = uart_fifo_read(dev, buffer, sizeof(buffer));

			if (recv_len < 0) {
				LOG_ERR("Failed to read CDC RX FIFO");
				continue;
			}

			if (recv_len > 0) {
				uint32_t written;
				unsigned int key = irq_lock();

				written = ring_buf_put(&rx_ringbuf, buffer,
						       (uint32_t)recv_len);
				irq_unlock(key);

				if (written < (uint32_t)recv_len) {
					LOG_WRN("Drop %d CDC RX bytes",
						recv_len - (int)written);
				}

				k_work_submit(&rx_work);
			}
		}

		if (uart_irq_tx_ready(dev)) {
			uint8_t buffer[USB_CDC_RX_CHUNK_SIZE];
			uint32_t len;
			int sent_len;
			unsigned int key = irq_lock();

			len = ring_buf_get(&tx_ringbuf, buffer, sizeof(buffer));
			irq_unlock(key);

			if (len == 0U) {
				uart_irq_tx_disable(dev);
				continue;
			}

			sent_len = uart_fifo_fill(dev, buffer, len);
			if (sent_len < 0) {
				LOG_ERR("Failed to write CDC TX FIFO");
				uart_irq_tx_disable(dev);
			} else if ((uint32_t)sent_len < len) {
				LOG_WRN("Drop %u CDC TX bytes",
					(unsigned int)(len - (uint32_t)sent_len));
			}
		}
	}
}

static int module_init(void)
{
	if (!device_is_ready(cdc_dev)) {
		LOG_ERR("CDC ACM device not ready");
		return -ENODEV;
	}

	reset_ring_buffers();
	k_work_init(&rx_work, rx_work_handler);
	k_work_init_delayable(&rx_flush_work, rx_flush_work_handler);
	uart_irq_callback_set(cdc_dev, cdc_interrupt_handler);
	ctx = (struct usb_cdc_ctx) {
		.lifecycle = MODULE_STATE_OFF,
		.business = USB_CDC_BUS_OFFLINE,
		.usb_active = false,
		.proto_rx_len = 0U,
	};

	return 0;
}

static void module_start(void)
{
	lifecycle_set(MODULE_STATE_READY);
	business_state_sync_from_usb();
}

static void module_pause(void)
{
	business_state_set(USB_CDC_BUS_OFFLINE);
	lifecycle_set(MODULE_STATE_STANDBY);
}

static bool handle_usb_state_event(const struct usb_state_event *event)
{
	bool new_usb_active = (event->state == USB_STATE_ACTIVE);

	if (new_usb_active == ctx.usb_active) {
		return false;
	}

	ctx.usb_active = new_usb_active;
	business_state_sync_from_usb();

	return false;
}

static bool handle_usb_control_event(const struct usb_control_event *event)
{
	if (event->dev != cdc_dev) {
		return false;
	}

	switch (event->type) {
	case USB_CONTROL_EVENT_CDC_LINE_STATE:
		if (!ctx.usb_active || !lifecycle_is_ready()) {
			return false;
		}

		if (event->data.cdc_line_state.dtr) {
			LOG_INF("CDC DTR set");
			business_state_set(USB_CDC_SESSION_READY);
			kick_tx();
		} else {
			LOG_INF("CDC DTR cleared");
			business_state_set(USB_CDC_WAIT_DTR);
		}
		return false;

	case USB_CONTROL_EVENT_CDC_LINE_CODING:
		if (event->data.cdc_line_coding.baudrate != 0U) {
			LOG_INF("CDC baudrate %u",
				event->data.cdc_line_coding.baudrate);
			if (event->data.cdc_line_coding.baudrate !=
			    USB_CDC_EXPECTED_BAUDRATE) {
				LOG_WRN("Expected CDC baudrate %u, got %u",
					USB_CDC_EXPECTED_BAUDRATE,
					event->data.cdc_line_coding.baudrate);
			}
		}

#ifdef CONFIG_UART_USE_RUNTIME_CONFIGURE
		if ((event->data.cdc_line_coding.data_bits != 0U) ||
		    (event->data.cdc_line_coding.stop_bits != 0U) ||
		    (event->data.cdc_line_coding.parity != 0U) ||
		    (event->data.cdc_line_coding.flow_ctrl != 0U)) {
			LOG_INF("CDC line coding data:%u stop:%u parity:%u flow:%u",
				event->data.cdc_line_coding.data_bits,
				event->data.cdc_line_coding.stop_bits,
				event->data.cdc_line_coding.parity,
				event->data.cdc_line_coding.flow_ctrl);
		}
#endif
		return false;

	default:
		return false;
	}
}

static bool handle_proto_tx_event(const struct proto_tx_event *event)
{
	uint32_t written;
	unsigned int key;

	if (event->transport != PROTO_TRANSPORT_USB_CDC) {
		return false;
	}

	if (transport_link_state_get() != PROTO_TRANSPORT_LINK_READY) {
		return false;
	}

	key = irq_lock();
	written = ring_buf_put(&tx_ringbuf, event->dyndata.data,
			       (uint32_t)event->dyndata.size);
	irq_unlock(key);

	if (written < event->dyndata.size) {
		LOG_WRN("Drop %zu CDC TX bytes", event->dyndata.size - written);
	}

	if (written > 0U) {
		kick_tx();
	}

	return false;
}

static bool app_event_handler(const struct app_event_header *aeh)
{
	if (is_usb_state_event(aeh)) {
		return handle_usb_state_event(cast_usb_state_event(aeh));
	}

	if (is_proto_tx_event(aeh)) {
		return handle_proto_tx_event(cast_proto_tx_event(aeh));
	}

	if (is_usb_control_event(aeh)) {
		return handle_usb_control_event(cast_usb_control_event(aeh));
	}

	if (is_module_state_event(aeh)) {
		const struct module_state_event *event =
			cast_module_state_event(aeh);

		if (check_state(event, MODULE_ID(main), MODULE_STATE_READY)) {
			if (ctx.lifecycle == MODULE_STATE_OFF) {
				int err = module_init();

				if (err) {
					lifecycle_set(MODULE_STATE_ERROR);
					return false;
				}
			}

			module_start();
		}

		return false;
	}

	if (is_power_down_event(aeh)) {
		if (ctx.lifecycle != MODULE_STATE_OFF) {
			module_pause();
		}

		return false;
	}

	if (is_wake_up_event(aeh)) {
		if (ctx.lifecycle != MODULE_STATE_OFF) {
			module_start();
		}

		return false;
	}

	return false;
}

APP_EVENT_LISTENER(MODULE, app_event_handler);
APP_EVENT_SUBSCRIBE(MODULE, module_state_event);
APP_EVENT_SUBSCRIBE(MODULE, proto_tx_event);
APP_EVENT_SUBSCRIBE(MODULE, usb_control_event);
APP_EVENT_SUBSCRIBE(MODULE, usb_state_event);
APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);
APP_EVENT_SUBSCRIBE(MODULE, wake_up_event);