Update README.md

Debugprobe release v2.2.2
Point release to address high uart TX baud rate corruption, at the expense of throughput. Also skip over an attempt at UART/SDK optimisation that caused issues for users.
2025-03-27 15:53:18 +00:00 · 2025-03-13 16:36:24 +00:00 · 2025-03-13 11:11:27 +00:00 · 2025-03-11 09:50:23 +00:00 · 2025-01-17 15:14:06 +00:00 · 2025-01-17 15:03:02 +00:00
27 changed files with 1528 additions and 617 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,24 +2,29 @@ cmake_minimum_required(VERSION 3.12)

 include(pico_sdk_import.cmake)

-set(FREERTOS_KERNEL_PATH ${CMAKE_CURRENT_LIST_DIR}/freertos)
+set(FREERTOS_KERNEL_PATH "${CMAKE_CURRENT_LIST_DIR}/freertos")
 include(FreeRTOS_Kernel_import.cmake)

-project(picoprobe)
+project(debugprobe)

 pico_sdk_init()

-add_executable(picoprobe
-        src/led.c
+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/main.c
        src/usb_descriptors.c
        src/probe.c
        src/cdc_uart.c
        src/get_serial.c
        src/sw_dp_pio.c
+        src/tusb_edpt_handler.c
 )

-target_sources(picoprobe PRIVATE
+target_sources(debugprobe PRIVATE
        CMSIS_5/CMSIS/DAP/Firmware/Source/DAP.c
        CMSIS_5/CMSIS/DAP/Firmware/Source/JTAG_DP.c
        CMSIS_5/CMSIS/DAP/Firmware/Source/DAP_vendor.c
@@ -27,30 +32,43 @@ target_sources(picoprobe PRIVATE
        #CMSIS_5/CMSIS/DAP/Firmware/Source/SW_DP.c
        )

-target_include_directories(picoprobe PRIVATE
+target_include_directories(debugprobe PRIVATE
        CMSIS_5/CMSIS/DAP/Firmware/Include/
        CMSIS_5/CMSIS/Core/Include/
        include/
        )

-target_compile_options(picoprobe PRIVATE -Wall)
+target_compile_options(debugprobe PRIVATE -Wall)

-if (DEFINED ENV{PICOPROBE_LED})
-        message("PICOPROBE_LED is defined as " $ENV{PICOPROBE_LED})
-        target_compile_definitions(picoprobe PRIVATE PICOPROBE_LED=$ENV{PICOPROBE_LED})
-endif()
+pico_generate_pio_header(debugprobe "${CMAKE_CURRENT_LIST_DIR}/src/probe.pio")
+pico_generate_pio_header(debugprobe "${CMAKE_CURRENT_LIST_DIR}/src/probe_oen.pio")

-set(DBG_PIN_COUNT=4)
+target_include_directories(debugprobe PRIVATE src)

-pico_generate_pio_header(picoprobe ${CMAKE_CURRENT_LIST_DIR}/src/probe.pio)
-
-target_include_directories(picoprobe PRIVATE src)
-
-target_compile_definitions (picoprobe PRIVATE
+target_compile_definitions (debugprobe PRIVATE
 	PICO_RP2040_USB_DEVICE_ENUMERATION_FIX=1
 )

-target_link_libraries(picoprobe PRIVATE
+option (DEBUG_ON_PICO "Compile firmware for the Pico instead of Debug Probe" OFF)
+if (DEBUG_ON_PICO)
+    target_compile_definitions (debugprobe PRIVATE
+	DEBUG_ON_PICO=1
+    )
+    if (PICO_BOARD STREQUAL "pico")
+        set_target_properties(debugprobe PROPERTIES
+            OUTPUT_NAME "debugprobe_on_pico"
+        )
+    elseif (PICO_BOARD STREQUAL "pico2")
+        set_target_properties(debugprobe PROPERTIES
+            OUTPUT_NAME "debugprobe_on_pico2"
+        )
+    else ()
+        message(SEND_ERROR "Unsupported board ${PICO_BOARD}")
+    endif ()
+endif ()
+
+
+target_link_libraries(debugprobe PRIVATE
        pico_multicore
        pico_stdlib
        pico_unique_id
@@ -61,6 +79,6 @@ target_link_libraries(picoprobe PRIVATE
        FreeRTOS-Kernel-Heap1
 )

-pico_set_binary_type(picoprobe copy_to_ram)
+pico_set_binary_type(debugprobe copy_to_ram)

-pico_add_extra_outputs(picoprobe)
+pico_add_extra_outputs(debugprobe)
--- a/FreeRTOS_Kernel_import.cmake
+++ b/FreeRTOS_Kernel_import.cmake
@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: BSD-3-clause
 # 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
@@ -6,42 +7,72 @@
 # respectively.

 if (DEFINED ENV{FREERTOS_KERNEL_PATH} AND (NOT FREERTOS_KERNEL_PATH))
-    set(FREERTOS_KERNEL_PATH $ENV{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)
+# first pass we look in old tree; second pass we look in new tree
+foreach(SEARCH_PASS RANGE 0 1)
+    if (SEARCH_PASS)
+        # ports may be moving to submodule in the future
+        set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "portable/ThirdParty/Community-Supported-Ports/GCC")
+        set(FREERTOS_KERNEL_RP2040_BACK_PATH "../../../../..")
+    else()
+        set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "portable/ThirdParty/GCC")
+        set(FREERTOS_KERNEL_RP2040_BACK_PATH "../../../..")
    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")
+    if(PICO_PLATFORM STREQUAL "rp2040")
+        set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/RP2040")
+    else()
+        if (PICO_PLATFORM STREQUAL "rp2350-riscv")
+            set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/RP2350_RISC-V")
+        else()
+            set(FREERTOS_KERNEL_RP2040_RELATIVE_PATH "${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/RP2350_ARM_NTZ")
+        endif()
+    endif()
+
+    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")
+            break()
+        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}'")
            break()
        endif()
-    endforeach()
-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()
+        if (FREERTOS_KERNEL_PATH)
+            break()
+        endif()
+    endif()
+
+    # user must have specified
+    if (FREERTOS_KERNEL_PATH)
+        if (EXISTS "${FREERTOS_KERNEL_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}")
+            break()
+        endif()
+    endif()
+endforeach ()

 if (NOT FREERTOS_KERNEL_PATH)
    message(FATAL_ERROR "FreeRTOS location was not specified. Please set FREERTOS_KERNEL_PATH.")
@@ -50,12 +81,12 @@ 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})
+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}")
+if (NOT EXISTS "${FREERTOS_KERNEL_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}/CMakeLists.txt")
+    message(FATAL_ERROR "Directory '${FREERTOS_KERNEL_PATH}' does not contain a '${PICO_PLATFORM}' port here: '${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}'")
 endif()
-set(FREERTOS_KERNEL_PATH ${FREERTOS_KERNEL_PATH} CACHE PATH "Path to the FreeRTOS_KERNEL" FORCE)
+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)
+add_subdirectory("${FREERTOS_KERNEL_PATH}/${FREERTOS_KERNEL_RP2040_RELATIVE_PATH}" FREERTOS_KERNEL)
--- a/23
+++ b/23
@@ -0,0 +1,23 @@
+Unless otherwise indicated in individual files, this project is licenced as:
+
+MIT License
+
+Copyright (c) 2024 Raspberry Pi Ltd
+
+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.
--- a/README.md
+++ b/README.md
@@ -1,5 +1,68 @@
-# Picoprobe
-Picoprobe allows a Pico / RP2040 to be used as USB -> SWD and UART bridge. This means it can be used as a debugger and serial console for another Pico.
+# Debugprobe
+
+Firmware source for the Raspberry Pi Debug Probe SWD/UART accessory. Can also be run on a Raspberry Pi Pico.
+
+[Raspberry Pi Debug Probe product page](https://www.raspberrypi.com/products/debug-probe/)
+
+[Raspberry Pi Pico product page](https://www.raspberrypi.com/products/raspberry-pi-pico/)
+

 # Documentation
-Picoprobe documentation can be found in the [Pico Getting Started Guide](https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf). See "Appendix A: Using Picoprobe".
+
+Debug Probe documentation can be found at the [Raspberry Pi Microcontroller Documentation portal](https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html#about-the-debug-probe).
+
+# Hacking
+
+For the purpose of making changes or studying of the code, you may want to compile the code yourself.
+
+First, clone the repository:
+```
+git clone https://github.com/raspberrypi/debugprobe
+cd debugprobe
+```
+Initialize and update the submodules:
+```
+ git submodule update --init --recursive
+```
+Then create and switch to the build directory:
+```
+ mkdir build
+ cd build
+```
+If your environment doesn't contain `PICO_SDK_PATH`, then either add it to your environment variables with `export PICO_SDK_PATH=/path/to/sdk` or add `PICO_SDK_PATH=/path/to/sdk` to the arguments to CMake below.
+
+Run cmake and build the code:
+```
+ cmake ..
+ make
+```
+Done! You should now have a `debugprobe.uf2` that you can upload to your Debug Probe via the UF2 bootloader.
+
+If you want to create the version that runs on the Pico, then you need to invoke `cmake` in the sequence above with the `DEBUG_ON_PICO=ON` option:
+```
+cmake -DDEBUG_ON_PICO=ON ..
+```
+
+This will build with the configuration for the Pico and call the output program `debugprobe_on_pico.uf2`, as opposed to `debugprobe.uf2` for the accessory hardware.
+
+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
+- Possibly include RTT support
--- a/2
+++ b/2
--- a/include/DAP_config.h
+++ b/include/DAP_config.h
@@ -47,12 +47,12 @@ This information includes:
 #include <hardware/gpio.h>

 #include "cmsis_compiler.h"
-#include "picoprobe_config.h"
+#include "probe_config.h"
 #include "probe.h"

 /// Processor Clock of the Cortex-M MCU used in the Debug Unit.
 /// This value is used to calculate the SWD/JTAG clock speed.
-/* Picoprobe actually uses kHz rather than Hz, so just lie about it here */
+/* Debugprobe actually uses kHz rather than Hz, so just lie about it here */
 #define CPU_CLOCK               125000000U      ///< Specifies the CPU Clock in Hz.

 /// Number of processor cycles for I/O Port write operations.
@@ -460,7 +460,11 @@ __STATIC_FORCEINLINE void     PIN_nTRST_OUT  (uint32_t bit) {
 \return Current status of the nRESET DAP hardware I/O pin.
 */
 __STATIC_FORCEINLINE uint32_t PIN_nRESET_IN  (void) {
+#ifdef PROBE_PIN_RESET
+  return probe_reset_level();
+#else
  return (0U);
+#endif
 }

 /** nRESET I/O pin: Set Output.
@@ -469,7 +473,11 @@ __STATIC_FORCEINLINE uint32_t PIN_nRESET_IN  (void) {
           - 1: release device hardware reset.
 */
 __STATIC_FORCEINLINE void     PIN_nRESET_OUT (uint32_t bit) {
-  ;
+#ifdef PROBE_PIN_RESET
+  probe_assert_reset(!!bit);
+#else
+  (void) bit;
+#endif
 }

 ///@}
@@ -494,8 +502,8 @@ It is recommended to provide the following LEDs for status indication:
           - 0: Connect LED OFF: debugger is not connected to CMSIS-DAP Debug Unit.
 */
 __STATIC_INLINE void LED_CONNECTED_OUT (uint32_t bit) {
-#ifdef PICOPROBE_DAP_CONNECTED_LED
-  gpio_put(PICOPROBE_DAP_CONNECTED_LED, bit);
+#ifdef PROBE_DAP_CONNECTED_LED
+  gpio_put(PROBE_DAP_CONNECTED_LED, bit);
 #endif
 }

@@ -505,8 +513,8 @@ __STATIC_INLINE void LED_CONNECTED_OUT (uint32_t bit) {
           - 0: Target Running LED OFF: program execution in target stopped.
 */
 __STATIC_INLINE void LED_RUNNING_OUT (uint32_t bit) {
-#ifdef PICOPROBE_DAP_RUNNING_LED
-  gpio_put(PICOPROBE_DAP_RUNNING_LED, bit);
+#ifdef PROBE_DAP_RUNNING_LED
+  gpio_put(PROBE_DAP_RUNNING_LED, bit);
 #endif
 }

@@ -553,7 +561,16 @@ Status LEDs. In detail the operation of Hardware I/O and LED pins are enabled an
 - LED output pins are enabled and LEDs are turned off.
 */
 __STATIC_INLINE void DAP_SETUP (void) {
-  probe_gpio_init();
+// We synchronously setup probe IOs when the respective PIO program is loaded - not at start of day
+
+#ifdef PROBE_DAP_CONNECTED_LED
+    gpio_init(PROBE_DAP_CONNECTED_LED);
+    gpio_set_dir(PROBE_DAP_CONNECTED_LED, GPIO_OUT);
+#endif
+#ifdef PROBE_DAP_RUNNING_LED
+    gpio_init(PROBE_DAP_RUNNING_LED);
+    gpio_set_dir(PROBE_DAP_RUNNING_LED, GPIO_OUT);
+#endif
 }

 /** Reset Target Device with custom specific I/O pin or command sequence.
--- a/include/board_debug_probe_config.h
+++ b/include/board_debug_probe_config.h
@@ -0,0 +1,55 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
+ *
+ * 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 BOARD_DEBUG_PROBE_H_
+#define BOARD_DEBUG_PROBE_H_
+
+#define PROBE_IO_SWDI
+#define PROBE_CDC_UART
+// No reset pin 
+
+// PIO config
+#define PROBE_SM 0
+#define PROBE_PIN_OFFSET 12
+#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 0)
+// For level-shifted input.
+#define PROBE_PIN_SWDI (PROBE_PIN_OFFSET + 1)
+#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 2)
+
+// UART config
+#define PROBE_UART_TX 4
+#define PROBE_UART_RX 5
+#define PROBE_UART_INTERFACE uart1
+#define PROBE_UART_BAUDRATE 115200
+
+#define PROBE_USB_CONNECTED_LED 2
+#define PROBE_DAP_CONNECTED_LED 15
+#define PROBE_DAP_RUNNING_LED 16
+#define PROBE_UART_RX_LED 7
+#define PROBE_UART_TX_LED 8
+
+#define PROBE_PRODUCT_STRING "Debug Probe (CMSIS-DAP)"
+
+#endif
--- a/include/board_example_config.h
+++ b/include/board_example_config.h
@@ -0,0 +1,97 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
+ *
+ * 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 BOARD_EXAMPLE_H_
+#define BOARD_EXAMPLE_H_
+#error "Example board configuration requested - specify PICO_BOARD and re-run CMake."
+
+/* Select one of these. */
+/* Direct connection - SWCLK/SWDIO on two GPIOs */
+#define PROBE_IO_RAW
+/* SWCLK connected to a GPIO, SWDO driven from a GPIO, SWDI sampled via a level shifter */
+#define PROBE_IO_SWDI
+/* Level-shifted SWCLK, SWDIO with separate SWDO, SWDI and OE_N pin */
+#define PROBE_IO_OEN
+
+/* Include CDC interface to bridge to target UART. Omit if not used. */
+#define PROBE_CDC_UART
+
+/* Board implements hardware flow control for UART RTS/CTS instead of ACM control */
+#define PROBE_UART_HWFC
+
+/* Target reset GPIO (active-low). Omit if not used.*/
+#define PROBE_PIN_RESET 1
+
+#define PROBE_SM 0
+#define PROBE_PIN_OFFSET 12
+/* PIO config for PROBE_IO_RAW */
+#if defined(PROBE_IO_RAW)
+#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 0)
+#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 1)
+#endif
+
+/* PIO config for PROBE_IO_SWDI */
+#if defined(PROBE_IO_SWDI)
+#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 0)
+#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 1)
+#define PROBE_PIN_SWDI  (PROBE_PIN_OFFSET + 2)
+#endif
+
+/* PIO config for PROBE_IO_OEN - note that SWDIOEN and SWCLK are both side_set signals, so must be consecutive. */
+#if defined(PROBE_IO_OEN)
+#define PROBE_PIN_SWDIOEN (PROBE_PIN_OFFSET + 0)
+#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 1)
+#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 2)
+#define PROBE_PIN_SWDI (PROBE_PIN_OFFSET + 3)
+#endif
+
+#if defined(PROBE_CDC_UART)
+#define PROBE_UART_TX 4
+#define PROBE_UART_RX 5
+#define PROBE_UART_INTERFACE uart1
+#define PROBE_UART_BAUDRATE 115200
+
+#if defined(PROBE_UART_HWFC)
+/* Hardware flow control - see 1.4.3 in the RP2040 datasheet for valid pin settings */
+#define PROBE_UART_CTS 6
+#define PROBE_UART_RTS 7
+#else
+/* Software flow control - RTS and DTR can be omitted if not used */
+#define PROBE_UART_RTS 9
+#endif
+#define PROBE_UART_DTR 10
+
+#endif
+
+/* LED config - some or all of these can be omitted if not used */
+#define PROBE_USB_CONNECTED_LED 2
+#define PROBE_DAP_CONNECTED_LED 15
+#define PROBE_DAP_RUNNING_LED 16
+#define PROBE_UART_RX_LED 7
+#define PROBE_UART_TX_LED 8
+
+#define PROBE_PRODUCT_STRING "Example Debug Probe"
+
+#endif
--- a/include/board_pico_config.h
+++ b/include/board_pico_config.h
@@ -1,7 +1,7 @@
 /*
 * The MIT License (MIT)
 *
- * Copyright (c) 2021 a-pushkin on GitHub
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
@@ -23,11 +23,30 @@
 *
 */

-#ifndef LED_H
-#define LED_H
+#ifndef BOARD_PICO_H_
+#define BOARD_PICO_H_

-void led_init(void);
-void led_task(void);
-void led_signal_activity(uint total_bits);
+#define PROBE_IO_RAW
+#define PROBE_CDC_UART
+
+// PIO config
+#define PROBE_SM 0
+#define PROBE_PIN_OFFSET 2
+#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 0) // 2
+#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 1) // 3
+// Target reset config
+#if false
+#define PROBE_PIN_RESET 1
+#endif
+
+// UART config
+#define PROBE_UART_TX 4
+#define PROBE_UART_RX 5
+#define PROBE_UART_INTERFACE uart1
+#define PROBE_UART_BAUDRATE 115200
+
+#define PROBE_USB_CONNECTED_LED 25
+
+#define PROBE_PRODUCT_STRING "Debugprobe on Pico (CMSIS-DAP)"

 #endif
--- a/pico_sdk_import.cmake
+++ b/pico_sdk_import.cmake
@@ -1,12 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
 # This is a copy of <PICO_SDK_PATH>/external/pico_sdk_import.cmake

 # This can be dropped into an external project to help locate this SDK
 # It should be include()ed prior to project()

-# todo document
-
 if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH))
-    set(PICO_SDK_PATH $ENV{PICO_SDK_PATH})
+    set(PICO_SDK_PATH "$ENV{PICO_SDK_PATH}")
    message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')")
 endif ()

@@ -16,49 +15,60 @@ if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT} AND (NOT PICO_SDK_FETCH_FROM_GIT))
 endif ()

 if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_PATH))
