/* * This file is part of the Black Magic Debug project. * * Copyright (C) 2011 Black Sphere Technologies Ltd. * Written by Gareth McMullin * Copyright (C) 2022 1BitSquared * Written by Rachel Mant * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ /* This file implements a the USB Communications Device Class - Abstract * Control Model (CDC-ACM) as defined in CDC PSTN subclass 1.2. * A Device Firmware Upgrade (DFU 1.1) class interface is provided for * field firmware upgrade. * * The device's unique id is used as the USB serial number string. * * Endpoint Usage * * 0 Control Endpoint * IN 1 GDB CDC DATA * OUT 1 GDB CDC DATA * IN 2 GDB CDC CTR * IN 3 UART CDC DATA * OUT 3 UART CDC DATA * OUT 4 UART CDC CTRL * In 5 Trace Capture * */ #include "general.h" #include "gdb_if.h" #include "usb_serial.h" #ifdef PLATFORM_HAS_TRACESWO #include "traceswo.h" #endif #include "usbuart.h" #include "aux_serial.h" #include #include #include #if defined(STM32F0) || defined(STM32F1) || defined(STM32F3) || defined(STM32F4) #include #include #endif static bool gdb_uart_dtr = true; static void usb_serial_set_state(usbd_device *dev, uint16_t iface, uint8_t ep); static void debug_uart_send_callback(usbd_device *dev, uint8_t ep); static void usbuart_usb_out_cb(usbd_device *dev, uint8_t ep); #ifdef ENABLE_DEBUG /* * This call initialises "SemiHosting", only we then do our own SVC interrupt things to * route all output through to the debug USB serial interface if debug_bmp is true. * * https://github.com/mirror/newlib-cygwin/blob/master/newlib/libc/sys/arm/syscalls.c#L115 */ void initialise_monitor_handles(void); #endif static enum usbd_request_return_codes gdb_uart_control_request(usbd_device *dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *const len, void (**complete)(usbd_device *dev, struct usb_setup_data *req)) { (void)buf; (void)complete; /* Is the request for the GDB UART interface? */ if (req->wIndex != GDB_IF_NO) return USBD_REQ_NEXT_CALLBACK; switch (req->bRequest) { case USB_CDC_REQ_SET_CONTROL_LINE_STATE: usb_serial_set_state(dev, req->wIndex, CDCACM_GDB_ENDPOINT); gdb_uart_dtr = req->wValue & 1; return USBD_REQ_HANDLED; case USB_CDC_REQ_SET_LINE_CODING: if (*len < sizeof(struct usb_cdc_line_coding)) return USBD_REQ_NOTSUPP; return USBD_REQ_HANDLED; /* Ignore on GDB Port */ } return USBD_REQ_NOTSUPP; } static enum usbd_request_return_codes debug_uart_control_request(usbd_device *dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *const len, void (**complete)(usbd_device *dev, struct usb_setup_data *req)) { (void)complete; /* Is the request for the physical/debug UART interface? */ if (req->wIndex != UART_IF_NO) return USBD_REQ_NEXT_CALLBACK; switch (req->bRequest) { case USB_CDC_REQ_SET_CONTROL_LINE_STATE: usb_serial_set_state(dev, req->wIndex, CDCACM_UART_ENDPOINT); #ifdef USBUSART_DTR_PIN gpio_set_val(USBUSART_PORT, USBUSART_DTR_PIN, !(req->wValue & 1U)); #endif #ifdef USBUSART_RTS_PIN gpio_set_val(USBUSART_PORT, USBUSART_RTS_PIN, !((req->wValue >> 1U) & 1U)); #endif return USBD_REQ_HANDLED; case USB_CDC_REQ_SET_LINE_CODING: if (*len < sizeof(struct usb_cdc_line_coding)) return USBD_REQ_NOTSUPP; aux_serial_set_encoding((struct usb_cdc_line_coding *)*buf); return USBD_REQ_HANDLED; } return USBD_REQ_NOTSUPP; } bool gdb_uart_get_dtr(void) { return gdb_uart_dtr; } void usb_serial_set_state(usbd_device *const dev, const uint16_t iface, const uint8_t ep) { uint8_t buf[10]; struct usb_cdc_notification *notif = (void*)buf; /* We echo signals back to host as notification */ notif->bmRequestType = 0xA1; notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE; notif->wValue = 0; notif->wIndex = iface; notif->wLength = 2; buf[8] = 3U; buf[9] = 0U; usbd_ep_write_packet(dev, ep, buf, sizeof(buf)); } void usb_serial_set_config(usbd_device *dev, uint16_t value) { usb_config = value; /* GDB interface */ #if defined(STM32F4) || defined(LM4F) usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE, gdb_usb_out_cb); #else usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE, NULL); #endif usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE, NULL); usbd_ep_setup(dev, (CDCACM_GDB_ENDPOINT + 1) | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL); /* Serial interface */ usbd_ep_setup(dev, CDCACM_UART_ENDPOINT, USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE / 2, usbuart_usb_out_cb); usbd_ep_setup( dev, CDCACM_UART_ENDPOINT | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE, debug_uart_send_callback); usbd_ep_setup(dev, (CDCACM_UART_ENDPOINT + 1) | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL); #ifdef PLATFORM_HAS_TRACESWO /* Trace interface */ usbd_ep_setup(dev, TRACE_ENDPOINT | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_BULK, 64, trace_buf_drain); #endif usbd_register_control_callback(dev, USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT, debug_uart_control_request); usbd_register_control_callback(dev, USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT, gdb_uart_control_request); /* Notify the host that DCD is asserted. * Allows the use of /dev/tty* devices on *BSD/MacOS */ usb_serial_set_state(dev, GDB_IF_NO, CDCACM_GDB_ENDPOINT); usb_serial_set_state(dev, UART_IF_NO, CDCACM_UART_ENDPOINT); #ifdef ENABLE_DEBUG initialise_monitor_handles(); #endif } void debug_uart_send_stdout(const uint8_t *const data, const size_t len) { for (size_t offset = 0; offset < len; offset += CDCACM_PACKET_SIZE) { const size_t count = MIN(len - offset, CDCACM_PACKET_SIZE); nvic_disable_irq(USB_IRQ); /* XXX: Do we actually care if this fails? Possibly not.. */ usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, data + offset, count); nvic_enable_irq(USB_IRQ); } } #ifdef ENABLE_DEBUG size_t debug_uart_write(const char *buf, const size_t len) { if (nvic_get_active_irq(USB_IRQ) || nvic_get_active_irq(USBUSART_IRQ) || nvic_get_active_irq(USBUSART_DMA_RX_IRQ)) return 0; CM_ATOMIC_CONTEXT(); for (size_t i = 0; i < len && (usb_dbg_in + 1) % RX_FIFO_SIZE != usb_dbg_out; ++i) { if (buf[i] == '\n') { usb_dbg_buf[usb_dbg_in++] = '\r'; usb_dbg_in %= RX_FIFO_SIZE; if ((usb_dbg_in + 1) % RX_FIFO_SIZE == usb_dbg_out) break; } usb_dbg_buf[usb_dbg_in++] = buf[i]; usb_dbg_in %= RX_FIFO_SIZE; } debug_uart_run(); return len; } /* * Copy data from fifo into continuous buffer. Return copied length. */ static uint32_t copy_from_fifo(char *dst, const char *src, uint32_t start, uint32_t end, uint32_t len, uint32_t fifo_sz) { uint32_t out_len = 0; for (uint32_t buf_out = start; buf_out != end && out_len < len; buf_out %= fifo_sz) dst[out_len++] = src[buf_out++]; return out_len; } /* * Runs deferred processing for USBUSART RX, draining RX FIFO by sending * characters to host PC via CDCACM. Allowed to write to FIFO OUT pointer. */ static void debug_uart_send_rx_packet(void) { rx_usb_trfr_cplt = false; /* Calculate writing position in the FIFO */ const uint32_t buf_rx_in = (RX_FIFO_SIZE - dma_get_number_of_data(USBUSART_DMA_BUS, USBUSART_DMA_RX_CHAN)) % RX_FIFO_SIZE; /* Forcibly empty fifo if no USB endpoint. * If fifo empty, nothing further to do. */ if (usb_get_config() != 1 || (buf_rx_in == buf_rx_out #ifdef ENABLE_DEBUG && usb_dbg_in == usb_dbg_out #endif )) { #ifdef ENABLE_DEBUG usb_dbg_out = usb_dbg_in; #endif buf_rx_out = buf_rx_in; /* Turn off LED */ usbuart_set_led_state(RX_LED_ACT, false); rx_usb_trfr_cplt = true; } else { /* To avoid the need of sending ZLP don't transmit full packet. * Also reserve space for copy function overrun. */ char packet_buf[CDCACM_PACKET_SIZE - 1 + sizeof(uint64_t)]; uint32_t packet_size; #ifdef ENABLE_DEBUG /* Copy data from DEBUG FIFO into local usb packet buffer */ packet_size = copy_from_fifo(packet_buf, usb_dbg_buf, usb_dbg_out, usb_dbg_in, CDCACM_PACKET_SIZE - 1, RX_FIFO_SIZE); /* Send if buffer not empty */ if (packet_size) { const uint16_t written = usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, packet_buf, packet_size); usb_dbg_out = (usb_dbg_out + written) % RX_FIFO_SIZE; return; } #endif /* Copy data from uart RX FIFO into local usb packet buffer */ packet_size = copy_from_fifo(packet_buf, buf_rx, buf_rx_out, buf_rx_in, CDCACM_PACKET_SIZE - 1, RX_FIFO_SIZE); /* Advance fifo out pointer by amount written */ const uint16_t written = usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, packet_buf, packet_size); buf_rx_out = (buf_rx_out + written) % RX_FIFO_SIZE; } } void debug_uart_run(void) { nvic_disable_irq(USB_IRQ); /* Enable LED */ usbuart_set_led_state(RX_LED_ACT, true); /* Try to send a packet if usb is idle */ if (rx_usb_trfr_cplt) debug_uart_send_rx_packet(); nvic_enable_irq(USB_IRQ); } static void debug_uart_send_callback(usbd_device *dev, uint8_t ep) { (void) ep; (void) dev; #if defined(STM32F0) || defined(STM32F1) || defined(STM32F3) || defined(STM32F4) debug_uart_send_rx_packet(); #endif } #ifndef ENABLE_RTT static void usbuart_usb_out_cb(usbd_device *dev, uint8_t ep) { (void)ep; #if defined(STM32F0) || defined(STM32F1) || defined(STM32F3) || defined(STM32F4) usbd_ep_nak_set(dev, CDCACM_UART_ENDPOINT, 1); /* Read new packet directly into TX buffer */ char *const tx_buf_ptr = &buf_tx[buf_tx_act_idx * TX_BUF_SIZE]; const uint16_t len = usbd_ep_read_packet(dev, CDCACM_UART_ENDPOINT, tx_buf_ptr + buf_tx_act_sz, CDCACM_PACKET_SIZE); #if defined(BLACKMAGIC) /* Don't bother if uart is disabled. * This will be the case on mini while we're being debugged. */ if(!(RCC_APB2ENR & RCC_APB2ENR_USART1EN) && !(RCC_APB1ENR & RCC_APB1ENR_USART2EN)) { usbd_ep_nak_set(dev, CDCACM_UART_ENDPOINT, 0); return; } #endif if (len) { buf_tx_act_sz += len; /* If DMA is idle, schedule new transfer */ if (tx_trfr_cplt) { tx_trfr_cplt = false; usbuart_change_dma_tx_buf(); /* Enable LED */ usbuart_set_led_state(TX_LED_ACT, true); } } /* Enable USBUART TX packet reception if buffer has enough space */ if (TX_BUF_SIZE - buf_tx_act_sz >= CDCACM_PACKET_SIZE) usbd_ep_nak_set(dev, CDCACM_UART_ENDPOINT, 0); #elif defined(LM4F) char buf[CDCACM_PACKET_SIZE]; int len = usbd_ep_read_packet(dev, CDCACM_UART_ENDPOINT, buf, CDCACM_PACKET_SIZE); for(int i = 0; i < len; i++) uart_send_blocking(USBUART, buf[i]); #endif } #endif /* * newlib defines _write as a weak link'd function for user code to override. * * This function forms the root of the implementation of a variety of functions * that can write to stdout/stderr, including printf(). * * The result of this function is the number of bytes written. */ /* NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp) */ int _write(const int file, const void *const ptr, const size_t len) { (void)file; #ifdef PLATFORM_HAS_DEBUG if (debug_bmp) return debug_uart_write(ptr, len); #endif return len; } /* * newlib defines isatty as a weak link'd function for user code to override. * * The result of this function is always 'true'. */ int isatty(const int file) { (void)file; return true; } enum { RDI_SYS_OPEN = 0x01, }; typedef struct ex_frame { uint32_t r0; const uint32_t *params; uint32_t r2; uint32_t r3; uint32_t r12; uintptr_t lr; uintptr_t return_address; } ex_frame_s; void debug_monitor_handler(void) __attribute__((used)) __attribute__((naked)); /* * This implements the other half of the newlib syscall puzzle. * When newlib is built for ARM, various calls that do file IO * such as printf end up calling [_swiwrite](https://github.com/mirror/newlib-cygwin/blob/master/newlib/libc/sys/arm/syscalls.c#L317) * and other similar low-level implementation functions. These * generate `swi` instructions for the "RDI Monitor" and that lands us.. here. * * The RDI calling convention sticks the file number in r0, the buffer pointer in r1, and length in r2. * ARMv7-M's SWI (SVC) instruction then takes all that and maps it into an exception frame on the stack. */ void debug_monitor_handler(void) { ex_frame_s *frame; __asm__( "mov %[frame], sp" : [frame] "=r" (frame) ); /* Make sure to return to the instruction after the SWI/BKPT */ frame->return_address += 2U; switch (frame->r0) { case RDI_SYS_OPEN: frame->r0 = 1; break; default: frame->r0 = UINT32_MAX; } __asm__("bx lr"); } #endif