github: ci: switch to ubuntu-22.04

Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>

.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  CI:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: 'Check out code'
+        uses: actions/checkout@v4
+
+      - name: 'Install dependencies'
+        run: |
+          sudo apt-get install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi
+
+      - name: 'Update Submodules'
+        run: |
+          git submodule sync --recursive
+          git submodule update --init --recursive
+
+      - name: 'Configure'
+        run: |
+          mkdir -p build
+          cmake -B build
+
+      - name: 'Build'
+        run: |
+          make -C build
+
+      - name: 'Upload binary'
+        uses: actions/upload-artifact@v4
+        with:
+          name: pico-uart-bridge.uf2
+          path: build/uart_bridge.uf2
+          retention-days: 5

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "pico-sdk"]
 	path = pico-sdk
-	url = git@github.com:raspberrypi/pico-sdk.git
+	url = https://github.com/raspberrypi/pico-sdk.git

CMakeLists.txt

@@ -7,7 +7,7 @@ include(pico-sdk/pico_sdk_init.cmake)
 project(pico_uart_bridge)
 
 pico_sdk_init()
-  
+
 add_executable(uart_bridge uart-bridge.c usb-descriptors.c)
 
 target_include_directories(uart_bridge PUBLIC
@@ -15,6 +15,7 @@ target_include_directories(uart_bridge PUBLIC
 	pico-sdk/lib/tinyusb/src)
 
 target_link_libraries(uart_bridge
+	hardware_flash
 	pico_multicore
 	pico_stdlib
 	tinyusb_device)

README.md

@@ -13,7 +13,7 @@ Raspberry Pi Pico Pinout
 
 | Raspberry Pi Pico GPIO | Function |
 |:----------------------:|:--------:|
-| GPIO0 (Pin 1)          | UART0 TX |
-| GPIO1 (Pin 2)          | UART0 RX |
+| GPIO16 (Pin 21)        | UART0 TX |
+| GPIO17 (Pin 22)        | UART0 RX |
 | GPIO4 (Pin 6)          | UART1 TX |
 | GPIO5 (Pin 7)          | UART1 RX |

build.sh

@@ -1,15 +1,17 @@
-#!/bin/sh
+#!/bin/bash
 
-BUILD_DIR=build
+BASE_DIR="$(dirname ${BASH_SOURCE[0]})"
+BUILD_DIR=$BASE_DIR/build
+PICO_SDK_DIR=$BASE_DIR/pico-sdk
 
-main () {
-	local cur_dir=$PWD
+main() {
+	if [ ! -d "$PICO_SDK_DIR/.git" ]; then
+		git submodule sync --recursive
+		git submodule update --init --recursive
+	fi
 
-	mkdir -p $BUILD_DIR
-	cd $BUILD_DIR
-	cmake ..
-	make
-	cd $cur_dir
+	cmake -B $BUILD_DIR -S $BASE_DIR
+	make -C $BUILD_DIR
 }
 
 main $@

pico-sdk

@@ -1 +1 @@
-Subproject commit 2d5789eca89658a7f0a01e2d6010c0f254605d72
+Subproject commit 6a7db34ff63345a7badec79ebea3aaef1712f374

tusb_config.h

@@ -1,36 +1,21 @@
+// SPDX-License-Identifier: MIT
 /*
- * The MIT License (MIT)
- *
+ * Copyright (c) 2021 Álvaro Fernández Rojas <noltari@gmail.com>
  * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
  * Copyright (c) 2020 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
  */
 
-#ifndef _PICO_STDIO_USB_TUSB_CONFIG_H
-#define _PICO_STDIO_USB_TUSB_CONFIG_H
+#if !defined(_TUSB_CONFIG_H_)
+#define _TUSB_CONFIG_H_
 
-#define CFG_TUSB_RHPORT0_MODE   (OPT_MODE_DEVICE)
+#include <tusb_option.h>
 
-#define CFG_TUD_CDC             (2)
-#define CFG_TUD_CDC_RX_BUFSIZE  (256)
-#define CFG_TUD_CDC_TX_BUFSIZE  (256)
+#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE
 
-#endif
+#define CFG_TUD_CDC 2
+#define CFG_TUD_CDC_RX_BUFSIZE 1024
+#define CFG_TUD_CDC_TX_BUFSIZE 1024
+
+void usbd_serial_init(void);
+
+#endif /* _TUSB_CONFIG_H_ */

uart-bridge.c

@@ -8,6 +8,7 @@
 #include <hardware/uart.h>
 #include <pico/multicore.h>
 #include <pico/stdlib.h>
+#include <string.h>
 #include <tusb.h>
 
 #if !defined(MIN)
@@ -16,7 +17,7 @@
 
 #define LED_PIN 25
 
-#define BUFFER_SIZE 64
+#define BUFFER_SIZE 2560
 
 #define DEF_BIT_RATE 115200
 #define DEF_STOP_BITS 1
@@ -25,6 +26,8 @@
 
 typedef struct {
 	uart_inst_t *const inst;
+	uint irq;
+	void *irq_fn;
 	uint8_t tx_pin;
 	uint8_t rx_pin;
 } uart_id_t;
@@ -32,6 +35,7 @@ typedef struct {
 typedef struct {
 	cdc_line_coding_t usb_lc;
 	cdc_line_coding_t uart_lc;
+	mutex_t lc_mtx;
 	uint8_t uart_buffer[BUFFER_SIZE];
 	uint32_t uart_pos;
 	mutex_t uart_mtx;
@@ -40,13 +44,20 @@ typedef struct {
 	mutex_t usb_mtx;
 } uart_data_t;
 
+void uart0_irq_fn(void);
+void uart1_irq_fn(void);
+
 const uart_id_t UART_ID[CFG_TUD_CDC] = {
 	{
 		.inst = uart0,
-		.tx_pin = 0,
-		.rx_pin = 1,
+		.irq = UART0_IRQ,
+		.irq_fn = &uart0_irq_fn,
+		.tx_pin = 16,
+		.rx_pin = 17,
 	}, {
 		.inst = uart1,
+		.irq = UART1_IRQ,
+		.irq_fn = &uart1_irq_fn,
 		.tx_pin = 4,
 		.rx_pin = 5,
 	}
@@ -95,6 +106,8 @@ void update_uart_cfg(uint8_t itf)
 	const uart_id_t *ui = &UART_ID[itf];
 	uart_data_t *ud = &UART_DATA[itf];
 
+	mutex_enter_blocking(&ud->lc_mtx);
+
 	if (ud->usb_lc.bit_rate != ud->uart_lc.bit_rate) {
 		uart_set_baudrate(ui->inst, ud->usb_lc.bit_rate);
 		ud->uart_lc.bit_rate = ud->usb_lc.bit_rate;
@@ -111,21 +124,22 @@ void update_uart_cfg(uint8_t itf)
 		ud->uart_lc.parity = ud->usb_lc.parity;
 		ud->uart_lc.stop_bits = ud->usb_lc.stop_bits;
 	}
+
+	mutex_exit(&ud->lc_mtx);
 }
 
-void usb_read_bytes(uint8_t itf) {
+void usb_read_bytes(uint8_t itf)
+{
+	uart_data_t *ud = &UART_DATA[itf];
 	uint32_t len = tud_cdc_n_available(itf);
 
-	if (len) {
-		uart_data_t *ud = &UART_DATA[itf];
-
-		mutex_enter_blocking(&ud->usb_mtx);
-
+	if (len &&
+	    mutex_try_enter(&ud->usb_mtx, NULL)) {
 		len = MIN(len, BUFFER_SIZE - ud->usb_pos);
 		if (len) {
 			uint32_t count;
 
-			count = tud_cdc_n_read(itf, ud->usb_buffer, len);
+			count = tud_cdc_n_read(itf, &ud->usb_buffer[ud->usb_pos], len);
 			ud->usb_pos += count;
 		}
 
@@ -133,30 +147,35 @@ void usb_read_bytes(uint8_t itf) {
 	}
 }
 
-void usb_write_bytes(uint8_t itf) {
+void usb_write_bytes(uint8_t itf)
+{
 	uart_data_t *ud = &UART_DATA[itf];
 
-	if (ud->uart_pos) {
+	if (ud->uart_pos &&
+	    mutex_try_enter(&ud->uart_mtx, NULL)) {
 		uint32_t count;
 
-		mutex_enter_blocking(&ud->uart_mtx);
-
 		count = tud_cdc_n_write(itf, ud->uart_buffer, ud->uart_pos);
-		if (count) {
-			ud->uart_pos -= count;
-			tud_cdc_n_write_flush(itf);
-		}
+		if (count < ud->uart_pos)
+			memmove(ud->uart_buffer, &ud->uart_buffer[count],
+			       ud->uart_pos - count);
+		ud->uart_pos -= count;
 
 		mutex_exit(&ud->uart_mtx);
+
+		if (count)
+			tud_cdc_n_write_flush(itf);
 	}
 }
 
 void usb_cdc_process(uint8_t itf)
 {
 	uart_data_t *ud = &UART_DATA[itf];
-	int con = tud_cdc_n_connected(itf);
 
+	mutex_enter_blocking(&ud->lc_mtx);
 	tud_cdc_n_get_line_coding(itf, &ud->usb_lc);
+	mutex_exit(&ud->lc_mtx);
+
 	usb_read_bytes(itf);
 	usb_write_bytes(itf);
 }
@@ -170,7 +189,7 @@ void core1_entry(void)
 		int con = 0;
 
 		tud_task();
-	
+
 		for (itf = 0; itf < CFG_TUD_CDC; itf++) {
 			if (tud_cdc_n_connected(itf)) {
 				con = 1;
@@ -182,16 +201,16 @@ void core1_entry(void)
 	}
 }
 
-void uart_read_bytes(uint8_t itf) {
+static inline void uart_read_bytes(uint8_t itf)
+{
+	uart_data_t *ud = &UART_DATA[itf];
 	const uart_id_t *ui = &UART_ID[itf];
 
 	if (uart_is_readable(ui->inst)) {
-		uart_data_t *ud = &UART_DATA[itf];
-
 		mutex_enter_blocking(&ud->uart_mtx);
 
 		while (uart_is_readable(ui->inst) &&
-			ud->uart_pos < BUFFER_SIZE) {
+		       (ud->uart_pos < BUFFER_SIZE)) {
 			ud->uart_buffer[ud->uart_pos] = uart_getc(ui->inst);
 			ud->uart_pos++;
 		}
@@ -200,22 +219,42 @@ void uart_read_bytes(uint8_t itf) {
 	}
 }
 
-void uart_write_bytes(uint8_t itf) {
+void uart0_irq_fn(void)
+{
+	uart_read_bytes(0);
+}
+
+void uart1_irq_fn(void)
+{
+	uart_read_bytes(1);
+}
+
+void uart_write_bytes(uint8_t itf)
+{
 	uart_data_t *ud = &UART_DATA[itf];
 
-	if (ud->usb_pos) {
+	if (ud->usb_pos &&
+	    mutex_try_enter(&ud->usb_mtx, NULL)) {
 		const uart_id_t *ui = &UART_ID[itf];
+		uint32_t count = 0;
 
-		mutex_enter_blocking(&ud->usb_mtx);
+		while (uart_is_writable(ui->inst) &&
+		       count < ud->usb_pos) {
+			uart_putc_raw(ui->inst, ud->usb_buffer[count]);
+			count++;
+		}
 
-		uart_write_blocking(ui->inst, ud->usb_buffer, ud->usb_pos);
-		ud->usb_pos = 0;
+		if (count < ud->usb_pos)
+			memmove(ud->usb_buffer, &ud->usb_buffer[count],
+			       ud->usb_pos - count);
+		ud->usb_pos -= count;
 
 		mutex_exit(&ud->usb_mtx);
 	}
 }
 
-void init_uart_data(uint8_t itf) {
+void init_uart_data(uint8_t itf)
+{
 	const uart_id_t *ui = &UART_ID[itf];
 	uart_data_t *ud = &UART_DATA[itf];
 
@@ -240,6 +279,7 @@ void init_uart_data(uint8_t itf) {
 	ud->usb_pos = 0;
 
 	/* Mutex */
+	mutex_init(&ud->lc_mtx);
 	mutex_init(&ud->uart_mtx);
 	mutex_init(&ud->usb_mtx);
 
@@ -249,14 +289,20 @@ void init_uart_data(uint8_t itf) {
 	uart_set_format(ui->inst, databits_usb2uart(ud->usb_lc.data_bits),
 			stopbits_usb2uart(ud->usb_lc.stop_bits),
 			parity_usb2uart(ud->usb_lc.parity));
+	uart_set_fifo_enabled(ui->inst, false);
+
+	/* UART RX Interrupt */
+	irq_set_exclusive_handler(ui->irq, ui->irq_fn);
+	irq_set_enabled(ui->irq, true);
+	uart_set_irq_enables(ui->inst, true, false);
 }
 
 int main(void)
 {
-	uint8_t ch;
-	int rc;
 	int itf;
 
+	usbd_serial_init();
+
 	for (itf = 0; itf < CFG_TUD_CDC; itf++)
 		init_uart_data(itf);
 
@@ -268,7 +314,6 @@ int main(void)
 	while (1) {
 		for (itf = 0; itf < CFG_TUD_CDC; itf++) {
 			update_uart_cfg(itf);
-			uart_read_bytes(itf);
 			uart_write_bytes(itf);
 		}
 	}

usb-descriptors.c

@@ -1,135 +1,128 @@
+// SPDX-License-Identifier: MIT
 /*
+ * Copyright (c) 2021 Álvaro Fernández Rojas <noltari@gmail.com>
+ *
  * This file is based on a file originally part of the
  * MicroPython project, http://micropython.org/
  *
- * The MIT License (MIT)
- *
  * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
  * Copyright (c) 2019 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
  */
 
-#include "tusb.h"
+#include <hardware/flash.h>
+#include <tusb.h>
 
-#define USBD_VID (0x2E8A) // Raspberry Pi
-#define USBD_PID (0x000a) // Raspberry Pi Pico SDK CDC
+#define DESC_STR_MAX 20
+
+#define USBD_VID 0x2E8A /* Raspberry Pi */
+#define USBD_PID 0x000A /* Raspberry Pi Pico SDK CDC */
 
 #define USBD_DESC_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN * CFG_TUD_CDC)
-#define USBD_MAX_POWER_MA (250)
+#define USBD_MAX_POWER_MA 500
 
-enum
-{
-  ITF_NUM_CDC_0 = 0,
-  ITF_NUM_CDC_0_DATA,
-  ITF_NUM_CDC_1,
-  ITF_NUM_CDC_1_DATA,
-  ITF_NUM_TOTAL
-};
+#define USBD_ITF_CDC_0 0
+#define USBD_ITF_CDC_1 2
+#define USBD_ITF_MAX 4
 
-#define USBD_ITF_CDC (0) // needs 2 interfaces
-#define USBD_ITF_MAX (2)
+#define USBD_CDC_0_EP_CMD 0x81
+#define USBD_CDC_1_EP_CMD 0x83
 
-#define USBD_CDC_EP_CMD (0x81)
-#define USBD_CDC_EP_OUT (0x02)
-#define USBD_CDC_EP_IN (0x82)
-#define USBD_CDC_CMD_MAX_SIZE (8)
-#define USBD_CDC_IN_OUT_MAX_SIZE (64)
+#define USBD_CDC_0_EP_OUT 0x01
+#define USBD_CDC_1_EP_OUT 0x03
 
-#define USBD_STR_0 (0x00)
-#define USBD_STR_MANUF (0x01)
-#define USBD_STR_PRODUCT (0x02)
-#define USBD_STR_SERIAL (0x03)
-#define USBD_STR_CDC (0x04)
+#define USBD_CDC_0_EP_IN 0x82
+#define USBD_CDC_1_EP_IN 0x84
 
-#define EPNUM_CDC_0_NOTIF (0x81)
-#define EPNUM_CDC_0_DATA (0x02)
+#define USBD_CDC_CMD_MAX_SIZE 8
+#define USBD_CDC_IN_OUT_MAX_SIZE 64
 
-#define EPNUM_CDC_1_NOTIF (0x84)
-#define EPNUM_CDC_1_DATA (0x05)
-
-// Note: descriptors returned from callbacks must exist long enough for transfer to complete
+#define USBD_STR_0 0x00
+#define USBD_STR_MANUF 0x01
+#define USBD_STR_PRODUCT 0x02
+#define USBD_STR_SERIAL 0x03
+#define USBD_STR_SERIAL_LEN 17
+#define USBD_STR_CDC 0x04
 
 static const tusb_desc_device_t usbd_desc_device = {
-    .bLength = sizeof(tusb_desc_device_t),
-    .bDescriptorType = TUSB_DESC_DEVICE,
-    .bcdUSB = 0x0200,
-    .bDeviceClass = TUSB_CLASS_MISC,
-    .bDeviceSubClass = MISC_SUBCLASS_COMMON,
-    .bDeviceProtocol = MISC_PROTOCOL_IAD,
-    .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
-    .idVendor = USBD_VID,
-    .idProduct = USBD_PID,
-    .bcdDevice = 0x0100,
-    .iManufacturer = USBD_STR_MANUF,
-    .iProduct = USBD_STR_PRODUCT,
-    .iSerialNumber = USBD_STR_SERIAL,
-    .bNumConfigurations = 1,
+	.bLength = sizeof(tusb_desc_device_t),
+	.bDescriptorType = TUSB_DESC_DEVICE,
+	.bcdUSB = 0x0200,
+	.bDeviceClass = TUSB_CLASS_MISC,
+	.bDeviceSubClass = MISC_SUBCLASS_COMMON,
+	.bDeviceProtocol = MISC_PROTOCOL_IAD,
+	.bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
+	.idVendor = USBD_VID,
+	.idProduct = USBD_PID,
+	.bcdDevice = 0x0100,
+	.iManufacturer = USBD_STR_MANUF,
+	.iProduct = USBD_STR_PRODUCT,
+	.iSerialNumber = USBD_STR_SERIAL,
+	.bNumConfigurations = 1,
 };
 
 static const uint8_t usbd_desc_cfg[USBD_DESC_LEN] = {
-    TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, USBD_STR_0, USBD_DESC_LEN,
-        TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
+	TUD_CONFIG_DESCRIPTOR(1, USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN,
+		TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
 
-    TUD_CDC_DESCRIPTOR(ITF_NUM_CDC_0, USBD_STR_CDC, EPNUM_CDC_0_NOTIF,
-        USBD_CDC_CMD_MAX_SIZE, EPNUM_CDC_0_DATA, 0x80 | EPNUM_CDC_0_DATA, USBD_CDC_IN_OUT_MAX_SIZE),
+	TUD_CDC_DESCRIPTOR(USBD_ITF_CDC_0, USBD_STR_CDC, USBD_CDC_0_EP_CMD,
+		USBD_CDC_CMD_MAX_SIZE, USBD_CDC_0_EP_OUT, USBD_CDC_0_EP_IN,
+		USBD_CDC_IN_OUT_MAX_SIZE),
 
-    TUD_CDC_DESCRIPTOR(ITF_NUM_CDC_1, USBD_STR_CDC, EPNUM_CDC_1_NOTIF,
-        USBD_CDC_CMD_MAX_SIZE, EPNUM_CDC_1_DATA, 0x80 | EPNUM_CDC_1_DATA, USBD_CDC_IN_OUT_MAX_SIZE),
+	TUD_CDC_DESCRIPTOR(USBD_ITF_CDC_1, USBD_STR_CDC, USBD_CDC_1_EP_CMD,
+		USBD_CDC_CMD_MAX_SIZE, USBD_CDC_1_EP_OUT, USBD_CDC_1_EP_IN,
+		USBD_CDC_IN_OUT_MAX_SIZE),
 };
 
+static char usbd_serial[USBD_STR_SERIAL_LEN] = "000000000000";
+
 static const char *const usbd_desc_str[] = {
-    [USBD_STR_MANUF] = "Raspberry Pi",
-    [USBD_STR_PRODUCT] = "Pico",
-    [USBD_STR_SERIAL] = "000000000000", // TODO
-    [USBD_STR_CDC] = "Board CDC",
+	[USBD_STR_MANUF] = "Raspberry Pi",
+	[USBD_STR_PRODUCT] = "Pico",
+	[USBD_STR_SERIAL] = usbd_serial,
+	[USBD_STR_CDC] = "Board CDC",
 };
 
-const uint8_t *tud_descriptor_device_cb(void) {
-    return (const uint8_t *)&usbd_desc_device;
+const uint8_t *tud_descriptor_device_cb(void)
+{
+	return (const uint8_t *) &usbd_desc_device;
 }
 
-const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
-    (void)index;
-    return usbd_desc_cfg;
+const uint8_t *tud_descriptor_configuration_cb(uint8_t index)
+{
+	return usbd_desc_cfg;
 }
 
-const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
-    #define DESC_STR_MAX (20)
-    static uint16_t desc_str[DESC_STR_MAX];
+const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
+{
+	static uint16_t desc_str[DESC_STR_MAX];
+	uint8_t len;
 
-    uint8_t len;
-    if (index == 0) {
-        desc_str[1] = 0x0409; // supported language is English
-        len = 1;
-    } else {
-        if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0])) {
-            return NULL;
-        }
-        const char *str = usbd_desc_str[index];
-        for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len) {
-            desc_str[1 + len] = str[len];
-        }
-    }
+	if (index == 0) {
+		desc_str[1] = 0x0409;
+		len = 1;
+	} else {
+		const char *str;
+		char serial[USBD_STR_SERIAL_LEN];
 
-    // first byte is length (including header), second byte is string type
-    desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * len + 2);
+		if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0]))
+			return NULL;
 
-    return desc_str;
+		str = usbd_desc_str[index];
+		for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len)
+			desc_str[1 + len] = str[len];
+	}
+
+	desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * len + 2);
+
+	return desc_str;
+}
+
+void usbd_serial_init(void)
+{
+	uint8_t id[8];
+
+	flash_get_unique_id(id);
+
+	snprintf(usbd_serial, USBD_STR_SERIAL_LEN, "%02X%02X%02X%02X%02X%02X%02X%02X",
+		 id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7]);
 }