flight/pios/stm32f30x/pios_usb_cdc.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup   PIOS_USB_COM USB COM Functions
   6  * @brief PIOS USB COM implementation for CDC interfaces
   7  * @notes      This implements a CDC Serial Port
   8  * @{
   9  *
  10  * @file       pios_usb_cdc.c
  11  * @author     The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
  12  *             The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
  13  * @brief      USB COM functions (STM32 dependent code)
  14  * @see        The GNU Public License (GPL) Version 3
  15  *
  16  *****************************************************************************/
  17 /*
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 3 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful, but
  24  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  25  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  26  * for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License along
  29  * with this program; if not, write to the Free Software Foundation, Inc.,
  30  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  31  */
  32
  33 #include "pios.h"
  34
  35 #ifdef PIOS_INCLUDE_USB_CDC
  36
  37 #include "pios_usb_cdc_priv.h"
  38 #include "pios_usb_board_data.h" /* PIOS_BOARD_*_DATA_LENGTH */
  39
  40 /* STM32 USB Library Definitions */
  41 #include "usb_lib.h"
  42
  43 static void PIOS_USB_CDC_RegisterTxCallback(uint32_t usbcdc_id, pios_com_callback tx_out_cb, uint32_t context);
  44 static void PIOS_USB_CDC_RegisterRxCallback(uint32_t usbcdc_id, pios_com_callback rx_in_cb, uint32_t context);
  45 static void PIOS_USB_CDC_RegisterBaudRateCallback(uint32_t usbcdc_id, pios_com_callback_baud_rate baud_rate_cb, uint32_t context);
  46 static void PIOS_USB_CDC_RegisterAvailableCallback(uint32_t usbcdc_id, pios_com_callback_available baud_rate_cb, uint32_t context);
  47 static void PIOS_USB_CDC_ChangeConnectionState(bool connected, uint32_t usbcdc_id);
  48 static void PIOS_USB_CDC_TxStart(uint32_t usbcdc_id, uint16_t tx_bytes_avail);
  49 static void PIOS_USB_CDC_RxStart(uint32_t usbcdc_id, uint16_t rx_bytes_avail);
  50 static uint32_t PIOS_USB_CDC_Available(uint32_t usbcdc_id);
  51
  52 const struct pios_com_driver pios_usb_cdc_com_driver = {
  53     .tx_start   = PIOS_USB_CDC_TxStart,
  54     .rx_start   = PIOS_USB_CDC_RxStart,
  55     .bind_tx_cb = PIOS_USB_CDC_RegisterTxCallback,
  56     .bind_rx_cb = PIOS_USB_CDC_RegisterRxCallback,
  57     .bind_baud_rate_cb = PIOS_USB_CDC_RegisterBaudRateCallback,
  58     .available  = PIOS_USB_CDC_Available,
  59     .bind_available_cb = PIOS_USB_CDC_RegisterAvailableCallback,
  60 };
  61
  62 enum pios_usb_cdc_dev_magic {
  63     PIOS_USB_CDC_DEV_MAGIC = 0xAABBCCDD,
  64 };
  65
  66 struct pios_usb_cdc_dev {
  67     enum pios_usb_cdc_dev_magic   magic;
  68     const struct pios_usb_cdc_cfg *cfg;
  69
  70     uint32_t lower_id;
  71
  72     pios_com_callback rx_in_cb;
  73     uint32_t rx_in_context;
  74     pios_com_callback tx_out_cb;
  75     uint32_t tx_out_context;
  76
  77     pios_com_callback_baud_rate baud_rate_cb;
  78     uint32_t baud_rate_context;
  79     pios_com_callback_available available_cb;
  80     uint32_t available_context;
  81
  82     uint8_t  rx_packet_buffer[PIOS_USB_BOARD_CDC_DATA_LENGTH];
  83     /*
  84      * NOTE: This is -1 as somewhat of a hack.  It ensures that we always send packets
  85      * that are strictly < maxPacketSize for this interface which means we never have
  86      * to bother with zero length packets (ZLP).
  87      */
  88     uint8_t  tx_packet_buffer[PIOS_USB_BOARD_CDC_DATA_LENGTH - 1];
  89
  90     uint32_t rx_dropped;
  91     uint32_t rx_oversize;
  92 };
  93
  94 static bool PIOS_USB_CDC_validate(struct pios_usb_cdc_dev *usb_cdc_dev)
  95 {
  96     return usb_cdc_dev->magic == PIOS_USB_CDC_DEV_MAGIC;
  97 }
  98
  99 #if defined(PIOS_INCLUDE_FREERTOS)
 100 static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
 101 {
 102     struct pios_usb_cdc_dev *usb_cdc_dev;
 103
 104     usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_fastheapmalloc(sizeof(struct pios_usb_cdc_dev));
 105     if (!usb_cdc_dev) {
 106         return NULL;
 107     }
 108
 109     memset(usb_cdc_dev, 0, sizeof(struct pios_usb_cdc_dev));
 110     usb_cdc_dev->magic = PIOS_USB_CDC_DEV_MAGIC;
 111     return usb_cdc_dev;
 112 }
 113 #else
 114 static struct pios_usb_cdc_dev pios_usb_cdc_devs[PIOS_USB_CDC_MAX_DEVS];
 115 static uint8_t pios_usb_cdc_num_devs;
 116 static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
 117 {
 118     struct pios_usb_cdc_dev *usb_cdc_dev;
 119
 120     if (pios_usb_cdc_num_devs >= PIOS_USB_CDC_MAX_DEVS) {
 121         return NULL;
 122     }
 123
 124     usb_cdc_dev = &pios_usb_cdc_devs[pios_usb_cdc_num_devs++];
 125
 126     memset(usb_cdc_dev, 0, sizeof(struct pios_usb_cdc_dev));
 127     usb_cdc_dev->magic = PIOS_USB_CDC_DEV_MAGIC;
 128
 129     return usb_cdc_dev;
 130 }
 131 #endif /* if defined(PIOS_INCLUDE_FREERTOS) */
 132
 133 static void PIOS_USB_CDC_DATA_EP_IN_Callback(void);
 134 static void PIOS_USB_CDC_DATA_EP_OUT_Callback(void);
 135 static void PIOS_USB_CDC_CTRL_EP_IN_Callback(void);
 136
 137 static uint32_t pios_usb_cdc_id;
 138
 139 /* Need a better way to pull these in */
 140 extern void(*pEpInt_IN[7]) (void);
 141 extern void(*pEpInt_OUT[7]) (void);
 142
 143 int32_t PIOS_USB_CDC_Init(uint32_t *usbcdc_id, const struct pios_usb_cdc_cfg *cfg, uint32_t lower_id)
 144 {
 145     PIOS_Assert(usbcdc_id);
 146     PIOS_Assert(cfg);
 147
 148     struct pios_usb_cdc_dev *usb_cdc_dev;
 149
 150     usb_cdc_dev = (struct pios_usb_cdc_dev *)PIOS_USB_CDC_alloc();
 151     if (!usb_cdc_dev) {
 152         goto out_fail;
 153     }
 154
 155     /* Bind the configuration to the device instance */
 156     usb_cdc_dev->cfg = cfg;
 157     usb_cdc_dev->lower_id = lower_id;
 158
 159     pios_usb_cdc_id  = (uint32_t)usb_cdc_dev;
 160
 161     /* Bind lower level callbacks into the USB infrastructure */
 162     pEpInt_OUT[cfg->ctrl_tx_ep - 1] = PIOS_USB_CDC_CTRL_EP_IN_Callback;
 163     pEpInt_IN[cfg->data_tx_ep - 1]  = PIOS_USB_CDC_DATA_EP_IN_Callback;
 164     pEpInt_OUT[cfg->data_rx_ep - 1] = PIOS_USB_CDC_DATA_EP_OUT_Callback;
 165
 166     PIOS_USB_RegisterConnectionStateCallback(PIOS_USB_CDC_ChangeConnectionState, (uint32_t)usb_cdc_dev);
 167
 168     *usbcdc_id = (uint32_t)usb_cdc_dev;
 169
 170     return 0;
 171
 172 out_fail:
 173     return -1;
 174 }
 175
 176
 177 static void PIOS_USB_CDC_RegisterRxCallback(uint32_t usbcdc_id, pios_com_callback rx_in_cb, uint32_t context)
 178 {
 179     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 180
 181     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 182
 183     PIOS_Assert(valid);
 184
 185     /*
 186      * Order is important in these assignments since ISR uses _cb
 187      * field to determine if it's ok to dereference _cb and _context
 188      */
 189     usb_cdc_dev->rx_in_context = context;
 190     usb_cdc_dev->rx_in_cb = rx_in_cb;
 191 }
 192
 193 static void PIOS_USB_CDC_RegisterTxCallback(uint32_t usbcdc_id, pios_com_callback tx_out_cb, uint32_t context)
 194 {
 195     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 196
 197     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 198
 199     PIOS_Assert(valid);
 200
 201     /*
 202      * Order is important in these assignments since ISR uses _cb
 203      * field to determine if it's ok to dereference _cb and _context
 204      */
 205     usb_cdc_dev->tx_out_context = context;
 206     usb_cdc_dev->tx_out_cb = tx_out_cb;
 207 }
 208
 209 static void PIOS_USB_CDC_RxStart(uint32_t usbcdc_id, uint16_t rx_bytes_avail)
 210 {
 211     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 212
 213     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 214
 215     PIOS_Assert(valid);
 216
 217     if (!PIOS_USB_CheckAvailable(usb_cdc_dev->lower_id)) {
 218         return;
 219     }
 220
 221     // If endpoint was stalled and there is now space make it valid
 222     PIOS_IRQ_Disable();
 223     if ((GetEPRxStatus(usb_cdc_dev->cfg->data_rx_ep) != EP_RX_VALID) &&
 224         (rx_bytes_avail >= sizeof(usb_cdc_dev->rx_packet_buffer))) {
 225         SetEPRxStatus(usb_cdc_dev->cfg->data_rx_ep, EP_RX_VALID);
 226     }
 227     PIOS_IRQ_Enable();
 228 }
 229
 230 static void PIOS_USB_CDC_SendData(struct pios_usb_cdc_dev *usb_cdc_dev)
 231 {
 232     uint16_t bytes_to_tx;
 233
 234     if (!usb_cdc_dev->tx_out_cb) {
 235         return;
 236     }
 237
 238     bool need_yield = false;
 239     bytes_to_tx = (usb_cdc_dev->tx_out_cb)(usb_cdc_dev->tx_out_context,
 240                                            usb_cdc_dev->tx_packet_buffer,
 241                                            sizeof(usb_cdc_dev->tx_packet_buffer),
 242                                            NULL,
 243                                            &need_yield);
 244     if (bytes_to_tx == 0) {
 245         return;
 246     }
 247
 248     UserToPMABufferCopy(usb_cdc_dev->tx_packet_buffer,
 249                         GetEPTxAddr(usb_cdc_dev->cfg->data_tx_ep),
 250                         bytes_to_tx);
 251     SetEPTxCount(usb_cdc_dev->cfg->data_tx_ep, bytes_to_tx);
 252     SetEPTxValid(usb_cdc_dev->cfg->data_tx_ep);
 253
 254 #if defined(PIOS_INCLUDE_FREERTOS)
 255     if (need_yield) {
 256         vPortYield();
 257     }
 258 #endif /* PIOS_INCLUDE_FREERTOS */
 259 }
 260
 261 static void PIOS_USB_CDC_TxStart(uint32_t usbcdc_id, __attribute__((unused)) uint16_t tx_bytes_avail)
 262 {
 263     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 264
 265     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 266
 267     PIOS_Assert(valid);
 268
 269     if (!PIOS_USB_CheckAvailable(usb_cdc_dev->lower_id)) {
 270         return;
 271     }
 272
 273     if (GetEPTxStatus(usb_cdc_dev->cfg->data_tx_ep) == EP_TX_VALID) {
 274         /* Endpoint is already transmitting */
 275         return;
 276     }
 277
 278     PIOS_USB_CDC_SendData(usb_cdc_dev);
 279 }
 280
 281 static void PIOS_USB_CDC_DATA_EP_IN_Callback(void)
 282 {
 283     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 284
 285     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 286
 287     PIOS_Assert(valid);
 288
 289     PIOS_USB_CDC_SendData(usb_cdc_dev);
 290 }
 291
 292 static void PIOS_USB_CDC_DATA_EP_OUT_Callback(void)
 293 {
 294     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 295
 296     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 297
 298     PIOS_Assert(valid);
 299
 300     uint32_t DataLength;
 301
 302     /* Get the number of received data on the selected Endpoint */
 303     DataLength = GetEPRxCount(usb_cdc_dev->cfg->data_rx_ep);
 304     if (DataLength > sizeof(usb_cdc_dev->rx_packet_buffer)) {
 305         usb_cdc_dev->rx_oversize++;
 306         DataLength = sizeof(usb_cdc_dev->rx_packet_buffer);
 307     }
 308
 309     /* Use the memory interface function to read from the selected endpoint */
 310     PMAToUserBufferCopy((uint8_t *)usb_cdc_dev->rx_packet_buffer,
 311                         GetEPRxAddr(usb_cdc_dev->cfg->data_rx_ep),
 312                         DataLength);
 313
 314     if (!usb_cdc_dev->rx_in_cb) {
 315         /* No Rx call back registered, disable the receiver */
 316         SetEPRxStatus(usb_cdc_dev->cfg->data_rx_ep, EP_RX_NAK);
 317         return;
 318     }
 319
 320     uint16_t headroom;
 321     bool need_yield = false;
 322     uint16_t rc;
 323     rc = (usb_cdc_dev->rx_in_cb)(usb_cdc_dev->rx_in_context,
 324                                  usb_cdc_dev->rx_packet_buffer,
 325                                  DataLength,
 326                                  &headroom,
 327                                  &need_yield);
 328
 329     if (rc < DataLength) {
 330         /* Lost bytes on rx */
 331         usb_cdc_dev->rx_dropped += (DataLength - rc);
 332     }
 333
 334     if (headroom >= sizeof(usb_cdc_dev->rx_packet_buffer)) {
 335         /* We have room for a maximum length message */
 336         SetEPRxStatus(usb_cdc_dev->cfg->data_rx_ep, EP_RX_VALID);
 337     } else {
 338         /* Not enough room left for a message, apply backpressure */
 339         SetEPRxStatus(usb_cdc_dev->cfg->data_rx_ep, EP_RX_NAK);
 340     }
 341
 342 #if defined(PIOS_INCLUDE_FREERTOS)
 343     if (need_yield) {
 344         vPortYield();
 345     }
 346 #endif /* PIOS_INCLUDE_FREERTOS */
 347 }
 348
 349 static uint16_t control_line_state;
 350 RESULT PIOS_USB_CDC_SetControlLineState(void)
 351 {
 352     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 353
 354     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 355
 356     if (!valid) {
 357         /* No CDC interface is configured */
 358         return USB_UNSUPPORT;
 359     }
 360
 361     uint8_t wValue0 = pInformation->USBwValue0;
 362     uint8_t wValue1 = pInformation->USBwValue1;
 363
 364     control_line_state = wValue1 << 8 | wValue0;
 365
 366     return USB_SUCCESS;
 367 }
 368
 369 static uint32_t PIOS_USB_CDC_Available(uint32_t usbcdc_id)
 370 {
 371     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 372
 373     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 374
 375     PIOS_Assert(valid);
 376
 377     return PIOS_USB_CheckAvailable(usb_cdc_dev->lower_id) ? COM_AVAILABLE_RXTX : COM_AVAILABLE_NONE;
 378 }
 379
 380 static struct usb_cdc_line_coding line_coding = {
 381     .dwDTERate   = htousbl(57600),
 382     .bCharFormat = USB_CDC_LINE_CODING_STOP_1,
 383     .bParityType = USB_CDC_LINE_CODING_PARITY_NONE,
 384     .bDataBits   = 8,
 385 };
 386
 387 uint8_t *PIOS_USB_CDC_SetLineCoding(uint16_t Length)
 388 {
 389     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 390
 391     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 392
 393     if (!valid) {
 394         /* No CDC interface is configured */
 395         return NULL;
 396     }
 397
 398     if (Length == 0) {
 399         /* Report the number of bytes we're prepared to consume */
 400         pInformation->Ctrl_Info.Usb_wLength = sizeof(line_coding);
 401         pInformation->Ctrl_Info.Usb_rLength = sizeof(line_coding);
 402         return NULL;
 403     } else {
 404         /* Give out a pointer to the data struct */
 405         return (uint8_t *)&line_coding;
 406     }
 407 }
 408
 409 const uint8_t *PIOS_USB_CDC_GetLineCoding(uint16_t Length)
 410 {
 411     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 412
 413     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 414
 415     if (!valid) {
 416         /* No CDC interface is configured */
 417         return NULL;
 418     }
 419
 420     if (Length == 0) {
 421         pInformation->Ctrl_Info.Usb_wLength = sizeof(line_coding);
 422         return NULL;
 423     } else {
 424         return (uint8_t *)&line_coding;
 425     }
 426 }
 427
 428 struct usb_cdc_serial_state_report uart_state = {
 429     .bmRequestType = 0xA1,
 430     .bNotification = USB_CDC_NOTIFICATION_SERIAL_STATE,
 431     .wValue      = 0,
 432     .wIndex      = htousbs(1),
 433     .wLength     = htousbs(2),
 434     .bmUartState = htousbs(0),
 435 };
 436
 437 static void PIOS_USB_CDC_CTRL_EP_IN_Callback(void)
 438 {
 439     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 440
 441     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 442
 443     PIOS_Assert(valid);
 444
 445     /* Give back UART State Bitmap */
 446     /* UART State Bitmap
 447      *   15-7: reserved
 448      *      6:  bOverRun    overrun error
 449      *      5:  bParity     parity error
 450      *      4:  bFraming    framing error
 451      *      3:  bRingSignal RI
 452      *      2:  bBreak      break reception
 453      *      1:  bTxCarrier  DSR
 454      *      0:  bRxCarrier  DCD
 455      */
 456     uart_state.bmUartState = htousbs(0x0003);
 457
 458     UserToPMABufferCopy((uint8_t *)&uart_state,
 459                         GetEPTxAddr(usb_cdc_dev->cfg->ctrl_tx_ep),
 460                         sizeof(uart_state));
 461     SetEPTxCount(usb_cdc_dev->cfg->ctrl_tx_ep, PIOS_USB_BOARD_CDC_MGMT_LENGTH);
 462     SetEPTxValid(usb_cdc_dev->cfg->ctrl_tx_ep);
 463 }
 464
 465 static void PIOS_USB_CDC_RegisterBaudRateCallback(uint32_t usbcdc_id, pios_com_callback_baud_rate baud_rate_cb, uint32_t context)
 466 {
 467     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 468
 469     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 470
 471     PIOS_Assert(valid);
 472
 473     /*
 474      * Order is important in these assignments since ISR uses _cb
 475      * field to determine if it's ok to dereference _cb and _context
 476      */
 477     usb_cdc_dev->baud_rate_context = context;
 478     usb_cdc_dev->baud_rate_cb = baud_rate_cb;
 479 }
 480
 481 void PIOS_USB_CDC_SetLineCoding_Completed()
 482 {
 483     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_usb_cdc_id;
 484
 485     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 486
 487     if (!valid) {
 488         /* No CDC interface is configured */
 489         return;
 490     }
 491
 492     if (usb_cdc_dev->baud_rate_cb) {
 493         usb_cdc_dev->baud_rate_cb(usb_cdc_dev->baud_rate_context, usbltoh(line_coding.dwDTERate));
 494     }
 495 }
 496
 497 static void PIOS_USB_CDC_ChangeConnectionState(__attribute__((unused)) bool connected, uint32_t usbcdc_id)
 498 {
 499     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 500
 501     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 502
 503     PIOS_Assert(valid);
 504
 505     if (usb_cdc_dev->available_cb) {
 506         (usb_cdc_dev->available_cb)(usb_cdc_dev->available_context, PIOS_USB_CDC_Available(usbcdc_id));
 507     }
 508 }
 509
 510 static void PIOS_USB_CDC_RegisterAvailableCallback(uint32_t usbcdc_id, pios_com_callback_available available_cb, uint32_t context)
 511 {
 512     struct pios_usb_cdc_dev *usb_cdc_dev = (struct pios_usb_cdc_dev *)usbcdc_id;
 513
 514     bool valid = PIOS_USB_CDC_validate(usb_cdc_dev);
 515
 516     PIOS_Assert(valid);
 517
 518     /*
 519      * Order is important in these assignments since ISR uses _cb
 520      * field to determine if it's ok to dereference _cb and _context
 521      */
 522     usb_cdc_dev->available_context = context;
 523     usb_cdc_dev->available_cb = available_cb;
 524 }
 525
 526 #endif /* PIOS_INCLUDE_USB_CDC */