-    set(PICO_SDK_FETCH_FROM_GIT_PATH $ENV{PICO_SDK_FETCH_FROM_GIT_PATH})
+    set(PICO_SDK_FETCH_FROM_GIT_PATH "$ENV{PICO_SDK_FETCH_FROM_GIT_PATH}")
    message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')")
 endif ()

-set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the PICO SDK")
-set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of PICO SDK from git if not otherwise locatable")
+set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK")
+set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of SDK from git if not otherwise locatable")
 set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK")

 if (NOT PICO_SDK_PATH)
    if (PICO_SDK_FETCH_FROM_GIT)
        include(FetchContent)
-        set(FETCHCONTENT_BASE_DIR_SAVE ${FETCHCONTENT_BASE_DIR})
+        set(FETCHCONTENT_BASE_DIR_SAVE "${FETCHCONTENT_BASE_DIR}")
        if (PICO_SDK_FETCH_FROM_GIT_PATH)
            get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_SDK_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
        endif ()
-        FetchContent_Declare(
-                pico_sdk
-                GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
-                GIT_TAG master
-        )
-        if (NOT pico_sdk)
-            message("Downloading PICO SDK")
-            FetchContent_Populate(pico_sdk)
-            set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR})
+        # GIT_SUBMODULES_RECURSE was added in 3.17
+        if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.17.0")
+            FetchContent_Declare(
+                    pico_sdk
+                    GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
+                    GIT_TAG master
+                    GIT_SUBMODULES_RECURSE FALSE
+            )
+        else ()
+            FetchContent_Declare(
+                    pico_sdk
+                    GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
+                    GIT_TAG master
+            )
        endif ()
-        set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE})
+
+        if (NOT pico_sdk)
+            message("Downloading Raspberry Pi Pico SDK")
+            FetchContent_Populate(pico_sdk)
+            set(PICO_SDK_PATH "${pico_sdk_SOURCE_DIR}")
+        endif ()
+        set(FETCHCONTENT_BASE_DIR "${FETCHCONTENT_BASE_DIR_SAVE}")
    else ()
        message(FATAL_ERROR
-                "PICO SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
+                "SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
                )
    endif ()
 endif ()

 get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
-if (NOT EXISTS ${PICO_SDK_PATH})
+if (NOT EXISTS "${PICO_SDK_PATH}")
    message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' not found")
 endif ()

-set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake)
-if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE})
-    message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the PICO SDK")
+set(PICO_SDK_INIT_CMAKE_FILE "${PICO_SDK_PATH}/pico_sdk_init.cmake")
+if (NOT EXISTS "${PICO_SDK_INIT_CMAKE_FILE}")
+    message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the Raspberry Pi Pico SDK")
 endif ()

-set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the PICO SDK" FORCE)
+set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE)

-include(${PICO_SDK_INIT_CMAKE_FILE})
+include("${PICO_SDK_INIT_CMAKE_FILE}")
--- a/src/FreeRTOSConfig.h
+++ b/src/FreeRTOSConfig.h
@@ -71,7 +71,7 @@
 /* Memory allocation related definitions. */
 #define configSUPPORT_STATIC_ALLOCATION         0
 #define configSUPPORT_DYNAMIC_ALLOCATION        1
-#define configTOTAL_HEAP_SIZE                   (128*1024)
+#define configTOTAL_HEAP_SIZE                   (64*1024)
 #define configAPPLICATION_ALLOCATED_HEAP        0

 /* Hook function related definitions. */
@@ -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)
--- a/src/cdc_uart.c
+++ b/src/cdc_uart.c
@@ -26,38 +26,82 @@
 #include <pico/stdlib.h>
 #include "FreeRTOS.h"
 #include "task.h"
-
 #include "tusb.h"

-#include "picoprobe_config.h"
+#include "probe_config.h"

 TaskHandle_t uart_taskhandle;
 TickType_t last_wake, interval = 100;
+volatile TickType_t break_expiry;
+volatile bool timed_break;

-static uint8_t tx_buf[CFG_TUD_CDC_TX_BUFSIZE];
-static uint8_t rx_buf[CFG_TUD_CDC_RX_BUFSIZE];
+/* Max 1 FIFO worth of data */
+static uint8_t tx_buf[32];
+static uint8_t rx_buf[32];
 // Actually s^-1 so 25ms
 #define DEBOUNCE_MS 40
 static uint debounce_ticks = 5;
-static uint tx_led_debounce;
+
+#ifdef PROBE_UART_TX_LED
+static volatile uint tx_led_debounce;
+#endif
+
+#ifdef PROBE_UART_RX_LED
 static uint rx_led_debounce;
+#endif

 void cdc_uart_init(void) {
-    gpio_set_function(PICOPROBE_UART_TX, GPIO_FUNC_UART);
-    gpio_set_function(PICOPROBE_UART_RX, GPIO_FUNC_UART);
-    gpio_set_pulls(PICOPROBE_UART_TX, 1, 0);
-    gpio_set_pulls(PICOPROBE_UART_RX, 1, 0);
-    uart_init(PICOPROBE_UART_INTERFACE, PICOPROBE_UART_BAUDRATE);
+    gpio_set_function(PROBE_UART_TX, GPIO_FUNC_UART);
+    gpio_set_function(PROBE_UART_RX, GPIO_FUNC_UART);
+    gpio_set_pulls(PROBE_UART_TX, 1, 0);
+    gpio_set_pulls(PROBE_UART_RX, 1, 0);
+    uart_init(PROBE_UART_INTERFACE, PROBE_UART_BAUDRATE);
+
+#ifdef PROBE_UART_TX_LED
+    tx_led_debounce = 0;
+    gpio_init(PROBE_UART_TX_LED);
+    gpio_set_dir(PROBE_UART_TX_LED, GPIO_OUT);
+#endif
+#ifdef PROBE_UART_RX_LED
+    rx_led_debounce = 0;
+    gpio_init(PROBE_UART_RX_LED);
+    gpio_set_dir(PROBE_UART_RX_LED, GPIO_OUT);
+#endif
+
+#ifdef PROBE_UART_HWFC
+    /* HWFC implies that hardware flow control is implemented and the
+     * UART operates in "full-duplex" mode (See USB CDC PSTN120 6.3.12).
+     * Default to pulling in the active direction, so an unconnected CTS
+     * behaves the same as if CTS were not enabled. */
+    gpio_set_pulls(PROBE_UART_CTS, 0, 1);
+    gpio_set_function(PROBE_UART_RTS, GPIO_FUNC_UART);
+    gpio_set_function(PROBE_UART_CTS, GPIO_FUNC_UART);
+    uart_set_hw_flow(PROBE_UART_INTERFACE, true, true);
+#else
+#ifdef PROBE_UART_RTS
+    gpio_init(PROBE_UART_RTS);
+    gpio_set_dir(PROBE_UART_RTS, GPIO_OUT);
+    gpio_put(PROBE_UART_RTS, 1);
+#endif
+#endif
+
+#ifdef PROBE_UART_DTR
+    gpio_init(PROBE_UART_DTR);
+    gpio_set_dir(PROBE_UART_DTR, GPIO_OUT);
+    gpio_put(PROBE_UART_DTR, 1);
+#endif
 }

-void cdc_task(void)
+bool cdc_task(void)
 {
    static int was_connected = 0;
+    static uint cdc_tx_oe = 0;
    uint rx_len = 0;
+    bool keep_alive = false;

    // Consume uart fifo regardless even if not connected
-    while(uart_is_readable(PICOPROBE_UART_INTERFACE) && (rx_len < sizeof(rx_buf))) {
-        rx_buf[rx_len++] = uart_getc(PICOPROBE_UART_INTERFACE);
+    while(uart_is_readable(PROBE_UART_INTERFACE) && (rx_len < sizeof(rx_buf))) {
+        rx_buf[rx_len++] = uart_getc(PROBE_UART_INTERFACE);
    }

    if (tud_cdc_connected()) {
@@ -66,21 +110,24 @@ void cdc_task(void)
        /* Implicit overflow if we don't write all the bytes to the host.
         * Also throw away bytes if we can't write... */
        if (rx_len) {
-#ifdef PICOPROBE_UART_RX_LED
-          gpio_put(PICOPROBE_UART_RX_LED, 1);
+#ifdef PROBE_UART_RX_LED
+          gpio_put(PROBE_UART_RX_LED, 1);
          rx_led_debounce = debounce_ticks;
 #endif
          written = MIN(tud_cdc_write_available(), rx_len);
+          if (rx_len > written)
+              cdc_tx_oe++;
+
          if (written > 0) {
            tud_cdc_write(rx_buf, written);
            tud_cdc_write_flush();
          }
        } else {
-#ifdef PICOPROBE_UART_RX_LED
+#ifdef PROBE_UART_RX_LED
          if (rx_led_debounce)
            rx_led_debounce--;
          else
-            gpio_put(PICOPROBE_UART_RX_LED, 0);
+            gpio_put(PROBE_UART_RX_LED, 0);
 #endif
        }

@@ -88,74 +135,183 @@ void cdc_task(void)
      size_t watermark = MIN(tud_cdc_available(), sizeof(tx_buf));
      if (watermark > 0) {
        size_t tx_len;
-#ifdef PICOPROBE_UART_TX_LED
-        gpio_put(PICOPROBE_UART_TX_LED, 1);
+#ifdef PROBE_UART_TX_LED
+        gpio_put(PROBE_UART_TX_LED, 1);
        tx_led_debounce = debounce_ticks;
 #endif
        /* Batch up to half a FIFO of data - don't clog up on RX */
        watermark = MIN(watermark, 16);
        tx_len = tud_cdc_read(tx_buf, watermark);
-        uart_write_blocking(PICOPROBE_UART_INTERFACE, tx_buf, tx_len);
+        uart_write_blocking(PROBE_UART_INTERFACE, tx_buf, tx_len);
      } else {
-#ifdef PICOPROBE_UART_TX_LED
+#ifdef PROBE_UART_TX_LED
          if (tx_led_debounce)
            tx_led_debounce--;
          else
-            gpio_put(PICOPROBE_UART_TX_LED, 0);
+            gpio_put(PROBE_UART_TX_LED, 0);
 #endif
      }
+      /* Pending break handling */
+      if (timed_break) {
+        if (((int)break_expiry - (int)xTaskGetTickCount()) < 0) {
+          timed_break = false;
+          uart_set_break(PROBE_UART_INTERFACE, false);
+#ifdef PROBE_UART_TX_LED
+          tx_led_debounce = 0;
+#endif
+        } else {
+          keep_alive = true;
+        }
+      }
    } else if (was_connected) {
      tud_cdc_write_clear();
+      uart_set_break(PROBE_UART_INTERFACE, false);
+      timed_break = false;
      was_connected = 0;
+#ifdef PROBE_UART_TX_LED
+      tx_led_debounce = 0;
+#endif
+      cdc_tx_oe = 0;
    }
+    return keep_alive;
 }

 void cdc_thread(void *ptr)
 {
  BaseType_t delayed;
  last_wake = xTaskGetTickCount();
+  bool keep_alive;
  /* Threaded with a polling interval that scales according to linerate */
  while (1) {
-    cdc_task();
-    delayed = xTaskDelayUntil(&last_wake, interval);
-    if (delayed == pdFALSE)
-      last_wake = xTaskGetTickCount();
+    keep_alive = cdc_task();
+    if (!keep_alive) {
+      delayed = xTaskDelayUntil(&last_wake, interval);
+        if (delayed == pdFALSE)
+          last_wake = xTaskGetTickCount();
+    }
  }
 }

 void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* line_coding)
 {
+  uart_parity_t parity;
+  uint data_bits, stop_bits;
  /* Set the tick thread interval to the amount of time it takes to
   * fill up half a FIFO. Millis is too coarse for integer divide.
   */
  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));
