src/main/drivers/serial_usb_vcp.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdint.h>
  22 #include <stdbool.h>
  23
  24 #include "platform.h"
  25
  26 #ifdef USE_VCP
  27
  28 #include "build/build_config.h"
  29
  30 #include "common/utils.h"
  31
  32 #include "drivers/io.h"
  33
  34 #include "pg/usb.h"
  35
  36 #if defined(STM32F4)
  37 #include "usb_core.h"
  38 #include "usbd_cdc_vcp.h"
  39 #ifdef USE_USB_CDC_HID
  40 #include "usbd_hid_cdc_wrapper.h"
  41 #endif
  42 #include "usb_io.h"
  43 #elif defined(STM32F7) || defined(STM32H7)
  44 #include "vcp_hal/usbd_cdc_interface.h"
  45 #include "usb_io.h"
  46 #ifdef USE_USB_CDC_HID
  47 #include "usbd_ioreq.h"
  48
  49 extern USBD_ClassTypeDef  USBD_HID_CDC;
  50 #endif
  51 USBD_HandleTypeDef USBD_Device;
  52 #else
  53 #include "usb_core.h"
  54 #include "usb_init.h"
  55 #include "hw_config.h"
  56 #endif
  57
  58 #include "drivers/time.h"
  59
  60 #include "serial.h"
  61 #include "serial_usb_vcp.h"
  62
  63
  64 #define USB_TIMEOUT  50
  65
  66 static vcpPort_t vcpPort;
  67
  68 static void usbVcpSetBaudRate(serialPort_t *instance, uint32_t baudRate)
  69 {
  70     UNUSED(instance);
  71     UNUSED(baudRate);
  72
  73     // TODO implement
  74 }
  75
  76 static void usbVcpSetMode(serialPort_t *instance, portMode_e mode)
  77 {
  78     UNUSED(instance);
  79     UNUSED(mode);
  80
  81     // TODO implement
  82 }
  83
  84 static void usbVcpSetCtrlLineStateCb(serialPort_t *instance, void (*cb)(void *context, uint16_t ctrlLineState), void *context)
  85 {
  86     UNUSED(instance);
  87
  88     // Register upper driver control line state callback routine with USB driver
  89     CDC_SetCtrlLineStateCb((void (*)(void *context, uint16_t ctrlLineState))cb, context);
  90 }
  91
  92 static void usbVcpSetBaudRateCb(serialPort_t *instance, void (*cb)(serialPort_t *context, uint32_t baud), serialPort_t *context)
  93 {
  94     UNUSED(instance);
  95
  96     // Register upper driver baud rate callback routine with USB driver
  97     CDC_SetBaudRateCb((void (*)(void *context, uint32_t baud))cb, (void *)context);
  98 }
  99
 100 static bool isUsbVcpTransmitBufferEmpty(const serialPort_t *instance)
 101 {
 102     UNUSED(instance);
 103     return true;
 104 }
 105
 106 static uint32_t usbVcpAvailable(const serialPort_t *instance)
 107 {
 108     UNUSED(instance);
 109
 110     return CDC_Receive_BytesAvailable();
 111 }
 112
 113 static uint8_t usbVcpRead(serialPort_t *instance)
 114 {
 115     UNUSED(instance);
 116
 117     uint8_t buf[1];
 118
 119     while (true) {
 120         if (CDC_Receive_DATA(buf, 1))
 121             return buf[0];
 122     }
 123 }
 124
 125 static void usbVcpWriteBuf(serialPort_t *instance, const void *data, int count)
 126 {
 127     UNUSED(instance);
 128
 129     if (!(usbIsConnected() && usbIsConfigured())) {
 130         return;
 131     }
 132
 133     uint32_t start = millis();
 134     const uint8_t *p = data;
 135     while (count > 0) {
 136         uint32_t txed = CDC_Send_DATA(p, count);
 137         count -= txed;
 138         p += txed;
 139
 140         if (millis() - start > USB_TIMEOUT) {
 141             break;
 142         }
 143     }
 144 }
 145
 146 static bool usbVcpFlush(vcpPort_t *port)
 147 {
 148     uint32_t count = port->txAt;
 149     port->txAt = 0;
 150
 151     if (count == 0) {
 152         return true;
 153     }
 154
 155     if (!usbIsConnected() || !usbIsConfigured()) {
 156         return false;
 157     }
 158
 159     uint32_t start = millis();
 160     uint8_t *p = port->txBuf;
 161     while (count > 0) {
 162         uint32_t txed = CDC_Send_DATA(p, count);
 163         count -= txed;
 164         p += txed;
 165
 166         if (millis() - start > USB_TIMEOUT) {
 167             break;
 168         }
 169     }
 170     return count == 0;
 171 }
 172
 173 static void usbVcpWrite(serialPort_t *instance, uint8_t c)
 174 {
 175     vcpPort_t *port = container_of(instance, vcpPort_t, port);
 176
 177     port->txBuf[port->txAt++] = c;
 178     if (!port->buffering || port->txAt >= ARRAYLEN(port->txBuf)) {
 179         usbVcpFlush(port);
 180     }
 181 }
 182
 183 static void usbVcpBeginWrite(serialPort_t *instance)
 184 {
 185     vcpPort_t *port = container_of(instance, vcpPort_t, port);
 186     port->buffering = true;
 187 }
 188
 189 static uint32_t usbTxBytesFree(const serialPort_t *instance)
 190 {
 191     UNUSED(instance);
 192     return CDC_Send_FreeBytes();
 193 }
 194
 195 static void usbVcpEndWrite(serialPort_t *instance)
 196 {
 197     vcpPort_t *port = container_of(instance, vcpPort_t, port);
 198     port->buffering = false;
 199     usbVcpFlush(port);
 200 }
 201
 202 static const struct serialPortVTable usbVTable[] = {
 203     {
 204         .serialWrite = usbVcpWrite,
 205         .serialTotalRxWaiting = usbVcpAvailable,
 206         .serialTotalTxFree = usbTxBytesFree,
 207         .serialRead = usbVcpRead,
 208         .serialSetBaudRate = usbVcpSetBaudRate,
 209         .isSerialTransmitBufferEmpty = isUsbVcpTransmitBufferEmpty,
 210         .setMode = usbVcpSetMode,
 211         .setCtrlLineStateCb = usbVcpSetCtrlLineStateCb,
 212         .setBaudRateCb = usbVcpSetBaudRateCb,
 213         .writeBuf = usbVcpWriteBuf,
 214         .beginWrite = usbVcpBeginWrite,
 215         .endWrite = usbVcpEndWrite
 216     }
 217 };
 218
 219 serialPort_t *usbVcpOpen(void)
 220 {
 221     vcpPort_t *s;
 222
 223     IOInit(IOGetByTag(IO_TAG(PA11)), OWNER_USB, 0);
 224     IOInit(IOGetByTag(IO_TAG(PA12)), OWNER_USB, 0);
 225
 226 #if defined(STM32F4)
 227     usbGenerateDisconnectPulse();
 228
 229     switch (usbDevConfig()->type) {
 230 #ifdef USE_USB_CDC_HID
 231     case COMPOSITE:
 232         USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_HID_CDC_cb, &USR_cb);
 233         break;
 234 #endif
 235     default:
 236         USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb);
 237         break;
 238     }
 239 #elif defined(STM32F7) || defined(STM32H7)
 240
 241     usbGenerateDisconnectPulse();
 242
 243     /* Init Device Library */
 244     USBD_Init(&USBD_Device, &VCP_Desc, 0);
 245
 246     /* Add Supported Class */
 247     switch (usbDevConfig()->type) {
 248 #ifdef USE_USB_CDC_HID
 249     case COMPOSITE:
 250         USBD_RegisterClass(&USBD_Device, &USBD_HID_CDC);
 251         break;
 252 #endif
 253     default:
 254         USBD_RegisterClass(&USBD_Device, USBD_CDC_CLASS);
 255         break;
 256     }
 257
 258     /* HID Interface doesn't have any callbacks... */
 259     /* Add CDC Interface Class */
 260     USBD_CDC_RegisterInterface(&USBD_Device, &USBD_CDC_fops);
 261
 262     /* Start Device Process */
 263     USBD_Start(&USBD_Device);
 264
 265 #ifdef STM32H7
 266     HAL_PWREx_EnableUSBVoltageDetector();
 267     delay(100); // Cold boot failures observed without this, even when USB cable is not connected
 268 #endif
 269
 270
 271 #else
 272     Set_System();
 273     Set_USBClock();
 274     USB_Init();
 275     USB_Interrupts_Config();
 276 #endif
 277
 278     s = &vcpPort;
 279     s->port.vTable = usbVTable;
 280
 281     return (serialPort_t *)s;
 282 }
 283
 284 uint32_t usbVcpGetBaudRate(serialPort_t *instance)
 285 {
 286     UNUSED(instance);
 287
 288     return CDC_BaudRate();
 289 }
 290
 291 uint8_t usbVcpIsConnected(void)
 292 {
 293     return usbIsConnected();
 294 }
 295 #endif