/* * This file is part of the Black Magic Debug project. * * Copyright (C) 2012 Black Sphere Technologies Ltd. * Written by Gareth McMullin * * 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 . */ #include #include #include #include #include #include #include #include #include "general.h" #include "cdcacm.h" #define USBUART_TIMER_FREQ_HZ 1000000U /* 1us per tick */ #define USBUART_RUN_FREQ_HZ 5000U /* 200us (or 100 characters at 2Mbps) */ #define FIFO_SIZE 128 /* RX Fifo buffer */ static uint8_t buf_rx[FIFO_SIZE]; /* Fifo in pointer, writes assumed to be atomic, should be only incremented within RX ISR */ static uint8_t buf_rx_in; /* Fifo out pointer, writes assumed to be atomic, should be only incremented outside RX ISR */ static uint8_t buf_rx_out; static void usbuart_run(void); void usbuart_init(void) { #if defined(BLACKMAGIC) /* On mini hardware, UART and SWD share connector pins. * Don't enable UART if we're being debugged. */ if ((platform_hwversion() == 1) && (SCS_DEMCR & SCS_DEMCR_TRCENA)) return; #endif rcc_periph_clock_enable(USBUSART_CLK); UART_PIN_SETUP(); /* Setup UART parameters. */ usart_set_baudrate(USBUSART, 38400); usart_set_databits(USBUSART, 8); usart_set_stopbits(USBUSART, USART_STOPBITS_1); usart_set_mode(USBUSART, USART_MODE_TX_RX); usart_set_parity(USBUSART, USART_PARITY_NONE); usart_set_flow_control(USBUSART, USART_FLOWCONTROL_NONE); /* Finally enable the USART. */ usart_enable(USBUSART); /* Enable interrupts */ USBUSART_CR1 |= USART_CR1_RXNEIE; nvic_set_priority(USBUSART_IRQ, IRQ_PRI_USBUSART); nvic_enable_irq(USBUSART_IRQ); /* Setup timer for running deferred FIFO processing */ USBUSART_TIM_CLK_EN(); timer_reset(USBUSART_TIM); timer_set_mode(USBUSART_TIM, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); timer_set_prescaler(USBUSART_TIM, rcc_ppre2_frequency / USBUART_TIMER_FREQ_HZ * 2 - 1); timer_set_period(USBUSART_TIM, USBUART_TIMER_FREQ_HZ / USBUART_RUN_FREQ_HZ - 1); /* Setup update interrupt in NVIC */ nvic_set_priority(USBUSART_TIM_IRQ, IRQ_PRI_USBUSART_TIM); nvic_enable_irq(USBUSART_TIM_IRQ); /* turn the timer on */ timer_enable_counter(USBUSART_TIM); } /* * Runs deferred processing for usb uart rx, draining RX FIFO by sending * characters to host PC via CDCACM. Allowed to read from FIFO in pointer, * but not write to it. Allowed to write to FIFO out pointer. */ static void usbuart_run(void) { /* forcibly empty fifo if no USB endpoint */ if (cdcacm_get_config() != 1) { buf_rx_out = buf_rx_in; } /* if fifo empty, nothing further to do */ if (buf_rx_in == buf_rx_out) { /* turn off LED, disable IRQ */ timer_disable_irq(USBUSART_TIM, TIM_DIER_UIE); gpio_clear(LED_PORT_UART, LED_UART); } else { uint8_t packet_buf[CDCACM_PACKET_SIZE]; uint8_t packet_size = 0; uint8_t buf_out = buf_rx_out; /* copy from uart FIFO into local usb packet buffer */ while (buf_rx_in != buf_out && packet_size < CDCACM_PACKET_SIZE) { packet_buf[packet_size++] = buf_rx[buf_out++]; /* wrap out pointer */ if (buf_out >= FIFO_SIZE) { buf_out = 0; } } /* advance fifo out pointer by amount written */ buf_rx_out += usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, packet_buf, packet_size); buf_rx_out %= FIFO_SIZE; } } void usbuart_set_line_coding(struct usb_cdc_line_coding *coding) { usart_set_baudrate(USBUSART, coding->dwDTERate); if (coding->bParityType) usart_set_databits(USBUSART, coding->bDataBits + 1); else usart_set_databits(USBUSART, coding->bDataBits); switch(coding->bCharFormat) { case 0: usart_set_stopbits(USBUSART, USART_STOPBITS_1); break; case 1: usart_set_stopbits(USBUSART, USART_STOPBITS_1_5); break; case 2: usart_set_stopbits(USBUSART, USART_STOPBITS_2); break; } switch(coding->bParityType) { case 0: usart_set_parity(USBUSART, USART_PARITY_NONE); break; case 1: usart_set_parity(USBUSART, USART_PARITY_ODD); break; case 2: usart_set_parity(USBUSART, USART_PARITY_EVEN); break; } } void usbuart_usb_out_cb(usbd_device *dev, uint8_t ep) { (void)ep; char buf[CDCACM_PACKET_SIZE]; int len = usbd_ep_read_packet(dev, CDCACM_UART_ENDPOINT, buf, 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)) return; #endif gpio_set(LED_PORT_UART, LED_UART); for(int i = 0; i < len; i++) usart_send_blocking(USBUSART, buf[i]); gpio_clear(LED_PORT_UART, LED_UART); } void usbuart_usb_in_cb(usbd_device *dev, uint8_t ep) { (void) dev; (void) ep; } /* * Read a character from the UART RX and stuff it in a software FIFO. * Allowed to read from FIFO out pointer, but not write to it. * Allowed to write to FIFO in pointer. */ void USBUSART_ISR(void) { char c = usart_recv(USBUSART); /* Turn on LED */ gpio_set(LED_PORT_UART, LED_UART); /* If the next increment of rx_in would put it at the same point * as rx_out, the FIFO is considered full. */ if (((buf_rx_in + 1) % FIFO_SIZE) != buf_rx_out) { /* insert into FIFO */ buf_rx[buf_rx_in++] = c; /* wrap out pointer */ if (buf_rx_in >= FIFO_SIZE) { buf_rx_in = 0; } /* enable deferred processing if we put data in the FIFO */ timer_enable_irq(USBUSART_TIM, TIM_DIER_UIE); } } void USBUSART_TIM_ISR(void) { /* need to clear timer update event */ timer_clear_flag(USBUSART_TIM, TIM_SR_UIF); /* process FIFO */ usbuart_run(); }