-  picoprobe_info("New baud rate %d micros %d interval %u\n",
+  probe_info("New baud rate %ld micros %ld interval %lu\n",
                  line_coding->bit_rate, micros, interval);
-  uart_deinit(PICOPROBE_UART_INTERFACE);
+  uart_deinit(PROBE_UART_INTERFACE);
  tud_cdc_write_clear();
  tud_cdc_read_flush();
-  uart_init(PICOPROBE_UART_INTERFACE, line_coding->bit_rate);
-  vTaskResume(uart_taskhandle);
+  uart_init(PROBE_UART_INTERFACE, line_coding->bit_rate);
+
+  switch (line_coding->parity) {
+  case CDC_LINE_CODING_PARITY_ODD:
+    parity = UART_PARITY_ODD;
+    break;
+  case CDC_LINE_CODING_PARITY_EVEN:
+    parity = UART_PARITY_EVEN;
+    break;
+  default:
+    probe_info("invalid parity setting %u\n", line_coding->parity);
+    /* fallthrough */
+  case CDC_LINE_CODING_PARITY_NONE:
+    parity = UART_PARITY_NONE;
+    break;
+  }
+
+  switch (line_coding->data_bits) {
+  case 5:
+  case 6:
+  case 7:
+  case 8:
+    data_bits = line_coding->data_bits;
+    break;
+  default:
+    probe_info("invalid data bits setting: %u\n", line_coding->data_bits);
+    data_bits = 8;
+    break;
+  }
+
+  /* The PL011 only supports 1 or 2 stop bits. 1.5 stop bits is translated to 2,
+   * which is safer than the alternative. */
+  switch (line_coding->stop_bits) {
+  case CDC_LINE_CONDING_STOP_BITS_1_5:
+  case CDC_LINE_CONDING_STOP_BITS_2:
+    stop_bits = 2;
+  break;
+  default:
+    probe_info("invalid stop bits setting: %u\n", line_coding->stop_bits);
+    /* fallthrough */
+  case CDC_LINE_CONDING_STOP_BITS_1:
+    stop_bits = 1;
+  break;
+  }
+
+  uart_set_format(PROBE_UART_INTERFACE, data_bits, stop_bits, parity);
+  /* 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)
 {
+#ifdef PROBE_UART_RTS
+  gpio_put(PROBE_UART_RTS, !rts);
+#endif
+#ifdef PROBE_UART_DTR
+  gpio_put(PROBE_UART_DTR, !dtr);
+#endif
+
  /* 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 PICOPROBE_UART_RX_LED
-    gpio_put(PICOPROBE_UART_RX_LED, 0);
+#ifdef PROBE_UART_RX_LED
+    gpio_put(PROBE_UART_RX_LED, 0);
    rx_led_debounce = 0;
 #endif
-#ifdef PICOPROBE_UART_RX_LED
-    gpio_put(PICOPROBE_UART_TX_LED, 0);
+#ifdef PROBE_UART_TX_LED
+    gpio_put(PROBE_UART_TX_LED, 0);
    tx_led_debounce = 0;
 #endif
  } else
    vTaskResume(uart_taskhandle);
 }
+
+void tud_cdc_send_break_cb(uint8_t itf, uint16_t wValue) {
+  switch(wValue) {
+    case 0:
+    uart_set_break(PROBE_UART_INTERFACE, false);
+    timed_break = false;
+#ifdef PROBE_UART_TX_LED
+    tx_led_debounce = 0;
+#endif
+    break;
+    case 0xffff:
+    uart_set_break(PROBE_UART_INTERFACE, true);
+    timed_break = false;
+#ifdef PROBE_UART_TX_LED
+    gpio_put(PROBE_UART_TX_LED, 1);
+    tx_led_debounce = 1 << 30;
+#endif
+    break;
+    default:
+    uart_set_break(PROBE_UART_INTERFACE, true);
+    timed_break = true;
+#ifdef PROBE_UART_TX_LED
+    gpio_put(PROBE_UART_TX_LED, 1);
+    tx_led_debounce = 1 << 30;
+#endif
+    break_expiry = xTaskGetTickCount() + (wValue * (configTICK_RATE_HZ / 1000));
+    break;
+  }
+}
--- a/src/cdc_uart.h
+++ b/src/cdc_uart.h
@@ -28,7 +28,7 @@

 void cdc_thread(void *ptr);
 void cdc_uart_init(void);
-void cdc_task(void);
+bool cdc_task(void);

 extern TaskHandle_t uart_taskhandle;

--- a/src/led.c
+++ b/src/led.c
@@ -1,78 +0,0 @@
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2021 a-pushkin on GitHub
- *
- * 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 <pico/stdlib.h>
-#include <stdint.h>
-
-#include "picoprobe_config.h"
-
-#define LED_COUNT_SHIFT 14
-#define LED_COUNT_MAX 5 * (1 << LED_COUNT_SHIFT)
-
-static uint32_t led_count;
-
-void led_init(void) {
-    led_count = 0;
-    gpio_init(PICOPROBE_LED);
-    gpio_set_dir(PICOPROBE_LED, GPIO_OUT);
-    gpio_put(PICOPROBE_LED, 1);
-#ifdef PICOPROBE_USB_CONNECTED_LED
-    gpio_init(PICOPROBE_USB_CONNECTED_LED);
-    gpio_set_dir(PICOPROBE_USB_CONNECTED_LED, GPIO_OUT);
-#endif
-#ifdef PICOPROBE_DAP_CONNECTED_LED
-    gpio_init(PICOPROBE_DAP_CONNECTED_LED);
-    gpio_set_dir(PICOPROBE_DAP_CONNECTED_LED, GPIO_OUT);
-#endif
-#ifdef PICOPROBE_DAP_RUNNING_LED
-    gpio_init(PICOPROBE_DAP_RUNNING_LED);
-    gpio_set_dir(PICOPROBE_DAP_RUNNING_LED, GPIO_OUT);
-#endif
-#ifdef PICOPROBE_UART_RX_LED
-    gpio_init(PICOPROBE_UART_RX_LED);
-    gpio_set_dir(PICOPROBE_UART_RX_LED, GPIO_OUT);
-#endif
-#ifdef PICOPROBE_UART_TX_LED
-    gpio_init(PICOPROBE_UART_TX_LED);
-    gpio_set_dir(PICOPROBE_UART_TX_LED, GPIO_OUT);
-#endif
-}
-
-void led_task(void) {
-    if (led_count != 0) {
-        --led_count;
-        gpio_put(PICOPROBE_LED, !((led_count >> LED_COUNT_SHIFT) & 1));
-    }
-}
-
-void led_signal_activity(uint total_bits) {
-    if (led_count == 0) {
-        gpio_put(PICOPROBE_LED, 0);
-    }
-
-    if (led_count < LED_COUNT_MAX) {
-        led_count += total_bits;
-    }
-}
--- a/src/main.c
+++ b/src/main.c
@@ -31,18 +31,23 @@
 #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 "picoprobe_config.h"
+#include "probe_config.h"
 #include "probe.h"
 #include "cdc_uart.h"
 #include "get_serial.h"
-#include "led.h"
+#include "tusb_edpt_handler.h"
 #include "DAP.h"
+#include "hardware/structs/usb.h"

-// UART0 for Picoprobe debug
-// UART1 for picoprobe to target device
+// UART0 for debugprobe debug
+// UART1 for debugprobe to target device

 static uint8_t TxDataBuffer[CFG_TUD_HID_EP_BUFSIZE];
 static uint8_t RxDataBuffer[CFG_TUD_HID_EP_BUFSIZE];
@@ -53,72 +58,98 @@ static uint8_t RxDataBuffer[CFG_TUD_HID_EP_BUFSIZE];
 #define TUD_TASK_PRIO  (tskIDLE_PRIORITY + 2)
 #define DAP_TASK_PRIO  (tskIDLE_PRIORITY + 1)

-static TaskHandle_t dap_taskhandle, tud_taskhandle;
+TaskHandle_t dap_taskhandle, tud_taskhandle, mon_taskhandle;

-void usb_thread(void *ptr)
-{
-    do {
-        tud_task();
-#ifdef PICOPROBE_USB_CONNECTED_LED
-        if (!gpio_get(PICOPROBE_USB_CONNECTED_LED) && tud_ready())
-            gpio_put(PICOPROBE_USB_CONNECTED_LED, 1);
-        else
-            gpio_put(PICOPROBE_USB_CONNECTED_LED, 0);
-#endif
-        // Trivial delay to save power
-        vTaskDelay(1);
-    } while (1);
-}
+static int was_configured;

-void dap_thread(void *ptr)
+void dev_mon(void *ptr)
 {
-    uint32_t resp_len;
+    uint32_t sof[3];
+    int i = 0;
+    TickType_t wake;
+    wake = xTaskGetTickCount();
    do {
-        if (tud_vendor_available()) {
-            tud_vendor_read(RxDataBuffer, sizeof(RxDataBuffer));
-            resp_len = DAP_ProcessCommand(RxDataBuffer, TxDataBuffer);
-            tud_vendor_write(TxDataBuffer, resp_len);
+        /* ~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 {
-            // Trivial delay to save power
-            vTaskDelay(1);
+            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)
+{
+#ifdef PROBE_USB_CONNECTED_LED
+    gpio_init(PROBE_USB_CONNECTED_LED);
+    gpio_set_dir(PROBE_USB_CONNECTED_LED, GPIO_OUT);
+#endif
+    TickType_t wake;
+    wake = xTaskGetTickCount();
+    do {
+        tud_task();
+#ifdef PROBE_USB_CONNECTED_LED
+        if (!gpio_get(PROBE_USB_CONNECTED_LED) && tud_ready())
+            gpio_put(PROBE_USB_CONNECTED_LED, 1);
+        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
+        else if (!tud_task_event_ready())
+            xTaskDelayUntil(&wake, 1);
+    } while (1);
+}
+
+// Workaround API change in 0.13
+#if (TUSB_VERSION_MAJOR == 0) && (TUSB_VERSION_MINOR <= 12)
+#define tud_vendor_flush(x) ((void)0)
+#endif
+
 int main(void) {
-    uint32_t resp_len;
+    // Declare pins in binary information
+    bi_decl_config();

    board_init();
    usb_serial_init();
    cdc_uart_init();
    tusb_init();
-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_OPENOCD_CUSTOM)
-    probe_gpio_init();
-    probe_init();
-#else
-    DAP_Setup();
-#endif
-    led_init();
+    stdio_uart_init();

-    picoprobe_info("Welcome to Picoprobe!\n");
+    DAP_Setup();
+
+    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();
    }

    while (!THREADED) {
        tud_task();
        cdc_task();
-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_OPENOCD_CUSTOM)
-        probe_task();
-        led_task();
-#elif (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
+
+#if (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
        if (tud_vendor_available()) {
+            uint32_t resp_len;
            tud_vendor_read(RxDataBuffer, sizeof(RxDataBuffer));
            resp_len = DAP_ProcessCommand(RxDataBuffer, TxDataBuffer);
            tud_vendor_write(TxDataBuffer, resp_len);
@@ -155,7 +186,7 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t rep
  tud_hid_report(0, TxDataBuffer, response_size);
 }

-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
+#if (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
 extern uint8_t const desc_ms_os_20[];

 bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
@@ -192,6 +223,48 @@ 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");
+  /* Were we actually configured? If not, threads don't exist */
+  if (was_configured) {
+	  vTaskSuspend(uart_taskhandle);
+	  vTaskSuspend(dap_taskhandle);
+  }
+  /* slow down clk_sys for power saving ? */
+}
+
+void tud_resume_cb(void)
+{
+  probe_info("Resumed\n");
+  if (was_configured) {
+	  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);
+  was_configured = 0;
+}
+
+void tud_mount_cb(void)
+{
+  probe_info("Connected, Configured\n");
+  if (!was_configured) {
+    /* 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);
+    was_configured = 1;
+  }
+}
+
 void vApplicationTickHook (void)
 {
 };
--- a/src/picoprobe_config.h
+++ b/src/picoprobe_config.h
@@ -1,93 +0,0 @@
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2021 Raspberry Pi (Trading) Ltd.
- *
- * 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 PICOPROBE_H_
-#define PICOPROBE_H_
-
-#if false
-#define picoprobe_info(format,args...) printf(format, ## args)
-#else
-#define picoprobe_info(format,...) ((void)0)
-#endif
-
-
-#if false
-#define picoprobe_debug(format,args...) printf(format, ## args)
-#else
-#define picoprobe_debug(format,...) ((void)0)
-#endif
-
-#if false
-#define picoprobe_dump(format,args...) printf(format, ## args)
-#else
-#define picoprobe_dump(format,...) ((void)0)
-#endif
-
-
-// PIO config
-#define PROBE_SM 0
-#define PROBE_PIN_OFFSET 12
-#define PROBE_PIN_SWCLK (PROBE_PIN_OFFSET + 0) // 2
-#define PROBE_PIN_SWDIO (PROBE_PIN_OFFSET + 2) // 3
-#define PROBE_PIN_SWDI (PROBE_PIN_OFFSET + 1) // 1 - for level-shifted input
-
-// Target reset config
-#define PROBE_PIN_RESET 0
-
-// UART config
-#define PICOPROBE_UART_TX 4
-#define PICOPROBE_UART_RX 5
-#define PICOPROBE_UART_INTERFACE uart1
-#define PICOPROBE_UART_BAUDRATE 115200
-
-#define PICOPROBE_USB_CONNECTED_LED 2
-#define PICOPROBE_DAP_CONNECTED_LED 15
-#define PICOPROBE_DAP_RUNNING_LED 16
-#define PICOPROBE_UART_RX_LED 7
-#define PICOPROBE_UART_TX_LED 8
-
-// LED config
-#ifndef PICOPROBE_LED
-
-#ifndef PICO_DEFAULT_LED_PIN
-#error PICO_DEFAULT_LED_PIN is not defined, run PICOPROBE_LED=<led_pin> cmake
-#elif PICO_DEFAULT_LED_PIN == -1
-#error PICO_DEFAULT_LED_PIN is defined as -1, run PICOPROBE_LED=<led_pin> cmake
-#else
-#define PICOPROBE_LED PICO_DEFAULT_LED_PIN
-#endif
-
-#define PROTO_OPENOCD_CUSTOM 0
-#define PROTO_DAP_V1 1
-#define PROTO_DAP_V2 2
-
-// Interface config
-#ifndef PICOPROBE_DEBUG_PROTOCOL
-#define PICOPROBE_DEBUG_PROTOCOL PROTO_DAP_V2
-#endif
-
-#endif
-
-#endif
--- a/src/probe.c
+++ b/src/probe.c
@@ -30,9 +30,8 @@
 #include <hardware/clocks.h>
 #include <hardware/gpio.h>

-#include "led.h"
-#include "picoprobe_config.h"
-#include "probe.pio.h"
+#include "probe_config.h"
+#include "probe.h"
 #include "tusb.h"

 #define DIV_ROUND_UP(m, n)	(((m) + (n) - 1) / (n))
@@ -52,15 +51,6 @@ CU_REGISTER_DEBUG_PINS(probe_timing)

 #define PROBE_BUF_SIZE 8192
 struct _probe {
-    // Total length
-    uint tx_len;
-    // Data back to host
-    uint8_t tx_buf[PROBE_BUF_SIZE];
-
-    // CMD / Data RX'd from
-    uint rx_len;
-    uint8_t rx_buf[PROBE_BUF_SIZE];
-
    // PIO offset
    uint offset;
    uint initted;
@@ -68,252 +58,121 @@ struct _probe {

 static struct _probe probe;

-enum PROBE_CMDS {
-    PROBE_INVALID      = 0, // Invalid command
-    PROBE_WRITE_BITS   = 1, // Host wants us to write bits
-    PROBE_READ_BITS    = 2, // Host wants us to read bits
-    PROBE_SET_FREQ     = 3, // Set TCK
-    PROBE_RESET        = 4, // Reset all state
-    PROBE_TARGET_RESET = 5, // Reset target
-};
-
-struct __attribute__((__packed__)) probe_cmd_hdr {
-	uint8_t id;
-    uint8_t cmd;
-    uint32_t bits;
-};
-
-struct __attribute__((__packed__)) probe_pkt_hdr {
-    uint32_t total_packet_length;
-};
-
 void probe_set_swclk_freq(uint freq_khz) {
        uint clk_sys_freq_khz = clock_get_hz(clk_sys) / 1000;
-        picoprobe_info("Set swclk freq %dKHz sysclk %dkHz\n", freq_khz, clk_sys_freq_khz);
-        // Worked out with saleae
-        uint32_t divider = clk_sys_freq_khz / freq_khz / 2;
+        probe_info("Set swclk freq %dKHz sysclk %dkHz\n", freq_khz, clk_sys_freq_khz);
+        uint32_t divider = clk_sys_freq_khz / freq_khz / 4;
+        if (divider == 0)
+            divider = 1;
        pio_sm_set_clkdiv_int_frac(pio0, PROBE_SM, divider, 0);
 }

 void probe_assert_reset(bool state)
 {
+#if defined(PROBE_PIN_RESET)
    /* Change the direction to out to drive pin to 0 or to in to emulate open drain */
-    gpio_set_dir(PROBE_PIN_RESET, state);
+    gpio_set_dir(PROBE_PIN_RESET, state == 0 ? GPIO_OUT : GPIO_IN);
+#endif
+}
+
+int probe_reset_level(void)
+{
+#if defined(PROBE_PIN_RESET)
+    return gpio_get(PROBE_PIN_RESET);
+#else
+    return 0;
+#endif
+}
+
+typedef enum probe_pio_command {
+    CMD_WRITE = 0,
+    CMD_SKIP,
+    CMD_TURNAROUND,
+    CMD_READ
+} probe_pio_command_t;
+
+static inline uint32_t fmt_probe_command(uint bit_count, bool out_en, probe_pio_command_t cmd) {
+    uint cmd_addr =
+        cmd == CMD_WRITE      ? probe.offset + probe_offset_write_cmd :
+        cmd == CMD_SKIP       ? probe.offset + probe_offset_get_next_cmd :
+        cmd == CMD_TURNAROUND ? probe.offset + probe_offset_turnaround_cmd :
+                                probe.offset + probe_offset_read_cmd;
+    return ((bit_count - 1) & 0xff) | ((uint)out_en << 8) | (cmd_addr << 9);
 }

 void probe_write_bits(uint bit_count, uint32_t data_byte) {
    DEBUG_PINS_SET(probe_timing, DBG_PIN_WRITE);
-    pio_sm_put_blocking(pio0, PROBE_SM, bit_count - 1);
+    pio_sm_put_blocking(pio0, PROBE_SM, fmt_probe_command(bit_count, true, CMD_WRITE));
    pio_sm_put_blocking(pio0, PROBE_SM, data_byte);
-    DEBUG_PINS_SET(probe_timing, DBG_PIN_WRITE_WAIT);
-    picoprobe_dump("Write %d bits 0x%x\n", bit_count, data_byte);
-    // Wait for pio to push garbage to rx fifo so we know it has finished sending
-    pio_sm_get_blocking(pio0, PROBE_SM);
-    DEBUG_PINS_CLR(probe_timing, DBG_PIN_WRITE_WAIT);
+    probe_dump("Write %d bits 0x%x\n", bit_count, data_byte);
+    // Return immediately so we can cue up the next command whilst this one runs
    DEBUG_PINS_CLR(probe_timing, DBG_PIN_WRITE);
 }

+void probe_hiz_clocks(uint bit_count) {
+    pio_sm_put_blocking(pio0, PROBE_SM, fmt_probe_command(bit_count, false, CMD_TURNAROUND));
+    pio_sm_put_blocking(pio0, PROBE_SM, 0);
+}
+
 uint32_t probe_read_bits(uint bit_count) {
    DEBUG_PINS_SET(probe_timing, DBG_PIN_READ);
-    pio_sm_put_blocking(pio0, PROBE_SM, bit_count - 1);
+    pio_sm_put_blocking(pio0, PROBE_SM, fmt_probe_command(bit_count, false, CMD_READ));
    uint32_t data = pio_sm_get_blocking(pio0, PROBE_SM);
    uint32_t data_shifted = data;
    if (bit_count < 32) {
        data_shifted = data >> (32 - bit_count);
    }

-    picoprobe_dump("Read %d bits 0x%x (shifted 0x%x)\n", bit_count, data, data_shifted);
+    probe_dump("Read %d bits 0x%x (shifted 0x%x)\n", bit_count, data, data_shifted);
    DEBUG_PINS_CLR(probe_timing, DBG_PIN_READ);
    return data_shifted;
 }

+static void probe_wait_idle() {
+    pio0->fdebug = 1u << (PIO_FDEBUG_TXSTALL_LSB + PROBE_SM);
+    while (!(pio0->fdebug & (1u << (PIO_FDEBUG_TXSTALL_LSB + PROBE_SM))))
+        ;
+}
+
 void probe_read_mode(void) {
-    pio_sm_exec(pio0, PROBE_SM, pio_encode_jmp(probe.offset + probe_offset_in_posedge));
-    while(pio0->dbg_padoe & (1 << PROBE_PIN_SWDIO));
+    pio_sm_put_blocking(pio0, PROBE_SM, fmt_probe_command(0, false, CMD_SKIP));
+    probe_wait_idle();
 }

 void probe_write_mode(void) {
-    pio_sm_exec(pio0, PROBE_SM, pio_encode_jmp(probe.offset + probe_offset_out_negedge));
-    while(!(pio0->dbg_padoe & (1 << PROBE_PIN_SWDIO)));
-}
-
-void probe_gpio_init()
-{
-    // Funcsel pins
-    pio_gpio_init(pio0, PROBE_PIN_SWCLK);
-    pio_gpio_init(pio0, PROBE_PIN_SWDIO);
-    // Make sure SWDIO has a pullup on it. Idle state is high
-    gpio_pull_up(PROBE_PIN_SWDIO);
+    pio_sm_put_blocking(pio0, PROBE_SM, fmt_probe_command(0, true, CMD_SKIP));
+    probe_wait_idle();
 }

 void probe_init() {
-    // Target reset pin: pull up, input to emulate open drain pin
-    gpio_pull_up(PROBE_PIN_RESET);
-    // gpio_init will leave the pin cleared and set as input
-    gpio_init(PROBE_PIN_RESET);
    if (!probe.initted) {
+        probe_gpio_init();
        uint offset = pio_add_program(pio0, &probe_program);
        probe.offset = offset;

        pio_sm_config sm_config = probe_program_get_default_config(offset);
-
-        // Set SWCLK as a sideset pin
-        sm_config_set_sideset_pins(&sm_config, PROBE_PIN_SWCLK);
-
-        // Set SWDIO offset
-        sm_config_set_out_pins(&sm_config, PROBE_PIN_SWDIO, 1);
-        sm_config_set_set_pins(&sm_config, PROBE_PIN_SWDIO, 1);
-#ifdef PROBE_PIN_SWDI
-        sm_config_set_in_pins(&sm_config, PROBE_PIN_SWDI);
-#else
-        sm_config_set_in_pins(&sm_config, PROBE_PIN_SWDIO);
-#endif
-
-        // Set SWD and SWDIO pins as output to start. This will be set in the sm
-        pio_sm_set_consecutive_pindirs(pio0, PROBE_SM, PROBE_PIN_OFFSET, 2, true);
-
-        // shift output right, autopull off, autopull threshold
-        sm_config_set_out_shift(&sm_config, true, false, 0);
-        // shift input right as swd data is lsb first, autopush off
-        sm_config_set_in_shift(&sm_config, true, false, 0);
-
-        // Init SM with config
+        probe_sm_init(&sm_config);
        pio_sm_init(pio0, PROBE_SM, offset, &sm_config);

        // Set up divisor
        probe_set_swclk_freq(1000);

-        // Enable SM
+        // Jump SM to command dispatch routine, and enable it
+        pio_sm_exec(pio0, PROBE_SM, offset + probe_offset_get_next_cmd);
        pio_sm_set_enabled(pio0, PROBE_SM, 1);
        probe.initted = 1;
    }
-
-    // Jump to write program
-    probe_write_mode();
 }

 void probe_deinit(void)
 {
-  probe_read_mode();
  if (probe.initted) {
+    probe_read_mode();
    pio_sm_set_enabled(pio0, PROBE_SM, 0);
    pio_remove_program(pio0, &probe_program, probe.offset);
+
+    probe_assert_reset(1);	// de-assert nRESET
+    probe_gpio_deinit();
    probe.initted = 0;
  }
 }
-
-void probe_handle_read(uint total_bits) {
-    picoprobe_debug("Read %d bits\n", total_bits);
-    probe_read_mode();
-
-    uint chunk;
-    uint bits = total_bits;
-    while (bits > 0) {
-        if (bits > 8) {
-            chunk = 8;
-        } else {
-            chunk = bits;
-        }
-        probe.tx_buf[probe.tx_len] = (uint8_t)probe_read_bits(chunk);
-        probe.tx_len++;
-        // Decrement remaining bits
-        bits -= chunk;
-    }
-}
-
-void probe_handle_write(uint8_t *data, uint total_bits) {
-    picoprobe_debug("Write %d bits\n", total_bits);
-
-    led_signal_activity(total_bits);
-
-    probe_write_mode();
-
-    uint chunk;
-    uint bits = total_bits;
-    while (bits > 0) {
-        if (bits > 8) {
-            chunk = 8;
-        } else {
-            chunk = bits;
-        }
-
-        probe_write_bits(chunk, (uint32_t)*data++);
-        bits -= chunk;
-    }
-}
-
-void probe_prepare_read_header(struct probe_cmd_hdr *hdr) {
-    // We have a read so need to prefix the data with the cmd header
-    if (probe.tx_len == 0) {
-        // Reserve some space for probe_pkt_hdr
-        probe.tx_len += sizeof(struct probe_pkt_hdr);
-    }
-
-    memcpy((void*)&probe.tx_buf[probe.tx_len], hdr, sizeof(struct probe_cmd_hdr));
-    probe.tx_len += sizeof(struct probe_cmd_hdr);
-}
-
-void probe_handle_pkt(void) {
-    uint8_t *pkt = &probe.rx_buf[0] + sizeof(struct probe_pkt_hdr);
-    uint remaining = probe.rx_len - sizeof(struct probe_pkt_hdr);
-
-    DEBUG_PINS_SET(probe_timing, DBG_PIN_PKT);
-
-    picoprobe_debug("Processing packet of length %d\n", probe.rx_len);
-
-    probe.tx_len = 0;
-    while (remaining) {
-        struct probe_cmd_hdr *hdr = (struct probe_cmd_hdr*)pkt;
-        uint data_bytes = DIV_ROUND_UP(hdr->bits, 8);
-        pkt += sizeof(struct probe_cmd_hdr);
-        remaining -= sizeof(struct probe_cmd_hdr);
-
-        if (hdr->cmd == PROBE_WRITE_BITS) {
-            uint8_t *data = pkt;
-            probe_handle_write(data, hdr->bits);
-            pkt += data_bytes;
-            remaining -= data_bytes;
-        } else if (hdr->cmd == PROBE_READ_BITS) {
-            probe_prepare_read_header(hdr);
-            probe_handle_read(hdr->bits);
-        } else if (hdr->cmd == PROBE_SET_FREQ) {
-            probe_set_swclk_freq(hdr->bits);
-        } else if (hdr->cmd == PROBE_RESET) {
-            // TODO: Is there anything to do after a reset?
-            // tx len and rx len should already be 0
-            ;
-        } else if (hdr->cmd == PROBE_TARGET_RESET) {
-            probe_assert_reset(hdr->bits);
-        }
-    }
-    probe.rx_len = 0;
-
-    if (probe.tx_len) {
-        // Fill in total packet length before sending
-        struct probe_pkt_hdr *tx_hdr = (struct probe_pkt_hdr*)&probe.tx_buf[0];
-        tx_hdr->total_packet_length = probe.tx_len;
-        tud_vendor_write(&probe.tx_buf[0], probe.tx_len);
-        picoprobe_debug("Picoprobe wrote %d response bytes\n", probe.tx_len);
-    }
-    probe.tx_len = 0;
-
-    DEBUG_PINS_CLR(probe_timing, DBG_PIN_PKT);
-}
-
-// USB bits
-void probe_task(void) {
-    if ( tud_vendor_available() ) {
-        uint count = tud_vendor_read(&probe.rx_buf[probe.rx_len], 64);
-        if (count == 0) {
-            return;
-        }
-        probe.rx_len += count;
-    }
-
-    if (probe.rx_len >= sizeof(struct probe_pkt_hdr)) {
-        struct probe_pkt_hdr *pkt_hdr = (struct probe_pkt_hdr*)&probe.rx_buf[0];
-        if (pkt_hdr->total_packet_length == probe.rx_len) {
-            probe_handle_pkt();
-        }
-    }
-}
--- a/src/probe.h
+++ b/src/probe.h
@@ -26,19 +26,27 @@
 #ifndef PROBE_H_
 #define PROBE_H_

+#if defined(PROBE_IO_RAW) || defined(PROBE_IO_SWDI)
+#include "probe.pio.h"
+#endif
+
+#if defined(PROBE_IO_OEN)
+#include "probe_oen.pio.h"
+#endif
+
 void probe_set_swclk_freq(uint freq_khz);
+
+// Bit counts in the range 1..256
 void probe_write_bits(uint bit_count, uint32_t data_byte);
 uint32_t probe_read_bits(uint bit_count);
+void probe_hiz_clocks(uint bit_count);

 void probe_read_mode(void);
 void probe_write_mode(void);

-void probe_handle_read(uint total_bits);
-void probe_handle_write(uint8_t *data, uint total_bits);
-
-void probe_task(void);
-void probe_gpio_init(void);
 void probe_init(void);
 void probe_deinit(void);
+void probe_assert_reset(bool state);
+int probe_reset_level(void);

 #endif
--- a/src/probe.pio
+++ b/src/probe.pio
@@ -1,7 +1,7 @@
 /*
 * The MIT License (MIT)
 *
- * Copyright (c) 2021 Raspberry Pi (Trading) Ltd.
+ * Copyright (c) 2021-2023 Raspberry Pi (Trading) Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
@@ -23,27 +23,104 @@
 *
 */

+// Every TX FIFO entry is either a command, or up to 32 bits of data.
+// Command format:
+//
+// | 13:9 |  8  |  7:0  |
+// | Cmd  | Dir | Count |
+//
+// Count is the number of bits to be transferred by this command, minus 1.
+// Dir is the output enable for the SWDIO pin.
+// Cmd is the address of the write_cmd, read_cmd or get_next_cmd label.
+//
+// write_cmd expects a FIFO data entry, but read_cmd does not.
+//
+// read_cmd pushes data to the FIFO, but write_cmd does not. (The lack of RX
+// garbage on writes allows the interface code to return early after pushing a
+// write command, as there is no need in general to poll for a command's
+// completion as long as all commands are executed in order.)
+//
+// The SWCLK period is 4 PIO SM execution cycles.
+
 .program probe
 .side_set 1 opt

-public out_negedge:
-    set pindirs, 1 side 0x0 ; Init OE clock 0
-    pull           ; Pull number of bits to shift -1 from tx fifo and put into output shift register
-    mov x, osr     ; mov bits to shift -1 from output shift register into x
-    pull           ; Pull data to shift out
-out_negedge_bitloop:
-    out pins, 1                  side 0x0 ; clock data out on falling edge
-    jmp  x-- out_negedge_bitloop side 0x1 ; data is present for posedge
-    set pins, 1                  side 0x0 ; Drive data high (idle bus state)
-    push                                 ; Push to rx fifo just so processor knows when done
-    jmp out_negedge                      ; Wait for next transaction
+public write_cmd:
+public turnaround_cmd:                      ; Alias of write, used for probe_oen.pio
+    pull
+write_bitloop:
+    out pins, 1             [1]  side 0x0   ; Data is output by host on negedge
+    jmp x-- write_bitloop   [1]  side 0x1   ; ...and captured by target on posedge
+                                            ; Fall through to next command
+.wrap_target
+public get_next_cmd:
+    pull                         side 0x0   ; SWCLK is initially low
+    out x, 8                                ; Get bit count
+    out pindirs, 1                          ; Set SWDIO direction
+    out pc, 5                               ; Go to command routine

-public in_posedge:
-    set pindirs, 0 side 0x0 ; INIT IE clock 0
-    pull                   ; Pull number of bits to shift -1 from tx fifo and put into output shift register
-    mov x, osr             ; mov bits to shift -1 from output shift register into x into x
-in_posedge_bitloop:
-    in pins, 1                        side 0x1 ; Generate posedge and read data
-    jmp x-- in_posedge_bitloop        side 0x0 ;
-    push                                      ; Push to rx fifo when done
-    jmp in_posedge                            ; Jump back to start
+read_bitloop:
+    nop                                     ; Additional delay on taken loop branch
+public read_cmd:
+    in pins, 1              [1]  side 0x1   ; Data is captured by host on posedge
+    jmp x-- read_bitloop         side 0x0
+    push
+.wrap                                       ; Wrap to next command
+
+
+; Implement probe_gpio_init() and probe_sm_init() methods here - set pins, offsets, sidesets etc
+% c-sdk {
+
+static inline void probe_gpio_init()
+{
+#if defined(PROBE_PIN_RESET)
+    // Target reset pin: pull up, input to emulate open drain pin
+    gpio_pull_up(PROBE_PIN_RESET);
+    // gpio_init will leave the pin cleared and set as input
+    gpio_init(PROBE_PIN_RESET);
+#endif
+    // Funcsel pins
+    pio_gpio_init(pio0, PROBE_PIN_SWCLK);
+    pio_gpio_init(pio0, PROBE_PIN_SWDIO);
+    // Make sure SWDIO has a pullup on it. Idle state is high
+    gpio_pull_up(PROBE_PIN_SWDIO);
+}
+
+// DAP interface says all pins have to be High-Z when disabled
+static inline void probe_gpio_deinit()
+{
+#if defined(PROBE_PIN_RESET)
+	gpio_deinit(PROBE_PIN_RESET);
+	gpio_disable_pulls(PROBE_PIN_RESET);
+#endif
+	gpio_deinit(PROBE_PIN_SWCLK);
+	gpio_disable_pulls(PROBE_PIN_SWCLK);
+	gpio_deinit(PROBE_PIN_SWDIO);
+	gpio_disable_pulls(PROBE_PIN_SWDIO);
+}
+
+static inline void probe_sm_init(pio_sm_config* sm_config) {
+
+    // Set SWCLK as a sideset pin
+    sm_config_set_sideset_pins(sm_config, PROBE_PIN_SWCLK);
+
+    // Set SWDIO offset
+    sm_config_set_out_pins(sm_config, PROBE_PIN_SWDIO, 1);
+    sm_config_set_set_pins(sm_config, PROBE_PIN_SWDIO, 1);
+#ifdef PROBE_IO_SWDI
+    sm_config_set_in_pins(sm_config, PROBE_PIN_SWDI);
+#else
+    sm_config_set_in_pins(sm_config, PROBE_PIN_SWDIO);
+#endif
+
+
+    // Set SWD and SWDIO pins as output to start. This will be set in the sm
+    pio_sm_set_consecutive_pindirs(pio0, PROBE_SM, PROBE_PIN_OFFSET, 2, true);
+
+    // shift output right, autopull off, autopull threshold
+    sm_config_set_out_shift(sm_config, true, false, 0);
+    // shift input right as swd data is lsb first, autopush off
+    sm_config_set_in_shift(sm_config, true, false, 0);
+}
+
+%}
--- a/src/probe_config.c
+++ b/src/probe_config.c
@@ -0,0 +1,48 @@
+#include "probe_config.h"
+#include "pico/binary_info.h"
+
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+
+
+void bi_decl_config()
+{
+#ifdef PROBE_PIN_RESET
+    bi_decl(bi_1pin_with_name(PROBE_PIN_RESET, "PROBE RESET"));
+#endif
+
+#ifdef PROBE_PIN_SWCLK
+    bi_decl(bi_1pin_with_name(PROBE_PIN_SWCLK, "PROBE SWCLK"));
+#endif
+
+#ifdef PROBE_PIN_SWDIO
+    bi_decl(bi_1pin_with_name(PROBE_PIN_SWDIO, "PROBE SWDIO"));
+#endif
+
+#ifdef PROBE_PIN_SWDI
+    bi_decl(bi_1pin_with_name(PROBE_PIN_SWDI, "PROBE SWDI"));
+#endif
+
+#ifdef PROBE_PIN_SWDIOEN
+    bi_decl(bi_1pin_with_name(PROBE_PIN_SWDIOEN, "PROBE SWDIOEN"));
+#endif
+
+#ifdef PROBE_CDC_UART
+    bi_decl(bi_program_feature("PROBE UART INTERFACE " STR(PROBE_UART_INTERFACE)));
+    bi_decl(bi_program_feature("PROBE UART BAUDRATE " STR(PROBE_UART_BAUDRATE)));
+    bi_decl(bi_1pin_with_name(PROBE_UART_TX, "PROBE UART TX"));
+    bi_decl(bi_1pin_with_name(PROBE_UART_RX, "PROBE UART RX"));
+#endif
+
+#ifdef PROBE_UART_CTS
+    bi_decl(bi_1pin_with_name(PROBE_UART_CTS, "PROBE UART CTS"));
+#endif
+#ifdef PROBE_UART_RTS
+    bi_decl(bi_1pin_with_name(PROBE_UART_RTS, "PROBE UART RTS"));
+#endif
+#ifdef PROBE_UART_DTR
+    bi_decl(bi_1pin_with_name(PROBE_UART_DTR, "PROBE UART DTR"));
+#endif
+
+}
--- a/src/probe_config.h
+++ b/src/probe_config.h
@@ -0,0 +1,86 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Raspberry Pi (Trading) Ltd.
+ *
+ * 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 PROBE_CONFIG_H_
+#define PROBE_CONFIG_H_
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#if false
+#define probe_info(format,args...) \
+do { \
+	vTaskSuspendAll(); \
+	printf(format, ## args); \
+	xTaskResumeAll(); \
+} while (0)
+#else
+#define probe_info(format,...) ((void)0)
+#endif
+
+
+#if false
+#define probe_debug(format,args...) \
+do { \
+	vTaskSuspendAll(); \
+	printf(format, ## args); \
+	xTaskResumeAll(); \
+} while (0)
+#else
+#define probe_debug(format,...) ((void)0)
+#endif
+
+#if false
+#define probe_dump(format,args...)\
+do { \
+	vTaskSuspendAll(); \
+	printf(format, ## args); \
+	xTaskResumeAll(); \
+} while (0)
+#else
+#define probe_dump(format,...) ((void)0)
+#endif
+
+// TODO tie this up with PICO_BOARD defines in the main SDK
+
+#ifdef DEBUG_ON_PICO 
+#include "board_pico_config.h"
+#else
+#include "board_debug_probe_config.h"
+#endif
+//#include "board_example_config.h"
+
+// Add the configuration to binary information
+void bi_decl_config();
+
+#define PROTO_DAP_V1 1
+#define PROTO_DAP_V2 2
+
+// Interface config
+#ifndef PROBE_DEBUG_PROTOCOL
+#define PROBE_DEBUG_PROTOCOL PROTO_DAP_V2
+#endif
+
+#endif
--- a/src/probe_oen.pio
+++ b/src/probe_oen.pio
@@ -0,0 +1,100 @@
+; SPDX-License-Identifier: MIT
+; Copyright (c) 2023 Raspberry Pi Ltd
+
+; Output-enable active-low variant of the SWD probe
+
+; This program is very similar to the one in probe.pio. The only difference is
+; that here write_cmd and turnaround_cmd are split into two separate routines,
+; whose difference is OEn being high/low.
+
+; SWDIO_OEn is pin 0, SWCLK pin 1, SWDIO (out) pin 2, SWDI (in) pin 3.
+; Pin 0 and 1 are sideset pins
+
+.program probe
+.side_set 2 opt
+
+public turnaround_cmd:
+    pull
+turnaround_bitloop:
+    nop                         [1]  side 0x1
+    jmp x-- turnaround_bitloop  [1]  side 0x3
+    jmp get_next_cmd
+
+public write_cmd:
+    pull
+write_bitloop:
+    out pins, 1                 [1]  side 0x0   ; Data is output by host on negedge
+    jmp x-- write_bitloop       [1]  side 0x2   ; ...and captured by target on posedge
+                                                ; Fall through to next command
+.wrap_target
+public get_next_cmd:
+    pull                             side 0x1   ; SWCLK initially low, OEn disabled
+    out x, 8                                    ; Get bit count
+    out pindirs, 1                              ; Set SWDIO direction
+    out pc, 5                                   ; Go to command routine
+
+read_bitloop:
+    nop                                         ; Additional delay on taken loop branch
+public read_cmd:
+    in pins, 1                  [1]  side 0x3   ; Data is captured by host on posedge
+    jmp x-- read_bitloop             side 0x1
+    push
+.wrap                                           ; Wrap to next command
+
+
+; Implement probe_gpio_init() and probe_sm_init() methods here - set pins, offsets, sidesets etc
+% c-sdk {
+
+static inline void probe_gpio_init()
+{
+#if defined(PROBE_PIN_RESET)
+    // Target reset pin: pull up, input to emulate open drain pin
+    gpio_pull_up(PROBE_PIN_RESET);
+    // gpio_init will leave the pin cleared and set as input
+    gpio_init(PROBE_PIN_RESET);
+#endif
+    // Funcsel pins
+    pio_gpio_init(pio0, PROBE_PIN_SWDIOEN);
+    pio_gpio_init(pio0, PROBE_PIN_SWCLK);
+    pio_gpio_init(pio0, PROBE_PIN_SWDIO);
+
+    // Make sure SWDIO has a pullup on it. Idle state is high
+    gpio_pull_up(PROBE_PIN_SWDIO);
+    gpio_pull_up(PROBE_PIN_SWDIOEN);
+}
+
+// DAP interface says all pins have to be High-Z when disabled
+static inline void probe_gpio_deinit()
+{
+#if defined(PROBE_PIN_RESET)
+	gpio_deinit(PROBE_PIN_RESET);
+	gpio_disable_pulls(PROBE_PIN_RESET);
+#endif
+	gpio_deinit(PROBE_PIN_SWCLK);
+	gpio_disable_pulls(PROBE_PIN_SWCLK);
+// Note for SWDIOEN - make sure the driver output enable is removed before removing drive - leave pull-up enabled
+	gpio_deinit(PROBE_PIN_SWDIOEN);
+	gpio_deinit(PROBE_PIN_SWDIO);
+	gpio_disable_pulls(PROBE_PIN_SWDIO);
+}
+
+static inline void probe_sm_init(pio_sm_config* sm_config) {
+
+    // Set SWDIOEN and SWCLK as sideset pins
+    sm_config_set_sideset_pins(sm_config, PROBE_PIN_SWDIOEN);
+
+    // Set SWDIO offset
+    sm_config_set_out_pins(sm_config, PROBE_PIN_SWDIO, 1);
+    sm_config_set_set_pins(sm_config, PROBE_PIN_SWDIO, 1);
+    sm_config_set_in_pins(sm_config, PROBE_PIN_SWDI);
+
+    // Set SWDIOEN, SWD and SWDIO pins as output to start. This will be set in the sm
+    pio_sm_set_consecutive_pindirs(pio0, PROBE_SM, PROBE_PIN_OFFSET, 3, true);
+
+    // shift output right, autopull off, autopull threshold
+    sm_config_set_out_shift(sm_config, true, false, 0);
+    // shift input right as swd data is lsb first, autopush off
+    sm_config_set_in_shift(sm_config, true, false, 0);
+}
+
+%}
--- a/src/sw_dp_pio.c
+++ b/src/sw_dp_pio.c
@@ -19,7 +19,7 @@

 /*
 * This is a shim between the SW_DP functions and the PIO
- * implementation used for Picoprobe. Instead of calling bitbash functions,
+ * implementation used for Debugprobe. Instead of calling bitbash functions,
 * hand off the bit sequences to a SM for asynchronous completion.
 */

@@ -47,7 +47,7 @@ void SWJ_Sequence (uint32_t count, const uint8_t *data) {
    probe_set_swclk_freq(MAKE_KHZ(DAP_Data.clock_delay));
    cached_delay = DAP_Data.clock_delay;
  }
-  picoprobe_debug("SWJ sequence count = %d FDB=0x%2x\n", count, data[0]);
+  probe_debug("SWJ sequence count = %d FDB=0x%2x\n", count, data[0]);
  n = count;
  while (n > 0) {
    if (n > 8)
@@ -74,7 +74,7 @@ void SWD_Sequence (uint32_t info, const uint8_t *swdo, uint8_t *swdi) {
    probe_set_swclk_freq(MAKE_KHZ(DAP_Data.clock_delay));
    cached_delay = DAP_Data.clock_delay;
  }
-  picoprobe_debug("SWD sequence\n");
+  probe_debug("SWD sequence\n");
  n = info & SWD_SEQUENCE_CLK;
  if (n == 0U) {
    n = 64U;
@@ -119,7 +119,7 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
    probe_set_swclk_freq(MAKE_KHZ(DAP_Data.clock_delay));
    cached_delay = DAP_Data.clock_delay;
  }
-  picoprobe_debug("SWD_transfer\n");
+  probe_debug("SWD_transfer\n");
  /* Generate the request packet */
  prq |= (1 << 0); /* Start Bit */
  for (n = 1; n < 5; n++) {
@@ -133,8 +133,6 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
  probe_write_bits(8, prq);

  /* Turnaround (ignore read bits) */
-  probe_read_mode();
-
  ack = probe_read_bits(DAP_Data.swd_conf.turnaround + 3);
  ack >>= DAP_Data.swd_conf.turnaround;

@@ -151,15 +149,13 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
      }
      if (data)
        *data = val;
-      picoprobe_debug("Read %02x ack %02x 0x%08x parity %01x\n",
+      probe_debug("Read %02x ack %02x 0x%08x parity %01x\n",
                      prq, ack, val, bit);
      /* Turnaround for line idle */
-      probe_read_bits(DAP_Data.swd_conf.turnaround);
-      probe_write_mode();
+      probe_hiz_clocks(DAP_Data.swd_conf.turnaround);
    } else {
      /* Turnaround for write */
-      probe_read_bits(DAP_Data.swd_conf.turnaround);
-      probe_write_mode();
+      probe_hiz_clocks(DAP_Data.swd_conf.turnaround);

      /* Write WDATA[0:31] */
      val = *data;
@@ -167,7 +163,7 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
      parity = __builtin_popcount(val);
      /* Write Parity Bit */
      probe_write_bits(1, parity & 0x1);
-      picoprobe_debug("write %02x ack %02x 0x%08x parity %01x\n",
+      probe_debug("write %02x ack %02x 0x%08x parity %01x\n",
                      prq, ack, val, parity);
    }
    /* Capture Timestamp */
@@ -178,9 +174,9 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
    /* Idle cycles - drive 0 for N clocks */
    if (DAP_Data.transfer.idle_cycles) {
      for (n = DAP_Data.transfer.idle_cycles; n; ) {
-        if (n > 32) {
-          probe_write_bits(32, 0);
-          n -= 32;
+        if (n > 256) {
+          probe_write_bits(256, 0);
+          n -= 256;
        } else {
          probe_write_bits(n, 0);
          n -= n;
@@ -195,8 +191,7 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
      /* Dummy Read RDATA[0:31] + Parity */
      probe_read_bits(33);
    }
-    probe_read_bits(DAP_Data.swd_conf.turnaround);
-    probe_write_mode();
+    probe_hiz_clocks(DAP_Data.swd_conf.turnaround);
    if (DAP_Data.swd_conf.data_phase && ((request & DAP_TRANSFER_RnW) == 0U)) {
      /* Dummy Write WDATA[0:31] + Parity */
      probe_write_bits(32, 0);
@@ -209,7 +204,6 @@ uint8_t SWD_Transfer (uint32_t request, uint32_t *data) {
  n = DAP_Data.swd_conf.turnaround + 32U + 1U;
  /* Back off data phase */
  probe_read_bits(n);
-  probe_write_mode();
  return ((uint8_t)ack);
 }

--- a/src/tusb_config.h
+++ b/src/tusb_config.h
@@ -68,12 +68,23 @@
 #define CFG_TUD_MIDI            0
 #define CFG_TUD_VENDOR          1

+/*
+ * TX bufsize (actually UART RX) is oversized because the Windows CDC-ACM
+ * driver submits a grand total of _one_ URB at any one time.
+ * This means the application must consume the data before the next IN token
+ * is issued. At high datarates this leads to huge variation in instantaneous
+ * throughput on USB, so a large runway is needed.
+ */
 #define CFG_TUD_CDC_RX_BUFSIZE 64
-#define CFG_TUD_CDC_TX_BUFSIZE 64
+#define CFG_TUD_CDC_TX_BUFSIZE 4096

 #define CFG_TUD_VENDOR_RX_BUFSIZE 8192
 #define CFG_TUD_VENDOR_TX_BUFSIZE 8192

+#ifndef TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX
+#define TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX 1
+#endif
+
 #ifdef __cplusplus
 }
 #endif
--- a/src/tusb_edpt_handler.c
+++ b/src/tusb_edpt_handler.c
@@ -0,0 +1,291 @@
+/**
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "tusb_edpt_handler.h"
+#include "DAP.h"
+
+static uint8_t itf_num;
+static uint8_t _rhport;
+
+volatile uint32_t _resp_len;
+
+static uint8_t _out_ep_addr;
+static uint8_t _in_ep_addr;
+
+static buffer_t USBRequestBuffer;
+static buffer_t USBResponseBuffer;
+
+static uint8_t DAPRequestBuffer[DAP_PACKET_SIZE];
+static uint8_t DAPResponseBuffer[DAP_PACKET_SIZE];
+
+#define WR_IDX(x) (x.wptr % DAP_PACKET_COUNT)
+#define RD_IDX(x) (x.rptr % DAP_PACKET_COUNT)
+
+#define WR_SLOT_PTR(x) &(x.data[WR_IDX(x)][0])
+#define RD_SLOT_PTR(x) &(x.data[RD_IDX(x)][0])
+
+bool buffer_full(buffer_t *buffer)
+{
+	return ((buffer->wptr + 1) % DAP_PACKET_COUNT == buffer->rptr);
+}
+
+bool buffer_empty(buffer_t *buffer)
+{
+	return (buffer->wptr == buffer->rptr);
+}
+
+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;
+}
+
+char * dap_cmd_string[] = {
+	[ID_DAP_Info               ] = "DAP_Info",
+	[ID_DAP_HostStatus         ] = "DAP_HostStatus",
+	[ID_DAP_Connect            ] = "DAP_Connect",
+	[ID_DAP_Disconnect         ] = "DAP_Disconnect",
+	[ID_DAP_TransferConfigure  ] = "DAP_TransferConfigure",
+	[ID_DAP_Transfer           ] = "DAP_Transfer",
+	[ID_DAP_TransferBlock      ] = "DAP_TransferBlock",
+	[ID_DAP_TransferAbort      ] = "DAP_TransferAbort",
+	[ID_DAP_WriteABORT         ] = "DAP_WriteABORT",
+	[ID_DAP_Delay              ] = "DAP_Delay",
+	[ID_DAP_ResetTarget        ] = "DAP_ResetTarget",
+	[ID_DAP_SWJ_Pins           ] = "DAP_SWJ_Pins",
+	[ID_DAP_SWJ_Clock          ] = "DAP_SWJ_Clock",
+	[ID_DAP_SWJ_Sequence       ] = "DAP_SWJ_Sequence",
+	[ID_DAP_SWD_Configure      ] = "DAP_SWD_Configure",
+	[ID_DAP_SWD_Sequence       ] = "DAP_SWD_Sequence",
+	[ID_DAP_JTAG_Sequence      ] = "DAP_JTAG_Sequence",
+	[ID_DAP_JTAG_Configure     ] = "DAP_JTAG_Configure",
+	[ID_DAP_JTAG_IDCODE        ] = "DAP_JTAG_IDCODE",
+	[ID_DAP_SWO_Transport      ] = "DAP_SWO_Transport",
+	[ID_DAP_SWO_Mode           ] = "DAP_SWO_Mode",
+	[ID_DAP_SWO_Baudrate       ] = "DAP_SWO_Baudrate",
+	[ID_DAP_SWO_Control        ] = "DAP_SWO_Control",
+	[ID_DAP_SWO_Status         ] = "DAP_SWO_Status",
+	[ID_DAP_SWO_ExtendedStatus ] = "DAP_SWO_ExtendedStatus",
+	[ID_DAP_SWO_Data           ] = "DAP_SWO_Data",
+	[ID_DAP_QueueCommands      ] = "DAP_QueueCommands",
+	[ID_DAP_ExecuteCommands    ] = "DAP_ExecuteCommands",
+};
+
+
+uint16_t dap_edpt_open(uint8_t __unused rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len)
+{
+
+	TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass &&
+			DAP_INTERFACE_SUBCLASS == itf_desc->bInterfaceSubClass &&
+			DAP_INTERFACE_PROTOCOL == itf_desc->bInterfaceProtocol, 0);
+
+	//  Initialise circular buffer indices
+	USBResponseBuffer.wptr = 0;
+	USBResponseBuffer.rptr = 0;
+	USBRequestBuffer.wptr = 0;
+	USBRequestBuffer.rptr = 0;
+
+	// Initialse full/empty flags
+	USBResponseBuffer.wasFull = false;
+	USBResponseBuffer.wasEmpty = true;
+	USBRequestBuffer.wasFull = false;
+	USBRequestBuffer.wasEmpty = true;
+
+	uint16_t const drv_len = sizeof(tusb_desc_interface_t) + (itf_desc->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
+	TU_VERIFY(max_len >= drv_len, 0);
+	itf_num = itf_desc->bInterfaceNumber;
+
+	// Initialising the OUT endpoint
+
+	tusb_desc_endpoint_t *edpt_desc = (tusb_desc_endpoint_t *) (itf_desc + 1);
+	uint8_t ep_addr = edpt_desc->bEndpointAddress;
+
+	_out_ep_addr = ep_addr;
+
+	// The OUT endpoint requires a call to usbd_edpt_xfer to initialise the endpoint, giving tinyUSB a buffer to consume when a transfer occurs at the endpoint
+	usbd_edpt_open(rhport, edpt_desc);
+	usbd_edpt_xfer(rhport, ep_addr, WR_SLOT_PTR(USBRequestBuffer), DAP_PACKET_SIZE);
+
+	// Initiliasing the IN endpoint
+
+	edpt_desc++;
+	ep_addr = edpt_desc->bEndpointAddress;
+
+	_in_ep_addr = ep_addr;
+
+	// The IN endpoint doesn't need a transfer to initialise it, as this will be done by the main loop of dap_thread
+	usbd_edpt_open(rhport, edpt_desc);
+
+	return drv_len;
+
+}
+
+bool dap_edpt_control_xfer_cb(uint8_t __unused rhport, uint8_t stage, tusb_control_request_t const *request)
+{
+	return false;
+}
+
+// Manage USBResponseBuffer (request) write and USBRequestBuffer (response) read indices
+bool dap_edpt_xfer_cb(uint8_t __unused rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
+{
+	const uint8_t ep_dir = tu_edpt_dir(ep_addr);
+
+	if(ep_dir == TUSB_DIR_IN)
+	{
+		if(xferred_bytes >= 0u && xferred_bytes <= DAP_PACKET_SIZE)
+		{
+			USBResponseBuffer.rptr++;
+
+			// This checks that the buffer was not empty in DAP thread, which means the next buffer was not queued up for the in endpoint callback
+			// So, queue up the buffer at the new read index, since we expect read to catch up to write at this point.
+			// It is possible for the read index to be multiple spaces behind the write index (if the USB callbacks are lagging behind dap thread),
+			// so we account for this by only setting wasEmpty to true if the next callback will empty the buffer
+			if(!USBResponseBuffer.wasEmpty)
+			{
+				usbd_edpt_xfer(rhport, ep_addr, RD_SLOT_PTR(USBResponseBuffer), (uint16_t) _resp_len);
+				USBResponseBuffer.wasEmpty = (USBResponseBuffer.rptr + 1) == USBResponseBuffer.wptr;
+			}
+
+			//  Wake up DAP thread after processing the callback
+			vTaskResume(dap_taskhandle);
+			return true;
+		}
+
+		return false;
+
+	} else if(ep_dir == TUSB_DIR_OUT)    {
+
+		if(xferred_bytes >= 0u && xferred_bytes <= DAP_PACKET_SIZE)
+		{
+			// Only queue the next buffer in the out callback if the buffer is not full
+			// If full, we set the wasFull flag, which will be checked by dap thread
+			if(!buffer_full(&USBRequestBuffer))
+			{
+				USBRequestBuffer.wptr++;
+				usbd_edpt_xfer(rhport, ep_addr, WR_SLOT_PTR(USBRequestBuffer), DAP_PACKET_SIZE);
+				USBRequestBuffer.wasFull = false;
+			}
+			else {
+				USBRequestBuffer.wasFull = true;
+			}
+
+			//  Wake up DAP thread after processing the callback
+			vTaskResume(dap_taskhandle);
+			return true;
+		}
+
+		return false;
+	}
+	else return false;
+}
+
+void dap_thread(void *ptr)
+{
+	uint32_t n;
+	do
+	{
+		while(USBRequestBuffer.rptr != USBRequestBuffer.wptr)
+		{
+			/*
+			 * Atomic command support - buffer QueueCommands, but don't process them
+			 * until a non-QueueCommands packet is seen.
+			 */
+			n = USBRequestBuffer.rptr;
+			while (USBRequestBuffer.data[n % DAP_PACKET_COUNT][0] == ID_DAP_QueueCommands) {
+				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;
+				n++;
+				while (n == USBRequestBuffer.wptr) {
+					/* Need yield in a loop here, as IN callbacks will also wake the thread */
+					probe_info("DAP wait\n");
+					vTaskSuspend(dap_taskhandle);
+				}
+			}
+			// Read a single packet from the USB buffer into the DAP Request buffer
+			memcpy(DAPRequestBuffer, RD_SLOT_PTR(USBRequestBuffer), DAP_PACKET_SIZE);
+			probe_info("%lu %lu DAP cmd %s len %02x\n",
+				       USBRequestBuffer.wptr, USBRequestBuffer.rptr,
+				       dap_cmd_string[DAPRequestBuffer[0]], DAPRequestBuffer[1]);
+			USBRequestBuffer.rptr++;
+
+			// If the buffer was full in the out callback, we need to queue up another buffer for the endpoint to consume, now that we know there is space in the buffer.
+			if(USBRequestBuffer.wasFull)
+			{
+				vTaskSuspendAll(); // Suspend the scheduler to safely update the write index
+				USBRequestBuffer.wptr++;
+				usbd_edpt_xfer(_rhport, _out_ep_addr, WR_SLOT_PTR(USBRequestBuffer), DAP_PACKET_SIZE);
+				USBRequestBuffer.wasFull = false;
+				xTaskResumeAll();
+			}
+
+			_resp_len = DAP_ExecuteCommand(DAPRequestBuffer, DAPResponseBuffer);
+			probe_info("%lu %lu DAP resp %s\n",
+					USBResponseBuffer.wptr, USBResponseBuffer.rptr,
+					dap_cmd_string[DAPResponseBuffer[0]]);
+
+
+			//  Suspend the scheduler to avoid stale values/race conditions between threads
+			vTaskSuspendAll();
+
+			if(buffer_empty(&USBResponseBuffer))
+			{
+				memcpy(WR_SLOT_PTR(USBResponseBuffer), DAPResponseBuffer, (uint16_t) _resp_len);
+				USBResponseBuffer.wptr++;
+
+				usbd_edpt_xfer(_rhport, _in_ep_addr, RD_SLOT_PTR(USBResponseBuffer), (uint16_t) _resp_len);
+			} else {
+
+				memcpy(WR_SLOT_PTR(USBResponseBuffer), DAPResponseBuffer, (uint16_t) _resp_len);
+				USBResponseBuffer.wptr++;
+
+				// The In callback needs to check this flag to know when to queue up the next buffer.
+				USBResponseBuffer.wasEmpty = false;
+			}
+			xTaskResumeAll();
+		}
+
+		// Suspend DAP thread until it is awoken by a USB thread callback
+		vTaskSuspend(dap_taskhandle);
+
+	} while (1);
+
+}
+
+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,
+		.xfer_cb = dap_edpt_xfer_cb,
+		.sof = NULL,
+#if CFG_TUSB_DEBUG >= 2
+		.name = "DAP ENDPOINT"
+#endif
+};
+
+// Add the custom driver to the tinyUSB stack
+usbd_class_driver_t const *usbd_app_driver_get_cb(uint8_t *driver_count)
+{
+	*driver_count = 1;
+	return &_dap_edpt_driver;
+}
+
--- a/src/tusb_edpt_handler.h
+++ b/src/tusb_edpt_handler.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef TUSB_EDPT_HANDLER_H
+#define TUSB_EDPT_HANDLER_H
+
+#include "tusb.h"
+
+#include "device/usbd_pvt.h"
+#include "DAP_config.h"
+
+#define DAP_INTERFACE_SUBCLASS 0x00
+#define DAP_INTERFACE_PROTOCOL 0x00
+
+typedef struct {
+	uint8_t data[DAP_PACKET_COUNT][DAP_PACKET_SIZE];
+	volatile uint32_t wptr;
+	volatile uint32_t rptr;
+	volatile bool wasEmpty;
+	volatile bool wasFull;
+} buffer_t;
+
+extern TaskHandle_t dap_taskhandle, tud_taskhandle;
+
+/* Main DAP loop */
+void dap_thread(void *ptr);
+
+/* Endpoint Handling */
+void dap_edpt_init(void);
+uint16_t dap_edpt_open(uint8_t __unused rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
+bool dap_edpt_control_xfer_cb(uint8_t __unused rhport, uint8_t stage,  tusb_control_request_t const *request);
+bool dap_edpt_xfer_cb(uint8_t __unused rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+
+/* Helper Functions */
+bool buffer_full(buffer_t *buffer);
+bool buffer_empty(buffer_t *buffer);
+
+#endif
--- a/src/usb_descriptors.c
+++ b/src/usb_descriptors.c
@@ -27,7 +27,7 @@

 #include "tusb.h"
 #include "get_serial.h"
-#include "picoprobe_config.h"
+#include "probe_config.h"

 //--------------------------------------------------------------------+
 // Device Descriptors
@@ -36,7 +36,7 @@ tusb_desc_device_t const desc_device =
 {
    .bLength            = sizeof(tusb_desc_device_t),
    .bDescriptorType    = TUSB_DESC_DEVICE,
-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
+#if (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
    .bcdUSB             = 0x0210, // USB Specification version 2.1 for BOS
 #else
    .bcdUSB             = 0x0110,
@@ -47,12 +47,8 @@ tusb_desc_device_t const desc_device =
    .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,

    .idVendor           = 0x2E8A, // Pi
-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_OPENOCD_CUSTOM)
-    .idProduct          = 0x0004, // Picoprobe
-#else
    .idProduct          = 0x000c, // CMSIS-DAP Debug Probe
-#endif
-    .bcdDevice          = 0x0101, // Version 01.01
+    .bcdDevice          = 0x0222, // Version 02.22
    .iManufacturer      = 0x01,
    .iProduct           = 0x02,
    .iSerialNumber      = 0x03,
@@ -81,10 +77,10 @@ enum
 #define CDC_NOTIFICATION_EP_NUM 0x81
 #define CDC_DATA_OUT_EP_NUM 0x02
 #define CDC_DATA_IN_EP_NUM 0x83
-#define PROBE_OUT_EP_NUM 0x04
-#define PROBE_IN_EP_NUM 0x85
+#define DAP_OUT_EP_NUM 0x04
+#define DAP_IN_EP_NUM 0x85

-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V1)
+#if (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V1)
 #define CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_INOUT_DESC_LEN)
 #else
 #define CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_VENDOR_DESC_LEN)
@@ -101,19 +97,19 @@ uint8_t const * tud_hid_descriptor_report_cb(uint8_t itf)
  return desc_hid_report;
 }

-uint8_t const desc_configuration[] =
+uint8_t desc_configuration[] =
 {
-  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0, 100),
  // Interface 0
-#if (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V1)
+#if (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V1)
  // HID (named interface)
-  TUD_HID_INOUT_DESCRIPTOR(ITF_NUM_PROBE, 4, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report), PROBE_OUT_EP_NUM, PROBE_IN_EP_NUM, CFG_TUD_HID_EP_BUFSIZE, 1),
-#elif (PICOPROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
+  TUD_HID_INOUT_DESCRIPTOR(ITF_NUM_PROBE, 4, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report), DAP_OUT_EP_NUM, DAP_IN_EP_NUM, CFG_TUD_HID_EP_BUFSIZE, 1),
+#elif (PROBE_DEBUG_PROTOCOL == PROTO_DAP_V2)
  // Bulk (named interface)
-  TUD_VENDOR_DESCRIPTOR(ITF_NUM_PROBE, 5, PROBE_OUT_EP_NUM, PROBE_IN_EP_NUM, 64),
-#elif (PICOPROBE_DEBUG_PROTOCOL == PROTO_OPENOCD_CUSTOM)
+  TUD_VENDOR_DESCRIPTOR(ITF_NUM_PROBE, 5, DAP_OUT_EP_NUM, DAP_IN_EP_NUM, 64),
+#elif (PROBE_DEBUG_PROTOCOL == PROTO_OPENOCD_CUSTOM)
  // Bulk
-  TUD_VENDOR_DESCRIPTOR(ITF_NUM_PROBE, 0, PROBE_OUT_EP_NUM, PROBE_IN_EP_NUM, 64),
+  TUD_VENDOR_DESCRIPTOR(ITF_NUM_PROBE, 0, DAP_OUT_EP_NUM, DAP_IN_EP_NUM, 64),
 #endif
  // Interface 1 + 2
  TUD_CDC_DESCRIPTOR(ITF_NUM_CDC_COM, 6, CDC_NOTIFICATION_EP_NUM, 64, CDC_DATA_OUT_EP_NUM, CDC_DATA_IN_EP_NUM, 64),
@@ -125,6 +121,8 @@ uint8_t const desc_configuration[] =
 uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
 {
  (void) index; // for multiple configurations
+  /* Hack in CAP_BREAK support */
+  desc_configuration[CONFIG_TOTAL_LEN - TUD_CDC_DESC_LEN + 8 + 9 + 5 + 5 + 4 - 1] = 0x6;
  return desc_configuration;
 }

@@ -137,7 +135,7 @@ char const* string_desc_arr [] =
 {
  (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
  "Raspberry Pi", // 1: Manufacturer
-  "Debug Probe (CMSIS-DAP)", // 2: Product
+  PROBE_PRODUCT_STRING, // 2: Product
  usb_serial,     // 3: Serial, uses flash unique ID
  "CMSIS-DAP v1 Interface", // 4: Interface descriptor for HID transport
  "CMSIS-DAP v2 Interface", // 5: Interface descriptor for Bulk transport
Author	SHA1	Message	Date
P33M	cc69bb8927	Update README.md	2025-03-27 15:53:18 +00:00
Jonathan Bell	c70815a297	Debugprobe release v2.2.2 Point release to address high uart TX baud rate corruption, at the expense of throughput. Also skip over an attempt at UART/SDK optimisation that caused issues for users.	2025-03-13 16:36:24 +00:00
Jonathan Bell	f601757084	Revert "cdc_uart: performance optimisations" This reverts commit `83e28db1d3`.	2025-03-13 11:11:27 +00:00
TankedThomas	1abda4c329	Fix variable pathname spacing Signed-off-by: TankedThomas <TankedThomas@users.noreply.github.com>	2025-03-11 09:50:23 +00:00
Jonathan Bell	83e28db1d3	cdc_uart: performance optimisations For RX, do burst reads without the SDK wrapper function which checks the FIFO flags for each read. For TX, avoid waiting for the FIFO to have space available, which causes significant thread stalls. Use a slightly pessimistic estimate of the number of bytes the TX FIFO should consume and only write up to that number. Also, there's no point tracking whether or not the scheduler parked the thread in a call to xTaskDelayUntil - missing a scheduler tick can't be recovered from.	2025-01-17 15:14:06 +00:00
Jonathan Bell	3d58384754	cdc_uart: work around suspected TinyUSB FIFO bug UART TX corruption has been observed at high baud rates. It seems to be related to thread preemption when a buffer is pushed to the CDC FIFO while another task is reading/updating FIFO pointers. If set to 1x wMaxPacket bytes, the FIFO push only occurs when it is completely empty. This avoids the bug at the cost of some amount of throughput, usually 1-2 USB packet times plus inter-packet delay.	2025-01-17 15:03:02 +00:00
Jonathan Bell	818ed79f4b	Fixes for #160 and #159	2025-01-09 16:34:30 +00:00
Jonathan Bell	53875ec320	Debugprobe release v2.2.1 This release is a point release because unknown/stale submodule(s) caused a regression with long UART TX strings that subsequently could not be reproduced. The build artifacts for this release were compiled on a Raspberry Pi 5 running Raspberry Pi OS (Debian 12) instead of Ubuntu 22.04 on amd64.	2025-01-09 14:49:12 +00:00
Jonathan Bell	9226fac61a	Debugprobe release v2.2.0	2024-12-03 13:16:13 +00:00
Jonathan Bell	06c7792560	main: kludge for Pi 5 reboot crashes The Pi 5 bootloader will leave devices it doesn't care about in the Addressed state, so tud_mount_cb never gets called. Handoff from the bootloader to Linux causes a suspend event followed by Reset. Check if the interface association was configured on entry to Suspend or Resume. Also, TinyUSB doesn't expose Bus Reset events for whatever reason, so there's nothing that tears down the interface threads.	2024-12-03 11:48:25 +00:00
Jonathan Bell	1752f2a61b	CMmakeLists.txt: add pico2 variant target naming	2024-11-29 10:02:49 +00:00
Jonathan Bell	e887004fdf	Debugprobe release v2.1.0	2024-11-27 15:48:41 +00:00
Jonathan Bell	df68d70400	Fix PORT_SWD/PORT_OFF mismatch - do GPIO setup in each	2024-11-27 15:48:41 +00:00
Jonathan Bell	0c84dd0dc1	FreeRTOS: use upstream port again, RP2350 support has landed But the RP2350 kernel import is broken, use copy from pico-examples 2.1.0	2024-11-27 15:10:38 +00:00
Jonathan Bell	4238b780c2	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>	2024-11-27 14:19:33 +00:00
Jonathan Bell	189e367332	main: add callbacks for discrete USB states We can save more power by parking threads when suspended, and threads should be deleted when disconnected. Also fix an inefficiency in usb_thread wakeups when the device is yet to be configured, but is addressed - slowing down control transfers. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2024-11-27 14:19:33 +00:00
Jonathan Bell	d9c507f579	dap_edpt_driver: handle deinit properly Zap pending buffers if the interface went away. Also fix -Wformat warnings. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2024-11-27 14:19:33 +00:00
Jonathan Bell	6d2f83e30c	cdc_uart: be more careful about when the thread gets parked or resumed tud_cdc_connected tests dtr, not rts - so we should do the same. Don't unconditionally wake the uart thread when set_line_coding happens - Windows frequently calls this after every linestate change, including device close. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2024-11-27 14:19:33 +00:00
Jonathan Bell	1182803822	probe: revert pins to Hi-Z when PORT_OFF is called Alternative implementation of #146 Fixes #146	2024-11-27 14:10:51 +00:00
Andrew Burge	65b1e73589	Where enabled: Add calls to set the various xxx_LED status lines as GPIO outputs Signed-off-by: Andrew Burge <andrew.burge@raspberrypi.com>	2024-11-27 11:03:04 +00:00
Jonathan Bell	152f85d2ec	Specify MIT license as the project's default. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2024-11-27 10:58:50 +00:00
Jonathan Bell	d85fd1f58d	Remove unattributed contributions from the project Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2024-11-27 10:45:59 +00:00
Jonathan Bell	8f5d6fcc9f	Clarify pico_sdk_import.cmake license This file was copied from the pico-sdk, which is a BSD 3-Clause project.	2024-11-20 11:21:58 +00:00
Jonathan Bell	9aed4ca509	Add license and copyright to probe_oen.pio This file is directly attributable to Raspberry Pi.	2024-11-20 11:12:09 +00:00
Jonathan Bell	e4585d551a	probe: don't include pio headers directly	2024-11-07 15:13:03 +00:00
Jonathan Bell	46b9613d14	Update to support building for Pico 2 - Update CMSIS to 5.7.0 - Update FreeRTOS to downstream commit aa52f214d Note: for an existing repository clone, you must run git submodule update --init and delete and regenerate your build/ directory.	2024-08-08 14:40:22 +01:00
Jonathan Bell	2bbe900d68	Debugprobe release 2.0.1	2024-04-16 13:43:17 +01:00
tanxiao	7410b45e1d	rename PROBE_IO_SWDIOEN to PROBE_IO_OEN	2024-03-26 19:12:28 +00:00
tanxiao	920f717e71	Add pin names to binary information	2024-03-26 19:12:28 +00:00
Taylor Alexander	34a4ba0e01	Fix incorrect LED ifdefs	2024-03-26 19:11:14 +00:00
Jonathan Bell	0476e9cae5	cdc_uart: add missing clear-break reset of TX LED	2024-03-19 14:49:41 +00:00
Jonathan Bell	c0ff91421a	Debugprobe release 2.0	2024-03-18 16:37:56 +00:00
Jonathan Bell	b5962e0818	Fix builds for which UART_TX_LED aren't defined	2024-03-18 16:37:56 +00:00
Jonathan Bell	ddc028fe18	cdc_acm: turn on UART_TX LED when sending break signals Software typically asserts line break for an extended period (e.g. PuTTY will assert continuously until the next keypress), so provide feedback via the LED. Also declare variables used in both tinyusb callback and uart_thread context as volatile.	2024-03-18 16:01:35 +00:00
Jonathan Bell	af2540b045	cdc_uart: add CTS/RTS configuration options to board_example_config For high data rate applications it's desirable to use hardware flow control to prevent characters getting dropped when faced with the vagaries of RTOS and kernel latencies. Adding PROBE_UART_HWFC enables the UART's CTS/RTS pins, and SET_LINE_STATE messages no longer affect the RTS pin.	2024-03-18 16:01:35 +00:00
Jonathan Bell	d5047e7ef8	cdc_uart: add break handling Implement break set/unset and declare the interface as capable of sending line breaks.	2024-03-18 16:01:35 +00:00
geekman	a7aa0766f0	Make target reset functionality work out-of-the-box (#123 ) * Fix up target reset functionality. - Correct GPIO direction logic error in `probe_assert_reset` - Remember to de-assert nRESET on deinit * board_pico_config: use pin 1 for reset This pin is normally used for UART debug output, but that is undocumented. Repurpose it as reset output. Signed-off-by: Sean Cross <sean@xobs.io> * main: move stdio_uart_init() before DAP_Setup() When using GP1 as a reset line, this is necessary to overwrite the stdio function call from reusing the pin as a debug output. Signed-off-by: Sean Cross <sean@xobs.io> --------- Signed-off-by: Sean Cross <sean@xobs.io> Co-authored-by: Sean Cross <sean@xobs.io>	2024-03-18 15:12:46 +00:00
David Lynch	b09854c639	fix: Corrected typo in preprocessor ifdef * Changed PROBE_UART_RX_LED to PROBE_UART_TX_LED in ifdef to control TX LED	2024-03-18 09:33:57 +00:00
Jonathan Bell	327e15f176	board_debug_probe_config.h - nit	2024-02-05 16:17:46 +00:00
Jonathan Bell	62f4a31335	Update README.md	2024-02-05 16:17:46 +00:00
Jonathan Bell	abf675ca8c	More renaming - Prefix DAP-specific defines with DAP_ - PROBE_ defines refer to config options selected by a board type	2024-02-05 16:17:46 +00:00
Jonathan Bell	d0c03d2564	Rename picoprobe to debugprobe Picoprobe is a registered trademark. Rename to debugprobe, and make it clear that the code in this repository is firmware for the Debug Probe.	2024-02-05 16:17:46 +00:00
Jonathan Bell	1267a8c367	DAP: fix atomic command support Two bugs - ignoring DAP_QueueCommand, and calling DAP_ProcessCommand instead of DAP_Executecommand	2024-01-29 10:09:55 +00:00
Jonathan Bell	bdb1bf287d	tusb_edpt_handler: macroify	2024-01-25 16:48:07 +00:00
Jonathan Bell	d9a975b24e	tusb_edpt_handler - whitespace/indentation	2024-01-25 15:00:31 +00:00
marble	721b69cf5c	cdc_uart: add RTS and DTR pins	2023-09-21 10:57:18 +01:00
Jonathan Bell	2658c2c997	cdc_uart: support databits, stopbits and parity setup	2023-09-18 18:45:44 +01:00
Jonathan Bell	e51647492e	cdc_uart: cater for Windows driver deficiencies It's possible for the Windows CDC-ACM driver to ignore the IN endpoint for long periods of time - multiple frames - if the host application doesn't consume uart RX data. Boost buffer sizes to compensate. Also prevent usb_thread from potentially being idle for a tick when there's work to do.	2023-09-05 10:59:50 +01:00
Jonathan Bell	d13775ee72	Merge branch 'fix_debug' into 'master' Fix ARM CMSIS-DAP issues See merge request projectmu/picoprobe!1	2023-08-25 10:13:04 +01:00
Sunaabh Trivedi	58fa7a14cd	Added a custom USB endpoint handler to process commands on a packet basis, as opposed to the byte FIFO employed previously. This allows multiple commmands to be framed correctly, so they can be processed sequentially without losing packets. Suspend DAP thread until the end of the USB callback. This prevents the need for continous polling by DAP thread.	2023-08-24 17:15:47 +01:00
Jonathan Bell	1586ef0caa	picoprobe version 1.0.3	2023-08-15 11:48:50 +01:00
Jonathan Bell	0761424821	probe: hook up reset functionality to DAP commands	2023-08-15 11:48:50 +01:00
Jonathan Bell	d47b3082f8	Fix debug prints - The reset pin must move otherwise uart0 tx is squashed - Don't preempt printf, it doesn't like it - Set up the UART by default	2023-08-15 11:48:50 +01:00
P33M	6473166494	usb_descriptors: disable remote wake (#91 ) see https://github.com/raspberrypi/picoprobe/issues/71	2023-08-09 13:13:36 +01:00
Luke Wren	3a1887ff06	Merge pull request #90 from raspberrypi/lurch-patch-1 Small README tweaks	2023-06-22 16:17:39 +01:00
Andrew Scheller	13b420d34c	Small README tweaks	2023-06-22 15:56:45 +01:00
Roger Wolff	eb494103d4	buildsystem improvements to make it easier to build for debugprobe. (#87 ) Merge documentation pull request from @rewolff	2023-06-22 13:50:25 +01:00
P33M	7de418cce3	Merge pull request #89 from raspberrypi/fix-deinit-without-init Don't call probe_read_mode() in deinit() without matching prior init(), fixes #88	2023-06-18 11:00:24 +01:00
Luke Wren	0746b5a844	Don't call probe_read_mode() in deinit() without matching prior init(), fixes #88	2023-06-17 19:59:52 +01:00
P33M	d04ff3b472	Merge pull request #83 from raspberrypi/pio-program-improvements PIO program improvements	2023-05-30 10:22:02 +01:00
Luke Wren	57f5569894	Update probe_oen.pio to use the same logic as the new probe.pio. Fix a couple of compilation issues in the helpers for probe_oen.pio.	2023-05-09 13:36:10 +01:00
Luke Wren	ae5bdb082d	Reduce SWCLK frequency from SM/2 to SM/4, to reduce dead cycles. Also fix divider becoming 0 when extremely high SWCLK frequencies are requested (this would have been safe but you would get an extremely slow SWCLK).	2023-05-09 11:29:53 +01:00
Luke Wren	491b96c1d4	Update PIO program to pass read/write commands through FIFO alongside bit counts. Also, don't return RX data on write commands. These two changes allow the probe code to return early after pushing write commands into the FIFO, which improves throughput.	2023-05-09 11:15:12 +01:00
Jonathan Bell	46eb924601	board configs: differentiate the USB product strings	2023-05-02 10:09:01 +01:00
Jonathan Bell	cdc33333c9	picoprobe_config: default should be the Pico, not Debug Probe	2023-05-02 10:00:44 +01:00
Jonathan Bell	c8eb077c6c	cdc_uart: avoid compilation warning if UART LEDs not used	2023-02-27 15:07:10 +00:00
Jonathan Bell	fbc4116141	probe: split pioasm and setup code into variant files, and add OEN variant	2023-02-27 15:07:10 +00:00
Jonathan Bell	364adfe1f1	picoprobe_config: split board-related pin setup into separate header files	2023-02-27 15:07:10 +00:00
Jonathan Bell	08ed872793	probe: drop support for PROTO_OPENOCD_CUSTOM CMSIS-DAP is a complete superset of the Picoprobe protocol, so now we default to DAPv2 there's no need to keep the downstream code. Also make setting up the reset pin conditional and in the correct place.	2023-02-27 15:07:10 +00:00
Jonathan Bell	5a9c6940c4	probe: use a more generic method for direction changes	2023-02-27 15:07:10 +00:00
Jonathan Bell	bb1c547b07	picoprobe: rename to Debug Adapter	2023-02-27 15:07:10 +00:00
Jonathan Bell	724e5de6c8	probe: if we have a separate SWDIO input, use it For boards with a level-shifter on SWDIO for compatibility with 1.8V VDDIO. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2023-02-27 15:07:10 +00:00
Jonathan Bell	1ca6aa36dd	picoprobe: add a USB Connected LED and signal it appropriately Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2023-02-27 15:07:10 +00:00
Jonathan Bell	db24224846	picoprobe: use GPIO definitions for the new debug adapter, PCB R2 Limitations: - Power LED doesn't yet do anything sensible - The level-shifted SWDIO input isn't utilised by the PIO SM, so only 3.3v I/O Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2023-02-27 15:07:10 +00:00
Jonathan Bell	e187e5754b	RTOS: reduce DAP polling delay - improves throughput. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2023-02-27 15:07:10 +00:00
Jonathan Bell	a2890561c0	Add DAP and UART LED options. Use a debounce for UART LEDs. Signed-off-by: Jonathan Bell <jonathan@raspberrypi.com>	2023-02-27 15:07:10 +00:00
Jonathan Bell	156a33fa01	freeRTOS: shrink heap by half A 128K reservation on a device with 256K of RAM is a bit demanding. Shrink to fix a link error in a DebugRel build.	2023-02-27 14:06:22 +00:00
P33M	3bd58697e6	Merge pull request #69 from raspberrypi/enable_e15_fix Default TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX=1	2023-02-22 15:52:36 +00:00
graham sanderson	599ee88582	Default TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX=1	2023-02-21 16:44:15 -06:00
Jonathan Bell	42d1ff28c8	Fix vendor interface semantics for tinyUSB >= 0.13 Explicit flushing of writes is now required.	2023-01-06 11:48:55 +00:00
P33M	fd445fd8c1	Merge pull request #13 from lurch/patch-1 Use latest upstream version of pico_sdk_import.cmake	2022-11-24 13:34:13 +00:00
Andrew Scheller	3e367acf66	Use latest upstream version of pico_sdk_import.cmake	2022-11-24 12:01:57 +00:00