295 lines
7.9 KiB
C++
295 lines
7.9 KiB
C++
/*
|
|
* Copyright (C) EdgeTX
|
|
*
|
|
* Based on code named
|
|
* opentx - https://github.com/opentx/opentx
|
|
* th9x - http://code.google.com/p/th9x
|
|
* er9x - http://code.google.com/p/er9x
|
|
* gruvin9x - http://code.google.com/p/gruvin9x
|
|
*
|
|
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
|
|
#pragma data_alignment = 4
|
|
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
|
|
|
|
// include STM32 headers and generic board defs
|
|
#include "board_common.h"
|
|
|
|
extern "C" {
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "usb_conf.h"
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
/* Private define ------------------------------------------------------------*/
|
|
/* Private macro -------------------------------------------------------------*/
|
|
/* Private variables ---------------------------------------------------------*/
|
|
|
|
/* The following structures groups all needed parameters to be configured for the
|
|
ComPort. These parameters can modified on the fly by the host through CDC class
|
|
command class requests. */
|
|
typedef struct __attribute__ ((packed))
|
|
{
|
|
uint32_t bitrate;
|
|
uint8_t format;
|
|
uint8_t paritytype;
|
|
uint8_t datatype;
|
|
} LINE_CODING;
|
|
|
|
static LINE_CODING g_lc;
|
|
|
|
/* These are external variables imported from CDC core to be used for IN
|
|
transfer management. */
|
|
extern uint8_t APP_Rx_Buffer []; /* Write CDC received data in this buffer.
|
|
These data will be sent over USB IN endpoint
|
|
in the CDC core functions. */
|
|
extern volatile uint32_t APP_Rx_ptr_in; /* Increment this pointer or roll it back to
|
|
start address when writing received data
|
|
in the buffer APP_Rx_Buffer. */
|
|
extern volatile uint32_t APP_Rx_ptr_out;
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
static uint16_t VCP_Init (void);
|
|
static uint16_t VCP_DeInit (void);
|
|
static uint16_t VCP_Ctrl (uint32_t Cmd, uint8_t* Buf, uint32_t Len);
|
|
static uint16_t VCP_DataRx (uint8_t* Buf, uint32_t Len);
|
|
|
|
extern "C" const CDC_IF_Prop_TypeDef VCP_fops =
|
|
{
|
|
VCP_Init,
|
|
VCP_DeInit,
|
|
VCP_Ctrl,
|
|
0,
|
|
VCP_DataRx
|
|
};
|
|
|
|
} // extern "C"
|
|
|
|
static void (*receiveDataCb)(uint8_t* buf, uint32_t len);
|
|
static void (*ctrlLineStateCb)(uint16_t ctrlLineState);
|
|
static void (*baudRateCb)(uint32_t baud);
|
|
|
|
bool cdcConnected = false;
|
|
|
|
/* Private functions ---------------------------------------------------------*/
|
|
/**
|
|
* @brief VCP_Init
|
|
* Initializes the Media on the STM32
|
|
* @param None
|
|
* @retval Result of the opeartion (USBD_OK in all cases)
|
|
*/
|
|
static uint16_t VCP_Init(void)
|
|
{
|
|
cdcConnected = true;
|
|
ctrlLineStateCb = NULL;
|
|
baudRateCb = NULL;
|
|
return USBD_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief VCP_DeInit
|
|
* DeInitializes the Media on the STM32
|
|
* @param None
|
|
* @retval Result of the opeartion (USBD_OK in all cases)
|
|
*/
|
|
static uint16_t VCP_DeInit(void)
|
|
{
|
|
cdcConnected = false;
|
|
return USBD_OK;
|
|
}
|
|
|
|
void ust_cpy(LINE_CODING* plc2, const LINE_CODING* plc1)
|
|
{
|
|
plc2->bitrate = plc1->bitrate;
|
|
plc2->format = plc1->format;
|
|
plc2->paritytype = plc1->paritytype;
|
|
plc2->datatype = plc1->datatype;
|
|
}
|
|
|
|
/**
|
|
* @brief VCP_Ctrl
|
|
* Manage the CDC class requests
|
|
* @param Cmd: Command code
|
|
* @param Buf: Buffer containing command data (request parameters)
|
|
* @param Len: Number of data to be sent (in bytes)
|
|
* @retval Result of the opeartion (USBD_OK in all cases)
|
|
*/
|
|
static uint16_t VCP_Ctrl (uint32_t Cmd, uint8_t* Buf, uint32_t Len)
|
|
{
|
|
LINE_CODING* plc = (LINE_CODING*)Buf;
|
|
|
|
assert_param(Len>=sizeof(LINE_CODING));
|
|
|
|
switch (Cmd)
|
|
{
|
|
case SEND_ENCAPSULATED_COMMAND:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
case GET_ENCAPSULATED_RESPONSE:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
case SET_COMM_FEATURE:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
case GET_COMM_FEATURE:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
case CLEAR_COMM_FEATURE:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
case SET_LINE_CODING:
|
|
if (plc && (Len == sizeof (*plc))) {
|
|
// If a callback is provided, tell the upper driver of changes in baud rate
|
|
if (baudRateCb) {
|
|
baudRateCb(plc->bitrate);
|
|
}
|
|
// Copy into structure to save for later
|
|
ust_cpy(&g_lc, plc);
|
|
}
|
|
break;
|
|
|
|
case GET_LINE_CODING:
|
|
if (plc && (Len == sizeof (*plc))) {
|
|
ust_cpy(plc, &g_lc);
|
|
}
|
|
break;
|
|
|
|
case SET_CONTROL_LINE_STATE:
|
|
// If a callback is provided, tell the upper driver of changes in DTR/RTS state
|
|
if (plc && (Len == sizeof (uint16_t))) {
|
|
if (ctrlLineStateCb) {
|
|
ctrlLineStateCb(*((uint16_t *)Buf));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SEND_BREAK:
|
|
/* Not needed for this driver */
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return USBD_OK;
|
|
}
|
|
|
|
// return the bytes free in the circular buffer
|
|
uint32_t usbSerialFreeSpace()
|
|
{
|
|
// functionally equivalent to:
|
|
//
|
|
// (APP_Rx_ptr_out > APP_Rx_ptr_in ? APP_Rx_ptr_out - APP_Rx_ptr_in :
|
|
// APP_RX_DATA_SIZE - APP_Rx_ptr_in + APP_Rx_ptr_in)
|
|
//
|
|
// but without the impact of the condition check.
|
|
|
|
return ((APP_Rx_ptr_out - APP_Rx_ptr_in) +
|
|
(-((int)(APP_Rx_ptr_out <= APP_Rx_ptr_in)) & APP_RX_DATA_SIZE)) -
|
|
1;
|
|
}
|
|
|
|
void usbSerialPutc(uint8_t c)
|
|
{
|
|
/*
|
|
Apparently there is no reliable way to tell if the
|
|
virtual serial port is opened or not.
|
|
|
|
The cdcConnected variable only reports the state
|
|
of the physical USB connection.
|
|
*/
|
|
|
|
if (!cdcConnected) return;
|
|
|
|
/*
|
|
APP_Rx_Buffer and associated variables must be modified
|
|
atomically, because they are used from the interrupt
|
|
*/
|
|
|
|
/* Read PRIMASK register, check interrupt status before you disable them */
|
|
/* Returns 0 if they are enabled, or non-zero if disabled */
|
|
|
|
uint32_t prim = __get_PRIMASK();
|
|
__disable_irq();
|
|
|
|
APP_Rx_Buffer[APP_Rx_ptr_in] = c;
|
|
APP_Rx_ptr_in = (APP_Rx_ptr_in + 1) % APP_RX_DATA_SIZE;
|
|
|
|
if (!prim) __enable_irq();
|
|
}
|
|
|
|
/**
|
|
* @brief VCP_DataRx
|
|
* Data received over USB OUT endpoint is available here
|
|
*
|
|
* @note
|
|
* This function will block any OUT packet reception on USB endpoint
|
|
* until exiting this function. If you exit this function before transfer
|
|
* is complete on CDC interface (ie. using DMA controller) it will result
|
|
* in receiving more data while previous ones are still not sent.
|
|
*
|
|
* @note
|
|
* This function is executed inside the USBD_OTG_ISR_Handler() interrupt handler!
|
|
|
|
* @param Buf: Buffer of data to be received
|
|
* @param Len: Number of data received (in bytes)
|
|
* @retval Result of the opeartion: USBD_OK if all operations are OK else VCP_FAIL
|
|
*/
|
|
static uint16_t VCP_DataRx (uint8_t* Buf, uint32_t Len)
|
|
{
|
|
if (receiveDataCb)
|
|
receiveDataCb(Buf, Len);
|
|
|
|
// #if defined(CLI)
|
|
// // pass data to CLI
|
|
// cliReceiveData(Buf, Len);
|
|
// #elif defined(LUA)
|
|
// // copy data to the LUA FIFO
|
|
// if (luaRxFifo) {
|
|
// for (uint32_t i = 0; i < Len; i++) {
|
|
// luaRxFifo->push(Buf[i]);
|
|
// }
|
|
// }
|
|
// #endif
|
|
|
|
return USBD_OK;
|
|
}
|
|
|
|
uint32_t usbSerialBaudRate(void)
|
|
{
|
|
return g_lc.bitrate;
|
|
}
|
|
|
|
void usbSerialSetReceiveDataCb(void (*cb)(uint8_t* buf, uint32_t len))
|
|
{
|
|
receiveDataCb = cb;
|
|
}
|
|
|
|
void usbSerialSetBaudRateCb(void (*cb)(uint32_t baud))
|
|
{
|
|
baudRateCb = cb;
|
|
}
|
|
|
|
void usbSerialSetCtrlLineStateCb(void (*cb)(uint16_t ctrlLineState))
|
|
{
|
|
ctrlLineStateCb = cb;
|
|
}
|
|
|
|
// /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|