main: handle RP2040's broken USB error handling

RP2040-E15 can also be triggered if a Debug Probe is connected to a
board with a floating ground. Typically this causes port ESD protection
to temporarily activate, meaning the Dp/Dm state gets corrupted. If this
happens in the middle of a handshake packet, the SIE can lock up.

The only way to detect this case is if SOF_RD stops advancing without a
corresponding suspend interrupt - so add a watchdog thread that forces a
disconnect if the hardware stops reporting frame counts.

This is disruptive, but immediate notification that the probe broke is
preferable to silently failing until the next character is sent by the host.

Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>

.gitmodules

@@ -3,4 +3,4 @@
 	url = https://github.com/ARM-software/CMSIS_5
 [submodule "freertos"]
 	path = freertos
-	url = https://github.com/FreeRTOS/FreeRTOS-Kernel
+	url = https://github.com/raspberrypi/FreeRTOS-Kernel

CMakeLists.txt

@@ -3,12 +3,16 @@ cmake_minimum_required(VERSION 3.12)
 include(pico_sdk_import.cmake)
 
 set(FREERTOS_KERNEL_PATH ${CMAKE_CURRENT_LIST_DIR}/freertos)
-include(FreeRTOS_Kernel_import.cmake)
+include(freertos/portable/ThirdParty/GCC/RP2350_ARM_NTZ/FreeRTOS_Kernel_import.cmake)
 
 project(debugprobe)
 
 pico_sdk_init()
 
