Implement DTR+RTS hardware control handling

Adds compatibility with NXP Flash Magic for flashing NXP MCUs.

Implements devanlai#3

Author: dallmair

src/DAP42.c

@@ -71,6 +71,48 @@ static void on_dfu_request(void) {
     do_reset_to_dfu = true;
 }
 
+static inline void set_target_state(bool reset, bool enter_bootloader) {
+    /*
+     * For transitioning from true/true to false/false, clear CTL first to ensure
+     * the MCU does not enter the bootloader.
+     */
+    PIN_CTL_OUT(enter_bootloader);
+    PIN_nRESET_OUT(!reset);
+}
+
+static bool do_deferred_set_target_state = false;
+static uint32_t set_target_state_timer_start;
+static bool set_target_state_reset;
+static bool set_target_state_enter_bootloader;
+static void on_cdc_set_control_line_state(bool dtr, bool rts) {
+    /*
+     * At least Linux and Windows set true/true by default when an app opens
+     * the channel, so forwarding these values directly to set_target_state
+     * would cause the target MCU to reset right away, even when one simply wants
+     * to capture UART output without resetting the target. Therefore, this
+     * combination must be ignored here.
+     *
+     * When NXP Flash Magic wants to reset the target, it first sets true/true,
+     * followed by either true/false or false/true, followed by false/false.
+     * Thus, the condition dtr != rts indicates it's time to reset the target.
+     */
+    if (dtr != rts) {
+        /* Reset now */
+        set_target_state(true, true);
+
+        /* Defer setting the requested state */
+        do_deferred_set_target_state = true;
+        set_target_state_timer_start = get_ticks();
+        set_target_state_reset = dtr;
+        set_target_state_enter_bootloader = rts;
+    }
+    else if (!dtr) {
+        /* Parameters are false/false */
+        do_deferred_set_target_state = false;
+        set_target_state(false, false);
+    }
+}
+
 int main(void) {
     if (DFU_AVAILABLE) {
         DFU_maybe_jump_to_bootloader();
@@ -109,7 +151,10 @@ int main(void) {
     DAP_app_setup(usbd_dev, &on_dfu_request);
 
     if (CDC_AVAILABLE) {
-        cdc_uart_app_setup(usbd_dev, &on_usb_activity, &on_usb_activity);
+        cdc_uart_app_setup(usbd_dev,
+                           &on_cdc_set_control_line_state,
+                           &on_usb_activity,
+                           &on_usb_activity);
         cdc_uart_app_set_timeout(1);
     }
 
@@ -175,6 +220,12 @@ int main(void) {
         } else {
             LED_ACTIVITY_OUT(0);
         }
+
+        bool timer_elapsed = (get_ticks() - set_target_state_timer_start) >= 25;
+        if (do_deferred_set_target_state && timer_elapsed) {
+            do_deferred_set_target_state = false;
+            set_target_state(set_target_state_reset, set_target_state_enter_bootloader);
+        }
     }
 
     return 0;

src/USB/cdc.c

@@ -241,6 +241,7 @@ static struct usb_cdc_line_coding current_line_coding = {
 };
 
 void cdc_uart_app_reset(void);
+void cdc_uart_app_reset_buffer(void);
 
 static bool cdc_uart_set_line_coding(const struct usb_cdc_line_coding* line_coding) {
     uint32_t databits;
@@ -281,7 +282,7 @@ static bool cdc_uart_set_line_coding(const struct usb_cdc_line_coding* line_codi
     }
 
     // Reset the output packet buffer
-    cdc_uart_app_reset();
+    cdc_uart_app_reset_buffer();
 
     console_reconfigure(line_coding->dwDTERate, databits, stopbits, parity);
     memcpy(&current_line_coding, (const void*)line_coding, sizeof(current_line_coding));
@@ -313,21 +314,29 @@ static uint32_t packet_timestamp = 0;
 static bool need_zlp = false;
 
 void cdc_uart_app_reset(void) {
+    if (cdc_set_control_line_state_callback) {
+        cdc_set_control_line_state_callback(false, false);
+    }
+    cdc_uart_app_reset_buffer();
+}
+
+void cdc_uart_app_reset_buffer(void) {
     packet_len = 0;
     packet_timestamp = get_ticks();
     need_zlp = false;
     cdc_clear_nak();
 }
 
 void cdc_uart_app_setup(usbd_device* usbd_dev,
+                   SetControlLineStateFunction cdc_set_control_line_state_cb,
                    GenericCallback cdc_tx_cb,
                    GenericCallback cdc_rx_cb) {
     cdc_uart_tx_callback = cdc_tx_cb;
     cdc_uart_rx_callback = cdc_rx_cb;
 
     cdc_setup(usbd_dev,
               &cdc_uart_on_host_tx,
-              NULL,
+              cdc_set_control_line_state_cb,
               &cdc_uart_set_line_coding, &cdc_uart_get_line_coding);
     cmp_usb_register_reset_callback(cdc_uart_app_reset);
 }

src/USB/cdc.h

@@ -39,6 +39,7 @@ extern void cdc_setup(usbd_device* usbd_dev,
 extern bool cdc_send_data(const uint8_t* data, size_t len);
 
 extern void cdc_uart_app_setup(usbd_device* usbd_dev,
+                               SetControlLineStateFunction cdc_set_control_line_state_cb,
                                GenericCallback cdc_tx_cb,
                                GenericCallback cdc_rx_cb);
 

src/stm32f042/DAP/CMSIS_DAP_hal.h

@@ -254,6 +254,25 @@ static __inline void PIN_nRESET_OUT (uint32_t bit) {
 #endif
 }
 
+/*
+CTL I/O pin: Set Output.
+Parameters
+    bit        target device enter bootloader pin status:
+        0: do not enter bootloader.
+        1: enter bootloader.
+*/
+static __inline void PIN_CTL_OUT (uint32_t bit) {
+#if defined(CTL_GPIO_PORT) && defined(CTL_GPIO_PIN)
+    if (bit & 0x1) {
+        GPIO_BRR(CTL_GPIO_PORT) = CTL_GPIO_PIN;
+    } else {
+        GPIO_BSRR(CTL_GPIO_PORT) = CTL_GPIO_PIN;
+    }
+#else
+    (void)bit;
+#endif
+}
+
 /*
 Debug Unit: Set status of Connected LED.
 Parameters

src/stm32f103/DAP/CMSIS_DAP_hal.h

@@ -189,6 +189,10 @@ static __inline void PIN_nRESET_OUT (uint32_t bit) {
     }
 }
 
+static __inline void PIN_CTL_OUT (uint32_t bit) {
+    (void)bit;
+}
+
 static __inline void LED_CONNECTED_OUT (uint32_t bit) {
     if ((bit & 0x1) ^ LED_OPEN_DRAIN) {
         gpio_set(LED_CON_GPIO_PORT, LED_CON_GPIO_PIN);