+/* 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library for USB CDC ACM communication (code)
+ * @file usb_cdcacm.c
+ * @author King Kévin <kingkevin@cuvoodoo.info>
+ * @date 2016
+ */
+
+/* standard libraries */
+#include <stdint.h> // standard integer types
+#include <stdio.h> // standard I/O facilities
+#include <stdlib.h> // general utilities
+
+/* STM32 (including CM3) libraries */
+#include <libopencm3/stm32/rcc.h> // real-time control clock library
+#include <libopencm3/stm32/gpio.h> // general purpose input output library
+#include <libopencm3/cm3/nvic.h> // interrupt handler
+#include <libopencm3/cm3/scb.h> // reset utilities
+#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
+#include <libopencm3/usb/usbd.h> // USB library
+#include <libopencm3/usb/cdc.h> // USB CDC library
+#include <libopencm3/cm3/sync.h> // synchronisation utilities
+
+#include "global.h"
+#include "usb_cdcacm.h" // USB CDC ACM header and definitions
+
+/** USB CDC ACM device descriptor
+ * @note as defined in USB CDC specification section 5
+ */
+static const struct usb_device_descriptor device_descriptor = {
+ .bLength = USB_DT_DEVICE_SIZE, // the size of this header in bytes, 18
+ .bDescriptorType = USB_DT_DEVICE, // a value of 1 indicates that this is a device descriptor
+ .bcdUSB = 0x0200, // this device supports USB 2.0
+ .bDeviceClass = USB_CLASS_CDC, // use the CDC device class
+ .bDeviceSubClass = 0, // unused
+ .bDeviceProtocol = 0, // unused
+ .bMaxPacketSize0 = 64, // packet size for endpoint zero in bytes
+ .idVendor = 0xc440, // Vendor ID (CuVo...)
+ .idProduct = 0x0d00, // product ID within the Vendor ID space (...odoo)
+ .bcdDevice = 0x0100, // version number for the device
+ .iManufacturer = 1, // the index of the string in the string table that represents the name of the manufacturer of this device.
+ .iProduct = 2, // the index of the string in the string table that represents the name of the product
+ .iSerialNumber = 3, // the index of the string in the string table that represents the serial number of this item in string form.
+ .bNumConfigurations = 1, // the number of possible configurations this device has
+};
+
+/** USB CDC ACM data endpoints
+ * @note as defined in USB CDC specification section 5
+ */
+static const struct usb_endpoint_descriptor data_endpoints[] = {{
+ .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
+ .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
+ .bEndpointAddress = 0x01, // OUT (from host) direction (0<<7), endpoint 1
+ .bmAttributes = USB_ENDPOINT_ATTR_BULK, // bulk mode
+ .wMaxPacketSize = 64, // maximum packet size
+ .bInterval = 1, // the frequency, in number of frames, that we're going to be sending data
+},{
+ .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
+ .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
+ .bEndpointAddress = 0x82, // IN (to host) direction (1<<7), endpoint 2
+ .bmAttributes = USB_ENDPOINT_ATTR_BULK, // bulk mode
+ .wMaxPacketSize = 64, // maximum packet size
+ .bInterval = 1, // the frequency, in number of frames, that we're going to be sending data
+}};
+
+/** USB CDC ACM communication endpoints
+ * @note This notification endpoint isn't implemented. According to CDC spec its optional, but its absence causes a NULL pointer dereference in Linux cdc_acm driver
+ */
+static const struct usb_endpoint_descriptor communication_endpoints[] = {{
+ .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
+ .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
+ .bEndpointAddress = 0x83, // IN (to host) direction (1<<7), endpoint 3
+ .bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT, // interrupt mode
+ .wMaxPacketSize = 16, // maximum packet size
+ .bInterval = 255, // the frequency, in number of frames, that we're going to be sending data
+}};
+
+/** USB CDC ACM functional descriptor
+ * @return
+ * @note as defined in USB CDC specification section 5.2.3
+ */
+static const struct {
+ struct usb_cdc_header_descriptor header; /**< header */
+ struct usb_cdc_call_management_descriptor call_mgmt; /**< call management descriptor */
+ struct usb_cdc_acm_descriptor acm; /**< descriptor */
+ struct usb_cdc_union_descriptor cdc_union; /**< descriptor */
+} __attribute__((packed)) cdcacm_functional_descriptors = {
+ .header = {
+ .bFunctionLength = sizeof(struct usb_cdc_header_descriptor), /**< descriptor length */
+ .bDescriptorType = CS_INTERFACE, /**< descriptor type */
+ .bDescriptorSubtype = USB_CDC_TYPE_HEADER, /**< descriptor subtype */
+ .bcdCDC = 0x0110, /**< CDC value */
+ },
+ .call_mgmt = {
+ .bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor), /**< descriptor length */
+ .bDescriptorType = CS_INTERFACE, /**< descriptor type */
+ .bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT, /**< descriptor subtype */
+ .bmCapabilities = 0, /**< capabilities */
+ .bDataInterface = 1, /**< data interface */
+ },
+ .acm = {
+ .bFunctionLength = sizeof(struct usb_cdc_acm_descriptor), /**< descriptor length */
+ .bDescriptorType = CS_INTERFACE, /**< descriptor type */
+ .bDescriptorSubtype = USB_CDC_TYPE_ACM, /**< descriptor subtype */
+ .bmCapabilities = 0, /**< capabilities */
+ },
+ .cdc_union = {
+ .bFunctionLength = sizeof(struct usb_cdc_union_descriptor), /**< descriptor length */
+ .bDescriptorType = CS_INTERFACE, /**< descriptor type */
+ .bDescriptorSubtype = USB_CDC_TYPE_UNION, /**< descriptor subtype */
+ .bControlInterface = 0, /**< control interface */
+ .bSubordinateInterface0 = 1, /**< subordinate interface */
+ },
+};
+
+/** USB CDC interface descriptor
+ * @note as defined in USB CDC specification section 5.1.3
+ */
+static const struct usb_interface_descriptor communication_interface[] = {{
+ .bLength = USB_DT_INTERFACE_SIZE,
+ .bDescriptorType = USB_DT_INTERFACE,
+ .bInterfaceNumber = 0,
+ .bAlternateSetting = 0,
+ .bNumEndpoints = 1,
+ .bInterfaceClass = USB_CLASS_CDC,
+ .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
+ .bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
+ .iInterface = 0,
+
+ .endpoint = communication_endpoints,
+
+ .extra = &cdcacm_functional_descriptors,
+ .extralen = sizeof(cdcacm_functional_descriptors),
+}};
+
+/** USB CDC ACM data class interface descriptor
+ * @note as defined in USB CDC specification section 5.1.3
+ */
+static const struct usb_interface_descriptor data_interface[] = {{
+ .bLength = USB_DT_INTERFACE_SIZE,
+ .bDescriptorType = USB_DT_INTERFACE,
+ .bInterfaceNumber = 1,
+ .bAlternateSetting = 0,
+ .bNumEndpoints = 2,
+ .bInterfaceClass = USB_CLASS_DATA,
+ .bInterfaceSubClass = 0,
+ .bInterfaceProtocol = 0,
+ .iInterface = 0,
+
+ .endpoint = data_endpoints,
+}};
+
+/** USB CDC ACM interface descriptor */
+static const struct usb_interface interfaces[] = {{
+ .num_altsetting = 1,
+ .altsetting = communication_interface,
+}, {
+ .num_altsetting = 1,
+ .altsetting = data_interface,
+}};
+
+/** USB CDC ACM configuration descriptor */
+static const struct usb_config_descriptor config = {
+ .bLength = USB_DT_CONFIGURATION_SIZE, // the length of this header in bytes
+ .bDescriptorType = USB_DT_CONFIGURATION, // a value of 2 indicates that this is a configuration descriptor
+ .wTotalLength = 0, // this should hold the total size of the configuration descriptor including all sub interfaces. it is automatically filled in by the USB stack in libopencm3
+ .bNumInterfaces = 2, // the number of interfaces in this configuration
+ .bConfigurationValue = 1, // the index of this configuration
+ .iConfiguration = 0, // a string index describing this configuration (zero means not provided)
+ .bmAttributes = 0x80, // self powered (0<<6), supports remote wakeup (0<<5)
+ .bMaxPower = 0x32, // the maximum amount of current that this device will draw in 2mA units
+ // end of header
+ .interface = interfaces, // pointer to an array of interfaces
+};
+
+/** USB string table
+ * @note starting with index 1
+ */
+static const char *usb_strings[] = {
+ "BarBillards v1",
+ "CDC-ACM",
+ "STM32F1",
+};
+
+static uint8_t usbd_control_buffer[128] = {0}; /**< buffer to be used for control requests */
+static usbd_device *usb_device = NULL; /**< structure holding all the info related to the USB device */
+static bool connected = false; /**< is the USB device is connected to a host */
+
+/* input and output ring buffer, indexes, and available memory */
+static uint8_t rx_buffer[CDCACM_BUFFER] = {0}; /**< ring buffer for received data */
+static volatile uint8_t rx_i = 0; /**< current position of read received data */
+static volatile uint8_t rx_used = 0; /**< how much data has been received and not red */
+mutex_t rx_lock = MUTEX_UNLOCKED; /**< lock to update rx_i or rx_used */
+static uint8_t tx_buffer[CDCACM_BUFFER] = {0}; /**< ring buffer for data to transmit */
+static volatile uint8_t tx_i = 0; /**< current position if transmitted data */
+static volatile uint8_t tx_used = 0; /**< how much data needs to be transmitted */
+mutex_t tx_lock = MUTEX_UNLOCKED; /**< lock to update tx_i or tx_used */
+volatile uint8_t cdcacm_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
+
+/** disconnect USB by pulling down D+ to for re-enumerate */
+static void usb_disconnect(void)
+{
+ /* short USB disconnect to force re-enumerate */
+#if defined(SYSTEM_BOARD) || defined(BLUE_PILL)
+ // pull USB D+ low for a short while
+ rcc_periph_clock_enable(RCC_GPIOA);
+ gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO12);
+ gpio_clear(GPIOA, GPIO12);
+ for (uint32_t i = 0; i < 0x2000; i++) {
+ __asm__("nop");
+ }
+#elif defined(MAPLE_MINI)
+ // disconnect USB D+ using dedicated DISC line/circuit on PB9
+ rcc_periph_clock_enable(RCC_GPIOB);
+ gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO9);
+ gpio_set(GPIOB, GPIO9);
+ for (uint32_t i = 0; i < 0x2000; i++) {
+ __asm__("nop");
+ }
+ gpio_clear(GPIOB, GPIO9);
+#endif
+}
+
+/** incoming USB CDC ACM control request
+ * @param[in] usbd_dev USB device descriptor
+ * @param[in] req control request information
+ * @param[in] buf control request data
+ * @param[in] len control request data length
+ * @param[in] complete not used
+ * @return 0 if succeeded, error else
+ * @note resets device when configured with 5 bits
+ */
+static enum usbd_request_return_codes cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *len, void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
+{
+ (void)complete;
+ (void)buf;
+ (void)usbd_dev;
+
+ switch (req->bRequest) {
+ case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
+ connected = req->wValue ? true : false; // check if terminal is open
+ //bool dtr = (req->wValue & (1 << 0)) ? true : false;
+ //bool rts = (req->wValue & (1 << 1)) ? true : false;
+ /* this Linux cdc_acm driver requires this to be implemented
+ * even though it's optional in the CDC spec, and we don't
+ * advertise it in the ACM functional descriptor.
+ */
+ uint8_t reply[10] = {0};
+ struct usb_cdc_notification *notif = (void *)reply;
+ /* we echo signals back to host as notification. */
+ notif->bmRequestType = 0xA1;
+ notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
+ notif->wValue = 0;
+ notif->wIndex = 0;
+ notif->wLength = 2;
+ reply[8] = req->wValue & 3;
+ reply[9] = 0;
+ usbd_ep_write_packet(usbd_dev, 0x83, reply, LENGTH(reply));
+ return USBD_REQ_HANDLED;
+ break;
+ case USB_CDC_REQ_SET_LINE_CODING:
+ // ignore if length is wrong
+ if (*len < sizeof(struct usb_cdc_line_coding)) {
+ return USBD_REQ_NOTSUPP;
+ }
+ // get the line coding
+ struct usb_cdc_line_coding *coding = (struct usb_cdc_line_coding *)*buf;
+ /* reset device is the data bits is set to 5
+ * this is used to allowing rebooting the device in DFU mode for reflashing
+ * to reset the device from the host you can use stty --file /dev/ttyACM0 115200 raw cs5
+ */
+ if (coding->bDataBits==5) {
+ usb_disconnect(); // force re-enumerate after reset
+ scb_reset_system(); // reset device
+ while (true); // wait for the reset to happen
+ }
+ return USBD_REQ_HANDLED;
+ break;
+ default:
+ return USBD_REQ_HANDLED;
+ }
+ return USBD_REQ_NOTSUPP;
+}
+
+/** USB CDC ACM data received callback
+ * @param[in] usbd_dev USB device descriptor
+ * @param[in] ep endpoint where data came in
+ */
+static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
+{
+ (void)ep;
+
+ char usb_data[64] = {0}; // buffer to read data
+ uint16_t usb_length = 0; // length of incoming data
+
+ /* receive data */
+ usb_length = usbd_ep_read_packet(usbd_dev, 0x01, usb_data, sizeof(usb_data));
+ if (usb_length) { // copy received data
+ for (uint16_t i=0; i<usb_length && rx_used<LENGTH(rx_buffer); i++) { // only until buffer is full
+ rx_buffer[(rx_i+rx_used)%LENGTH(rx_buffer)] = usb_data[i]; // put character in buffer
+ rx_used++; // update used buffer
+ }
+ cdcacm_received = rx_used; // update available data
+ }
+}
+
+/** USB CDC ACM data transmitted callback
+ * @param[in] usbd_dev USB device descriptor
+ * @param[in] ep endpoint where data came in
+ */
+static void cdcacm_data_tx_cb(usbd_device *usbd_dev, uint8_t ep)
+{
+ (void)ep;
+ (void)usbd_dev;
+
+ if (!usbd_dev || !connected || !tx_used) { // verify if we can send and there is something to send
+ return;
+ }
+ if (mutex_trylock(&tx_lock)) { // try to get lock
+ uint8_t usb_length = (tx_used > 64 ? 64 : tx_used); // length of data to be transmitted (respect max packet size)
+ usb_length = (usb_length > (LENGTH(tx_buffer)-tx_i) ? LENGTH(tx_buffer)-tx_i : usb_length); // since here we use the source array not as ring buffer, only go up to the end
+ while (usb_length != usbd_ep_write_packet(usb_device, 0x82, (void*)(&tx_buffer[tx_i]), usb_length)); // ensure data is written into transmit buffer
+ tx_i = (tx_i+usb_length)%LENGTH(tx_buffer); // update location on buffer
+ tx_used -= usb_length; // update used size
+ mutex_unlock(&tx_lock); // release lock
+ } else {
+ usbd_ep_write_packet(usb_device, 0x82, NULL, 0); // trigger empty tx for a later callback
+ }
+ usbd_poll(usb_device); // ensure the data gets sent
+}
+
+/** set USB CDC ACM configuration
+ * @param[in] usbd_dev USB device descriptor
+ * @param[in] wValue not used
+ */
+static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
+{
+ (void)wValue;
+
+ usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
+ usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_tx_cb);
+ usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
+
+ usbd_register_control_callback( usbd_dev, USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT, cdcacm_control_request);
+}
+
+void cdcacm_setup(void)
+{
+ connected = false; // start with USB not connected
+ usb_disconnect(); // force re-enumerate (useful after a restart or if there is a bootloader using another USB profile)
+
+ /* initialize USB */
+ usb_device = usbd_init(&st_usbfs_v1_usb_driver, &device_descriptor, &config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer));
+ usbd_register_set_config_callback(usb_device, cdcacm_set_config);
+
+ /* enable interrupts (to not have to poll all the time) */
+ nvic_enable_irq(NVIC_USB_LP_CAN_RX0_IRQ); // without this USB isn't detected by the host
+
+ /* reset buffer states */
+ rx_i = 0;
+ rx_used = 0;
+ mutex_unlock(&rx_lock);
+ cdcacm_received = 0;
+ tx_i = 0;
+ tx_used = 0;
+ mutex_unlock(&tx_lock);
+}
+
+char cdcacm_getchar(void)
+{
+ while (!rx_used) { // idle until data is available
+ __WFI(); // sleep until interrupt (not sure if it's a good idea here)
+ }
+ char to_return = rx_buffer[rx_i]; // get the next available character
+ rx_i = (rx_i+1)%LENGTH(rx_buffer); // update used buffer
+ rx_used--; // update used buffer
+ cdcacm_received = rx_used; // update available data
+ return to_return;
+}
+
+void cdcacm_putchar(char c)
+{
+ if (!usb_device || !connected) {
+ return;
+ }
+ mutex_lock(&tx_lock); // get lock to prevent race condition
+ if (tx_used<LENGTH(tx_buffer)) { // buffer not full
+ tx_buffer[(tx_i+tx_used)%LENGTH(tx_buffer)] = c; // put character in buffer
+ tx_used++; // update used buffer
+ } else { // buffer full (might be that no terminal is connected to this serial)
+ tx_i = (tx_i+1)%LENGTH(tx_buffer); // shift start
+ tx_buffer[(tx_i+tx_used)%LENGTH(tx_buffer)] = c; // overwrite old data
+ }
+ mutex_unlock(&tx_lock); // release lock
+ if (tx_used==1) { // to buffer is not empty anymore
+ usbd_ep_write_packet(usb_device, 0x82, NULL, 0); // trigger tx callback
+ }
+}
+
+/** USB interrupt service routine called when data is received */
+void usb_lp_can_rx0_isr(void) {
+ usbd_poll(usb_device);
+}
projects / barbilliards.git / commitdiff