+if (${PICO_SDK_VERSION_MAJOR} LESS 2)
+	message(SEND_ERROR "Version 2 of the Pico SDK is required to compile this project. Please update your installation at ${PICO_SDK_PATH}")
+endif ()
+
 add_executable(debugprobe
         src/probe_config.c
         src/led.c

FreeRTOS_Kernel_import.cmake

@@ -1,61 +0,0 @@
-# This is a copy of <FREERTOS_KERNEL_PATH>/portable/ThirdParty/GCC/RP2040/FREERTOS_KERNEL_import.cmake
-
-# This can be dropped into an external project to help locate the FreeRTOS kernel
-# It should be include()ed prior to project(). Alternatively this file may
-# or the CMakeLists.txt in this directory may be included or added via add_subdirectory
-# respectively.
-
-if (DEFINED ENV{FREERTOS_KERNEL_PATH} AND (NOT FREERTOS_KERNEL_PATH))
-    set(FREERTOS_KERNEL_PATH $ENV{FREERTOS_KERNEL_PATH})
-    message("Using FREERTOS_KERNEL_PATH from environment ('${FREERTOS_KERNEL_PATH}')")
-endif ()
-
-set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "portable/ThirdParty/GCC/RP2040")
-# undo the above
-set(FREERTOS_KERNEL_RP2040_BACK_PATH "../../../..")
-
-if (NOT FREERTOS_KERNEL_PATH)
-    # check if we are inside the FreeRTOS kernel tree (i.e. this file has been included directly)
-    get_filename_component(_ACTUAL_PATH ${CMAKE_CURRENT_LIST_DIR} REALPATH)
-    get_filename_component(_POSSIBLE_PATH ${CMAKE_CURRENT_LIST_DIR}/${FREERTOS_KERNEL_RP2040_BACK_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH} REALPATH)
-    if (_ACTUAL_PATH STREQUAL _POSSIBLE_PATH)
-        get_filename_component(FREERTOS_KERNEL_PATH ${CMAKE_CURRENT_LIST_DIR}/${FREERTOS_KERNEL_RP2040_BACK_PATH} REALPATH)
-    endif()
-    if (_ACTUAL_PATH STREQUAL _POSSIBLE_PATH)
-        get_filename_component(FREERTOS_KERNEL_PATH ${CMAKE_CURRENT_LIST_DIR}/${FREERTOS_KERNEL_RP2040_BACK_PATH} REALPATH)
-        message("Setting FREERTOS_KERNEL_PATH to ${FREERTOS_KERNEL_PATH} based on location of FreeRTOS-Kernel-import.cmake")
-    elseif (PICO_SDK_PATH AND EXISTS "${PICO_SDK_PATH}/../FreeRTOS-Kernel")
-        set(FREERTOS_KERNEL_PATH ${PICO_SDK_PATH}/../FreeRTOS-Kernel)
-        message("Defaulting FREERTOS_KERNEL_PATH as sibling of PICO_SDK_PATH: ${FREERTOS_KERNEL_PATH}")
-    endif()
-endif ()
-
-if (NOT FREERTOS_KERNEL_PATH)
-    foreach(POSSIBLE_SUFFIX Source FreeRTOS-Kernel FreeRTOS/Source)
-        # check if FreeRTOS-Kernel exists under directory that included us
-        set(SEARCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
-        get_filename_component(_POSSIBLE_PATH ${SEARCH_ROOT}/${POSSIBLE_SUFFIX} REALPATH)
-        if (EXISTS ${_POSSIBLE_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/CMakeLists.txt)
-            get_filename_component(FREERTOS_KERNEL_PATH ${_POSSIBLE_PATH} REALPATH)
-            message("Setting FREERTOS_KERNEL_PATH to '${FREERTOS_KERNEL_PATH}' found relative to enclosing project")
-            break()
-        endif()
-    endforeach()
-endif()
-
-if (NOT FREERTOS_KERNEL_PATH)
-    message(FATAL_ERROR "FreeRTOS location was not specified. Please set FREERTOS_KERNEL_PATH.")
-endif()
-
-set(FREERTOS_KERNEL_PATH "${FREERTOS_KERNEL_PATH}" CACHE PATH "Path to the FreeRTOS Kernel")
-
-get_filename_component(FREERTOS_KERNEL_PATH "${FREERTOS_KERNEL_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
-if (NOT EXISTS ${FREERTOS_KERNEL_PATH})
-    message(FATAL_ERROR "Directory '${FREERTOS_KERNEL_PATH}' not found")
-endif()
-if (NOT EXISTS ${FREERTOS_KERNEL_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/CMakeLists.txt)
-    message(FATAL_ERROR "Directory '${FREERTOS_KERNEL_PATH}' does not contain an RP2040 port here: ${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}")
-endif()
-set(FREERTOS_KERNEL_PATH ${FREERTOS_KERNEL_PATH} CACHE PATH "Path to the FreeRTOS_KERNEL" FORCE)
-
-add_subdirectory(${FREERTOS_KERNEL_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH} FREERTOS_KERNEL)

README.md

@@ -47,6 +47,21 @@ This will build with the configuration for the Pico and call the output program
 
 Note that if you first ran through the whole sequence to compile for the Debug Probe, then you don't need to start back at the top. You can just go back to the `cmake` step and start from there.
 
+# Building for the Pico 2
+
+If using an existing debugprobe clone:
+- You must completely regenerate your build directory, or use a different one.
+- You must also sync and update submodules as rp2350 needs a downstream FreeRTOS port for now.
+- `PICO_SDK_PATH` must point to a version 2.0.0 or greater install.
+
+
+```
+git submodule sync
+git submodule update --init
+mkdir build-pico2
+cd build-pico2
+cmake -DDEBUG_ON_PICO=1 -DPICO_BOARD=pico2 -DPICO_PLATFORM=rp2350 ../
+```
 
 # TODO
 - AutoBaud selection, as PIO is a capable frequency counter

src/FreeRTOSConfig.h

@@ -110,6 +110,13 @@
 #define configSUPPORT_PICO_SYNC_INTEROP         1
 #define configSUPPORT_PICO_TIME_INTEROP         1
 
+/* RP2350 grows some features */
+#define configENABLE_FPU                        1
+#define configENABLE_MPU                        0
+#define configENABLE_TRUSTZONE                  0
+#define configRUN_FREERTOS_SECURE_ONLY          1
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY    16
+
 #include <assert.h>
 /* Define to trap errors during development. */
 #define configASSERT(x)                         assert(x)

src/cdc_uart.c

@@ -26,7 +26,6 @@
 #include <pico/stdlib.h>
 #include "FreeRTOS.h"
 #include "task.h"
-
 #include "tusb.h"
 
 #include "probe_config.h"
@@ -191,7 +190,8 @@ void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* line_coding)
    */
   uint32_t micros = (1000 * 1000 * 16 * 10) / MAX(line_coding->bit_rate, 1);
   /* Modifying state, so park the thread before changing it. */
-  vTaskSuspend(uart_taskhandle);
+  if (tud_cdc_connected())
+    vTaskSuspend(uart_taskhandle);
   interval = MAX(1, micros / ((1000 * 1000) / configTICK_RATE_HZ));
   debounce_ticks = MAX(1, configTICK_RATE_HZ / (interval * DEBOUNCE_MS));
   probe_info("New baud rate %ld micros %ld interval %lu\n",
@@ -245,7 +245,10 @@ void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* line_coding)
   }
 
   uart_set_format(PROBE_UART_INTERFACE, data_bits, stop_bits, parity);
-  vTaskResume(uart_taskhandle);
+  /* Windows likes to arbitrarily set/get line coding after dtr/rts changes, so
+   * don't resume if we shouldn't */
+  if(tud_cdc_connected())
+    vTaskResume(uart_taskhandle);
 }
 
 void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
@@ -259,7 +262,7 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 
   /* CDC drivers use linestate as a bodge to activate/deactivate the interface.
    * Resume our UART polling on activate, stop on deactivate */
-  if (!dtr && !rts) {
+  if (!dtr) {
     vTaskSuspend(uart_taskhandle);
 #ifdef PROBE_UART_RX_LED
     gpio_put(PROBE_UART_RX_LED, 0);

src/main.c

@@ -31,7 +31,11 @@
 #include <stdio.h>
 #include <string.h>
 
+#if PICO_SDK_VERSION_MAJOR >= 2
+#include "bsp/board_api.h"
+#else
 #include "bsp/board.h"
+#endif
 #include "tusb.h"
 
 #include "probe_config.h"
@@ -41,6 +45,7 @@
 #include "led.h"
 #include "tusb_edpt_handler.h"
 #include "DAP.h"
+#include "hardware/structs/usb.h"
 
 // UART0 for debugprobe debug
 // UART1 for debugprobe to target device
@@ -54,7 +59,36 @@ static uint8_t RxDataBuffer[CFG_TUD_HID_EP_BUFSIZE];
 #define TUD_TASK_PRIO  (tskIDLE_PRIORITY + 2)
 #define DAP_TASK_PRIO  (tskIDLE_PRIORITY + 1)
 
-TaskHandle_t dap_taskhandle, tud_taskhandle;
+TaskHandle_t dap_taskhandle, tud_taskhandle, mon_taskhandle;
+
+void dev_mon(void *ptr)
+{
+    uint32_t sof[3];
+    int i = 0;
+    TickType_t wake;
+    wake = xTaskGetTickCount();
+    do {
+        /* ~5 SOF events per tick */
+        xTaskDelayUntil(&wake, 100);
+        if (tud_connected() && !tud_suspended()) {
+            sof[i++] = usb_hw->sof_rd & USB_SOF_RD_BITS;
+            i = i % 3;
+        } else {
+            for (i = 0; i < 3; i++)
+                sof[i] = 0;
+        }
+        if ((sof[0] | sof[1] | sof[2]) != 0) {
+            if ((sof[0] == sof[1]) && (sof[1] == sof[2])) {
+                probe_info("Watchdog timeout! Resetting USBD\n");
+                /* uh oh, signal disconnect (implicitly resets the controller) */
+                tud_deinit(0);
+                /* Make sure the port got the message */
+                xTaskDelayUntil(&wake, 1);
+                tud_init(0);
+            }
+        }
+    } while (1);
+}
 
 void usb_thread(void *ptr)
 {
@@ -68,8 +102,11 @@ void usb_thread(void *ptr)
         else
             gpio_put(PROBE_USB_CONNECTED_LED, 0);
 #endif
+        // If suspended or disconnected, delay for 1ms (20 ticks)
+        if (tud_suspended() || !tud_connected())
+            xTaskDelayUntil(&wake, 20);
         // Go to sleep for up to a tick if nothing to do
-        if (!tud_task_event_ready())
+        else if (!tud_task_event_ready())
             xTaskDelayUntil(&wake, 1);
     } while (1);
 }
@@ -96,11 +133,10 @@ int main(void) {
     probe_info("Welcome to debugprobe!\n");
 
     if (THREADED) {
-        /* UART needs to preempt USB as if we don't, characters get lost */
-        xTaskCreate(cdc_thread, "UART", configMINIMAL_STACK_SIZE, NULL, UART_TASK_PRIO, &uart_taskhandle);
         xTaskCreate(usb_thread, "TUD", configMINIMAL_STACK_SIZE, NULL, TUD_TASK_PRIO, &tud_taskhandle);
-        /* Lowest priority thread is debug - need to shuffle buffers before we can toggle swd... */
-        xTaskCreate(dap_thread, "DAP", configMINIMAL_STACK_SIZE, NULL, DAP_TASK_PRIO, &dap_taskhandle);
+#if PICO_RP2040
+        xTaskCreate(dev_mon, "WDOG", configMINIMAL_STACK_SIZE, NULL, TUD_TASK_PRIO, &mon_taskhandle);
+#endif
         vTaskStartScheduler();
     }
 
@@ -184,6 +220,40 @@ bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_requ
 }
 #endif
 
+void tud_suspend_cb(bool remote_wakeup_en)
+{
+  probe_info("Suspended\n");
+  /* Join DAP and UART threads? Or just suspend them, for transparency */
+  vTaskSuspend(uart_taskhandle);
+  vTaskSuspend(dap_taskhandle);
+  /* slow down clk_sys for power saving ? */
+}
+
+void tud_resume_cb(void)
+{
+  probe_info("Resumed\n");
+  vTaskResume(uart_taskhandle);
+  vTaskResume(dap_taskhandle);
+}
+
+void tud_unmount_cb(void)
+{
+  probe_info("Disconnected\n");
+  vTaskSuspend(uart_taskhandle);
+  vTaskSuspend(dap_taskhandle);
+  vTaskDelete(uart_taskhandle);
+  vTaskDelete(dap_taskhandle);
+}
+
+void tud_mount_cb(void)
+{
+  probe_info("Connected, Configured\n");
+  /* UART needs to preempt USB as if we don't, characters get lost */
+  xTaskCreate(cdc_thread, "UART", configMINIMAL_STACK_SIZE, NULL, UART_TASK_PRIO, &uart_taskhandle);
+  /* Lowest priority thread is debug - need to shuffle buffers before we can toggle swd... */
+  xTaskCreate(dap_thread, "DAP", configMINIMAL_STACK_SIZE, NULL, DAP_TASK_PRIO, &dap_taskhandle);
+}
+
 void vApplicationTickHook (void)
 {
 };

src/probe.c

@@ -32,7 +32,7 @@
 
 #include "led.h"
 #include "probe_config.h"
-#include "probe.pio.h"
+#include "probe.h"
 #include "tusb.h"
 
 #define DIV_ROUND_UP(m, n)	(((m) + (n) - 1) / (n))

src/tusb_edpt_handler.c

@@ -41,6 +41,15 @@ void dap_edpt_init(void) {
 
 }
 
+bool dap_edpt_deinit(void)
+{
+	memset(DAPRequestBuffer, 0, sizeof(DAPRequestBuffer));
+	memset(DAPResponseBuffer, 0, sizeof(DAPResponseBuffer));
+	USBRequestBuffer.wptr = USBRequestBuffer.rptr = 0;
+	USBResponseBuffer.wptr = USBResponseBuffer.rptr = 0;
+	return true;
+}
+
 void dap_edpt_reset(uint8_t __unused rhport)
 {
 	itf_num = 0;
@@ -198,7 +207,7 @@ void dap_thread(void *ptr)
 			 */
 			n = USBRequestBuffer.rptr;
 			while (USBRequestBuffer.data[n % DAP_PACKET_COUNT][0] == ID_DAP_QueueCommands) {
-				probe_info("%u %u DAP queued cmd %s len %02x\n",
+				probe_info("%lu %lu DAP queued cmd %s len %02x\n",
 					       USBRequestBuffer.wptr, USBRequestBuffer.rptr,
 					       dap_cmd_string[USBRequestBuffer.data[n % DAP_PACKET_COUNT][0]], USBRequestBuffer.data[n % DAP_PACKET_COUNT][1]);
 				USBRequestBuffer.data[n % DAP_PACKET_COUNT][0] = ID_DAP_ExecuteCommands;
@@ -211,7 +220,7 @@ void dap_thread(void *ptr)
 			}
 			// Read a single packet from the USB buffer into the DAP Request buffer
 			memcpy(DAPRequestBuffer, RD_SLOT_PTR(USBRequestBuffer), DAP_PACKET_SIZE);
-			probe_info("%u %u DAP cmd %s len %02x\n",
+			probe_info("%lu %lu DAP cmd %s len %02x\n",
 				       USBRequestBuffer.wptr, USBRequestBuffer.rptr,
 				       dap_cmd_string[DAPRequestBuffer[0]], DAPRequestBuffer[1]);
 			USBRequestBuffer.rptr++;
@@ -227,7 +236,7 @@ void dap_thread(void *ptr)
 			}
 
 			_resp_len = DAP_ExecuteCommand(DAPRequestBuffer, DAPResponseBuffer);
-			probe_info("%u %u DAP resp %s\n",
+			probe_info("%lu %lu DAP resp %s\n",
 					USBResponseBuffer.wptr, USBResponseBuffer.rptr,
 					dap_cmd_string[DAPResponseBuffer[0]]);
 
@@ -262,6 +271,7 @@ void dap_thread(void *ptr)
 usbd_class_driver_t const _dap_edpt_driver =
 {
 		.init = dap_edpt_init,
+		.deinit = dap_edpt_deinit,
 		.reset = dap_edpt_reset,
 		.open = dap_edpt_open,
 		.control_xfer_cb = dap_edpt_control_xfer_cb,