LED clock
 All Files Functions Variables Macros Groups
usb_cdcacm.c
Go to the documentation of this file.
1 /* This program is free software: you can redistribute it and/or modify
2  * it under the terms of the GNU General Public License as published by
3  * the Free Software Foundation, either version 3 of the License, or
4  * (at your option) any later version.
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program. If not, see <http://www.gnu.org/licenses/>.
13  *
14  */
21 /* standard libraries */
22 #include <stdint.h> // standard integer types
23 #include <stdio.h> // standard I/O facilities
24 #include <stdlib.h> // general utilities
25 
26 /* STM32 (including CM3) libraries */
27 #include <libopencm3/stm32/rcc.h> // real-time control clock library
28 #include <libopencm3/stm32/gpio.h> // general purpose input output library
29 #include <libopencm3/cm3/nvic.h> // interrupt handler
30 #include <libopencm3/cm3/scb.h> // reset utilities
31 #include <libopencmsis/core_cm3.h> // Cortex M3 utilities
32 #include <libopencm3/usb/usbd.h> // USB library
33 #include <libopencm3/usb/cdc.h> // USB CDC library
34 #include <libopencm3/cm3/sync.h> // synchronisation utilities
35 
36 #include "global.h" // global utilities
37 #include "usb_cdcacm.h" // USB CDC ACM header and definitions
38 
42 static const struct usb_device_descriptor device_descriptor = {
43  .bLength = USB_DT_DEVICE_SIZE, // the size of this header in bytes, 18
44  .bDescriptorType = USB_DT_DEVICE, // a value of 1 indicates that this is a device descriptor
45  .bcdUSB = 0x0200, // this device supports USB 2.0
46  .bDeviceClass = USB_CLASS_CDC, // use the CDC device class
47  .bDeviceSubClass = 0, // unused
48  .bDeviceProtocol = 0, // unused
49  .bMaxPacketSize0 = 64, // packet size for endpoint zero in bytes
50  .idVendor = 0xc440, // Vendor ID (CuVo...)
51  .idProduct = 0x0d00, // product ID within the Vendor ID space (...odoo)
52  .bcdDevice = 0x0100, // version number for the device
53  .iManufacturer = 1, // the index of the string in the string table that represents the name of the manufacturer of this device.
54  .iProduct = 2, // the index of the string in the string table that represents the name of the product
55  .iSerialNumber = 3, // the index of the string in the string table that represents the serial number of this item in string form.
56  .bNumConfigurations = 1, // the number of possible configurations this device has
57 };
58 
62 static const struct usb_endpoint_descriptor data_endpoints[] = {{
63  .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
64  .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
65  .bEndpointAddress = 0x01, // OUT (from host) direction (0<<7), endpoint 1
66  .bmAttributes = USB_ENDPOINT_ATTR_BULK, // bulk mode
67  .wMaxPacketSize = 64, // maximum packet size
68  .bInterval = 1, // the frequency, in number of frames, that we're going to be sending data
69 },{
70  .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
71  .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
72  .bEndpointAddress = 0x82, // IN (to host) direction (1<<7), endpoint 2
73  .bmAttributes = USB_ENDPOINT_ATTR_BULK, // bulk mode
74  .wMaxPacketSize = 64, // maximum packet size
75  .bInterval = 1, // the frequency, in number of frames, that we're going to be sending data
76 }};
77 
81 static const struct usb_endpoint_descriptor communication_endpoints[] = {{
82  .bLength = USB_DT_ENDPOINT_SIZE, // the size of the endpoint descriptor in bytes
83  .bDescriptorType = USB_DT_ENDPOINT, // a value of 5 indicates that this describes an endpoint
84  .bEndpointAddress = 0x83, // IN (to host) direction (1<<7), endpoint 3
85  .bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT, // interrupt mode
86  .wMaxPacketSize = 16, // maximum packet size
87  .bInterval = 255, // the frequency, in number of frames, that we're going to be sending data
88 }};
89 
94 static const struct {
95  struct usb_cdc_header_descriptor header;
96  struct usb_cdc_call_management_descriptor call_mgmt;
97  struct usb_cdc_acm_descriptor acm;
98  struct usb_cdc_union_descriptor cdc_union;
99 } __attribute__((packed)) cdcacm_functional_descriptors = {
100  .header = {
101  .bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
102  .bDescriptorType = CS_INTERFACE,
103  .bDescriptorSubtype = USB_CDC_TYPE_HEADER,
104  .bcdCDC = 0x0110,
105  },
106  .call_mgmt = {
107  .bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor),
108  .bDescriptorType = CS_INTERFACE,
109  .bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
110  .bmCapabilities = 0,
111  .bDataInterface = 1,
112  },
113  .acm = {
114  .bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
115  .bDescriptorType = CS_INTERFACE,
116  .bDescriptorSubtype = USB_CDC_TYPE_ACM,
117  .bmCapabilities = 0,
118  },
119  .cdc_union = {
120  .bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
121  .bDescriptorType = CS_INTERFACE,
122  .bDescriptorSubtype = USB_CDC_TYPE_UNION,
123  .bControlInterface = 0,
124  .bSubordinateInterface0 = 1,
125  },
126 };
127 
131 static const struct usb_interface_descriptor communication_interface[] = {{
132  .bLength = USB_DT_INTERFACE_SIZE,
133  .bDescriptorType = USB_DT_INTERFACE,
134  .bInterfaceNumber = 0,
135  .bAlternateSetting = 0,
136  .bNumEndpoints = 1,
137  .bInterfaceClass = USB_CLASS_CDC,
138  .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
139  .bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
140  .iInterface = 0,
141 
142  .endpoint = communication_endpoints,
143 
144  .extra = &cdcacm_functional_descriptors,
145  .extralen = sizeof(cdcacm_functional_descriptors),
146 }};
147 
151 static const struct usb_interface_descriptor data_interface[] = {{
152  .bLength = USB_DT_INTERFACE_SIZE,
153  .bDescriptorType = USB_DT_INTERFACE,
154  .bInterfaceNumber = 1,
155  .bAlternateSetting = 0,
156  .bNumEndpoints = 2,
157  .bInterfaceClass = USB_CLASS_DATA,
158  .bInterfaceSubClass = 0,
159  .bInterfaceProtocol = 0,
160  .iInterface = 0,
161 
162  .endpoint = data_endpoints,
163 }};
164 
166 static const struct usb_interface interfaces[] = {{
167  .num_altsetting = 1,
168  .altsetting = communication_interface,
169 }, {
170  .num_altsetting = 1,
171  .altsetting = data_interface,
172 }};
173 
175 static const struct usb_config_descriptor config = {
176  .bLength = USB_DT_CONFIGURATION_SIZE, // the length of this header in bytes
177  .bDescriptorType = USB_DT_CONFIGURATION, // a value of 2 indicates that this is a configuration descriptor
178  .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
179  .bNumInterfaces = 2, // the number of interfaces in this configuration
180  .bConfigurationValue = 1, // the index of this configuration
181  .iConfiguration = 0, // a string index describing this configuration (zero means not provided)
182  .bmAttributes = 0x80, // self powered (0<<6), supports remote wakeup (0<<5)
183  .bMaxPower = 0x32, // the maximum amount of current that this device will draw in 2mA units
184  // end of header
185  .interface = interfaces, // pointer to an array of interfaces
186 };
187 
191 static const char *usb_strings[] = {
192  "CuVoodoo",
193  "CDC-ACM",
194  "STM32F1",
195 };
196 
197 static uint8_t usbd_control_buffer[128] = {0};
198 static usbd_device *usb_device = NULL;
199 static bool connected = false;
201 /* input and output ring buffer, indexes, and available memory */
202 static uint8_t rx_buffer[CDCACM_BUFFER] = {0};
203 static volatile uint8_t rx_i = 0;
204 static volatile uint8_t rx_used = 0;
205 mutex_t rx_lock = MUTEX_UNLOCKED;
206 static uint8_t tx_buffer[CDCACM_BUFFER] = {0};
207 static volatile uint8_t tx_i = 0;
208 static volatile uint8_t tx_used = 0;
209 mutex_t tx_lock = MUTEX_UNLOCKED;
210 volatile uint8_t cdcacm_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
211 
213 static void usb_disconnect(void)
214 {
215  /* short USB disconnect to force re-enumerate */
216 #if defined(SYSTEM_BOARD) || defined(BLUE_PILL)
217  // pull USB D+ low for a short while
218  rcc_periph_clock_enable(RCC_GPIOA);
219  gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO12);
220  gpio_clear(GPIOA, GPIO12);
221  for (uint32_t i = 0; i < 0x2000; i++) {
222  __asm__("nop");
223  }
224 #elif defined(MAPLE_MINI)
225  // disconnect USB D+ using dedicated DISC line/circuit on PB9
226  rcc_periph_clock_enable(RCC_GPIOB);
227  gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO9);
228  gpio_set(GPIOB, GPIO9);
229  for (uint32_t i = 0; i < 0x2000; i++) {
230  __asm__("nop");
231  }
232  gpio_clear(GPIOB, GPIO9);
233 #endif
234 }
235 
245 static int 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))
246 {
247  (void)complete;
248  (void)buf;
249  (void)usbd_dev;
250 
251  switch (req->bRequest) {
252  case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
253  connected = req->wValue ? true : false; // check if terminal is open
254  //bool dtr = (req->wValue & (1 << 0)) ? true : false;
255  //bool rts = (req->wValue & (1 << 1)) ? true : false;
256  /* this Linux cdc_acm driver requires this to be implemented
257  * even though it's optional in the CDC spec, and we don't
258  * advertise it in the ACM functional descriptor.
259  */
260  uint8_t reply[10] = {0};
261  struct usb_cdc_notification *notif = (void *)reply;
262  /* we echo signals back to host as notification. */
263  notif->bmRequestType = 0xA1;
264  notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
265  notif->wValue = 0;
266  notif->wIndex = 0;
267  notif->wLength = 2;
268  reply[8] = req->wValue & 3;
269  reply[9] = 0;
270  usbd_ep_write_packet(usbd_dev, 0x83, reply, LENGTH(reply));
271  break;
272  case USB_CDC_REQ_SET_LINE_CODING:
273  // ignore if length is wrong
274  if (*len < sizeof(struct usb_cdc_line_coding)) {
275  return 0;
276  }
277  // get the line coding
278  struct usb_cdc_line_coding *coding = (struct usb_cdc_line_coding *)*buf;
279  /* reset device is the data bits is set to 5
280  * this is used to allowing rebooting the device in DFU mode for reflashing
281  * to reset the device from the host you can use stty --file /dev/ttyACM0 115200 raw cs5
282  */
283  if (coding->bDataBits==5) {
284  usb_disconnect(); // force re-enumerate after reset
285  scb_reset_system(); // reset device
286  while (true); // wait for the reset to happen
287  }
288  break;
289  default:
290  return 0;
291  }
292  return 1;
293 }
294 
299 static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
300 {
301  (void)ep;
302 
303  char usb_data[64] = {0}; // buffer to read data
304  uint16_t usb_length = 0; // length of incoming data
305 
306  /* receive data */
307  usb_length = usbd_ep_read_packet(usbd_dev, 0x01, usb_data, sizeof(usb_data));
308  if (usb_length) { // copy received data
309  for (uint16_t i=0; i<usb_length && rx_used<LENGTH(rx_buffer); i++) { // only until buffer is full
310  rx_buffer[(rx_i+rx_used)%LENGTH(rx_buffer)] = usb_data[i]; // put character in buffer
311  rx_used++; // update used buffer
312  }
313  cdcacm_received = rx_used; // update available data
314  }
315 }
316 
321 static void cdcacm_data_tx_cb(usbd_device *usbd_dev, uint8_t ep)
322 {
323  (void)ep;
324  (void)usbd_dev;
325 
326  if (!usbd_dev || !connected || !tx_used) { // verify if we can send and there is something to send
327  return;
328  }
329  if (mutex_trylock(&tx_lock)) { // try to get lock
330  uint8_t usb_length = (tx_used > 64 ? 64 : tx_used); // length of data to be transmitted (respect max packet size)
331  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
332  while (usb_length != usbd_ep_write_packet(usb_device, 0x82, (void*)(&tx_buffer[tx_i]), usb_length)); // ensure data is written into transmit buffer
333  tx_i = (tx_i+usb_length)%LENGTH(tx_buffer); // update location on buffer
334  tx_used -= usb_length; // update used size
335  mutex_unlock(&tx_lock); // release lock
336  } else {
337  usbd_ep_write_packet(usb_device, 0x82, NULL, 0); // trigger empty tx for a later callback
338  }
339  usbd_poll(usb_device); // ensure the data gets sent
340 }
341 
346 static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
347 {
348  (void)wValue;
349 
350  usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
351  usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_tx_cb);
352  usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
353 
354  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);
355 }
356 
357 void cdcacm_setup(void)
358 {
359  connected = false; // start with USB not connected
360  usb_disconnect(); // force re-enumerate (useful after a restart or if there is a bootloader using another USB profile)
361 
362  /* initialize USB */
363  usb_device = usbd_init(&st_usbfs_v1_usb_driver, &device_descriptor, &config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer));
364  usbd_register_set_config_callback(usb_device, cdcacm_set_config);
365 
366  /* enable interrupts (to not have to poll all the time) */
367  nvic_enable_irq(NVIC_USB_LP_CAN_RX0_IRQ); // without this USB isn't detected by the host
368 
369  /* reset buffer states */
370  rx_i = 0;
371  rx_used = 0;
372  mutex_unlock(&rx_lock);
373  cdcacm_received = 0;
374  tx_i = 0;
375  tx_used = 0;
376  mutex_unlock(&tx_lock);
377 }
378 
379 char cdcacm_getchar(void)
380 {
381  while (!rx_used) { // idle until data is available
382  __WFI(); // sleep until interrupt (not sure if it's a good idea here)
383  }
384  char to_return = rx_buffer[rx_i]; // get the next available character
385  rx_i = (rx_i+1)%LENGTH(rx_buffer); // update used buffer
386  rx_used--; // update used buffer
387  cdcacm_received = rx_used; // update available data
388  return to_return;
389 }
390 
391 void cdcacm_putchar(char c)
392 {
393  if (!usb_device || !connected) {
394  return;
395  }
396  mutex_lock(&tx_lock); // get lock to prevent race condition
397  if (tx_used<LENGTH(tx_buffer)) { // buffer not full
398  tx_buffer[(tx_i+tx_used)%LENGTH(tx_buffer)] = c; // put character in buffer
399  tx_used++; // update used buffer
400  } else { // buffer full (might be that no terminal is connected to this serial)
401  tx_i = (tx_i+1)%LENGTH(tx_buffer); // shift start
402  tx_buffer[(tx_i+tx_used)%LENGTH(tx_buffer)] = c; // overwrite old data
403  }
404  mutex_unlock(&tx_lock); // release lock
405  if (tx_used==1) { // to buffer is not empty anymore
406  usbd_ep_write_packet(usb_device, 0x82, NULL, 0); // trigger tx callback
407  }
408 }
409 
411 void usb_lp_can_rx0_isr(void) {
412  usbd_poll(usb_device);
413 }
static int 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))
incoming USB CDC ACM control request
Definition: usb_cdcacm.c:245
static const struct usb_interface interfaces[]
USB CDC ACM interface descriptor.
Definition: usb_cdcacm.c:166
static volatile uint8_t tx_i
current position if transmitted data
Definition: usb_cdcacm.c:207
void cdcacm_putchar(char c)
send character over USB (non-blocking)
Definition: usb_cdcacm.c:391
static uint8_t rx_buffer[CDCACM_BUFFER]
ring buffer for received data
Definition: usb_cdcacm.c:202
static const struct @0 __attribute__((packed))
USB CDC ACM functional descriptor.
Definition: usb_cdcacm.c:99
global definitions and methods
static void cdcacm_data_tx_cb(usbd_device *usbd_dev, uint8_t ep)
USB CDC ACM data transmitted callback.
Definition: usb_cdcacm.c:321
static const struct usb_config_descriptor config
USB CDC ACM configuration descriptor.
Definition: usb_cdcacm.c:175
static const struct usb_endpoint_descriptor data_endpoints[]
USB CDC ACM data endpoints.
Definition: usb_cdcacm.c:62
void cdcacm_setup(void)
setup USB CDC ACM peripheral
Definition: usb_cdcacm.c:357
static uint8_t usbd_control_buffer[128]
buffer to be used for control requests
Definition: usb_cdcacm.c:197
static volatile uint8_t rx_used
how much data has been received and not red
Definition: usb_cdcacm.c:204
mutex_t rx_lock
lock to update rx_i or rx_used
Definition: usb_cdcacm.c:205
static const struct usb_interface_descriptor communication_interface[]
USB CDC interface descriptor.
Definition: usb_cdcacm.c:131
volatile uint8_t cdcacm_received
how many bytes available in the received buffer since last read
Definition: usb_cdcacm.c:210
static const char * usb_strings[]
USB string table.
Definition: usb_cdcacm.c:191
static void usb_disconnect(void)
disconnect USB by pulling down D+ to for re-enumerate
Definition: usb_cdcacm.c:213
static const struct usb_interface_descriptor data_interface[]
USB CDC ACM data class interface descriptor.
Definition: usb_cdcacm.c:151
static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
set USB CDC ACM configuration
Definition: usb_cdcacm.c:346
static bool connected
is the USB device is connected to a host
Definition: usb_cdcacm.c:199
void usb_lp_can_rx0_isr(void)
USB interrupt service routine called when data is received.
Definition: usb_cdcacm.c:411
static const struct usb_endpoint_descriptor communication_endpoints[]
USB CDC ACM communication endpoints.
Definition: usb_cdcacm.c:81
static uint8_t tx_buffer[CDCACM_BUFFER]
ring buffer for data to transmit
Definition: usb_cdcacm.c:206
library for USB CDC ACM communication (API)
#define LENGTH(x)
get the length of an array
Definition: global.h:26
static const struct usb_device_descriptor device_descriptor
USB CDC ACM device descriptor.
Definition: usb_cdcacm.c:42
static volatile uint8_t rx_i
current position of read received data
Definition: usb_cdcacm.c:203
#define CDCACM_BUFFER
transmit and receive buffer sizes
Definition: usb_cdcacm.h:23
static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
USB CDC ACM data received callback.
Definition: usb_cdcacm.c:299
static volatile uint8_t tx_used
how much data needs to be transmitted
Definition: usb_cdcacm.c:208
static usbd_device * usb_device
structure holding all the info related to the USB device
Definition: usb_cdcacm.c:198
mutex_t tx_lock
lock to update tx_i or tx_used
Definition: usb_cdcacm.c:209
char cdcacm_getchar(void)
get character received over USB (blocking)
Definition: usb_cdcacm.c:379